http.c File Reference

http server for AMI access More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include "asterisk/network.h"
#include <time.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/signal.h>
#include <fcntl.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 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	MAX_PREFIX   80
Functions
static int	__ast_http_load (int reload)
static void	__fini_uri_redirects (void)
static void	__fini_uris (void)
static void	__init_uri_redirects (void)
static void	__init_uris (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.
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)
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)
	Destroy an HTTP server.
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, int *status, char **title, int *contentlength, struct ast_variable **cookies, 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 char *uri, struct ast_variable *vars, 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 char *uri, struct ast_variable *vars, int *status, char **title, int *contentlength)
Variables
static struct ast_cli_entry	cli_http []
static int	enablestatic
static struct server_args	http_desc
static struct ast_tls_config	http_tls_cfg
static struct server_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 struct ast_http_uri	staticuri
static struct ast_http_uri	statusuri

---

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 MAX_PREFIX   80

Definition at line 57 of file http.c.

Referenced by __ast_http_load().

---

Function Documentation

static int __ast_http_load

(

int

reload

)

[static]

Definition at line 1003 of file http.c.

References add_redirect(), AST_CERTFILE, ast_config_destroy(), ast_config_load, ast_copy_string(), ast_free, ast_gethostbyname(), ast_log(), 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_FILEUNCHANGED, ast_tls_config::enabled, enabled, enablestatic, hp, http_tls_cfg, LOG_WARNING, MAX_PREFIX, ast_variable::name, ast_variable::next, prefix, server_args::sin, server_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 };

   if ((cfg = ast_config_load("http.conf", config_flags)) == CONFIG_STATUS_FILEUNCHANGED)
      return 0;

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

   memset(&https_desc.sin, 0, sizeof(https_desc.sin));
   https_desc.sin.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);

#ifdef ENABLE_UPLOADS
   destroy_post_mappings();
