http.c File Reference

http server for AMI access More...

#include "asterisk.h"
#include <time.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <signal.h>
#include <fcntl.h>
#include "asterisk/paths.h"
#include "asterisk/cli.h"
#include "asterisk/tcptls.h"
#include "asterisk/http.h"
#include "asterisk/utils.h"
#include "asterisk/strings.h"
#include "asterisk/config.h"
#include "asterisk/stringfields.h"
#include "asterisk/ast_version.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
#include "asterisk/netsock2.h"
#include "asterisk/json.h"

Include dependency graph for http.c:

Go to the source code of this file.

Data Structures
struct	ast_cfhttp_methods_text
struct	ast_http_server
struct	http_uri_redirect
struct	http_worker_private_data
struct	uri_redirects
struct	uris

Macros
#define	BASIC_LEN   6
#define	BASIC_PREFIX   "Basic "
#define	DEFAULT_PORT   8088
#define	DEFAULT_RESPONSE_HEADER_LENGTH   512
#define	DEFAULT_SESSION_INACTIVITY   30000
#define	DEFAULT_SESSION_KEEP_ALIVE   15000
#define	DEFAULT_SESSION_LIMIT   100
#define	DEFAULT_TLS_PORT   8089
#define	HTTP_SERVER_BUCKETS   5
	Number of HTTP server buckets.
#define	INITIAL_RESPONSE_BODY_BUFFER   1024
#define	MAX_CONTENT_LENGTH   40960
#define	MAX_HTTP_LINE_LENGTH   4096
#define	MAX_HTTP_REQUEST_HEADERS   100
#define	MAX_PREFIX   80
#define	MAX_SERVER_NAME_LENGTH   128
#define	MIN_INITIAL_REQUEST_TIMEOUT   10000

Enumerations
enum	http_private_flags { HTTP_FLAG_HAS_BODY = (1 << 0) , HTTP_FLAG_BODY_READ = (1 << 1) , HTTP_FLAG_CLOSE_ON_COMPLETION = (1 << 2) }

Functions
static int	__ast_http_load (int reload)
static void	__reg_module (void)
static void	__unreg_module (void)
static void	add_redirect (const char *value)
	Add a new URI redirect The entries in the redirect list are sorted by length, just like the list of URI handlers.
	AO2_STRING_FIELD_CMP_FN (ast_http_server, address)
	AO2_STRING_FIELD_HASH_FN (ast_http_server, address)
const char *	ast_get_http_method (enum ast_http_method method)
	Return http method name string.
enum ast_http_method	ast_get_http_method_from_string (const char *method)
	Return http method from string.
void	ast_http_auth (struct ast_tcptls_session_instance *ser, const char *realm, const unsigned long nonce, const unsigned long opaque, int stale, const char *text)
	Send http "401 Unauthorized" response and close socket.
int	ast_http_body_discard (struct ast_tcptls_session_instance *ser)
	Read and discard any unread HTTP request body.
void	ast_http_body_read_status (struct ast_tcptls_session_instance *ser, int read_success)
	Update the body read success status.
struct ast_variable *	ast_http_create_basic_auth_header (const char *userid, const char *password)
	Create an HTTP authorization header.
void	ast_http_create_response (struct ast_tcptls_session_instance *ser, int status_code, const char *status_title, struct ast_str *http_header_data, const char *text)
	Creates and sends a formatted http response message.
void	ast_http_error (struct ast_tcptls_session_instance *ser, int status_code, const char *status_title, const char *text)
	Send HTTP error message and close socket.
const char *	ast_http_ftype2mtype (const char *ftype)
	Return mime type based on extension.
struct ast_http_auth *	ast_http_get_auth (struct ast_variable *headers)
	Get HTTP authentication information from headers.
static char *	ast_http_get_contents (int *return_length, struct ast_tcptls_session_instance *ser, struct ast_variable *headers)
	Returns the contents (body) of the HTTP request.
struct ast_variable *	ast_http_get_cookies (struct ast_variable *headers)
	Get cookie from Request headers.
struct ast_json *	ast_http_get_json (struct ast_tcptls_session_instance *ser, struct ast_variable *headers)
	Get JSON from client Request Entity-Body, if content type is application/json.
struct ast_variable *	ast_http_get_post_vars (struct ast_tcptls_session_instance *ser, struct ast_variable *headers)
	Get post variables from client Request Entity-Body, if content type is application/x-www-form-urlencoded.
int	ast_http_header_match (const char *name, const char *expected_name, const char *value, const char *expected_value)
	Check if the header and value match (case insensitive) their associated expected values.
int	ast_http_header_match_in (const char *name, const char *expected_name, const char *value, const char *expected_value)
	Check if the header name matches the expected header name. If so, then check to see if the value can be located in the expected value.
int	ast_http_header_parse (char *buf, char **name, char **value)
	Parse a header into the given name/value strings.
uint32_t	ast_http_manid_from_vars (struct ast_variable *headers)
	Return manager id, if exist, from request headers.
struct ast_variable *	ast_http_parse_post_form (char *buf, int content_length, const char *content_type)
	Get post variables from an application/x-www-form-urlencoded buffer.
void	ast_http_prefix (char *buf, int len)
	Return the current prefix.
void	ast_http_request_close_on_completion (struct ast_tcptls_session_instance *ser)
	Request the HTTP connection be closed after this HTTP request.
int	ast_http_response_status_line (const char *buf, const char *version, int code)
	Parse the http response status line.
void	ast_http_send (struct ast_tcptls_session_instance *ser, enum ast_http_method method, int status_code, const char *status_title, struct ast_str *http_header, struct ast_str *out, int fd, unsigned int static_content)
	Generic function for sending HTTP/1.1 response.
int	ast_http_uri_link (struct ast_http_uri *urih)
	Link the new uri into the list.
void	ast_http_uri_unlink (struct ast_http_uri *urih)
	Unregister a URI handler.
void	ast_http_uri_unlink_all_with_key (const char *key)
	Unregister all handlers with matching key.
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_http_auth *	auth_create (const char *userid, const char *password)
static int	chunked_atoh (const char *s, int len)
static int	get_content_length (struct ast_variable *headers)
	Returns the value of the Content-Length header.
static char *	get_content_type (struct ast_variable *headers)
	Retrieves the content type specified in the "Content-Type" header.
static const char *	get_header (struct ast_variable *headers, const char *field_name)
	Retrieves the header with the given field name.
static const char *	get_transfer_encoding (struct ast_variable *headers)
	Returns the value of the Transfer-Encoding header.
static char *	handle_show_http (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	handle_uri (struct ast_tcptls_session_instance *ser, char *uri, enum ast_http_method method, struct ast_variable *headers)
static int	http_body_check_chunk_sync (struct ast_tcptls_session_instance *ser)
static int	http_body_discard_chunk_trailer_headers (struct ast_tcptls_session_instance *ser)
static int	http_body_discard_contents (struct ast_tcptls_session_instance *ser, int length, const char *what_getting)
static int	http_body_get_chunk_length (struct ast_tcptls_session_instance *ser)
static int	http_body_read_contents (struct ast_tcptls_session_instance *ser, char *buf, int length, const char *what_getting)
static int	http_check_connection_close (struct ast_variable *headers)
static int	http_request_headers_get (struct ast_tcptls_session_instance *ser, struct ast_variable **headers)
static void	http_request_tracking_init (struct http_worker_private_data *request)
static int	http_request_tracking_setup (struct ast_tcptls_session_instance *ser, struct ast_variable *headers)
static struct ast_http_server *	http_server_create (const char *name, const char *address, const struct ast_sockaddr *addr)
static void	http_server_destroy (void *obj)
static void	http_server_discard (struct ast_http_server *server)
	Discard/Drop a HTTP server.
static struct ast_http_server *	http_server_get (const char *name, const char *host, uint32_t port, struct ast_http_server **replace_me)
	Retrieve, or create and start a HTTP server.
static struct ast_http_server *	http_server_get_by_addr (const char *name, const struct ast_sockaddr *addr)
	Retrieve, or create a HTTP server object by sock address.
static struct ast_http_server *	http_server_get_by_host (const char *name, const char *host, uint32_t port)
	Retrieve, or create a HTTP server object by host.
static int	http_server_start (struct ast_http_server *server)
static void *	httpd_helper_thread (void *arg)
static int	httpd_process_request (struct ast_tcptls_session_instance *ser)
static int	httpstatus_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_vars, struct ast_variable *headers)
static int	load_module (void)
static struct ast_variable *	parse_cookies (const char *cookies)
static int	reload_module (void)
static void	remove_excess_lws (char *s)
static int	static_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_vars, struct ast_variable *headers)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Built-in HTTP Server" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }
static const struct ast_cfhttp_methods_text	ast_http_methods_text []
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_http []
struct ast_http_server *	global_http_server = NULL
static char	http_server_name [MAX_SERVER_NAME_LENGTH]
struct ao2_container *	http_servers = NULL
static struct ast_tls_config	http_tls_cfg
static struct ast_tcptls_session_args	https_desc
struct {
const char *   ext
const char *   mtype
}	mimetypes []
	Limit the kinds of files we're willing to serve up.
static char	prefix [MAX_PREFIX]
static int	session_count = 0
static int	session_inactivity = DEFAULT_SESSION_INACTIVITY
static int	session_keep_alive = DEFAULT_SESSION_KEEP_ALIVE
static int	session_limit = DEFAULT_SESSION_LIMIT
static struct ast_http_uri	static_uri
static int	static_uri_enabled
static struct ast_http_uri	status_uri
static int	status_uri_enabled
static struct uri_redirects	uri_redirects = AST_RWLIST_HEAD_INIT_VALUE
static struct uris	uris = AST_RWLIST_HEAD_INIT_VALUE

Detailed Description

http server for AMI access

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

This program implements a tiny http server and was inspired by micro-httpd by Jef Poskanzer

GMime http://spruce.sourceforge.net/gmime/

AMI over HTTP support - AMI over the http protocol

Definition in file http.c.

Macro Definition Documentation

BASIC_LEN

#define BASIC_LEN   6

strlen(BASIC_PREFIX)

Definition at line 1609 of file http.c.

BASIC_PREFIX

#define BASIC_PREFIX   "Basic "

Definition at line 1608 of file http.c.

DEFAULT_PORT

#define DEFAULT_PORT   8088

Definition at line 69 of file http.c.

DEFAULT_RESPONSE_HEADER_LENGTH

#define DEFAULT_RESPONSE_HEADER_LENGTH   512

Max size for the http response header

Definition at line 81 of file http.c.

DEFAULT_SESSION_INACTIVITY

#define DEFAULT_SESSION_INACTIVITY   30000

(ms) Idle time waiting for data.

Definition at line 73 of file http.c.

DEFAULT_SESSION_KEEP_ALIVE

#define DEFAULT_SESSION_KEEP_ALIVE   15000

(ms) Idle time between HTTP requests

Definition at line 77 of file http.c.

DEFAULT_SESSION_LIMIT

#define DEFAULT_SESSION_LIMIT   100

Definition at line 71 of file http.c.

DEFAULT_TLS_PORT

#define DEFAULT_TLS_PORT   8089

Definition at line 70 of file http.c.

HTTP_SERVER_BUCKETS

#define HTTP_SERVER_BUCKETS   5

Number of HTTP server buckets.

Definition at line 2154 of file http.c.

INITIAL_RESPONSE_BODY_BUFFER

#define INITIAL_RESPONSE_BODY_BUFFER   1024

Initial response body length.

Definition at line 92 of file http.c.

MAX_CONTENT_LENGTH

#define MAX_CONTENT_LENGTH   40960

Maximum application/json or application/x-www-form-urlencoded body content length.

Definition at line 85 of file http.c.

MAX_HTTP_LINE_LENGTH

#define MAX_HTTP_LINE_LENGTH   4096

Maximum line length for HTTP requests.

Definition at line 99 of file http.c.

MAX_HTTP_REQUEST_HEADERS

#define MAX_HTTP_REQUEST_HEADERS   100

Limit the number of request headers in case the sender is being ridiculous.

Definition at line 1820 of file http.c.

MAX_PREFIX

#define MAX_PREFIX   80

Definition at line 68 of file http.c.

MAX_SERVER_NAME_LENGTH

#define MAX_SERVER_NAME_LENGTH   128

Max size for the http server name

Definition at line 79 of file http.c.

MIN_INITIAL_REQUEST_TIMEOUT

#define MIN_INITIAL_REQUEST_TIMEOUT   10000

(ms) Min timeout for initial HTTP request to start coming in.

Definition at line 75 of file http.c.

Enumeration Type Documentation

http_private_flags

enum http_private_flags

Enumerator
HTTP_FLAG_HAS_BODY	TRUE if the HTTP request has a body.
HTTP_FLAG_BODY_READ	TRUE if the HTTP request body has been read.
HTTP_FLAG_CLOSE_ON_COMPLETION	TRUE if the HTTP request must close when completed.

Definition at line 455 of file http.c.

                        {
    /*! TRUE if the HTTP request has a body. */
    HTTP_FLAG_HAS_BODY = (1 << 0),
    /*! TRUE if the HTTP request body has been read. */
    HTTP_FLAG_BODY_READ = (1 << 1),
    /*! TRUE if the HTTP request must close when completed. */
    HTTP_FLAG_CLOSE_ON_COMPLETION = (1 << 2),
};

Function Documentation

__ast_http_load()

static int __ast_http_load ( int  reload )

static

Definition at line 2440 of file http.c.

