res_http_media_cache.c File Reference

#include "asterisk.h"
#include <curl/curl.h>
#include "asterisk/file.h"
#include "asterisk/module.h"
#include "asterisk/bucket.h"
#include "asterisk/sorcery.h"
#include "asterisk/threadstorage.h"
#include "asterisk/uri.h"

Include dependency graph for res_http_media_cache.c:

Go to the source code of this file.

Data Structures
struct	conf
	All configuration options for http media cache. More...
struct	conf_general_options
	General configuration options for http media cache. More...
struct	curl_bucket_file_data
	Data passed to cURL callbacks. More...

Macros
#define	MAX_HEADER_LENGTH   1023

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static	AO2_GLOBAL_OBJ_STATIC (confs)
	Locking container for safe configuration access.
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	bucket_file_always_revalidate (struct ast_bucket_file *bucket_file)
static int	bucket_file_expired (struct ast_bucket_file *bucket_file)
static int	bucket_file_run_curl (struct ast_bucket_file *bucket_file)
static void	bucket_file_set_expiration (struct ast_bucket_file *bucket_file)
static void	bucket_file_set_extension (struct ast_bucket_file *bucket_file)
static int	bucket_http_wizard_create (const struct ast_sorcery *sorcery, void *data, void *object)
static int	bucket_http_wizard_delete (const struct ast_sorcery *sorcery, void *data, void *object)
static int	bucket_http_wizard_is_stale (const struct ast_sorcery *sorcery, void *data, void *object)
static void *	bucket_http_wizard_retrieve_id (const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
static void *	conf_alloc (void)
	Creates the http media cache conf object.
static void	conf_destructor (void *obj)
	Disposes of the http media cache conf object.
	CONFIG_INFO_STANDARD (cfg_info, confs, conf_alloc,.pre_apply_config=http_media_cache_config_pre_apply,.files=ACO_FILES(&conf_file))
static size_t	curl_body_callback (void *ptr, size_t size, size_t nitems, void *data)
static size_t	curl_header_callback (char *buffer, size_t size, size_t nitems, void *data)
static int	derive_extension_from_mime_type (const char *mime_type, char *buffer, size_t capacity)
static long	execute_curl_instance (CURL *curl)
	Execute the CURL.
static char *	file_extension_from_content_type (struct ast_bucket_file *bucket_file, char *buffer, size_t capacity)
static char *	file_extension_from_string (const char *str, char *buffer, size_t capacity)
static char *	file_extension_from_url_path (struct ast_bucket_file *bucket_file, char *buffer, size_t capacity)
static CURL *	get_curl_instance (struct curl_bucket_file_data *cb_data)
static int	http_media_cache_config_pre_apply (void)
	Pre-apply callback for the config framework.
static int	load_module (void)
static int	normalize_content_type_header (char *content_type)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "HTTP Media Cache Backend" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_curl", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct aco_file	conf_file
	The conf file that's processed for the module.
static struct aco_type	general_option
	Mapping of the http media cache conf struct's general to the general context in the config file.
static struct aco_type *	general_options [] = ACO_TYPES(&general_option)
static struct ast_sorcery_wizard	http_bucket_file_wizard
static struct ast_sorcery_wizard	http_bucket_wizard
static struct ast_sorcery_wizard	https_bucket_file_wizard
static struct ast_sorcery_wizard	https_bucket_wizard

Detailed Description

Author

Matt Jordan <mjordan@digium.com> 

HTTP backend for the core media cache

Definition in file res_http_media_cache.c.

Macro Definition Documentation

MAX_HEADER_LENGTH

#define MAX_HEADER_LENGTH   1023

Definition at line 116 of file res_http_media_cache.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 854 of file res_http_media_cache.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 854 of file res_http_media_cache.c.

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( confs  )

static

Locking container for safe configuration access.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 854 of file res_http_media_cache.c.

bucket_file_always_revalidate()

static int bucket_file_always_revalidate ( struct ast_bucket_file *  bucket_file )

static

Definition at line 470 of file res_http_media_cache.c.

{
    RAII_VAR(struct ast_bucket_metadata *, metadata,
        ast_bucket_file_metadata_get(bucket_file, "cache-control"),
        ao2_cleanup);
 
    if (!metadata) {
        return 0;
    }
 
    if (strstr(metadata->value, "no-cache")
        || strstr(metadata->value, "must-revalidate")) {
        return 1;
    }
 
    return 0;
}

References ao2_cleanup, ast_bucket_file_metadata_get(), and RAII_VAR.

Referenced by bucket_http_wizard_is_stale().

bucket_file_expired()

static int bucket_file_expired ( struct ast_bucket_file *  bucket_file )

static

Definition at line 491 of file res_http_media_cache.c.

{
    RAII_VAR(struct ast_bucket_metadata *, metadata,
        ast_bucket_file_metadata_get(bucket_file, "__actual_expires"),
        ao2_cleanup);
    struct timeval current_time = ast_tvnow();
    struct timeval expires = { .tv_sec = 0, .tv_usec = 0 };
 
    if (!metadata) {
        return 1;
    }
 
    if ((expires.tv_sec = ast_string_to_time_t(metadata->value)) == -1) {
        return 1;
    }
 
    return ast_tvcmp(current_time, expires) == -1 ? 0 : 1;
}

References ao2_cleanup, ast_bucket_file_metadata_get(), ast_string_to_time_t(), ast_tvcmp(), ast_tvnow(), and RAII_VAR.

Referenced by bucket_http_wizard_is_stale().

bucket_file_run_curl()

static int bucket_file_run_curl ( struct ast_bucket_file *  bucket_file )

static

Definition at line 595 of file res_http_media_cache.c.

{
    struct curl_bucket_file_data cb_data = {
        .bucket_file = bucket_file,
    };
    long http_code;
    CURL *curl;
 
    cb_data.out_file = fopen(bucket_file->path, "wb");
    if (!cb_data.out_file) {
        ast_log(LOG_WARNING, "Failed to open file '%s' for writing: %s (%d)\n",
            bucket_file->path, strerror(errno), errno);
        return -1;
    }
 
    curl = get_curl_instance(&cb_data);
    if (!curl) {
        fclose(cb_data.out_file);
        return -1;
    }
 
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_body_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&cb_data);
 
    http_code = execute_curl_instance(curl);
 
    fclose(cb_data.out_file);
 
    if (http_code / 100 == 2) {
        bucket_file_set_expiration(bucket_file);
        bucket_file_set_extension(bucket_file);
        return 0;
    } else {
        ast_log(LOG_WARNING, "Failed to retrieve URL '%s': server returned %ld\n",
            ast_sorcery_object_get_id(bucket_file), http_code);
    }
 
    return -1;
}

