Google Git
Sign in
chromium / external / github.com / ellzey / libevhtp / refs/tags/0.4.12 / . / evhtp.c
blob: 1aedc1bf74ab5e01d760a02ed55d82c9900e2f6e [file] [log] [blame]
#define _GNU_SOURCE
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <signal.h>
#include <strings.h>
#include <inttypes.h>
#include <sys/socket.h>
#ifndef NO_SYS_UN
#include <sys/un.h>
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include <alloca.h>
#include <sys/tree.h>
#include "evhtp.h"
static int _evhtp_request_parser_start(htparser * p);
static int _evhtp_request_parser_path(htparser * p, const char * data, size_t len);
static int _evhtp_request_parser_args(htparser * p, const char * data, size_t len);
static int _evhtp_request_parser_header_key(htparser * p, const char * data, size_t len);
static int _evhtp_request_parser_header_val(htparser * p, const char * data, size_t len);
static int _evhtp_request_parser_headers(htparser * p);
static int _evhtp_request_parser_body(htparser * p, const char * data, size_t len);
static int _evhtp_request_parser_fini(htparser * p);
static int _evhtp_request_parser_chunk_new(htparser * p);
static int _evhtp_request_parser_chunk_fini(htparser * p);
static int _evhtp_request_parser_chunks_fini(htparser * p);
static int _evhtp_request_parser_headers_start(htparser * p);
static void _evhtp_connection_readcb(evbev_t * bev, void * arg);
static evhtp_connection_t * _evhtp_connection_new(evhtp_t * htp, int sock);
static evhtp_uri_t * _evhtp_uri_new(void);
static void _evhtp_uri_free(evhtp_uri_t * uri);
static evhtp_path_t * _evhtp_path_new(const char * data, size_t len);
static void _evhtp_path_free(evhtp_path_t * path);
#define HOOK_AVAIL(var, hook_name) (var->hooks && var->hooks->hook_name)
#define HOOK_FUNC(var, hook_name) (var->hooks->hook_name)
#define HOOK_ARGS(var, hook_name) var->hooks->hook_name ## _arg
#define HOOK_REQUEST_RUN(request, hook_name, ...) do { \
if (HOOK_AVAIL(request, hook_name)) { \
return HOOK_FUNC(request, hook_name) (request, __VA_ARGS__, \
HOOK_ARGS(request, hook_name)); \
} \
\
if (HOOK_AVAIL(evhtp_request_get_connection(request), hook_name)) { \
return HOOK_FUNC(request->conn, hook_name) (request, __VA_ARGS__, \
HOOK_ARGS(request->conn, hook_name)); \
} \
} while (0)
#define HOOK_REQUEST_RUN_NARGS(request, hook_name) do { \
if (HOOK_AVAIL(request, hook_name)) { \
return HOOK_FUNC(request, hook_name) (request, \
HOOK_ARGS(request, hook_name)); \
} \
\
if (HOOK_AVAIL(request->conn, hook_name)) { \
return HOOK_FUNC(request->conn, hook_name) (request, \
HOOK_ARGS(request->conn, hook_name)); \
} \
} while (0);
#ifndef EVHTP_DISABLE_EVTHR
#define _evhtp_lock(h) do { \
if (h->lock) { \
pthread_mutex_lock(h->lock); \
} \
} while (0)
#define _evhtp_unlock(h) do { \
if (h->lock) { \
pthread_mutex_unlock(h->lock); \
} \
} while (0)
#else
#define _evhtp_lock(h) do {} while (0)
#define _evhtp_unlock(h) do {} while (0)
#endif
static int scode_tree_initialized = 0;
/**
* @brief An RBTREE entry for the status code -> str matcher
*/
struct status_code {
evhtp_res code;
const char * str;
RB_ENTRY(status_code) entry;
};
static int
status_code_cmp(void * _a, void * _b) {
struct status_code * a = _a;
struct status_code * b = _b;
return b->code - a->code;
}
RB_HEAD(status_code_tree, status_code) status_code_head = RB_INITIALIZER(&status_code_head);
RB_GENERATE(status_code_tree, status_code, entry, status_code_cmp);
#define scode_add(scode, cstr) do { \
struct status_code * c = malloc(sizeof(struct status_code)); \
\
c->code = scode; \
c->str = cstr; \
\
RB_INSERT(status_code_tree, &status_code_head, c); \
} while (0)
static void
status_code_init(void) {
if (scode_tree_initialized > 0) {
return;
}
/* 100 codes */
scode_add(EVHTP_RES_CONTINUE, "Continue");
scode_add(EVHTP_RES_SWITCH_PROTO, "Switching Protocols");
scode_add(EVHTP_RES_PROCESSING, "Processing");
scode_add(EVHTP_RES_URI_TOOLONG, "URI Too Long");
/* 200 codes */
scode_add(EVHTP_RES_200, "OK");
scode_add(EVHTP_RES_CREATED, "Created");
scode_add(EVHTP_RES_ACCEPTED, "Accepted");
scode_add(EVHTP_RES_NAUTHINFO, "No Auth Info");
scode_add(EVHTP_RES_NOCONTENT, "No Content");
scode_add(EVHTP_RES_RSTCONTENT, "Reset Content");
scode_add(EVHTP_RES_PARTIAL, "Partial Content");
scode_add(EVHTP_RES_MSTATUS, "Multi-Status");
scode_add(EVHTP_RES_IMUSED, "IM Used");
/* 300 codes */
scode_add(EVHTP_RES_300, "Redirect");
scode_add(EVHTP_RES_MOVEDPERM, "Moved Permanently");
scode_add(EVHTP_RES_FOUND, "Found");
scode_add(EVHTP_RES_SEEOTHER, "See Other");
scode_add(EVHTP_RES_NOTMOD, "Not Modified");
scode_add(EVHTP_RES_USEPROXY, "Use Proxy");
scode_add(EVHTP_RES_SWITCHPROXY, "Switch Proxy");
scode_add(EVHTP_RES_TMPREDIR, "Temporary Redirect");
/* 400 codes */
scode_add(EVHTP_RES_400, "Bad Request");
scode_add(EVHTP_RES_UNAUTH, "Unauthorized");
scode_add(EVHTP_RES_PAYREQ, "Payment Required");
scode_add(EVHTP_RES_FORBIDDEN, "Forbidden");
scode_add(EVHTP_RES_NOTFOUND, "Not Found");
scode_add(EVHTP_RES_METHNALLOWED, "Not Allowed");
scode_add(EVHTP_RES_NACCEPTABLE, "Not Acceptable");
scode_add(EVHTP_RES_PROXYAUTHREQ, "Proxy Authentication Required");
scode_add(EVHTP_RES_TIMEOUT, "Request Timeout");
scode_add(EVHTP_RES_CONFLICT, "Conflict");
scode_add(EVHTP_RES_GONE, "Gone");
scode_add(EVHTP_RES_LENREQ, "Length Required");
scode_add(EVHTP_RES_PRECONDFAIL, "Precondition Failed");
scode_add(EVHTP_RES_ENTOOLARGE, "Entity Too Large");
scode_add(EVHTP_RES_URITOOLARGE, "Request-URI Too Long");
scode_add(EVHTP_RES_UNSUPPORTED, "Unsupported Media Type");
scode_add(EVHTP_RES_RANGENOTSC, "Requested Range Not Satisfiable");
scode_add(EVHTP_RES_EXPECTFAIL, "Expectation Failed");
scode_add(EVHTP_RES_IAMATEAPOT, "I'm a teapot");
/* 500 codes */
scode_add(EVHTP_RES_SERVERR, "Internal Server Error");
scode_add(EVHTP_RES_NOTIMPL, "Not Implemented");
scode_add(EVHTP_RES_BADGATEWAY, "Bad Gateway");
scode_add(EVHTP_RES_SERVUNAVAIL, "Service Unavailable");
scode_add(EVHTP_RES_GWTIMEOUT, "Gateway Timeout");
scode_add(EVHTP_RES_VERNSUPPORT, "HTTP Version Not Supported");
scode_add(EVHTP_RES_BWEXEED, "Bandwidth Limit Exceeded");
scode_tree_initialized = 1;
} /* status_code_init */
const char *
status_code_to_str(evhtp_res code) {
struct status_code c;
struct status_code * found;
c.code = code;
if (!(found = RB_FIND(status_code_tree, &status_code_head, &c))) {
return "DERP";
}
return found->str;
}
/**
* @brief callback definitions for request processing from libhtparse
*/
static htparse_hooks request_psets = {
.on_msg_begin = _evhtp_request_parser_start,
.method = NULL,
.scheme = NULL,
.host = NULL,
.port = NULL,
.path = _evhtp_request_parser_path,
.args = _evhtp_request_parser_args,
.uri = NULL,
.on_hdrs_begin = _evhtp_request_parser_headers_start,
.hdr_key = _evhtp_request_parser_header_key,
.hdr_val = _evhtp_request_parser_header_val,
.on_hdrs_complete = _evhtp_request_parser_headers,
.on_new_chunk = _evhtp_request_parser_chunk_new,
.on_chunk_complete = _evhtp_request_parser_chunk_fini,
.on_chunks_complete = _evhtp_request_parser_chunks_fini,
.body = _evhtp_request_parser_body,
.on_msg_complete = _evhtp_request_parser_fini
};
#ifndef DISABLE_SSL
static int session_id_context = 1;
static int ssl_num_locks;
static evhtp_mutex_t * ssl_locks;
static int ssl_locks_initialized = 0;
#endif
/*
* COMPAT FUNCTIONS
*/
#ifdef NO_STRNLEN
static size_t
strnlen(const char * s, size_t maxlen) {
const char * e;
size_t n;
for (e = s, n = 0; *e && n < maxlen; e++, n++) {
;
}
return n;
}
#endif
#ifdef NO_STRNDUP
static char *
strndup(const char * s, size_t n) {
size_t len = strnlen(s, n);
char * ret;
if (len < n) {
return strdup(s);
}
ret = malloc(n + 1);
ret[n] = '\0';
strncpy(ret, s, n);
return ret;
}
#endif
/*
* PRIVATE FUNCTIONS
*/
/**
* @brief a weak hash function
*
* @param str a null terminated string
*
* @return an unsigned integer hash of str
*/
static unsigned int
_evhtp_quick_hash(const char * str) {
unsigned int h = 0;
for (; *str; str++) {
h = 31 * h + *str;
}
return h;
}
/**
* @brief helper function to determine if http version is HTTP/1.0
*
* @param major the major version number
* @param minor the minor version number
*
* @return 1 if HTTP/1.0, else 0
*/
static int
_evhtp_is_http_10(const char major, const char minor) {
if (major >= 1 && minor <= 0) {
return 1;
}
return 0;
}
/**
* @brief helper function to determine if http version is HTTP/1.1
*
* @param major the major version number
* @param minor the minor version number
*
* @return 1 if HTTP/1.1, else 0
*/
static int
_evhtp_is_http_11(const char major, const char minor) {
if (major >= 1 && minor >= 1) {
return 1;
}
return 0;
}
/**
* @brief returns the HTTP protocol version
*
* @param major the major version number
* @param minor the minor version number
*
* @return EVHTP_PROTO_10 if HTTP/1.0, EVHTP_PROTO_11 if HTTP/1.1, otherwise
* EVHTP_PROTO_INVALID
*/
static evhtp_proto
_evhtp_protocol(const char major, const char minor) {
if (_evhtp_is_http_10(major, minor)) {
return EVHTP_PROTO_10;
}
if (_evhtp_is_http_11(major, minor)) {
return EVHTP_PROTO_11;
}
return EVHTP_PROTO_INVALID;
}
/**
* @brief runs the user-defined on_path hook for a request
*
* @param request the request structure
* @param path the path structure
*
* @return EVHTP_RES_OK on success, otherwise something else.
*/
static evhtp_res
_evhtp_path_hook(evhtp_request_t * request, evhtp_path_t * path) {
HOOK_REQUEST_RUN(request, on_path, path);
return EVHTP_RES_OK;
}
/**
* @brief runs the user-defined on_header hook for a request
*
* once a full key: value header has been parsed, this will call the hook
*
* @param request the request strucutre
* @param header the header structure
*
* @return EVHTP_RES_OK on success, otherwise something else.
*/
static evhtp_res
_evhtp_header_hook(evhtp_request_t * request, evhtp_header_t * header) {
HOOK_REQUEST_RUN(request, on_header, header);
return EVHTP_RES_OK;
}
/**
* @brief runs the user-defined on_Headers hook for a request after all headers
* have been parsed.
*
* @param request the request structure
* @param headers the headers tailq structure
*
* @return EVHTP_RES_OK on success, otherwise something else.
*/
static evhtp_res
_evhtp_headers_hook(evhtp_request_t * request, evhtp_headers_t * headers) {
HOOK_REQUEST_RUN(request, on_headers, headers);
return EVHTP_RES_OK;
}
/**
* @brief runs the user-defined on_body hook for requests containing a body.
* the data is stored in the request->buffer_in so the user may either
* leave it, or drain upon being called.
*
* @param request the request strucutre
* @param buf a evbuffer containing body data
*
* @return EVHTP_RES_OK on success, otherwise something else.
*/
static evhtp_res
_evhtp_body_hook(evhtp_request_t * request, evbuf_t * buf) {
HOOK_REQUEST_RUN(request, on_read, buf);
return EVHTP_RES_OK;
}
/**
* @brief runs the user-defined hook called just prior to a request been
* free()'d
*
* @param request therequest structure
*
* @return EVHTP_RES_OK on success, otherwise treated as an error
*/
static evhtp_res
_evhtp_request_fini_hook(evhtp_request_t * request) {
HOOK_REQUEST_RUN_NARGS(request, on_request_fini);
return EVHTP_RES_OK;
}
static evhtp_res
_evhtp_chunk_new_hook(evhtp_request_t * request, uint64_t len) {
HOOK_REQUEST_RUN(request, on_new_chunk, len);
return EVHTP_RES_OK;
}
static evhtp_res
_evhtp_chunk_fini_hook(evhtp_request_t * request) {
HOOK_REQUEST_RUN_NARGS(request, on_chunk_fini);
return EVHTP_RES_OK;
}
static evhtp_res
_evhtp_chunks_fini_hook(evhtp_request_t * request) {
HOOK_REQUEST_RUN_NARGS(request, on_chunks_fini);
return EVHTP_RES_OK;
}
static evhtp_res
_evhtp_headers_start_hook(evhtp_request_t * request) {
HOOK_REQUEST_RUN_NARGS(request, on_headers_start);
return EVHTP_RES_OK;
}
/**
* @brief runs the user-definedhook called just prior to a connection being
* closed
*
* @param connection the connection structure
*
* @return EVHTP_RES_OK on success, but pretty much ignored in any case.
*/
static evhtp_res
_evhtp_connection_fini_hook(evhtp_connection_t * connection) {
if (connection->hooks && connection->hooks->on_connection_fini) {
return (connection->hooks->on_connection_fini)(connection,
connection->hooks->on_connection_fini_arg);
}
return EVHTP_RES_OK;
}
/**
* @brief attempts to find a callback via hashing the path
*
* @param callbacks a evhtp_callbacks_t * structure
* @param path a null terminated string to be hashed and searched
*
* @return evhtp_callback_t * if found, NULL if not found.
*/
static evhtp_callback_t *
_evhtp_callback_hash_find(evhtp_callbacks_t * callbacks, const char * path) {
evhtp_callback_t * callback;
unsigned int hash;
unsigned int shash;
if (path == NULL) {
return NULL;
}
hash = _evhtp_quick_hash(path);
shash = (hash & (callbacks->buckets - 1));
callback = callbacks->callbacks[shash];
while (callback != NULL) {
if (callback->hash == hash &&
callback->type == evhtp_callback_type_hash &&
strcmp(callback->val.path, path) == 0) {
return callback;
}
callback = callback->next;
}
return NULL;
}
/**
* @brief iterate through a tailq of callback hooks defined as a regex until a
* match is found.
*
* @param callbacks a evhtp_callbacks_t structure
* @param path a string containing a path to be matched against
* @param soff a pointer to an integer which will be filled with the start
* offset in the string if matched.
* @param eoff a pointer to an integer which will be filled with the end
* offset in the string if matched
*
* @return an evhtp_callback_t function on success, otherwise NULL
*/
#ifndef EVHTP_DISABLE_REGEX
static evhtp_callback_t *
_evhtp_callback_regex_find(evhtp_callbacks_t * callbacks, const char * path,
unsigned int * soff, unsigned int * eoff) {
evhtp_callback_t * callback = callbacks->regex_callbacks;
if (path == NULL) {
return NULL;
}
while (callback != NULL) {
regmatch_t pmatch[28];
if (callback->type == evhtp_callback_type_regex) {
if (regexec(callback->val.regex, path, callback->val.regex->re_nsub + 1, pmatch, 0) == 0) {
*soff = (unsigned int)pmatch[callback->val.regex->re_nsub].rm_so;
*eoff = (unsigned int)pmatch[callback->val.regex->re_nsub].rm_eo;
return callback;
}
}
callback = callback->next;
}
return NULL;
}
#endif
/**
* @brief A wrapper around both hash and regex hook lookups
*
* @param callbacks
* @param path
* @param start_offset
* @param end_offset
*
* @return evhtp_callback_t on success, otherwise NULL
*/
static evhtp_callback_t *
_evhtp_callback_find(evhtp_callbacks_t * callbacks,
const char * path,
unsigned int * start_offset,
unsigned int * end_offset) {
evhtp_callback_t * callback;
if (callbacks == NULL) {
return NULL;
}
if ((callback = _evhtp_callback_hash_find(callbacks, path)) != NULL) {
*start_offset = 0;
*end_offset = (unsigned int)strlen(path);
return callback;
}
#ifndef EVHTP_DISABLE_REGEX
if ((callback = _evhtp_callback_regex_find(callbacks, path,
start_offset, end_offset)) != NULL) {
return callback;
}
#endif
return NULL;
}
/**
* @brief Creates a new evhtp_request_t
*
* @param c
*
* @return evhtp_request_t structure on success, otherwise NULL
*/
static evhtp_request_t *
_evhtp_request_new(evhtp_connection_t * c) {
evhtp_request_t * req;
if (!(req = calloc(sizeof(evhtp_request_t), 1))) {
return NULL;
}
req->conn = c;
req->htp = c->htp;
req->status = EVHTP_RES_OK;
req->buffer_in = evbuffer_new();
req->buffer_out = evbuffer_new();
req->headers_in = malloc(sizeof(evhtp_headers_t));
req->headers_out = malloc(sizeof(evhtp_headers_t));
TAILQ_INIT(req->headers_in);
TAILQ_INIT(req->headers_out);
return req;
}
/**
* @brief frees all data in an evhtp_request_t along with calling finished hooks
*
* @param request the request structure
*/
static void
_evhtp_request_free(evhtp_request_t * request) {
if (request == NULL) {
return;
}
_evhtp_request_fini_hook(request);
_evhtp_uri_free(request->uri);
evhtp_headers_free(request->headers_in);
evhtp_headers_free(request->headers_out);
if (request->hooks) {
free(request->hooks);
}
if (request->buffer_in) {
evbuffer_free(request->buffer_in);
}
if (request->buffer_out) {
evbuffer_free(request->buffer_out);
}
free(request);
}
/**
* @brief create an overlay URI structure
*
* @return evhtp_uri_t
*/
static evhtp_uri_t *
_evhtp_uri_new(void) {
evhtp_uri_t * uri;
if (!(uri = calloc(sizeof(evhtp_uri_t), 1))) {
return NULL;
}
return uri;
}
/**
* @brief frees an overlay URI structure
*
* @param uri evhtp_uri_t
*/
static void
_evhtp_uri_free(evhtp_uri_t * uri) {
if (uri == NULL) {
return;
}
evhtp_query_free(uri->query);
_evhtp_path_free(uri->path);
if (uri->fragment) {
free(uri->fragment);
}
if (uri->query_raw) {
free(uri->query_raw);
}
free(uri);
}
/**
* @brief parses the path and file from an input buffer
*
* @details in order to properly create a structure that can match
* both a path and a file, this will parse a string into
* what it considers a path, and a file.
*
* @details if for example the input was "/a/b/c", the parser will
* consider "/a/b/" as the path, and "c" as the file.
*
* @param data raw input data (assumes a /path/[file] structure)
* @param len length of the input data
*
* @return evhtp_request_t * on success, NULL on error.
*/
static evhtp_path_t *
_evhtp_path_new(const char * data, size_t len) {
evhtp_path_t * req_path;
const char * data_end = (const char *)(data + len);
char * path = NULL;
char * file = NULL;
if (!(req_path = calloc(sizeof(evhtp_path_t), 1))) {
return NULL;
}
if (len == 0) {
/*
* odd situation here, no preceding "/", so just assume the path is "/"
*/
path = strdup("/");
} else if (*data != '/') {
/* request like GET stupid HTTP/1.0, treat stupid as the file, and
* assume the path is "/"
*/
path = strdup("/");
file = strndup(data, len);
} else {
if (data[len - 1] != '/') {
/*
* the last character in data is assumed to be a file, not the end of path
* loop through the input data backwards until we find a "/"
*/
size_t i;
for (i = (len - 1); i != 0; i--) {
if (data[i] == '/') {
/*
* we have found a "/" representing the start of the file,
* and the end of the path
*/
size_t path_len;
size_t file_len;
path_len = (size_t)(&data[i] - data) + 1;
file_len = (size_t)(data_end - &data[i + 1]);
/* check for overflow */
if ((const char *)(data + path_len) > data_end) {
fprintf(stderr, "PATH Corrupted.. (path_len > len)\n");
free(req_path);
return NULL;
}
/* check for overflow */
if ((const char *)(&data[i + 1] + file_len) > data_end) {
fprintf(stderr, "FILE Corrupted.. (file_len > len)\n");
free(req_path);
return NULL;
}
path = strndup(data, path_len);
file = strndup(&data[i + 1], file_len);
break;
}
}
if (i == 0 && data[i] == '/' && !file && !path) {
/* drops here if the request is something like GET /foo */
path = strdup("/");
if (len > 1) {
file = strndup((const char *)(data + 1), len);
}
}
} else {
/* the last character is a "/", thus the request is just a path */
path = strndup(data, len);
}
}
if (len != 0) {
req_path->full = strndup(data, len);
}
req_path->path = path;
req_path->file = file;
return req_path;
} /* _evhtp_path_new */
static void
_evhtp_path_free(evhtp_path_t * path) {
if (path == NULL) {
return;
}
if (path->full) {
free(path->full);
}
if (path->path) {
free(path->path);
}
if (path->file) {
free(path->file);
}
if (path->match_start) {
free(path->match_start);
}
if (path->match_end) {
free(path->match_end);
}
free(path);
}
static int
_evhtp_request_parser_start(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
if (c->request) {
if (c->request->finished == 1) {
_evhtp_request_free(c->request);
} else {
return -1;
}
}
if (!(c->request = _evhtp_request_new(c))) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_args(htparser * p, const char * data, size_t len) {
evhtp_connection_t * c = htparser_get_userdata(p);
evhtp_uri_t * uri = c->request->uri;
if (!(uri->query = evhtp_parse_query(data, len))) {
c->request->status = EVHTP_RES_ERROR;
return -1;
}
uri->query_raw = calloc(len + 1, 1);
memcpy(uri->query_raw, data, len);
return 0;
}
static int
_evhtp_request_parser_headers_start(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
if ((c->request->status = _evhtp_headers_start_hook(c->request)) != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_header_key(htparser * p, const char * data, size_t len) {
evhtp_connection_t * c = htparser_get_userdata(p);
char * key_s; /* = strndup(data, len); */
evhtp_header_t * hdr;
key_s = malloc(len + 1);
key_s[len] = '\0';
memcpy(key_s, data, len);
if ((hdr = evhtp_header_key_add(c->request->headers_in, key_s, 0)) == NULL) {
c->request->status = EVHTP_RES_FATAL;
return -1;
}
hdr->k_heaped = 1;
return 0;
}
static int
_evhtp_request_parser_header_val(htparser * p, const char * data, size_t len) {
evhtp_connection_t * c = htparser_get_userdata(p);
char * val_s; /* = strndup(data, len); */
evhtp_header_t * header;
val_s = malloc(len + 1);
val_s[len] = '\0';
memcpy(val_s, data, len);
if ((header = evhtp_header_val_add(c->request->headers_in, val_s, 0)) == NULL) {
c->request->status = EVHTP_RES_FATAL;
return -1;
}
header->v_heaped = 1;
if ((c->request->status = _evhtp_header_hook(c->request, header)) != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_path(htparser * p, const char * data, size_t len) {
evhtp_connection_t * c = htparser_get_userdata(p);
evhtp_hooks_t * hooks = NULL;
evhtp_callback_t * callback = NULL;
evhtp_callback_cb cb = NULL;
evhtp_uri_t * uri;
evhtp_path_t * path;
void * cbarg = NULL;
char * match_start;
char * match_end;
if (!(uri = _evhtp_uri_new())) {
c->request->status = EVHTP_RES_FATAL;
return -1;
}
if (!(path = _evhtp_path_new(data, len))) {
c->request->status = EVHTP_RES_FATAL;
return -1;
}
_evhtp_lock(c->htp);
if ((callback = _evhtp_callback_find(c->htp->callbacks, path->path,
&path->matched_soff, &path->matched_eoff))) {
/* matched a callback using *just* the path (/a/b/c/) */
cb = callback->cb;
cbarg = callback->cbarg;
hooks = callback->hooks;
} else if ((callback = _evhtp_callback_find(c->htp->callbacks, path->full,
&path->matched_soff, &path->matched_eoff))) {
/* matched a callback using both path and file (/a/b/c/d) */
cb = callback->cb;
cbarg = callback->cbarg;
hooks = callback->hooks;
} else {
/* no callbacks found for either case, use defaults */
cb = c->htp->defaults.cb;
cbarg = c->htp->defaults.cbarg;
path->matched_soff = 0;
path->matched_eoff = (unsigned int)strlen(path->full);
}
_evhtp_unlock(c->htp);
match_start = calloc(strlen(path->full) + 1, 1);
match_end = calloc(strlen(path->full) + 1, 1);
memcpy(match_start,
(void *)(path->full + path->matched_soff),
path->matched_eoff);
memcpy(match_end,
(void *)(path->full + path->matched_eoff),
strlen(path->full) - path->matched_eoff);
path->match_start = match_start;
path->match_end = match_end;
uri->path = path;
uri->scheme = htparser_get_scheme(p);
if (hooks != NULL) {
c->request->hooks = malloc(sizeof(evhtp_hooks_t));
memcpy(c->request->hooks, hooks, sizeof(evhtp_hooks_t));
}
c->request->uri = uri;
c->request->cb = cb;
c->request->cbarg = cbarg;
c->request->method = htparser_get_method(p);
if ((c->request->status = _evhtp_path_hook(c->request, path)) != EVHTP_RES_OK) {
return -1;
}
return 0;
} /* _evhtp_request_parser_path */
static int
_evhtp_request_parser_headers(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
const char * expect_val;
/* XXX proto should be set with htparsers on_hdrs_begin hook */
c->request->keepalive = htparser_should_keep_alive(p);
c->request->proto = _evhtp_protocol(htparser_get_major(p), htparser_get_minor(p));
c->request->status = _evhtp_headers_hook(c->request, c->request->headers_in);
if (c->request->status != EVHTP_RES_OK) {
return -1;
}
if (!(expect_val = evhtp_header_find(c->request->headers_in, "Expect"))) {
return 0;
}
evbuffer_add_printf(bufferevent_get_output(c->bev),
"HTTP/%d.%d 100 Continue\r\n\r\n",
htparser_get_major(p),
htparser_get_minor(p));
return 0;
}
static int
_evhtp_request_parser_body(htparser * p, const char * data, size_t len) {
evhtp_connection_t * c = htparser_get_userdata(p);
evbuf_t * buf = evbuffer_new();
int res = 0;
evbuffer_add(buf, data, len);
if ((c->request->status = _evhtp_body_hook(c->request, buf)) != EVHTP_RES_OK) {
res = -1;
}
if (evbuffer_get_length(buf)) {
evbuffer_add_buffer(c->request->buffer_in, buf);
}
evbuffer_free(buf);
return res;
}
static int
_evhtp_request_parser_chunk_new(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
if ((c->request->status = _evhtp_chunk_new_hook(c->request,
htparser_get_content_length(p))) != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_chunk_fini(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
if ((c->request->status = _evhtp_chunk_fini_hook(c->request)) != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_chunks_fini(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
if ((c->request->status = _evhtp_chunks_fini_hook(c->request)) != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_request_parser_fini(htparser * p) {
evhtp_connection_t * c = htparser_get_userdata(p);
/* c->request->finished = 1; */
if (c->request->cb) {
(c->request->cb)(c->request, c->request->cbarg);
}
return 0;
}
static int
_evhtp_create_headers(evhtp_header_t * header, void * arg) {
evbuf_t * buf = arg;
evbuffer_add(buf, header->key, header->klen);
evbuffer_add(buf, ": ", 2);
evbuffer_add(buf, header->val, header->vlen);
evbuffer_add(buf, "\r\n", 2);
return 0;
}
static evbuf_t *
_evhtp_create_reply(evhtp_request_t * request, evhtp_res code) {
evbuf_t * buf = evbuffer_new();
const char * content_type = evhtp_header_find(request->headers_out, "Content-Type");
if (content_type && strstr(content_type, "multipart")) {
/* multipart messages should not get any extra headers */
goto check_proto;
}
if (evbuffer_get_length(request->buffer_out) && request->chunked == 0) {
/* add extra headers (like content-length/type) if not already present */
if (!evhtp_header_find(request->headers_out, "Content-Length")) {
char lstr[128];
int sres;
sres = snprintf(lstr, sizeof(lstr), "%zu",
evbuffer_get_length(request->buffer_out));
if (sres >= sizeof(lstr) || sres < 0) {
/* overflow condition, this should never happen, but if it does,
* well lets just shut the connection down */
request->keepalive = 0;
goto check_proto;
}
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Content-Length", lstr, 0, 1));
}
if (!content_type) {
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Content-Type", "text/plain", 0, 0));
}
} else {
if (!evhtp_header_find(request->headers_out, "Content-Length")) {
const char * chunked = evhtp_header_find(request->headers_out,
"transfer-encoding");
if (!chunked || !strstr(chunked, "chunked")) {
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Content-Length", "0", 0, 0));
}
}
}
check_proto:
/* add the proper keep-alive type headers based on http version */
switch (request->proto) {
case EVHTP_PROTO_11:
if (request->keepalive == 0) {
/* protocol is HTTP/1.1 but client wanted to close */
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Connection", "close", 0, 0));
}
break;
case EVHTP_PROTO_10:
if (request->keepalive == 1) {
/* protocol is HTTP/1.0 and clients wants to keep established */
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Connection", "keep-alive", 0, 0));
}
break;
default:
/* this sometimes happens when a response is made but paused before
* the method has been parsed */
htparser_set_major(request->conn->parser, 1);
htparser_set_minor(request->conn->parser, 0);
break;
} /* switch */
/* add the status line */
evbuffer_add_printf(buf, "HTTP/%d.%d %d %s\r\n",
htparser_get_major(request->conn->parser),
htparser_get_minor(request->conn->parser),
code, status_code_to_str(code));
evhtp_headers_for_each(request->headers_out, _evhtp_create_headers, buf);
evbuffer_add(buf, "\r\n", 2);
if (evbuffer_get_length(request->buffer_out)) {
evbuffer_add_buffer(buf, request->buffer_out);
}
return buf;
} /* _evhtp_create_reply */
static void
_evhtp_connection_resumecb(int fd, short events, void * arg) {
evhtp_connection_t * c = arg;
if (c->request) {
c->request->status = EVHTP_RES_OK;
}
return _evhtp_connection_readcb(c->bev, c);
}
static void
_evhtp_connection_readcb(evbev_t * bev, void * arg) {
evhtp_connection_t * c = arg;
void * buf;
size_t nread;
size_t avail;
avail = evbuffer_get_length(bufferevent_get_input(bev));
if (c->request) {
c->request->status = EVHTP_RES_OK;
}
buf = evbuffer_pullup(bufferevent_get_input(bev), avail);
nread = htparser_run(c->parser, &request_psets, (const char *)buf, avail);
if (c->owner != 1) {
return evhtp_connection_free(c);
}
if (avail != nread) {
if (c->request && c->request->status == EVHTP_RES_PAUSE) {
evhtp_request_pause(c->request);
} else {
return evhtp_connection_free(c);
}
}
evbuffer_drain(bufferevent_get_input(bev), nread);
}
static void
_evhtp_connection_writecb(evbev_t * bev, void * arg) {
evhtp_connection_t * c = arg;
if (c->request == NULL) {
return;
}
if (c->request->finished == 0 || evbuffer_get_length(bufferevent_get_output(bev))) {
return;
}
if (c->request->keepalive) {
_evhtp_request_free(c->request);
c->request = NULL;
htparser_init(c->parser, htp_type_request);
return htparser_set_userdata(c->parser, c);
} else {
return evhtp_connection_free(c);
}
return;
}
static void
_evhtp_connection_eventcb(evbev_t * bev, short events, void * arg) {
evhtp_connection_t * c;
if ((events & BEV_EVENT_CONNECTED)) {
return;
}
c = arg;
if (c->ssl && !(events & BEV_EVENT_EOF)) {
/* XXX need to do better error handling for SSL specific errors */
c->error = 1;
if (c->request) {
c->request->error = 1;
}
}
c->error = 1;
if (c->request && c->request->hooks && c->request->hooks->on_error) {
(*c->request->hooks->on_error)(c->request, events,
c->request->hooks->on_error_arg);
}
return evhtp_connection_free((evhtp_connection_t *)arg);
}
static int
_evhtp_run_pre_accept(evhtp_t * htp, evhtp_connection_t * conn) {
void * args;
evhtp_res res;
if (htp->defaults.pre_accept == NULL) {
return 0;
}
args = htp->defaults.pre_accept_cbarg;
res = htp->defaults.pre_accept(conn, args);
if (res != EVHTP_RES_OK) {
return -1;
}
return 0;
}
static int
_evhtp_connection_accept(evbase_t * evbase, evhtp_connection_t * connection) {
if (_evhtp_run_pre_accept(connection->htp, connection) < 0) {
evutil_closesocket(connection->sock);
return -1;
}
#ifndef DISABLE_SSL
if (connection->htp->ssl_ctx != NULL) {
connection->ssl = SSL_new(connection->htp->ssl_ctx);
connection->bev = bufferevent_openssl_socket_new(evbase,
connection->sock,
connection->ssl,
BUFFEREVENT_SSL_ACCEPTING,
connection->htp->bev_flags);
SSL_set_app_data(connection->ssl, connection);
goto end;
}
#endif
connection->bev = bufferevent_socket_new(evbase,
connection->sock,
connection->htp->bev_flags);
#ifndef DISABLE_SSL
end:
#endif
bufferevent_set_timeouts(connection->bev,
connection->htp->recv_timeo,
connection->htp->send_timeo);
connection->resume_ev = event_new(evbase, -1, EV_READ | EV_PERSIST,
_evhtp_connection_resumecb, connection);
event_add(connection->resume_ev, NULL);
bufferevent_enable(connection->bev, EV_READ);
bufferevent_setcb(connection->bev,
_evhtp_connection_readcb,
_evhtp_connection_writecb,
_evhtp_connection_eventcb, connection);
return 0;
} /* _evhtp_connection_accept */
static void
_evhtp_default_request_cb(evhtp_request_t * request, void * arg) {
return evhtp_send_reply(request, EVHTP_RES_NOTFOUND);
}
static evhtp_connection_t *
_evhtp_connection_new(evhtp_t * htp, int sock) {
evhtp_connection_t * connection;
if (!(connection = malloc(sizeof(evhtp_connection_t)))) {
return NULL;
}
connection->evbase = NULL;
connection->bev = NULL;
connection->thread = NULL;
connection->ssl = NULL;
connection->hooks = NULL;
connection->request = NULL;
connection->resume_ev = NULL;
connection->error = 0;
connection->owner = 1;
connection->sock = sock;
connection->htp = htp;
connection->parser = htparser_new();
htparser_init(connection->parser, htp_type_request);
htparser_set_userdata(connection->parser, connection);
return connection;
}
#ifndef DISABLE_SSL
static void
_evhtp_shutdown_eventcb(evbev_t * bev, short events, void * arg) {
}
#endif
static int
_evhtp_run_post_accept(evhtp_t * htp, evhtp_connection_t * connection) {
void * args;
evhtp_res res;
if (htp->defaults.post_accept == NULL) {
return 0;
}
args = htp->defaults.post_accept_cbarg;
res = htp->defaults.post_accept(connection, args);
if (res != EVHTP_RES_OK) {
return -1;
}
return 0;
}
#ifndef EVHTP_DISABLE_EVTHR
static void
_evhtp_run_in_thread(evthr_t * thr, void * arg, void * shared) {
evhtp_t * htp = shared;
evhtp_connection_t * connection = arg;
connection->evbase = evthr_get_base(thr);
connection->thread = thr;
evthr_inc_backlog(connection->thread);
if (_evhtp_connection_accept(connection->evbase, connection) < 0) {
return evhtp_connection_free(connection);
}
if (_evhtp_run_post_accept(htp, connection) < 0) {
return evhtp_connection_free(connection);
}
}
#endif
static void
_evhtp_accept_cb(evserv_t * serv, int fd, struct sockaddr * s, int sl, void * arg) {
evhtp_t * htp = arg;
evhtp_connection_t * connection;
if (!(connection = _evhtp_connection_new(htp, fd))) {
return;
}
connection->saddr = malloc(sl);
memcpy(connection->saddr, s, sl);
#ifndef EVHTP_DISABLE_EVTHR
if (htp->thr_pool != NULL) {
if (evthr_pool_defer(htp->thr_pool, _evhtp_run_in_thread, connection) != EVTHR_RES_OK) {
evutil_closesocket(connection->sock);
return evhtp_connection_free(connection);
}
return;
}
#endif
connection->evbase = htp->evbase;
if (_evhtp_connection_accept(htp->evbase, connection) < 0) {
return evhtp_connection_free(connection);
}
if (_evhtp_run_post_accept(htp, connection) < 0) {
return evhtp_connection_free(connection);
}
}
#ifndef DISABLE_SSL
#ifndef EVHTP_DISABLE_EVTHR
static unsigned long
_evhtp_ssl_get_thread_id(void) {
return (unsigned long)pthread_self();
}
static void
_evhtp_ssl_thread_lock(int mode, int type, const char * file, int line) {
if (type < ssl_num_locks) {
if (mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(ssl_locks[type]));
} else {
pthread_mutex_unlock(&(ssl_locks[type]));
}
}
}
#endif
static void
_evhtp_ssl_delete_scache_ent(evhtp_ssl_ctx_t * ctx, evhtp_ssl_sess_t * sess) {
evhtp_t * htp;
evhtp_ssl_cfg_t * cfg;
unsigned char * sid;
unsigned int slen;
htp = (evhtp_t *)SSL_CTX_get_app_data(ctx);
cfg = htp->ssl_cfg;
sid = sess->session_id;
slen = sess->session_id_length;
if (cfg->scache_del) {
(cfg->scache_del)(htp, sid, slen);
}
}
static int
_evhtp_ssl_add_scache_ent(evhtp_ssl_t * ssl, evhtp_ssl_sess_t * sess) {
evhtp_connection_t * connection;
evhtp_ssl_cfg_t * cfg;
unsigned char * sid;
int slen;
connection = (evhtp_connection_t *)SSL_get_app_data(ssl);
cfg = connection->htp->ssl_cfg;
sid = sess->session_id;
slen = sess->session_id_length;
SSL_set_timeout(sess, cfg->scache_timeout);
if (cfg->scache_add) {
return (cfg->scache_add)(connection, sid, slen, sess);
}
return 0;
}
static evhtp_ssl_sess_t *
_evhtp_ssl_get_scache_ent(evhtp_ssl_t * ssl, unsigned char * sid, int sid_len, int * copy) {
evhtp_connection_t * connection;
evhtp_ssl_cfg_t * cfg;
evhtp_ssl_sess_t * sess;
connection = (evhtp_connection_t * )SSL_get_app_data(ssl);
cfg = connection->htp->ssl_cfg;
sess = NULL;
if (cfg->scache_get) {
sess = (cfg->scache_get)(connection, sid, sid_len);
}
*copy = 0;
return sess;
}
#endif
/*
* PUBLIC FUNCTIONS
*/
htp_method
evhtp_request_get_method(evhtp_request_t * r) {
return htparser_get_method(r->conn->parser);
}
/**
* @brief pauses a connection (disables reading)
*
* @param c a evhtp_connection_t * structure
*/
void
evhtp_connection_pause(evhtp_connection_t * c) {
if ((bufferevent_get_enabled(c->bev) & EV_READ)) {
bufferevent_disable(c->bev, EV_READ);
}
}
/**
* @brief resumes a connection (enables reading) and activates resume event.
*
* @param c
*/
void
evhtp_connection_resume(evhtp_connection_t * c) {
if (!(bufferevent_get_enabled(c->bev) & EV_READ)) {
bufferevent_enable(c->bev, EV_READ);
event_active(c->resume_ev, EV_WRITE, 1);
}
}
/**
* @brief Wrapper around evhtp_connection_pause
*
* @see evhtp_connection_pause
*
* @param request
*/
void
evhtp_request_pause(evhtp_request_t * request) {
request->status = EVHTP_RES_PAUSE;
return evhtp_connection_pause(request->conn);
}
/**
* @brief Wrapper around evhtp_connection_resume
*
* @see evhtp_connection_resume
*
* @param request
*/
void
evhtp_request_resume(evhtp_request_t * request) {
return evhtp_connection_resume(request->conn);
}
evhtp_header_t *
evhtp_header_key_add(evhtp_headers_t * headers, const char * key, char kalloc) {
evhtp_header_t * header;
if (!(header = evhtp_header_new(key, NULL, kalloc, 0))) {
return NULL;
}
evhtp_headers_add_header(headers, header);
return header;
}
evhtp_header_t *
evhtp_header_val_add(evhtp_headers_t * headers, const char * val, char valloc) {
evhtp_header_t * header = TAILQ_LAST(headers, evhtp_headers_s);
if (header == NULL) {
return NULL;
}
header->vlen = strlen(val);
if (valloc == 1) {
header->val = malloc(header->vlen + 1);
header->val[header->vlen] = '\0';
memcpy(header->val, val, header->vlen);
} else {
header->val = (char *)val;
}
header->v_heaped = valloc;
return header;
}
evhtp_kvs_t *
evhtp_kvs_new(void) {
evhtp_kvs_t * kvs = malloc(sizeof(evhtp_kvs_t));
TAILQ_INIT(kvs);
return kvs;
}
evhtp_kv_t *
evhtp_kv_new(const char * key, const char * val, char kalloc, char valloc) {
evhtp_kv_t * kv;
if (!(kv = malloc(sizeof(evhtp_kv_t)))) {
return NULL;
}
kv->k_heaped = kalloc;
kv->v_heaped = valloc;
kv->klen = 0;
kv->vlen = 0;
if (key != NULL) {
kv->klen = strlen(key);
if (kalloc == 1) {
char * s = malloc(kv->klen + 1);
s[kv->klen] = '\0';
memcpy(s, key, kv->klen);
kv->key = s;
} else {
kv->key = (char *)key;
}
}
if (val != NULL) {
kv->vlen = strlen(val);
if (valloc == 1) {
char * s = malloc(kv->vlen + 1);
s[kv->vlen] = '\0';
memcpy(s, val, kv->vlen);
kv->val = s;
} else {
kv->val = (char *)val;
}
}
return kv;
} /* evhtp_kv_new */
void
evhtp_kv_free(evhtp_kv_t * kv) {
if (kv == NULL) {
return;
}
if (kv->k_heaped && kv->key) {
free(kv->key);
}
if (kv->v_heaped && kv->val) {
free(kv->val);
}
free(kv);
}
void
evhtp_kv_rm_and_free(evhtp_kvs_t * kvs, evhtp_kv_t * kv) {
if (kvs == NULL || kv == NULL) {
return;
}
TAILQ_REMOVE(kvs, kv, next);
evhtp_kv_free(kv);
}
void
evhtp_kvs_free(evhtp_kvs_t * kvs) {
evhtp_kv_t * kv;
evhtp_kv_t * save;
if (kvs == NULL) {
return;
}
for (kv = TAILQ_FIRST(kvs); kv != NULL; kv = save) {
save = TAILQ_NEXT(kv, next);
TAILQ_REMOVE(kvs, kv, next);
evhtp_kv_free(kv);
}
free(kvs);
}
int
evhtp_kvs_for_each(evhtp_kvs_t * kvs, evhtp_kvs_iterator cb, void * arg) {
evhtp_kv_t * kv;
TAILQ_FOREACH(kv, kvs, next) {
int res;
if ((res = cb(kv, arg))) {
return res;
}
}
return 0;
}
const char *
evhtp_kv_find(evhtp_kvs_t * kvs, const char * key) {
evhtp_kv_t * kv;
if (kvs == NULL || key == NULL) {
return NULL;
}
TAILQ_FOREACH(kv, kvs, next) {
if (strcasecmp(kv->key, key) == 0) {
return kv->val;
}
}
return NULL;
}
evhtp_kv_t *
evhtp_kvs_find_kv(evhtp_kvs_t * kvs, const char * key) {
evhtp_kv_t * kv;
if (kvs == NULL || key == NULL) {
return NULL;
}
TAILQ_FOREACH(kv, kvs, next) {
if (strcasecmp(kv->key, key) == 0) {
return kv;
}
}
return NULL;
}
void
evhtp_kvs_add_kv(evhtp_kvs_t * kvs, evhtp_kv_t * kv) {
if (kvs == NULL || kv == NULL) {
return;
}
TAILQ_INSERT_TAIL(kvs, kv, next);
}
typedef enum {
s_query_start = 0,
s_query_question_mark,
s_query_separator,
s_query_key,
s_query_val,
s_query_key_hex_1,
s_query_key_hex_2,
s_query_val_hex_1,
s_query_val_hex_2,
s_query_done
} query_parser_state;
static inline int
evhtp_is_hex_query_char(unsigned char ch) {
switch (ch) {
case 'a': case 'A':
case 'b': case 'B':
case 'c': case 'C':
case 'd': case 'D':
case 'e': case 'E':
case 'f': case 'F':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return 1;
default:
return 0;
} /* switch */
}
enum unscape_state {
unscape_state_start = 0,
unscape_state_hex1,
unscape_state_hex2
};
int
evhtp_unescape_string(unsigned char ** out, unsigned char * str, size_t str_len) {
unsigned char * optr;
unsigned char * sptr;
unsigned char d;
unsigned char ch;
unsigned char c;
size_t i;
enum unscape_state state;
if (out == NULL || *out == NULL) {
return -1;
}
state = unscape_state_start;
optr = *out;
sptr = str;
d = 0;
for (i = 0; i < str_len; i++) {
ch = *sptr++;
switch (state) {
case unscape_state_start:
if (ch == '%') {
state = unscape_state_hex1;
break;
}
*optr++ = ch;
break;
case unscape_state_hex1:
if (ch >= '0' && ch <= '9') {
d = (unsigned char)(ch - '0');
state = unscape_state_hex2;
break;
}
c = (unsigned char)(ch | 0x20);
if (c >= 'a' && c <= 'f') {
d = (unsigned char)(c - 'a' + 10);
state = unscape_state_hex2;
break;
}
state = unscape_state_start;
*optr++ = ch;
break;
case unscape_state_hex2:
state = unscape_state_start;
if (ch >= '0' && ch <= '9') {
ch = (unsigned char)((d << 4) + ch - '0');
*optr++ = ch;
break;
}
c = (unsigned char)(ch | 0x20);
if (c >= 'a' && c <= 'f') {
ch = (unsigned char)((d << 4) + c - 'a' + 10);
*optr++ = ch;
break;
}
break;
} /* switch */
}
return 0;
} /* evhtp_unescape_string */
evhtp_query_t *
evhtp_parse_query(const char * query, size_t len) {
evhtp_query_t * query_args;
query_parser_state state = s_query_start;
char * key_buf = NULL;
char * val_buf = NULL;
int key_idx;
int val_idx;
int res;
unsigned char ch;
size_t i;
query_args = evhtp_query_new();
if (!(key_buf = malloc(len))) {
return NULL;
}
if (!(val_buf = malloc(len))) {
free(key_buf);
return NULL;
}
key_idx = 0;
val_idx = 0;
for (i = 0; i < len; i++) {
res = 0;
ch = query[i];
if (key_idx >= len || val_idx >= len) {
res = -1;
goto error;
}
switch (state) {
case s_query_start:
memset(key_buf, 0, len);
memset(val_buf, 0, len);
key_idx = 0;
val_idx = 0;
switch (ch) {
case '?':
state = s_query_key;
break;
case '/':
state = s_query_question_mark;
break;
default:
state = s_query_key;
goto query_key;
}
break;
case s_query_question_mark:
switch (ch) {
case '?':
state = s_query_key;
break;
case '/':
state = s_query_question_mark;
break;
default:
res = -1;
goto error;
}
break;
query_key:
case s_query_key:
switch (ch) {
case '=':
state = s_query_val;
break;
case '%':
key_buf[key_idx++] = ch;
key_buf[key_idx] = '\0';
state = s_query_key_hex_1;
break;
default:
key_buf[key_idx++] = ch;
key_buf[key_idx] = '\0';
break;
}
break;
case s_query_key_hex_1:
if (!evhtp_is_hex_query_char(ch)) {
res = -1;
goto error;
}
key_buf[key_idx++] = ch;
key_buf[key_idx] = '\0';
state = s_query_key_hex_2;
break;
case s_query_key_hex_2:
if (!evhtp_is_hex_query_char(ch)) {
res = -1;
goto error;
}
key_buf[key_idx++] = ch;
key_buf[key_idx] = '\0';
state = s_query_key;
break;
case s_query_val:
switch (ch) {
case ';':
case '&':
evhtp_kvs_add_kv(query_args, evhtp_kv_new(key_buf, val_buf, 1, 1));
memset(key_buf, 0, len);
memset(val_buf, 0, len);
key_idx = 0;
val_idx = 0;
state = s_query_key;
break;
case '%':
val_buf[val_idx++] = ch;
val_buf[val_idx] = '\0';
state = s_query_val_hex_1;
break;
default:
val_buf[val_idx++] = ch;
val_buf[val_idx] = '\0';
break;
} /* switch */
break;
case s_query_val_hex_1:
if (!evhtp_is_hex_query_char(ch)) {
res = -1;
goto error;
}
val_buf[val_idx++] = ch;
val_buf[val_idx] = '\0';
state = s_query_val_hex_2;
break;
case s_query_val_hex_2:
if (!evhtp_is_hex_query_char(ch)) {
res = -1;
goto error;
}
val_buf[val_idx++] = ch;
val_buf[val_idx] = '\0';
state = s_query_val;
break;
default:
/* bad state */
res = -1;
goto error;
} /* switch */
}
if (key_idx && val_idx) {
evhtp_kvs_add_kv(query_args, evhtp_kv_new(key_buf, val_buf, 1, 1));
}
if (key_buf) {
free(key_buf);
}
if (val_buf) {
free(val_buf);
}
return query_args;
error:
if (key_buf) {
free(key_buf);
}
if (val_buf) {
free(val_buf);
}
return NULL;
} /* evhtp_parse_query */
void
evhtp_send_reply_start(evhtp_request_t * request, evhtp_res code) {
evhtp_connection_t * c;
evbuf_t * reply_buf;
c = evhtp_request_get_connection(request);
if (!(reply_buf = _evhtp_create_reply(request, code))) {
return evhtp_connection_free(c);
}
bufferevent_write_buffer(c->bev, reply_buf);
evbuffer_free(reply_buf);
}
void
evhtp_send_reply_body(evhtp_request_t * request, evbuf_t * buf) {
evhtp_connection_t * c;
c = request->conn;
bufferevent_write_buffer(c->bev, buf);
}
void
evhtp_send_reply_end(evhtp_request_t * request) {
request->finished = 1;
return _evhtp_connection_writecb(evhtp_request_get_bev(request),
evhtp_request_get_connection(request));
}
void
evhtp_send_reply(evhtp_request_t * request, evhtp_res code) {
evhtp_connection_t * c;
evbuf_t * reply_buf;
c = evhtp_request_get_connection(request);
request->finished = 1;
if (!(reply_buf = _evhtp_create_reply(request, code))) {
return evhtp_connection_free(request->conn);
}
bufferevent_write_buffer(evhtp_connection_get_bev(c), reply_buf);
evbuffer_free(reply_buf);
}
int
evhtp_response_needs_body(const evhtp_res code, const htp_method method) {
return code != EVHTP_RES_NOCONTENT &&
code != EVHTP_RES_NOTMOD &&
(code < 100 || code >= 200) &&
method != htp_method_HEAD;
}
void
evhtp_send_reply_chunk_start(evhtp_request_t * request, evhtp_res code) {
evhtp_header_t * content_len;
if (evhtp_response_needs_body(code, request->method)) {
content_len = evhtp_headers_find_header(request->headers_out, "Content-Length");
switch (request->proto) {
case EVHTP_PROTO_11:
/*
* prefer HTTP/1.1 chunked encoding to closing the connection;
* note RFC 2616 section 4.4 forbids it with Content-Length:
* and it's not necessary then anyway.
*/
evhtp_kv_rm_and_free(request->headers_out, content_len);
request->chunked = 1;
break;
case EVHTP_PROTO_10:
/*
* HTTP/1.0 can be chunked as long as the Content-Length header
* is set to 0
*/
evhtp_kv_rm_and_free(request->headers_out, content_len);
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Content-Length", "0", 0, 0));
request->chunked = 1;
break;
default:
request->chunked = 0;
break;
} /* switch */
} else {
request->chunked = 0;
}
if (request->chunked == 1) {
evhtp_headers_add_header(request->headers_out,
evhtp_header_new("Transfer-Encoding", "chunked", 0, 0));
/*
* if data already exists on the output buffer, we automagically convert
* it to the first chunk.
*/
if (evbuffer_get_length(request->buffer_out) > 0) {
char lstr[128];
int sres;
sres = snprintf(lstr, sizeof(lstr), "%x\r\n",
(unsigned)evbuffer_get_length(request->buffer_out));
if (sres >= sizeof(lstr) || sres < 0) {
/* overflow condition, shouldn't ever get here, but lets
* terminate the connection asap */
goto end;
}
evbuffer_prepend(request->buffer_out, lstr, strlen(lstr));
evbuffer_add(request->buffer_out, "\r\n", 2);
}
}
end:
evhtp_send_reply_start(request, code);
} /* evhtp_send_reply_chunk_start */
void
evhtp_send_reply_chunk(evhtp_request_t * request, evbuf_t * buf) {
evbuf_t * output;
output = bufferevent_get_output(request->conn->bev);
if (evbuffer_get_length(buf) == 0) {
return;
}
if (request->chunked) {
evbuffer_add_printf(output, "%x\r\n",
(unsigned)evbuffer_get_length(buf));
}
evhtp_send_reply_body(request, buf);
if (request->chunked) {
evbuffer_add(output, "\r\n", 2);
}
bufferevent_flush(request->conn->bev, EV_WRITE, BEV_FLUSH);
}
void
evhtp_send_reply_chunk_end(evhtp_request_t * request) {
if (request->chunked) {
evbuffer_add(bufferevent_get_output(evhtp_request_get_bev(request)),
"0\r\n\r\n", 5);
}
evhtp_send_reply_end(request);
}
int
evhtp_bind_sockaddr(evhtp_t * htp, struct sockaddr * sa, size_t sin_len, int backlog) {
signal(SIGPIPE, SIG_IGN);
htp->server = evconnlistener_new_bind(htp->evbase, _evhtp_accept_cb, (void *)htp,
LEV_OPT_THREADSAFE | LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
backlog, sa, sin_len);
return htp->server ? 0 : -1;
}
int
evhtp_bind_socket(evhtp_t * htp, const char * baddr, uint16_t port, int backlog) {
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
#ifndef NO_SYS_UN
struct sockaddr_un sun;
#endif
struct sockaddr * sa;
size_t sin_len;
memset(&sin, 0, sizeof(sin));
if (!strncmp(baddr, "ipv6:", 5)) {
memset(&sin6, 0, sizeof(sin6));
baddr += 5;
sin_len = sizeof(struct sockaddr_in6);
sin6.sin6_port = htons(port);
sin6.sin6_family = AF_INET6;
evutil_inet_pton(AF_INET6, baddr, &sin6.sin6_addr);
sa = (struct sockaddr *)&sin6;
} else if (!strncmp(baddr, "unix:", 5)) {
#ifndef NO_SYS_UN
baddr += 5;
if (strlen(baddr) >= sizeof(sun.sun_path)) {
return -1;
}
memset(&sun, 0, sizeof(sun));
sin_len = sizeof(struct sockaddr_un);
sun.sun_family = AF_UNIX;
strncpy(sun.sun_path, baddr, strlen(baddr));
sa = (struct sockaddr *)&sun;
#else
fprintf(stderr, "System does not support AF_UNIX sockets\n");
return -1;
#endif
} else {
if (!strncmp(baddr, "ipv4:", 5)) {
baddr += 5;
}
sin_len = sizeof(struct sockaddr_in);
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sin.sin_addr.s_addr = inet_addr(baddr);
sa = (struct sockaddr *)&sin;
}
return evhtp_bind_sockaddr(htp, sa, sin_len, backlog);
} /* evhtp_bind_socket */
evhtp_callbacks_t *
evhtp_callbacks_new(unsigned int buckets) {
evhtp_callbacks_t * cbs;
if (!(cbs = calloc(sizeof(evhtp_callbacks_t), 1))) {
return NULL;
}
if (!(cbs->callbacks = calloc(sizeof(evhtp_callback_t *), buckets))) {
free(cbs);
return NULL;
}
cbs->buckets = buckets;
cbs->count = 0;
return cbs;
}
void
evhtp_callbacks_free(evhtp_callbacks_t * callbacks) {
evhtp_callback_t * callback;
evhtp_callback_t * next;
unsigned int idx;
if (callbacks == NULL) {
return;
}
if (callbacks->callbacks) {
for (idx = 0; idx < callbacks->buckets; idx++) {
if (callbacks->callbacks[idx] == NULL) {
continue;
}
callback = callbacks->callbacks[idx];
while (callback != NULL) {
next = callback->next;
evhtp_callback_free(callback);
callback = next;
}
}
free(callbacks->callbacks);
}
#ifndef EVHTP_DISABLE_REGEX
callback = callbacks->regex_callbacks;
while (callback != NULL) {
next = callback->next;
evhtp_callback_free(callback);
callback = next;
}
#endif
free(callbacks);
}
evhtp_callback_t *
evhtp_callback_new(const char * path, evhtp_callback_type type, evhtp_callback_cb cb, void * arg) {
evhtp_callback_t * hcb;
if (!(hcb = calloc(sizeof(evhtp_callback_t), 1))) {
return NULL;
}
hcb->type = type;
hcb->cb = cb;
hcb->cbarg = arg;
switch (type) {
case evhtp_callback_type_hash:
hcb->hash = _evhtp_quick_hash(path);
hcb->val.path = strdup(path);
break;
#ifndef EVHTP_DISABLE_REGEX
case evhtp_callback_type_regex:
hcb->val.regex = malloc(sizeof(regex_t));
if (regcomp(hcb->val.regex, (char *)path, REG_EXTENDED) != 0) {
free(hcb->val.regex);
free(hcb);
return NULL;
}
break;
#endif
default:
free(hcb);
return NULL;
}
return hcb;
}
void
evhtp_callback_free(evhtp_callback_t * callback) {
if (callback == NULL) {
return;
}
switch (callback->type) {
case evhtp_callback_type_hash:
if (callback->val.path) {
free(callback->val.path);
}
break;
#ifndef EVHTP_DISABLE_REGEX
case evhtp_callback_type_regex:
if (callback->val.regex) {
regfree(callback->val.regex);
}
break;
#endif
}
free(callback);
return;
}
int
evhtp_callbacks_add_callback(evhtp_callbacks_t * cbs, evhtp_callback_t * cb) {
unsigned int hkey;
switch (cb->type) {
case evhtp_callback_type_hash:
hkey = cb->hash & (cbs->buckets - 1);
if (cbs->callbacks[hkey] == NULL) {
cbs->callbacks[hkey] = cb;
} else {
cb->next = cbs->callbacks[hkey];
cbs->callbacks[hkey] = cb;
}
break;
#ifndef EVHTP_DISABLE_REGEX
case evhtp_callback_type_regex:
cb->next = cbs->regex_callbacks;
cbs->regex_callbacks = cb;
break;
#endif
default:
return -1;
}
return 0;
}
int
evhtp_set_hook(evhtp_hooks_t ** hooks, evhtp_hook_type type, void * cb, void * arg) {
if (*hooks == NULL) {
if (!(*hooks = calloc(sizeof(evhtp_hooks_t), 1))) {
return -1;
}
}
switch (type) {
case evhtp_hook_on_headers_start:
(*hooks)->on_headers_start = (evhtp_hook_headers_start_cb)cb;
(*hooks)->on_headers_start_arg = arg;
break;
case evhtp_hook_on_header:
(*hooks)->on_header = (evhtp_hook_header_cb)cb;
(*hooks)->on_header_arg = arg;
break;
case evhtp_hook_on_headers:
(*hooks)->on_headers = (evhtp_hook_headers_cb)cb;
(*hooks)->on_headers_arg = arg;
break;
case evhtp_hook_on_path:
(*hooks)->on_path = (evhtp_hook_path_cb)cb;
(*hooks)->on_path_arg = arg;
break;
case evhtp_hook_on_read:
(*hooks)->on_read = (evhtp_hook_read_cb)cb;
(*hooks)->on_read_arg = arg;
break;
case evhtp_hook_on_request_fini:
(*hooks)->on_request_fini = (evhtp_hook_request_fini_cb)cb;
(*hooks)->on_request_fini_arg = arg;
break;
case evhtp_hook_on_connection_fini:
(*hooks)->on_connection_fini = (evhtp_hook_connection_fini_cb)cb;
(*hooks)->on_connection_fini_arg = arg;
break;
case evhtp_hook_on_error:
(*hooks)->on_error = (evhtp_hook_err_cb)cb;
(*hooks)->on_error_arg = arg;
break;
case evhtp_hook_on_new_chunk:
(*hooks)->on_new_chunk = (evhtp_hook_chunk_new_cb)cb;
(*hooks)->on_new_chunk_arg = arg;
break;
case evhtp_hook_on_chunk_complete:
(*hooks)->on_chunk_fini = (evhtp_hook_chunk_fini_cb)cb;
(*hooks)->on_chunk_fini_arg = arg;
break;
case evhtp_hook_on_chunks_complete:
(*hooks)->on_chunks_fini = (evhtp_hook_chunks_fini_cb)cb;
(*hooks)->on_chunks_fini_arg = arg;
break;
default:
return -1;
} /* switch */
return 0;
} /* evhtp_set_hook */
int
evhtp_unset_hook(evhtp_hooks_t ** hooks, evhtp_hook_type type) {
return evhtp_set_hook(hooks, type, NULL, NULL);
}
int
evhtp_unset_all_hooks(evhtp_hooks_t ** hooks) {
int res = 0;
if (evhtp_unset_hook(hooks, evhtp_hook_on_headers_start)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_header)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_headers)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_path)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_read)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_request_fini)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_connection_fini)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_error)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_new_chunk)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_chunk_complete)) {
res -= 1;
}
if (evhtp_unset_hook(hooks, evhtp_hook_on_chunks_complete)) {
res -= 1;
}
return res;
} /* evhtp_unset_all_hooks */
evhtp_callback_t *
evhtp_set_cb(evhtp_t * htp, const char * path, evhtp_callback_cb cb, void * arg) {
evhtp_callback_t * hcb;
_evhtp_lock(htp);
if (htp->callbacks == NULL) {
if (!(htp->callbacks = evhtp_callbacks_new(1024))) {
_evhtp_unlock(htp);
return NULL;
}
}
if (!(hcb = evhtp_callback_new(path, evhtp_callback_type_hash, cb, arg))) {
_evhtp_unlock(htp);
return NULL;
}
if (evhtp_callbacks_add_callback(htp->callbacks, hcb)) {
evhtp_callback_free(hcb);
_evhtp_unlock(htp);
return NULL;
}
_evhtp_unlock(htp);
return hcb;
}
#ifndef EVHTP_DISABLE_EVTHR
static void
_evhtp_thread_init(evthr_t * thr, void * arg) {
evhtp_t * htp = (evhtp_t *)arg;
if (htp->thread_init_cb) {
htp->thread_init_cb(htp, thr, htp->thread_init_cbarg);
}
}
int
evhtp_use_threads(evhtp_t * htp, evhtp_thread_init_cb init_cb, int nthreads, void * arg) {
htp->thread_init_cb = init_cb;
htp->thread_init_cbarg = arg;
#ifndef DISABLE_SSL
evhtp_ssl_use_threads();
#endif
if (!(htp->thr_pool = evthr_pool_new(nthreads, _evhtp_thread_init, htp))) {
return -1;
}
evthr_pool_start(htp->thr_pool);
return 0;
}
#endif
#ifndef EVHTP_DISABLE_EVTHR
int
evhtp_use_callback_locks(evhtp_t * htp) {
if (htp == NULL) {
return -1;
}
if (!(htp->lock = malloc(sizeof(pthread_mutex_t)))) {
return -1;
}
return pthread_mutex_init(htp->lock, NULL);
}
#endif
#ifndef EVHTP_DISABLE_REGEX
evhtp_callback_t *
evhtp_set_regex_cb(evhtp_t * htp, const char * pattern, evhtp_callback_cb cb, void * arg) {
evhtp_callback_t * hcb;
_evhtp_lock(htp);
if (htp->callbacks == NULL) {
if (!(htp->callbacks = evhtp_callbacks_new(1024))) {
_evhtp_unlock(htp);
return NULL;
}
}
if (!(hcb = evhtp_callback_new(pattern, evhtp_callback_type_regex, cb, arg))) {
_evhtp_unlock(htp);
return NULL;
}
if (evhtp_callbacks_add_callback(htp->callbacks, hcb)) {
evhtp_callback_free(hcb);
_evhtp_unlock(htp);
return NULL;
}
_evhtp_unlock(htp);
return hcb;
}
#endif
void
evhtp_set_gencb(evhtp_t * htp, evhtp_callback_cb cb, void * arg) {
htp->defaults.cb = cb;
htp->defaults.cbarg = arg;
}
void
evhtp_set_pre_accept_cb(evhtp_t * htp, evhtp_pre_accept_cb cb, void * arg) {
htp->defaults.pre_accept = cb;
htp->defaults.pre_accept_cbarg = arg;
}
void
evhtp_set_post_accept_cb(evhtp_t * htp, evhtp_post_accept_cb cb, void * arg) {
htp->defaults.post_accept = cb;
htp->defaults.post_accept_cbarg = arg;
}
#ifndef DISABLE_SSL
#ifndef EVHTP_DISABLE_EVTHR
int
evhtp_ssl_use_threads(void) {
int i;
if (ssl_locks_initialized == 1) {
return 0;
}
ssl_locks_initialized = 1;
ssl_num_locks = CRYPTO_num_locks();
ssl_locks = malloc(ssl_num_locks * sizeof(evhtp_mutex_t));
for (i = 0; i < ssl_num_locks; i++) {
pthread_mutex_init(&(ssl_locks[i]), NULL);
}
CRYPTO_set_id_callback(_evhtp_ssl_get_thread_id);
CRYPTO_set_locking_callback(_evhtp_ssl_thread_lock);
return 0;
}
#endif
int
evhtp_ssl_init(evhtp_t * htp, evhtp_ssl_cfg_t * cfg) {
long cache_mode;
evhtp_ssl_scache_init init_cb = NULL;
evhtp_ssl_scache_add add_cb = NULL;
evhtp_ssl_scache_get get_cb = NULL;
evhtp_ssl_scache_del del_cb = NULL;
if (cfg == NULL || htp == NULL || cfg->pemfile == NULL) {
return -1;
}
SSL_library_init();
SSL_load_error_strings();
RAND_poll();
STACK_OF(SSL_COMP) * comp_methods = SSL_COMP_get_compression_methods();
sk_SSL_COMP_zero(comp_methods);
htp->ssl_cfg = cfg;
htp->ssl_ctx = SSL_CTX_new(SSLv23_server_method());
#if OPENSSL_VERSION_NUMBER >= 0x10000000L
SSL_CTX_set_options(htp->ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
/* SSL_CTX_set_options(htp->ssl_ctx, SSL_MODE_AUTO_RETRY); */
SSL_CTX_set_timeout(htp->ssl_ctx, cfg->ssl_ctx_timeout);
#endif
SSL_CTX_set_options(htp->ssl_ctx, cfg->ssl_opts);
if (cfg->ciphers != NULL) {
SSL_CTX_set_cipher_list(htp->ssl_ctx, cfg->ciphers);
}
SSL_CTX_load_verify_locations(htp->ssl_ctx, cfg->cafile, cfg->capath);
X509_STORE_set_flags(SSL_CTX_get_cert_store(htp->ssl_ctx), cfg->store_flags);
SSL_CTX_set_verify(htp->ssl_ctx, cfg->verify_peer, cfg->x509_verify_cb);
if (cfg->x509_chk_issued_cb != NULL) {
htp->ssl_ctx->cert_store->check_issued = cfg->x509_chk_issued_cb;
}
if (cfg->verify_depth) {
SSL_CTX_set_verify_depth(htp->ssl_ctx, cfg->verify_depth);
}
switch (cfg->scache_type) {
case evhtp_ssl_scache_type_disabled:
cache_mode = SSL_SESS_CACHE_OFF;
break;
case evhtp_ssl_scache_type_user:
cache_mode = SSL_SESS_CACHE_SERVER |
SSL_SESS_CACHE_NO_INTERNAL |
SSL_SESS_CACHE_NO_INTERNAL_LOOKUP;
init_cb = cfg->scache_init;
add_cb = cfg->scache_add;
get_cb = cfg->scache_get;
del_cb = cfg->scache_del;
break;
case evhtp_ssl_scache_type_builtin:
cache_mode = SSL_SESS_CACHE_SERVER |
SSL_SESS_CACHE_NO_INTERNAL |
SSL_SESS_CACHE_NO_INTERNAL_LOOKUP;
#if 0
init_cb = _evhtp_ssl_builtin_init;
add_cb = _evhtp_ssl_builtin_add;
get_cb = _evhtp_ssl_builtin_get;
del_cb = _evhtp_ssl_builtin_del;
#endif
break;
case evhtp_ssl_scache_type_internal:
default:
cache_mode = SSL_SESS_CACHE_SERVER;
break;
} /* switch */
SSL_CTX_use_certificate_file(htp->ssl_ctx, cfg->pemfile, SSL_FILETYPE_PEM);
SSL_CTX_use_PrivateKey_file(htp->ssl_ctx, cfg->privfile ? : cfg->pemfile, SSL_FILETYPE_PEM);
SSL_CTX_set_session_id_context(htp->ssl_ctx,
(void*)&session_id_context,
sizeof(session_id_context));
SSL_CTX_set_app_data(htp->ssl_ctx, htp);
SSL_CTX_set_session_cache_mode(htp->ssl_ctx, cache_mode);
if (cache_mode != SSL_SESS_CACHE_OFF) {
SSL_CTX_sess_set_cache_size(htp->ssl_ctx,
cfg->scache_size ? cfg->scache_size : 1024);
if (cfg->scache_type == evhtp_ssl_scache_type_builtin ||
cfg->scache_type == evhtp_ssl_scache_type_user) {
SSL_CTX_sess_set_new_cb(htp->ssl_ctx, _evhtp_ssl_add_scache_ent);
SSL_CTX_sess_set_get_cb(htp->ssl_ctx, _evhtp_ssl_get_scache_ent);
SSL_CTX_sess_set_remove_cb(htp->ssl_ctx, _evhtp_ssl_delete_scache_ent);
if (cfg->scache_init) {
cfg->args = (cfg->scache_init)(htp);
}
}
}
return 0;
} /* evhtp_use_ssl */
#endif
evbev_t *
evhtp_connection_get_bev(evhtp_connection_t * connection) {
return connection->bev;
}
evbev_t *
evhtp_connection_take_ownership(evhtp_connection_t * connection) {
evbev_t * bev = evhtp_connection_get_bev(connection);
if (connection->hooks) {
evhtp_unset_all_hooks(&connection->hooks);
}
if (connection->request && connection->request->hooks) {
evhtp_unset_all_hooks(&connection->request->hooks);
}
evhtp_connection_set_bev(connection, NULL);
connection->owner = 0;
bufferevent_disable(bev, EV_READ);
bufferevent_setcb(bev, NULL, NULL, NULL, NULL);
return bev;
}
evbev_t *
evhtp_request_get_bev(evhtp_request_t * request) {
return evhtp_connection_get_bev(request->conn);
}
evbev_t *
evhtp_request_take_ownership(evhtp_request_t * request) {
return evhtp_connection_take_ownership(evhtp_request_get_connection(request));
}
void
evhtp_connection_set_bev(evhtp_connection_t * conn, evbev_t * bev) {
conn->bev = bev;
}
void
evhtp_request_set_bev(evhtp_request_t * request, evbev_t * bev) {
return evhtp_connection_set_bev(request->conn, bev);
}
evhtp_connection_t *
evhtp_request_get_connection(evhtp_request_t * request) {
return request->conn;
}
void
evhtp_connection_free(evhtp_connection_t * connection) {
if (connection == NULL) {
printf("connection == NULL????\n");
return;
}
_evhtp_request_free(connection->request);
_evhtp_connection_fini_hook(connection);
if (connection->parser) {
free(connection->parser);
}
if (connection->resume_ev) {
event_free(connection->resume_ev);
}
if (connection->bev) {
#ifdef LIBEVENT_HAS_SHUTDOWN
bufferevent_shutdown(connection->bev, _evhtp_shutdown_eventcb);
#else
#ifndef DISABLE_SSL
if (connection->ssl != NULL) {
SSL_set_shutdown(connection->ssl, SSL_RECEIVED_SHUTDOWN);
SSL_shutdown(connection->ssl);
}
#endif
bufferevent_free(connection->bev);
#endif
}
if (connection->hooks) {
free(connection->hooks);
}
#ifndef EVHTP_DISABLE_EVTHR
if (connection->thread) {
evthr_dec_backlog(connection->thread);
}
#endif
if (connection->saddr) {
free(connection->saddr);
}
free(connection);
} /* evhtp_connection_free */
void
evhtp_set_timeouts(evhtp_t * htp, struct timeval * r_timeo, struct timeval * w_timeo) {
if (r_timeo != NULL) {
htp->recv_timeo = malloc(sizeof(struct timeval));
memcpy(htp->recv_timeo, r_timeo, sizeof(struct timeval));
}
if (w_timeo != NULL) {
htp->send_timeo = malloc(sizeof(struct timeval));
memcpy(htp->send_timeo, w_timeo, sizeof(struct timeval));
}
}
void
evhtp_set_bev_flags(evhtp_t * htp, int flags) {
htp->bev_flags = flags;
}
evhtp_t *
evhtp_new(evbase_t * evbase, void * arg) {
evhtp_t * htp;
if (evbase == NULL) {
return NULL;
}
if (!(htp = calloc(sizeof(evhtp_t), 1))) {
return NULL;
}
status_code_init();
htp->arg = arg;
htp->evbase = evbase;
htp->server_name = "evhtp, sucka";
htp->bev_flags = BEV_OPT_CLOSE_ON_FREE;
evhtp_set_gencb(htp, _evhtp_default_request_cb, (void *)htp);
return htp;
}