Quelle  http.c   Sprache: C

/*
 * Copyright (c) 2002-2007 Niels Provos <provos@citi.umich.edu>
 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
 *
 * 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
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "event2/event-config.h"
#include "evconfig-private.h"

#ifdef EVENT__HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef EVENT__HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

#ifdef HAVE_SYS_IOCCOM_H
#include <sys/ioccom.h>
#endif
#ifdef EVENT__HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#ifdef EVENT__HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef EVENT__HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif

#ifndef _WIN32
#include <sys/socket.h>
#include <sys/stat.h>
#else /* _WIN32 */
#include <winsock2.h>
#include <ws2tcpip.h>
#endif /* _WIN32 */

#ifdef EVENT__HAVE_SYS_UN_H
#include <sys/un.h>
#endif
#ifdef EVENT__HAVE_AFUNIX_H
#include <afunix.h>
#endif

#include <sys/queue.h>

#ifdef EVENT__HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef EVENT__HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef EVENT__HAVE_NETDB_H
#include <netdb.h>
#endif

#ifdef _WIN32
#include <winsock2.h>
#endif

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <syslog.h>
#endif /* !_WIN32 */
#include <signal.h>
#ifdef EVENT__HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef EVENT__HAVE_FCNTL_H
#include <fcntl.h>
#endif

#undef timeout_pending
#undef timeout_initialized

#include "strlcpy-internal.h"
#include "event2/http.h"
#include "event2/event.h"
#include "event2/buffer.h"
#include "event2/bufferevent.h"
#include "event2/http_struct.h"
#include "event2/http_compat.h"
#include "event2/util.h"
#include "event2/listener.h"
#include "log-internal.h"
#include "util-internal.h"
#include "http-internal.h"
#include "mm-internal.h"
#include "bufferevent-internal.h"

#ifndef EVENT__HAVE_GETNAMEINFO
#define NI_MAXSERV 32
#define NI_MAXHOST 1025

#ifndef NI_NUMERICHOST
#define NI_NUMERICHOST 1
#endif

#ifndef NI_NUMERICSERV
#define NI_NUMERICSERV 2
#endif

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)
   return (-1);
 }

 if (host != NULL) {
  if (flags & NI_NUMERICHOST) {
   if (strlcpy(host, inet_ntoa(sin->sin_addr),
       hostlen) >= hostlen)
    return (-1);
   else
    return (0);
  } else {
   struct hostent *hp;
   hp = gethostbyaddr((char *)&sin->sin_addr,
       sizeof(struct in_addr), AF_INET);
   if (hp == NULL)
    return (-2);

   if (strlcpy(host, hp->h_name, hostlen) >= hostlen)
    return (-1);
   else
    return (0);
  }
 }
 return (0);
}

#endif

#define REQ_VERSION_BEFORE(req, major_v, minor_v)   \
 ((req)->major < (major_v) ||     \
     ((req)->major == (major_v) && (req)->minor < (minor_v)))

#define REQ_VERSION_ATLEAST(req, major_v, minor_v)   \
 ((req)->major > (major_v) ||     \
     ((req)->major == (major_v) && (req)->minor >= (minor_v)))

#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif

extern int debug;