References ast_log, ast_sorcery_object_get_id(), curl_bucket_file_data::bucket_file, bucket_file_set_expiration(), bucket_file_set_extension(), curl_body_callback(), errno, execute_curl_instance(), get_curl_instance(), LOG_WARNING, curl_bucket_file_data::out_file, and ast_bucket_file::path.

Referenced by bucket_http_wizard_create(), and bucket_http_wizard_retrieve_id().

bucket_file_set_expiration()

static void bucket_file_set_expiration ( struct ast_bucket_file *  bucket_file )

static

Definition at line 304 of file res_http_media_cache.c.

{
    struct ast_bucket_metadata *metadata;
    char time_buf[32], secs[AST_TIME_T_LEN];
    struct timeval actual_expires = ast_tvnow();
 
    metadata = ast_bucket_file_metadata_get(bucket_file, "cache-control");
    if (metadata) {
        char *str_max_age;
 
        str_max_age = strstr(metadata->value, "s-maxage");
        if (!str_max_age) {
            str_max_age = strstr(metadata->value, "max-age");
        }
 
        if (str_max_age) {
            unsigned int max_age;
            char *equal = strchr(str_max_age, '=');
            if (equal && (sscanf(equal + 1, "%30u", &max_age) == 1)) {
                actual_expires.tv_sec += max_age;
            }
        }
        ao2_ref(metadata, -1);
    } else {
        metadata = ast_bucket_file_metadata_get(bucket_file, "expires");
        if (metadata) {
            struct tm expires_time;
 
            strptime(metadata->value, "%a, %d %b %Y %T %z", &expires_time);
            expires_time.tm_isdst = -1;
            actual_expires.tv_sec = mktime(&expires_time);
 
            ao2_ref(metadata, -1);
        }
    }
 
    /* Use 'now' if we didn't get an expiration time */
    ast_time_t_to_string(actual_expires.tv_sec, secs, sizeof(secs));
    snprintf(time_buf, sizeof(time_buf), "%30s", secs);
 
    ast_bucket_file_metadata_set(bucket_file, "__actual_expires", time_buf);
}