{
    struct ast_config *cfg;
    struct ast_variable *v;
    int enabled = 0;
    int new_static_uri_enabled = 0;
    int new_status_uri_enabled = 1; /* Default to enabled for BC */
    char newprefix[MAX_PREFIX] = "";
    char server_name[MAX_SERVER_NAME_LENGTH];
    struct http_uri_redirect *redirect;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    uint32_t bindport = DEFAULT_PORT;
    int http_tls_was_enabled = 0;
    char *bindaddr = NULL;
 
    cfg = ast_config_load2("http.conf", "http", config_flags);
    if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
        return 0;
    }
 
    /* Even if the http.conf hasn't been updated, the TLS certs/keys may have been */
    if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        if (http_tls_cfg.enabled && ast_ssl_setup(https_desc.tls_cfg)) {
            ast_tcptls_server_start(&https_desc);
        }
        return 0;
    }
 
    http_tls_was_enabled = (reload && http_tls_cfg.enabled);
 
    http_tls_cfg.enabled = 0;
 
    ast_free(http_tls_cfg.certfile);
    http_tls_cfg.certfile = ast_strdup(AST_CERTFILE);
 
    ast_free(http_tls_cfg.capath);
    http_tls_cfg.capath = ast_strdup("");
 
    ast_free(http_tls_cfg.pvtfile);
    http_tls_cfg.pvtfile = ast_strdup("");
 
    /* Apply modern intermediate settings according to the Mozilla OpSec team as of July 30th, 2015 but disable TLSv1 */
    ast_set_flag(&http_tls_cfg.flags, AST_SSL_DISABLE_TLSV1 | AST_SSL_SERVER_CIPHER_ORDER);
 
    ast_free(http_tls_cfg.cipher);
    http_tls_cfg.cipher = ast_strdup("ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA");
 
    AST_RWLIST_WRLOCK(&uri_redirects);
    while ((redirect = AST_RWLIST_REMOVE_HEAD(&uri_redirects, entry))) {
        ast_free(redirect);
    }
    AST_RWLIST_UNLOCK(&uri_redirects);
 
    ast_sockaddr_setnull(&https_desc.local_address);
 
    session_limit = DEFAULT_SESSION_LIMIT;
    session_inactivity = DEFAULT_SESSION_INACTIVITY;
    session_keep_alive = DEFAULT_SESSION_KEEP_ALIVE;
 
    snprintf(server_name, sizeof(server_name), "Asterisk/%s", ast_get_version());
 
    v = ast_variable_browse(cfg, "general");
    for (; v; v = v->next) {
        /* read tls config options while preventing unsupported options from being set */
        if (strcasecmp(v->name, "tlscafile")
            && strcasecmp(v->name, "tlscapath")
            && strcasecmp(v->name, "tlscadir")
            && strcasecmp(v->name, "tlsverifyclient")
            && strcasecmp(v->name, "tlsdontverifyserver")
            && strcasecmp(v->name, "tlsclientmethod")
            && strcasecmp(v->name, "sslclientmethod")
            && !ast_tls_read_conf(&http_tls_cfg, &https_desc, v->name, v->value)) {
            continue;
        }
 
        if (!strcasecmp(v->name, "servername")) {
            if (!ast_strlen_zero(v->value)) {
                ast_copy_string(server_name, v->value, sizeof(server_name));
            } else {
                server_name[0] = '\0';
            }
        } else if (!strcasecmp(v->name, "enabled")) {
            enabled = ast_true(v->value);
        } else if (!strcasecmp(v->name, "enablestatic") || !strcasecmp(v->name, "enable_static")) {
            new_static_uri_enabled = ast_true(v->value);
        } else if (!strcasecmp(v->name, "enable_status")) {
            new_status_uri_enabled = ast_true(v->value);
        } else if (!strcasecmp(v->name, "bindport")) {
            if (ast_parse_arg(v->value, PARSE_UINT32 | PARSE_IN_RANGE | PARSE_DEFAULT,
                &bindport, DEFAULT_PORT, 0, 65535)) {
                ast_log(LOG_WARNING, "Invalid port %s specified. Using default port %" PRId32 "\n",
                    v->value, DEFAULT_PORT);
            }
        } else if (!strcasecmp(v->name, "bindaddr")) {
            bindaddr = ast_strdupa(v->value);
        } else if (!strcasecmp(v->name, "prefix")) {
            if (!ast_strlen_zero(v->value)) {
                newprefix[0] = '/';
                ast_copy_string(newprefix + 1, v->value, sizeof(newprefix) - 1);
            } else {
                newprefix[0] = '\0';
            }
        } else if (!strcasecmp(v->name, "redirect")) {
            add_redirect(v->value);
        } else if (!strcasecmp(v->name, "sessionlimit")) {
            if (ast_parse_arg(v->value, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE,
                &session_limit, DEFAULT_SESSION_LIMIT, 1, INT_MAX)) {
                ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of http.conf\n",
                    v->name, v->value, v->lineno);
            }
        } else if (!strcasecmp(v->name, "session_inactivity")) {
            if (ast_parse_arg(v->value, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE,
                &session_inactivity, DEFAULT_SESSION_INACTIVITY, 1, INT_MAX)) {
                ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of http.conf\n",
                    v->name, v->value, v->lineno);
            }
        } else if (!strcasecmp(v->name, "session_keep_alive")) {
            if (sscanf(v->value, "%30d", &session_keep_alive) != 1
                || session_keep_alive < 0) {
                session_keep_alive = DEFAULT_SESSION_KEEP_ALIVE;
                ast_log(LOG_WARNING, "Invalid %s '%s' at line %d of http.conf\n",
                    v->name, v->value, v->lineno);
            }
        } else {
            ast_log(LOG_WARNING, "Ignoring unknown option '%s' in http.conf\n", v->name);
        }
    }
 
    ast_config_destroy(cfg);
 
    if (strcmp(prefix, newprefix)) {
        ast_copy_string(prefix, newprefix, sizeof(prefix));
    }
 
    ast_copy_string(http_server_name, server_name, sizeof(http_server_name));
 
    if (enabled) {
        http_server_get("http server", bindaddr, bindport, &global_http_server);
    } else if (global_http_server) {
        http_server_discard(global_http_server);
        global_http_server = NULL;
    }
 
    /* When no specific TLS bindaddr is specified, we just use
     * the non-TLS bindaddress here.
     */
    if (global_http_server && ast_sockaddr_isnull(&https_desc.local_address) &&
        global_http_server->args.accept_fd != -1) {
 
        ast_sockaddr_copy(&https_desc.local_address, &global_http_server->args.local_address);
        /* Of course, we can't use the same port though.
         * Since no bind address was specified, we just use the
         * default TLS port
         */
        ast_sockaddr_set_port(&https_desc.local_address, DEFAULT_TLS_PORT);
    }
 
    if (http_tls_was_enabled && !http_tls_cfg.enabled) {
        ast_tcptls_server_stop(&https_desc);
    } else if (http_tls_cfg.enabled && !ast_sockaddr_isnull(&https_desc.local_address)) {
        /* We can get here either because a TLS-specific address was specified
         * or because we copied the non-TLS address here. In the case where
         * we read an explicit address from the config, there may have been
         * no port specified, so we'll just use the default TLS port.
         */
        if (!ast_sockaddr_port(&https_desc.local_address)) {
            ast_sockaddr_set_port(&https_desc.local_address, DEFAULT_TLS_PORT);
        }
        if (ast_ssl_setup(https_desc.tls_cfg)) {
            ast_tcptls_server_start(&https_desc);
        }
    }
 
    if (static_uri_enabled && !new_static_uri_enabled) {
        ast_http_uri_unlink(&static_uri);
    } else if (!static_uri_enabled && new_static_uri_enabled) {
        ast_http_uri_link(&static_uri);
    }
 
    static_uri_enabled = new_static_uri_enabled;
 
    if (status_uri_enabled && !new_status_uri_enabled) {
        ast_http_uri_unlink(&status_uri);
    } else if (!status_uri_enabled && new_status_uri_enabled) {
        ast_http_uri_link(&status_uri);
    }
 
    status_uri_enabled = new_status_uri_enabled;
 
    return 0;
}

References ast_tcptls_session_args::accept_fd, add_redirect(), ast_http_server::args, AST_CERTFILE, ast_config_destroy(), ast_config_load2(), ast_copy_string(), ast_free, ast_get_version(), ast_http_uri_link(), ast_http_uri_unlink(), ast_log, ast_parse_arg(), AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_set_flag, ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_port, ast_sockaddr_set_port, ast_sockaddr_setnull(), AST_SSL_DISABLE_TLSV1, AST_SSL_SERVER_CIPHER_ORDER, ast_ssl_setup(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_tcptls_server_start(), ast_tcptls_server_stop(), ast_tls_read_conf(), ast_true(), ast_variable_browse(), bindaddr, ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_PORT, DEFAULT_SESSION_INACTIVITY, DEFAULT_SESSION_KEEP_ALIVE, DEFAULT_SESSION_LIMIT, DEFAULT_TLS_PORT, ast_tls_config::enabled, enabled, ast_tls_config::flags, global_http_server, http_server_discard(), http_server_get(), http_server_name, http_tls_cfg, https_desc, ast_variable::lineno, ast_tcptls_session_args::local_address, LOG_WARNING, MAX_PREFIX, MAX_SERVER_NAME_LENGTH, ast_variable::name, ast_variable::next, NULL, PARSE_DEFAULT, PARSE_IN_RANGE, PARSE_INT32, PARSE_UINT32, prefix, ast_tls_config::pvtfile, reload(), session_inactivity, session_keep_alive, session_limit, static_uri, static_uri_enabled, status_uri, status_uri_enabled, ast_tcptls_session_args::tls_cfg, and ast_variable::value.

Referenced by load_module(), and reload_module().

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2755 of file http.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2755 of file http.c.

add_redirect()

static void add_redirect ( const char *  value )

static

Add a new URI redirect The entries in the redirect list are sorted by length, just like the list of URI handlers.

Definition at line 2098 of file http.c.

{
    char *target, *dest;
    struct http_uri_redirect *redirect, *cur;
    unsigned int target_len;
    unsigned int total_len;
    size_t dest_len;
 
    dest = ast_strdupa(value);
    dest = ast_skip_blanks(dest);
    target = strsep(&dest, " ");
    target = ast_skip_blanks(target);
    target = strsep(&target, " "); /* trim trailing whitespace */
 
    if (!dest) {
        ast_log(LOG_WARNING, "Invalid redirect '%s'\n", value);
        return;
    }
 
    target_len = strlen(target) + 1;
    dest_len = strlen(dest) + 1;
    total_len = sizeof(*redirect) + target_len + dest_len;
 
    if (!(redirect = ast_calloc(1, total_len))) {
        return;
    }
    redirect->dest = redirect->target + target_len;
    strcpy(redirect->target, target);
    ast_copy_string(redirect->dest, dest, dest_len);
 
    AST_RWLIST_WRLOCK(&uri_redirects);
 
    target_len--; /* So we can compare directly with strlen() */
    if (AST_RWLIST_EMPTY(&uri_redirects)
        || strlen(AST_RWLIST_FIRST(&uri_redirects)->target) <= target_len ) {
        AST_RWLIST_INSERT_HEAD(&uri_redirects, redirect, entry);
        AST_RWLIST_UNLOCK(&uri_redirects);
 
        return;
    }
 
    AST_RWLIST_TRAVERSE(&uri_redirects, cur, entry) {
        if (AST_RWLIST_NEXT(cur, entry)
            && strlen(AST_RWLIST_NEXT(cur, entry)->target) <= target_len ) {
            AST_RWLIST_INSERT_AFTER(&uri_redirects, cur, redirect, entry);
            AST_RWLIST_UNLOCK(&uri_redirects);
            return;
        }
    }
 
    AST_RWLIST_INSERT_TAIL(&uri_redirects, redirect, entry);
 
    AST_RWLIST_UNLOCK(&uri_redirects);
}

References ast_calloc, ast_copy_string(), ast_log, AST_RWLIST_EMPTY, AST_RWLIST_FIRST, AST_RWLIST_INSERT_AFTER, AST_RWLIST_INSERT_HEAD, AST_RWLIST_INSERT_TAIL, AST_RWLIST_NEXT, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_skip_blanks(), ast_strdupa, http_uri_redirect::dest, http_uri_redirect::entry, LOG_WARNING, strsep(), http_uri_redirect::target, and value.

Referenced by __ast_http_load().

AO2_STRING_FIELD_CMP_FN()

AO2_STRING_FIELD_CMP_FN	(	ast_http_server	,
		address
	)

AO2_STRING_FIELD_HASH_FN()

AO2_STRING_FIELD_HASH_FN	(	ast_http_server	,
		address
	)

ast_get_http_method()

const char * ast_get_http_method

(

enum ast_http_method

method

)

Return http method name string.

Since

1.8

Definition at line 193 of file http.c.

{
    int x;
 
    for (x = 0; x < ARRAY_LEN(ast_http_methods_text); x++) {
        if (ast_http_methods_text[x].method == method) {
            return ast_http_methods_text[x].text;
        }
    }
 
    return NULL;
}

References ARRAY_LEN, ast_http_methods_text, method, NULL, and ast_cfhttp_methods_text::text.

Referenced by add_allow_header(), ast_ari_callback(), ast_ari_invoke(), auth_http_callback(), and handle_options().

ast_get_http_method_from_string()

enum ast_http_method ast_get_http_method_from_string

(

const char *

method

)

Return http method from string.

Definition at line 206 of file http.c.

{
    int x;
 
    for (x = 0; x < ARRAY_LEN(ast_http_methods_text); x++) {
        if (ast_strings_equal(method, ast_http_methods_text[x].text)) {
            return ast_http_methods_text[x].method;
        }
    }
 
    return AST_HTTP_UNKNOWN;
}

References ARRAY_LEN, ast_http_methods_text, AST_HTTP_UNKNOWN, ast_strings_equal(), ast_cfhttp_methods_text::method, method, and text.

Referenced by parse_rest_request_msg().

ast_http_auth()

void ast_http_auth	(	struct ast_tcptls_session_instance *	ser,
		const char *	realm,
		const unsigned long	nonce,
		const unsigned long	opaque,
		int	stale,
		const char *	text
	)

Send http "401 Unauthorized" response and close socket.

Definition at line 638 of file http.c.

{
    int status_code = 401;
    char *status_title = "Unauthorized";
    struct ast_str *http_header_data = ast_str_create(DEFAULT_RESPONSE_HEADER_LENGTH);
 
    if (http_header_data) {
        ast_str_set(&http_header_data,
                    0,
                    "WWW-authenticate: Digest algorithm=MD5, realm=\"%s\", nonce=\"%08lx\", qop=\"auth\", opaque=\"%08lx\"%s\r\n"
                    "Content-type: text/html\r\n",
                    realm ? realm : "Asterisk",
                    nonce,
                    opaque,
                    stale ? ", stale=true" : "");
    }
 
    ast_http_create_response(ser,
                             status_code,
                             status_title,
                             http_header_data,
                             text);
}

References ast_http_create_response(), ast_str_create, ast_str_set(), DEFAULT_RESPONSE_HEADER_LENGTH, and text.

ast_http_body_discard()

int ast_http_body_discard

(

struct ast_tcptls_session_instance *

ser

)

Read and discard any unread HTTP request body.

Since

12.4.0

Parameters

ser	HTTP TCP/TLS session object.

Return values

0	on success.
-1	on error.

Definition at line 1135 of file http.c.

{
    struct http_worker_private_data *request;
 
    request = ser->private_data;
    if (!ast_test_flag(&request->flags, HTTP_FLAG_HAS_BODY)
        || ast_test_flag(&request->flags, HTTP_FLAG_BODY_READ)) {
        /* No body to read or it has already been read. */
        return 0;
    }
    ast_set_flag(&request->flags, HTTP_FLAG_BODY_READ);
 
    ast_debug(1, "HTTP discarding unused request body\n");
 
    ast_assert(request->body_length != 0);
    if (0 < request->body_length) {
        if (http_body_discard_contents(ser, request->body_length, "body")) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            return -1;
        }
        return 0;
    }
 
    /* parse chunked-body */
    for (;;) {
        int length;
 
        length = http_body_get_chunk_length(ser);
        if (length < 0) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            return -1;
        }
        if (length == 0) {
            /* parsed last-chunk */
            break;
        }
 
        if (http_body_discard_contents(ser, length, "chunk-data")
            || http_body_check_chunk_sync(ser)) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            return -1;
        }
    }
 
    /* Read and discard any trailer entity-header lines. */
    if (http_body_discard_chunk_trailer_headers(ser)) {
        ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
        return -1;
    }
    return 0;
}

