blob: 835164b550a5860164169816ff6d6844d7f1982c [file] [log] [blame]
#include <evhtp-config.h>
#ifndef __EVHTP__H__
#define __EVHTP__H__
/** @file */
#ifndef EVHTP_DISABLE_EVTHR
#include <evthr.h>
#endif
#include <htparse.h>
#ifndef EVHTP_DISABLE_REGEX
#include <onigposix.h>
#endif
#include <sys/queue.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>
#ifndef EVHTP_DISABLE_SSL
#include <event2/bufferevent_ssl.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/rand.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef EVHTP_DEBUG
#define __QUOTE(x) # x
#define _QUOTE(x) __QUOTE(x)
#define htp_debug_strlen(x) strlen(x)
#define htp_log_debug(fmt, ...) do { \
time_t t = time(NULL); \
struct tm * dm = localtime(&t); \
\
fprintf(stdout, "[%02d:%02d:%02d] evhtp.c:[" _QUOTE(__LINE__) "]\t %-26s: " \
fmt "\n", dm->tm_hour, dm->tm_min, dm->tm_sec, __func__, ## __VA_ARGS__); \
fflush(stdout); \
} while (0)
#else
#define htp_debug_strlen(x) 0
#define htp_log_debug(fmt, ...) do { \
} while (0)
#endif
struct evhtp_callback_s;
struct evhtp_callbacks_s;
#ifndef EVHTP_DISABLE_SSL
typedef SSL_SESSION evhtp_ssl_sess_t;
typedef SSL evhtp_ssl_t;
typedef SSL_CTX evhtp_ssl_ctx_t;
typedef X509 evhtp_x509_t;
typedef X509_STORE_CTX evhtp_x509_store_ctx_t;
#else
typedef void evhtp_ssl_sess_t;
typedef void evhtp_ssl_t;
typedef void evhtp_ssl_ctx_t;
typedef void evhtp_x509_t;
typedef void evhtp_x509_store_ctx_t;
#endif
typedef struct evbuffer evbuf_t;
typedef struct event event_t;
typedef struct evconnlistener evserv_t;
typedef struct bufferevent evbev_t;
#ifdef EVHTP_DISABLE_EVTHR
typedef struct event_base evbase_t;
typedef void evthr_t;
typedef void evthr_pool_t;
typedef void evhtp_mutex_t;
#else
typedef pthread_mutex_t evhtp_mutex_t;
#endif
typedef struct evhtp_s evhtp_t;
typedef struct evhtp_defaults_s evhtp_defaults_t;
typedef struct evhtp_callbacks_s evhtp_callbacks_t;
typedef struct evhtp_callback_s evhtp_callback_t;
typedef struct evhtp_defaults_s evhtp_defaults_5;
typedef struct evhtp_kv_s evhtp_kv_t;
typedef struct evhtp_kvs_s evhtp_kvs_t;
typedef struct evhtp_uri_s evhtp_uri_t;
typedef struct evhtp_path_s evhtp_path_t;
typedef struct evhtp_authority_s evhtp_authority_t;
typedef struct evhtp_request_s evhtp_request_t;
typedef struct evhtp_hooks_s evhtp_hooks_t;
typedef struct evhtp_connection_s evhtp_connection_t;
typedef struct evhtp_ssl_cfg_s evhtp_ssl_cfg_t;
typedef struct evhtp_alias_s evhtp_alias_t;
typedef uint16_t evhtp_res;
typedef uint8_t evhtp_error_flags;
#define evhtp_header_s evhtp_kv_s
#define evhtp_headers_s evhtp_kvs_s
#define evhtp_query_s evhtp_kvs_s
#define evhtp_header_t evhtp_kv_t
#define evhtp_headers_t evhtp_kvs_t
#define evhtp_query_t evhtp_kvs_t
enum evhtp_ssl_scache_type {
evhtp_ssl_scache_type_disabled = 0,
evhtp_ssl_scache_type_internal,
evhtp_ssl_scache_type_user,
evhtp_ssl_scache_type_builtin
};
/**
* @brief types associated with where a developer can hook into
* during the request processing cycle.
*/
enum evhtp_hook_type {
evhtp_hook_on_header, /**< type which defines to hook after one header has been parsed */
evhtp_hook_on_headers, /**< type which defines to hook after all headers have been parsed */
evhtp_hook_on_path, /**< type which defines to hook once a path has been parsed */
evhtp_hook_on_read, /**< type which defines to hook whenever the parser recieves data in a body */
evhtp_hook_on_request_fini, /**< type which defines to hook before the request is free'd */
evhtp_hook_on_connection_fini,
evhtp_hook_on_new_chunk,
evhtp_hook_on_chunk_complete,
evhtp_hook_on_chunks_complete,
evhtp_hook_on_headers_start,
evhtp_hook_on_error, /**< type which defines to hook whenever an error occurs */
evhtp_hook_on_hostname,
evhtp_hook_on_write,
evhtp_hook_on_event,
evhtp_hook_on_conn_error, /**< type which defines to hook whenever a connection error occurs */
};
enum evhtp_callback_type {
evhtp_callback_type_hash,
evhtp_callback_type_glob,
#ifndef EVHTP_DISABLE_REGEX
evhtp_callback_type_regex,
#endif
};
enum evhtp_proto {
EVHTP_PROTO_INVALID,
EVHTP_PROTO_10,
EVHTP_PROTO_11
};
enum evhtp_type {
evhtp_type_client,
evhtp_type_server
};
typedef enum evhtp_hook_type evhtp_hook_type;
typedef enum evhtp_callback_type evhtp_callback_type;
typedef enum evhtp_proto evhtp_proto;
typedef enum evhtp_ssl_scache_type evhtp_ssl_scache_type;
typedef enum evhtp_type evhtp_type;
typedef void (* evhtp_thread_init_cb)(evhtp_t * htp, evthr_t * thr, void * arg);
typedef void (* evhtp_thread_exit_cb)(evhtp_t * htp, evthr_t * thr, void * arg);
typedef void (* evhtp_callback_cb)(evhtp_request_t * req, void * arg);
typedef void (* evhtp_hook_err_cb)(evhtp_request_t * req, evhtp_error_flags errtype, void * arg);
typedef void (* evhtp_hook_event_cb)(evhtp_connection_t * conn, short events, void * arg);
/* Generic hook for passing ISO tests */
typedef evhtp_res (* evhtp_hook)();
typedef evhtp_res (* evhtp_hook_conn_err_cb)(evhtp_connection_t * connection, evhtp_error_flags errtype, void * arg);
typedef evhtp_res (* evhtp_pre_accept_cb)(evhtp_connection_t * conn, void * arg);
typedef evhtp_res (* evhtp_post_accept_cb)(evhtp_connection_t * conn, void * arg);
typedef evhtp_res (* evhtp_hook_header_cb)(evhtp_request_t * req, evhtp_header_t * hdr, void * arg);
typedef evhtp_res (* evhtp_hook_headers_cb)(evhtp_request_t * req, evhtp_headers_t * hdr, void * arg);
typedef evhtp_res (* evhtp_hook_path_cb)(evhtp_request_t * req, evhtp_path_t * path, void * arg);
typedef evhtp_res (* evhtp_hook_read_cb)(evhtp_request_t * req, evbuf_t * buf, void * arg);
typedef evhtp_res (* evhtp_hook_request_fini_cb)(evhtp_request_t * req, void * arg);
typedef evhtp_res (* evhtp_hook_connection_fini_cb)(evhtp_connection_t * connection, void * arg);
typedef evhtp_res (* evhtp_hook_chunk_new_cb)(evhtp_request_t * r, uint64_t len, void * arg);
typedef evhtp_res (* evhtp_hook_chunk_fini_cb)(evhtp_request_t * r, void * arg);
typedef evhtp_res (* evhtp_hook_chunks_fini_cb)(evhtp_request_t * r, void * arg);
typedef evhtp_res (* evhtp_hook_headers_start_cb)(evhtp_request_t * r, void * arg);
typedef evhtp_res (* evhtp_hook_hostname_cb)(evhtp_request_t * r, const char * hostname, void * arg);
typedef evhtp_res (* evhtp_hook_write_cb)(evhtp_connection_t * conn, void * arg);
typedef int (* evhtp_kvs_iterator)(evhtp_kv_t * kv, void * arg);
typedef int (* evhtp_headers_iterator)(evhtp_header_t * header, void * arg);
#ifndef EVHTP_DISABLE_SSL
typedef int (* evhtp_ssl_verify_cb)(int pre_verify, evhtp_x509_store_ctx_t * ctx);
typedef int (* evhtp_ssl_chk_issued_cb)(evhtp_x509_store_ctx_t * ctx, evhtp_x509_t * x, evhtp_x509_t * issuer);
typedef EVP_PKEY * (* evhtp_ssl_decrypt_cb)(char * privfile);
typedef int (* evhtp_ssl_scache_add)(evhtp_connection_t * connection, unsigned char * sid, int sid_len, evhtp_ssl_sess_t * sess);
typedef void (* evhtp_ssl_scache_del)(evhtp_t * htp, unsigned char * sid, int sid_len);
typedef evhtp_ssl_sess_t * (* evhtp_ssl_scache_get)(evhtp_connection_t * connection, unsigned char * sid, int sid_len);
typedef void * (* evhtp_ssl_scache_init)(evhtp_t *);
#endif
#define EVHTP_VERSION "1.2.12-pre3"
#define EVHTP_VERSION_MAJOR 1
#define EVHTP_VERSION_MINOR 2
#define EVHTP_VERSION_PATCH 12
#define evhtp_headers_iterator evhtp_kvs_iterator
#define EVHTP_RES_ERROR 0
#define EVHTP_RES_PAUSE 1
#define EVHTP_RES_FATAL 2
#define EVHTP_RES_USER 3
#define EVHTP_RES_DATA_TOO_LONG 4
#define EVHTP_RES_OK 200
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define EVHTP_RES_100 100
#define EVHTP_RES_CONTINUE 100
#define EVHTP_RES_SWITCH_PROTO 101
#define EVHTP_RES_PROCESSING 102
#define EVHTP_RES_URI_TOOLONG 122
#define EVHTP_RES_200 200
#define EVHTP_RES_CREATED 201
#define EVHTP_RES_ACCEPTED 202
#define EVHTP_RES_NAUTHINFO 203
#define EVHTP_RES_NOCONTENT 204
#define EVHTP_RES_RSTCONTENT 205
#define EVHTP_RES_PARTIAL 206
#define EVHTP_RES_MSTATUS 207
#define EVHTP_RES_IMUSED 226
#define EVHTP_RES_300 300
#define EVHTP_RES_MCHOICE 300
#define EVHTP_RES_MOVEDPERM 301
#define EVHTP_RES_FOUND 302
#define EVHTP_RES_SEEOTHER 303
#define EVHTP_RES_NOTMOD 304
#define EVHTP_RES_USEPROXY 305
#define EVHTP_RES_SWITCHPROXY 306
#define EVHTP_RES_TMPREDIR 307
#define EVHTP_RES_400 400
#define EVHTP_RES_BADREQ 400
#define EVHTP_RES_UNAUTH 401
#define EVHTP_RES_PAYREQ 402
#define EVHTP_RES_FORBIDDEN 403
#define EVHTP_RES_NOTFOUND 404
#define EVHTP_RES_METHNALLOWED 405
#define EVHTP_RES_NACCEPTABLE 406
#define EVHTP_RES_PROXYAUTHREQ 407
#define EVHTP_RES_TIMEOUT 408
#define EVHTP_RES_CONFLICT 409
#define EVHTP_RES_GONE 410
#define EVHTP_RES_LENREQ 411
#define EVHTP_RES_PRECONDFAIL 412
#define EVHTP_RES_ENTOOLARGE 413
#define EVHTP_RES_URITOOLARGE 414
#define EVHTP_RES_UNSUPPORTED 415
#define EVHTP_RES_RANGENOTSC 416
#define EVHTP_RES_EXPECTFAIL 417
#define EVHTP_RES_IAMATEAPOT 418
#define EVHTP_RES_500 500
#define EVHTP_RES_SERVERR 500
#define EVHTP_RES_NOTIMPL 501
#define EVHTP_RES_BADGATEWAY 502
#define EVHTP_RES_SERVUNAVAIL 503
#define EVHTP_RES_GWTIMEOUT 504
#define EVHTP_RES_VERNSUPPORT 505
#define EVHTP_RES_BWEXEED 509
#endif
struct evhtp_defaults_s {
evhtp_callback_cb cb;
evhtp_pre_accept_cb pre_accept;
evhtp_post_accept_cb post_accept;
void * cbarg;
void * pre_accept_cbarg;
void * post_accept_cbarg;
};
struct evhtp_alias_s {
char * alias;
TAILQ_ENTRY(evhtp_alias_s) next;
};
/**
* @ingroup evhtp_core
* @brief main structure containing all configuration information
*/
struct evhtp_s {
evhtp_t * parent; /**< only when this is a vhost */
evbase_t * evbase; /**< the initialized event_base */
evserv_t * server; /**< the libevent listener struct */
char * server_name; /**< the name included in Host: responses */
void * arg; /**< user-defined evhtp_t specific arguments */
int bev_flags; /**< bufferevent flags to use on bufferevent_*_socket_new() */
uint64_t max_body_size;
uint64_t max_keepalive_requests;
#define EVHTP_FLAG_ENABLE_100_CONT (1 << 1)
#define EVHTP_FLAG_ENABLE_REUSEPORT (1 << 2)
#define EVHTP_FLAG_ENABLE_NODELAY (1 << 3)
#define EVHTP_FLAG_ENABLE_DEFER_ACCEPT (1 << 4)
#define EVHTP_FLAG_DEFAULTS EVHTP_FLAG_ENABLE_100_CONT
uint16_t flags; /**< the base flags set for this context, see: EVHTP_FLAG_* */
uint16_t parser_flags; /**< default query flags to alter 'strictness' (see EVHTP_PARSE_QUERY_FLAG_*) */
#ifndef EVHTP_DISABLE_SSL
evhtp_ssl_ctx_t * ssl_ctx; /**< if ssl enabled, this is the servers CTX */
evhtp_ssl_cfg_t * ssl_cfg;
#endif
#ifndef EVHTP_DISABLE_EVTHR
evthr_pool_t * thr_pool; /**< connection threadpool */
pthread_mutex_t * lock; /**< parent lock for add/del cbs in threads */
evhtp_thread_init_cb thread_init_cb;
evhtp_thread_exit_cb thread_exit_cb;
/* keep backwards compat because I'm dumb and didn't
* make these structs private
*/
#define thread_init_cbarg thread_cbarg
void * thread_cbarg;
#endif
evhtp_callbacks_t * callbacks;
evhtp_defaults_t defaults;
struct timeval recv_timeo;
struct timeval send_timeo;
TAILQ_HEAD(, evhtp_alias_s) aliases;
TAILQ_HEAD(, evhtp_s) vhosts;
TAILQ_ENTRY(evhtp_s) next_vhost;
};
/**
* @brief a generic key/value structure
*/
struct evhtp_kv_s {
char * key;
char * val;
size_t klen;
size_t vlen;
char k_heaped; /**< set to 1 if the key can be free()'d */
char v_heaped; /**< set to 1 if the val can be free()'d */
TAILQ_ENTRY(evhtp_kv_s) next;
};
TAILQ_HEAD(evhtp_kvs_s, evhtp_kv_s);
/**
* @brief a generic container representing an entire URI strucutre
*/
struct evhtp_uri_s {
evhtp_authority_t * authority;
evhtp_path_t * path;
unsigned char * fragment; /**< data after '#' in uri */
unsigned char * query_raw; /**< the unparsed query arguments */
evhtp_query_t * query; /**< list of k/v for query arguments */
htp_scheme scheme; /**< set if a scheme is found */
};
/**
* @brief structure which represents authority information in a URI
*/
struct evhtp_authority_s {
char * username; /**< the username in URI (scheme://USER:.. */
char * password; /**< the password in URI (scheme://...:PASS.. */
char * hostname; /**< hostname if present in URI */
uint16_t port; /**< port if present in URI */
};
/**
* @brief structure which represents a URI path and or file
*/
struct evhtp_path_s {
char * full; /**< the full path+file (/a/b/c.html) */
char * path; /**< the path (/a/b/) */
char * file; /**< the filename if present (c.html) */
char * match_start;
char * match_end;
unsigned int matched_soff; /**< offset of where the uri starts
* mainly used for regex matching
*/
unsigned int matched_eoff; /**< offset of where the uri ends
* mainly used for regex matching
*/
};
/**
* @brief a structure containing all information for a http request.
*/
struct evhtp_request_s {
evhtp_t * htp; /**< the parent evhtp_t structure */
evhtp_connection_t * conn; /**< the associated connection */
evhtp_hooks_t * hooks; /**< request specific hooks */
evhtp_uri_t * uri; /**< request URI information */
evbuf_t * buffer_in; /**< buffer containing data from client */
evbuf_t * buffer_out; /**< buffer containing data to client */
evhtp_headers_t * headers_in; /**< headers from client */
evhtp_headers_t * headers_out; /**< headers to client */
evhtp_proto proto; /**< HTTP protocol used */
htp_method method; /**< HTTP method used */
evhtp_res status; /**< The HTTP response code or other error conditions */
#define EVHTP_REQ_FLAG_KEEPALIVE (1 << 1)
#define EVHTP_REQ_FLAG_FINISHED (1 << 2)
#define EVHTP_REQ_FLAG_CHUNKED (1 << 3)
#define EVHTP_REQ_FLAG_ERROR (1 << 4)
uint16_t flags;
evhtp_callback_cb cb; /**< the function to call when fully processed */
void * cbarg; /**< argument which is passed to the cb function */
TAILQ_ENTRY(evhtp_request_s) next;
};
#define evhtp_request_content_len(r) htparser_get_content_length(r->conn->parser)
struct evhtp_connection_s {
evhtp_t * htp;
evbase_t * evbase;
evbev_t * bev;
#ifndef EVHTP_DISABLE_EVTHR
evthr_t * thread;
#endif
#ifndef EVHTP_DISABLE_SSL
evhtp_ssl_t * ssl;
#endif
evhtp_hooks_t * hooks;
htparser * parser;
event_t * resume_ev;
struct sockaddr * saddr;
struct timeval recv_timeo; /**< conn read timeouts (overrides global) */
struct timeval send_timeo; /**< conn write timeouts (overrides global) */
evutil_socket_t sock;
evhtp_request_t * request; /**< the request currently being processed */
uint64_t max_body_size;
uint64_t body_bytes_read;
uint64_t num_requests;
evhtp_type type; /**< server or client */
#define EVHTP_CONN_FLAG_ERROR (1 << 1)
#define EVHTP_CONN_FLAG_OWNER (1 << 2) /**< set to 1 if this structure owns the bufferevent */
#define EVHTP_CONN_FLAG_VHOST_VIA_SNI (1 << 3) /**< set to 1 if the vhost was found via SSL SNI */
#define EVHTP_CONN_FLAG_PAUSED (1 << 4) /**< this connection has been marked as paused */
#define EVHTP_CONN_FLAG_CONNECTED (1 << 5) /**< client specific - set after successful connection */
#define EVHTP_CONN_FLAG_WAITING (1 << 6) /**< used to make sure resuming happens AFTER sending a reply */
#define EVHTP_CONN_FLAG_FREE_CONN (1 << 7)
#define EVHTP_CONN_FLAG_KEEPALIVE (1 << 8) /**< set to 1 after the first request has been processed and the connection is kept open */
uint16_t flags;
struct evbuffer * scratch_buf; /**< always zero'd out after used */
#ifdef EVHTP_FUTURE_USE
TAILQ_HEAD(, evhtp_request_s) pending; /**< client pending data */
#endif
};
struct evhtp_hooks_s {
evhtp_hook_headers_start_cb on_headers_start;
evhtp_hook_header_cb on_header;
evhtp_hook_headers_cb on_headers;
evhtp_hook_path_cb on_path;
evhtp_hook_read_cb on_read;
evhtp_hook_request_fini_cb on_request_fini;
evhtp_hook_connection_fini_cb on_connection_fini;
evhtp_hook_conn_err_cb on_connection_error;
evhtp_hook_err_cb on_error;
evhtp_hook_chunk_new_cb on_new_chunk;
evhtp_hook_chunk_fini_cb on_chunk_fini;
evhtp_hook_chunks_fini_cb on_chunks_fini;
evhtp_hook_hostname_cb on_hostname;
evhtp_hook_write_cb on_write;
evhtp_hook_event_cb on_event;
void * on_headers_start_arg;
void * on_header_arg;
void * on_headers_arg;
void * on_path_arg;
void * on_read_arg;
void * on_request_fini_arg;
void * on_connection_fini_arg;
void * on_connection_error_arg;
void * on_error_arg;
void * on_new_chunk_arg;
void * on_chunk_fini_arg;
void * on_chunks_fini_arg;
void * on_hostname_arg;
void * on_write_arg;
void * on_event_arg;
};
#ifndef EVHTP_DISABLE_SSL
struct evhtp_ssl_cfg_s {
char * pemfile;
char * privfile;
char * cafile;
char * capath;
char * ciphers;
char * named_curve;
char * dhparams;
long ssl_opts;
long ssl_ctx_timeout;
int verify_peer;
int verify_depth;
evhtp_ssl_verify_cb x509_verify_cb;
evhtp_ssl_chk_issued_cb x509_chk_issued_cb;
evhtp_ssl_decrypt_cb decrypt_cb;
long store_flags;
evhtp_ssl_scache_type scache_type;
long scache_timeout;
long scache_size;
evhtp_ssl_scache_init scache_init;
evhtp_ssl_scache_add scache_add;
evhtp_ssl_scache_get scache_get;
evhtp_ssl_scache_del scache_del;
void * args;
};
#endif
EVHTP_EXPORT void evhtp_set_mem_functions(void *(*malloc_)(size_t),
void *(*realloc_)(void *, size_t),
void (* free_)(void *));
/**
* @defgroup evhtp_core Core evhtp functions
* @{
*/
/**
* @brief creates a new evhtp_t instance
*
* @param evbase the initialized event base
* @param arg user-defined argument which is evhtp_t specific
*
* @return a new evhtp_t structure or NULL on error
*/
EVHTP_EXPORT evhtp_t * evhtp_new(evbase_t * evbase, void * arg);
EVHTP_EXPORT void evhtp_enable_flag(evhtp_t *, int);
EVHTP_EXPORT void evhtp_connection_enable_flag(evhtp_connection_t *, int);
EVHTP_EXPORT void evhtp_request_enable_flag(evhtp_request_t *, int);
EVHTP_EXPORT int evhtp_get_flags(evhtp_t *);
EVHTP_EXPORT int evhtp_connection_get_flags(evhtp_connection_t *);
EVHTP_EXPORT int evhtp_request_get_flags(evhtp_request_t *);
EVHTP_EXPORT void evhtp_disable_flag(evhtp_t *, int);
EVHTP_EXPORT void evhtp_connection_disable_flag(evhtp_connection_t *, int);
EVHTP_EXPORT void evhtp_request_disable_flag(evhtp_request_t *, int);
/**
* @brief free a evhtp_t context
*
* @param evhtp
*
* @return
*/
EVHTP_EXPORT void evhtp_free(evhtp_t * evhtp);
/** @} */
/**
* @brief set a read/write timeout on all things evhtp_t. When the timeout
* expires your error hook will be called with the libevent supplied event
* flags.
*
* @param htp the base evhtp_t struct
* @param r read-timeout in timeval
* @param w write-timeout in timeval.
*/
EVHTP_EXPORT void evhtp_set_timeouts(evhtp_t * htp, const struct timeval * r, const struct timeval * w);
/**
* @brief during the request processing cycle, these flags will be used to
* for query argument parsing. i.e., what to parse and not to parse.
*
* SEE: EVHTP_PARSE_QUERY_* stuff.
*
* For example, if you do not wish for the streaming parser attempting the act
* of fragment parsing:
* evhtp_set_parser_flags(htp, EVHTP_PARSE_QUERY_FLAG_IGNORE_FRAGMENTS);
*
* @param htp
* @param flags
*/
EVHTP_EXPORT void evhtp_set_parser_flags(evhtp_t * htp, int flags);
/**
* @brief bufferevent flags which will be used for bev sockets.
*
* @param htp
* @param flags
*/
EVHTP_EXPORT void evhtp_set_bev_flags(evhtp_t * htp, int flags);
#ifndef EVHTP_DISABLE_SSL
EVHTP_EXPORT int evhtp_ssl_use_threads(void);
EVHTP_EXPORT int evhtp_ssl_init(evhtp_t * htp, evhtp_ssl_cfg_t * ssl_cfg);
#endif
/**
* @brief when a client sends an Expect: 100-continue, if this is function is
* called, evhtp will not send a HTTP/x.x continue response.
*
* @param htp
*/
EVHTP_EXPORT void evhtp_disable_100_continue(evhtp_t * htp);
DEPRECATED("evhtp_disable_100 will soon be deprecated, use htp->flags instead");
/**
* @brief creates a lock around callbacks and hooks, allowing for threaded
* applications to add/remove/modify hooks & callbacks in a thread-safe manner.
*
* @param htp
*
* @return 0 on success, -1 on error
*/
EVHTP_EXPORT int evhtp_use_callback_locks(evhtp_t * htp);
/**
* @brief sets a callback which is called if no other callbacks are matched
*
* @param htp the initialized evhtp_t
* @param cb the function to be executed
* @param arg user-defined argument passed to the callback
*/
EVHTP_EXPORT void evhtp_set_gencb(evhtp_t * htp, evhtp_callback_cb cb, void * arg);
/**
* @brief call a user-defined function before the connection is accepted.
*
* @param htp
* @param evhtp_pre_accept_cb
* @param arg
*
* @return
*/
EVHTP_EXPORT void evhtp_set_pre_accept_cb(evhtp_t * htp, evhtp_pre_accept_cb, void * arg);
/**
* @brief call a user-defined function right after a connection is accepted.
*
* @param htp
* @param evhtp_post_accept_cb
* @param arg
*
* @return
*/
EVHTP_EXPORT void evhtp_set_post_accept_cb(evhtp_t * htp, evhtp_post_accept_cb, void * arg);
/**
* @brief sets a callback to be executed on a specific path
*
* @param htp the initialized evhtp_t
* @param path the path to match
* @param cb the function to be executed
* @param arg user-defined argument passed to the callback
*
* @return evhtp_callback_t * on success, NULL on error.
*/
EVHTP_EXPORT evhtp_callback_t * evhtp_set_cb(evhtp_t * htp, const char * path,
evhtp_callback_cb cb, void * arg);
/**
* @brief sets a callback to be executed based on a regex pattern
*
* @param htp the initialized evhtp_t
* @param pattern a POSIX compat regular expression
* @param cb the function to be executed
* @param arg user-defined argument passed to the callback
*
* @return evhtp_callback_t * on success, NULL on error
*/
#ifndef EVHTP_DISABLE_REGEX
EVHTP_EXPORT evhtp_callback_t * evhtp_set_regex_cb(evhtp_t * htp, const char * pattern,
evhtp_callback_cb cb, void * arg);
#endif
/**
* @brief sets a callback to to be executed on simple glob/wildcard patterns
* this is useful if the app does not care about what was matched, but
* just that it matched. This is technically faster than regex.
*
* @param htp
* @param pattern wildcard pattern, the '*' can be set at either or both the front or end.
* @param cb
* @param arg
*
* @return
*/
EVHTP_EXPORT evhtp_callback_t * evhtp_set_glob_cb(evhtp_t * htp, const char * pattern,
evhtp_callback_cb cb, void * arg);
/**
* @brief attempts to find the callback matching the exact string 'needle'. This is useful
* in cases where we want to get the original handle, but is not in scope.
*
* with pattern based callbacks, this does not attempt to find a callback that would
* match the string if the pattern matcher was executed.
*
* Meaning:
* evhtp_set_glob_cb(htp, "/foo/bar*", ....);
*
* Calling
* evhtp_get_cb(htp, "/foo/bar/baz");
*
* Will return NULL since it's not the exact pattern set
*
* Calling
* evhtp_get_cb(htp, "/foo/bar*");
*
* Is the correct usage.
*
* @param htp
* @param needle
*
* @return NULL if callback is not not found
*/
EVHTP_EXPORT evhtp_callback_t * evhtp_get_cb(evhtp_t * htp, const char * needle);
/**
* @brief sets a callback hook for either a connection or a path/regex .
*
* A user may set a variety of hooks either per-connection, or per-callback.
* This allows the developer to hook into various parts of the request processing
* cycle.
*
* a per-connection hook can be set at any time, but it is recommended to set these
* during either a pre-accept phase, or post-accept phase. This allows a developer
* to set hooks before any other hooks are called.
*
* a per-callback hook works differently. In this mode a developer can setup a set
* of hooks prior to starting the event loop for specific callbacks. For example
* if you wanted to hook something ONLY for a callback set by evhtp_set_cb or
* evhtp_set_regex_cb this is the method of doing so.
*
* per-callback example:
*
* evhtp_callback_t * cb = evhtp_set_regex_cb(htp, "/anything/(.*)", default_cb, NULL);
*
* evhtp_set_hook(&cb->hooks, evhtp_hook_on_headers, anything_headers_cb, NULL);
*
* evhtp_set_hook(&cb->hooks, evhtp_hook_on_fini, anything_fini_cb, NULL);
*
* With the above example, once libevhtp has determined that it has a user-defined
* callback for /anything/.*; anything_headers_cb will be executed after all headers
* have been parsed, and anything_fini_cb will be executed before the request is
* free()'d.
*
* The same logic applies to per-connection hooks, but it should be noted that if
* a per-callback hook is set, the per-connection hook will be ignored.
*
* @param hooks double pointer to the evhtp_hooks_t structure
* @param type the hook type
* @param cb the callback to be executed.
* @param arg optional argument which is passed when the callback is executed
*
* @return 0 on success, -1 on error (if hooks is NULL, it is allocated)
*/
EVHTP_EXPORT int evhtp_set_hook(evhtp_hooks_t ** hooks, evhtp_hook_type type, evhtp_hook cb, void * arg);
DEPRECATED("use evhtp_[connection|request|callback]_set_hook() instead of set_hook directly");
EVHTP_EXPORT int evhtp_connection_set_hook(evhtp_connection_t * c, evhtp_hook_type type, evhtp_hook cb, void * arg);
EVHTP_EXPORT int evhtp_request_set_hook(evhtp_request_t * r, evhtp_hook_type type, evhtp_hook cb, void * arg);
EVHTP_EXPORT int evhtp_callback_set_hook(evhtp_callback_t * cb, evhtp_hook_type type, evhtp_hook hookcb, void * arg);
/**
* @brief remove a specific hook from being called.
*
* @param hooks
* @param type
*
* @return
*/
EVHTP_EXPORT int evhtp_unset_hook(evhtp_hooks_t ** hooks, evhtp_hook_type type);
/**
* @brief removes all hooks.
*
* @param hooks
*
* @return
*/
EVHTP_EXPORT int evhtp_unset_all_hooks(evhtp_hooks_t ** hooks);
/**
* @brief bind to a socket, optionally with specific protocol support
* formatting. The addr can be defined as one of the following:
* ipv6:<ipv6addr> for binding to an IPv6 address.
* unix:<named pipe> for binding to a unix named socket
* ipv4:<ipv4addr> for binding to an ipv4 address
* Otherwise the addr is assumed to be ipv4.
*
* @param htp
* @param addr
* @param port
* @param backlog
*
* @return
*/
EVHTP_EXPORT int evhtp_bind_socket(evhtp_t * htp, const char * addr, uint16_t port, int backlog);
/**
* @brief stops the listening socket.
*
* @param htp
*/
EVHTP_EXPORT void evhtp_unbind_socket(evhtp_t * htp);
/**
* @brief create the listener plus setup various options with an already-bound
* socket.
*
* @note Since the file descriptor is passed to the function, it will not
* attempt to close it if an error occurs.
*
* @param htp
* @param sock
* @param backlog
*
* @return 0 on success, -1 on error (check errno)
*/
EVHTP_EXPORT int evhtp_accept_socket(evhtp_t * htp, evutil_socket_t sock, int backlog);
/**
* @brief bind to an already allocated sockaddr.
*
* @param htp
* @parami s
* @param sin_len
* @param backlog
*
* @return
*/
EVHTP_EXPORT int evhtp_bind_sockaddr(evhtp_t * htp, struct sockaddr *,
size_t sin_len, int backlog);
/**
* @brief Enable thread-pool support for an evhtp_t context. Connectios are
* distributed across 'nthreads'. An optional "on-start" callback can
* be set which allows you to manipulate the thread-specific inforation
* (such as the thread-specific event_base).
*
* @param htp
* @param init_cb
* @param exit_cb
* @param nthreads
* @param arg
*
* @return
*/
EVHTP_EXPORT int evhtp_use_threads(evhtp_t *, evhtp_thread_init_cb, int nthreads, void *)
DEPRECATED("will take on the syntax of evhtp_use_threads_wexit");
/**
* @brief Temporary function which will be renamed evhtp_use_threads in the
* future. evhtp_use_threads() has been noted as deprecated for now
*/
EVHTP_EXPORT int evhtp_use_threads_wexit(evhtp_t *,
evhtp_thread_init_cb,
evhtp_thread_exit_cb,
int nthreads, void * arg);
/**
* @brief generates all the right information for a reply to be sent to the client
*
* @param request
* @param code HTTP return status code
*/
EVHTP_EXPORT void evhtp_send_reply(evhtp_request_t * request, evhtp_res code);
/* The following three functions allow for the user to do what evhtp_send_reply does at its core
* but for the weak of heart.
*/
EVHTP_EXPORT void evhtp_send_reply_start(evhtp_request_t * request, evhtp_res code);
EVHTP_EXPORT void evhtp_send_reply_body(evhtp_request_t * request, evbuf_t * buf);
EVHTP_EXPORT void evhtp_send_reply_end(evhtp_request_t * request);
/**
* @brief Determine 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.
*/
EVHTP_EXPORT int evhtp_response_needs_body(const evhtp_res code, const htp_method method);
/**
* @brief start a chunked response. If data already exists on the output buffer,
* this will be converted to the first chunk.
*
* @param request
* @param code
*/
EVHTP_EXPORT void evhtp_send_reply_chunk_start(evhtp_request_t * request, evhtp_res code);
/**
* @brief send a chunk reply.
*
* @param request
* @param buf
*/
EVHTP_EXPORT void evhtp_send_reply_chunk(evhtp_request_t * request, evbuf_t * buf);
/**
* @brief call when all chunks have been sent and you wish to send the last
* bits. This will add the last 0CRLFCRCL and call send_reply_end().
*
* @param request
*/
EVHTP_EXPORT void evhtp_send_reply_chunk_end(evhtp_request_t * request);
/**
* @brief creates a new evhtp_callback_t structure.
*
* All callbacks are stored in this structure
* which define what the final function to be
* called after all parsing is done. A callback
* can be either a static string or a regular
* expression.
*
* @param path can either be a static path (/path/to/resource/) or
* a POSIX compatible regular expression (^/resource/(.*))
* @param type informs the function what type of of information is
* is contained within the path argument. This can either be
* callback_type_path, or callback_type_regex.
* @param cb the callback function to be invoked
* @param arg optional argument which is passed when the callback is executed.
*
* @return 0 on success, -1 on error.
*/
EVHTP_EXPORT evhtp_callback_t *
evhtp_callback_new(const char * path, evhtp_callback_type type, evhtp_callback_cb cb, void * arg);
/**
* @brief frees information associated with a ainflwx callback.
*
* @param callback
*/
EVHTP_EXPORT void evhtp_callback_free(evhtp_callback_t * callback);
/**
* @brief Adds a evhtp_callback_t to the evhtp_callbacks_t list
*
* @param cbs an allocated evhtp_callbacks_t structure
* @param cb an initialized evhtp_callback_t structure
*
* @return 0 on success, -1 on error
*/
EVHTP_EXPORT int evhtp_callbacks_add_callback(evhtp_callbacks_t * cbs, evhtp_callback_t * cb);
/**
* @brief add an evhtp_t structure (with its own callbacks) to a base evhtp_t
* structure for virtual hosts. It should be noted that if you enable SSL
* on the base evhtp_t and your version of OpenSSL supports SNI, the SNI
* hostname will always take precedence over the Host header value.
*
* @param evhtp
* @param name
* @param vhost
*
* @return
*/
EVHTP_EXPORT int evhtp_add_vhost(evhtp_t * evhtp, const char * name, evhtp_t * vhost);
/**
* @brief Add an alias hostname for a virtual-host specific evhtp_t. This avoids
* having multiple evhtp_t virtual hosts with the same callback for the same
* vhost.
*
* @param evhtp
* @param name
*
* @return
*/
EVHTP_EXPORT int evhtp_add_alias(evhtp_t * evhtp, const char * name);
/**
* @brief Allocates a new key/value structure.
*
* @param key null terminated string
* @param val null terminated string
* @param kalloc if set to 1, the key will be copied, if 0 no copy is done.
* @param valloc if set to 1, the val will be copied, if 0 no copy is done.
*
* @return evhtp_kv_t * on success, NULL on error.
*/
EVHTP_EXPORT evhtp_kv_t * evhtp_kv_new(const char * key, const char * val, char kalloc, char valloc);
/**
* @brief creates an empty list of key/values
*
* @return
*/
EVHTP_EXPORT evhtp_kvs_t * evhtp_kvs_new(void);
/**
* @brief frees resources allocated for a single key/value
*
* @param kv
*/
EVHTP_EXPORT void evhtp_kv_free(evhtp_kv_t * kv);
/**
* @brief frees a the list of key/values, and all underlying entries
*
* @param kvs
*/
EVHTP_EXPORT void evhtp_kvs_free(evhtp_kvs_t * kvs);
/**
* @brief free's resources associated with 'kv' if ONLY found within the key/value list
*
* @param kvs
* @param kv
*/
EVHTP_EXPORT void evhtp_kv_rm_and_free(evhtp_kvs_t * kvs, evhtp_kv_t * kv);
/**
* @brief find the string value of 'key' from the key/value list 'kvs'
*
* @param kvs
* @param key
*
* @return NULL if not found
*/
EVHTP_EXPORT const char * evhtp_kv_find(evhtp_kvs_t * kvs, const char * key);
/**
* @brief find the evhtp_kv_t reference 'key' from the k/val list 'kvs'
*
* @param kvs
* @param key
*
* @return
*/
EVHTP_EXPORT evhtp_kv_t * evhtp_kvs_find_kv(evhtp_kvs_t * kvs, const char * key);
/**
* @brief appends a key/val structure to a evhtp_kvs_t tailq
*
* @param kvs an evhtp_kvs_t structure
* @param kv an evhtp_kv_t structure
*/
EVHTP_EXPORT void evhtp_kvs_add_kv(evhtp_kvs_t * kvs, evhtp_kv_t * kv);
/**
* @brief appends all key/val structures from src tailq onto dst tailq
*
* @param dst an evhtp_kvs_t structure
* @param src an evhtp_kvs_t structure
*/
EVHTP_EXPORT void evhtp_kvs_add_kvs(evhtp_kvs_t * dst, evhtp_kvs_t * src);
/**
* @brief callback iterator which executes 'cb' for every entry in 'kvs'
*
* @param kvs
* @param cb
* @param arg
*
* @return
*/
EVHTP_EXPORT int evhtp_kvs_for_each(evhtp_kvs_t * kvs, evhtp_kvs_iterator cb, void * arg);
#define EVHTP_PARSE_QUERY_FLAG_STRICT 0
#define EVHTP_PARSE_QUERY_FLAG_IGNORE_HEX (1 << 0)
#define EVHTP_PARSE_QUERY_FLAG_ALLOW_EMPTY_VALS (1 << 1)
#define EVHTP_PARSE_QUERY_FLAG_ALLOW_NULL_VALS (1 << 2)
#define EVHTP_PARSE_QUERY_FLAG_TREAT_SEMICOLON_AS_SEP (1 << 3)
#define EVHTP_PARSE_QUERY_FLAG_IGNORE_FRAGMENTS (1 << 4)
#define EVHTP_PARSE_QUERY_FLAG_LENIENT \
EVHTP_PARSE_QUERY_FLAG_IGNORE_HEX \
| EVHTP_PARSE_QUERY_FLAG_ALLOW_EMPTY_VALS \
| EVHTP_PARSE_QUERY_FLAG_ALLOW_NULL_VALS \
| EVHTP_PARSE_QUERY_FLAG_TREAT_SEMICOLON_AS_SEP
#define EVHTP_PARSE_QUERY_FLAG_DEFAULT EVHTP_PARSE_QUERY_FLAG_LENIENT
/**
* @brief Parses the query portion of the uri into a set of key/values
*
* Parses query arguments like "?herp=&foo=bar;blah=baz&a=%3"
*
* @param query data containing the uri query arguments
* @param len size of the data
* @param flags parse query flags to alter 'strictness' (see EVHTP_PARSE_QUERY_FLAG_*)
*
* @return evhtp_query_t * on success, NULL on error
*/
EVHTP_EXPORT evhtp_query_t * evhtp_parse_query_wflags(const char * query, size_t len, int flags);
/**
* @brief Parses the query portion of the uri into a set of key/values in a
* strict manner
*
* Parses query arguments like "?herp=derp&foo=bar&blah=baz"
*
* @param query data containing the uri query arguments
* @param len size of the data
*
* @return evhtp_query_t * on success, NULL on error
*/
EVHTP_EXPORT evhtp_query_t * evhtp_parse_query(const char * query, size_t len);
/**
* @brief Unescapes strings like '%7B1,%202,%203%7D' would become '{1, 2, 3}'
*
* @param out double pointer where output is stored. This is allocated by the user.
* @param str the string to unescape
* @param str_len the length of the string to unescape
*
* @return 0 on success, -1 on error
*/
EVHTP_EXPORT int evhtp_unescape_string(unsigned char ** out, unsigned char * str, size_t str_len);
/**
* @brief creates a new evhtp_header_t key/val structure
*
* @param key a null terminated string
* @param val a null terminated string
* @param kalloc if 1, key will be copied, otherwise no copy performed
* @param valloc if 1, val will be copied, otehrwise no copy performed
*
* @return evhtp_header_t * or NULL on error
*/
EVHTP_EXPORT evhtp_header_t * evhtp_header_new(const char * key, const char * val,
char kalloc, char valloc);
/**
* @brief creates a new evhtp_header_t, sets only the key, and adds to the
* evhtp_headers TAILQ
*
* @param headers the evhtp_headers_t TAILQ (evhtp_kv_t)
* @param key a null terminated string
* @param kalloc if 1 the string will be copied, otherwise assigned
*
* @return an evhtp_header_t pointer or NULL on error
*/
EVHTP_EXPORT evhtp_header_t * evhtp_header_key_add(evhtp_headers_t * headers,
const char * key, char kalloc);
/**
* @brief finds the last header in the headers tailq and adds the value
*
* @param headers the evhtp_headers_t TAILQ (evhtp_kv_t)
* @param val a null terminated string
* @param valloc if 1 the string will be copied, otherwise assigned
*
* @return an evhtp_header_t pointer or NULL on error
*/
EVHTP_EXPORT evhtp_header_t * evhtp_header_val_add(evhtp_headers_t * headers,
const char * val, char valloc);
/**
* @brief adds an evhtp_header_t to the end of the evhtp_headers_t tailq
*
* @param headers
* @param header
*/
EVHTP_EXPORT void evhtp_headers_add_header(evhtp_headers_t * headers, evhtp_header_t * header);
/**
* @brief finds the value of a key in a evhtp_headers_t structure
*
* @param headers the evhtp_headers_t tailq
* @param key the key to find
*
* @return the value of the header key if found, NULL if not found.
*/
EVHTP_EXPORT const char * evhtp_header_find(evhtp_headers_t * headers, const char * key);
#define evhtp_header_find evhtp_kv_find
#define evhtp_headers_find_header evhtp_kvs_find_kv
#define evhtp_headers_for_each evhtp_kvs_for_each
#define evhtp_header_new evhtp_kv_new
#define evhtp_header_free evhtp_kv_free
#define evhtp_headers_new evhtp_kvs_new
#define evhtp_headers_free evhtp_kvs_free
#define evhtp_header_rm_and_free evhtp_kv_rm_and_free
#define evhtp_headers_add_header evhtp_kvs_add_kv
#define evhtp_headers_add_headers evhtp_kvs_add_kvs
#define evhtp_query_new evhtp_kvs_new
#define evhtp_query_free evhtp_kvs_free
/**
* @brief returns the htp_method enum version of the request method.
*
* @param r
*
* @return htp_method enum
*/
EVHTP_EXPORT htp_method evhtp_request_get_method(evhtp_request_t * r);
EVHTP_EXPORT evhtp_proto evhtp_request_get_proto(evhtp_request_t * r);
/* the following functions all do the same thing, pause and the processing */
EVHTP_EXPORT void evhtp_connection_pause(evhtp_connection_t * connection);
EVHTP_EXPORT void evhtp_connection_resume(evhtp_connection_t * connection);
EVHTP_EXPORT void evhtp_request_pause(evhtp_request_t * request);
EVHTP_EXPORT void evhtp_request_resume(evhtp_request_t * request);
/**
* @brief returns the underlying evhtp_connection_t structure from a request
*
* @param request
*
* @return evhtp_connection_t on success, otherwise NULL
*/
EVHTP_EXPORT evhtp_connection_t * evhtp_request_get_connection(evhtp_request_t * request);
/**
* @brief Sets the connections underlying bufferevent
*
* @param conn
* @param bev
*/
EVHTP_EXPORT void evhtp_connection_set_bev(evhtp_connection_t * conn, evbev_t * bev);
/**
* @brief sets the underlying bufferevent for a evhtp_request
*
* @param request
* @param bev
*/
EVHTP_EXPORT void evhtp_request_set_bev(evhtp_request_t * request, evbev_t * bev);
/**
* @brief returns the underlying connections bufferevent
*
* @param conn
*
* @return bufferevent on success, otherwise NULL
*/
EVHTP_EXPORT evbev_t * evhtp_connection_get_bev(evhtp_connection_t * conn);
/**
* @brief sets a connection-specific read/write timeout which overrides the
* global read/write settings.
*
* @param conn
* @param r timeval for read
* @param w timeval for write
*/
EVHTP_EXPORT void
evhtp_connection_set_timeouts(evhtp_connection_t * conn,
const struct timeval * r,
const struct timeval * w);
/**
* @brief returns the underlying requests bufferevent
*
* @param request
*
* @return bufferevent on success, otherwise NULL
*/
EVHTP_EXPORT evbev_t * evhtp_request_get_bev(evhtp_request_t * request);
/**
* @brief let a user take ownership of the underlying bufferevent and free
* all other underlying resources.
*
* Warning: this will free all evhtp_connection/request structures, remove all
* associated hooks and reset the bufferevent to defaults, i.e., disable
* EV_READ, and set all callbacks to NULL.
*
* @param connection
*
* @return underlying connections bufferevent.
*/
EVHTP_EXPORT evbev_t * evhtp_connection_take_ownership(evhtp_connection_t * connection);
/**
* @brief free's all connection related resources, this will also call your
* request fini hook and request fini hook.
*
* @param connection
*/
EVHTP_EXPORT void evhtp_connection_free(evhtp_connection_t * connection);
EVHTP_EXPORT void evhtp_request_free(evhtp_request_t * request);
/**
* @brief set a max body size to accept for an incoming request, this will
* default to unlimited.
*
* @param htp
* @param len
*/
EVHTP_EXPORT void evhtp_set_max_body_size(evhtp_t * htp, uint64_t len);
/**
* @brief set a max body size for a specific connection, this will default to
* the size set by evhtp_set_max_body_size
*
* @param conn
* @param len
*/
EVHTP_EXPORT void evhtp_connection_set_max_body_size(evhtp_connection_t * conn, uint64_t len);
/**
* @brief just calls evhtp_connection_set_max_body_size for the request.
*
* @param request
* @param len
*/
EVHTP_EXPORT void evhtp_request_set_max_body_size(evhtp_request_t * request, uint64_t len);
EVHTP_EXPORT void evhtp_request_set_keepalive(evhtp_request_t * request, int val);
/**
* @brief sets a maximum number of requests that a single connection can make.
*
* @param htp
* @param num
*/
EVHTP_EXPORT void evhtp_set_max_keepalive_requests(evhtp_t * htp, uint64_t num);
/*****************************************************************
* client request functions *
*****************************************************************/
/**
* @brief allocate a new connection
*/
EVHTP_EXPORT evhtp_connection_t * evhtp_connection_new_dns(evbase_t * evbase,
struct evdns_base * dns_base,
const char * addr, uint16_t port);
/**
* @brief allocate a new connection
*/
EVHTP_EXPORT evhtp_connection_t *
evhtp_connection_new(evbase_t * evbase, const char * addr, uint16_t port);
#ifndef EVHTP_DISABLE_SSL
EVHTP_EXPORT evhtp_connection_t * evhtp_connection_ssl_new(evbase_t * evbase, const char * addr, uint16_t port, evhtp_ssl_ctx_t * ctx);
#endif
/**
* @brief allocate a new request
*/
EVHTP_EXPORT evhtp_request_t * evhtp_request_new(evhtp_callback_cb cb, void * arg);
/**
* @brief make a client request
*/
EVHTP_EXPORT int evhtp_make_request(evhtp_connection_t * c,
evhtp_request_t * r, htp_method meth, const char * uri);
EVHTP_EXPORT unsigned int evhtp_request_status(evhtp_request_t *);
#ifdef __cplusplus
}
#endif
#endif /* __EVHTP__H__ */