References ao2_ref, ast_bucket_file_metadata_get(), ast_bucket_file_metadata_set(), AST_TIME_T_LEN, ast_time_t_to_string(), ast_tvnow(), and ast_bucket_metadata::value.

Referenced by bucket_file_run_curl(), and bucket_http_wizard_is_stale().

bucket_file_set_extension()

static void bucket_file_set_extension ( struct ast_bucket_file *  bucket_file )

static

Definition at line 453 of file res_http_media_cache.c.

{
    /* Using Content-Type first allows for the most flexibility for whomever
     * is serving up the audio file. If that doesn't turn up anything useful
     * we'll try to parse the URL and use the extension */
 
    char buffer[64];
 
    if (file_extension_from_content_type(bucket_file, buffer, sizeof(buffer))
       || file_extension_from_url_path(bucket_file, buffer, sizeof(buffer))) {
        ast_bucket_file_metadata_set(bucket_file, "ext", buffer);
    }
}

References ast_bucket_file_metadata_set(), file_extension_from_content_type(), and file_extension_from_url_path().

Referenced by bucket_file_run_curl().

bucket_http_wizard_create()

static int bucket_http_wizard_create ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Definition at line 678 of file res_http_media_cache.c.

{
    struct ast_bucket_file *bucket_file = object;
 
    return bucket_file_run_curl(bucket_file);
}

References bucket_file_run_curl().

bucket_http_wizard_delete()

static int bucket_http_wizard_delete ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Definition at line 723 of file res_http_media_cache.c.

{
    struct ast_bucket_file *bucket_file = object;
 
    unlink(bucket_file->path);
 
    return 0;
}

References ast_bucket_file::path.

bucket_http_wizard_is_stale()

static int bucket_http_wizard_is_stale ( const struct ast_sorcery *  sorcery, void *  data, void *  object  )

static

Definition at line 635 of file res_http_media_cache.c.

{
    struct ast_bucket_file *bucket_file = object;
    struct ast_bucket_metadata *metadata;
    struct curl_slist *header_list = NULL;
    long http_code;
    CURL *curl;
    struct curl_bucket_file_data cb_data = {
        .bucket_file = bucket_file
    };
    char etag_buf[256];
 
    if (!bucket_file_expired(bucket_file) && !bucket_file_always_revalidate(bucket_file)) {
        return 0;
    }
 
    /* See if we have an ETag for this item. If not, it's stale. */
    metadata = ast_bucket_file_metadata_get(bucket_file, "etag");
    if (!metadata) {
        return 1;
    }
 
    curl = get_curl_instance(&cb_data);
 
    /* Set the ETag header on our outgoing request */
    snprintf(etag_buf, sizeof(etag_buf), "If-None-Match: %s", metadata->value);
    header_list = curl_slist_append(header_list, etag_buf);
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
    ao2_ref(metadata, -1);
 
    http_code = execute_curl_instance(curl);
 
    curl_slist_free_all(header_list);
 
    if (http_code == 304) {
        bucket_file_set_expiration(bucket_file);
        return 0;
    }
 
    return 1;
}

References ao2_ref, ast_bucket_file_metadata_get(), curl_bucket_file_data::bucket_file, bucket_file_always_revalidate(), bucket_file_expired(), bucket_file_set_expiration(), execute_curl_instance(), get_curl_instance(), NULL, and ast_bucket_metadata::value.

bucket_http_wizard_retrieve_id()