References ast_assert, ast_debug, ast_set_flag, ast_test_flag, http_body_check_chunk_sync(), http_body_discard_chunk_trailer_headers(), http_body_discard_contents(), http_body_get_chunk_length(), HTTP_FLAG_BODY_READ, HTTP_FLAG_CLOSE_ON_COMPLETION, HTTP_FLAG_HAS_BODY, ast_tcptls_session_instance::private_data, and request().

Referenced by ast_http_send(), and ast_websocket_uri_cb().

ast_http_body_read_status()

void ast_http_body_read_status	(	struct ast_tcptls_session_instance *	ser,
		int	read_success
	)

Update the body read success status.

Since

12.4.0

Parameters

ser	HTTP TCP/TLS session object.
read_success	TRUE if body was read successfully.

Definition at line 914 of file http.c.

{
    struct http_worker_private_data *request;
 
    request = ser->private_data;
    if (!ast_test_flag(&request->flags, HTTP_FLAG_HAS_BODY)
        || ast_test_flag(&request->flags, HTTP_FLAG_BODY_READ)) {
        /* No body to read. */
        return;
    }
    ast_set_flag(&request->flags, HTTP_FLAG_BODY_READ);
    if (!read_success) {
        ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
    }
}

References ast_set_flag, ast_test_flag, HTTP_FLAG_BODY_READ, HTTP_FLAG_CLOSE_ON_COMPLETION, HTTP_FLAG_HAS_BODY, ast_tcptls_session_instance::private_data, and request().

Referenced by http_post_callback().

ast_http_create_basic_auth_header()

struct ast_variable * ast_http_create_basic_auth_header	(	const char *	userid,
		const char *	password
	)

Create an HTTP authorization header.

The returned ast_variable must be freed with ast_variables_destroy()

Parameters

userid	User ID or "<userid>:<password>".
password	Password if not in userid.

Returns

ast_variable with name="Authorization" and value="Basic <base64enc>"

Return values

NULL	if memory allocation failed.

Definition at line 1668 of file http.c.

{
    int encoded_size = 0;
    int userinfo_len = 0;
    RAII_VAR(char *, userinfo, NULL, ast_free);
    char *encoded_userinfo = NULL;
    struct ast_variable *auth_header = NULL;
 
    if (ast_strlen_zero(userid)) {
        return NULL;
    }
 
    if (strchr(userid, ':')) {
        userinfo = ast_strdup(userid);
        userinfo_len = strlen(userinfo);
    } else {
        if (ast_strlen_zero(password)) {
            return NULL;
        }
        userinfo_len = ast_asprintf(&userinfo, "%s:%s", userid, password);
    }
    if (!userinfo) {
        return NULL;
    }
 
    /*
     * The header value is "Basic " + base64(userinfo).
     * Doubling the userinfo length then adding the length
     * of the "Basic " prefix is a conservative estimate of the
     * final encoded size.
     */
    encoded_size = userinfo_len * 2 * sizeof(char) + 1 + BASIC_LEN;
    encoded_userinfo = ast_alloca(encoded_size);
    strcpy(encoded_userinfo, BASIC_PREFIX); /* Safe */
    ast_base64encode(encoded_userinfo + BASIC_LEN, (unsigned char *)userinfo,
        userinfo_len, encoded_size - BASIC_LEN);
 
    auth_header = ast_variable_new("Authorization",
        encoded_userinfo, "");
 
    return auth_header;
}

References ast_alloca, ast_asprintf, ast_base64encode(), ast_free, ast_strdup, ast_strlen_zero(), ast_variable_new, BASIC_LEN, BASIC_PREFIX, NULL, and RAII_VAR.

Referenced by outbound_session_handler_thread(), and websocket_client_handshake().

ast_http_create_response()

void ast_http_create_response	(	struct ast_tcptls_session_instance *	ser,
		int	status_code,
		const char *	status_title,
		struct ast_str *	http_header_data,
		const char *	text
	)

Creates and sends a formatted http response message.

Parameters

ser	TCP/TLS session object
status_code	HTTP response code (200/401/403/404/500)
status_title	English equivalent to the status_code parameter
http_header_data	The formatted text to use in the http header
text	Additional informational text to use in the response

Note

Function constructs response headers from the status_code, status_title and http_header_data parameters.

The response body is created as HTML content, from the status_code, status_title, and the text parameters.

The http_header_data parameter will be freed as a result of calling function.

Since

13.2.0

Definition at line 583 of file http.c.

{
    char server_name[MAX_SERVER_NAME_LENGTH];
    struct ast_str *server_address = ast_str_create(MAX_SERVER_NAME_LENGTH);
    struct ast_str *out = ast_str_create(INITIAL_RESPONSE_BODY_BUFFER);
 
    if (!http_header_data || !server_address || !out) {
        ast_free(http_header_data);
        ast_free(server_address);
        ast_free(out);
        if (ser) {
            ast_debug(1, "HTTP closing session. OOM.\n");
            ast_tcptls_close_session_file(ser);
        }
        return;
    }
 
    if(!ast_strlen_zero(http_server_name)) {
        ast_xml_escape(http_server_name, server_name, sizeof(server_name));
        ast_str_set(&server_address,
                    0,
                    "<address>%s</address>\r\n",
                    server_name);
    }
 
    ast_str_set(&out,
                0,
                "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n"
                "<html><head>\r\n"
                "<title>%d %s</title>\r\n"
                "</head><body>\r\n"
                "<h1>%s</h1>\r\n"
                "<p>%s</p>\r\n"
                "<hr />\r\n"
                "%s"
                "</body></html>\r\n",
                status_code,
                status_title,
                status_title,
                text ? text : "",
                ast_str_buffer(server_address));
 
    ast_free(server_address);
 
    ast_http_send(ser,
                  AST_HTTP_UNKNOWN,
                  status_code,
                  status_title,
                  http_header_data,
                  out,
                  0,
                  0);
}

References ast_debug, ast_free, ast_http_send(), AST_HTTP_UNKNOWN, ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), ast_tcptls_close_session_file(), ast_xml_escape(), http_server_name, INITIAL_RESPONSE_BODY_BUFFER, MAX_SERVER_NAME_LENGTH, out, and text.

Referenced by ast_http_auth(), and ast_http_error().

ast_http_error()

void ast_http_error	(	struct ast_tcptls_session_instance *	ser,
		int	status_code,
		const char *	status_title,
		const char *	text
	)

Send HTTP error message and close socket.

Definition at line 664 of file http.c.

{
    struct ast_str *http_header_data = ast_str_create(DEFAULT_RESPONSE_HEADER_LENGTH);
 
    if (http_header_data) {
        ast_str_set(&http_header_data, 0, "Content-type: text/html\r\n");
    }
 
    ast_http_create_response(ser,
                             status_code,
                             status_title,
                             http_header_data,
                             text);
}

References ast_http_create_response(), ast_str_create, ast_str_set(), DEFAULT_RESPONSE_HEADER_LENGTH, and text.

Referenced by ast_ari_callback(), ast_websocket_uri_cb(), auth_http_callback(), generic_http_callback(), handle_uri(), http_callback(), http_post_callback(), http_request_headers_get(), http_request_tracking_setup(), httpd_helper_thread(), httpd_process_request(), httpstatus_callback(), incoming_ws_http_callback(), phoneprov_callback(), static_callback(), and websocket_bad_request().

ast_http_ftype2mtype()

const char * ast_http_ftype2mtype

(

const char *

ftype

)

Return mime type based on extension.

Parameters

ftype

filename extension

Returns

String containing associated MIME type

Since

1.8

Definition at line 219 of file http.c.

{
    int x;
 
    if (ftype) {
        for (x = 0; x < ARRAY_LEN(mimetypes); x++) {
            if (!strcasecmp(ftype, mimetypes[x].ext)) {
                return mimetypes[x].mtype;
            }
        }
    }
    return NULL;
}

References ARRAY_LEN, ext, mimetypes, and NULL.

Referenced by build_profile(), and static_callback().

ast_http_get_auth()

struct ast_http_auth * ast_http_get_auth

(

struct ast_variable *

headers

)

Get HTTP authentication information from headers.

The returned object is AO2 managed, so clean up with ao2_cleanup().

Parameters

headers

HTTP request headers.

Returns

HTTP auth structure.

Return values

NULL	if no supported HTTP auth headers present.

Since

12

Definition at line 1611 of file http.c.

{
    struct ast_variable *v;
 
    for (v = headers; v; v = v->next) {
        const char *base64;
        char decoded[256] = {};
        char *username;
        char *password;
#ifdef AST_DEVMODE
        int cnt;
#endif /* AST_DEVMODE */
 
        if (strcasecmp("Authorization", v->name) != 0) {
            continue;
        }
 
        if (!ast_begins_with(v->value, BASIC_PREFIX)) {
            ast_log(LOG_DEBUG,
                "Unsupported Authorization scheme\n");
            continue;
        }
 
        /* Basic auth header parsing. RFC 2617, section 2.
         *   credentials = "Basic" basic-credentials
         *   basic-credentials = base64-user-pass
         *   base64-user-pass  = <base64 encoding of user-pass,
         *                        except not limited to 76 char/line>
         *   user-pass   = userid ":" password
         */
 
        base64 = v->value + BASIC_LEN;
 
        /* This will truncate "userid:password" lines to
         * sizeof(decoded). The array is long enough that this shouldn't
         * be a problem */
#ifdef AST_DEVMODE
        cnt =
#endif /* AST_DEVMODE */
        ast_base64decode((unsigned char*)decoded, base64,
            sizeof(decoded) - 1);
        ast_assert(cnt < sizeof(decoded));
 
        /* Split the string at the colon */
        password = decoded;
        username = strsep(&password, ":");
        if (!password) {
            ast_log(LOG_WARNING, "Invalid Authorization header\n");
            return NULL;
        }
 
        return auth_create(username, password);
    }
 
    return NULL;
}

References ast_assert, ast_base64decode(), ast_begins_with(), ast_log, auth_create(), base64, BASIC_LEN, BASIC_PREFIX, LOG_DEBUG, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, strsep(), and ast_variable::value.

Referenced by authenticate_user(), and http_callback().

ast_http_get_contents()

static char * ast_http_get_contents ( int *  return_length, struct ast_tcptls_session_instance *  ser, struct ast_variable *  headers  )

static

Returns the contents (body) of the HTTP request.

Parameters

return_length	ptr to int that returns content length
ser	HTTP TCP/TLS session object
headers	List of HTTP headers

Returns

ptr to content (zero terminated)

Return values

NULL	on failure

Note

Since returned ptr is malloc'd, it should be free'd by caller

Definition at line 1197 of file http.c.

{
    struct http_worker_private_data *request;
    int content_length;
    int bufsize;
    char *buf;
 
    request = ser->private_data;
    if (!ast_test_flag(&request->flags, HTTP_FLAG_HAS_BODY)) {
        /* no content - not an error */
        return NULL;
    }
    if (ast_test_flag(&request->flags, HTTP_FLAG_BODY_READ)) {
        /* Already read the body.  Cannot read again.  Assume no content. */
        ast_assert(0);
        return NULL;
    }
    ast_set_flag(&request->flags, HTTP_FLAG_BODY_READ);
 
    ast_debug(2, "HTTP consuming request body\n");
 
    ast_assert(request->body_length != 0);
    if (0 < request->body_length) {
        /* handle regular non-chunked content */
        content_length = request->body_length;
        if (content_length > MAX_CONTENT_LENGTH) {
            ast_log(LOG_WARNING, "Excessively long HTTP content. (%d > %d)\n",
                content_length, MAX_CONTENT_LENGTH);
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            errno = EFBIG;
            return NULL;
        }
        buf = ast_malloc(content_length + 1);
        if (!buf) {
            /* Malloc sets ENOMEM */
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            return NULL;
        }
 
        if (http_body_read_contents(ser, buf, content_length, "body")) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            errno = EIO;
            ast_free(buf);
            return NULL;
        }
 
        buf[content_length] = 0;
        *return_length = content_length;
        return buf;
    }
 
    /* pre-allocate buffer */
    bufsize = 250;
    buf = ast_malloc(bufsize);
    if (!buf) {
        ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
        return NULL;
    }
 
    /* parse chunked-body */
    content_length = 0;
    for (;;) {
        int chunk_length;
 
        chunk_length = http_body_get_chunk_length(ser);
        if (chunk_length < 0) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            errno = EIO;
            ast_free(buf);
            return NULL;
        }
        if (chunk_length == 0) {
            /* parsed last-chunk */
            break;
        }
        if (content_length + chunk_length > MAX_CONTENT_LENGTH) {
            ast_log(LOG_WARNING,
                "Excessively long HTTP accumulated chunked body. (%d + %d > %d)\n",
                content_length, chunk_length, MAX_CONTENT_LENGTH);
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            errno = EFBIG;
            ast_free(buf);
            return NULL;
        }
 
        /* insure buffer is large enough +1 */
        if (content_length + chunk_length >= bufsize) {
            char *new_buf;
 
            /* Increase bufsize until it can handle the expected data. */
            do {
                bufsize *= 2;
            } while (content_length + chunk_length >= bufsize);
 
            new_buf = ast_realloc(buf, bufsize);
            if (!new_buf) {
                ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
                ast_free(buf);
                return NULL;
            }
            buf = new_buf;
        }
 
        if (http_body_read_contents(ser, buf + content_length, chunk_length, "chunk-data")
            || http_body_check_chunk_sync(ser)) {
            ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
            errno = EIO;
            ast_free(buf);
            return NULL;
        }
        content_length += chunk_length;
    }
 
    /*
     * Read and discard any trailer entity-header lines
     * which we don't care about.
     *
     * XXX In the future we may need to add the trailer headers
     * to the passed in headers list rather than discarding them.
     */
    if (http_body_discard_chunk_trailer_headers(ser)) {
        ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
        errno = EIO;
        ast_free(buf);
        return NULL;
    }
 
    buf[content_length] = 0;
    *return_length = content_length;
    return buf;
}

References ast_assert, ast_debug, ast_free, ast_log, ast_malloc, ast_realloc, ast_set_flag, ast_test_flag, buf, errno, http_body_check_chunk_sync(), http_body_discard_chunk_trailer_headers(), http_body_get_chunk_length(), http_body_read_contents(), HTTP_FLAG_BODY_READ, HTTP_FLAG_CLOSE_ON_COMPLETION, HTTP_FLAG_HAS_BODY, LOG_WARNING, MAX_CONTENT_LENGTH, NULL, ast_tcptls_session_instance::private_data, and request().

Referenced by ast_http_get_json(), and ast_http_get_post_vars().

ast_http_get_cookies()

struct ast_variable * ast_http_get_cookies

(

struct ast_variable *

headers

)

