Routines implementing music on hold. More...

#include "asterisk.h"
#include <ctype.h>
#include <signal.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <dirent.h>
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/say.h"
#include "asterisk/musiconhold.h"
#include "asterisk/config.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"
#include "asterisk/stringfields.h"
#include "asterisk/linkedlists.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/paths.h"
#include "asterisk/astobj2.h"
#include "asterisk/timing.h"
#include "asterisk/time.h"
#include "asterisk/poll-compat.h"

Data Structures
struct	moh_files_state

struct	mohclass

struct	mohdata

Macros
#define	DONT_UNREF 0

#define	get_mohbyname(a, b, c) _get_mohbyname(a,b,c,__FILE__,__LINE__,__PRETTY_FUNCTION__)

#define	HANDLE_REF 1

#define	INITIAL_NUM_FILES 8

#define	LOCAL_MPG_123 "/usr/local/bin/mpg123"

#define	MAX_MP3S 256

#define	MOH_ANNOUNCEMENT (1 << 6)

#define	MOH_CACHERTCLASSES (1 << 5)

#define	moh_class_malloc() _moh_class_malloc(__FILE__,__LINE__,__PRETTY_FUNCTION__)

#define	MOH_CUSTOM (1 << 2)

#define	MOH_MS_INTERVAL 100

#define	MOH_NOTDELETED (1 << 30)

#define	MOH_PREFERCHANNELCLASS (1 << 7)

#define	MOH_QUIET (1 << 0)

#define	MOH_RANDOMIZE (1 << 3)

#define	MOH_RANDSTART (MOH_RANDOMIZE \| MOH_SORTALPHA)

#define	MOH_REALTIME (1 << 31)

#define	moh_register(moh, reload, unref) _moh_register(moh, reload, unref, __FILE__, __LINE__, __PRETTY_FUNCTION__)

#define	MOH_SINGLE (1 << 1)

#define	MOH_SORTALPHA (1 << 4)

#define	MOH_SORTMODE (3 << 3)

#define	moh_unregister(a) _moh_unregister(a,__FILE__,__LINE__,__PRETTY_FUNCTION__)

#define	mohclass_ref(class, string) (ao2_t_ref((class), +1, (string)), class)

#define	mohclass_unref(class, string) ({ ao2_t_ref((class), -1, (string)); (struct mohclass *) NULL; })

#define	MPG_123 "/usr/bin/mpg123"

Enumerations
enum	kill_methods { KILL_METHOD_PROCESS_GROUP = 0, KILL_METHOD_PROCESS }

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

static struct mohclass *	_get_mohbyname (const char name, int warn, int flags, const char file, int lineno, const char *funcname)

static struct mohclass *	_moh_class_malloc (const char file, int line, const char funcname)

static int	_moh_register (struct mohclass moh, int reload, int unref, const char file, int line, const char *funcname)

static int	_moh_unregister (struct mohclass moh, const char file, int line, const char *funcname)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static void	ast_moh_destroy (void)

static int	ast_moh_files_next (struct ast_channel *chan)

static char *	complete_mohclass_realtime (const char line, const char word, int pos, int state)
	Support routing for 'moh unregister class' CLI This is in charge of generating all strings that match a prefix in the given position. As many functions of this kind, each invokation has O(state) time complexity so be careful in using it. More...

static struct mohclass *	get_mohbydigit (char digit)

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

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

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

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

static int	init_app_class (struct mohclass *class)

static int	init_files_class (struct mohclass *class)

static int	killer (pid_t pid, int signum, enum kill_methods kill_method)

static void	killpid (int pid, size_t delay, enum kill_methods kill_method)

static int	load_module (void)
	Load the module. More...

static int	load_moh_classes (int reload)

static struct ast_variable *	load_realtime_musiconhold (const char *name)

static void	local_ast_moh_cleanup (struct ast_channel *chan)

static int	local_ast_moh_start (struct ast_channel chan, const char mclass, const char *interpclass)

static void	local_ast_moh_stop (struct ast_channel *chan)

static void *	moh_alloc (struct ast_channel chan, void params)

static int	moh_class_cmp (void obj, void arg, int flags)

static void	moh_class_destructor (void *obj)

static int	moh_class_hash (const void *obj, const int flags)

static int	moh_class_inuse (void obj, void arg, int flags)

static int	moh_class_mark (void obj, void arg, int flags)

static int	moh_classes_delete_marked (void obj, void arg, int flags)

static int	moh_diff (struct mohclass old, struct mohclass new)

static int	moh_digit_match (void obj, void arg, int flags)

static void *	moh_files_alloc (struct ast_channel chan, void params)

static int	moh_files_generator (struct ast_channel chan, void data, int len, int samples)

static struct ast_frame *	moh_files_readframe (struct ast_channel *chan)

static void	moh_files_release (struct ast_channel chan, void data)

static void	moh_files_write_format_change (struct ast_channel chan, void data)

static int	moh_generate (struct ast_channel chan, void data, int len, int samples)

static void	moh_handle_digit (struct ast_channel *chan, char digit)

static void	moh_parse_options (struct ast_variable var, struct mohclass mohclass)

static void	moh_post_start (struct ast_channel chan, const char moh_class_name)

static void	moh_post_stop (struct ast_channel *chan)

static void	moh_release (struct ast_channel chan, void data)

static void	moh_rescan_files (void)

static int	moh_scan_files (struct mohclass *class)

static struct mohdata *	mohalloc (struct mohclass *cl)

static void *	monmp3thread (void *data)

static int	play_moh_exec (struct ast_channel chan, const char data)

static int	reload (void)

static int	spawn_mp3 (struct mohclass *class)

static int	start_moh_exec (struct ast_channel chan, const char data)

static int	stop_moh_exec (struct ast_channel chan, const char data)

static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Music On Hold Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DEPEND, }

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct ast_cli_entry	cli_moh []

static struct ast_flags	global_flags [1] = {{0}}

static struct ast_generator	moh_file_stream

static struct ao2_container *	mohclasses

static struct ast_generator	mohgen

static const char	play_moh [] = "MusicOnHold"

static int	respawn_time = 20

static const char	start_moh [] = "StartMusicOnHold"

static const char	stop_moh [] = "StopMusicOnHold"

Detailed Description

Routines implementing music on hold.

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

Definition in file res_musiconhold.c.

Macro Definition Documentation

◆ DONT_UNREF

#define DONT_UNREF 0

Definition at line 78 of file res_musiconhold.c.

Referenced by local_ast_moh_start().

◆ get_mohbyname

#define get_mohbyname	(	a,
		b,
		c
	)	_get_mohbyname(a,b,c,__FILE__,__LINE__,__PRETTY_FUNCTION__)

Definition at line 919 of file res_musiconhold.c.

Referenced by local_ast_moh_start().

◆ HANDLE_REF

#define HANDLE_REF 1

Definition at line 77 of file res_musiconhold.c.

Referenced by load_moh_classes().

◆ INITIAL_NUM_FILES

#define INITIAL_NUM_FILES 8

Definition at line 76 of file res_musiconhold.c.

◆ LOCAL_MPG_123

#define LOCAL_MPG_123 "/usr/local/bin/mpg123"

Definition at line 208 of file res_musiconhold.c.

Referenced by spawn_mp3().

◆ MAX_MP3S

#define MAX_MP3S 256

Definition at line 210 of file res_musiconhold.c.

Referenced by spawn_mp3().

◆ MOH_ANNOUNCEMENT

#define MOH_ANNOUNCEMENT (1 << 6)

Do we play announcement files between songs on this channel?

Definition at line 153 of file res_musiconhold.c.

Referenced by ast_moh_files_next(), handle_cli_moh_show_classes(), and moh_parse_options().

◆ MOH_CACHERTCLASSES

#define MOH_CACHERTCLASSES (1 << 5)

Should we use a separate instance of MOH for each user or not

Definition at line 152 of file res_musiconhold.c.

Referenced by load_moh_classes(), and local_ast_moh_start().

◆ moh_class_malloc

#define moh_class_malloc ( ) _moh_class_malloc(__FILE__,__LINE__,__PRETTY_FUNCTION__)

Definition at line 1495 of file res_musiconhold.c.

Referenced by load_moh_classes(), and local_ast_moh_start().

◆ MOH_CUSTOM

#define MOH_CUSTOM (1 << 2)

Definition at line 146 of file res_musiconhold.c.

Referenced by handle_cli_moh_show_classes(), init_app_class(), local_ast_moh_start(), and spawn_mp3().

◆ MOH_MS_INTERVAL

#define MOH_MS_INTERVAL 100

Referenced by monmp3thread().

◆ MOH_NOTDELETED

#define MOH_NOTDELETED (1 << 30)

Find only records that aren't deleted?

Definition at line 157 of file res_musiconhold.c.

Referenced by _moh_register(), and moh_class_cmp().

◆ MOH_PREFERCHANNELCLASS

#define MOH_PREFERCHANNELCLASS (1 << 7)

Should queue moh override channel moh

Definition at line 154 of file res_musiconhold.c.

Referenced by load_moh_classes(), and local_ast_moh_start().

◆ MOH_QUIET

#define MOH_QUIET (1 << 0)

Definition at line 144 of file res_musiconhold.c.

Referenced by init_app_class(), local_ast_moh_start(), and spawn_mp3().

◆ MOH_RANDOMIZE

#define MOH_RANDOMIZE (1 << 3)

Definition at line 147 of file res_musiconhold.c.

Referenced by ast_moh_files_next(), local_ast_moh_start(), moh_files_alloc(), and moh_parse_options().

◆ MOH_RANDSTART

#define MOH_RANDSTART (MOH_RANDOMIZE | MOH_SORTALPHA)

Sorted but start at random position

Definition at line 149 of file res_musiconhold.c.

Referenced by moh_parse_options().

◆ MOH_REALTIME

#define MOH_REALTIME (1 << 31)

Find only records that are realtime

Definition at line 158 of file res_musiconhold.c.

Referenced by load_moh_classes(), and moh_class_mark().

◆ moh_register

#define moh_register	(	moh,
		reload,
		unref
	)	_moh_register(moh, reload, unref, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Note: This function owns the reference it gets to moh if unref is true

Definition at line 1328 of file res_musiconhold.c.

Referenced by load_moh_classes(), and local_ast_moh_start().

◆ MOH_SINGLE

#define MOH_SINGLE (1 << 1)

Definition at line 145 of file res_musiconhold.c.

Referenced by init_app_class(), local_ast_moh_start(), and spawn_mp3().

◆ MOH_SORTALPHA

#define MOH_SORTALPHA (1 << 4)

Definition at line 148 of file res_musiconhold.c.

Referenced by moh_parse_options(), and moh_scan_files().

◆ MOH_SORTMODE

#define MOH_SORTMODE (3 << 3)

Definition at line 150 of file res_musiconhold.c.

Referenced by ast_moh_files_next().

◆ moh_unregister

#define moh_unregister ( a ) _moh_unregister(a,__FILE__,__LINE__,__PRETTY_FUNCTION__)

Definition at line 1390 of file res_musiconhold.c.

Referenced by handle_cli_moh_unregister_class().

◆ mohclass_ref

#define mohclass_ref	(	class,
		string
	)	(ao2_t_ref((class), +1, (string)), class)

Definition at line 215 of file res_musiconhold.c.

Referenced by local_ast_moh_start(), moh_alloc(), moh_files_alloc(), and mohalloc().

◆ mohclass_unref

#define mohclass_unref	(	class,
		string
	)	({ ao2_t_ref((class), -1, (string)); (struct mohclass *) NULL; })

Definition at line 218 of file res_musiconhold.c.

Referenced by _moh_register(), complete_mohclass_realtime(), handle_cli_moh_show_classes(), handle_cli_moh_show_files(), handle_cli_moh_unregister_class(), load_moh_classes(), local_ast_moh_cleanup(), local_ast_moh_start(), moh_alloc(), moh_files_alloc(), moh_files_release(), moh_handle_digit(), moh_release(), and unload_module().

◆ MPG_123

#define MPG_123 "/usr/bin/mpg123"

Definition at line 209 of file res_musiconhold.c.

Referenced by spawn_mp3().

Enumeration Type Documentation

◆ kill_methods

enum kill_methods

Enumerator
KILL_METHOD_PROCESS_GROUP
KILL_METHOD_PROCESS

Definition at line 162 of file res_musiconhold.c.

                   {
    KILL_METHOD_PROCESS_GROUP = 0,
    KILL_METHOD_PROCESS
 };

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 2168 of file res_musiconhold.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 2168 of file res_musiconhold.c.

◆ _get_mohbyname()

static struct mohclass* _get_mohbyname	(	const char *	name,
		int	warn,
		int	flags,
		const char *	file,
		int	lineno,
		const char *	funcname
	)

static

Definition at line 921 of file res_musiconhold.c.

References __ao2_find(), ast_copy_string(), ast_log, mohclass::flags, LOG_WARNING, mohclass::name, and NULL.

