http server for AMI access More...

#include "asterisk.h"
#include <time.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <fcntl.h>
#include "asterisk/paths.h"
#include "asterisk/network.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/_private.h"
#include "asterisk/astobj2.h"

Include dependency graph for http.c:

Go to the source code of this file.

Data Structures
struct	http_uri_redirect
struct	uri_redirects
struct	uris
Defines
#define	DEFAULT_SESSION_LIMIT 100
#define	DO_SSL
#define	HOOK_T ssize_t
#define	LEN_T size_t
#define	MAX_PREFIX 80
Functions
static int	__ast_http_load (int reload)
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.
struct ast_str *	ast_http_error (int status, const char title, const char extra_header, const char *text)
	Return an ast_str malloc()'d string containing an HTTP error message.
int	ast_http_init (void)
void	ast_http_prefix (char *buf, int len)
	Return the current prefix.
int	ast_http_reload (void)
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.
static const char *	ftype2mtype (const char ftype, char wkspace, int wkspacelen)
static char *	handle_show_http (struct ast_cli_entry e, int cmd, struct ast_cli_args a)
static struct ast_str *	handle_uri (struct ast_tcptls_session_instance ser, char uri, enum ast_http_method method, int status, char title, int contentlength, struct ast_variable *cookies, struct ast_variable headers, unsigned int *static_content)
static void	http_decode (char *s)
static void *	httpd_helper_thread (void *arg)
static struct ast_str *	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 vars, struct ast_variable headers, int status, char *title, int contentlength)
static uint32_t	manid_from_vars (struct ast_variable *sid)
static struct ast_variable *	parse_cookies (char *cookies)
static struct ast_str *	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 vars, struct ast_variable headers, int status, char *title, int contentlength)
Variables
static struct ast_cli_entry	cli_http []
static int	enablestatic
static struct ast_tcptls_session_args	http_desc
static struct ast_tls_config	http_tls_cfg
static struct ast_tcptls_session_args	https_desc
struct {
const char * ext
const char * mtype
}	mimetypes []
static char	prefix [MAX_PREFIX]
static int	session_count = 0
static int	session_limit = DEFAULT_SESSION_LIMIT
static struct ast_http_uri	staticuri
static struct ast_http_uri	statusuri
static struct uri_redirects	uri_redirects
static struct uris	uris

Detailed Description

http server for AMI access

Author:: Mark Spencer <markster@digium.com>

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

AMI over HTTP support - AMI over the http protocol

Definition in file http.c.

Define Documentation

#define DEFAULT_SESSION_LIMIT 100

Definition at line 56 of file http.c.

Referenced by __ast_http_load().

#define DO_SSL

Definition at line 60 of file http.c.

#define HOOK_T ssize_t

Definition at line 597 of file http.c.

#define LEN_T size_t

Definition at line 598 of file http.c.

#define MAX_PREFIX 80

Definition at line 55 of file http.c.

Referenced by __ast_http_load().

Function Documentation

static int __ast_http_load ( int reload ) [static]

Definition at line 866 of file http.c.

References add_redirect(), AST_CERTFILE, ast_config_destroy(), ast_config_load2(), ast_copy_string(), ast_free, ast_gethostbyname(), ast_log(), ast_parse_arg(), AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_ssl_setup(), ast_strdup, ast_strlen_zero(), ast_tcptls_server_start(), ast_true(), ast_variable_browse(), ast_tls_config::certfile, ast_tls_config::cipher, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_SESSION_LIMIT, ast_tls_config::enabled, enabled, http_uri_redirect::entry, hp, http_tls_cfg, ast_variable::lineno, ast_tcptls_session_args::local_address, LOG_WARNING, MAX_PREFIX, ast_variable::name, ast_variable::next, PARSE_DEFAULT, PARSE_IN_RANGE, PARSE_INT32, ast_tcptls_session_args::tls_cfg, and ast_variable::value.

Referenced by ast_http_init(), and ast_http_reload().