Get cookie from Request headers.

Definition at line 1564 of file http.c.

{
    struct ast_variable *v, *cookies = NULL;
 
    for (v = headers; v; v = v->next) {
        if (!strcasecmp(v->name, "Cookie")) {
            ast_variables_destroy(cookies);
            cookies = parse_cookies(v->value);
        }
    }
    return cookies;
}

References ast_variables_destroy(), ast_variable::name, ast_variable::next, NULL, parse_cookies(), and ast_variable::value.

Referenced by ast_http_manid_from_vars(), and httpstatus_callback().

ast_http_get_json()

struct ast_json * ast_http_get_json	(	struct ast_tcptls_session_instance *	ser,
		struct ast_variable *	headers
	)

Get JSON from client Request Entity-Body, if content type is application/json.

Parameters

ser	TCP/TLS session object
headers	List of HTTP headers

Returns

Parsed JSON content body

Return values

NULL	on error, if no content, or if different content type.

Since

12

Definition at line 1330 of file http.c.

{
    int content_length = 0;
    struct ast_json *body;
    RAII_VAR(char *, buf, NULL, ast_free);
    RAII_VAR(char *, type, get_content_type(headers), ast_free);
 
    /* Use errno to distinguish errors from no body */
    errno = 0;
 
    if (ast_strlen_zero(type) || strcasecmp(type, "application/json")) {
        /* Content type is not JSON.  Don't read the body. */
        return NULL;
    }
 
    buf = ast_http_get_contents(&content_length, ser, headers);
    if (!buf || !content_length) {
        /*
         * errno already set
         * or it is not an error to have zero content
         */
        return NULL;
    }
 
    body = ast_json_load_buf(buf, content_length, NULL);
    if (!body) {
        /* Failed to parse JSON; treat as an I/O error */
        errno = EIO;
        return NULL;
    }
 
    return body;
}

References ast_free, ast_http_get_contents(), ast_json_load_buf(), ast_strlen_zero(), buf, errno, get_content_type(), NULL, RAII_VAR, and type.

Referenced by ast_ari_callback().

ast_http_get_post_vars()

struct ast_variable * ast_http_get_post_vars	(	struct ast_tcptls_session_instance *	ser,
		struct ast_variable *	headers
	)

Get post variables from client Request Entity-Body, if content type is application/x-www-form-urlencoded.

Parameters

ser	TCP/TLS session object
headers	List of HTTP headers

Returns

List of variables within the POST body

Note

Since returned list is malloc'd, list should be free'd by the calling function

Since

1.8

Definition at line 1405 of file http.c.

{
    int content_length = 0;
    RAII_VAR(char *, buf, NULL, ast_free);
    RAII_VAR(char *, type, get_content_type(headers), ast_free);
 
    /* Use errno to distinguish errors from no params */
    errno = 0;
 
    if (ast_strlen_zero(type) ||
        strcasecmp(type, "application/x-www-form-urlencoded")) {
        /* Content type is not form data.  Don't read the body. */
        return NULL;
    }
 
    buf = ast_http_get_contents(&content_length, ser, headers);
    if (!buf || !content_length) {
        /*
         * errno already set
         * or it is not an error to have zero content
         */
        return NULL;
    }
 
    return ast_http_parse_post_form(buf, content_length, type);
}

References ast_free, ast_http_get_contents(), ast_http_parse_post_form(), ast_strlen_zero(), buf, errno, get_content_type(), NULL, RAII_VAR, and type.

Referenced by ast_ari_callback(), auth_http_callback(), and generic_http_callback().

ast_http_header_match()

int ast_http_header_match	(	const char *	name,
		const char *	expected_name,
		const char *	value,
		const char *	expected_value
	)

Check if the header and value match (case insensitive) their associated expected values.

Parameters

name	header name to check
expected_name	the expected name of the header
value	header value to check
expected_value	the expected value of the header

Return values

0	if the name and expected name do not match
-1	if the value and expected value do not match
1	if the both the name and value match their expected value

Since

13

Definition at line 1786 of file http.c.

{
    if (strcasecmp(name, expected_name)) {
        /* no value to validate if names don't match */
        return 0;
    }
 
    if (strcasecmp(value, expected_value)) {
        ast_log(LOG_ERROR, "Invalid header value - expected %s "
            "received %s", value, expected_value);
        return -1;
    }
    return 1;
}

References ast_log, LOG_ERROR, name, and value.

Referenced by websocket_client_handshake_get_response().

ast_http_header_match_in()

int ast_http_header_match_in	(	const char *	name,
		const char *	expected_name,
		const char *	value,
		const char *	expected_value
	)

Check if the header name matches the expected header name. If so, then check to see if the value can be located in the expected value.

Note

Both header and value checks are case insensitive.

Parameters

name	header name to check
expected_name	the expected name of the header
value	header value to check if in expected value
expected_value	the expected value(s)

Return values

0	if the name and expected name do not match
-1	if the value and is not in the expected value
1	if the name matches expected name and value is in expected value

Since

13

Definition at line 1802 of file http.c.

{
    if (strcasecmp(name, expected_name)) {
        /* no value to validate if names don't match */
        return 0;
    }
 
    if (!strcasestr(expected_value, value)) {
        ast_log(LOG_ERROR, "Header '%s' - could not locate '%s' "
            "in '%s'\n", name, value, expected_value);
        return -1;
 
    }
    return 1;
}

References ast_log, LOG_ERROR, name, strcasestr(), and value.

Referenced by websocket_client_handshake_get_response().

ast_http_header_parse()

int ast_http_header_parse	(	char *	buf,
		char **	name,
		char **	value
	)

Parse a header into the given name/value strings.

Note

This modifies the given buffer and the out parameters point (not allocated) to the start of the header name and header value, respectively.

Parameters

	buf	a string containing the name/value to point to
[out]	name	header name
[out]	value	header value

Return values

-1	if buf is empty
0	if buf could be separated into name and value
1	if name or value portion don't exist

Since

13

Definition at line 1764 of file http.c.

{
    ast_trim_blanks(buf);
    if (ast_strlen_zero(buf)) {
        return -1;
    }
 
    *value = buf;
    *name = strsep(value, ":");
    if (!*value) {
        return 1;
    }
 
    *value = ast_skip_blanks(*value);
    if (ast_strlen_zero(*value) || ast_strlen_zero(*name)) {
        return 1;
    }
 
    remove_excess_lws(*value);
    return 0;
}

References ast_skip_blanks(), ast_strlen_zero(), ast_trim_blanks(), buf, name, remove_excess_lws(), strsep(), and value.

Referenced by websocket_client_handshake_get_response().

ast_http_manid_from_vars()

uint32_t ast_http_manid_from_vars

(

struct ast_variable *

headers

)

Return manager id, if exist, from request headers.

Parameters

headers

List of HTTP headers

Returns

32-bit associated manager session identifier

Since

1.8

Definition at line 233 of file http.c.

{
    uint32_t mngid = 0;
    struct ast_variable *v, *cookies;
 
    cookies = ast_http_get_cookies(headers);
    for (v = cookies; v; v = v->next) {
        if (!strcasecmp(v->name, "mansession_id")) {
            sscanf(v->value, "%30x", &mngid);
            break;
        }
    }
    ast_variables_destroy(cookies);
    return mngid;
}

References ast_http_get_cookies(), ast_variables_destroy(), ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by generic_http_callback(), http_post_callback(), and static_callback().

ast_http_parse_post_form()

struct ast_variable * ast_http_parse_post_form	(	char *	buf,
		int	content_length,
		const char *	content_type
	)

Get post variables from an application/x-www-form-urlencoded buffer.

Parameters

buf	input buffer
content_len	Buffer length
content_type	Content type (must be "application/x-www-form-urlencoded")

Warning

The input buffer will be modified by strsep() so pass in a copy if you need to keep the original.

Returns

List of ast_variables from the buffer. Must be freed with ast_variables_destroy().

Definition at line 1369 of file http.c.

{
    struct ast_variable *v, *post_vars=NULL, *prev = NULL;
    char *var, *val;
 
    /* Use errno to distinguish errors from no params */
    errno = 0;
 
    if (ast_strlen_zero(content_type) ||
        strcasecmp(content_type, "application/x-www-form-urlencoded") != 0) {
        /* Content type is not form data.  Don't read the body. */
        return NULL;
    }
 
    while ((val = strsep(&buf, "&"))) {
        var = strsep(&val, "=");
        if (val) {
            ast_uri_decode(val, ast_uri_http_legacy);
        } else  {
            val = "";
        }
        ast_uri_decode(var, ast_uri_http_legacy);
        if ((v = ast_variable_new(var, val, ""))) {
            if (post_vars) {
                prev->next = v;
            } else {
                post_vars = v;
            }
            prev = v;
        }
    }
 
    return post_vars;
}

References ast_strlen_zero(), ast_uri_decode(), ast_uri_http_legacy, ast_variable_new, buf, errno, NULL, strsep(), and var.

Referenced by ast_http_get_post_vars(), and parse_rest_request_msg().

ast_http_prefix()

void ast_http_prefix	(	char *	buf,
		int	len
	)

Return the current prefix.

Parameters

[out]	buf	destination buffer for previous
[in]	len	length of prefix to copy

Since

1.6.1

Definition at line 249 of file http.c.

{
    if (buf) {
        ast_copy_string(buf, prefix, len);
    }
}

References ast_copy_string(), buf, len(), and prefix.

ast_http_request_close_on_completion()

void ast_http_request_close_on_completion

(

struct ast_tcptls_session_instance *

ser

)

Request the HTTP connection be closed after this HTTP request.

Since

12.4.0

Parameters

ser	HTTP TCP/TLS session object.

Note

Call before ast_http_error() to make the connection close.

Definition at line 853 of file http.c.

{
    struct http_worker_private_data *request = ser->private_data;
 
    ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
}

References ast_set_flag, HTTP_FLAG_CLOSE_ON_COMPLETION, ast_tcptls_session_instance::private_data, and request().

Referenced by ast_ari_callback(), ast_ari_invoke(), auth_http_callback(), generic_http_callback(), handle_uri(), http_callback(), http_post_callback(), httpstatus_callback(), static_callback(), and websocket_bad_request().

ast_http_response_status_line()

int ast_http_response_status_line	(	const char *	buf,
		const char *	version,
		int	code
	)

Parse the http response status line.

Parameters

buf	the http response line information
version	the expected http version (e.g. HTTP/1.1)
code	the expected status code

Return values

-1	if version didn't match or status code conversion fails.

Returns

status code (>0)

Since

13

Definition at line 1712 of file http.c.

{
    int status_code;
    size_t size = strlen(version);
 
    if (strncmp(buf, version, size) || buf[size] != ' ') {
        ast_log(LOG_ERROR, "HTTP version not supported - "
            "expected %s\n", version);
        return -1;
    }
 
    /* skip to status code (version + space) */
    buf += size + 1;
 
    if (sscanf(buf, "%d", &status_code) != 1) {
        ast_log(LOG_ERROR, "Could not read HTTP status code - "
            "%s\n", buf);
        return -1;
    }
 
    return status_code;
}

References ast_log, buf, LOG_ERROR, and version.

Referenced by websocket_client_handshake_get_response().

ast_http_send()

void ast_http_send	(	struct ast_tcptls_session_instance *	ser,
		enum ast_http_method	method,
		int	status_code,
		const char *	status_title,
		struct ast_str *	http_header,
		struct ast_str *	out,
		int	fd,
		unsigned int	static_content
	)

Generic function for sending HTTP/1.1 response.

Parameters

ser	TCP/TLS session object
method	GET/POST/HEAD
status_code	HTTP response code (200/401/403/404/500)
status_title	English equivalent to the status_code parameter
http_header	An ast_str object containing all headers
out	An ast_str object containing the body of the response
fd	If out is NULL, a file descriptor where the body of the response is held (otherwise -1)
static_content	Zero if the content is dynamically generated and should not be cached; nonzero otherwise

Note

Function determines the HTTP response header from status_code, status_header, and http_header.

Extra HTTP headers MUST be present only in the http_header argument. The argument "out" should contain only content of the response (no headers!).

HTTP content can be constructed from the argument "out", if it is not NULL; otherwise, the function will read content from FD.

This function calculates the content-length http header itself.

Both the http_header and out arguments will be freed by this function; however, if FD is open, it will remain open.

Since

1.8

Definition at line 472 of file http.c.

{
    struct timeval now = ast_tvnow();
    struct ast_tm tm;
    char timebuf[80];
    char buf[256];
    int len;
    int content_length = 0;
    int close_connection;
    struct ast_str *server_header_field = ast_str_create(MAX_SERVER_NAME_LENGTH);
    int send_content;
 
    if (!ser || !server_header_field) {
        /* The connection is not open. */
        ast_free(http_header);
        ast_free(out);
        ast_free(server_header_field);
        return;
    }
 
    if(!ast_strlen_zero(http_server_name)) {
        ast_str_set(&server_header_field,
                    0,
                    "Server: %s\r\n",
                    http_server_name);
    }
 
    /*
     * We shouldn't be sending non-final status codes to this
     * function because we may close the connection before
     * returning.
     */
    ast_assert(200 <= status_code);
 
    if (session_keep_alive <= 0) {
        close_connection = 1;
    } else {
        struct http_worker_private_data *request;
 
        request = ser->private_data;
        if (!request
            || ast_test_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION)
            || ast_http_body_discard(ser)) {
            close_connection = 1;
        } else {
            close_connection = 0;
        }
    }
 
    ast_strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", ast_localtime(&now, &tm, "GMT"));
 
    /* calc content length */
    if (out) {
        content_length += ast_str_strlen(out);
    }
 
    if (fd) {
        content_length += lseek(fd, 0, SEEK_END);
        lseek(fd, 0, SEEK_SET);
    }
 
    send_content = method != AST_HTTP_HEAD || status_code >= 400;
 
    /* send http header */
    if (ast_iostream_printf(ser->stream,
        "HTTP/1.1 %d %s\r\n"
        "%s"
        "Date: %s\r\n"
        "%s"
        "%s"
        "%s"
        "Content-Length: %d\r\n"
        "\r\n"
        "%s",
        status_code, status_title ? status_title : "OK",
        ast_str_buffer(server_header_field),
        timebuf,
        close_connection ? "Connection: close\r\n" : "",
        static_content ? "" : "Cache-Control: no-cache, no-store\r\n",
        http_header ? ast_str_buffer(http_header) : "",
        content_length,
        send_content && out && ast_str_strlen(out) ? ast_str_buffer(out) : ""
        ) <= 0) {
        ast_debug(1, "ast_iostream_printf() failed: %s\n", strerror(errno));
        close_connection = 1;
    } else if (send_content && fd) {
        /* send file content */
        while ((len = read(fd, buf, sizeof(buf))) > 0) {
            if (ast_iostream_write(ser->stream, buf, len) != len) {
                ast_debug(1, "ast_iostream_write() failed: %s\n", strerror(errno));
                close_connection = 1;
                break;
            }
        }
    }
 
    ast_free(http_header);
    ast_free(out);
    ast_free(server_header_field);
 
    if (close_connection) {
        ast_debug(1, "HTTP closing session.  status_code:%d\n", status_code);
        ast_tcptls_close_session_file(ser);
    } else {
        ast_debug(1, "HTTP keeping session open.  status_code:%d\n", status_code);
    }
}