static evutil_socket_t create_bind_socket_nonblock(struct evutil_addrinfo *, int reuse);
static evutil_socket_t bind_socket(const char *, ev_uint16_t, int reuse);
static void name_from_addr(struct sockaddr *, ev_socklen_t, char **, char **);
static struct evhttp_uri *evhttp_uri_parse_authority(char *source_uri);
static int evhttp_associate_new_request_with_connection(
 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 const char *evhttp_response_phrase_internal(int code);
static void evhttp_get_request(struct evhttp *, evutil_socket_t, struct sockaddr *, ev_socklen_t);
static void evhttp_write_buffer(struct evhttp_connection *,
    void (*)(struct evhttp_connection *, void *), void *);
static void evhttp_make_header(struct evhttp_connection *, struct evhttp_request *);

/* callbacks for bufferevent */
static void evhttp_read_cb(struct bufferevent *, void *);
static void evhttp_write_cb(struct bufferevent *, void *);
static void evhttp_error_cb(struct bufferevent *bufev, short what, void *arg);
static int evhttp_find_vhost(struct evhttp *http, struct evhttp **outhttp,
    const char *hostname);

#ifndef EVENT__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)
{
 char *d, *tok;
 EVUTIL_ASSERT(strlen(del) == 1);
 if (!s || !*s)
  return NULL;
 tok = *s;
 d = strstr(tok, del);
 if (d) {
  *d = '\0';
  *s = d + 1;
 } else
  *s = NULL;
 return tok;
}
#endif

static size_t
html_replace(const char ch, const char **escaped)
{
 switch (ch) {
 case '<':
  *escaped = "<";
  return 4;
 case '>':
  *escaped = ">";
  return 4;
 case '"':
  *escaped = """;
  return 6;
 case '\'':
  *escaped = "'";
  return 6;
 case '&':
  *escaped = "&";
  return 5;
 default:
  break;
 }

 return 1;
}

/*
 * Replaces <, >, ", ' and & with <, >, ",
 * ' and & correspondingly.
 *
 * The returned string needs to be freed by the caller.
 */

char *
evhttp_htmlescape(const char *html)
{
 size_t i;
 size_t new_size = 0, old_size = 0;
 char *escaped_html, *p;

 if (html == NULL)
  return (NULL);

 old_size = strlen(html);
 for (i = 0; i < old_size; ++i) {
  const char *replaced = NULL;
  const size_t replace_size = html_replace(html[i], &replaced);
  if (replace_size > EV_SIZE_MAX - new_size) {
   event_warn("%s: html_replace overflow", __func__);
   return (NULL);
  }
  new_size += replace_size;
 }

 if (new_size == EV_SIZE_MAX)
  return (NULL);
 p = escaped_html = mm_malloc(new_size + 1);
 if (escaped_html == NULL) {
  event_warn("%s: malloc(%lu)", __func__,
             (unsigned long)(new_size + 1));
  return (NULL);
 }
 for (i = 0; i < old_size; ++i) {
  const char *replaced = &html[i];
  const size_t len = html_replace(html[i], &replaced);
  memcpy(p, replaced, len);
  p += len;
 }

 *p = '\0';

 return (escaped_html);
}

/** Given an evhttp_cmd_type, returns a constant string containing the
 * equivalent HTTP command, or NULL if the evhttp_command_type is
 * unrecognized. */
static const char *
evhttp_method(enum evhttp_cmd_type type)
{
 const char *method;

 switch (type) {
 case EVHTTP_REQ_GET:
  method = "GET";
  break;
 case EVHTTP_REQ_POST:
  method = "POST";
  break;
 case EVHTTP_REQ_HEAD:
  method = "HEAD";
  break;
 case EVHTTP_REQ_PUT:
  method = "PUT";
  break;
 case EVHTTP_REQ_DELETE:
  method = "DELETE";
  break;
 case EVHTTP_REQ_OPTIONS:
  method = "OPTIONS";
  break;
 case EVHTTP_REQ_TRACE:
  method = "TRACE";
  break;
 case EVHTTP_REQ_CONNECT:
  method = "CONNECT";
  break;
 case EVHTTP_REQ_PATCH:
  method = "PATCH";
  break;
 default:
  method = NULL;
  break;
 }

 return (method);
}

/**
 * Determines if a response should have a body.
 * Follows the rules in RFC 2616 section 4.3.
 * @return 1 if the response MUST have a body; 0 if the response MUST NOT have
 *     a body.
 */
static int
evhttp_response_needs_body(struct evhttp_request *req)
{
 return (req->response_code != HTTP_NOCONTENT &&
  req->response_code != HTTP_NOTMODIFIED &&
  (req->response_code < 100 || req->response_code >= 200) &&
  req->type != EVHTTP_REQ_CONNECT &&
  req->type != EVHTTP_REQ_HEAD);
}

/** Helper: called after we've added some data to an evcon's bufferevent's
 * output buffer.  Sets the evconn's writing-is-done callback, and puts
 * the bufferevent into writing mode.
 */
static void
evhttp_write_buffer(struct evhttp_connection *evcon,
    void (*cb)(struct evhttp_connection *, void *), void *arg)
{
 event_debug(("%s: preparing to write buffer\n", __func__));

 /* Set call back */
 evcon->cb = cb;
 evcon->cb_arg = arg;

 /* Disable the read callback: we don't actually care about data;
 * we only care about close detection. (We don't disable reading --
 * EV_READ, since we *do* want to learn about any close events.) */
 bufferevent_setcb(evcon->bufev,
     NULL, /*read*/
     evhttp_write_cb,
     evhttp_error_cb,
     evcon);

 bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE);
}

static void
evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
{
 bufferevent_disable(evcon->bufev, EV_WRITE);
}

static void
evhttp_send_continue(struct evhttp_connection *evcon,
   struct evhttp_request *req)
{
 bufferevent_enable(evcon->bufev, EV_WRITE);
 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
   "HTTP/%d.%d 100 Continue\r\n\r\n",
   req->major, req->minor);
 evcon->cb = evhttp_send_continue_done;
 evcon->cb_arg = NULL;
 bufferevent_setcb(evcon->bufev,
     evhttp_read_cb,
     evhttp_write_cb,
     evhttp_error_cb,
     evcon);
}

/** Helper: returns true iff evconn is in any connected state. */
static int
evhttp_connected(struct evhttp_connection *evcon)
{
 switch (evcon->state) {
 case EVCON_DISCONNECTED:
 case EVCON_CONNECTING:
  return (0);
 case EVCON_IDLE:
 case EVCON_READING_FIRSTLINE:
 case EVCON_READING_HEADERS:
 case EVCON_READING_BODY:
 case EVCON_READING_TRAILER:
 case EVCON_WRITING:
 default:
  return (1);
 }
}

/* Create the headers needed for an outgoing HTTP request, adds them to
 * the request's header list, and writes the request line to the
 * connection's output buffer.
 */
static void
evhttp_make_header_request(struct evhttp_connection *evcon,
    struct evhttp_request *req)
{
 const char *method;

 evhttp_remove_header(req->output_headers, "Proxy-Connection");

 /* Generate request line */
 if (!(method = evhttp_method(req->type))) {
  method = "NULL";
 }

 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
     "%s %s HTTP/%d.%d\r\n",
     method, req->uri, req->major, req->minor);

 /* Add the content length on a post or put request if missing */
 if ((req->type == EVHTTP_REQ_POST || req->type == EVHTTP_REQ_PUT) &&
     evhttp_find_header(req->output_headers, "Content-Length") == NULL){
  char size[22];
  evutil_snprintf(size, sizeof(size), EV_SIZE_FMT,
      EV_SIZE_ARG(evbuffer_get_length(req->output_buffer)));
  evhttp_add_header(req->output_headers, "Content-Length", size);
 }
}

/** Return true if the list of headers in 'headers', intepreted with respect
 * to flags, means that we should send a "connection: close" when the request
 * is done. */
static int
evhttp_is_connection_close(int flags, struct evkeyvalq* headers)
{
 if (flags & EVHTTP_PROXY_REQUEST) {
  /* proxy connection */
  const char *connection = evhttp_find_header(headers, "Proxy-Connection");
  return (connection == NULL || evutil_ascii_strcasecmp(connection, "keep-alive") != 0);
 } else {
  const char *connection = evhttp_find_header(headers, "Connection");
  return (connection != NULL && evutil_ascii_strcasecmp(connection, "close") == 0);
 }
}
static int
evhttp_is_request_connection_close(struct evhttp_request *req)
{
 if (req->type == EVHTTP_REQ_CONNECT)
  return 0;

 return
  evhttp_is_connection_close(req->flags, req->input_headers) ||
  evhttp_is_connection_close(req->flags, req->output_headers);
}

/* Return true iff 'headers' contains 'Connection: keep-alive' */
static int
evhttp_is_connection_keepalive(struct evkeyvalq* headers)
{
 const char *connection = evhttp_find_header(headers, "Connection");
 return (connection != NULL
     && evutil_ascii_strncasecmp(connection, "keep-alive", 10) == 0);
}

/* Add a correct "Date" header to headers, unless it already has one. */
static void
evhttp_maybe_add_date_header(struct evkeyvalq *headers)
{
 if (evhttp_find_header(headers, "Date") == NULL) {
  char date[50];
  if (sizeof(date) - evutil_date_rfc1123(date, sizeof(date), NULL) > 0) {
   evhttp_add_header(headers, "Date", date);
  }
 }
}

/* Add a "Content-Length" header with value 'content_length' to headers,
 * unless it already has a content-length or transfer-encoding header. */
static void
evhttp_maybe_add_content_length_header(struct evkeyvalq *headers,
    size_t content_length)
{
 if (evhttp_find_header(headers, "Transfer-Encoding") == NULL &&
     evhttp_find_header(headers, "Content-Length") == NULL) {
  char len[22];
  evutil_snprintf(len, sizeof(len), EV_SIZE_FMT,
      EV_SIZE_ARG(content_length));
  evhttp_add_header(headers, "Content-Length", len);
 }
}

/*
 * Create the headers needed for an HTTP reply in req->output_headers,
 * and write the first HTTP response for req line to evcon.
 */
static void
evhttp_make_header_response(struct evhttp_connection *evcon,
    struct evhttp_request *req)
{
 int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
     "HTTP/%d.%d %d %s\r\n",
     req->major, req->minor, req->response_code,
     req->response_code_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)
   evhttp_add_header(req->output_headers,
       "Connection", "keep-alive");

  if ((req->minor >= 1 || is_keepalive) &&
      evhttp_response_needs_body(req)) {
   /*
 * we need to add the content length if the
 * user did not give it, this is required for
 * persistent connections to work.
 */
   evhttp_maybe_add_content_length_header(
    req->output_headers,
    evbuffer_get_length(req->output_buffer));
  }
 }

 /* Potentially add headers for unidentified content. */
 if (evhttp_response_needs_body(req)) {
  if (evhttp_find_header(req->output_headers,
   "Content-Type") == NULL
      && evcon->http_server->default_content_type) {
   evhttp_add_header(req->output_headers,
       "Content-Type",
       evcon->http_server->default_content_type);
  }
 }

 /* if the request asked for a close, we send a close, too */
 if (evhttp_is_connection_close(req->flags, req->input_headers)) {
  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");
 }
}

enum expect { NO, CONTINUE, OTHER };
static enum expect evhttp_have_expect(struct evhttp_request *req, int input)
{
 const char *expect;
 struct evkeyvalq *h = input ? req->input_headers : req->output_headers;

 if (!(req->kind == EVHTTP_REQUEST) || !REQ_VERSION_ATLEAST(req, 1, 1))
  return NO;

 expect = evhttp_find_header(h, "Expect");
 if (!expect)
  return NO;

 return !evutil_ascii_strcasecmp(expect, "100-continue") ? CONTINUE : OTHER;
}


/** Generate all headers appropriate for sending the http request in req (or
 * the response, if we're sending a response), and write them to evcon's
 * bufferevent. Also writes all data from req->output_buffer */
static void
evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
{
 struct evkeyval *header;
 struct evbuffer *output = bufferevent_get_output(evcon->bufev);

 /*
 * 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) {
  evbuffer_add_printf(output, "%s: %s\r\n",
      header->key, header->value);
 }
 evbuffer_add(output, "\r\n", 2);

 if (evhttp_have_expect(req, 0) != CONTINUE &&
  evbuffer_get_length(req->output_buffer)) {
  /*
 * For a request, we add the POST data, for a reply, this
 * is the regular data.
 */
  evbuffer_add_buffer(output, req->output_buffer);
 }
}

void
evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
    ev_ssize_t new_max_headers_size)
{
 if (new_max_headers_size<0)
  evcon->max_headers_size = EV_SIZE_MAX;
 else
  evcon->max_headers_size = new_max_headers_size;
}
void
evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
    ev_ssize_t new_max_body_size)
{
 if (new_max_body_size<0)
  evcon->max_body_size = EV_UINT64_MAX;
 else
  evcon->max_body_size = new_max_body_size;
}

static int
evhttp_connection_incoming_fail(struct evhttp_request *req,
    enum evhttp_request_error error)
{
 switch (error) {
  case EVREQ_HTTP_DATA_TOO_LONG:
   req->response_code = HTTP_ENTITYTOOLARGE;
   break;
  default:
   req->response_code = HTTP_BADREQUEST;
 }

 switch (error) {
 case EVREQ_HTTP_TIMEOUT:
 case EVREQ_HTTP_EOF:
  /*
 * these are cases in which we probably should just
 * close the connection and not send a reply.  this
 * case may happen when a browser keeps a persistent
 * connection open and we timeout on the read.  when
 * the request is still being used for sending, we
 * need to disassociated it from the connection here.
 */
  if (!req->userdone) {
   /* remove it so that it will not be freed */
   TAILQ_REMOVE(&req->evcon->requests, req, next);
   /* indicate that this request no longer has a
 * connection object
 */
   req->evcon = NULL;
  }
  return (-1);
 case EVREQ_HTTP_INVALID_HEADER:
 case EVREQ_HTTP_BUFFER_ERROR:
 case EVREQ_HTTP_REQUEST_CANCEL:
 case EVREQ_HTTP_DATA_TOO_LONG:
 default: /* xxx: probably should just error on default */
  /* the callback looks at the uri to determine errors */
  if (req->uri) {
   mm_free(req->uri);
   req->uri = NULL;
  }
  if (req->uri_elems) {
   evhttp_uri_free(req->uri_elems);
   req->uri_elems = NULL;
  }

  /*
 * the callback needs to send a reply, once the reply has
 * been send, the connection should get freed.
 */
  (*req->cb)(req, req->cb_arg);
 }

 return (0);
}

/* Free connection ownership of which can be acquired by user using
 * evhttp_request_own(). */
static inline void
evhttp_request_free_auto(struct evhttp_request *req)
{
 if (!(req->flags & EVHTTP_USER_OWNED))
  evhttp_request_free(req);
}

static void
evhttp_request_free_(struct evhttp_connection *evcon, struct evhttp_request *req)
{
 TAILQ_REMOVE(&evcon->requests, req, next);
 evhttp_request_free_auto(req);
}

/* Called when evcon has experienced a (non-recoverable? -NM) error, as
 * given in error. If it's an outgoing connection, reset the connection,
 * retry any pending requests, and inform the user.  If it's incoming,
 * delegates to evhttp_connection_incoming_fail(). */
void
evhttp_connection_fail_(struct evhttp_connection *evcon,
    enum evhttp_request_error error)
{
 const int errsave = EVUTIL_SOCKET_ERROR();
 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
 void (*cb)(struct evhttp_request *, void *);
 void *cb_arg;
 void (*error_cb)(enum evhttp_request_error, void *);
 void *error_cb_arg;
 EVUTIL_ASSERT(req != NULL);

 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);

 if (evcon->flags & EVHTTP_CON_INCOMING) {
  /*
 * for incoming requests, there are two different
 * failure cases.  it's either a network level error
 * or an http layer error. for problems on the network
 * layer like timeouts we just drop the connections.
 * For HTTP problems, we might have to send back a
 * reply before the connection can be freed.
 */
  if (evhttp_connection_incoming_fail(req, error) == -1)
   evhttp_connection_free(evcon);
  return;
 }

 error_cb = req->error_cb;
 error_cb_arg = req->cb_arg;
 /* when the request was canceled, the callback is not executed */
 if (error != EVREQ_HTTP_REQUEST_CANCEL) {
  /* save the callback for later; the cb might free our object */
  cb = req->cb;
  cb_arg = req->cb_arg;
 } else {
  cb = NULL;
  cb_arg = NULL;
 }

 /* do not fail all requests; the next request is going to get
 * send over a new connection.   when a user cancels a request,
 * all other pending requests should be processed as normal
 */
 evhttp_request_free_(evcon, req);

 /* reset the connection */
 evhttp_connection_reset_(evcon);

 /* We are trying the next request that was queued on us */
 if (TAILQ_FIRST(&evcon->requests) != NULL)
  evhttp_connection_connect_(evcon);
 else
  if ((evcon->flags & EVHTTP_CON_OUTGOING) &&
      (evcon->flags & EVHTTP_CON_AUTOFREE)) {
   evhttp_connection_free(evcon);
  }

 /* The call to evhttp_connection_reset_ overwrote errno.
 * Let's restore the original errno, so that the user's
 * callback can have a better idea of what the error was.
 */
 EVUTIL_SET_SOCKET_ERROR(errsave);

 /* inform the user */
 if (error_cb != NULL)
  error_cb(error, error_cb_arg);
 if (cb != NULL)
  (*cb)(NULL, cb_arg);
}

/* Bufferevent callback: invoked when any data has been written from an
 * http connection's bufferevent */
static void
evhttp_write_cb(struct bufferevent *bufev, void *arg)
{
 struct evhttp_connection *evcon = arg;

 /* Activate our call back */
 if (evcon->cb != NULL)
  (*evcon->cb)(evcon, evcon->cb_arg);
}

/**
 * Advance the connection state.
 * - If this is an outgoing connection, we've just processed the response;
 *   idle or close the connection.
 * - If this is an incoming connection, we've just processed the request;
 *   respond.
 */
static void
evhttp_connection_done(struct evhttp_connection *evcon)
{
 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
 int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
 int free_evcon = 0;

 if (con_outgoing) {
  /* idle or close the connection */
  int need_close = evhttp_is_request_connection_close(req);
  TAILQ_REMOVE(&evcon->requests, req, next);
  req->evcon = NULL;

  evcon->state = EVCON_IDLE;

  /* check if we got asked to close the connection */
  if (need_close)
   evhttp_connection_reset_(evcon);

  if (TAILQ_FIRST(&evcon->requests) != NULL) {
   /*
 * We have more requests; reset the connection
 * and deal with the next request.
 */
   if (!evhttp_connected(evcon))
    evhttp_connection_connect_(evcon);
   else
    evhttp_request_dispatch(evcon);
  } else if (!need_close) {
   /*
 * The connection is going to be persistent, but we
 * need to detect if the other side closes it.
 */
   evhttp_connection_start_detectclose(evcon);
  } else if ((evcon->flags & EVHTTP_CON_AUTOFREE)) {
   /*
 * If we have no more requests that need completion
 * and we're not waiting for the connection to close
 */
    free_evcon = 1;
  }
 } else {
  /*
 * incoming connection - we need to leave the request on the
 * connection so that we can reply to it.
 */
  evcon->state = EVCON_WRITING;
 }

 /* notify the user of the request */
 (*req->cb)(req, req->cb_arg);

 /* if this was an outgoing request, we own and it's done. so free it. */
 if (con_outgoing) {
  evhttp_request_free_auto(req);
 }

 /* If this was the last request of an outgoing connection and we're
 * not waiting to receive a connection close event and we want to
 * automatically free the connection. We check to ensure our request
 * list is empty one last time just in case our callback added a
 * new request.
 */
 if (free_evcon && TAILQ_FIRST(&evcon->requests) == NULL) {
  evhttp_connection_free(evcon);
 }
}

/*
 * Handles reading from a chunked request.
 *   return ALL_DATA_READ:
 *     all data has been read
 *   return MORE_DATA_EXPECTED:
 *     more data is expected
 *   return DATA_CORRUPTED:
 *     data is corrupted
 *   return REQUEST_CANCELED:
 *     request was canceled by the user calling evhttp_cancel_request
 *   return DATA_TOO_LONG:
 *     ran over the maximum limit
 */

static enum message_read_status
evhttp_handle_chunked_read(struct evhttp_request *req, struct evbuffer *buf)
{
 if (req == NULL || buf == NULL) {
     return DATA_CORRUPTED;
 }

 while (1) {
  size_t buflen;

  if ((buflen = evbuffer_get_length(buf)) == 0) {
   break;
  }

  /* evbuffer_get_length returns size_t, but len variable is ssize_t,
 * check for overflow conditions */
  if (buflen > EV_SSIZE_MAX) {
   return DATA_CORRUPTED;
  }

  if (req->ntoread < 0) {
   /* Read chunk size */
   ev_int64_t ntoread;
   char *p = evbuffer_readln(buf, NULL, EVBUFFER_EOL_CRLF);
   char *endp;
   int error;
   if (p == NULL)
    break;
   /* the last chunk is on a new line? */
   if (strlen(p) == 0) {
    mm_free(p);
    continue;
   }
   ntoread = evutil_strtoll(p, &endp, 16);
   error = (*p == '\0' ||
       (*endp != '\0' && *endp != ' ') ||
       ntoread < 0);
   mm_free(p);
   if (error) {
    /* could not get chunk size */
    return (DATA_CORRUPTED);
   }

   /* ntoread is signed int64, body_size is unsigned size_t, check for under/overflow conditions */
   if ((ev_uint64_t)ntoread > EV_SIZE_MAX - req->body_size) {
       return DATA_CORRUPTED;
   }

   if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
    /* failed body length test */
    event_debug(("Request body is too long"));
    return (DATA_TOO_LONG);
   }

   req->body_size += (size_t)ntoread;
   req->ntoread = ntoread;
   if (req->ntoread == 0) {
    /* Last chunk */
    return (ALL_DATA_READ);
   }
   continue;
  }

  /* req->ntoread is signed int64, len is ssize_t, based on arch,
 * ssize_t could only be 32b, check for these conditions */
  if (req->ntoread > EV_SSIZE_MAX) {
   return DATA_CORRUPTED;
  }

  /* don't have enough to complete a chunk; wait for more */
  if (req->ntoread > 0 && buflen < (ev_uint64_t)req->ntoread)
   return (MORE_DATA_EXPECTED);

  /* Completed chunk */
  evbuffer_remove_buffer(buf, req->input_buffer, (size_t)req->ntoread);
  req->ntoread = -1;
  if (req->chunk_cb != NULL) {
   req->flags |= EVHTTP_REQ_DEFER_FREE;
   (*req->chunk_cb)(req, req->cb_arg);
   evbuffer_drain(req->input_buffer,
       evbuffer_get_length(req->input_buffer));
   req->flags &= ~EVHTTP_REQ_DEFER_FREE;
   if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
    return (REQUEST_CANCELED);
   }
  }
 }

 return (MORE_DATA_EXPECTED);
}

static void
evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
{
 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);

 switch (evhttp_parse_headers_(req, buf)) {
 case DATA_CORRUPTED:
 case DATA_TOO_LONG:
  evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
  break;
 case ALL_DATA_READ:
  bufferevent_disable(evcon->bufev, EV_READ);
  evhttp_connection_done(evcon);
  break;
 case MORE_DATA_EXPECTED:
 case REQUEST_CANCELED: /* ??? */
 default:
  break;
 }
}

static void
evhttp_lingering_close(struct evhttp_connection *evcon,
 struct evhttp_request *req)
{
 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);

 size_t n = evbuffer_get_length(buf);
 if (n > (size_t) req->ntoread)
  n = (size_t) req->ntoread;
 req->ntoread -= n;
 req->body_size += n;

 event_debug(("Request body is too long, left " EV_I64_FMT,
  EV_I64_ARG(req->ntoread)));

 evbuffer_drain(buf, n);
 if (!req->ntoread)
  evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
}
static void
evhttp_lingering_fail(struct evhttp_connection *evcon,
 struct evhttp_request *req)
{
 if (evcon->flags & EVHTTP_CON_LINGERING_CLOSE)
  evhttp_lingering_close(evcon, req);
 else
  evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
}

static void
evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
{
 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);

 if (req->chunked) {
  switch (evhttp_handle_chunked_read(req, buf)) {
  case ALL_DATA_READ:
   /* finished last chunk */
   evcon->state = EVCON_READING_TRAILER;
   evhttp_read_trailer(evcon, req);
   return;
  case DATA_CORRUPTED:
  case DATA_TOO_LONG:
   /* corrupted data */
   evhttp_connection_fail_(evcon,
       EVREQ_HTTP_DATA_TOO_LONG);
   return;
  case REQUEST_CANCELED:
   /* request canceled */
   evhttp_request_free_auto(req);
   return;
  case MORE_DATA_EXPECTED:
  default:
   break;
  }
 } else if (req->ntoread < 0) {
  /* Read until connection close. */
  if ((size_t)(req->body_size + evbuffer_get_length(buf)) < req->body_size) {
   evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
   return;
  }

  req->body_size += evbuffer_get_length(buf);
  evbuffer_add_buffer(req->input_buffer, buf);
 } else if (req->chunk_cb != NULL || evbuffer_get_length(buf) >= (size_t)req->ntoread) {
  /* XXX: the above get_length comparison has to be fixed for overflow conditions! */
  /* We've postponed moving the data until now, but we're
 * about to use it. */
  size_t n = evbuffer_get_length(buf);

  if (n > (size_t) req->ntoread)
   n = (size_t) req->ntoread;
  req->ntoread -= n;
  req->body_size += n;
  evbuffer_remove_buffer(buf, req->input_buffer, n);
 }

 if (req->body_size > req->evcon->max_body_size ||
     (!req->chunked && req->ntoread >= 0 &&
  (size_t)req->ntoread > req->evcon->max_body_size)) {
  /* XXX: The above casted comparison must checked for overflow */
  /* failed body length test */

  evhttp_lingering_fail(evcon, req);
  return;
 }

 if (evbuffer_get_length(req->input_buffer) > 0 && req->chunk_cb != NULL) {
  req->flags |= EVHTTP_REQ_DEFER_FREE;
  (*req->chunk_cb)(req, req->cb_arg);
  req->flags &= ~EVHTTP_REQ_DEFER_FREE;
  evbuffer_drain(req->input_buffer,
      evbuffer_get_length(req->input_buffer));
  if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
   evhttp_request_free_auto(req);
   return;
  }
 }

 if (!req->ntoread) {
  bufferevent_disable(evcon->bufev, EV_READ);
  /* Completed content length */
  evhttp_connection_done(evcon);
  return;
 }
}

#define get_deferred_queue(evcon)  \
 ((evcon)->base)

/*
 * Gets called when more data becomes available
 */

static void
evhttp_read_cb(struct bufferevent *bufev, void *arg)
{
 struct evhttp_connection *evcon = arg;
 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);

 /* Cancel if it's pending. */
 event_deferred_cb_cancel_(get_deferred_queue(evcon),
     &evcon->read_more_deferred_cb);

 switch (evcon->state) {
 case EVCON_READING_FIRSTLINE:
  evhttp_read_firstline(evcon, req);
  /* note the request may have been freed in
 * evhttp_read_body */
  break;
 case EVCON_READING_HEADERS:
  evhttp_read_header(evcon, req);
  /* note the request may have been freed in
 * evhttp_read_body */
  break;
 case EVCON_READING_BODY:
  evhttp_read_body(evcon, req);
  /* note the request may have been freed in
 * evhttp_read_body */
  break;
 case EVCON_READING_TRAILER:
  evhttp_read_trailer(evcon, req);
  break;
 case EVCON_IDLE:
  {
#ifdef USE_DEBUG
   struct evbuffer *input;
   size_t total_len;

   input = bufferevent_get_input(evcon->bufev);
   total_len = evbuffer_get_length(input);
   event_debug(("%s: read "EV_SIZE_FMT
    " bytes in EVCON_IDLE state,"
    " resetting connection",
    __func__, EV_SIZE_ARG(total_len)));
#endif

   evhttp_connection_reset_(evcon);
  }
  break;
 case EVCON_DISCONNECTED:
 case EVCON_CONNECTING:
 case EVCON_WRITING:
 default:
  event_errx(1, "%s: illegal connection state %d",
      __func__, evcon->state);
 }
}

static void
evhttp_deferred_read_cb(struct event_callback *cb, void *data)
{
 struct evhttp_connection *evcon = data;
 struct bufferevent *bev = evcon->bufev;
 if (bev->readcb)
  (bev->readcb)(evcon->bufev, evcon);
}

static void
evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
{
 /* This is after writing the request to the server */
 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
 EVUTIL_ASSERT(req != NULL);

 EVUTIL_ASSERT(evcon->state == EVCON_WRITING);

 /* We need to wait until we've written all of our output data before we can
 * continue */
 if (evbuffer_get_length(output) > 0)
  return;

 /* We are done writing our header and are now expecting the response */
 req->kind = EVHTTP_RESPONSE;

 evhttp_start_read_(evcon);
}

/*
 * Clean up a connection object
 */

void
evhttp_connection_free(struct evhttp_connection *evcon)
{
 struct evhttp_request *req;
 int need_close = 0;

 /* notify interested parties that this connection is going down */
 if (evcon->fd != -1) {
  if (evhttp_connected(evcon) && evcon->closecb != NULL)
   (*evcon->closecb)(evcon, evcon->closecb_arg);
 }

 /* remove all requests that might be queued on this
 * connection.  for server connections, this should be empty.
 * because it gets dequeued either in evhttp_connection_done or
 * evhttp_connection_fail_.
 */
 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
  evhttp_request_free_(evcon, req);
 }

 if (evcon->http_server != NULL) {
  struct evhttp *http = evcon->http_server;
  TAILQ_REMOVE(&http->connections, evcon, next);
 }

 if (event_initialized(&evcon->retry_ev)) {
  event_del(&evcon->retry_ev);
  event_debug_unassign(&evcon->retry_ev);
 }

 event_deferred_cb_cancel_(get_deferred_queue(evcon),
     &evcon->read_more_deferred_cb);

 if (evcon->bufev != NULL) {
  need_close =
   !(bufferevent_get_options_(evcon->bufev) & BEV_OPT_CLOSE_ON_FREE);
  if (evcon->fd == -1)
   evcon->fd = bufferevent_getfd(evcon->bufev);

  bufferevent_free(evcon->bufev);
 }

 if (evcon->fd != -1) {
  shutdown(evcon->fd, EVUTIL_SHUT_WR);
  if (need_close)
   evutil_closesocket(evcon->fd);
 }

 if (evcon->bind_address != NULL)
  mm_free(evcon->bind_address);

 if (evcon->address != NULL)
  mm_free(evcon->address);

 mm_free(evcon);
}

void
evhttp_connection_free_on_completion(struct evhttp_connection *evcon) {
 evcon->flags |= EVHTTP_CON_AUTOFREE;
}

void
evhttp_connection_set_local_address(struct evhttp_connection *evcon,
    const char *address)
{
 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
 if (evcon->bind_address)
  mm_free(evcon->bind_address);
 if ((evcon->bind_address = mm_strdup(address)) == NULL)
  event_warn("%s: strdup", __func__);
}

void
evhttp_connection_set_local_port(struct evhttp_connection *evcon,
    ev_uint16_t port)
{
 EVUTIL_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;

 EVUTIL_ASSERT(req->kind == EVHTTP_REQUEST);

 /* delete possible close detection events */
 evhttp_connection_stop_detectclose(evcon);

 /* we assume that the connection is connected already */
 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);

 evcon->state = EVCON_WRITING;

 /* Create the header from the store arguments */
 evhttp_make_header(evcon, req);

 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
}

/* Reset our connection state: disables reading/writing, closes our fd (if
* any), clears out buffers, and puts us in state DISCONNECTED. */
void
evhttp_connection_reset_(struct evhttp_connection *evcon)
{
 struct evbuffer *tmp;
 int err;

 bufferevent_setcb(evcon->bufev, NULL, NULL, NULL, NULL);

 /* XXXX This is not actually an optimal fix.  Instead we ought to have
   an API for "stop connecting", or use bufferevent_setfd to turn off
   connecting.  But for Libevent 2.0, this seems like a minimal change
   least likely to disrupt the rest of the bufferevent and http code.

   Why is this here?  If the fd is set in the bufferevent, and the
   bufferevent is connecting, then you can't actually stop the
   bufferevent from trying to connect with bufferevent_disable().  The
   connect will never trigger, since we close the fd, but the timeout
   might.  That caused an assertion failure in evhttp_connection_fail_.
*/
 bufferevent_disable_hard_(evcon->bufev, EV_READ|EV_WRITE);

 if (evcon->fd == -1)
  evcon->fd = bufferevent_getfd(evcon->bufev);

 if (evcon->fd != -1) {
  /* inform interested parties about connection close */
  if (evhttp_connected(evcon) && evcon->closecb != NULL)
   (*evcon->closecb)(evcon, evcon->closecb_arg);

  shutdown(evcon->fd, EVUTIL_SHUT_WR);
  evutil_closesocket(evcon->fd);
  evcon->fd = -1;
 }
 err = bufferevent_setfd(evcon->bufev, -1);
 EVUTIL_ASSERT(!err && "setfd");

 /* we need to clean up any buffered data */
 tmp = bufferevent_get_output(evcon->bufev);
 err = evbuffer_drain(tmp, -1);
 EVUTIL_ASSERT(!err && "drain output");
 tmp = bufferevent_get_input(evcon->bufev);
 err = evbuffer_drain(tmp, -1);
 EVUTIL_ASSERT(!err && "drain input");

 evcon->flags &= ~EVHTTP_CON_READING_ERROR;

 evcon->state = EVCON_DISCONNECTED;
}

static void
evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
{
 evcon->flags |= EVHTTP_CON_CLOSEDETECT;
 bufferevent_enable(evcon->bufev, EV_READ);
}

static void
evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
{
 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
 bufferevent_disable(evcon->bufev, EV_READ);
}

static void
evhttp_connection_retry(evutil_socket_t fd, short what, void *arg)
{
 struct evhttp_connection *evcon = arg;

 evcon->state = EVCON_DISCONNECTED;
 evhttp_connection_connect_(evcon);
}

static void
evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
{
 struct evcon_requestq requests;

 evhttp_connection_reset_(evcon);
 if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
  struct timeval tv_retry = evcon->initial_retry_timeout;
  int i;
  evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
  /* XXXX handle failure from evhttp_add_event */
  for (i=0; i < evcon->retry_cnt; ++i) {
   tv_retry.tv_usec *= 2;
   if (tv_retry.tv_usec > 1000000) {
    tv_retry.tv_usec -= 1000000;
    tv_retry.tv_sec += 1;
   }
   tv_retry.tv_sec *= 2;
   if (tv_retry.tv_sec > 3600) {
    tv_retry.tv_sec = 3600;
    tv_retry.tv_usec = 0;
   }
  }
  event_add(&evcon->retry_ev, &tv_retry);
  evcon->retry_cnt++;
  return;
 }

 /*
 * User callback can do evhttp_make_request() on the same
 * evcon so new request will be added to evcon->requests.  To
 * avoid freeing it prematurely we iterate over the copy of
 * the queue.
 */
 TAILQ_INIT(&requests);
 while (TAILQ_FIRST(&evcon->requests) != NULL) {
  struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
  TAILQ_REMOVE(&evcon->requests, request, next);
  TAILQ_INSERT_TAIL(&requests, request, next);
 }

 /* for now, we just signal all requests by executing their callbacks */
 while (TAILQ_FIRST(&requests) != NULL) {
  struct evhttp_request *request = TAILQ_FIRST(&requests);
  TAILQ_REMOVE(&requests, request, next);
  request->evcon = NULL;

  /* we might want to set an error here */
  request->cb(request, request->cb_arg);
  evhttp_request_free_auto(request);
 }
}

static void
evhttp_connection_read_on_write_error(struct evhttp_connection *evcon,
    struct evhttp_request *req)
{
 struct evbuffer *buf;

 /** Second time, we can't read anything */
 if (evcon->flags & EVHTTP_CON_READING_ERROR) {
  evcon->flags &= ~EVHTTP_CON_READING_ERROR;
  evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
  return;
 }

 req->kind = EVHTTP_RESPONSE;

 buf = bufferevent_get_output(evcon->bufev);
 evbuffer_unfreeze(buf, 1);
 evbuffer_drain(buf, evbuffer_get_length(buf));
 evbuffer_freeze(buf, 1);

 evhttp_start_read_(evcon);
 evcon->flags |= EVHTTP_CON_READING_ERROR;
}

static void
evhttp_error_cb(struct bufferevent *bufev, short what, void *arg)
{
 struct evhttp_connection *evcon = arg;
 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);

 if (evcon->fd == -1)
  evcon->fd = bufferevent_getfd(bufev);

 switch (evcon->state) {
 case EVCON_CONNECTING:
  if (what & BEV_EVENT_TIMEOUT) {
   event_debug(("%s: connection timeout for \"%s:%d\" on "
    EV_SOCK_FMT,
    __func__, evcon->address, evcon->port,
    EV_SOCK_ARG(evcon->fd)));
   evhttp_connection_cb_cleanup(evcon);
   return;
  }
  break;

 case EVCON_READING_BODY:
  if (!req->chunked && req->ntoread < 0
      && what == (BEV_EVENT_READING|BEV_EVENT_EOF)) {
   /* EOF on read can be benign */
   evhttp_connection_done(evcon);
   return;
  }
  break;

 case EVCON_DISCONNECTED:
 case EVCON_IDLE:
 case EVCON_READING_FIRSTLINE:
 case EVCON_READING_HEADERS:
 case EVCON_READING_TRAILER:
 case EVCON_WRITING:
 default:
  break;
 }

 /* when we are in close detect mode, a read error means that
 * the other side closed their connection.
 */
 if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
  evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
  EVUTIL_ASSERT(evcon->http_server == NULL);
  /* For connections from the client, we just
 * reset the connection so that it becomes
 * disconnected.
 */
  EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
  evhttp_connection_reset_(evcon);

  /*
 * If we have no more requests that need completion
 * and we want to auto-free the connection when all
 * requests have been completed.
 */
  if (TAILQ_FIRST(&evcon->requests) == NULL
    && (evcon->flags & EVHTTP_CON_OUTGOING)
    && (evcon->flags & EVHTTP_CON_AUTOFREE)) {
   evhttp_connection_free(evcon);
  }
  return;
 }

 if (what & BEV_EVENT_TIMEOUT) {
  evhttp_connection_fail_(evcon, EVREQ_HTTP_TIMEOUT);
 } else if (what & (BEV_EVENT_EOF|BEV_EVENT_ERROR)) {
  if (what & BEV_EVENT_WRITING &&
   evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR) {
   evhttp_connection_read_on_write_error(evcon, req);
   return;
  }

  if (what & BEV_EVENT_READING &&
   evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR &&
   evbuffer_get_length(bufferevent_get_input(bufev))) {
   event_deferred_cb_schedule_(get_deferred_queue(evcon),
       &evcon->read_more_deferred_cb);
   return;
  }

  evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
 } else if (what == BEV_EVENT_CONNECTED) {
 } else {
  evhttp_connection_fail_(evcon, EVREQ_HTTP_BUFFER_ERROR);
 }
}

/*
 * Event callback for asynchronous connection attempt.
 */
static void
evhttp_connection_cb(struct bufferevent *bufev, short what, void *arg)
{
 struct evhttp_connection *evcon = arg;
 int error;
 ev_socklen_t errsz = sizeof(error);

 if (evcon->fd == -1)
  evcon->fd = bufferevent_getfd(bufev);

 if (!(what & BEV_EVENT_CONNECTED)) {
  /* some operating systems return ECONNREFUSED immediately
 * when connecting to a local address.  the cleanup is going
 * to reschedule this function call.
 */
#ifndef _WIN32
  if (errno == ECONNREFUSED)
   goto cleanup;
#endif
  evhttp_error_cb(bufev, what, arg);
  return;
 }

 if (evcon->fd == -1) {
  event_debug(("%s: bufferevent_getfd returned -1",
   __func__));
  goto cleanup;
 }

 /* Check if the connection completed */
 if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
         &errsz) == -1) {
  event_debug(("%s: getsockopt for \"%s:%d\" on "EV_SOCK_FMT,
   __func__, evcon->address, evcon->port,
   EV_SOCK_ARG(evcon->fd)));
  goto cleanup;
 }

 if (error) {
  event_debug(("%s: connect failed for \"%s:%d\" on "
   EV_SOCK_FMT": %s",
   __func__, evcon->address, evcon->port,
   EV_SOCK_ARG(evcon->fd),
   evutil_socket_error_to_string(error)));
  goto cleanup;
 }

 /* We are connected to the server now */
 event_debug(("%s: connected to \"%s:%d\" on "EV_SOCK_FMT"\n",
   __func__, evcon->address, evcon->port,
   EV_SOCK_ARG(evcon->fd)));

 /* Reset the retry count as we were successful in connecting */
 evcon->retry_cnt = 0;
 evcon->state = EVCON_IDLE;

 /* reset the bufferevent cbs */
 bufferevent_setcb(evcon->bufev,
     evhttp_read_cb,
     evhttp_write_cb,
     evhttp_error_cb,
     evcon);

 if (!evutil_timerisset(&evcon->timeout)) {
  const struct timeval read_tv = { HTTP_READ_TIMEOUT, 0 };
  const struct timeval write_tv = { HTTP_WRITE_TIMEOUT, 0 };
  bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
 } else {
  bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
 }

 /* try to start requests that have queued up on this connection */
 evhttp_request_dispatch(evcon);
 return;

 cleanup:
 evhttp_connection_cb_cleanup(evcon);
}

/*
 * Check if we got a valid response code.
 */

static int
evhttp_valid_response_code(int code)
{
 if (code == 0)
  return (0);

 return (1);
}

static int
evhttp_parse_http_version(const char *version, struct evhttp_request *req)
{
 int major, minor;
 char ch;
 int n = sscanf(version, "HTTP/%d.%d%c", &major, &minor, &ch);
 if (n != 2 || major > 1) {
  event_debug(("%s: bad version %s on message %p from %s",
   __func__, version, req, req->remote_host));
  return (-1);
 }
 req->major = major;
 req->minor = minor;
 return (0);
}

/* Parses the status line of a web server */

static int
evhttp_parse_response_line(struct evhttp_request *req, char *line)
{
 char *protocol;
 char *number;
 const char *readable = "";

 protocol = strsep(&line, " ");
 if (line == NULL)
  return (-1);
 number = strsep(&line, " ");
 if (line != NULL)
  readable = line;

 if (evhttp_parse_http_version(protocol, req) < 0)
  return (-1);

 req->response_code = atoi(number);
 if (!evhttp_valid_response_code(req->response_code)) {
  event_debug(("%s: bad response code \"%s\"",
   __func__, number));
  return (-1);
 }

 if (req->response_code_line != NULL)
  mm_free(req->response_code_line);
 if ((req->response_code_line = mm_strdup(readable)) == NULL) {
  event_warn("%s: strdup", __func__);
  return (-1);
 }

 return (0);
}

/* Parse the first line of a HTTP request */

static int
evhttp_parse_request_line(struct evhttp_request *req, char *line, size_t len)
{
 char *eos = line + len;
 char *method;
 char *uri;
 char *version;
 const char *hostname;
 const char *scheme;
 size_t method_len;
 enum evhttp_cmd_type type;

 while (eos > line && *(eos-1) == ' ') {
  *(eos-1) = '\0';
  --eos;
  --len;
 }
 if (len < strlen("GET / HTTP/1.0"))
  return -1;

 /* Parse the request line */
 method = strsep(&line, " ");
 if (!line)
  return -1;
 uri = line;
 version = strrchr(uri, ' ');
 if (!version || uri == version)
  return -1;
 *version = '\0';
 version++;

 method_len = (uri - method) - 1;
 type       = EVHTTP_REQ_UNKNOWN_;

 /* First line */
 switch (method_len) {
     case 3:
  /* The length of the method string is 3, meaning it can only be one of two methods: GET or PUT */
            
  /* Since both GET and PUT share the same character 'T' at the end,
 * if the string doesn't have 'T', we can immediately determine this
 * is an invalid HTTP method */
            
  if (method[2] != 'T') {
      break;
  }
            
  switch (*method) {
      case 'G':
   /* This first byte is 'G', so make sure the next byte is
 * 'E', if it isn't then this isn't a valid method */
                    
   if (method[1] == 'E') {
       type = EVHTTP_REQ_GET;
   }
                    
   break;
      case 'P':
   /* First byte is P, check second byte for 'U', if not,
 * we know it's an invalid method */
   if (method[1] == 'U') {
       type = EVHTTP_REQ_PUT;
   }
   break;
      default:
   break;
  }
  break;
     case 4:
  /* The method length is 4 bytes, leaving only the methods "POST" and "HEAD" */
  switch (*method) {
      case 'P':
   if (method[3] == 'T' && method[2] == 'S' && method[1] == 'O') {
       type = EVHTTP_REQ_POST;
   }
   break;
      case 'H':
   if (method[3] == 'D' && method[2] == 'A' && method[1] == 'E') {
       type = EVHTTP_REQ_HEAD;
   }
   break;
      default:
   break;
  }
  break;
     case 5:
  /* Method length is 5 bytes, which can only encompass PATCH and TRACE */
  switch (*method) {
      case 'P':
   if (method[4] == 'H' && method[3] == 'C' && method[2] == 'T' && method[1] == 'A') {
       type = EVHTTP_REQ_PATCH;
   }
   break;
      case 'T':
   if (method[4] == 'E' && method[3] == 'C' && method[2] == 'A' && method[1] == 'R') {
       type = EVHTTP_REQ_TRACE;
   }
                    
   break;
      default:
   break;
  }
  break;
     case 6:
  /* Method length is 6, only valid method 6 bytes in length is DELEte */
            
  /* If the first byte isn't 'D' then it's invalid */
  if (*method != 'D') {
      break;
  }

  if (method[5] == 'E' && method[4] == 'T' && method[3] == 'E' && method[2] == 'L' && method[1] == 'E') {
      type = EVHTTP_REQ_DELETE;
  }

  break;
     case 7:
  /* Method length is 7, only valid methods are "OPTIONS" and "CONNECT" */
  switch (*method) {
      case 'O':
   if (method[6] == 'S' && method[5] == 'N' && method[4] == 'O' &&
    method[3] == 'I' && method[2] == 'T' && method[1] == 'P') {
       type = EVHTTP_REQ_OPTIONS;
   }
                   
          break;
      case 'C':
   if (method[6] == 'T' && method[5] == 'C' && method[4] == 'E' &&
    method[3] == 'N' && method[2] == 'N' && method[1] == 'O') {
       type = EVHTTP_REQ_CONNECT;
   }
                    
   break;
      default:
   break;
  }
  break;
 } /* switch */

 if ((int)type == EVHTTP_REQ_UNKNOWN_) {
         event_debug(("%s: bad method %s on request %p from %s",
   __func__, method, req, req->remote_host));
                /* No error yet; we'll give a better error later when
                 * we see that req->type is unsupported. */
 }
     
 req->type = type;

 if (evhttp_parse_http_version(version, req) < 0)
  return -1;

 if ((req->uri = mm_strdup(uri)) == NULL) {
  event_debug(("%s: mm_strdup", __func__));
  return -1;
 }

 if (type == EVHTTP_REQ_CONNECT) {
  if ((req->uri_elems = evhttp_uri_parse_authority(req->uri)) == NULL) {
   return -1;
  }
 } else {
  if ((req->uri_elems = evhttp_uri_parse_with_flags(req->uri,
       EVHTTP_URI_NONCONFORMANT)) == NULL) {
   return -1;
  }
 }

 /* If we have an absolute-URI, check to see if it is an http request
   for a known vhost or server alias. If we don't know about this
   host, we consider it a proxy request. */
 scheme = evhttp_uri_get_scheme(req->uri_elems);
 hostname = evhttp_uri_get_host(req->uri_elems);
 if (scheme && (!evutil_ascii_strcasecmp(scheme, "http") ||
         !evutil_ascii_strcasecmp(scheme, "https")) &&
     hostname &&
     !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
  req->flags |= EVHTTP_PROXY_REQUEST;

 return 0;
}

const char *
evhttp_find_header(const struct evkeyvalq *headers, const char *key)
{
 struct evkeyval *header;

 TAILQ_FOREACH(header, headers, next) {
  if (evutil_ascii_strcasecmp(header->key, key) == 0)
   return (header->value);
 }

 return (NULL);
}

void
evhttp_clear_headers(struct evkeyvalq *headers)
{
 struct evkeyval *header;

 for (header = TAILQ_FIRST(headers);
     header != NULL;
     header = TAILQ_FIRST(headers)) {
  TAILQ_REMOVE(headers, header, next);
  mm_free(header->key);
  mm_free(header->value);
  mm_free(header);
 }
}

/*
 * Returns 0,  if the header was successfully removed.
 * Returns -1, if the header could not be found.
 */

int
evhttp_remove_header(struct evkeyvalq *headers, const char *key)
{
 struct evkeyval *header;

 TAILQ_FOREACH(header, headers, next) {
  if (evutil_ascii_strcasecmp(header->key, key) == 0)
   break;
 }

 if (header == NULL)
  return (-1);

 /* Free and remove the header that we found */
 TAILQ_REMOVE(headers, header, next);
 mm_free(header->key);
 mm_free(header->value);
 mm_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)
{
 event_debug(("%s: key: %s val: %s\n", __func__, key, value));

 if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
  /* drop illegal headers */
  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);
 }

 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 = mm_calloc(1, sizeof(struct evkeyval));
 if (header == NULL) {
  event_warn("%s: calloc", __func__);
  return (-1);
 }
 if ((header->key = mm_strdup(key)) == NULL) {
  mm_free(header);
  event_warn("%s: strdup", __func__);
  return (-1);
 }
 if ((header->value = mm_strdup(value)) == NULL) {
  mm_free(header->key);
  mm_free(header);
  event_warn("%s: strdup", __func__);
  return (-1);
 }

 TAILQ_INSERT_TAIL(headers, header, next);

 return (0);
}

/*
 * Parses header lines from a request or a response into the specified
 * request object given an event buffer.
 *
 * Returns
 *   DATA_CORRUPTED      on error
 *   MORE_DATA_EXPECTED  when we need to read more headers
 *   ALL_DATA_READ       when all headers have been read.
 */

enum message_read_status
evhttp_parse_firstline_(struct evhttp_request *req, struct evbuffer *buffer)
{
 char *line;
 enum message_read_status status = ALL_DATA_READ;

 size_t len;
 /* XXX try */
 line = evbuffer_readln(buffer, &len, EVBUFFER_EOL_CRLF);
 if (line == NULL) {
  if (req->evcon != NULL &&
      evbuffer_get_length(buffer) > req->evcon->max_headers_size)
   return (DATA_TOO_LONG);
  else
   return (MORE_DATA_EXPECTED);
 }

 if (req->evcon != NULL && len > req->evcon->max_headers_size) {
  mm_free(line);
  return (DATA_TOO_LONG);
 }

 req->headers_size = len;

 switch (req->kind) {
 case EVHTTP_REQUEST:
  if (evhttp_parse_request_line(req, line, len) == -1)
   status = DATA_CORRUPTED;
  break;
 case EVHTTP_RESPONSE:
  if (evhttp_parse_response_line(req, line) == -1)
   status = DATA_CORRUPTED;
  break;
 default:
  status = DATA_CORRUPTED;
 }

 mm_free(line);
 return (status);
}

static int
evhttp_append_to_last_header(struct evkeyvalq *headers, char *line)
{
 struct evkeyval *header = TAILQ_LAST(headers, evkeyvalq);
 char *newval;
 size_t old_len, line_len;

 if (header == NULL)
  return (-1);

 old_len = strlen(header->value);

 /* Strip space from start and end of line. */
 while (*line == ' ' || *line == '\t')
  ++line;
 evutil_rtrim_lws_(line);

 line_len = strlen(line);

 newval = mm_realloc(header->value, old_len + line_len + 2);
 if (newval == NULL)
  return (-1);

 newval[old_len] = ' ';
 memcpy(newval + old_len + 1, line, line_len + 1);
 header->value = newval;

 return (0);
}

enum message_read_status
evhttp_parse_headers_(struct evhttp_request *req, struct evbuffer* buffer)
{
 enum message_read_status errcode = DATA_CORRUPTED;
 char *line;
 enum message_read_status status = MORE_DATA_EXPECTED;

 struct evkeyvalq* headers = req->input_headers;
 size_t len;
 while ((line = evbuffer_readln(buffer, &len, EVBUFFER_EOL_CRLF))
        != NULL) {
  char *skey, *svalue;

  req->headers_size += len;

  if (req->evcon != NULL &&
      req->headers_size > req->evcon->max_headers_size) {
   errcode = DATA_TOO_LONG;
   goto error;
  }

  if (*line == '\0') { /* Last header - Done */
   status = ALL_DATA_READ;
   mm_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;
   mm_free(line);
   continue;
  }

  /* Processing of header lines */
  svalue = line;
  skey = strsep(&svalue, ":");
  if (svalue == NULL)
   goto error;

  svalue += strspn(svalue, " ");
  evutil_rtrim_lws_(svalue);

  if (evhttp_add_header(headers, skey, svalue) == -1)
   goto error;

  mm_free(line);
 }

 if (status == MORE_DATA_EXPECTED) {
  if (req->evcon != NULL &&
  req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
   return (DATA_TOO_LONG);
 }

 return (status);

 error:
 mm_free(line);
 return (errcode);
}

static int
evhttp_get_body_length(struct evhttp_request *req)
{
 struct evkeyvalq *headers = req->input_headers;
 const char *content_length;
 const char *connection;

 content_length = evhttp_find_header(headers, "Content-Length");
 connection = evhttp_find_header(headers, "Connection");

 if (content_length == NULL && connection == NULL)
  req->ntoread = -1;
 else if (content_length == NULL &&
     evutil_ascii_strcasecmp(connection, "Close") != 0) {
  req->ntoread = 0;
 } else if (content_length == NULL) {
  req->ntoread = -1;
 } else {
  char *endp;
  ev_int64_t ntoread = evutil_strtoll(content_length, &endp, 10);
  if (*content_length == '\0' || *endp != '\0' || ntoread < 0) {
   event_debug(("%s: illegal content length: %s",
    __func__, content_length));
   return (-1);
  }
  req->ntoread = ntoread;
 }

 event_debug(("%s: bytes to read: "EV_I64_FMT" (in buffer "EV_SIZE_FMT")\n",
  __func__, EV_I64_ARG(req->ntoread),
  EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));

 return (0);
}

static int
evhttp_method_may_have_body(enum evhttp_cmd_type type)
{
 switch (type) {
 case EVHTTP_REQ_POST:
 case EVHTTP_REQ_PUT:
 case EVHTTP_REQ_PATCH:

 case EVHTTP_REQ_GET:
 case EVHTTP_REQ_DELETE:
 case EVHTTP_REQ_OPTIONS:
 case EVHTTP_REQ_CONNECT:
  return 1;

 case EVHTTP_REQ_TRACE:
 case EVHTTP_REQ_HEAD:
 default:
  return 0;
 }
}

static void
evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
{
 const char *xfer_enc;

 /* If this is a request without a body, then we are done */
 if (req->kind == EVHTTP_REQUEST &&
     !evhttp_method_may_have_body(req->type)) {
  evhttp_connection_done(evcon);
  return;
 }
 evcon->state = EVCON_READING_BODY;
 xfer_enc = evhttp_find_header(req->input_headers, "Transfer-Encoding");
 if (xfer_enc != NULL && evutil_ascii_strcasecmp(xfer_enc, "chunked") == 0) {
  req->chunked = 1;
  req->ntoread = -1;
 } else {
  if (evhttp_get_body_length(req) == -1) {
   evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
   return;
  }
  if (req->kind == EVHTTP_REQUEST && req->ntoread < 1) {
   /* An incoming request with no content-length and no
 * transfer-encoding has no body. */
   evhttp_connection_done(evcon);
   return;
  }
 }

 /* Should we send a 100 Continue status line? */
 switch (evhttp_have_expect(req, 1)) {
  case CONTINUE:
    /* XXX It would be nice to do some sanity
   checking here. Does the resource exist?
   Should the resource accept post requests? If
   no, we should respond with an error. For
   now, just optimistically tell the client to
   send their message body. */
    if (req->ntoread > 0) {
     /* ntoread is ev_int64_t, max_body_size is ev_uint64_t */ 
     if ((req->evcon->max_body_size <= EV_INT64_MAX) &&
      (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
      evhttp_lingering_fail(evcon, req);
      return;
     }
    }
    if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
     evhttp_send_continue(evcon, req);
   break;
  case OTHER:
   evhttp_send_error(req, HTTP_EXPECTATIONFAILED, NULL);
   return;
  case NO: break;
 }

 evhttp_read_body(evcon, req);
 /* note the request may have been freed in evhttp_read_body */
}

static void
evhttp_read_firstline(struct evhttp_connection *evcon,
        struct evhttp_request *req)
{
 enum message_read_status res;

 res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
 if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
  /* Error while reading, terminate */
  event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
   __func__, EV_SOCK_ARG(evcon->fd)));
  evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
  return;
 } else if (res == MORE_DATA_EXPECTED) {
  /* Need more header lines */
  return;
 }

 evcon->state = EVCON_READING_HEADERS;
 evhttp_read_header(evcon, req);
}

static void
evhttp_read_header(struct evhttp_connection *evcon,
     struct evhttp_request *req)
{
 enum message_read_status res;
 evutil_socket_t fd = evcon->fd;

 res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
 if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
  /* Error while reading, terminate */
  event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
   __func__, EV_SOCK_ARG(fd)));
  evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
  return;
 } else if (res == MORE_DATA_EXPECTED) {
  /* Need more header lines */
  return;
 }

 /* Callback can shut down connection with negative return value */
 if (req->header_cb != NULL) {
  if ((*req->header_cb)(req, req->cb_arg) < 0) {
   evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
   return;
  }
 }

 /* Done reading headers, do the real work */
 switch (req->kind) {
 case EVHTTP_REQUEST:
  event_debug(("%s: checking for post data on "EV_SOCK_FMT"\n",
   __func__, EV_SOCK_ARG(fd)));
  evhttp_get_body(evcon, req);
  /* note the request may have been freed in evhttp_get_body */
  break;

 case EVHTTP_RESPONSE:
  /* Start over if we got a 100 Continue response. */
  if (req->response_code == 100) {
   struct evbuffer *output = bufferevent_get_output(evcon->bufev);
   evbuffer_add_buffer(output, req->output_buffer);
   evhttp_start_write_(evcon);
   return;
  }
  if (!evhttp_response_needs_body(req)) {
   event_debug(("%s: skipping body for code %d\n",
     __func__, req->response_code));
   evhttp_connection_done(evcon);
  } else {
   event_debug(("%s: start of read body for %s on "
    EV_SOCK_FMT"\n",
    __func__, req->remote_host, EV_SOCK_ARG(fd)));
   evhttp_get_body(evcon, req);
   /* note the request may have been freed in
 * evhttp_get_body */
  }
  break;

 default:
  event_warnx("%s: bad header on "EV_SOCK_FMT, __func__,
      EV_SOCK_ARG(fd));
  evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
  break;
 }
 /* request may have been freed above */
}

/*
 * Creates a TCP connection to the specified port and executes a callback
 * when finished.  Failure or success is indicate by the passed connection
 * object.
 *
 * Although this interface accepts a hostname, it is intended to take
 * only numeric hostnames so that non-blocking DNS resolution can
 * happen elsewhere.
 */

struct evhttp_connection *
evhttp_connection_new(const char *address, ev_uint16_t port)
{
 return (evhttp_connection_base_new(NULL, NULL, address, port));
}

struct evhttp_connection *
evhttp_connection_base_bufferevent_new(struct event_base *base, struct evdns_base *dnsbase, struct bufferevent* bev,
    const char *address, ev_uint16_t port)
{
 struct evhttp_connection *evcon = NULL;

 event_debug(("Attempting connection to %s:%d\n", address, port));

 if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
  event_warn("%s: calloc failed", __func__);
  goto error;
 }

 evcon->fd = -1;
 evcon->port = port;

 evcon->max_headers_size = EV_SIZE_MAX;
 evcon->max_body_size = EV_SIZE_MAX;

 evutil_timerclear(&evcon->timeout);
 evcon->retry_cnt = evcon->retry_max = 0;

 if ((evcon->address = mm_strdup(address)) == NULL) {
  event_warn("%s: strdup failed", __func__);
  goto error;
 }

 if (bev == NULL) {
  if (!(bev = bufferevent_socket_new(base, -1, 0))) {
   event_warn("%s: bufferevent_socket_new failed", __func__);
   goto error;
  }
 }

 bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon);
 evcon->bufev = bev;

 evcon->state = EVCON_DISCONNECTED;
 TAILQ_INIT(&evcon->requests);

 evcon->initial_retry_timeout.tv_sec = 2;
 evcon->initial_retry_timeout.tv_usec = 0;

 if (base != NULL) {
  evcon->base = base;
  if (bufferevent_get_base(bev) != base)
   bufferevent_base_set(base, evcon->bufev);
 }

 event_deferred_cb_init_(
     &evcon->read_more_deferred_cb,
     bufferevent_get_priority(bev),
     evhttp_deferred_read_cb, evcon);

 evcon->dns_base = dnsbase;
 evcon->ai_family = AF_UNSPEC;

 return (evcon);

 error:
 if (evcon != NULL)
  evhttp_connection_free(evcon);
 return (NULL);
}

struct bufferevent* evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
{
 return evcon->bufev;
}

struct evhttp *
evhttp_connection_get_server(struct evhttp_connection *evcon)
{
 return evcon->http_server;
}

struct evhttp_connection *
evhttp_connection_base_new(struct event_base *base, struct evdns_base *dnsbase,
    const char *address, ev_uint16_t port)
{
 return evhttp_connection_base_bufferevent_new(base, dnsbase, NULL, address, port);
}

void evhttp_connection_set_family(struct evhttp_connection *evcon,
 int family)
{
--> --------------------

--> maximum size reached

--> --------------------