{
   struct ast_config *cfg;
   struct ast_variable *v;
   int enabled=0;
   int newenablestatic=0;
   struct hostent *hp;
   struct ast_hostent ahp;
   char newprefix[MAX_PREFIX] = "";
   int have_sslbindaddr = 0;
   struct http_uri_redirect *redirect;
   struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };

   cfg = ast_config_load2("http.conf", "http", config_flags);
   if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
      return 0;
   }

   /* default values */
   memset(&http_desc.local_address, 0, sizeof(http_desc.local_address));
   http_desc.local_address.sin_port = htons(8088);

   memset(&https_desc.local_address, 0, sizeof(https_desc.local_address));
   https_desc.local_address.sin_port = htons(8089);

   http_tls_cfg.enabled = 0;
   if (http_tls_cfg.certfile) {
      ast_free(http_tls_cfg.certfile);
   }
   http_tls_cfg.certfile = ast_strdup(AST_CERTFILE);
   if (http_tls_cfg.cipher) {
      ast_free(http_tls_cfg.cipher);
   }
   http_tls_cfg.cipher = ast_strdup("");

   AST_RWLIST_WRLOCK(&uri_redirects);
   while ((redirect = AST_RWLIST_REMOVE_HEAD(&uri_redirects, entry))) {
      ast_free(redirect);
   }
   AST_RWLIST_UNLOCK(&uri_redirects);

   if (cfg) {
      v = ast_variable_browse(cfg, "general");
      for (; v; v = v->next) {
         if (!strcasecmp(v->name, "enabled")) {
            enabled = ast_true(v->value);
         } else if (!strcasecmp(v->name, "sslenable")) {
            http_tls_cfg.enabled = ast_true(v->value);
         } else if (!strcasecmp(v->name, "sslbindport")) {
            https_desc.local_address.sin_port = htons(atoi(v->value));
         } else if (!strcasecmp(v->name, "sslcert")) {
            ast_free(http_tls_cfg.certfile);
            http_tls_cfg.certfile = ast_strdup(v->value);
         } else if (!strcasecmp(v->name, "sslcipher")) {
            ast_free(http_tls_cfg.cipher);
            http_tls_cfg.cipher = ast_strdup(v->value);
         } else if (!strcasecmp(v->name, "enablestatic")) {
            newenablestatic = ast_true(v->value);
         } else if (!strcasecmp(v->name, "bindport")) {
            http_desc.local_address.sin_port = htons(atoi(v->value));
         } else if (!strcasecmp(v->name, "sslbindaddr")) {
            if ((hp = ast_gethostbyname(v->value, &ahp))) {
               memcpy(&https_desc.local_address.sin_addr, hp->h_addr, sizeof(https_desc.local_address.sin_addr));
               have_sslbindaddr = 1;
            } else {
               ast_log(LOG_WARNING, "Invalid bind address '%s'\n", v->value);
            }
         } else if (!strcasecmp(v->name, "bindaddr")) {
            if ((hp = ast_gethostbyname(v->value, &ahp))) {
               memcpy(&http_desc.local_address.sin_addr, hp->h_addr, sizeof(http_desc.local_address.sin_addr));
            } else {
               ast_log(LOG_WARNING, "Invalid bind address '%s'\n", 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 {
            ast_log(LOG_WARNING, "Ignoring unknown option '%s' in http.conf\n", v->name);
         }
      }

      ast_config_destroy(cfg);
   }

   if (!have_sslbindaddr) {
      https_desc.local_address.sin_addr = http_desc.local_address.sin_addr;
   }
   if (enabled) {
      http_desc.local_address.sin_family = https_desc.local_address.sin_family = AF_INET;
   }
   if (strcmp(prefix, newprefix)) {
      ast_copy_string(prefix, newprefix, sizeof(prefix));
   }
   enablestatic = newenablestatic;
   ast_tcptls_server_start(&http_desc);
   if (ast_ssl_setup(https_desc.tls_cfg)) {
      ast_tcptls_server_start(&https_desc);
   }

   return 0;
}

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 811 of file http.c.

References ast_calloc, 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(), and http_uri_redirect::target.

Referenced by __ast_http_load().

{
   char *target, *dest;
   struct http_uri_redirect *redirect, *cur;
   unsigned int target_len;
   unsigned int total_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;
   total_len = sizeof(*redirect) + target_len + strlen(dest) + 1;

   if (!(redirect = ast_calloc(1, total_len))) {
      return;
   }

   redirect->dest = redirect->target + target_len;
   strcpy(redirect->target, target);
   strcpy(redirect->dest, dest);

   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);
}

struct ast_str* ast_http_error	(	int	status,
		const char *	title,
		const char *	extra_header,
		const char *	text
	)		`[read]`

Return an ast_str malloc()'d string containing an HTTP error message.

Definition at line 322 of file http.c.

References ast_str_create(), and ast_str_set().

Referenced by generic_http_callback(), handle_uri(), http_post_callback(), httpd_helper_thread(), phoneprov_callback(), and static_callback().

{
   struct ast_str *out = ast_str_create(512);

   if (out == NULL) {
      return out;
   }

   ast_str_set(&out, 0,
          "Content-type: text/html\r\n"
          "%s"
          "\r\n"
          "<!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"
          "<address>Asterisk Server</address>\r\n"
          "</body></html>\r\n",
          (extra_header ? extra_header : ""), status, title, title, text);

   return out;
}

int ast_http_init ( void )

Provided by http.c

Definition at line 1047 of file http.c.

References __ast_http_load(), ARRAY_LEN, ast_cli_register_multiple(), ast_http_uri_link(), cli_http, staticuri, and statusuri.

Referenced by main().

{
   ast_http_uri_link(&statusuri);
   ast_http_uri_link(&staticuri);
   ast_cli_register_multiple(cli_http, ARRAY_LEN(cli_http));

   return __ast_http_load(0);
}

void ast_http_prefix	(	char *	buf,
		int	len
	)

Return the current prefix.

Parameters:

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

Since:: 1.6.1

Definition at line 160 of file http.c.

References ast_copy_string().

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

int ast_http_reload ( void )

Provided by http.c

Definition at line 1038 of file http.c.

References __ast_http_load().

{
   return __ast_http_load(1);
}

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 357 of file http.c.

References 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_http_uri::description, http_uri_redirect::entry, len(), LOG_WARNING, ast_http_uri::supports_get, ast_http_uri::supports_post, and ast_http_uri::uri.

Referenced by __ast_http_post_load(), __init_manager(), ast_http_init(), and load_module().

{
   struct ast_http_uri *uri;
   int len = strlen(urih->uri);

   if (!(urih->supports_get || urih->supports_post)) {
      ast_log(LOG_WARNING, "URI handler does not provide either GET or POST method: %s (%s)\n", urih->uri, urih->description);
      return -1;
   }

   AST_RWLIST_WRLOCK(&uris);

   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;
}

void ast_http_uri_unlink ( struct ast_http_uri * urih )

Unregister a URI handler.

Definition at line 393 of file http.c.

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

Referenced by __init_manager(), and unload_module().

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

void ast_http_uri_unlink_all_with_key ( const char * key )

Unregister all handlers with matching key.

Definition at line 400 of file http.c.

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, http_uri_redirect::entry, ast_http_uri::key, and ast_http_uri::mallocd.

Referenced by __ast_http_post_load(), and unload_module().

{
   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);
}