References ast_assert, ast_debug, ast_free, ast_http_body_discard(), AST_HTTP_HEAD, ast_iostream_printf(), ast_iostream_write(), ast_localtime(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_str_strlen(), ast_strftime(), ast_strlen_zero(), ast_tcptls_close_session_file(), ast_test_flag, ast_tvnow(), buf, errno, HTTP_FLAG_CLOSE_ON_COMPLETION, http_server_name, len(), MAX_SERVER_NAME_LENGTH, method, out, ast_tcptls_session_instance::private_data, request(), session_keep_alive, and ast_tcptls_session_instance::stream.

Referenced by ast_ari_callback(), ast_http_create_response(), auth_http_callback(), generic_http_callback(), handle_uri(), http_callback(), http_callback(), httpstatus_callback(), phoneprov_callback(), static_callback(), and websocket_bad_request().

ast_http_uri_link()

int ast_http_uri_link

(

struct ast_http_uri *

urih

)

Link the new uri into the list.

Register a URI handler.

They are sorted by length of the string, not alphabetically. Duplicate entries are not replaced, but the insertion order (using <= and not just <) makes sure that more recent insertions hide older ones. On a lookup, we just scan the list and stop at the first matching entry.

Definition at line 689 of file http.c.

{
    struct ast_http_uri *uri;
    int len = strlen(urih->uri);
 
    AST_RWLIST_WRLOCK(&uris);
 
    urih->prefix = prefix;
 
    if ( AST_RWLIST_EMPTY(&uris) || strlen(AST_RWLIST_FIRST(&uris)->uri) <= len ) {
        AST_RWLIST_INSERT_HEAD(&uris, urih, entry);
        AST_RWLIST_UNLOCK(&uris);
        return 0;
    }
 
    AST_RWLIST_TRAVERSE(&uris, uri, entry) {
        if (AST_RWLIST_NEXT(uri, entry) &&
            strlen(AST_RWLIST_NEXT(uri, entry)->uri) <= len) {
            AST_RWLIST_INSERT_AFTER(&uris, uri, urih, entry);
            AST_RWLIST_UNLOCK(&uris);
 
            return 0;
        }
    }
 
    AST_RWLIST_INSERT_TAIL(&uris, urih, entry);
 
    AST_RWLIST_UNLOCK(&uris);
 
    return 0;
}

References AST_RWLIST_EMPTY, AST_RWLIST_FIRST, AST_RWLIST_INSERT_AFTER, AST_RWLIST_INSERT_HEAD, AST_RWLIST_INSERT_TAIL, AST_RWLIST_NEXT, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_http_uri::entry, len(), ast_http_uri::prefix, prefix, and ast_http_uri::uri.

Referenced by __ast_http_load(), __ast_http_post_load(), __init_manager(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), reload_module(), and reload_module().

ast_http_uri_unlink()

void ast_http_uri_unlink

(

struct ast_http_uri *

urih

)

Unregister a URI handler.

Definition at line 721 of file http.c.

{
    AST_RWLIST_WRLOCK(&uris);
    AST_RWLIST_REMOVE(&uris, urih, entry);
    AST_RWLIST_UNLOCK(&uris);
}

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and ast_http_uri::entry.

Referenced by __ast_http_load(), __init_manager(), load_module(), reload_module(), reload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), and unload_module().

ast_http_uri_unlink_all_with_key()

void ast_http_uri_unlink_all_with_key

(

const char *

key

)

Unregister all handlers with matching key.

Definition at line 728 of file http.c.

{
    struct ast_http_uri *urih;
    AST_RWLIST_WRLOCK(&uris);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&uris, urih, entry) {
        if (!strcmp(urih->key, key)) {
            AST_RWLIST_REMOVE_CURRENT(entry);
            if (urih->dmallocd) {
                ast_free(urih->data);
            }
            if (urih->mallocd) {
                ast_free(urih);
            }
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&uris);
}

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_http_uri::data, ast_http_uri::dmallocd, ast_http_uri::entry, ast_http_uri::key, and ast_http_uri::mallocd.

Referenced by __ast_http_post_load(), and unload_module().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2755 of file http.c.

auth_create()

static struct ast_http_auth * auth_create ( const char *  userid, const char *  password  )

static

Definition at line 1577 of file http.c.

{
    struct ast_http_auth *auth;
    size_t userid_len;
    size_t password_len;
 
    if (!userid || !password) {
        ast_log(LOG_ERROR, "Invalid userid/password\n");
        return NULL;
    }
 
    userid_len = strlen(userid) + 1;
    password_len = strlen(password) + 1;
 
    /* Allocate enough room to store everything in one memory block */
    auth = ao2_alloc(sizeof(*auth) + userid_len + password_len, NULL);
    if (!auth) {
        return NULL;
    }
 
    /* Put the userid right after the struct */
    auth->userid = (char *)(auth + 1);
    strcpy(auth->userid, userid);
 
    /* Put the password right after the userid */
    auth->password = auth->userid + userid_len;
    strcpy(auth->password, password);
 
    return auth;
}

References ao2_alloc, ast_log, LOG_ERROR, NULL, ast_http_auth::password, and ast_http_auth::userid.

Referenced by ast_http_get_auth().

chunked_atoh()

static int chunked_atoh ( const char *  s, int  len  )

static

Definition at line 1002 of file http.c.

{
    int value = 0;
    char c;
 
    if (*s < '0') {
        /* zero value must be 0\n not just \n */
        return -1;
    }
 
    while (len--) {
        c = *s++;
        if (c == '\x0D') {
            return value;
        }
        if (c == ';') {
            /* We have a chunk-extension that we don't care about. */
            while (len--) {
                if (*s++ == '\x0D') {
                    return value;
                }
            }
            break;
        }
        value <<= 4;
        if (c >= '0' && c <= '9') {
            value += c - '0';
            continue;
        }
        if (c >= 'a' && c <= 'f') {
            value += 10 + c - 'a';
            continue;
        }
        if (c >= 'A' && c <= 'F') {
            value += 10 + c - 'A';
            continue;
        }
        /* invalid character */
        return -1;
    }
    /* end of string */
    return -1;
}

References c, len(), and value.

Referenced by http_body_get_chunk_length().

get_content_length()

static int get_content_length ( struct ast_variable *  headers )

static

Returns the value of the Content-Length header.

Parameters

headers

HTTP headers.

Returns

length Value of the Content-Length header.

Return values

0	if header is not present.
-1	if header is invalid.

Definition at line 803 of file http.c.

{
    const char *content_length = get_header(headers, "Content-Length");
    int length;
 
    if (!content_length) {
        /* Missing content length; assume zero */
        return 0;
    }
 
    length = 0;
    if (sscanf(content_length, "%30d", &length) != 1) {
        /* Invalid Content-Length value */
        length = -1;
    }
    return length;
}

References get_header().

Referenced by http_request_tracking_setup().

get_content_type()

static char * get_content_type ( struct ast_variable *  headers )

static

Retrieves the content type specified in the "Content-Type" header.

This function only returns the "type/subtype" and any trailing parameter is not included.

Note

the return value is an allocated string that needs to be freed.

Returns

the content type/subtype

Return values

NULL	if the header is not found.

Definition at line 778 of file http.c.

{
    const char *content_type = get_header(headers, "Content-Type");
    const char *param;
    size_t size;
 
    if (!content_type) {
        return NULL;
    }
 
    param = strchr(content_type, ';');
    size = param ? param - content_type : strlen(content_type);
 
    return ast_strndup(content_type, size);
}

References ast_strndup, get_header(), and NULL.

Referenced by ast_http_get_json(), and ast_http_get_post_vars().

get_header()

static const char * get_header ( struct ast_variable *  headers, const char *  field_name  )

static

Retrieves the header with the given field name.

Parameters

headers	Headers to search.
field_name	Name of the header to find.

Returns

Associated header value.

Return values

NULL	if header is not present.

Definition at line 755 of file http.c.

{
    struct ast_variable *v;
 
    for (v = headers; v; v = v->next) {
        if (!strcasecmp(v->name, field_name)) {
            return v->value;
        }
    }
    return NULL;
}

References ast_variable::name, ast_variable::next, NULL, and ast_variable::value.

Referenced by get_content_length(), get_content_type(), get_transfer_encoding(), and http_check_connection_close().

get_transfer_encoding()

static const char * get_transfer_encoding ( struct ast_variable *  headers )

static

Returns the value of the Transfer-Encoding header.

Parameters

headers

HTTP headers.

Returns

string Value of the Transfer-Encoding header.

Return values

NULL	if header is not present.

Definition at line 828 of file http.c.

{
    return get_header(headers, "Transfer-Encoding");
}

References get_header().

Referenced by http_request_tracking_setup(), and httpd_process_request().

handle_show_http()

static char * handle_show_http ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2632 of file http.c.

{
    struct ast_http_uri *urih;
    struct http_uri_redirect *redirect;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "http show status";
        e->usage =
            "Usage: http show status\n"
            "       Lists status of internal HTTP engine\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
    ast_cli(a->fd, "HTTP Server Status:\n");
    ast_cli(a->fd, "Prefix: %s\n", prefix);
    ast_cli(a->fd, "Server: %s\n", http_server_name);
    if (!global_http_server) {
        ast_cli(a->fd, "Server Disabled\n\n");
    } else {
        ast_cli(a->fd, "Server Enabled and Bound to %s\n\n",
            ast_sockaddr_stringify(&global_http_server->args.old_address));
        if (http_tls_cfg.enabled) {
            ast_cli(a->fd, "HTTPS Server Enabled and Bound to %s\n\n",
                ast_sockaddr_stringify(&https_desc.old_address));
        }
    }
 
    ast_cli(a->fd, "Enabled URI's:\n");
    AST_RWLIST_RDLOCK(&uris);
    if (AST_RWLIST_EMPTY(&uris)) {
        ast_cli(a->fd, "None.\n");
    } else {
        AST_RWLIST_TRAVERSE(&uris, urih, entry)
            ast_cli(a->fd, "%s/%s%s => %s\n", prefix, urih->uri, (urih->has_subtree ? "/..." : "" ), urih->description);
    }
    AST_RWLIST_UNLOCK(&uris);
 
    ast_cli(a->fd, "\nEnabled Redirects:\n");
    AST_RWLIST_RDLOCK(&uri_redirects);
    AST_RWLIST_TRAVERSE(&uri_redirects, redirect, entry)
        ast_cli(a->fd, "  %s => %s\n", redirect->target, redirect->dest);
    if (AST_RWLIST_EMPTY(&uri_redirects)) {
        ast_cli(a->fd, "  None.\n");
    }
    AST_RWLIST_UNLOCK(&uri_redirects);
 
    return CLI_SUCCESS;
}