Referenced by _moh_register().

 {
    struct mohclass *moh = NULL;
    struct mohclass tmp_class = {
       .flags = 0,
    };
 
    ast_copy_string(tmp_class.name, name, sizeof(tmp_class.name));
 
    moh = __ao2_find(mohclasses, &tmp_class, flags,
       "get_mohbyname", file, lineno, funcname);
 
    if (!moh && warn) {
       ast_log(LOG_WARNING, "Music on Hold class '%s' not found in memory. Verify your configuration.\n", name);
    }
 
    return moh;
 }

◆ _moh_class_malloc()

static struct mohclass* _moh_class_malloc	(	const char *	file,
		int	line,
		const char *	funcname
	)

static

Definition at line 1497 of file res_musiconhold.c.

References __ao2_alloc(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_bump, ast_format_slin, AST_VECTOR_INIT, moh_files_state::class, mohclass::files, and moh_class_destructor().

 {
    struct mohclass *class;
 
    class = __ao2_alloc(sizeof(*class), moh_class_destructor, AO2_ALLOC_OPT_LOCK_MUTEX,
       "Allocating new moh class", file, line, funcname);
    if (class) {
       class->format = ao2_bump(ast_format_slin);
       class->srcfd = -1;
       class->kill_delay = 100000;
       AST_VECTOR_INIT(&class->files, 0);
    }
 
    return class;
 }

◆ _moh_register()

static int _moh_register	(	struct mohclass *	moh,
		int	reload,
		int	unref,
		const char *	file,
		int	line,
		const char *	funcname
	)

static

Definition at line 1329 of file res_musiconhold.c.

References _get_mohbyname(), ao2_t_link, ast_log, AST_VECTOR_SIZE, mohclass::files, init_app_class(), init_files_class(), LOG_WARNING, mohclass::mode, moh_diff(), MOH_NOTDELETED, mohclass_unref, mohclass::name, NULL, respawn_time, and mohclass::start.

 {
    struct mohclass *mohclass = NULL;
 
    mohclass = _get_mohbyname(moh->name, 0, MOH_NOTDELETED, file, line, funcname);
 
    if (mohclass && !moh_diff(mohclass, moh)) {
       ast_log(LOG_WARNING, "Music on Hold class '%s' already exists\n", moh->name);
       mohclass = mohclass_unref(mohclass, "unreffing mohclass we just found by name");
       if (unref) {
          moh = mohclass_unref(moh, "unreffing potential new moh class (it is a duplicate)");
       }
       return -1;
    } else if (mohclass) {
       /* Found a class, but it's different from the one being registered */
       mohclass = mohclass_unref(mohclass, "unreffing mohclass we just found by name");
    }
 
    time(&moh->start);
    moh->start -= respawn_time;
 
    if (!strcasecmp(moh->mode, "files")) {
       if (init_files_class(moh)) {
          if (unref) {
             moh = mohclass_unref(moh, "unreffing potential new moh class (init_files_class failed)");
          }
          return -1;
       }
    } else if (!strcasecmp(moh->mode, "playlist")) {
       if (!AST_VECTOR_SIZE(&moh->files)) {
          if (unref) {
             moh = mohclass_unref(moh, "unreffing potential new moh class (no playlist entries)");
          }
          return -1;
       }
    } else if (!strcasecmp(moh->mode, "mp3") || !strcasecmp(moh->mode, "mp3nb") ||
          !strcasecmp(moh->mode, "quietmp3") || !strcasecmp(moh->mode, "quietmp3nb") ||
          !strcasecmp(moh->mode, "httpmp3") || !strcasecmp(moh->mode, "custom")) {
       if (init_app_class(moh)) {
          if (unref) {
             moh = mohclass_unref(moh, "unreffing potential new moh class (init_app_class_failed)");
          }
          return -1;
       }
    } else {
       ast_log(LOG_WARNING, "Don't know how to do a mode '%s' music on hold\n", moh->mode);
       if (unref) {
          moh = mohclass_unref(moh, "unreffing potential new moh class (unknown mode)");
       }
       return -1;
    }
 
    ao2_t_link(mohclasses, moh, "Adding class to container");
 
    if (unref) {
       moh = mohclass_unref(moh, "Unreffing new moh class because we just added it to the container");
    }
 
    return 0;
 }

◆ _moh_unregister()

static int _moh_unregister	(	struct mohclass *	moh,
		const char *	file,
		int	line,
		const char *	funcname
	)

static

Definition at line 1391 of file res_musiconhold.c.

References ao2_t_unlink.

 {
    ao2_t_unlink(mohclasses, moh, "Removing class from container");
    return 0;
 }

◆ AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM ( void )

Definition at line 2168 of file res_musiconhold.c.

◆ ast_moh_destroy()

static void ast_moh_destroy ( void )

static

Definition at line 1941 of file res_musiconhold.c.

References ao2_ref, ao2_t_callback, ast_verb, NULL, OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

Referenced by load_module(), and unload_module().

 {
    ast_verb(2, "Destroying musiconhold processes\n");
    if (mohclasses) {
       ao2_t_callback(mohclasses, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "Destroy callback");
       ao2_ref(mohclasses, -1);
       mohclasses = NULL;
    }
 }

◆ ast_moh_files_next()

static int ast_moh_files_next ( struct ast_channel * chan )

static

Definition at line 313 of file res_musiconhold.c.

References moh_files_state::announcement, mohclass::announcement, ast_channel_language(), ast_channel_music_state(), ast_channel_name(), ast_channel_stream(), ast_channel_stream_set(), ast_closestream(), ast_copy_string(), ast_debug, ast_fileexists(), ast_log, ast_openstream_full(), ast_random(), ast_seekstream(), ast_strlen_zero, ast_tellstream(), ast_test_flag, AST_VECTOR_GET, AST_VECTOR_SIZE, moh_files_state::class, errno, mohclass::files, LOG_WARNING, MOH_ANNOUNCEMENT, MOH_RANDOMIZE, MOH_SORTMODE, mohclass::name, NULL, moh_files_state::pos, moh_files_state::samples, moh_files_state::save_pos, and moh_files_state::save_pos_filename.

Referenced by moh_files_readframe().

 {
    struct moh_files_state *state = ast_channel_music_state(chan);
    int tries;
    size_t file_count;
 
    /* Discontinue a stream if it is running already */
    if (ast_channel_stream(chan)) {
       ast_closestream(ast_channel_stream(chan));
       ast_channel_stream_set(chan, NULL);
    }
 
    if (ast_test_flag(state->class, MOH_ANNOUNCEMENT) && state->announcement == 0) {
       state->announcement = 1;
       if (ast_openstream_full(chan, state->class->announcement, ast_channel_language(chan), 1)) {
          ast_debug(1, "%s Opened announcement '%s'\n", ast_channel_name(chan), state->class->announcement);
          return 0;
       }
    } else {
       state->announcement = 0;
    }
 
    file_count = AST_VECTOR_SIZE(&state->class->files);
    if (!file_count) {
       ast_log(LOG_WARNING, "No files available for class '%s'\n", state->class->name);
       return -1;
    }
 
    if (state->pos == 0 && ast_strlen_zero(state->save_pos_filename)) {
       /* First time so lets play the file. */
       state->save_pos = -1;
    } else if (state->save_pos >= 0 && state->save_pos < file_count && !strcmp(AST_VECTOR_GET(&state->class->files, state->save_pos), state->save_pos_filename)) {
       /* If a specific file has been saved confirm it still exists and that it is still valid */
       state->pos = state->save_pos;
       state->save_pos = -1;
    } else if (ast_test_flag(state->class, MOH_SORTMODE) == MOH_RANDOMIZE) {
       /* Get a random file and ensure we can open it */
       for (tries = 0; tries < 20; tries++) {
          state->pos = ast_random() % file_count;
          if (ast_fileexists(AST_VECTOR_GET(&state->class->files, state->pos), NULL, NULL) > 0) {
             break;
          }
       }
       state->save_pos = -1;
       state->samples = 0;
    } else {
       /* This is easy, just increment our position and make sure we don't exceed the total file count */
       state->pos++;
       state->pos %= file_count;
       state->save_pos = -1;
       state->samples = 0;
    }
 
    for (tries = 0; tries < file_count; ++tries) {
       if (ast_openstream_full(chan, AST_VECTOR_GET(&state->class->files, state->pos), ast_channel_language(chan), 1)) {
          break;
       }
 
       ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", AST_VECTOR_GET(&state->class->files, state->pos), strerror(errno));
       state->pos++;
       state->pos %= file_count;
    }
 
    if (tries == file_count) {
       return -1;
    }
 
    /* Record the pointer to the filename for position resuming later */
    ast_copy_string(state->save_pos_filename, AST_VECTOR_GET(&state->class->files, state->pos), sizeof(state->save_pos_filename));
 
    ast_debug(1, "%s Opened file %d '%s'\n", ast_channel_name(chan), state->pos, state->save_pos_filename);
 
    if (state->samples) {
       size_t loc;
       /* seek *SHOULD* be good since it's from a known location */
       ast_seekstream(ast_channel_stream(chan), state->samples, SEEK_SET);
       /* if the seek failed then recover because if there is not a valid read,
        * moh_files_generate will return -1 and MOH will stop */
       loc = ast_tellstream(ast_channel_stream(chan));
       if (state->samples > loc && loc) {
          /* seek one sample from the end for one guaranteed valid read */
          ast_seekstream(ast_channel_stream(chan), 1, SEEK_END);
       }
    }
 
    return 0;
 }

◆ complete_mohclass_realtime()

static char* complete_mohclass_realtime	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)

static

Support routing for 'moh unregister class' CLI This is in charge of generating all strings that match a prefix in the given position. As many functions of this kind, each invokation has O(state) time complexity so be careful in using it.

Definition at line 1422 of file res_musiconhold.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_strdup, c, mohclass_unref, mohclass::name, NULL, and mohclass::realtime.

Referenced by handle_cli_moh_unregister_class().

 {
    int which=0;
    struct mohclass *cur;
    char *c = NULL;
    int wordlen = strlen(word);
    struct ao2_iterator i;
 
    if (pos != 3) {
       return NULL;
    }
 
    i = ao2_iterator_init(mohclasses, 0);
    while ((cur = ao2_t_iterator_next(&i, "iterate thru mohclasses"))) {
       if (cur->realtime && !strncasecmp(cur->name, word, wordlen) && ++which > state) {
          c = ast_strdup(cur->name);
          mohclass_unref(cur, "drop ref in iterator loop break");
          break;
       }
       mohclass_unref(cur, "drop ref in iterator loop");
    }
    ao2_iterator_destroy(&i);
 
    return c;
 }

◆ get_mohbydigit()

static struct mohclass* get_mohbydigit ( char digit )

static

Note: This function should be called with the mohclasses list locked

Definition at line 542 of file res_musiconhold.c.

References ao2_t_callback, and moh_digit_match().

Referenced by moh_handle_digit().

 {
    return ao2_t_callback(mohclasses, 0, moh_digit_match, &digit, "digit callback");
 }

◆ handle_cli_moh_reload()

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

static

Definition at line 1951 of file res_musiconhold.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_module_reload(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

 {
    switch (cmd) {
    case CLI_INIT:
       e->command = "moh reload";
       e->usage =
          "Usage: moh reload\n"
          "       Reloads the MusicOnHold module.\n"
          "       Alias for 'module reload res_musiconhold.so'\n";
       return NULL;
    case CLI_GENERATE:
       return NULL;
    }
 
    if (a->argc != e->args)
       return CLI_SHOWUSAGE;
 
    /* The module loader will prevent concurrent reloads from occurring, so we delegate */
    ast_module_reload("res_musiconhold");
 
    return CLI_SUCCESS;
 }

◆ handle_cli_moh_show_classes()

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

static

Definition at line 2012 of file res_musiconhold.c.

References mohclass::announcement, ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_cli_args::argc, mohclass::args, ast_cli_entry::args, ast_cli(), ast_format_get_name(), ast_test_flag, moh_files_state::class, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, mohclass::dir, ast_cli_args::fd, mohclass::format, mohclass::kill_delay, mohclass::kill_method, KILL_METHOD_PROCESS, mohclass::mode, MOH_ANNOUNCEMENT, MOH_CUSTOM, mohclass_unref, mohclass::name, NULL, S_OR, and ast_cli_entry::usage.

 {
    struct mohclass *class;
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
       e->command = "moh show classes";
       e->usage =
          "Usage: moh show classes\n"
          "       Lists all MusicOnHold classes.\n";
       return NULL;
    case CLI_GENERATE:
       return NULL;
    }
 
    if (a->argc != e->args)
       return CLI_SHOWUSAGE;
 
    i = ao2_iterator_init(mohclasses, 0);
    for (; (class = ao2_t_iterator_next(&i, "Show classes iterator")); mohclass_unref(class, "Unref iterator in moh show classes")) {
       ast_cli(a->fd, "Class: %s\n", class->name);
       ast_cli(a->fd, "\tMode: %s\n", S_OR(class->mode, "<none>"));
       ast_cli(a->fd, "\tDirectory: %s\n", S_OR(class->dir, "<none>"));
       if (ast_test_flag(class, MOH_ANNOUNCEMENT)) {
          ast_cli(a->fd, "\tAnnouncement: %s\n", S_OR(class->announcement, "<none>"));
       }
       if (ast_test_flag(class, MOH_CUSTOM)) {
          ast_cli(a->fd, "\tApplication: %s\n", S_OR(class->args, "<none>"));
          ast_cli(a->fd, "\tKill Escalation Delay: %zu ms\n", class->kill_delay / 1000);
          ast_cli(a->fd, "\tKill Method: %s\n",
             class->kill_method == KILL_METHOD_PROCESS ? "process" : "process_group");
       }
       if (strcasecmp(class->mode, "files")) {
          ast_cli(a->fd, "\tFormat: %s\n", ast_format_get_name(class->format));
       }
    }
    ao2_iterator_destroy(&i);
 
    return CLI_SUCCESS;
 }