static const char* ftype2mtype	(	const char *	ftype,
		char *	wkspace,
		int	wkspacelen
	)		`[static]`

Definition at line 131 of file http.c.

References ARRAY_LEN, ext, mimetypes, and S_OR.

Referenced by static_callback().

{
   int x;

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

   snprintf(wkspace, wkspacelen, "text/%s", S_OR(ftype, "plain"));

   return wkspace;
}

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

Definition at line 980 of file http.c.

References ast_cli_args::argc, ast_cli(), ast_inet_ntoa(), AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, 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, ast_cli_args::fd, ast_http_uri::has_subtree, http_tls_cfg, ast_tcptls_session_args::old_address, http_uri_redirect::target, ast_http_uri::uri, and ast_cli_entry::usage.

{
   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);
   if (!http_desc.old_address.sin_family) {
      ast_cli(a->fd, "Server Disabled\n\n");
   } else {
      ast_cli(a->fd, "Server Enabled and Bound to %s:%d\n\n",
         ast_inet_ntoa(http_desc.old_address.sin_addr),
         ntohs(http_desc.old_address.sin_port));
      if (http_tls_cfg.enabled) {
         ast_cli(a->fd, "HTTPS Server Enabled and Bound to %s:%d\n\n",
            ast_inet_ntoa(https_desc.old_address.sin_addr),
            ntohs(https_desc.old_address.sin_port));
      }
   }

   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;
}