References a, ast_http_server::args, ast_cli(), AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_sockaddr_stringify(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_http_uri::description, http_uri_redirect::dest, ast_tls_config::enabled, http_uri_redirect::entry, global_http_server, ast_http_uri::has_subtree, http_server_name, http_tls_cfg, https_desc, NULL, ast_tcptls_session_args::old_address, prefix, http_uri_redirect::target, ast_http_uri::uri, and ast_cli_entry::usage.

handle_uri()

static int handle_uri ( struct ast_tcptls_session_instance *  ser, char *  uri, enum ast_http_method  method, struct ast_variable *  headers  )

static

Definition at line 1433 of file http.c.

{
    char *c;
    int res = 0;
    char *params = uri;
    struct ast_http_uri *urih = NULL;
    int l;
    struct ast_variable *get_vars = NULL, *v, *prev = NULL;
    struct http_uri_redirect *redirect;
 
    ast_debug(2, "HTTP Request URI is %s \n", uri);
 
    strsep(&params, "?");
    /* Extract arguments from the request and store them in variables. */
    if (params) {
        char *var, *val;
 
        while ((val = strsep(&params, "&"))) {
            var = strsep(&val, "=");
            if (val) {
                ast_uri_decode(val, ast_uri_http_legacy);
            } else  {
                val = "";
            }
            ast_uri_decode(var, ast_uri_http_legacy);
            if ((v = ast_variable_new(var, val, ""))) {
                if (get_vars) {
                    prev->next = v;
                } else {
                    get_vars = v;
                }
                prev = v;
            }
        }
    }
 
    AST_RWLIST_RDLOCK(&uri_redirects);
    AST_RWLIST_TRAVERSE(&uri_redirects, redirect, entry) {
        if (!strcasecmp(uri, redirect->target)) {
            struct ast_str *http_header = ast_str_create(128);
 
            if (!http_header) {
                ast_http_request_close_on_completion(ser);
                ast_http_error(ser, 500, "Server Error", "Out of memory");
                break;
            }
            ast_str_set(&http_header, 0, "Location: %s\r\n", redirect->dest);
            ast_http_send(ser, method, 302, "Moved Temporarily", http_header, NULL, 0, 0);
            break;
        }
    }
    AST_RWLIST_UNLOCK(&uri_redirects);
    if (redirect) {
        goto cleanup;
    }
 
    /* We want requests to start with the (optional) prefix and '/' */
    l = strlen(prefix);
    if (!strncasecmp(uri, prefix, l) && uri[l] == '/') {
        uri += l + 1;
        /* scan registered uris to see if we match one. */
        AST_RWLIST_RDLOCK(&uris);
        AST_RWLIST_TRAVERSE(&uris, urih, entry) {
            l = strlen(urih->uri);
            c = uri + l;    /* candidate */
            ast_debug(2, "match request [%s] with handler [%s] len %d\n", uri, urih->uri, l);
            if (strncasecmp(urih->uri, uri, l) /* no match */
                || (*c && *c != '/')) { /* substring */
                continue;
            }
            if (*c == '/') {
                c++;
            }
            if (!*c || urih->has_subtree) {
                uri = c;
                break;
            }
        }
        AST_RWLIST_UNLOCK(&uris);
    }
    if (urih) {
        ast_debug(1, "Match made with [%s]\n", urih->uri);
        if (!urih->no_decode_uri) {
            ast_uri_decode(uri, ast_uri_http_legacy);
        }
        res = urih->callback(ser, urih, uri, method, get_vars, headers);
    } else {
        ast_debug(1, "Requested URI [%s] has no handler\n", uri);
        ast_http_error(ser, 404, "Not Found", "The requested URL was not found on this server.");
    }
 
cleanup:
    ast_variables_destroy(get_vars);
    return res;
}

References ast_debug, ast_http_error(), ast_http_request_close_on_completion(), ast_http_send(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_create, ast_str_set(), ast_uri_decode(), ast_uri_http_legacy, ast_variable_new, ast_variables_destroy(), c, ast_http_uri::callback, cleanup(), http_uri_redirect::dest, http_uri_redirect::entry, ast_http_uri::has_subtree, method, ast_http_uri::no_decode_uri, NULL, prefix, strsep(), http_uri_redirect::target, ast_http_uri::uri, and var.

Referenced by httpd_process_request().

http_body_check_chunk_sync()

static int http_body_check_chunk_sync ( struct ast_tcptls_session_instance *  ser )

static

Definition at line 1084 of file http.c.

{
    int res;
    char chunk_sync[2];
 
    /* Stay in fread until get the expected CRLF or timeout. */
    res = ast_iostream_read(ser->stream, chunk_sync, sizeof(chunk_sync));
    if (res < sizeof(chunk_sync)) {
        ast_log(LOG_WARNING, "Short HTTP chunk sync read (Wanted %zu)\n",
            sizeof(chunk_sync));
        return -1;
    }
    if (chunk_sync[0] != 0x0D || chunk_sync[1] != 0x0A) {
        ast_log(LOG_WARNING, "HTTP chunk sync bytes wrong (0x%02hhX, 0x%02hhX)\n",
            (unsigned char) chunk_sync[0], (unsigned char) chunk_sync[1]);
        return -1;
    }
 
    return 0;
}

References ast_iostream_read(), ast_log, LOG_WARNING, and ast_tcptls_session_instance::stream.

Referenced by ast_http_body_discard(), and ast_http_get_contents().

http_body_discard_chunk_trailer_headers()

static int http_body_discard_chunk_trailer_headers ( struct ast_tcptls_session_instance *  ser )

static

Definition at line 1115 of file http.c.

{
    char header_line[MAX_HTTP_LINE_LENGTH];
 
    for (;;) {
        if (ast_iostream_gets(ser->stream, header_line, sizeof(header_line)) <= 0) {
            ast_log(LOG_WARNING, "Short HTTP read of chunked trailer header\n");
            return -1;
        }
 
        /* Trim trailing whitespace */
        ast_trim_blanks(header_line);
        if (ast_strlen_zero(header_line)) {
            /* A blank line ends the chunked-body */
            break;
        }
    }
    return 0;
}

References ast_iostream_gets(), ast_log, ast_strlen_zero(), ast_trim_blanks(), LOG_WARNING, MAX_HTTP_LINE_LENGTH, and ast_tcptls_session_instance::stream.

Referenced by ast_http_body_discard(), and ast_http_get_contents().

http_body_discard_contents()

static int http_body_discard_contents ( struct ast_tcptls_session_instance *  ser, int  length, const char *  what_getting  )

static

Definition at line 979 of file http.c.

{
    ssize_t res;
 
    res = ast_iostream_discard(ser->stream, length);
    if (res < length) {
        ast_log(LOG_WARNING, "Short HTTP request %s (Wanted %d but got %zd)\n",
            what_getting, length, res);
        return -1;
    }
    return 0;
}

References ast_iostream_discard(), ast_log, LOG_WARNING, and ast_tcptls_session_instance::stream.

Referenced by ast_http_body_discard().

http_body_get_chunk_length()

static int http_body_get_chunk_length ( struct ast_tcptls_session_instance *  ser )

static

Definition at line 1056 of file http.c.

{
    int length;
    char header_line[MAX_HTTP_LINE_LENGTH];
 
    /* get the line of hexadecimal giving chunk-size w/ optional chunk-extension */
    if (ast_iostream_gets(ser->stream, header_line, sizeof(header_line)) <= 0) {
        ast_log(LOG_WARNING, "Short HTTP read of chunked header\n");
        return -1;
    }
    length = chunked_atoh(header_line, strlen(header_line));
    if (length < 0) {
        ast_log(LOG_WARNING, "Invalid HTTP chunk size\n");
        return -1;
    }
    return length;
}

References ast_iostream_gets(), ast_log, chunked_atoh(), LOG_WARNING, MAX_HTTP_LINE_LENGTH, and ast_tcptls_session_instance::stream.

Referenced by ast_http_body_discard(), and ast_http_get_contents().

http_body_read_contents()

static int http_body_read_contents ( struct ast_tcptls_session_instance *  ser, char *  buf, int  length, const char *  what_getting  )

static

Definition at line 943 of file http.c.

{
    int res;
    int total = 0;
 
    /* Stream is in exclusive mode so we get it all if possible. */
    while (total != length) {
        res = ast_iostream_read(ser->stream, buf + total, length - total);
        if (res <= 0) {
            break;
        }
 
        total += res;
    }
 
    if (total != length) {
        ast_log(LOG_WARNING, "Wrong HTTP content read. Request %s (Wanted %d, Read %d)\n",
            what_getting, length, res);
        return -1;
    }
 
    return 0;
}

References ast_iostream_read(), ast_log, buf, LOG_WARNING, ast_tcptls_session_instance::stream, and total.

Referenced by ast_http_get_contents().

http_check_connection_close()

static int http_check_connection_close ( struct ast_variable *  headers )

static

Definition at line 842 of file http.c.

{
    const char *connection = get_header(headers, "Connection");
    int close_connection = 0;
 
    if (connection && !strcasecmp(connection, "close")) {
        close_connection = -1;
    }
    return close_connection;
}

References get_header().

Referenced by http_request_tracking_setup().

http_request_headers_get()

static int http_request_headers_get ( struct ast_tcptls_session_instance *  ser, struct ast_variable **  headers  )

static

Definition at line 1833 of file http.c.

{
    struct ast_variable *tail = *headers;
    int remaining_headers;
    char header_line[MAX_HTTP_LINE_LENGTH];
 
    remaining_headers = MAX_HTTP_REQUEST_HEADERS;
    for (;;) {
        ssize_t len;
        char *name;
        char *value;
 
        len = ast_iostream_gets(ser->stream, header_line, sizeof(header_line));
        if (len <= 0) {
            ast_http_error(ser, 400, "Bad Request", "Timeout");
            return -1;
        }
        if (header_line[len - 1] != '\n') {
            /* We didn't get a full line */
            ast_http_error(ser, 400, "Bad Request",
                (len == sizeof(header_line) - 1) ? "Header line too long" : "Timeout");
            return -1;
        }
 
        /* Trim trailing characters */
        ast_trim_blanks(header_line);
        if (ast_strlen_zero(header_line)) {
            /* A blank line ends the request header section. */
            break;
        }
 
        value = header_line;
        name = strsep(&value, ":");
        if (!value) {
            continue;
        }
 
        value = ast_skip_blanks(value);
        if (ast_strlen_zero(value) || ast_strlen_zero(name)) {
            continue;
        }
 
        ast_trim_blanks(name);
 
        if (!remaining_headers--) {
            /* Too many headers. */
            ast_http_error(ser, 413, "Request Entity Too Large", "Too many headers");
            return -1;
        }
        if (!*headers) {
            *headers = ast_variable_new(name, value, __FILE__);
            tail = *headers;
        } else {
            tail->next = ast_variable_new(name, value, __FILE__);
            tail = tail->next;
        }
        if (!tail) {
            /*
             * Variable allocation failure.
             * Try to make some room.
             */
            ast_variables_destroy(*headers);
            *headers = NULL;
 
            ast_http_error(ser, 500, "Server Error", "Out of memory");
            return -1;
        }
    }
 
    return 0;
}

References ast_http_error(), ast_iostream_gets(), ast_skip_blanks(), ast_strlen_zero(), ast_trim_blanks(), ast_variable_new, ast_variables_destroy(), len(), MAX_HTTP_LINE_LENGTH, MAX_HTTP_REQUEST_HEADERS, name, ast_variable::next, NULL, ast_tcptls_session_instance::stream, strsep(), and value.

Referenced by httpd_process_request().

http_request_tracking_init()

static void http_request_tracking_init ( struct http_worker_private_data *  request )

static

Definition at line 867 of file http.c.

{
    ast_set_flags_to(&request->flags,
        HTTP_FLAG_HAS_BODY | HTTP_FLAG_BODY_READ | HTTP_FLAG_CLOSE_ON_COMPLETION,
        /* Assume close in case request fails early */
        HTTP_FLAG_CLOSE_ON_COMPLETION);
}

References ast_set_flags_to, HTTP_FLAG_BODY_READ, HTTP_FLAG_CLOSE_ON_COMPLETION, HTTP_FLAG_HAS_BODY, and request().

Referenced by httpd_helper_thread(), and httpd_process_request().

http_request_tracking_setup()

static int http_request_tracking_setup ( struct ast_tcptls_session_instance *  ser, struct ast_variable *  headers  )

static

Definition at line 886 of file http.c.

{
    struct http_worker_private_data *request = ser->private_data;
    const char *transfer_encoding;
 
    ast_set_flags_to(&request->flags,
        HTTP_FLAG_HAS_BODY | HTTP_FLAG_BODY_READ | HTTP_FLAG_CLOSE_ON_COMPLETION,
        http_check_connection_close(headers) ? HTTP_FLAG_CLOSE_ON_COMPLETION : 0);
 
    transfer_encoding = get_transfer_encoding(headers);
    if (transfer_encoding && !strcasecmp(transfer_encoding, "chunked")) {
        request->body_length = -1;
        ast_set_flag(&request->flags, HTTP_FLAG_HAS_BODY);
        return 0;
    }
 
    request->body_length = get_content_length(headers);
    if (0 < request->body_length) {
        ast_set_flag(&request->flags, HTTP_FLAG_HAS_BODY);
    } else if (request->body_length < 0) {
        /* Invalid Content-Length */
        ast_set_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION);
        ast_http_error(ser, 400, "Bad Request", "Invalid Content-Length in request!");
        return -1;
    }
    return 0;
}

References ast_http_error(), ast_set_flag, ast_set_flags_to, get_content_length(), get_transfer_encoding(), http_check_connection_close(), HTTP_FLAG_BODY_READ, HTTP_FLAG_CLOSE_ON_COMPLETION, HTTP_FLAG_HAS_BODY, ast_tcptls_session_instance::private_data, and request().

Referenced by httpd_process_request().

http_server_create()

static struct ast_http_server * http_server_create ( const char *  name, const char *  address, const struct ast_sockaddr *  addr  )

static

Definition at line 2173 of file http.c.

{
    struct ast_http_server *server;
 
    server = ao2_alloc(sizeof(*server), http_server_destroy);
    if (!server) {
        ast_log(LOG_ERROR, "Unable to allocate HTTP server '%s' at address '%s'\n",
            name, address);
        return NULL;
    }
 
    if (!(server->address = ast_strdup(address)) || !(server->name = ast_strdup(name))) {
        ast_log(LOG_ERROR, "Unable to complete setup for HTTP server '%s' at address '%s'\n",
            name, address);
        ao2_ref(server, -1);
        return NULL;
    }
 
    server->args.accept_fd = -1;
    server->args.master = AST_PTHREADT_NULL;
    server->args.tls_cfg = NULL;
    server->args.poll_timeout = -1;
    server->args.name = server->name;
    server->args.accept_fn = ast_tcptls_server_root;
    server->args.worker_fn = httpd_helper_thread;
 
    ast_sockaddr_copy(&server->args.local_address, addr);
 
    return server;
}

References ast_tcptls_session_args::accept_fd, ast_tcptls_session_args::accept_fn, ast_http_server::address, ao2_alloc, ao2_ref, ast_http_server::args, ast_log, AST_PTHREADT_NULL, ast_sockaddr_copy(), ast_strdup, ast_tcptls_server_root(), http_server_destroy(), httpd_helper_thread(), ast_tcptls_session_args::local_address, LOG_ERROR, ast_tcptls_session_args::master, name, ast_tcptls_session_args::name, ast_http_server::name, NULL, ast_tcptls_session_args::poll_timeout, ast_tcptls_session_args::tls_cfg, and ast_tcptls_session_args::worker_fn.

Referenced by http_server_get_by_addr().

http_server_destroy()

static void http_server_destroy ( void *  obj )

static

Definition at line 2161 of file http.c.

{
    struct ast_http_server *server = obj;
 
    ast_tcptls_server_stop(&server->args);
 
    ast_verb(1, "Stopped http server '%s' listening at '%s'\n", server->name, server->address);
 
    ast_free(server->name);
    ast_free(server->address);
}

References ast_http_server::address, ast_http_server::args, ast_free, ast_tcptls_server_stop(), ast_verb, and ast_http_server::name.

Referenced by http_server_create().

http_server_discard()

static void http_server_discard ( struct ast_http_server *  server )

static

Discard/Drop a HTTP server.

Decrements the reference to the given object, and unlinks it from the servers container if it's the last reference.

After a server object has been added to the container this method should always be called to decrement the object's reference instead of the regular ao2 methods.

Note

NULL tolerant

Parameters

server

The server object

Definition at line 2243 of file http.c.

{
    if (!server) {
        return;
    }
 
    /*
     * If only two references were on the object then the last one is from
     * the servers container, so remove from container now.
     */
    if (ao2_ref(server, -1) == 2) {
        ao2_unlink(http_servers, server);
    }
}

References ao2_ref, ao2_unlink, and http_servers.

Referenced by __ast_http_load(), and http_server_get().

http_server_get()

static struct ast_http_server * http_server_get ( const char *  name, const char *  host, uint32_t  port, struct ast_http_server **  replace_me  )

static

Retrieve, or create and start a HTTP server.

Resolve the given host, and retrieve a listening server object. If the server is not already listening then start it. If a replace_me parameter is given, and it points to a non-NULL value then that server is discarded and replaced.

Parameters

	name	The name of the server
	host	The host to resolve, and match on or create a new object with
	port	Optional port used if one is not specified with the host (default 8088)
[out]	replace_me	Optional server to be replaced

Note

If replace_me is specified the returned value is always the same as what's passed back out in the variable.

Returns

a HTTP server object, or NULL on error

Definition at line 2353 of file http.c.

{
    struct ast_http_server *server;
 
    ao2_lock(http_servers);
 
    server = http_server_get_by_host(name, host, port);
 
    if (replace_me) {
        /* Only replace if different */
        if (*replace_me == server) {
            ao2_cleanup(server);
            ao2_unlock(http_servers);
            return *replace_me;
        }
 
        if (*replace_me) {
            http_server_discard(*replace_me);
        }
 
        *replace_me = server;
    }
 
    if (server && http_server_start(server)) {
        if (replace_me) {
            *replace_me = NULL;
        }
 
        ao2_ref(server, -1);
        server = NULL;
    }
 
    ao2_unlock(http_servers);
    return server;
}

References ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, http_server_discard(), http_server_get_by_host(), http_server_start(), http_servers, name, and NULL.

Referenced by __ast_http_load().

http_server_get_by_addr()

static struct ast_http_server * http_server_get_by_addr ( const char *  name, const struct ast_sockaddr *  addr  )

static

Retrieve, or create a HTTP server object by sock address.

Look for, and return a matching server object by addr. If an object is not found then create a new one.

Note

This method should be called with the http_servers container already locked.

Parameters

name	The name of the server
addr	The address to match on, or create a new object with

Returns

a HTTP server object, or NULL on error

Definition at line 2271 of file http.c.

{
    struct ast_http_server *server;
    const char *address;
 
    address = ast_sockaddr_stringify(addr);
    if (ast_strlen_zero(address)) {
        return NULL;
    }
 
    server = ao2_find(http_servers, address, OBJ_KEY | OBJ_NOLOCK);
 
    return server ?: http_server_create(name, address, addr);
}

References ao2_find, ast_sockaddr_stringify(), ast_strlen_zero(), http_server_create(), http_servers, name, NULL, OBJ_KEY, and OBJ_NOLOCK.

Referenced by http_server_get_by_host().

http_server_get_by_host()

static struct ast_http_server * http_server_get_by_host ( const char *  name, const char *  host, uint32_t  port  )

static

Retrieve, or create a HTTP server object by host.

Resolve the given host, and then look for, and return a matching server object. If an object is not found then create a new one.

Note

This method should be called with the http_servers container already locked.

Parameters

name	The name of the server
host	The host to resolve, and match on or create a new object with
port	Optional port used if one is not specified with the host (default 8088)

Returns

a HTTP server object, or NULL on error

Definition at line 2301 of file http.c.

{
    struct ast_sockaddr *addrs = NULL;
    int num_addrs;
    int i;
 
    if (!(num_addrs = ast_sockaddr_resolve(&addrs, host, 0, AST_AF_UNSPEC))) {
        ast_log(LOG_WARNING, "Unable to resolve host '%s'\n", host);
        return NULL;
    }
 
    if (port == 0) {
        port = DEFAULT_PORT;
    }
 
    for (i = 0; i < num_addrs; ++i) {
        struct ast_http_server *server;
 
        /* Use the given port if one was not specified already */
        if (!ast_sockaddr_port(&addrs[i])) {
            ast_sockaddr_set_port(&addrs[i], port);
        }
 
        server = http_server_get_by_addr(name, &addrs[i]);
        if (server) {
            ast_free(addrs);
            return server;
        }
    }
 
    ast_free(addrs);
    return NULL;
}

References AST_AF_UNSPEC, ast_free, ast_log, ast_sockaddr_port, ast_sockaddr_resolve(), ast_sockaddr_set_port, DEFAULT_PORT, http_server_get_by_addr(), LOG_WARNING, name, and NULL.

Referenced by http_server_get().

http_server_start()

static int http_server_start ( struct ast_http_server *  server )

static

Definition at line 2205 of file http.c.

{
    if (server->args.accept_fd != -1) {
        /* Already running */
        return 0;
    }
 
    ast_tcptls_server_start(&server->args);
    if (server->args.accept_fd == -1) {
        ast_log(LOG_WARNING, "Failed to start HTTP server '%s' at address '%s'\n",
                server->name, server->address);
        return -1;
    }
 
    if (!ao2_link_flags(http_servers, server, OBJ_NOLOCK)) {
        ast_log(LOG_WARNING, "Failed to link HTTP server '%s' at address '%s'\n",
                server->name, server->address);
        return -1;
    }
 
    ast_verb(1, "Bound HTTP server '%s' to address %s\n", server->name, server->address);
 
    return 0;
}

References ast_tcptls_session_args::accept_fd, ast_http_server::address, ao2_link_flags, ast_http_server::args, ast_log, ast_tcptls_server_start(), ast_verb, http_servers, LOG_WARNING, ast_http_server::name, and OBJ_NOLOCK.

Referenced by http_server_get().

httpd_helper_thread()

static void * httpd_helper_thread ( void *  arg )

static

Definition at line 2013 of file http.c.

{
    struct ast_tcptls_session_instance *ser = data;
    int timeout;
    int arg = 1;
 
    if (!ser) {
        ao2_cleanup(ser);
        return NULL;
    }
 
    if (ast_atomic_fetchadd_int(&session_count, +1) >= session_limit) {
        ast_log(LOG_WARNING, "HTTP session count exceeded %d sessions.\n",
            session_limit);
        goto done;
    }
    ast_debug(1, "HTTP opening session.  Top level\n");
 
    /*
     * Here we set TCP_NODELAY on the socket to disable Nagle's algorithm.
     * This is necessary to prevent delays (caused by buffering) as we
     * write to the socket in bits and pieces.
     */
    if (setsockopt(ast_iostream_get_fd(ser->stream), IPPROTO_TCP, TCP_NODELAY, (char *) &arg, sizeof(arg)) < 0) {
        ast_log(LOG_WARNING, "Failed to set TCP_NODELAY on HTTP connection: %s\n", strerror(errno));
    }
    ast_iostream_nonblock(ser->stream);
 
    /* Setup HTTP worker private data to keep track of request body reading. */
    ao2_cleanup(ser->private_data);
    ser->private_data = ao2_alloc_options(sizeof(struct http_worker_private_data), NULL,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!ser->private_data) {
        ast_http_error(ser, 500, "Server Error", "Out of memory");
        goto done;
    }
    http_request_tracking_init(ser->private_data);
 
    /* Determine initial HTTP request wait timeout. */
    timeout = session_keep_alive;
    if (timeout <= 0) {
        /* Persistent connections not enabled. */
        timeout = session_inactivity;
    }
    if (timeout < MIN_INITIAL_REQUEST_TIMEOUT) {
        timeout = MIN_INITIAL_REQUEST_TIMEOUT;
    }
 
    /* We can let the stream wait for data to arrive. */
    ast_iostream_set_exclusive_input(ser->stream, 1);
 
    for (;;) {
        /* Wait for next potential HTTP request message. */
        ast_iostream_set_timeout_idle_inactivity(ser->stream, timeout, session_inactivity);
        if (httpd_process_request(ser)) {
            /* Break the connection or the connection closed */
            break;
        }
        if (!ser->stream) {
            /* Web-socket or similar that took the connection */
            break;
        }
 
        timeout = session_keep_alive;
        if (timeout <= 0) {
            /* Persistent connections not enabled. */
            break;
        }
    }
 
done:
    ast_atomic_fetchadd_int(&session_count, -1);
 
    ast_debug(1, "HTTP closing session.  Top level\n");
    ast_tcptls_close_session_file(ser);
 
    ao2_ref(ser, -1);
    return NULL;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_ref, ast_atomic_fetchadd_int(), ast_debug, ast_http_error(), ast_iostream_get_fd(), ast_iostream_nonblock(), ast_iostream_set_exclusive_input(), ast_iostream_set_timeout_idle_inactivity(), ast_log, ast_tcptls_close_session_file(), done, errno, http_request_tracking_init(), httpd_process_request(), LOG_WARNING, MIN_INITIAL_REQUEST_TIMEOUT, NULL, ast_tcptls_session_instance::private_data, session_count, session_inactivity, session_keep_alive, session_limit, and ast_tcptls_session_instance::stream.

Referenced by http_server_create().

httpd_process_request()

static int httpd_process_request ( struct ast_tcptls_session_instance *  ser )

static

Definition at line 1915 of file http.c.

{
    RAII_VAR(struct ast_variable *, headers, NULL, ast_variables_destroy);
    char *uri;
    char *method;
    const char *transfer_encoding;
    struct http_worker_private_data *request;
    enum ast_http_method http_method = AST_HTTP_UNKNOWN;
    int res;
    ssize_t len;
    char request_line[MAX_HTTP_LINE_LENGTH];
 
    len = ast_iostream_gets(ser->stream, request_line, sizeof(request_line));
    if (len <= 0) {
        return -1;
    }
 
    /* Re-initialize the request body tracking data. */
    request = ser->private_data;
    http_request_tracking_init(request);
 
    if (request_line[len - 1] != '\n') {
        /* We didn't get a full line */
        ast_http_error(ser, 400, "Bad Request",
            (len == sizeof(request_line) - 1) ? "Request line too long" : "Timeout");
        return -1;
    }
 
    /* Get method */
    method = ast_skip_blanks(request_line);
    uri = ast_skip_nonblanks(method);
    if (*uri) {
        *uri++ = '\0';
    }
 
    if (!strcasecmp(method,"GET")) {
        http_method = AST_HTTP_GET;
    } else if (!strcasecmp(method,"POST")) {
        http_method = AST_HTTP_POST;
    } else if (!strcasecmp(method,"HEAD")) {
        http_method = AST_HTTP_HEAD;
    } else if (!strcasecmp(method,"PUT")) {
        http_method = AST_HTTP_PUT;
    } else if (!strcasecmp(method,"DELETE")) {
        http_method = AST_HTTP_DELETE;
    } else if (!strcasecmp(method,"OPTIONS")) {
        http_method = AST_HTTP_OPTIONS;
    }
 
    uri = ast_skip_blanks(uri); /* Skip white space */
    if (*uri) {         /* terminate at the first blank */
        char *c = ast_skip_nonblanks(uri);
 
        if (*c) {
            *c = '\0';
        }
    } else {
        ast_http_error(ser, 400, "Bad Request", "Invalid Request");
        return -1;
    }
 
    if (ast_shutdown_final()) {
        ast_http_error(ser, 503, "Service Unavailable", "Shutdown in progress");
        return -1;
    }
 
    /* process "Request Headers" lines */
    if (http_request_headers_get(ser, &headers)) {
        return -1;
    }
 
    transfer_encoding = get_transfer_encoding(headers);
    /* Transfer encoding defaults to identity */
    if (!transfer_encoding) {
        transfer_encoding = "identity";
    }
 
    /*
     * RFC 2616, section 3.6, we should respond with a 501 for any transfer-
     * codings we don't understand.
     */
    if (strcasecmp(transfer_encoding, "identity") != 0 &&
        strcasecmp(transfer_encoding, "chunked") != 0) {
        /* Transfer encodings not supported */
        ast_http_error(ser, 501, "Unimplemented", "Unsupported Transfer-Encoding.");
        return -1;
    }
 
    if (http_request_tracking_setup(ser, headers)
        || handle_uri(ser, uri, http_method, headers)
        || ast_test_flag(&request->flags, HTTP_FLAG_CLOSE_ON_COMPLETION)) {
        res = -1;
    } else {
        res = 0;
    }
    return res;
}

References AST_HTTP_DELETE, ast_http_error(), AST_HTTP_GET, AST_HTTP_HEAD, AST_HTTP_OPTIONS, AST_HTTP_POST, AST_HTTP_PUT, AST_HTTP_UNKNOWN, ast_iostream_gets(), ast_shutdown_final(), ast_skip_blanks(), ast_skip_nonblanks(), ast_test_flag, ast_variables_destroy(), c, get_transfer_encoding(), handle_uri(), HTTP_FLAG_CLOSE_ON_COMPLETION, http_request_headers_get(), http_request_tracking_init(), http_request_tracking_setup(), len(), MAX_HTTP_LINE_LENGTH, method, NULL, ast_tcptls_session_instance::private_data, RAII_VAR, request(), and ast_tcptls_session_instance::stream.

Referenced by httpd_helper_thread().

httpstatus_callback()

static int httpstatus_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_vars, struct ast_variable *  headers  )

static

Definition at line 384 of file http.c.

{
    struct ast_str *out;
    struct ast_variable *v, *cookies = NULL;
 
    if (method != AST_HTTP_GET && method != AST_HTTP_HEAD) {
        ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
        return 0;
    }
 
    out = ast_str_create(512);
    if (!out) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Out of memory");
        return 0;
    }
 
    ast_str_append(&out, 0,
        "<html><title>Asterisk HTTP Status</title>\r\n"
        "<body bgcolor=\"#ffffff\">\r\n"
        "<table bgcolor=\"#f1f1f1\" align=\"center\"><tr><td bgcolor=\"#e0e0ff\" colspan=\"2\" width=\"500\">\r\n"
        "<h2>&nbsp;&nbsp;Asterisk&trade; HTTP Status</h2></td></tr>\r\n");
 
    ast_str_append(&out, 0, "<tr><td><i>Server</i></td><td><b>%s</b></td></tr>\r\n", http_server_name);
    ast_str_append(&out, 0, "<tr><td><i>Prefix</i></td><td><b>%s</b></td></tr>\r\n", prefix);
    if (global_http_server) {
        ast_str_append(&out, 0, "<tr><td><i>Bind Address</i></td><td><b>%s</b></td></tr>\r\n",
                   ast_sockaddr_stringify(&global_http_server->args.old_address));
    }
    if (http_tls_cfg.enabled) {
        ast_str_append(&out, 0, "<tr><td><i>TLS Bind Address</i></td><td><b>%s</b></td></tr>\r\n",
                   ast_sockaddr_stringify(&https_desc.old_address));
    }
    ast_str_append(&out, 0, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
    for (v = get_vars; v; v = v->next) {
        ast_str_append(&out, 0, "<tr><td><i>Submitted GET Variable '%s'</i></td><td>%s</td></tr>\r\n", v->name, v->value);
    }
    ast_str_append(&out, 0, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
 
    cookies = ast_http_get_cookies(headers);
    for (v = cookies; v; v = v->next) {
        ast_str_append(&out, 0, "<tr><td><i>Cookie '%s'</i></td><td>%s</td></tr>\r\n", v->name, v->value);
    }
    ast_variables_destroy(cookies);
 
    ast_str_append(&out, 0, "</table><center><font size=\"-1\"><i>Asterisk and Digium are registered trademarks of Digium, Inc.</i></font></center></body></html>\r\n");
    ast_http_send(ser, method, 200, NULL, NULL, out, 0, 0);
    return 0;
}

References ast_http_server::args, ast_http_error(), AST_HTTP_GET, ast_http_get_cookies(), AST_HTTP_HEAD, ast_http_request_close_on_completion(), ast_http_send(), ast_sockaddr_stringify(), ast_str_append(), ast_str_create, ast_variables_destroy(), ast_tls_config::enabled, global_http_server, http_server_name, http_tls_cfg, https_desc, method, ast_variable::name, ast_variable::next, NULL, ast_tcptls_session_args::old_address, out, prefix, and ast_variable::value.

load_module()

static int load_module ( void  )

static

Definition at line 2729 of file http.c.

{
    ast_cli_register_multiple(cli_http, ARRAY_LEN(cli_http));
 
    http_servers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        HTTP_SERVER_BUCKETS, ast_http_server_hash_fn, NULL, ast_http_server_cmp_fn);
    if (!http_servers) {
        return AST_MODULE_LOAD_FAILURE;
    }
 
    if (__ast_http_load(0)) {
        ao2_cleanup(http_servers);
        http_servers = NULL;
        return AST_MODULE_LOAD_FAILURE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References __ast_http_load(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_hash, ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, cli_http, HTTP_SERVER_BUCKETS, http_servers, and NULL.

parse_cookies()

static struct ast_variable * parse_cookies ( const char *  cookies )

static

Definition at line 1530 of file http.c.

{
    char *parse = ast_strdupa(cookies);
    char *cur;
    struct ast_variable *vars = NULL, *var;
 
    while ((cur = strsep(&parse, ";"))) {
        char *name, *val;
 
        name = val = cur;
        strsep(&val, "=");
 
        if (ast_strlen_zero(name) || ast_strlen_zero(val)) {
            continue;
        }
 
        name = ast_strip(name);
        val = ast_strip_quoted(val, "\"", "\"");
 
        if (ast_strlen_zero(name) || ast_strlen_zero(val)) {
            continue;
        }
 
        ast_debug(1, "HTTP Cookie, Name: '%s'  Value: '%s'\n", name, val);
 
        var = ast_variable_new(name, val, __FILE__);
        var->next = vars;
        vars = var;
    }
 
    return vars;
}

References ast_debug, ast_strdupa, ast_strip(), ast_strip_quoted(), ast_strlen_zero(), ast_variable_new, name, NULL, strsep(), and var.

Referenced by ast_http_get_cookies().

reload_module()

static int reload_module ( void  )

static

Definition at line 2687 of file http.c.

{
    return __ast_http_load(1);
}

References __ast_http_load().

remove_excess_lws()

static void remove_excess_lws ( char *  s )

static

Definition at line 1735 of file http.c.

{
    char *p, *res = s;
    char *buf = ast_malloc(strlen(s) + 1);
    char *buf_end;
 
    if (!buf) {
        return;
    }
 
    buf_end = buf;
 
    while (*s && *(s = ast_skip_blanks(s))) {
        p = s;
        s = ast_skip_nonblanks(s);
 
        if (buf_end != buf) {
            *buf_end++ = ' ';
        }
 
        memcpy(buf_end, p, s - p);
        buf_end += s - p;
    }
    *buf_end = '\0';
    /* safe since buf will always be less than or equal to res */
    strcpy(res, buf);
    ast_free(buf);
}

References ast_free, ast_malloc, ast_skip_blanks(), ast_skip_nonblanks(), and buf.

Referenced by ast_http_header_parse().

static_callback()

static int static_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_vars, struct ast_variable *  headers  )

static

Definition at line 256 of file http.c.

{
    char *path;
    const char *ftype;
    const char *mtype;
    char wkspace[80];
    struct stat st;
    int len;
    int fd;
    struct ast_str *http_header;
    struct timeval tv;
    struct ast_tm tm;
    char timebuf[80], etag[23];
    struct ast_variable *v;
    int not_modified = 0;
 
    if (method != AST_HTTP_GET && method != AST_HTTP_HEAD) {
        ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
        return 0;
    }
 
    /* Yuck.  I'm not really sold on this, but if you don't deliver static content it
     * makes your configuration substantially more challenging, but this seems like a
     * rather irritating feature creep on Asterisk.
     *
     * XXX: It is not clear to me what this comment means or if it is any longer
     *      relevant. */
    if (ast_strlen_zero(uri)) {
        goto out403;
    }
 
    /* Disallow any funny filenames at all (checking first character only??) */
    if ((uri[0] < 33) || strchr("./|~@#$%^&*() \t", uri[0])) {
        goto out403;
    }
 
    if (strstr(uri, "/..")) {
        goto out403;
    }
 
    if ((ftype = strrchr(uri, '.'))) {
        ftype++;
    }
 
    if (!(mtype = ast_http_ftype2mtype(ftype))) {
        snprintf(wkspace, sizeof(wkspace), "text/%s", S_OR(ftype, "plain"));
        mtype = wkspace;
    }
 
    /* Cap maximum length */
    if ((len = strlen(uri) + strlen(ast_config_AST_DATA_DIR) + strlen("/static-http/") + 5) > 1024) {
        goto out403;
    }
 
    path = ast_alloca(len);
    sprintf(path, "%s/static-http/%s", ast_config_AST_DATA_DIR, uri);
    if (stat(path, &st)) {
        goto out404;
    }
 
    if (S_ISDIR(st.st_mode)) {
        goto out404;
    }
 
    if (strstr(path, "/private/") && !astman_is_authed(ast_http_manid_from_vars(headers))) {
        goto out403;
    }
 
    fd = open(path, O_RDONLY);
    if (fd < 0) {
        goto out403;
    }
 
    /* make "Etag:" http header value */
    snprintf(etag, sizeof(etag), "\"%ld\"", (long)st.st_mtime);
 
    /* make "Last-Modified:" http header value */
    tv.tv_sec = st.st_mtime;
    tv.tv_usec = 0;
    ast_strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", ast_localtime(&tv, &tm, "GMT"));
 
    /* check received "If-None-Match" request header and Etag value for file */
    for (v = headers; v; v = v->next) {
        if (!strcasecmp(v->name, "If-None-Match")) {
            if (!strcasecmp(v->value, etag)) {
                not_modified = 1;
            }
            break;
        }
    }
 
    http_header = ast_str_create(255);
    if (!http_header) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Out of memory");
        close(fd);
        return 0;
    }
 
    ast_str_set(&http_header, 0, "Content-type: %s\r\n"
        "ETag: %s\r\n"
        "Last-Modified: %s\r\n",
        mtype,
        etag,
        timebuf);
 
    /* ast_http_send() frees http_header, so we don't need to do it before returning */
    if (not_modified) {
        ast_http_send(ser, method, 304, "Not Modified", http_header, NULL, 0, 1);
    } else {
        ast_http_send(ser, method, 200, NULL, http_header, NULL, fd, 1); /* static content flag is set */
    }
    close(fd);
    return 0;
 
out404:
    ast_http_error(ser, 404, "Not Found", "The requested URL was not found on this server.");
    return 0;
 
out403:
    ast_http_request_close_on_completion(ser);
    ast_http_error(ser, 403, "Access Denied", "You do not have permission to access the requested URL.");
    return 0;
}

References ast_alloca, ast_config_AST_DATA_DIR, ast_http_error(), ast_http_ftype2mtype(), AST_HTTP_GET, AST_HTTP_HEAD, ast_http_manid_from_vars(), ast_http_request_close_on_completion(), ast_http_send(), ast_localtime(), ast_str_create, ast_str_set(), ast_strftime(), ast_strlen_zero(), astman_is_authed(), len(), method, mtype, ast_variable::name, ast_variable::next, NULL, S_OR, and ast_variable::value.

unload_module()

static int unload_module ( void  )

static

Definition at line 2696 of file http.c.

{
    struct http_uri_redirect *redirect;
    ast_cli_unregister_multiple(cli_http, ARRAY_LEN(cli_http));
 
    ao2_cleanup(global_http_server);
    ao2_cleanup(http_servers);
 
    if (http_tls_cfg.enabled) {
        ast_tcptls_server_stop(&https_desc);
    }
    ast_free(http_tls_cfg.certfile);
    ast_free(http_tls_cfg.capath);
    ast_free(http_tls_cfg.pvtfile);
    ast_free(http_tls_cfg.cipher);
 
    if (status_uri_enabled) {
        ast_http_uri_unlink(&status_uri);
    }
 
    if (static_uri_enabled) {
        ast_http_uri_unlink(&static_uri);
    }
 
    AST_RWLIST_WRLOCK(&uri_redirects);
    while ((redirect = AST_RWLIST_REMOVE_HEAD(&uri_redirects, entry))) {
        ast_free(redirect);
    }
    AST_RWLIST_UNLOCK(&uri_redirects);
 
    return 0;
}

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), ast_free, ast_http_uri_unlink(), AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_tcptls_server_stop(), ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, cli_http, ast_tls_config::enabled, http_uri_redirect::entry, global_http_server, http_servers, http_tls_cfg, https_desc, ast_tls_config::pvtfile, static_uri, static_uri_enabled, status_uri, and status_uri_enabled.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Built-in HTTP Server" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }

static

Definition at line 2755 of file http.c.

ast_http_methods_text

const struct ast_cfhttp_methods_text ast_http_methods_text[]

static

Referenced by ast_get_http_method(), and ast_get_http_method_from_string().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2755 of file http.c.

cli_http

struct ast_cli_entry cli_http[]

static

Initial value:

= {
    { .handler =  handle_show_http , .summary =  "Display HTTP server status" ,},
}

Definition at line 2692 of file http.c.

                                         {
    AST_CLI_DEFINE(handle_show_http, "Display HTTP server status"),
};

Referenced by load_module(), and unload_module().

ext

const char* ext

Definition at line 150 of file http.c.

Referenced by ast_ext_ctx(), ast_http_ftype2mtype(), ast_media_cache_create_or_update(), ast_media_cache_retrieve(), ast_rtp_interpret(), bucket_file_update_path(), build_filename(), cli_console_dial(), common_exec(), console_new(), copy_to_voicemail(), create_dirpath(), dahdi_call(), do_directory(), file_extension_from_string(), filehelper(), filename_parse(), goto_exten(), handle_cli_dialplan_save(), hintdevice_hash_cb(), invent_message(), is_recording(), json_array_from_list(), leave_voicemail(), make_dir(), make_filename(), mixmonitor_save_prep(), ooh323_request(), pbx_load_config(), pbx_load_config(), play_mailbox_owner(), process_media_file(), pvalGotoSetTarget(), read_dirs_cb(), record_exec(), register_peer_exten(), rtp_raw_write(), search_directory(), search_directory_sub(), set_rec_filename(), split_ec(), and split_ext().

global_http_server

struct ast_http_server* global_http_server = NULL

The default configured HTTP server

Definition at line 129 of file http.c.

Referenced by __ast_http_load(), handle_show_http(), httpstatus_callback(), and unload_module().

http_server_name

char http_server_name[MAX_SERVER_NAME_LENGTH]

static

Definition at line 104 of file http.c.

Referenced by __ast_http_load(), ast_http_create_response(), ast_http_send(), handle_show_http(), and httpstatus_callback().

http_servers

struct ao2_container* http_servers = NULL

Definition at line 2156 of file http.c.

Referenced by http_server_discard(), http_server_get(), http_server_get_by_addr(), http_server_start(), load_module(), and unload_module().

http_tls_cfg

struct ast_tls_config http_tls_cfg

static

Definition at line 111 of file http.c.

Referenced by __ast_http_load(), handle_show_http(), httpstatus_callback(), and unload_module().

https_desc

struct ast_tcptls_session_args https_desc

static

Definition at line 131 of file http.c.

                                                   {
    .accept_fd = -1,
    .master = AST_PTHREADT_NULL,
    .tls_cfg = &http_tls_cfg,
    .poll_timeout = -1,
    .name = "https server",
    .accept_fn = ast_tcptls_server_root,
    .worker_fn = httpd_helper_thread,
};

Referenced by __ast_http_load(), handle_show_http(), httpstatus_callback(), and unload_module().

[struct]

struct { ... } mimetypes[]

Limit the kinds of files we're willing to serve up.

Referenced by ast_http_ftype2mtype().

mtype

const char* mtype

Definition at line 151 of file http.c.

Referenced by is_msg(), and static_callback().

prefix

char prefix[MAX_PREFIX]

static

Definition at line 144 of file http.c.

Referenced by __ast_http_load(), _while_exec(), aoc_amount_str(), aoc_d_event(), aoc_e_event(), aoc_s_event(), aoc_time_str(), aor_deleted_observer(), ast_acl_output(), ast_ari_get_docs(), ast_begins_with(), ast_cli_print_timestr_fromseconds(), ast_db_deltree(), ast_db_gettree(), ast_db_gettree_by_prefix(), ast_frame_dump(), ast_ha_output(), ast_http_prefix(), ast_http_uri_link(), ast_manager_build_bridge_state_string_prefix(), ast_manager_build_channel_state_string_prefix(), ast_remotecontrol(), ast_sip_location_retrieve_aor_contacts_nolock_filtered(), ast_sorcery_retrieve_by_prefix(), at_match_prefix(), clearvar_prefix(), cli_match_char_tree(), console_print(), create_prefix(), exec_clearhash(), generate_filenames_string(), get_index(), get_index(), get_key(), get_object_variables(), handle_auth(), handle_cli_database_show(), handle_show_http(), handle_uri(), hashkeys_read(), hashkeys_read2(), httpstatus_callback(), if_helper(), insert_test_duplicates(), insert_test_vector(), ip_identify_match_srv_lookup(), load_module(), log_jack_status(), manager_db_tree_get(), print_acl(), print_uptimestr(), process_config(), process_config(), refer_blind_callback(), say_date_generic(), shared_read(), shared_write(), sip_options_apply_aor_configuration(), sorcery_astdb_create(), sorcery_astdb_delete(), sorcery_astdb_retrieve_fields_common(), sorcery_astdb_retrieve_id(), sorcery_astdb_retrieve_prefix(), sorcery_astdb_retrieve_regex(), sorcery_astdb_update(), sorcery_config_retrieve_prefix(), sorcery_memory_cache_retrieve_prefix(), sorcery_memory_retrieve_prefix(), sorcery_realtime_retrieve_prefix(), test_ao2_callback_traversal(), test_ao2_iteration(), test_expected_duplicates(), vm_authenticate(), and while_continue_exec().

session_count

int session_count = 0

static

Definition at line 109 of file http.c.

Referenced by cli_fax_show_sessions(), httpd_helper_thread(), is_media_state_valid(), and manager_fax_sessions().

session_inactivity

int session_inactivity = DEFAULT_SESSION_INACTIVITY

static

Definition at line 107 of file http.c.

Referenced by __ast_http_load(), and httpd_helper_thread().

session_keep_alive

int session_keep_alive = DEFAULT_SESSION_KEEP_ALIVE

static

Definition at line 108 of file http.c.

Referenced by __ast_http_load(), ast_http_send(), and httpd_helper_thread().

session_limit

int session_limit = DEFAULT_SESSION_LIMIT

static

Definition at line 106 of file http.c.

Referenced by __ast_http_load(), evt_gen_session_limit(), httpd_helper_thread(), and report_session_limit().

static_uri

struct ast_http_uri static_uri

static

Definition at line 446 of file http.c.

                                        {
    .callback = static_callback,
    .description = "Asterisk HTTP Static Delivery",
    .uri = "static",
    .has_subtree = 1,
    .data = NULL,
    .key= __FILE__,
};

Referenced by __ast_http_load(), and unload_module().

static_uri_enabled

int static_uri_enabled

static

Definition at line 145 of file http.c.

Referenced by __ast_http_load(), and unload_module().

status_uri

struct ast_http_uri status_uri

static

Definition at line 437 of file http.c.

                                        {
    .callback = httpstatus_callback,
    .description = "Asterisk HTTP General Status",
    .uri = "httpstatus",
    .has_subtree = 0,
    .data = NULL,
    .key = __FILE__,
};

Referenced by __ast_http_load(), and unload_module().

status_uri_enabled

int status_uri_enabled

static

Definition at line 146 of file http.c.

Referenced by __ast_http_load(), and unload_module().

uri_redirects

struct uri_redirects uri_redirects = AST_RWLIST_HEAD_INIT_VALUE

static

uris

struct uris uris = AST_RWLIST_HEAD_INIT_VALUE

static

list of supported handlers