static void * bucket_http_wizard_retrieve_id ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const char *  id  )

static

Definition at line 686 of file res_http_media_cache.c.

{
    struct ast_bucket_file *bucket_file;
 
    if (strcmp(type, "file")) {
        ast_log(LOG_WARNING, "Failed to create storage: invalid bucket type '%s'\n", type);
        return NULL;
    }
 
    if (ast_strlen_zero(id)) {
        ast_log(LOG_WARNING, "Failed to create storage: no URI\n");
        return NULL;
    }
 
    bucket_file = ast_bucket_file_alloc(id);
    if (!bucket_file) {
        ast_log(LOG_WARNING, "Failed to create storage for '%s'\n", id);
        return NULL;
    }
 
    if (ast_bucket_file_temporary_create(bucket_file)) {
        ast_log(LOG_WARNING, "Failed to create temporary storage for '%s'\n", id);
        ast_sorcery_delete(sorcery, bucket_file);
        ao2_ref(bucket_file, -1);
        return NULL;
    }
 
    if (bucket_file_run_curl(bucket_file)) {
        ast_sorcery_delete(sorcery, bucket_file);
        ao2_ref(bucket_file, -1);
        return NULL;
    }
 
    return bucket_file;
}

References ao2_ref, ast_bucket_file_alloc(), ast_bucket_file_temporary_create(), ast_log, ast_sorcery_delete(), ast_strlen_zero(), bucket_file_run_curl(), LOG_WARNING, NULL, sorcery, and type.

conf_alloc()

static void * conf_alloc ( void  )

static

Creates the http media cache conf object.

Definition at line 177 of file res_http_media_cache.c.

{
    struct conf *cfg;
 
    if (!(cfg = ao2_alloc(sizeof(*cfg), conf_destructor))) {
        return NULL;
    }
 
    if (!(cfg->general = ao2_alloc(sizeof(*cfg->general), NULL))) {
        ao2_ref(cfg, -1);
        return NULL;
    }
 
    if (ast_string_field_init(cfg->general, 256)) {
        ao2_ref(cfg, -1);
        return NULL;
    }
 
    return cfg;
}

References ao2_alloc, ao2_ref, ast_string_field_init, conf_destructor(), conf::general, and NULL.

Referenced by load_module().

conf_destructor()

static void conf_destructor ( void *  obj )

static

Disposes of the http media cache conf object.

Definition at line 169 of file res_http_media_cache.c.

{
    struct conf *cfg = obj;
    ast_string_field_free_memory(cfg->general);
    ao2_cleanup(cfg->general);
}

References ao2_cleanup, ast_string_field_free_memory, and conf::general.

Referenced by conf_alloc().

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		confs	,
		conf_alloc	,
		.	pre_apply_config = http_media_cache_config_pre_apply,
		.	files = ACO_FILES(&conf_file)
	)

curl_body_callback()

static size_t curl_body_callback ( void *  ptr, size_t  size, size_t  nitems, void *  data  )

static

Definition at line 291 of file res_http_media_cache.c.

{
    struct curl_bucket_file_data *cb_data = data;
    size_t realsize;
 
    realsize = fwrite(ptr, size, nitems, cb_data->out_file);
 
    return realsize;
}

References curl_bucket_file_data::out_file.

Referenced by bucket_file_run_curl().

curl_header_callback()

static size_t curl_header_callback ( char *  buffer, size_t  size, size_t  nitems, void *  data  )

static

Definition at line 246 of file res_http_media_cache.c.

{
    struct curl_bucket_file_data *cb_data = data;
    size_t realsize;
    char *value;
    char *header;
 
    realsize = size * nitems;
 
    if (realsize > MAX_HEADER_LENGTH) {
        ast_log(LOG_WARNING, "cURL header length of '%zu' is too large: max %d\n",
            realsize, MAX_HEADER_LENGTH);
        return 0;
    }
 
    /* buffer may not be NULL terminated */
    header = ast_alloca(realsize + 1);
    memcpy(header, buffer, realsize);
    header[realsize] = '\0';
    value = strchr(header, ':');
    if (!value) {
        /* Not a header we care about; bail */
        return realsize;
    }
    *value++ = '\0';
 
    if (strcasecmp(header, "ETag")
        && strcasecmp(header, "Cache-Control")
        && strcasecmp(header, "Last-Modified")
        && strcasecmp(header, "Content-Type")
        && strcasecmp(header, "Expires")) {
        return realsize;
    }
 
    value = ast_trim_blanks(ast_skip_blanks(value));
    header = ast_str_to_lower(header);
 
    ast_bucket_file_metadata_set(cb_data->bucket_file, header, value);
 
    return realsize;
}