static struct ast_str* handle_uri	(	struct ast_tcptls_session_instance *	ser,
		char *	uri,
		enum ast_http_method	method,
		int *	status,
		char **	title,
		int *	contentlength,
		struct ast_variable **	cookies,
		struct ast_variable *	headers,
		unsigned int *	static_content
	)		`[static, read]`

Definition at line 436 of file http.c.

References ast_debug, ast_http_error(), AST_HTTP_GET, AST_HTTP_POST, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_variable_new(), ast_variables_destroy(), astman_is_authed(), buf, ast_http_uri::callback, cleanup(), http_uri_redirect::dest, http_uri_redirect::entry, ast_http_uri::has_subtree, http_decode(), manid_from_vars(), ast_variable::next, ast_http_uri::static_content, strsep(), ast_http_uri::supports_get, ast_http_uri::supports_post, http_uri_redirect::target, ast_http_uri::uri, val, and var.

Referenced by httpd_helper_thread().

{
   char *c;
   struct ast_str *out = NULL;
   char *params = uri;
   struct ast_http_uri *urih = NULL;
   int l;
   struct ast_variable *vars = NULL, *v, *prev = NULL;
   struct http_uri_redirect *redirect;
   int saw_method = 0;

   ast_debug(2, "HTTP Request URI is %s \n", uri);

   /* preserve previous behavior of only support URI parameters on GET requests */
   if (method == AST_HTTP_GET) {
      strsep(&params, "?");
      
      /* Extract arguments from the request and store them in variables.
       * Note that a request can have multiple arguments with the same
       * name, and we store them all in the list of variables.
       * It is up to the application to handle multiple values.
       */
      if (params) {
         char *var, *val;
         
         while ((val = strsep(&params, "&"))) {
            var = strsep(&val, "=");
            if (val) {
               http_decode(val);
            } else {
               val = "";
            }
            http_decode(var);
            if ((v = ast_variable_new(var, val, ""))) {
               if (vars) {
                  prev->next = v;
               } else {
                  vars = v;
               }
               prev = v;
            }
         }
      }
   }

   /*
    * Append the cookies to the list of variables.
    * This saves a pass in the cookies list, but has the side effect
    * that a variable might mask a cookie with the same name if the
    * application stops at the first match.
    * Note that this is the same behaviour as $_REQUEST variables in PHP.
    */
   if (prev) {
      prev->next = *cookies;
   } else {
      vars = *cookies;
   }
   *cookies = NULL;

   http_decode(uri);

   AST_RWLIST_RDLOCK(&uri_redirects);
   AST_RWLIST_TRAVERSE(&uri_redirects, redirect, entry) {
      if (!strcasecmp(uri, redirect->target)) {
         char buf[512];

         snprintf(buf, sizeof(buf), "Location: %s\r\n", redirect->dest);
         out = ast_http_error((*status = 302),
                    (*title = ast_strdup("Moved Temporarily")),
                    buf, "Redirecting...");

         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) {
         ast_debug(2, "match request [%s] with handler [%s] len %d\n", uri, urih->uri, l);
         if (!saw_method) {
            switch (method) {
            case AST_HTTP_GET:
               if (urih->supports_get) {
                  saw_method = 1;
               }
               break;
            case AST_HTTP_POST:
               if (urih->supports_post) {
                  saw_method = 1;
               }
               break;
            }
         }

         l = strlen(urih->uri);
         c = uri + l;   /* candidate */

         if (strncasecmp(urih->uri, uri, l) || /* no match */
             (*c && *c != '/')) { /* substring */
            continue;
         }

         if (*c == '/') {
            c++;
         }

         if (!*c || urih->has_subtree) {
            if (((method == AST_HTTP_GET) && urih->supports_get) ||
                ((method == AST_HTTP_POST) && urih->supports_post)) {
               uri = c;

               break;
            }
         }
      }

      if (!urih) {
         AST_RWLIST_UNLOCK(&uris);
      }
   }

   if (method == AST_HTTP_POST && !astman_is_authed(manid_from_vars(vars))) {
      out = ast_http_error((*status = 403),
               (*title = ast_strdup("Access Denied")),
               NULL, "You do not have permission to access the requested URL.");
   } else if (urih) {
      *static_content = urih->static_content;
      out = urih->callback(ser, urih, uri, method, vars, headers, status, title, contentlength);
      AST_RWLIST_UNLOCK(&uris);
   } else if (saw_method) {
      out = ast_http_error((*status = 404),
                 (*title = ast_strdup("Not Found")), NULL,
                 "The requested URL was not found on this server.");
   } else {
      out = ast_http_error((*status = 501),
                 (*title = ast_strdup("Not Implemented")), NULL,
                 "Attempt to use unimplemented / unsupported method");
   }

cleanup:
   ast_variables_destroy(vars);

   return out;
}