#endif /* ENABLE_UPLOADS */

   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.sin.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.sin.sin_port = htons(atoi(v->value));
         else if (!strcasecmp(v->name, "sslbindaddr")) {
            if ((hp = ast_gethostbyname(v->value, &ahp))) {
               memcpy(&https_desc.sin.sin_addr, hp->h_addr, sizeof(https_desc.sin.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.sin.sin_addr, hp->h_addr, sizeof(http_desc.sin.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 {
            ast_log(LOG_WARNING, "Ignoring unknown option '%s' in http.conf\n", v->name);
         }
      }

#ifdef ENABLE_UPLOADS
      for (v = ast_variable_browse(cfg, "post_mappings"); v; v = v->next)
         add_post_mapping(v->name, v->value);
#endif /* ENABLE_UPLOADS */

      ast_config_destroy(cfg);
   }
   if (!have_sslbindaddr)
      https_desc.sin.sin_addr = http_desc.sin.sin_addr;
   if (enabled)
      http_desc.sin.sin_family = https_desc.sin.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 __fini_uri_redirects

(

void

)

[static]

Definition at line 133 of file http.c.

{

static void __fini_uris

(

void

)

[static]

Definition at line 91 of file http.c.

{

static void __init_uri_redirects

(

void

)

[static]

Definition at line 133 of file http.c.

{

static void __init_uris

(

void

)

[static]

Definition at line 91 of file http.c.

{

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

References ast_str_create(), and ast_str_set().

Referenced by generic_http_callback(), handle_uri(), 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

)

Definition at line 1188 of file http.c.

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

Referenced by main().

{
#ifdef ENABLE_UPLOADS
   g_mime_init(0);
#endif /* ENABLE_UPLOADS */

   ast_http_uri_link(&statusuri);
   ast_http_uri_link(&staticuri);
   ast_cli_register_multiple(cli_http, sizeof(cli_http) / sizeof(struct ast_cli_entry));

   return __ast_http_load(0);
}

int ast_http_reload

(

void

)

Definition at line 1179 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.

Link into the Asterisk HTTP server.

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

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(), and ast_http_uri::uri.

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

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

   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

)

Destroy an HTTP server.

Definition at line 348 of file http.c.

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

Referenced by __init_manager(), and unload_module().

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

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

Definition at line 135 of file http.c.

References ext, mimetypes, and mtype.

Referenced by build_profile(), and static_callback().

{
   int x;
   if (ftype) {
      for (x=0;x<sizeof(mimetypes) / sizeof(mimetypes[0]); x++) {
         if (!strcasecmp(ftype, mimetypes[x].ext))
            return mimetypes[x].mtype;
      }
   }
   snprintf(wkspace, wkspacelen, "text/%s", ftype ? 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 1111 of file http.c.

References ast_cli_args::argc, ast_cli(), ast_inet_ntoa(), AST_LIST_EMPTY, AST_LIST_TRAVERSE, 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, ast_cli_args::fd, ast_http_uri::has_subtree, http_tls_cfg, server_args::oldsin, prefix, http_uri_redirect::target, ast_http_uri::uri, and ast_cli_entry::usage.

{
   struct ast_http_uri *urih;
   struct http_uri_redirect *redirect;

#ifdef ENABLE_UPLOADS
   struct ast_http_post_mapping *post_map;
#endif /* ENABLE_UPLOADS */

   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.oldsin.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.oldsin.sin_addr),
         ntohs(http_desc.oldsin.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.oldsin.sin_addr),
            ntohs(https_desc.oldsin.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);


#ifdef ENABLE_UPLOADS
   ast_cli(a->fd, "\nPOST mappings:\n");
   AST_RWLIST_RDLOCK(&post_mappings);
   AST_LIST_TRAVERSE(&post_mappings, post_map, entry) {
      ast_cli(a->fd, "%s/%s => %s\n", prefix, post_map->from, post_map->to);
   }
   ast_cli(a->fd, "%s\n", AST_LIST_EMPTY(&post_mappings) ? "None.\n" : "");
   AST_RWLIST_UNLOCK(&post_mappings);
#endif /* ENABLE_UPLOADS */

   return CLI_SUCCESS;
}

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

Definition at line 597 of file http.c.

References ast_http_error(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_variable_new(), ast_variables_destroy(), ast_http_uri::callback, cleanup(), http_uri_redirect::dest, http_uri_redirect::entry, ast_http_uri::has_subtree, http_decode(), ast_variable::next, prefix, ast_http_uri::static_content, strsep(), http_uri_redirect::target, and ast_http_uri::uri.

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;

   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)
            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 variables (the only reason to have them
    * at the end is to avoid another pass of the cookies list to find
    * the tail).
    */
   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) {
         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) {
            uri = c;
            break;
         }
      }
      if (!urih)
         AST_RWLIST_UNLOCK(&uris);
   }
   if (urih) {
      if (urih->static_content)
         *static_content = 1;
      out = urih->callback(ser, uri, vars, status, title, contentlength);
      AST_RWLIST_UNLOCK(&uris);
   } else {
      out = ast_http_error(404, "Not Found", NULL,
         "The requested URL was not found on this server.");
      *status = 404;
      *title = ast_strdup("Not Found");
   }

cleanup:
   ast_variables_destroy(vars);
   return out;
}

static void http_decode

(

char *

s

)

[static]

Definition at line 585 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 778 of file http.c.

References ao2_ref(), ast_free, ast_get_version(), ast_http_error(), ast_localtime(), ast_log(), ast_skip_blanks(), ast_skip_nonblanks(), ast_strdupa, ast_strftime(), ast_strlen_zero(), ast_trim_blanks(), ast_tvnow(), ast_variable_new(), ast_variables_destroy(), errno, ast_tcptls_session_instance::f, handle_uri(), LOG_WARNING, name, ast_variable::next, parse_cookies(), ast_str::str, and strsep().

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

   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)) {
         char *name, *value;
         struct ast_variable *var;

         value = ast_strdupa(cookie);
         name = strsep(&value, ":");
         if (!value)
            continue;
         value = ast_skip_blanks(value);
         if (ast_strlen_zero(value))
            continue;
         var = ast_variable_new(name, value, "");
         if (!var)
            continue;
         var->next = headers;
         headers = var;
         continue;
      }

      if (vars) {
         ast_variables_destroy(vars);
      }
      vars = parse_cookies(cookie);
   }

   if (!*uri) {
      out = ast_http_error(400, "Bad Request", NULL, "Invalid Request");
   } else if (!strcasecmp(buf, "post")) {
#ifdef ENABLE_UPLOADS
      out = handle_post(ser, uri, &status, &title, &contentlength, headers, vars);
#else
      out = ast_http_error(501, "Not Implemented", NULL,
         "Attempt to use unimplemented / unsupported method");
#endif /* ENABLE_UPLOADS */
   } else if (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, &status, &title, &contentlength, &vars, &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 tv = ast_tvnow();
      char timebuf[256];
      struct ast_tm tm;

      ast_strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S %Z", ast_localtime(&tv, &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", out->str);
      } else {
         char *tmp = strstr(out->str, "\r\n\r\n");

         if (tmp) {
            fprintf(ser->f, "Content-length: %d\r\n", contentlength);
            /* first write the header, then the body */
            if (fwrite(out->str, 1, (tmp + 4 - out->str), ser->f) != tmp + 4 - out->str) {
               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:
   fclose(ser->f);
   ao2_ref(ser, -1);
   ser = NULL;
   return NULL;
}

static struct ast_str* httpstatus_callback	(	struct ast_tcptls_session_instance *	ser,
		const char *	uri,
		struct ast_variable *	vars,
		int *	status,
		char **	title,
		int *	contentlength
	)			[static, read]

Definition at line 236 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, server_args::oldsin, prefix, 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.oldsin.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.oldsin.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.oldsin.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 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]

Definition at line 741 of file http.c.

References ast_log(), ast_strip(), ast_strip_quoted(), ast_strlen_zero(), ast_variable_new(), LOG_DEBUG, name, option_debug, and strsep().

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

      if (option_debug) {
         ast_log(LOG_DEBUG, "mmm ... 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 char *	uri,
		struct ast_variable *	vars,
		int *	status,
		char **	title,
		int *	contentlength
	)			[static, read]

Definition at line 160 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, enablestatic, 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 tv = 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 */
   len = strlen(uri) + strlen(ast_config_AST_DATA_DIR) + strlen("/static-http/") + 5;
   if (len > 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;
   fd = open(path, O_RDONLY);
   if (fd < 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(&tv, &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 1184 of file http.c.

Referenced by ast_http_init().

int enablestatic [static]

Definition at line 110 of file http.c.

Referenced by __ast_http_load(), and static_callback().

const char* ext

Definition at line 114 of file http.c.

Referenced by ast_filehelper(), ast_rtp_read(), cli_console_dial(), common_exec(), console_transfer(), do_directory(), exts_compare(), ftype2mtype(), iax_park_thread(), misdn_call(), misdn_request(), mixmonitor_thread(), moh_scan_files(), oh323_request(), pbx_load_config(), record_exec(), register_exten(), register_peer_exten(), sip_park_thread(), sip_request_call(), and unregister_exten().

struct server_args http_desc [static]

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

Definition at line 71 of file http.c.

struct ast_tls_config http_tls_cfg [static]

Definition at line 64 of file http.c.

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

struct server_args https_desc [static]

Definition at line 81 of file http.c.

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

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

Referenced by ftype2mtype().

const char* mtype

Definition at line 115 of file http.c.

Referenced by ftype2mtype(), and static_callback().

char prefix[MAX_PREFIX] [static]

list of supported handlers

Definition at line 91 of file http.c.

Referenced by __ast_http_load(), _while_exec(), ast_db_deltree(), ast_db_gettree(), exec_clearhash(), handle_cli_database_show(), handle_show_http(), handle_uri(), hashkeys_read(), httpstatus_callback(), read_config(), shared_read(), shared_write(), sip_show_settings(), and while_continue_exec().

struct ast_http_uri staticuri [static]

Definition at line 280 of file http.c.

Referenced by ast_http_init().

struct ast_http_uri statusuri [static]

Definition at line 273 of file http.c.

Referenced by ast_http_init().