◆ handle_cli_moh_show_files()

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

static

Definition at line 1974 of file res_musiconhold.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_cli_args::argc, ast_cli_entry::args, ast_cli(), AST_VECTOR_GET, AST_VECTOR_SIZE, moh_files_state::class, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, mohclass::files, mohclass_unref, mohclass::name, NULL, and ast_cli_entry::usage.

 {
    struct mohclass *class;
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
       e->command = "moh show files";
       e->usage =
          "Usage: moh show files\n"
          "       Lists all loaded file-based MusicOnHold classes and their\n"
          "       files.\n";
       return NULL;
    case CLI_GENERATE:
       return NULL;
    }
 
    if (a->argc != e->args)
       return CLI_SHOWUSAGE;
 
    i = ao2_iterator_init(mohclasses, 0);
    for (; (class = ao2_t_iterator_next(&i, "Show files iterator")); mohclass_unref(class, "Unref iterator in moh show files")) {
       int x;
 
       if (!AST_VECTOR_SIZE(&class->files)) {
          continue;
       }
 
       ast_cli(a->fd, "Class: %s\n", class->name);
       for (x = 0; x < AST_VECTOR_SIZE(&class->files); x++) {
          ast_cli(a->fd, "\tFile: %s\n", AST_VECTOR_GET(&class->files, x));
       }
    }
    ao2_iterator_destroy(&i);
 
    return CLI_SUCCESS;
 }

◆ handle_cli_moh_unregister_class()

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

static

Definition at line 1448 of file res_musiconhold.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_mohclass_realtime(), ast_cli_args::fd, len(), ast_cli_args::line, moh_class_destructor(), moh_unregister, mohclass_unref, ast_cli_args::n, mohclass::name, NULL, ast_cli_args::pos, mohclass::realtime, ast_cli_entry::usage, and ast_cli_args::word.

 {
    struct mohclass *cur;
    int len;
    int found = 0;
    struct ao2_iterator i;
 
    switch (cmd) {
       case CLI_INIT:
          e->command = "moh unregister class";
          e->usage =
             "Usage: moh unregister class <class>\n"
             "       Unregisters a realtime moh class.\n";
          return NULL;
       case CLI_GENERATE:
          return complete_mohclass_realtime(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 4)
       return CLI_SHOWUSAGE;
 
    len = strlen(a->argv[3]);
 
    i = ao2_iterator_init(mohclasses, 0);
    while ((cur = ao2_t_iterator_next(&i, "iterate thru mohclasses"))) {
       if (cur->realtime && len == strlen(cur->name) && !strncasecmp(cur->name, a->argv[3], len)) {
          found = 1;
          break;
       }
       mohclass_unref(cur, "drop ref in iterator loop");
    }
    ao2_iterator_destroy(&i);
 
    if (found) {
       moh_unregister(cur);
       mohclass_unref(cur, "drop ref after unregister");
    } else {
       ast_cli(a->fd, "No such realtime moh class '%s'\n", a->argv[3]);
    }
 
    return CLI_SUCCESS;
 }

◆ init_app_class()

static int init_app_class ( struct mohclass * class )

static

Definition at line 1289 of file res_musiconhold.c.

References ast_log, ast_pthread_create_background, ast_set_flag, ast_timer_close(), ast_timer_open(), ast_timer_set_rate(), moh_files_state::class, errno, LOG_WARNING, mohclass::mode, MOH_CUSTOM, MOH_QUIET, MOH_SINGLE, monmp3thread(), NULL, mohclass::thread, and mohclass::timer.

Referenced by _moh_register().

 {
    if (!strcasecmp(class->mode, "custom")) {
       ast_set_flag(class, MOH_CUSTOM);
    } else if (!strcasecmp(class->mode, "mp3nb")) {
       ast_set_flag(class, MOH_SINGLE);
    } else if (!strcasecmp(class->mode, "quietmp3nb")) {
       ast_set_flag(class, MOH_SINGLE | MOH_QUIET);
    } else if (!strcasecmp(class->mode, "quietmp3")) {
       ast_set_flag(class, MOH_QUIET);
    }
 
    class->srcfd = -1;
 
    if (!(class->timer = ast_timer_open())) {
       ast_log(LOG_WARNING, "Unable to create timer: %s\n", strerror(errno));
       return -1;
    }
    if (class->timer && ast_timer_set_rate(class->timer, 25)) {
       ast_log(LOG_WARNING, "Unable to set 40ms frame rate: %s\n", strerror(errno));
       ast_timer_close(class->timer);
       class->timer = NULL;
    }
 
    if (ast_pthread_create_background(&class->thread, NULL, monmp3thread, class)) {
       ast_log(LOG_WARNING, "Unable to create moh thread...\n");
       if (class->timer) {
          ast_timer_close(class->timer);
          class->timer = NULL;
       }
       return -1;
    }
 
    return 0;
 }

◆ init_files_class()

static int init_files_class ( struct mohclass * class )

static

Definition at line 1235 of file res_musiconhold.c.

References ast_verb, moh_files_state::class, mohclass::dir, moh_scan_files(), and mohclass::name.

Referenced by _moh_register().

 {
    int res;
 
    res = moh_scan_files(class);
 
    if (res < 0) {
       return -1;
    }
 
    if (!res) {
       ast_verb(3, "Files not found in %s for moh class:%s\n",
          class->dir, class->name);
       return -1;
    }
 
    return 0;
 }

◆ killer()

static int killer	(	pid_t	pid,
		int	signum,
		enum kill_methods	kill_method
	)

static

Definition at line 710 of file res_musiconhold.c.

References KILL_METHOD_PROCESS, and KILL_METHOD_PROCESS_GROUP.

Referenced by killpid().

 {
    switch (kill_method) {
    case KILL_METHOD_PROCESS_GROUP:
       return killpg(pid, signum);
    case KILL_METHOD_PROCESS:
       return kill(pid, signum);
    }
 
    return -1;
 }

◆ killpid()

static void killpid	(	int	pid,
		size_t	delay,
		enum kill_methods	kill_method
	)

static

Definition at line 722 of file res_musiconhold.c.

References ast_debug, ast_log, errno, KILL_METHOD_PROCESS_GROUP, killer(), and LOG_WARNING.

Referenced by moh_class_destructor(), and monmp3thread().

 {
    if (killer(pid, SIGHUP, kill_method) < 0) {
       if (errno == ESRCH) {
          return;
       }
       ast_log(LOG_WARNING, "Unable to send a SIGHUP to MOH process '%d'?!!: %s\n", pid, strerror(errno));
    } else {
       ast_debug(1, "Sent HUP to pid %d%s\n", pid,
          kill_method == KILL_METHOD_PROCESS_GROUP ? " and all children" : " only");
    }
    usleep(delay);
    if (killer(pid, SIGTERM, kill_method) < 0) {
       if (errno == ESRCH) {
          return;
       }
       ast_log(LOG_WARNING, "Unable to terminate MOH process '%d'?!!: %s\n", pid, strerror(errno));
    } else {
       ast_debug(1, "Sent TERM to pid %d%s\n", pid,
          kill_method == KILL_METHOD_PROCESS_GROUP ? " and all children" : " only");
    }
    usleep(delay);
    if (killer(pid, SIGKILL, kill_method) < 0) {
       if (errno == ESRCH) {
          return;
       }
       ast_log(LOG_WARNING, "Unable to kill MOH process '%d'?!!: %s\n", pid, strerror(errno));
    } else {
       ast_debug(1, "Sent KILL to pid %d%s\n", pid,
          kill_method == KILL_METHOD_PROCESS_GROUP ? " and all children" : " only");
    }
 }

◆ load_module()

static int load_module ( void )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 2087 of file res_musiconhold.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_t_container_alloc_hash, ARRAY_LEN, ast_check_realtime(), ast_cli_register_multiple, ast_install_music_functions(), ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_moh_destroy(), ast_register_application_xml, ast_register_atexit(), load_moh_classes(), local_ast_moh_cleanup(), local_ast_moh_start(), local_ast_moh_stop(), LOG_WARNING, moh_class_cmp(), moh_class_hash(), NULL, play_moh, play_moh_exec(), start_moh, start_moh_exec(), stop_moh, and stop_moh_exec().

Referenced by unload_module().

 {
    int res;
 
    mohclasses = ao2_t_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 53,
       moh_class_hash, NULL, moh_class_cmp, "Moh class container");
    if (!mohclasses) {
       return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!load_moh_classes(0) && ast_check_realtime("musiconhold") == 0) {   /* No music classes configured, so skip it */
       ast_log(LOG_WARNING, "No music on hold classes configured, "
             "disabling music on hold.\n");
    } else {
       ast_install_music_functions(local_ast_moh_start, local_ast_moh_stop,
             local_ast_moh_cleanup);
    }
 
    res = ast_register_application_xml(play_moh, play_moh_exec);
    ast_register_atexit(ast_moh_destroy);
    ast_cli_register_multiple(cli_moh, ARRAY_LEN(cli_moh));
    if (!res)
       res = ast_register_application_xml(start_moh, start_moh_exec);
    if (!res)
       res = ast_register_application_xml(stop_moh, stop_moh_exec);
 
    return AST_MODULE_LOAD_SUCCESS;
 }

◆ load_moh_classes()

static int load_moh_classes ( int reload )

static

Definition at line 1847 of file res_musiconhold.c.

References ao2_t_callback, mohclass::args, ast_category_browse(), ast_check_realtime(), ast_clear_flag, ast_config_destroy(), ast_config_load, ast_copy_string(), AST_FLAGS_ALL, ast_log, ast_set2_flag, ast_strlen_zero, ast_true(), ast_variable_browse(), moh_files_state::class, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, mohclass::dir, HANDLE_REF, LOG_WARNING, mohclass::mode, MOH_CACHERTCLASSES, moh_class_malloc, moh_class_mark(), moh_classes_delete_marked(), moh_parse_options(), MOH_PREFERCHANNELCLASS, MOH_REALTIME, moh_register, moh_rescan_files(), mohclass_unref, ast_variable::name, mohclass::name, ast_variable::next, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, ast_variable::value, and var.

Referenced by load_module(), and reload().

 {
    struct ast_config *cfg;
    struct ast_variable *var;
    struct mohclass *class;
    char *cat;
    int numclasses = 0;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
 
    cfg = ast_config_load("musiconhold.conf", config_flags);
 
    if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
       if (ast_check_realtime("musiconhold") && reload) {
          ao2_t_callback(mohclasses, OBJ_NODATA | MOH_REALTIME, moh_class_mark, NULL, "Mark realtime classes for deletion");
          ao2_t_callback(mohclasses, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, moh_classes_delete_marked, NULL, "Purge marked classes");
       }
       moh_rescan_files();
       return 0;
    }
 
    if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
       if (ast_check_realtime("musiconhold") && reload) {
          ao2_t_callback(mohclasses, OBJ_NODATA, moh_class_mark, NULL, "Mark deleted classes");
          ao2_t_callback(mohclasses, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, moh_classes_delete_marked, NULL, "Purge marked classes");
       }
       return 0;
    }
 
    if (reload) {
       ao2_t_callback(mohclasses, OBJ_NODATA, moh_class_mark, NULL, "Mark deleted classes");
    }
 
    ast_clear_flag(global_flags, AST_FLAGS_ALL);
    ast_set2_flag(global_flags, 1, MOH_PREFERCHANNELCLASS);
 
    cat = ast_category_browse(cfg, NULL);
    for (; cat; cat = ast_category_browse(cfg, cat)) {
       /* Setup common options from [general] section */
       if (!strcasecmp(cat, "general")) {
          for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
             if (!strcasecmp(var->name, "cachertclasses")) {
                ast_set2_flag(global_flags, ast_true(var->value), MOH_CACHERTCLASSES);
             } else if (!strcasecmp(var->name, "preferchannelclass")) {
                ast_set2_flag(global_flags, ast_true(var->value), MOH_PREFERCHANNELCLASS);
             } else {
                ast_log(LOG_WARNING, "Unknown option '%s' in [general] section of musiconhold.conf\n", var->name);
             }
          }
          continue;
       }
 
       if (!(class = moh_class_malloc())) {
          break;
       }
 
       moh_parse_options(ast_variable_browse(cfg, cat), class);
       /* For compatibility with the past, we overwrite any name=name
        * with the context [name]. */
       ast_copy_string(class->name, cat, sizeof(class->name));
 
       if (ast_strlen_zero(class->dir)) {
          if (!strcasecmp(class->mode, "custom") || !strcasecmp(class->mode, "playlist")) {
             strcpy(class->dir, "nodir");
          } else {
             ast_log(LOG_WARNING, "A directory must be specified for class '%s'!\n", class->name);
             class = mohclass_unref(class, "unreffing potential mohclass (no directory)");
             continue;
          }
       }
       if (ast_strlen_zero(class->mode)) {
          ast_log(LOG_WARNING, "A mode must be specified for class '%s'!\n", class->name);
          class = mohclass_unref(class, "unreffing potential mohclass (no mode)");
          continue;
       }
       if (ast_strlen_zero(class->args) && !strcasecmp(class->mode, "custom")) {
          ast_log(LOG_WARNING, "An application must be specified for class '%s'!\n", class->name);
          class = mohclass_unref(class, "unreffing potential mohclass (no app for custom mode)");
          continue;
       }
 
       /* Don't leak a class when it's already registered */
       if (!moh_register(class, reload, HANDLE_REF)) {
          numclasses++;
       }
    }
 
    ast_config_destroy(cfg);
 
    ao2_t_callback(mohclasses, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
          moh_classes_delete_marked, NULL, "Purge marked classes");
 
    return numclasses;
 }

◆ load_realtime_musiconhold()

static struct ast_variable* load_realtime_musiconhold ( const char * name )

static

Definition at line 1513 of file res_musiconhold.c.

References ast_load_realtime(), ast_log, ast_strings_equal(), ast_variable_find_in_list(), ast_variable_list_append, ast_variable_new, ast_variables_destroy(), LOG_WARNING, ast_variable::name, ast_variable::next, NULL, SENTINEL, ast_variable::value, and var.

Referenced by local_ast_moh_start().

 {
    struct ast_variable *var = ast_load_realtime("musiconhold", "name", name, SENTINEL);
 
    if (var) {
       const char *mode = ast_variable_find_in_list(var, "mode");
       if (ast_strings_equal(mode, "playlist")) {
          struct ast_variable *entries = ast_load_realtime("musiconhold_entry", "name", name, SENTINEL);
          struct ast_variable *cur = entries;
          size_t entry_count = 0;
          for (; cur; cur = cur->next) {
             if (!strcmp(cur->name, "entry")) {
                struct ast_variable *dup = ast_variable_new(cur->name, cur->value, "");
                if (dup) {
                   entry_count++;
                   ast_variable_list_append(&var, dup);
                }
             }
          }
          ast_variables_destroy(entries);
 
          if (entry_count == 0) {
             /* Behave as though this class doesn't exist */
             ast_variables_destroy(var);
             var = NULL;
          }
       }
    }
 
    if (!var) {
       ast_log(LOG_WARNING,
          "Music on Hold class '%s' not found in memory/database. "
          "Verify your configuration.\n",
          name);
    }
    return var;
 }

◆ local_ast_moh_cleanup()

static void local_ast_moh_cleanup ( struct ast_channel * chan )

static

Definition at line 1397 of file res_musiconhold.c.

References ao2_cleanup, ast_channel_music_state(), ast_channel_music_state_set(), ast_free, ast_log, ast_module_unref, moh_files_state::class, LOG_WARNING, mohclass_unref, moh_files_state::mohwfmt, NULL, moh_files_state::origwfmt, and ast_module_info::self.

Referenced by load_module(), and reload().

 {
    struct moh_files_state *state = ast_channel_music_state(chan);
 
    if (state) {
       ast_channel_music_state_set(chan, NULL);
       if (state->class) {
          /* This should never happen.  We likely just leaked some resource. */
          state->class =
             mohclass_unref(state->class, "Uh Oh. Cleaning up MOH with an active class");
          ast_log(LOG_WARNING, "Uh Oh. Cleaning up MOH with an active class\n");
       }
       ao2_cleanup(state->origwfmt);
       ao2_cleanup(state->mohwfmt);
       ast_free(state);
       /* Only held a module reference if we had a music state */
       ast_module_unref(ast_module_info->self);
    }
 }

◆ local_ast_moh_start()

static int local_ast_moh_start	(	struct ast_channel *	chan,
		const char *	mclass,
		const char *	interpclass
	)

static

Definition at line 1551 of file res_musiconhold.c.

References mohclass::args, ARRAY_LEN, ast_activate_generator(), ast_channel_flags(), ast_channel_lock, ast_channel_music_state(), ast_channel_musicclass(), ast_channel_unlock, ast_check_realtime(), AST_FLAG_MOH, ast_log, ast_pthread_create_background, ast_set_flag, ast_strlen_zero, ast_test_flag, ast_timer_close(), ast_timer_open(), ast_timer_set_rate(), ast_variables_destroy(), AST_VECTOR_SIZE, moh_files_state::class, mohclass::dir, DONT_UNREF, errno, mohclass::files, get_mohbyname, load_realtime_musiconhold(), LOG_NOTICE, LOG_WARNING, mohclass::mode, MOH_CACHERTCLASSES, moh_class_malloc, MOH_CUSTOM, moh_parse_options(), MOH_PREFERCHANNELCLASS, MOH_QUIET, MOH_RANDOMIZE, moh_register, moh_scan_files(), MOH_SINGLE, mohclass_ref, mohclass_unref, monmp3thread(), mohclass::name, NULL, mohclass::realtime, respawn_time, mohclass::srcfd, mohclass::start, mohclass::thread, mohclass::timer, and var.

Referenced by load_module(), and reload().

 {
    struct mohclass *mohclass = NULL;
    struct moh_files_state *state = ast_channel_music_state(chan);
    struct ast_variable *var = NULL;
    int res = 0;
    int i;
    int realtime_possible = ast_check_realtime("musiconhold");
    int warn_if_not_in_memory = !realtime_possible;
    const char *classes[] = {NULL, NULL, interpclass, "default"};
 
    if (ast_test_flag(global_flags, MOH_PREFERCHANNELCLASS)) {
       classes[0] = ast_channel_musicclass(chan);
       classes[1] = mclass;
    } else {
       classes[0] = mclass;
       classes[1] = ast_channel_musicclass(chan);
    }
 
    /* The following is the order of preference for which class to use:
     * 1) The channels explicitly set musicclass, which should *only* be
     *    set by a call to Set(CHANNEL(musicclass)=whatever) in the dialplan.
     *    Unless preferchannelclass in musiconhold.conf is false
     * 2) The mclass argument. If a channel is calling ast_moh_start() as the
     *    result of receiving a HOLD control frame, this should be the
     *    payload that came with the frame.
     * 3) The channels explicitly set musicclass, which should *only* be
     *    set by a call to Set(CHANNEL(musicclass)=whatever) in the dialplan.
     * 4) The interpclass argument. This would be from the mohinterpret
     *    option from channel drivers. This is the same as the old musicclass
     *    option.
     * 5) The default class.
     */
 
    for (i = 0; i < ARRAY_LEN(classes); ++i) {
       if (!ast_strlen_zero(classes[i])) {
          mohclass = get_mohbyname(classes[i], warn_if_not_in_memory, 0);
          if (!mohclass && realtime_possible) {
             var = load_realtime_musiconhold(classes[i]);
          }
          if (mohclass || var) {
             break;
          }
       }
    }
 
    /* If no moh class found in memory, then check RT. Note that the logic used
     * above guarantees that if var is non-NULL, then mohclass must be NULL.
     */
    if (var) {
       if ((mohclass = moh_class_malloc())) {
          mohclass->realtime = 1;
 
          moh_parse_options(var, mohclass);
          ast_variables_destroy(var);
 
          if (ast_strlen_zero(mohclass->dir)) {
             if (!strcasecmp(mohclass->mode, "custom") || !strcasecmp(mohclass->mode, "playlist")) {
                strcpy(mohclass->dir, "nodir");
             } else {
                ast_log(LOG_WARNING, "A directory must be specified for class '%s'!\n", mohclass->name);
                mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (no directory specified)");
                return -1;
             }
          }
          if (ast_strlen_zero(mohclass->mode)) {
             ast_log(LOG_WARNING, "A mode must be specified for class '%s'!\n", mohclass->name);
             mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (no mode specified)");
             return -1;
          }
          if (ast_strlen_zero(mohclass->args) && !strcasecmp(mohclass->mode, "custom")) {
             ast_log(LOG_WARNING, "An application must be specified for class '%s'!\n", mohclass->name);
             mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (no app specified for custom mode");
             return -1;
          }
 
          if (ast_test_flag(global_flags, MOH_CACHERTCLASSES)) {
             /* CACHERTCLASSES enabled, let's add this class to default tree */
             if (state && state->class) {
                /* Class already exist for this channel */
                ast_log(LOG_NOTICE, "This channel already has a MOH class attached (%s)!\n", state->class->name);
             }
             /* We don't want moh_register to unref the mohclass because we do it at the end of this function as well.
              * If we allowed moh_register to unref the mohclass,too, then the count would be off by one. The result would
              * be that the destructor would be called when the generator on the channel is deactivated. The container then
              * has a pointer to a freed mohclass, so any operations involving the mohclass container would result in reading
              * invalid memory.
              */
             if (moh_register(mohclass, 0, DONT_UNREF) == -1) {
                mohclass = mohclass_unref(mohclass, "unreffing mohclass failed to register");
                return -1;
             }
          } else {
             /* We don't register RT moh class, so let's init it manualy */
 
             time(&mohclass->start);
             mohclass->start -= respawn_time;
 
             if (!strcasecmp(mohclass->mode, "files")) {
                if (!moh_scan_files(mohclass)) {
                   mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (moh_scan_files failed)");
                   return -1;
                }
                if (strchr(mohclass->args, 'r')) {
                   static int deprecation_warning = 0;
                   if (!deprecation_warning) {
                      ast_log(LOG_WARNING, "Music on hold 'application=r' setting is deprecated in 14.  Please use 'sort=random' instead.\n");
                      deprecation_warning = 1;
                   }
                   ast_set_flag(mohclass, MOH_RANDOMIZE);
                }
             } else if (!strcasecmp(mohclass->mode, "playlist")) {
                if (!AST_VECTOR_SIZE(&mohclass->files)) {
                   mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (no playlist entries)");
                   return -1;
                }
             } else if (!strcasecmp(mohclass->mode, "mp3") || !strcasecmp(mohclass->mode, "mp3nb") || !strcasecmp(mohclass->mode, "quietmp3") || !strcasecmp(mohclass->mode, "quietmp3nb") || !strcasecmp(mohclass->mode, "httpmp3") || !strcasecmp(mohclass->mode, "custom")) {
 
                if (!strcasecmp(mohclass->mode, "custom"))
                   ast_set_flag(mohclass, MOH_CUSTOM);
                else if (!strcasecmp(mohclass->mode, "mp3nb"))
                   ast_set_flag(mohclass, MOH_SINGLE);
                else if (!strcasecmp(mohclass->mode, "quietmp3nb"))
                   ast_set_flag(mohclass, MOH_SINGLE | MOH_QUIET);
                else if (!strcasecmp(mohclass->mode, "quietmp3"))
                   ast_set_flag(mohclass, MOH_QUIET);
 
                mohclass->srcfd = -1;
                if (!(mohclass->timer = ast_timer_open())) {
                   ast_log(LOG_WARNING, "Unable to create timer: %s\n", strerror(errno));
                }
                if (mohclass->timer && ast_timer_set_rate(mohclass->timer, 25)) {
                   ast_log(LOG_WARNING, "Unable to set 40ms frame rate: %s\n", strerror(errno));
                   ast_timer_close(mohclass->timer);
                   mohclass->timer = NULL;
                }
 
                /* Let's check if this channel already had a moh class before */
                if (state && state->class) {
                   /* Class already exist for this channel */
                   ast_log(LOG_NOTICE, "This channel already has a MOH class attached (%s)!\n", state->class->name);
                   if (state->class->realtime && !ast_test_flag(global_flags, MOH_CACHERTCLASSES) && !strcasecmp(mohclass->name, state->class->name)) {
                      /* we found RT class with the same name, seems like we should continue playing existing one */
                      mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (channel already has one)");
                      mohclass = mohclass_ref(state->class, "using existing class from state");
                   }
                } else {
                   if (ast_pthread_create_background(&mohclass->thread, NULL, monmp3thread, mohclass)) {
                      ast_log(LOG_WARNING, "Unable to create moh...\n");
                      if (mohclass->timer) {
                         ast_timer_close(mohclass->timer);
                         mohclass->timer = NULL;
                      }
                      mohclass = mohclass_unref(mohclass, "Unreffing potential mohclass (failed to create background thread)");
                      return -1;
                   }
                }
             } else {
                ast_log(LOG_WARNING, "Don't know how to do a mode '%s' music on hold\n", mohclass->mode);
                mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (unknown mode)");
                return -1;
             }
          }
       } else {
          ast_variables_destroy(var);
          var = NULL;
       }
    }
 
    if (!mohclass) {
       return -1;
    }
 
    /* If we are using a cached realtime class with files, re-scan the files */
    if (!var && ast_test_flag(global_flags, MOH_CACHERTCLASSES) && mohclass->realtime && !strcasecmp(mohclass->mode, "files")) {
       if (!moh_scan_files(mohclass)) {
          mohclass = mohclass_unref(mohclass, "unreffing potential mohclass (moh_scan_files failed)");
          return -1;
       }
    }
 
    if (!state || !state->class || strcmp(mohclass->name, state->class->name)) {
       if (AST_VECTOR_SIZE(&mohclass->files)) {
          res = ast_activate_generator(chan, &moh_file_stream, mohclass);
       } else {
          res = ast_activate_generator(chan, &mohgen, mohclass);
       }
    }
    if (!res) {
       ast_channel_lock(chan);
       ast_channel_latest_musicclass_set(chan, mohclass->name);
       ast_set_flag(ast_channel_flags(chan), AST_FLAG_MOH);
       ast_channel_unlock(chan);
    }
 
    mohclass = mohclass_unref(mohclass, "unreffing local reference to mohclass in local_ast_moh_start");
 
    return res;
 }

◆ local_ast_moh_stop()

static void local_ast_moh_stop ( struct ast_channel * chan )

static

Definition at line 1751 of file res_musiconhold.c.

References ast_channel_flags(), ast_channel_lock, ast_channel_music_state(), ast_channel_stream(), ast_channel_stream_set(), ast_channel_unlock, ast_clear_flag, ast_closestream(), ast_deactivate_generator(), AST_FLAG_MOH, and NULL.

Referenced by load_module(), and reload().

 {
    ast_deactivate_generator(chan);
 
    ast_channel_lock(chan);
    ast_clear_flag(ast_channel_flags(chan), AST_FLAG_MOH);
    if (ast_channel_music_state(chan)) {
       if (ast_channel_stream(chan)) {
          ast_closestream(ast_channel_stream(chan));
          ast_channel_stream_set(chan, NULL);
       }
    }
    ast_channel_unlock(chan);
 }

◆ moh_alloc()

static void* moh_alloc	(	struct ast_channel *	chan,
		void *	params
	)

static

Definition at line 1003 of file res_musiconhold.c.

References ao2_bump, ao2_cleanup, ast_calloc, ast_channel_music_state(), ast_channel_music_state_set(), ast_channel_name(), ast_channel_writeformat(), ast_format_get_name(), ast_log, ast_module_ref, ast_set_write_format(), moh_files_state::class, mohclass::format, LOG_WARNING, moh_post_start(), moh_release(), mohalloc(), mohclass_ref, mohclass_unref, moh_files_state::mohwfmt, mohclass::name, NULL, moh_files_state::origwfmt, mohdata::origwfmt, ast_module_info::self, and state.

 {
    struct mohdata *res;
    struct mohclass *class = params;
    struct moh_files_state *state;
 
    /* Initiating music_state for current channel. Channel should know name of moh class */
    state = ast_channel_music_state(chan);
    if (!state && (state = ast_calloc(1, sizeof(*state)))) {
       ast_channel_music_state_set(chan, state);
       ast_module_ref(ast_module_info->self);
    } else {
       if (!state) {
          return NULL;
       }
       if (state->class) {
          mohclass_unref(state->class, "Uh Oh. Restarting MOH with an active class");
          ast_log(LOG_WARNING, "Uh Oh. Restarting MOH with an active class\n");
       }
       ao2_cleanup(state->origwfmt);
       ao2_cleanup(state->mohwfmt);
       memset(state, 0, sizeof(*state));
    }
 
    if ((res = mohalloc(class))) {
       res->origwfmt = ao2_bump(ast_channel_writeformat(chan));
       if (ast_set_write_format(chan, class->format)) {
          ast_log(LOG_WARNING, "Unable to set channel '%s' to format '%s'\n", ast_channel_name(chan),
             ast_format_get_name(class->format));
          moh_release(NULL, res);
          res = NULL;
       } else {
          state->class = mohclass_ref(class, "Placing reference into state container");
          moh_post_start(chan, class->name);
       }
    }
    return res;
 }

◆ moh_class_cmp()

static int moh_class_cmp	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 2068 of file res_musiconhold.c.

References moh_files_state::class, CMP_MATCH, CMP_STOP, mohclass::delete, MOH_NOTDELETED, and mohclass::name.

Referenced by load_module().

 {
    struct mohclass *class = obj, *class2 = arg;
 
    return strcasecmp(class->name, class2->name) ? 0 :
       (flags & MOH_NOTDELETED) && (class->delete || class2->delete) ? 0 :
       CMP_MATCH | CMP_STOP;
 }

◆ moh_class_destructor()

static void moh_class_destructor ( void * obj )

static

Definition at line 1766 of file res_musiconhold.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_debug, ast_free, AST_LIST_REMOVE_HEAD, AST_PTHREADT_NULL, ast_timer_close(), AST_VECTOR_FREE, AST_VECTOR_RESET, ast_wait_for_input(), buff, moh_files_state::class, mohclass::files, mohclass::format, mohclass::kill_delay, mohclass::kill_method, killpid(), mohdata::list, mohclass::members, mohclass::name, NULL, mohclass::pid, mohclass::srcfd, mohclass::thread, and mohclass::timer.

Referenced by _moh_class_malloc(), and handle_cli_moh_unregister_class().

 {
    struct mohclass *class = obj;
    struct mohdata *member;
    pthread_t tid = 0;
 
    ast_debug(1, "Destroying MOH class '%s'\n", class->name);
 
    ao2_lock(class);
    while ((member = AST_LIST_REMOVE_HEAD(&class->members, list))) {
       ast_free(member);
    }
    ao2_unlock(class);
 
    /* Kill the thread first, so it cannot restart the child process while the
     * class is being destroyed */
    if (class->thread != AST_PTHREADT_NULL && class->thread != 0) {
       tid = class->thread;
       class->thread = AST_PTHREADT_NULL;
       pthread_cancel(tid);
       /* We'll collect the exit status later, after we ensure all the readers
        * are dead. */
    }
 
    if (class->pid > 1) {
       char buff[8192];
       int bytes, tbytes = 0, stime = 0;
 
       ast_debug(1, "killing %d!\n", class->pid);
 
       stime = time(NULL) + 2;
       killpid(class->pid, class->kill_delay, class->kill_method);
 
       while ((ast_wait_for_input(class->srcfd, 100) > 0) &&
             (bytes = read(class->srcfd, buff, 8192)) && time(NULL) < stime) {
          tbytes = tbytes + bytes;
       }
 
       ast_debug(1, "mpg123 pid %d and child died after %d bytes read\n",
          class->pid, tbytes);
 
       class->pid = 0;
       close(class->srcfd);
       class->srcfd = -1;
    }
 
    AST_VECTOR_RESET(&class->files, ast_free);
    AST_VECTOR_FREE(&class->files);
 
    if (class->timer) {
       ast_timer_close(class->timer);
       class->timer = NULL;
    }
 
    ao2_cleanup(class->format);
 
    /* Finally, collect the exit status of the monitor thread */
    if (tid > 0) {
       pthread_join(tid, NULL);
    }
 
 }

◆ moh_class_hash()

static int moh_class_hash	(	const void *	obj,
		const int	flags
	)

static

Definition at line 2061 of file res_musiconhold.c.

References ast_str_case_hash(), moh_files_state::class, and mohclass::name.

Referenced by load_module().

 {
    const struct mohclass *class = obj;
 
    return ast_str_case_hash(class->name);
 }

◆ moh_class_inuse()

static int moh_class_inuse	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 2126 of file res_musiconhold.c.

References AST_LIST_EMPTY, moh_files_state::class, CMP_MATCH, CMP_STOP, and mohclass::members.

Referenced by unload_module().

 {
    struct mohclass *class = obj;
 
    return AST_LIST_EMPTY(&class->members) ? 0 : CMP_MATCH | CMP_STOP;
 }

◆ moh_class_mark()

static int moh_class_mark	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 1829 of file res_musiconhold.c.

References moh_files_state::class, mohclass::delete, MOH_REALTIME, and mohclass::realtime.

Referenced by load_moh_classes().

 {
    struct mohclass *class = obj;
 
    if ( ((flags & MOH_REALTIME) && class->realtime) || !(flags & MOH_REALTIME) ) {
       class->delete = 1;
    }
 
    return 0;
 }

◆ moh_classes_delete_marked()

static int moh_classes_delete_marked	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 1840 of file res_musiconhold.c.

References CMP_MATCH, and mohclass::delete.

Referenced by load_moh_classes().

 {
    struct mohclass *class = obj;
 
    return class->delete ? CMP_MATCH : 0;
 }

◆ moh_diff()

static int moh_diff	(	struct mohclass *	old,
		struct mohclass *	new
	)

static

Definition at line 1270 of file res_musiconhold.c.

References mohclass::args, mohclass::dir, mohclass::flags, and mohclass::mode.

Referenced by _moh_register().

 {
    if (!old || !new) {
       return -1;
    }
 
    if (strcmp(old->dir, new->dir)) {
       return -1;
    } else if (strcmp(old->mode, new->mode)) {
       return -1;
    } else if (strcmp(old->args, new->args)) {
       return -1;
    } else if (old->flags != new->flags) {
       return -1;
    }
 
    return 0;
 }

◆ moh_digit_match()

static int moh_digit_match	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 533 of file res_musiconhold.c.

References moh_files_state::class, CMP_MATCH, CMP_STOP, digit, and mohclass::digit.

Referenced by get_mohbydigit().

 {
    char *digit = arg;
    struct mohclass *class = obj;
 
    return (*digit == class->digit) ? CMP_MATCH | CMP_STOP : 0;
 }

◆ moh_files_alloc()

static void* moh_files_alloc	(	struct ast_channel *	chan,
		void *	params
	)

static

Definition at line 487 of file res_musiconhold.c.

References ao2_cleanup, ao2_replace, ast_calloc, ast_channel_music_state(), ast_channel_music_state_set(), ast_channel_writeformat(), ast_copy_string(), ast_log, ast_module_ref, ast_random(), ast_test_flag, AST_VECTOR_SIZE, moh_files_state::class, mohclass::files, LOG_WARNING, moh_post_start(), MOH_RANDOMIZE, mohclass_ref, mohclass_unref, moh_files_state::mohwfmt, moh_files_state::name, mohclass::name, NULL, moh_files_state::origwfmt, moh_files_state::pos, moh_files_state::save_total, ast_module_info::self, and state.

 {
    struct moh_files_state *state;
    struct mohclass *class = params;
    size_t file_count;
 
    state = ast_channel_music_state(chan);
    if (!state && (state = ast_calloc(1, sizeof(*state)))) {
       ast_channel_music_state_set(chan, state);
       ast_module_ref(ast_module_info->self);
    } else {
       if (!state) {
          return NULL;
       }
       if (state->class) {
          mohclass_unref(state->class, "Uh Oh. Restarting MOH with an active class");
          ast_log(LOG_WARNING, "Uh Oh. Restarting MOH with an active class\n");
       }
    }
 
    file_count = AST_VECTOR_SIZE(&class->files);
 
    /* Resume MOH from where we left off last time or start from scratch? */
    if (state->save_total != file_count || strcmp(state->name, class->name) != 0) {
       /* Start MOH from scratch. */
       ao2_cleanup(state->origwfmt);
       ao2_cleanup(state->mohwfmt);
       memset(state, 0, sizeof(*state));
       if (ast_test_flag(class, MOH_RANDOMIZE) && file_count) {
          state->pos = ast_random() % file_count;
       }
    }
 
    state->class = mohclass_ref(class, "Reffing music class for channel");
    /* it's possible state is not a new allocation, don't leak old refs */
    ao2_replace(state->origwfmt, ast_channel_writeformat(chan));
    ao2_replace(state->mohwfmt, ast_channel_writeformat(chan));
    /* For comparison on restart of MOH (see above) */
    ast_copy_string(state->name, class->name, sizeof(state->name));
    state->save_total = file_count;
 
    moh_post_start(chan, class->name);
 
    return state;
 }

◆ moh_files_generator()

static int moh_files_generator	(	struct ast_channel *	chan,
		void *	data,
		int	len,
		int	samples
	)

static

Definition at line 449 of file res_musiconhold.c.

References ao2_replace, ast_channel_lock, ast_channel_music_state(), ast_channel_name(), ast_channel_unlock, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_frfree, ast_log, ast_write(), errno, ast_frame_subclass::format, LOG_WARNING, moh_files_readframe(), moh_files_state::mohwfmt, NULL, moh_files_state::sample_queue, moh_files_state::samples, ast_frame::samples, and ast_frame::subclass.

 {
    struct moh_files_state *state = ast_channel_music_state(chan);
    struct ast_frame *f = NULL;
    int res = 0;
 
    state->sample_queue += samples;
 
    while (state->sample_queue > 0) {
       ast_channel_lock(chan);
       f = moh_files_readframe(chan);
 
       /* We need to be sure that we unlock
        * the channel prior to calling
        * ast_write. Otherwise, the recursive locking
        * that occurs can cause deadlocks when using
        * indirect channels, like local channels
        */
       ast_channel_unlock(chan);
       if (!f) {
          return -1;
       }
 
       state->samples += f->samples;
       state->sample_queue -= f->samples;
       if (ast_format_cmp(f->subclass.format, state->mohwfmt) == AST_FORMAT_CMP_NOT_EQUAL) {
          ao2_replace(state->mohwfmt, f->subclass.format);
       }
       res = ast_write(chan, f);
       ast_frfree(f);
       if (res < 0) {
          ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", ast_channel_name(chan), strerror(errno));
          return -1;
       }
    }
    return res;
 }

◆ moh_files_readframe()

static struct ast_frame* moh_files_readframe ( struct ast_channel * chan )

static

Definition at line 401 of file res_musiconhold.c.

References ast_channel_stream(), ast_moh_files_next(), and ast_readframe().

Referenced by moh_files_generator().

 {
    struct ast_frame *f;
 
    f = ast_readframe(ast_channel_stream(chan));
    if (!f) {
       /* Either there was no file stream setup or we reached EOF. */
       if (!ast_moh_files_next(chan)) {
          /*
           * Either we resetup the previously saved file stream position
           * or we started a new file stream.
           */
          f = ast_readframe(ast_channel_stream(chan));
          if (!f) {
             /*
              * We can get here if we were very unlucky because the
              * resetup file stream was saved at EOF when MOH was
              * previously stopped.
              */
             if (!ast_moh_files_next(chan)) {
                f = ast_readframe(ast_channel_stream(chan));
             }
          }
       }
    }
 
    return f;
 }

◆ moh_files_release()

static void moh_files_release	(	struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 281 of file res_musiconhold.c.

References moh_files_state::announcement, ao2_cleanup, ao2_ref, ast_channel_music_state(), ast_channel_name(), ast_channel_stream(), ast_channel_stream_set(), ast_closestream(), ast_format_get_name(), ast_log, ast_set_write_format(), moh_files_state::class, LOG_WARNING, moh_post_stop(), mohclass_unref, moh_files_state::mohwfmt, NULL, moh_files_state::origwfmt, moh_files_state::pos, moh_files_state::save_pos, and state.

 {
    struct moh_files_state *state;
 
    if (!chan || !ast_channel_music_state(chan)) {
       return;
    }
 
    state = ast_channel_music_state(chan);
 
    if (ast_channel_stream(chan)) {
       ast_closestream(ast_channel_stream(chan));
       ast_channel_stream_set(chan, NULL);
    }
 
    moh_post_stop(chan);
 
    ao2_ref(state->mohwfmt, -1);
    state->mohwfmt = NULL; /* make sure to clear this format before restoring the original format */
    if (state->origwfmt && ast_set_write_format(chan, state->origwfmt)) {
       ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%s'\n", ast_channel_name(chan),
          ast_format_get_name(state->origwfmt));
    }
    ao2_cleanup(state->origwfmt);
    state->origwfmt = NULL;
 
    state->save_pos = state->pos;
    state->announcement = 0;
 
    state->class = mohclass_unref(state->class, "Unreffing channel's music class upon deactivation of generator");
 }

◆ moh_files_write_format_change()

static void moh_files_write_format_change	(	struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 430 of file res_musiconhold.c.

References ao2_bump, ao2_replace, ast_channel_music_state(), ast_channel_writeformat(), ast_set_write_format(), moh_files_state::mohwfmt, NULL, moh_files_state::origwfmt, and tmp().

 {
    struct moh_files_state *state = ast_channel_music_state(chan);
 
    /* In order to prevent a recursive call to this function as a result
     * of setting the moh write format back on the channel. Clear
     * the moh write format before setting the write format on the channel.*/
    if (state->origwfmt) {
       struct ast_format *tmp;
 
       tmp = ao2_bump(ast_channel_writeformat(chan));
       ao2_replace(state->origwfmt, NULL);
       if (state->mohwfmt) {
          ast_set_write_format(chan, state->mohwfmt);
       }
       state->origwfmt = tmp;
    }
 }

◆ moh_generate()

static int moh_generate	(	struct ast_channel *	chan,
		void *	data,
		int	len,
		int	samples
	)

static

Definition at line 1042 of file res_musiconhold.c.

References ast_channel_name(), ast_codec_samples_count(), ast_format_determine_length(), AST_FRIENDLY_OFFSET, ast_log, ast_write(), buf, ast_frame::data, ast_frame::datalen, errno, mohdata::f, mohclass::format, LOG_WARNING, mohdata::parent, mohdata::pipe, ast_frame::ptr, and ast_frame::samples.

 {
    struct mohdata *moh = data;
    short buf[1280 + AST_FRIENDLY_OFFSET / 2];
    int res;
 
    len = ast_format_determine_length(moh->parent->format, samples);
 
    if (len > sizeof(buf) - AST_FRIENDLY_OFFSET) {
       ast_log(LOG_WARNING, "Only doing %d of %d requested bytes on %s\n", (int)sizeof(buf), len, ast_channel_name(chan));
       len = sizeof(buf) - AST_FRIENDLY_OFFSET;
    }
    res = read(moh->pipe[0], buf + AST_FRIENDLY_OFFSET/2, len);
    if (res <= 0)
       return 0;
 
    moh->f.datalen = res;
    moh->f.data.ptr = buf + AST_FRIENDLY_OFFSET / 2;
    moh->f.samples = ast_codec_samples_count(&moh->f);
 
    if (ast_write(chan, &moh->f) < 0) {
       ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", ast_channel_name(chan), strerror(errno));
       return -1;
    }
 
    return 0;
 }

◆ moh_handle_digit()

static void moh_handle_digit	(	struct ast_channel *	chan,
		char	digit
	)

static

Definition at line 547 of file res_musiconhold.c.

References ast_moh_start(), ast_moh_stop(), ast_strdupa, moh_files_state::class, get_mohbydigit(), mohclass_unref, mohclass::name, and NULL.

 {
    struct mohclass *class;
    const char *classname = NULL;
 
    if ((class = get_mohbydigit(digit))) {
       classname = ast_strdupa(class->name);
       class = mohclass_unref(class, "Unreffing ao2_find from finding by digit");
       ast_channel_musicclass_set(chan, classname);
       ast_moh_stop(chan);
       ast_moh_start(chan, classname, NULL);
    }
 }

◆ moh_parse_options()

static void moh_parse_options	(	struct ast_variable *	var,
		struct mohclass *	mohclass
	)

static

Definition at line 1077 of file res_musiconhold.c.

References mohclass::announcement, ao2_bump, ao2_cleanup, mohclass::args, ast_begins_with(), ast_copy_string(), ast_format_cache_get, ast_format_slin, ast_log, ast_set2_flag, ast_set_flag, ast_strdup, ast_strlen_zero, ast_true(), AST_VECTOR_APPEND, AST_VECTOR_COMPACT, mohclass::digit, mohclass::dir, mohclass::files, mohclass::format, mohclass::kill_delay, mohclass::kill_method, KILL_METHOD_PROCESS, KILL_METHOD_PROCESS_GROUP, LOG_ERROR, LOG_WARNING, mohclass::mode, MOH_ANNOUNCEMENT, MOH_RANDOMIZE, MOH_RANDSTART, MOH_SORTALPHA, ast_variable::name, mohclass::name, ast_variable::next, ast_variable::value, and var.

Referenced by load_moh_classes(), and local_ast_moh_start().

 {
    for (; var; var = var->next) {
       if (!strcasecmp(var->name, "name")) {
          ast_copy_string(mohclass->name, var->value, sizeof(mohclass->name));
       } else if (!strcasecmp(var->name, "mode")) {
          ast_copy_string(mohclass->mode, var->value, sizeof(mohclass->mode));
       } else if (!strcasecmp(var->name, "entry")) {
          if (ast_begins_with(var->value, "/") || ast_begins_with(var->value, "http://") || ast_begins_with(var->value, "https://")) {
             char *dup = ast_strdup(var->value);
             if (!dup) {
                continue;
             }
 
             if (ast_begins_with(dup, "/")) {
                char *last_pos_dot = strrchr(dup, '.');
                char *last_pos_slash = strrchr(dup, '/');
                if (last_pos_dot && last_pos_dot > last_pos_slash) {
                   ast_log(LOG_WARNING, "The playlist entry '%s' may include an extension, which could prevent it from playing.\n",
                      dup);
                }
             }
             AST_VECTOR_APPEND(&mohclass->files, dup);
          } else {
             ast_log(LOG_ERROR, "Playlist entries must be a URL or absolute path, '%s' provided.\n", var->value);
          }
       } else if (!strcasecmp(var->name, "directory")) {
          ast_copy_string(mohclass->dir, var->value, sizeof(mohclass->dir));
       } else if (!strcasecmp(var->name, "application")) {
          ast_copy_string(mohclass->args, var->value, sizeof(mohclass->args));
       } else if (!strcasecmp(var->name, "announcement")) {
          ast_copy_string(mohclass->announcement, var->value, sizeof(mohclass->announcement));
          ast_set_flag(mohclass, MOH_ANNOUNCEMENT);
       } else if (!strcasecmp(var->name, "digit") && (isdigit(*var->value) || strchr("*#", *var->value))) {
          mohclass->digit = *var->value;
       } else if (!strcasecmp(var->name, "random")) {
          static int deprecation_warning = 0;
          if (!deprecation_warning) {
             ast_log(LOG_WARNING, "Music on hold 'random' setting is deprecated in 14.  Please use 'sort=random' instead.\n");
             deprecation_warning = 1;
          }
          ast_set2_flag(mohclass, ast_true(var->value), MOH_RANDOMIZE);
       } else if (!strcasecmp(var->name, "sort")) {
          if (!strcasecmp(var->value, "random")) {
             ast_set_flag(mohclass, MOH_RANDOMIZE);
          } else if (!strcasecmp(var->value, "alpha")) {
             ast_set_flag(mohclass, MOH_SORTALPHA);
          } else if (!strcasecmp(var->value, "randstart")) {
             ast_set_flag(mohclass, MOH_RANDSTART);
          }
       } else if (!strcasecmp(var->name, "format") && !ast_strlen_zero(var->value)) {
          ao2_cleanup(mohclass->format);
          mohclass->format = ast_format_cache_get(var->value);
          if (!mohclass->format) {
             ast_log(LOG_WARNING, "Unknown format '%s' -- defaulting to SLIN\n", var->value);
             mohclass->format = ao2_bump(ast_format_slin);
          }
       } else if (!strcasecmp(var->name, "kill_escalation_delay")) {
          if (sscanf(var->value, "%zu", &mohclass->kill_delay) == 1) {
             mohclass->kill_delay *= 1000;
          } else {
             ast_log(LOG_WARNING, "kill_escalation_delay '%s' is invalid.  Setting to 100ms\n", var->value);
             mohclass->kill_delay = 100000;
          }
       } else if (!strcasecmp(var->name, "kill_method")) {
          if (!strcasecmp(var->value, "process")) {
             mohclass->kill_method = KILL_METHOD_PROCESS;
          } else if (!strcasecmp(var->value, "process_group")) {
             mohclass->kill_method = KILL_METHOD_PROCESS_GROUP;
          } else {
             ast_log(LOG_WARNING, "kill_method '%s' is invalid.  Setting to 'process_group'\n", var->value);
             mohclass->kill_method = KILL_METHOD_PROCESS_GROUP;
          }
       }
    }
 
    AST_VECTOR_COMPACT(&mohclass->files);
 }

◆ moh_post_start()

static void moh_post_start	(	struct ast_channel *	chan,
		const char *	moh_class_name
	)

static

Definition at line 239 of file res_musiconhold.c.

References ao2_cleanup, ast_assert, ast_channel_blob_create_from_cache(), ast_channel_moh_start_type(), ast_channel_name(), ast_channel_topic(), ast_channel_uniqueid(), ast_json_pack(), ast_json_unref(), ast_verb, NULL, stasis_message_data(), and stasis_publish().

Referenced by moh_alloc(), and moh_files_alloc().

 {
    struct stasis_message *message;
    struct ast_json *json_object;
 
    ast_verb(3, "Started music on hold, class '%s', on channel '%s'\n",
       moh_class_name, ast_channel_name(chan));
 
    json_object = ast_json_pack("{s: s}", "class", moh_class_name);
    if (!json_object) {
       return;
    }
 
    message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
       ast_channel_moh_start_type(), json_object);
    if (message) {
       /* A channel snapshot must have been in the cache. */
       ast_assert(((struct ast_channel_blob *) stasis_message_data(message))->snapshot != NULL);
 
       stasis_publish(ast_channel_topic(chan), message);
    }
    ao2_cleanup(message);
    ast_json_unref(json_object);
 }

◆ moh_post_stop()

static void moh_post_stop ( struct ast_channel * chan )

static

Definition at line 264 of file res_musiconhold.c.

References ao2_cleanup, ast_assert, ast_channel_blob_create_from_cache(), ast_channel_moh_stop_type(), ast_channel_name(), ast_channel_topic(), ast_channel_uniqueid(), ast_verb, NULL, stasis_message_data(), and stasis_publish().

Referenced by moh_files_release(), and moh_release().

 {
    struct stasis_message *message;
 
    ast_verb(3, "Stopped music on hold on %s\n", ast_channel_name(chan));
 
    message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
       ast_channel_moh_stop_type(), NULL);
    if (message) {
       /* A channel snapshot must have been in the cache. */
       ast_assert(((struct ast_channel_blob *) stasis_message_data(message))->snapshot != NULL);
 
       stasis_publish(ast_channel_topic(chan), message);
    }
    ao2_cleanup(message);
 }