static void http_decode ( char * s ) [static]

Definition at line 424 of file http.c.

References ast_uri_decode().

Referenced by handle_uri().

{
   char *t;
   
   for (t = s; *t; t++) {
      if (*t == '+')
         *t = ' ';
   }

   ast_uri_decode(s);
}

static void * httpd_helper_thread ( void * arg ) [static]

Definition at line 672 of file http.c.

References ao2_ref, ast_atomic_fetchadd_int(), ast_free, ast_get_version(), ast_http_error(), AST_HTTP_GET, AST_HTTP_POST, ast_localtime(), ast_log(), ast_skip_blanks(), ast_skip_nonblanks(), ast_str_buffer(), ast_strftime(), ast_strlen_zero(), ast_trim_blanks(), ast_tvnow(), ast_variable_new(), ast_variables_destroy(), buf, errno, ast_tcptls_session_instance::f, handle_uri(), LOG_WARNING, name, ast_variable::next, parse_cookies(), status, strsep(), and val.

{
   char buf[4096];
   char cookie[4096];
   struct ast_tcptls_session_instance *ser = data;
   struct ast_variable *vars=NULL, *headers = NULL;
   char *uri, *title=NULL;
   int status = 200, contentlength = 0;
   struct ast_str *out = NULL;
   unsigned int static_content = 0;
   struct ast_variable *tail = headers;

   if (ast_atomic_fetchadd_int(&session_count, +1) >= session_limit) {
      goto done;
   }

   if (!fgets(buf, sizeof(buf), ser->f)) {
      goto done;
   }

   uri = ast_skip_nonblanks(buf);   /* Skip method */
   if (*uri) {
      *uri++ = '\0';
   }

   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';
      }
   }

   /* process "Cookie: " lines */
   while (fgets(cookie, sizeof(cookie), ser->f)) {
      /* Trim trailing characters */
      ast_trim_blanks(cookie);
      if (ast_strlen_zero(cookie)) {
         break;
      }
      if (!strncasecmp(cookie, "Cookie: ", 8)) {
         vars = parse_cookies(cookie);
      } else {
         char *name, *val;

         val = cookie;
         name = strsep(&val, ":");
         if (ast_strlen_zero(name) || ast_strlen_zero(val)) {
            continue;
         }
         ast_trim_blanks(name);
         val = ast_skip_blanks(val);

         if (!headers) {
            headers = ast_variable_new(name, val, __FILE__);
            tail = headers;
         } else {
            tail->next = ast_variable_new(name, val, __FILE__);
            tail = tail->next;
         }
      }
   }

   if (!*uri) {
      out = ast_http_error(400, "Bad Request", NULL, "Invalid Request");
   } else if (strcasecmp(buf, "post") && strcasecmp(buf, "get")) {
      out = ast_http_error(501, "Not Implemented", NULL,
                 "Attempt to use unimplemented / unsupported method");
   } else { /* try to serve it */
      out = handle_uri(ser, uri, (!strcasecmp(buf, "get")) ? AST_HTTP_GET : AST_HTTP_POST,
             &status, &title, &contentlength, &vars, headers, &static_content);
   }

   /* If they aren't mopped up already, clean up the cookies */
   if (vars) {
      ast_variables_destroy(vars);
   }
   /* Clean up all the header information pulled as well */
   if (headers) {
      ast_variables_destroy(headers);
   }

   if (out) {
      struct timeval now = ast_tvnow();
      char timebuf[256];
      struct ast_tm tm;

      ast_strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S %Z", ast_localtime(&now, &tm, "GMT"));
      fprintf(ser->f,
         "HTTP/1.1 %d %s\r\n"
         "Server: Asterisk/%s\r\n"
         "Date: %s\r\n"
         "Connection: close\r\n"
         "%s",
         status, title ? title : "OK", ast_get_version(), timebuf,
         static_content ? "" : "Cache-Control: no-cache, no-store\r\n");
         /* We set the no-cache headers only for dynamic content.
         * If you want to make sure the static file you requested is not from cache,
         * append a random variable to your GET request.  Ex: 'something.html?r=109987734'
         */
      if (!contentlength) {   /* opaque body ? just dump it hoping it is properly formatted */
         fprintf(ser->f, "%s", ast_str_buffer(out));
      } else {
         char *tmp = strstr(ast_str_buffer(out), "\r\n\r\n");

         if (tmp) {
            fprintf(ser->f, "Content-length: %d\r\n", contentlength);
            /* first write the header, then the body */
            if (fwrite(ast_str_buffer(out), 1, (tmp + 4 - ast_str_buffer(out)), ser->f) != tmp + 4 - ast_str_buffer(out)) {
               ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
            }
            if (fwrite(tmp + 4, 1, contentlength, ser->f) != contentlength ) {
               ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
            }
         }
      }
      ast_free(out);
   }

   if (title) {
      ast_free(title);
   }