References ast_alloca, ast_bucket_file_metadata_set(), ast_log, ast_skip_blanks(), ast_str_to_lower(), ast_trim_blanks(), curl_bucket_file_data::bucket_file, LOG_WARNING, MAX_HEADER_LENGTH, and value.

Referenced by get_curl_instance().

derive_extension_from_mime_type()

static int derive_extension_from_mime_type ( const char *  mime_type, char *  buffer, size_t  capacity  )

static

Definition at line 384 of file res_http_media_cache.c.

{
    int res = 0;
 
    /* Compare the provided Content-Type directly, parameters and all */
    res = ast_get_extension_for_mime_type(mime_type, buffer, sizeof(buffer));
    if (!res) {
        char *m = ast_strdupa(mime_type);
        /* Strip MIME type parameters and then check */
        if (normalize_content_type_header(m)) {
            res = ast_get_extension_for_mime_type(m, buffer, sizeof(buffer));
        }
    }
 
    return res;
}

References ast_get_extension_for_mime_type(), ast_strdupa, and normalize_content_type_header().

Referenced by file_extension_from_content_type().

execute_curl_instance()

static long execute_curl_instance ( CURL *  curl )

static

Execute the CURL.

Definition at line 572 of file res_http_media_cache.c.

{
    char curl_errbuf[CURL_ERROR_SIZE + 1];
    long http_code;
 
    curl_errbuf[CURL_ERROR_SIZE] = '\0';
    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf);
 
    if (curl_easy_perform(curl)) {
        ast_log(LOG_WARNING, "%s\n", curl_errbuf);
        return -1;
    }
 
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
 
    curl_easy_cleanup(curl);
 
    return http_code;
}

References ast_log, and LOG_WARNING.

Referenced by bucket_file_run_curl(), and bucket_http_wizard_is_stale().

file_extension_from_content_type()

static char * file_extension_from_content_type ( struct ast_bucket_file *  bucket_file, char *  buffer, size_t  capacity  )

static

Definition at line 401 of file res_http_media_cache.c.

{
    /* Check for the extension based on the MIME type passed in the Content-Type
     * header.
     *
     * If a match is found then retrieve the extension from the supported list
     * corresponding to the mime-type and use that to rename the file */
 
    struct ast_bucket_metadata *header;
 
    header = ast_bucket_file_metadata_get(bucket_file, "content-type");
    if (!header) {
        return NULL;
    }
 
    if (derive_extension_from_mime_type(header->value, buffer, capacity)) {
        ast_debug(3, "Derived extension '%s' from MIME type %s\n",
            buffer,
            header->value);
        ao2_ref(header, -1);
        return buffer;
    }
 
    ao2_ref(header, -1);
 
    return NULL;
}

References ao2_ref, ast_bucket_file_metadata_get(), ast_debug, derive_extension_from_mime_type(), NULL, and header::value.

Referenced by bucket_file_set_extension().

file_extension_from_string()

static char * file_extension_from_string ( const char *  str, char *  buffer, size_t  capacity  )

static

Definition at line 347 of file res_http_media_cache.c.

{
    const char *ext;
 
    ext = strrchr(str, '.');
    if (ext && ast_get_format_for_file_ext(ext + 1)) {
        ast_debug(3, "Found extension '%s' at end of string\n", ext);
        ast_copy_string(buffer, ext, capacity);
        return buffer;
    }
 
    return NULL;
}

References ast_copy_string(), ast_debug, ast_get_format_for_file_ext(), ext, NULL, and str.

Referenced by file_extension_from_url_path().

file_extension_from_url_path()

static char * file_extension_from_url_path ( struct ast_bucket_file *  bucket_file, char *  buffer, size_t  capacity  )

static

Definition at line 429 of file res_http_media_cache.c.

{
    const char *path;
    struct ast_uri *uri;
 
    uri = ast_uri_parse(ast_sorcery_object_get_id(bucket_file));
    if (!uri) {
        ast_log(LOG_ERROR, "Failed to parse URI: %s\n",
            ast_sorcery_object_get_id(bucket_file));
        return NULL;
    }
 
    path = ast_uri_path(uri);
    if (!path) {
        ao2_cleanup(uri);
        return NULL;
    }
 
    /* Just parse it as a string like before, but without the extra cruft */
    buffer = file_extension_from_string(path, buffer, capacity);
    ao2_cleanup(uri);
    return buffer;
}

References ao2_cleanup, ast_log, ast_sorcery_object_get_id(), ast_uri_parse(), ast_uri_path(), file_extension_from_string(), LOG_ERROR, NULL, ast_uri::path, and ast_uri::uri.

Referenced by bucket_file_set_extension().

get_curl_instance()

static CURL * get_curl_instance ( struct curl_bucket_file_data *  cb_data )

static

Definition at line 513 of file res_http_media_cache.c.

{
    RAII_VAR(struct conf *, cfg, ao2_global_obj_ref(confs), ao2_cleanup);
    CURLcode rc;
    CURL *curl;
 
    curl = curl_easy_init();
    if (!curl) {
        return NULL;
    }
 
    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, curl_header_callback);
    curl_easy_setopt(curl, CURLOPT_URL, ast_sorcery_object_get_id(cb_data->bucket_file));
    curl_easy_setopt(curl, CURLOPT_HEADERDATA, cb_data);
 
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, cfg->general->curl_timeout);
    curl_easy_setopt(curl, CURLOPT_USERAGENT, cfg->general->curl_useragent);
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, cfg->general->curl_followlocation ? 1 : 0);
    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, cfg->general->curl_maxredirs);
 
    if (!ast_strlen_zero(cfg->general->curl_proxy)) {
        curl_easy_setopt(curl, CURLOPT_PROXY, cfg->general->curl_proxy);
    }
 
    if (!ast_strlen_zero(cfg->general->curl_protocols)) {
#ifdef AST_CURL_HAS_PROTOCOLS_STR
        CURLcode rc = curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, cfg->general->curl_protocols);
        if (rc != CURLE_OK) {
            ast_log(AST_LOG_ERROR, "Setting protocols to '%s' failed: %d\n", cfg->general->curl_protocols, rc);
            curl_easy_cleanup(curl);
            return NULL;
        }
#endif
    }
    if (!ast_strlen_zero(cfg->general->curl_redir_protocols)) {
#ifdef AST_CURL_HAS_PROTOCOLS_STR
        CURLcode rc = curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS_STR, cfg->general->curl_redir_protocols);
        if (rc != CURLE_OK) {
            ast_log(AST_LOG_ERROR, "Setting redirect_protocols to '%s' failed: %d\n", cfg->general->curl_redir_protocols, rc);
            curl_easy_cleanup(curl);
            return NULL;
        }
#endif
    }
 
    rc = curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, cfg->general->curl_dns_cache_timeout);
    if (rc != CURLE_OK) {
        ast_log(AST_LOG_ERROR, "Setting dns_cache_timeout to '%d' failed: %d\n", cfg->general->curl_dns_cache_timeout, rc);
        curl_easy_cleanup(curl);
        return NULL;
    }
 
    return curl;
}

References ao2_cleanup, ao2_global_obj_ref, ast_log, AST_LOG_ERROR, ast_sorcery_object_get_id(), ast_strlen_zero(), curl_bucket_file_data::bucket_file, curl_header_callback(), NULL, and RAII_VAR.

http_media_cache_config_pre_apply()

static int http_media_cache_config_pre_apply ( void  )

static

Pre-apply callback for the config framework.

This validates that used options match the ones supported by CURL.

Definition at line 215 of file res_http_media_cache.c.

{
#ifndef AST_CURL_HAS_PROTOCOLS_STR
    struct conf *cfg = aco_pending_config(&cfg_info);
 
    if (!ast_strlen_zero(cfg->general->curl_protocols)) {
        ast_log(AST_LOG_ERROR, "'protocols' not supported by linked CURL library. Please recompile against newer CURL.\n");
        return -1;
    }
 
    if (!ast_strlen_zero(cfg->general->curl_redir_protocols)) {
        ast_log(AST_LOG_ERROR, "'redirect_protocols' not supported by linked CURL library. Please recompile against newer CURL.\n");
        return -1;
    }
#endif
 
    return 0;
}

References aco_pending_config(), ast_log, AST_LOG_ERROR, ast_strlen_zero(), conf_general_options::curl_protocols, conf_general_options::curl_redir_protocols, and conf::general.

load_module()

static int load_module ( void  )

static

Definition at line 772 of file res_http_media_cache.c.

{
    if (aco_info_init(&cfg_info)) {
        aco_info_destroy(&cfg_info);
        return AST_MODULE_LOAD_DECLINE;
    }
 
 
    aco_option_register(&cfg_info, "timeout_secs", ACO_EXACT, general_options,
            "180", OPT_INT_T, 0,
            FLDSET(struct conf_general_options, curl_timeout));
 
    aco_option_register(&cfg_info, "user_agent", ACO_EXACT, general_options,
            AST_CURL_USER_AGENT, OPT_STRINGFIELD_T, 0,
            STRFLDSET(struct conf_general_options, curl_useragent));
 
    aco_option_register(&cfg_info, "follow_location", ACO_EXACT, general_options,
            "yes", OPT_BOOL_T, 1,
            FLDSET(struct conf_general_options, curl_followlocation));
 
    aco_option_register(&cfg_info, "max_redirects", ACO_EXACT, general_options,
            "8", OPT_INT_T, 0,
            FLDSET(struct conf_general_options, curl_maxredirs));
 
    aco_option_register(&cfg_info, "proxy", ACO_EXACT, general_options,
            NULL, OPT_STRINGFIELD_T, 1,
            STRFLDSET(struct conf_general_options, curl_proxy));
 
    aco_option_register(&cfg_info, "dns_cache_timeout_secs", ACO_EXACT, general_options,
            "60", OPT_INT_T, 0,
            FLDSET(struct conf_general_options, curl_dns_cache_timeout));
 
    aco_option_register(&cfg_info, "protocols", ACO_EXACT, general_options,
            NULL, OPT_STRINGFIELD_T, 1,
            STRFLDSET(struct conf_general_options, curl_protocols));
 
    aco_option_register(&cfg_info, "redirect_protocols", ACO_EXACT, general_options,
            NULL, OPT_STRINGFIELD_T, 1,
            STRFLDSET(struct conf_general_options, curl_redir_protocols));
 
 
    if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
        struct conf *cfg;
 
        ast_log(LOG_NOTICE, "Could not load res_http_media_cache config; using defaults\n");
        cfg = conf_alloc();
        if (!cfg) {
            aco_info_destroy(&cfg_info);
            return AST_MODULE_LOAD_DECLINE;
        }
 
        if (aco_set_defaults(&general_option, "general", cfg->general)) {
            ast_log(LOG_ERROR, "Failed to initialize res_http_media_cache defaults.\n");
            ao2_ref(cfg, -1);
            aco_info_destroy(&cfg_info);
            return AST_MODULE_LOAD_DECLINE;
        }
 
        ao2_global_obj_replace_unref(confs, cfg);
        ao2_ref(cfg, -1);
    }
 
    if (ast_bucket_scheme_register("http", &http_bucket_wizard, &http_bucket_file_wizard,
            NULL, NULL)) {
        ast_log(LOG_ERROR, "Failed to register Bucket HTTP wizard scheme implementation\n");
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_bucket_scheme_register("https", &https_bucket_wizard, &https_bucket_file_wizard,
            NULL, NULL)) {
        ast_log(LOG_ERROR, "Failed to register Bucket HTTPS wizard scheme implementation\n");
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ACO_EXACT, aco_info_destroy(), aco_info_init(), aco_option_register, aco_process_config(), ACO_PROCESS_ERROR, aco_set_defaults(), ao2_global_obj_replace_unref, ao2_ref, ast_bucket_scheme_register, AST_CURL_USER_AGENT, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, conf_alloc(), FLDSET, conf::general, general_option, general_options, http_bucket_file_wizard, http_bucket_wizard, https_bucket_file_wizard, https_bucket_wizard, LOG_ERROR, LOG_NOTICE, NULL, OPT_BOOL_T, OPT_INT_T, OPT_STRINGFIELD_T, and STRFLDSET.

normalize_content_type_header()

static int normalize_content_type_header ( char *  content_type )

static

Definition at line 369 of file res_http_media_cache.c.

{
    char *params = strchr(content_type, ';');
 
    if (params) {
        *params-- = 0;
        while (params > content_type && (*params == ' ' || *params == '\t')) {
            *params-- = 0;
        }
        return 1;
    }
 
    return 0;
}

Referenced by derive_extension_from_mime_type().

unload_module()

static int unload_module ( void  )

static

Definition at line 765 of file res_http_media_cache.c.

{
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(confs);
    return 0;
}

References aco_info_destroy(), and ao2_global_obj_release.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "HTTP Media Cache Backend" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_curl", }

static

Definition at line 854 of file res_http_media_cache.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 854 of file res_http_media_cache.c.

conf_file

struct aco_file conf_file

static

The conf file that's processed for the module.

Definition at line 199 of file res_http_media_cache.c.

                                   {
    /*! The config file name. */
    .filename = "res_http_media_cache.conf",
    /*! The mapping object types to be processed. */
    .types = ACO_TYPES(&general_option),
};

general_option

struct aco_type general_option

static

Mapping of the http media cache conf struct's general to the general context in the config file.

Definition at line 158 of file res_http_media_cache.c.

                                        {
    .type = ACO_GLOBAL,
    .name = "general",
    .item_offset = offsetof(struct conf, general),
    .category = "general",
    .category_match = ACO_WHITELIST_EXACT,
};

Referenced by load_module().

general_options

struct aco_type* general_options[] = ACO_TYPES(&general_option)

static

Definition at line 166 of file res_http_media_cache.c.

Referenced by load_module().

http_bucket_file_wizard

struct ast_sorcery_wizard http_bucket_file_wizard

static

Definition at line 741 of file res_http_media_cache.c.

                                                           {
    .name = "http",
    .create = bucket_http_wizard_create,
    .retrieve_id = bucket_http_wizard_retrieve_id,
    .delete = bucket_http_wizard_delete,
    .is_stale = bucket_http_wizard_is_stale,
};

Referenced by load_module().

http_bucket_wizard

struct ast_sorcery_wizard http_bucket_wizard

static

Definition at line 733 of file res_http_media_cache.c.

                                                      {
    .name = "http",
    .create = bucket_http_wizard_create,
    .retrieve_id = bucket_http_wizard_retrieve_id,
    .delete = bucket_http_wizard_delete,
    .is_stale = bucket_http_wizard_is_stale,
};

Referenced by load_module().

https_bucket_file_wizard

struct ast_sorcery_wizard https_bucket_file_wizard

static

Definition at line 757 of file res_http_media_cache.c.

                                                            {
    .name = "https",
    .create = bucket_http_wizard_create,
    .retrieve_id = bucket_http_wizard_retrieve_id,
    .delete = bucket_http_wizard_delete,
    .is_stale = bucket_http_wizard_is_stale,
};

Referenced by load_module().

https_bucket_wizard

struct ast_sorcery_wizard https_bucket_wizard

static

Definition at line 749 of file res_http_media_cache.c.

                                                       {
    .name = "https",
    .create = bucket_http_wizard_create,
    .retrieve_id = bucket_http_wizard_retrieve_id,
    .delete = bucket_http_wizard_delete,
    .is_stale = bucket_http_wizard_is_stale,
};

Referenced by load_module().