◆ moh_release()

static void moh_release	(	struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 966 of file res_musiconhold.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_channel_music_state(), ast_channel_name(), ast_format_get_name(), ast_free, AST_LIST_REMOVE, ast_log, ast_set_write_format(), moh_files_state::class, LOG_WARNING, mohclass::members, moh_post_stop(), mohclass_unref, mohdata::origwfmt, mohdata::parent, mohdata::pipe, and state.

Referenced by moh_alloc().

 {
    struct mohdata *moh = data;
    struct mohclass *class = moh->parent;
    struct ast_format *oldwfmt;
 
    ao2_lock(class);
    AST_LIST_REMOVE(&moh->parent->members, moh, list);
    ao2_unlock(class);
 
    close(moh->pipe[0]);
    close(moh->pipe[1]);
 
    oldwfmt = moh->origwfmt;
 
    moh->parent = class = mohclass_unref(class, "unreffing moh->parent upon deactivation of generator");
 
    ast_free(moh);
 
    if (chan) {
       struct moh_files_state *state;
 
       state = ast_channel_music_state(chan);
       if (state && state->class) {
          state->class = mohclass_unref(state->class, "Unreffing channel's music class upon deactivation of generator");
       }
       if (oldwfmt && ast_set_write_format(chan, oldwfmt)) {
          ast_log(LOG_WARNING, "Unable to restore channel '%s' to format %s\n",
                ast_channel_name(chan), ast_format_get_name(oldwfmt));
       }
 
       moh_post_stop(chan);
    }
 
    ao2_cleanup(oldwfmt);
 }

◆ moh_rescan_files()

static void moh_rescan_files ( void )

static

Definition at line 1254 of file res_musiconhold.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, c, mohclass::mode, and moh_scan_files().

Referenced by load_moh_classes().

                                    {
    struct ao2_iterator i;
    struct mohclass *c;
 
    i = ao2_iterator_init(mohclasses, 0);
 
    while ((c = ao2_iterator_next(&i))) {
       if (!strcasecmp(c->mode, "files")) {
          moh_scan_files(c);
       }
       ao2_ref(c, -1);
    }
 
    ao2_iterator_destroy(&i);
 }

◆ moh_scan_files()

static int moh_scan_files ( struct mohclass * class )

static

Definition at line 1156 of file res_musiconhold.c.

References ast_config_AST_DATA_DIR, ast_copy_string(), ast_debug, ast_free, ast_log, ast_strdup, ast_test_flag, AST_VECTOR_ADD_SORTED, AST_VECTOR_APPEND, AST_VECTOR_COMPACT, AST_VECTOR_GET_CMP, AST_VECTOR_RESET, AST_VECTOR_SIZE, moh_files_state::class, mohclass::dir, ext, mohclass::files, LOG_WARNING, MOH_SORTALPHA, mohclass::name, and PATH_MAX.

Referenced by init_files_class(), local_ast_moh_start(), and moh_rescan_files().

                                                   {
 
    DIR *files_DIR;
    struct dirent *files_dirent;
    char dir_path[PATH_MAX - sizeof(class->dir)];
    char filepath[PATH_MAX];
    char *ext;
    struct stat statbuf;
    int res;
 
    if (class->dir[0] != '/') {
       snprintf(dir_path, sizeof(dir_path), "%s/%s", ast_config_AST_DATA_DIR, class->dir);
    } else {
       ast_copy_string(dir_path, class->dir, sizeof(dir_path));
    }
    ast_debug(4, "Scanning '%s' for files for class '%s'\n", dir_path, class->name);
    files_DIR = opendir(dir_path);
    if (!files_DIR) {
       ast_log(LOG_WARNING, "Cannot open dir %s or dir does not exist\n", dir_path);
       return -1;
    }
 
    AST_VECTOR_RESET(&class->files, ast_free);
 
    while ((files_dirent = readdir(files_DIR))) {
       char *filepath_copy;
 
       /* The file name must be at least long enough to have the file type extension */
       if ((strlen(files_dirent->d_name) < 4))
          continue;
 
       /* Skip files that starts with a dot */
       if (files_dirent->d_name[0] == '.')
          continue;
 
       /* Skip files without extensions... they are not audio */
       if (!strchr(files_dirent->d_name, '.'))
          continue;
 
       snprintf(filepath, sizeof(filepath), "%s/%s", dir_path, files_dirent->d_name);
 
       if (stat(filepath, &statbuf))
          continue;
 
       if (!S_ISREG(statbuf.st_mode))
          continue;
 
       if ((ext = strrchr(filepath, '.')))
          *ext = '\0';
 
       /* if the file is present in multiple formats, ensure we only put it into the list once */
       if (AST_VECTOR_GET_CMP(&class->files, &filepath[0], !strcmp)) {
          continue;
       }
 
       filepath_copy = ast_strdup(filepath);
       if (!filepath_copy) {
          break;
       }
 
       if (ast_test_flag(class, MOH_SORTALPHA)) {
          res = AST_VECTOR_ADD_SORTED(&class->files, filepath_copy, strcasecmp);
       } else {
          res = AST_VECTOR_APPEND(&class->files, filepath_copy);
       }
 
       if (res) {
          ast_free(filepath_copy);
          break;
       }
    }
 
    closedir(files_DIR);
 
    AST_VECTOR_COMPACT(&class->files);
 
    return AST_VECTOR_SIZE(&class->files);
 }

◆ mohalloc()

static struct mohdata* mohalloc ( struct mohclass * cl )

static

Definition at line 940 of file res_musiconhold.c.

References ao2_lock, ao2_unlock, ast_calloc, AST_FRAME_VOICE, ast_free, AST_FRIENDLY_OFFSET, AST_LIST_INSERT_HEAD, ast_log, ast_pipe_nonblock, errno, mohdata::f, ast_frame_subclass::format, mohclass::format, ast_frame::frametype, mohdata::list, LOG_WARNING, mohclass::members, mohclass_ref, NULL, ast_frame::offset, mohdata::parent, mohdata::pipe, and ast_frame::subclass.

Referenced by moh_alloc().

 {
    struct mohdata *moh;
 
    if (!(moh = ast_calloc(1, sizeof(*moh))))
       return NULL;
 
    if (ast_pipe_nonblock(moh->pipe)) {
       ast_log(LOG_WARNING, "Failed to create pipe: %s\n", strerror(errno));
       ast_free(moh);
       return NULL;
    }
 
    moh->f.frametype = AST_FRAME_VOICE;
    moh->f.subclass.format = cl->format;
    moh->f.offset = AST_FRIENDLY_OFFSET;
 
    moh->parent = mohclass_ref(cl, "Reffing music class for mohdata parent");
 
    ao2_lock(cl);
    AST_LIST_INSERT_HEAD(&cl->members, moh, list);
    ao2_unlock(cl);
 
    return moh;
 }

◆ monmp3thread()

static void* monmp3thread ( void * data )

static

Definition at line 755 of file res_musiconhold.c.

References ao2_lock, ao2_unlock, ast_debug, ast_format_determine_length(), ast_format_get_sample_rate(), AST_LIST_EMPTY, AST_LIST_TRAVERSE, ast_log, ast_poll, ast_samp2tv(), ast_timer_ack(), ast_timer_fd(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), moh_files_state::class, mohclass::dir, errno, mohclass::format, mohclass::kill_delay, mohclass::kill_method, killpid(), len(), LOG_ERROR, LOG_NOTICE, LOG_WARNING, mohclass::members, MOH_MS_INTERVAL, NULL, mohclass::pid, mohdata::pipe, spawn_mp3(), mohclass::srcfd, and mohclass::timer.

Referenced by init_app_class(), and local_ast_moh_start().

 {
 #define  MOH_MS_INTERVAL      100
 
    struct mohclass *class = data;
    struct mohdata *moh;
    short sbuf[8192];
    int res = 0, res2;
    int len;
    struct timeval deadline, tv_tmp;
 
    deadline.tv_sec = 0;
    deadline.tv_usec = 0;
    for(;/* ever */;) {
       pthread_testcancel();
       /* Spawn mp3 player if it's not there */
       if (class->srcfd < 0) {
          if ((class->srcfd = spawn_mp3(class)) < 0) {
             ast_log(LOG_WARNING, "Unable to spawn mp3player\n");
             /* Try again later */
             sleep(500);
             continue;
          }
       }
       if (class->timer) {
          struct pollfd pfd = { .fd = ast_timer_fd(class->timer), .events = POLLIN | POLLPRI, };
 
 #ifdef SOLARIS
          thr_yield();
 #endif
          /* Pause some amount of time */
          if (ast_poll(&pfd, 1, -1) > 0) {
             if (ast_timer_ack(class->timer, 1) < 0) {
                ast_log(LOG_ERROR, "Failed to acknowledge timer for mp3player\n");
                return NULL;
             }
             /* 25 samples per second => 40ms framerate => 320 samples */
             res = 320; /* 320/40 = 8 samples/ms */
          } else {
             ast_log(LOG_WARNING, "poll() failed: %s\n", strerror(errno));
             res = 0;
          }
          pthread_testcancel();
       } else {
          long delta;
          /* Reliable sleep */
          tv_tmp = ast_tvnow();
          if (ast_tvzero(deadline))
             deadline = tv_tmp;
          delta = ast_tvdiff_ms(tv_tmp, deadline);
          if (delta < MOH_MS_INTERVAL) {   /* too early */
             deadline = ast_tvadd(deadline, ast_samp2tv(MOH_MS_INTERVAL, 1000));  /* next deadline */
             usleep(1000 * (MOH_MS_INTERVAL - delta));
             pthread_testcancel();
          } else {
             ast_log(LOG_NOTICE, "Request to schedule in the past?!?!\n");
             deadline = tv_tmp;
          }
          /* 10 samples per second (MOH_MS_INTERVAL) => 100ms framerate => 800 samples */
          res = 8 * MOH_MS_INTERVAL; /* 800/100 = 8 samples/ms */
       }
       /* For non-8000Hz formats, we need to alter the resolution */
       res = res * ast_format_get_sample_rate(class->format) / 8000;
 
       if ((strncasecmp(class->dir, "http://", 7) && strcasecmp(class->dir, "nodir")) && AST_LIST_EMPTY(&class->members))
          continue;
       /* Read mp3 audio */
       len = ast_format_determine_length(class->format, res);
 
       if ((res2 = read(class->srcfd, sbuf, len)) != len) {
          if (!res2) {
             close(class->srcfd);
             class->srcfd = -1;
             pthread_testcancel();
             if (class->pid > 1) {
                killpid(class->pid, class->kill_delay, class->kill_method);
                class->pid = 0;
             }
          } else {
             ast_debug(1, "Read %d bytes of audio while expecting %d\n", res2, len);
          }
          continue;
       }
 
       pthread_testcancel();
 
       ao2_lock(class);
       AST_LIST_TRAVERSE(&class->members, moh, list) {
          /* Write data */
          if ((res = write(moh->pipe[1], sbuf, res2)) != res2) {
             ast_debug(1, "Only wrote %d of %d bytes to pipe\n", res, res2);
          }
       }
       ao2_unlock(class);
    }
    return NULL;
 }

◆ play_moh_exec()

static int play_moh_exec	(	struct ast_channel *	chan,
		const char *	data
	)

static

Definition at line 853 of file res_musiconhold.c.

References args, AST_APP_ARG, ast_channel_name(), AST_DECLARE_APP_ARGS, ast_log, ast_moh_start(), ast_moh_stop(), ast_safe_sleep(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero, LOG_WARNING, parse(), S_OR, and timeout.

Referenced by load_module().

 {
    char *parse;
    char *class;
    int timeout = -1;
    int res;
    AST_DECLARE_APP_ARGS(args,
       AST_APP_ARG(class);
       AST_APP_ARG(duration);
    );
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (!ast_strlen_zero(args.duration)) {
       if (sscanf(args.duration, "%30d", &timeout) == 1) {
          timeout *= 1000;
       } else {
          ast_log(LOG_WARNING, "Invalid MusicOnHold duration '%s'. Will wait indefinitely.\n", args.duration);
       }
    }
 
    class = S_OR(args.class, NULL);
    if (ast_moh_start(chan, class, NULL)) {
       ast_log(LOG_WARNING, "Unable to start music on hold class '%s' on channel %s\n", class, ast_channel_name(chan));
       return 0;
    }
 
    if (timeout > 0)
       res = ast_safe_sleep(chan, timeout);
    else {
       while (!(res = ast_safe_sleep(chan, 10000)));
    }
 
    ast_moh_stop(chan);
 
    return res;
 }

◆ reload()

static int reload ( void )

static

Definition at line 2116 of file res_musiconhold.c.

References ast_install_music_functions(), AST_MODULE_LOAD_SUCCESS, load_moh_classes(), local_ast_moh_cleanup(), local_ast_moh_start(), and local_ast_moh_stop().

Referenced by unload_module().

 {
    if (load_moh_classes(1)) {
       ast_install_music_functions(local_ast_moh_start, local_ast_moh_stop,
             local_ast_moh_cleanup);
    }
 
    return AST_MODULE_LOAD_SUCCESS;
 }

◆ spawn_mp3()

static int spawn_mp3 ( struct mohclass * class )

static

Definition at line 569 of file res_musiconhold.c.

References mohclass::args, ast_close_fds_above_n(), ast_copy_string(), ast_log, ast_opt_high_priority, ast_safe_fork(), ast_set_priority(), ast_strlen_zero, ast_test_flag, moh_files_state::class, mohclass::dir, errno, LOCAL_MPG_123, LOG_WARNING, MAX_MP3S, MOH_CUSTOM, MOH_QUIET, MOH_SINGLE, MPG_123, NULL, mohclass::pid, respawn_time, mohclass::start, and strsep().

Referenced by monmp3thread().

 {
    int fds[2];
    int files = 0;
    char fns[MAX_MP3S][80];
    char *argv[MAX_MP3S + 50];
    char xargs[256];
    char *argptr;
    int argc = 0;
    DIR *dir = NULL;
    struct dirent *de;
 
 
    if (!strcasecmp(class->dir, "nodir")) {
       files = 1;
    } else {
       dir = opendir(class->dir);
       if (!dir && strncasecmp(class->dir, "http://", 7)) {
          ast_log(LOG_WARNING, "%s is not a valid directory\n", class->dir);
          return -1;
       }
    }
 
    if (!ast_test_flag(class, MOH_CUSTOM)) {
       argv[argc++] = "mpg123";
       argv[argc++] = "-q";
       argv[argc++] = "-s";
       argv[argc++] = "--mono";
       argv[argc++] = "-r";
       argv[argc++] = "8000";
 
       if (!ast_test_flag(class, MOH_SINGLE)) {
          argv[argc++] = "-b";
          argv[argc++] = "2048";
       }
 
       argv[argc++] = "-f";
 
       if (ast_test_flag(class, MOH_QUIET))
          argv[argc++] = "4096";
       else
          argv[argc++] = "8192";
 
       /* Look for extra arguments and add them to the list */
       ast_copy_string(xargs, class->args, sizeof(xargs));
       argptr = xargs;
       while (!ast_strlen_zero(argptr)) {
          argv[argc++] = argptr;
          strsep(&argptr, ",");
       }
    } else  {
       /* Format arguments for argv vector */
       ast_copy_string(xargs, class->args, sizeof(xargs));
       argptr = xargs;
       while (!ast_strlen_zero(argptr)) {
          argv[argc++] = argptr;
          strsep(&argptr, " ");
       }
    }
 
    if (!strncasecmp(class->dir, "http://", 7)) {
       ast_copy_string(fns[files], class->dir, sizeof(fns[files]));
       argv[argc++] = fns[files];
       files++;
    } else if (dir) {
       while ((de = readdir(dir)) && (files < MAX_MP3S)) {
          if ((strlen(de->d_name) > 3) &&
              ((ast_test_flag(class, MOH_CUSTOM) &&
                (!strcasecmp(de->d_name + strlen(de->d_name) - 4, ".raw") ||
                 !strcasecmp(de->d_name + strlen(de->d_name) - 4, ".sln"))) ||
               !strcasecmp(de->d_name + strlen(de->d_name) - 4, ".mp3"))) {
             ast_copy_string(fns[files], de->d_name, sizeof(fns[files]));
             argv[argc++] = fns[files];
             files++;
          }
       }
    }
    argv[argc] = NULL;
    if (dir) {
       closedir(dir);
    }
    if (pipe(fds)) {
       ast_log(LOG_WARNING, "Pipe failed\n");
       return -1;
    }
    if (!files) {
       ast_log(LOG_WARNING, "Found no files in '%s'\n", class->dir);
       close(fds[0]);
       close(fds[1]);
       return -1;
    }
    if (!strncasecmp(class->dir, "http://", 7) && time(NULL) - class->start < respawn_time) {
       sleep(respawn_time - (time(NULL) - class->start));
    }
 
    time(&class->start);
    class->pid = ast_safe_fork(0);
    if (class->pid < 0) {
       close(fds[0]);
       close(fds[1]);
       ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
       return -1;
    }
    if (!class->pid) {
       if (ast_opt_high_priority)
          ast_set_priority(0);
 
       close(fds[0]);
       /* Stdout goes to pipe */
       dup2(fds[1], STDOUT_FILENO);
 
       /* Close everything else */
       ast_close_fds_above_n(STDERR_FILENO);
 
       /* Child */
       if (strncasecmp(class->dir, "http://", 7) && strcasecmp(class->dir, "nodir") && chdir(class->dir) < 0) {
          ast_log(LOG_WARNING, "chdir() failed: %s\n", strerror(errno));
          _exit(1);
       }
       setpgid(0, getpid());
       if (ast_test_flag(class, MOH_CUSTOM)) {
          execv(argv[0], argv);
       } else {
          /* Default install is /usr/local/bin */
          execv(LOCAL_MPG_123, argv);
          /* Many places have it in /usr/bin */
          execv(MPG_123, argv);
          /* Check PATH as a last-ditch effort */
          execvp("mpg123", argv);
       }
       /* Can't use logger, since log FDs are closed */
       fprintf(stderr, "MOH: exec failed: %s\n", strerror(errno));
       close(fds[1]);
       _exit(1);
    } else {
       /* Parent */
       close(fds[1]);
    }
    return fds[0];
 }

◆ start_moh_exec()

static int start_moh_exec	(	struct ast_channel *	chan,
		const char *	data
	)

static

Definition at line 893 of file res_musiconhold.c.

References args, AST_APP_ARG, ast_channel_name(), AST_DECLARE_APP_ARGS, ast_log, ast_moh_start(), AST_STANDARD_APP_ARGS, ast_strdupa, LOG_WARNING, parse(), and S_OR.

Referenced by load_module().

 {
    char *parse;
    char *class;
    AST_DECLARE_APP_ARGS(args,
       AST_APP_ARG(class);
    );
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    class = S_OR(args.class, NULL);
    if (ast_moh_start(chan, class, NULL))
       ast_log(LOG_WARNING, "Unable to start music on hold class '%s' on channel %s\n", class, ast_channel_name(chan));
 
    return 0;
 }

◆ stop_moh_exec()

static int stop_moh_exec	(	struct ast_channel *	chan,
		const char *	data
	)

static

Definition at line 912 of file res_musiconhold.c.

References ast_moh_stop().

Referenced by load_module().

 {
    ast_moh_stop(chan);
 
    return 0;
 }

◆ unload_module()

static int unload_module ( void )

static

Definition at line 2133 of file res_musiconhold.c.

References ao2_t_callback, ARRAY_LEN, ast_cli_unregister_multiple(), ast_log, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DEPEND, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_moh_destroy(), ast_uninstall_music_functions(), ast_unregister_application(), ast_unregister_atexit(), ASTERISK_GPL_KEY, load_module(), LOG_WARNING, moh_class_inuse(), mohclass_unref, NULL, play_moh, reload(), start_moh, and stop_moh.

 {
    int res = 0;
    struct mohclass *class = NULL;
 
    /* XXX This check shouldn't be required if module ref counting was being used
     * properly ... */
    if ((class = ao2_t_callback(mohclasses, 0, moh_class_inuse, NULL, "Module unload callback"))) {
       class = mohclass_unref(class, "unref of class from module unload callback");
       res = -1;
    }
 
    if (res < 0) {
       ast_log(LOG_WARNING, "Unable to unload res_musiconhold due to active MOH channels\n");
       return res;
    }
 
    ast_uninstall_music_functions();
 
    ast_moh_destroy();
    res = ast_unregister_application(play_moh);
    res |= ast_unregister_application(start_moh);
    res |= ast_unregister_application(stop_moh);
    ast_cli_unregister_multiple(cli_moh, ARRAY_LEN(cli_moh));
    ast_unregister_atexit(ast_moh_destroy);
 
    return res;
 }

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Music On Hold Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DEPEND, }

static

Definition at line 2168 of file res_musiconhold.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2168 of file res_musiconhold.c.

◆ cli_moh

struct ast_cli_entry cli_moh[]

static

Definition at line 2054 of file res_musiconhold.c.

◆ global_flags

struct ast_flags global_flags[1] = {{0}}

static

global MOH_ flags

Definition at line 160 of file res_musiconhold.c.

◆ moh_file_stream

struct ast_generator moh_file_stream

static

Definition at line 561 of file res_musiconhold.c.

◆ mohclasses

struct ao2_container* mohclasses

static

Definition at line 206 of file res_musiconhold.c.

◆ mohgen

struct ast_generator mohgen

static

Definition at line 1070 of file res_musiconhold.c.

◆ play_moh

const char play_moh[] = "MusicOnHold"

static

Definition at line 123 of file res_musiconhold.c.

Referenced by load_module(), and unload_module().

◆ respawn_time

int respawn_time = 20

static

Definition at line 127 of file res_musiconhold.c.

Referenced by _moh_register(), local_ast_moh_start(), and spawn_mp3().

◆ start_moh

const char start_moh[] = "StartMusicOnHold"

static

Definition at line 124 of file res_musiconhold.c.

Referenced by load_module(), and unload_module().

◆ stop_moh

const char stop_moh[] = "StopMusicOnHold"

static

Definition at line 125 of file res_musiconhold.c.

Referenced by load_module(), and unload_module().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DONT_UNREF

◆ get_mohbyname

◆ HANDLE_REF

◆ INITIAL_NUM_FILES

◆ LOCAL_MPG_123

◆ MAX_MP3S

◆ MOH_ANNOUNCEMENT

◆ MOH_CACHERTCLASSES

◆ moh_class_malloc

◆ MOH_CUSTOM

◆ MOH_MS_INTERVAL

◆ MOH_NOTDELETED

◆ MOH_PREFERCHANNELCLASS

◆ MOH_QUIET

◆ MOH_RANDOMIZE

◆ MOH_RANDSTART

◆ MOH_REALTIME

◆ moh_register

◆ MOH_SINGLE

◆ MOH_SORTALPHA

◆ MOH_SORTMODE

◆ moh_unregister

◆ mohclass_ref

◆ mohclass_unref

◆ MPG_123

Enumeration Type Documentation

◆ kill_methods

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ _get_mohbyname()

◆ _moh_class_malloc()

◆ _moh_register()

◆ _moh_unregister()

◆ AST_MODULE_SELF_SYM()

◆ ast_moh_destroy()

◆ ast_moh_files_next()

◆ complete_mohclass_realtime()

◆ get_mohbydigit()

◆ handle_cli_moh_reload()

◆ handle_cli_moh_show_classes()

◆ handle_cli_moh_show_files()

◆ handle_cli_moh_unregister_class()

◆ init_app_class()

◆ init_files_class()

◆ killer()

◆ killpid()

◆ load_module()

◆ load_moh_classes()

◆ load_realtime_musiconhold()

◆ local_ast_moh_cleanup()

◆ local_ast_moh_start()

◆ local_ast_moh_stop()

◆ moh_alloc()

◆ moh_class_cmp()

◆ moh_class_destructor()

◆ moh_class_hash()

◆ moh_class_inuse()

◆ moh_class_mark()

◆ moh_classes_delete_marked()

◆ moh_diff()

◆ moh_digit_match()

◆ moh_files_alloc()

◆ moh_files_generator()

◆ moh_files_readframe()

◆ moh_files_release()

◆ moh_files_write_format_change()

◆ moh_generate()

◆ moh_handle_digit()

◆ moh_parse_options()

◆ moh_post_start()

◆ moh_post_stop()

◆ moh_release()