done:
   ast_atomic_fetchadd_int(&session_count, -1);
   fclose(ser->f);
   ao2_ref(ser, -1);
   ser = NULL;

   return NULL;
}

static struct ast_str* 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 *	vars,
		struct ast_variable *	headers,
		int *	status,
		char **	title,
		int *	contentlength
	)		`[static, read]`

Definition at line 256 of file http.c.

References ast_inet_ntoa(), ast_str_append(), ast_str_create(), ast_tls_config::enabled, http_tls_cfg, ast_variable::name, ast_variable::next, ast_tcptls_session_args::old_address, and ast_variable::value.

{
   struct ast_str *out = ast_str_create(512);
   struct ast_variable *v;

   if (out == NULL) {
      return out;
   }

   ast_str_append(&out, 0,
             "\r\n"
             "<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>Prefix</i></td><td><b>%s</b></td></tr>\r\n", prefix);
   ast_str_append(&out, 0, "<tr><td><i>Bind Address</i></td><td><b>%s</b></td></tr>\r\n",
             ast_inet_ntoa(http_desc.old_address.sin_addr));
   ast_str_append(&out, 0, "<tr><td><i>Bind Port</i></td><td><b>%d</b></td></tr>\r\n",
             ntohs(http_desc.old_address.sin_port));

   if (http_tls_cfg.enabled) {
      ast_str_append(&out, 0, "<tr><td><i>SSL Bind Port</i></td><td><b>%d</b></td></tr>\r\n",
                ntohs(https_desc.old_address.sin_port));
   }

   ast_str_append(&out, 0, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");

   for (v = vars; v; v = v->next) {
      if (strncasecmp(v->name, "cookie_", 7)) {
         ast_str_append(&out, 0, "<tr><td><i>Submitted 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");

   for (v = vars; v; v = v->next) {
      if (!strncasecmp(v->name, "cookie_", 7)) {
         ast_str_append(&out, 0, "<tr><td><i>Cookie '%s'</i></td><td>%s</td></tr>\r\n", v->name, v->value);
      }
   }

   ast_str_append(&out, 0, "</table><center><font size=\"-1\"><i>Asterisk and Digium are registered trademarks of Digium, Inc.</i></font></center></body>\r\n");
   return out;
}

static uint32_t manid_from_vars ( struct ast_variable * sid ) [static]

Definition at line 148 of file http.c.

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

Referenced by handle_uri(), and static_callback().

                                                          {
   uint32_t mngid;

   while (sid && strcmp(sid->name, "mansession_id"))
      sid = sid->next;

   if (!sid || sscanf(sid->value, "%30x", &mngid) != 1)
      return 0;

   return mngid;
}

static struct ast_variable* parse_cookies ( char * cookies ) [static, read]

replacement read/write functions for SSL support. We use wrappers rather than SSL_read/SSL_write directly so we can put in some debugging.

Definition at line 637 of file http.c.

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

Referenced by httpd_helper_thread().

{
   char *cur;
   struct ast_variable *vars = NULL, *var;

   /* Skip Cookie: */
   cookies += 8;

   while ((cur = strsep(&cookies, ";"))) {
      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;
}

static struct ast_str* 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 *	vars,
		struct ast_variable *	headers,
		int *	status,
		char **	title,
		int *	contentlength
	)		`[static, read]`

Definition at line 167 of file http.c.

References ast_config_AST_DATA_DIR, ast_get_version(), ast_http_error(), ast_localtime(), ast_log(), ast_strdup, ast_strftime(), ast_strlen_zero(), ast_tvnow(), astman_is_authed(), buf, errno, ast_tcptls_session_instance::f, ftype2mtype(), len(), LOG_WARNING, manid_from_vars(), and mtype.

{
   char *path;
   char *ftype;
   const char *mtype;
   char wkspace[80];
   struct stat st;
   int len;
   int fd;
   struct timeval now = ast_tvnow();
   char buf[256];
   struct ast_tm tm;

   /* 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. */
   if (!enablestatic || ast_strlen_zero(uri)) {
      goto out403;
   }

   /* Disallow any funny filenames at all */
   if ((uri[0] < 33) || strchr("./|~@#$%^&*() \t", uri[0])) {
      goto out403;
   }

   if (strstr(uri, "/..")) {
      goto out403;
   }
      
   if ((ftype = strrchr(uri, '.'))) {
      ftype++;
   }

   mtype = ftype2mtype(ftype, wkspace, sizeof(wkspace));
   
   /* Cap maximum length */
   if ((len = strlen(uri) + strlen(ast_config_AST_DATA_DIR) + strlen("/static-http/") + 5) > 1024) {
      goto out403;
   }
      
   path = 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 ((fd = open(path, O_RDONLY)) < 0) {
      goto out403;
   }

   if (strstr(path, "/private/") && !astman_is_authed(manid_from_vars(vars))) {
      goto out403;
   }

   ast_strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S %Z", ast_localtime(&now, &tm, "GMT"));
   fprintf(ser->f, "HTTP/1.1 200 OK\r\n"
      "Server: Asterisk/%s\r\n"
      "Date: %s\r\n"
      "Connection: close\r\n"
      "Cache-Control: private\r\n"
      "Content-Length: %d\r\n"
      "Content-type: %s\r\n\r\n",
      ast_get_version(), buf, (int) st.st_size, mtype);

   while ((len = read(fd, buf, sizeof(buf))) > 0) {
      if (fwrite(buf, 1, len, ser->f) != len) {
         ast_log(LOG_WARNING, "fwrite() failed: %s\n", strerror(errno));
      }
   }

   close(fd);

   return NULL;

out404:
   return ast_http_error((*status = 404),
               (*title = ast_strdup("Not Found")),
                NULL, "The requested URL was not found on this server.");

out403:
   return ast_http_error((*status = 403),
               (*title = ast_strdup("Access Denied")),
               NULL, "You do not have permission to access the requested URL.");
}

Variable Documentation

struct ast_cli_entry cli_http[] [static]

Initial value:

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

Definition at line 1043 of file http.c.

Referenced by ast_http_init().

int enablestatic [static]

Definition at line 97 of file http.c.

const char* ext

struct ast_tcptls_session_args http_desc [static]

we have up to two accepting threads, one for http, one for https

Definition at line 73 of file http.c.

struct ast_tls_config http_tls_cfg [static]

Definition at line 66 of file http.c.

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

struct ast_tcptls_session_args https_desc [static]

Definition at line 83 of file http.c.

struct { ... } mimetypes[] [static]

Referenced by ftype2mtype().

const char* mtype

Definition at line 102 of file http.c.

Referenced by ftype2mtype(), and static_callback().

char prefix[MAX_PREFIX] [static]

Definition at line 96 of file http.c.

Referenced by _while_exec(), ast_db_deltree(), ast_db_gettree(), ast_remotecontrol(), exec_clearhash(), handle_cli_database_show(), hashkeys_read(), read_config(), shared_read(), shared_write(), sip_show_settings(), and while_continue_exec().

int session_count = 0 [static]

Definition at line 64 of file http.c.

int session_limit = DEFAULT_SESSION_LIMIT [static]

Definition at line 63 of file http.c.

struct ast_http_uri staticuri [static]

Definition at line 311 of file http.c.

Referenced by ast_http_init().

struct ast_http_uri statusuri [static]

Definition at line 302 of file http.c.

Referenced by ast_http_init().

struct uri_redirects uri_redirects [static]

struct uris uris [static]

list of supported handlers

Asterisk developer's documentation

Data Structures

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation