Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:46 2007

Asterisk developer's documentation :: Codename Pineapple

---

res_musiconhold.c File Reference

---

Detailed Description

Routines implementing music on hold.

• See also Music on Hold Configuration

Author:

Mark Spencer <markster@digium.com>

Definition in file res_musiconhold.c.

#include "asterisk.h"
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <dirent.h>
#include <sys/ioctl.h>
#include "asterisk/zapata.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/options.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 dependency graph for res_musiconhold.c:

Go to the source code of this file.

Data Structures
struct	moh_files_state
struct	mohclass
struct	mohdata
Defines
#define	INITIAL_NUM_FILES   8
#define	LOCAL_MPG_123   "/usr/local/bin/mpg123"
#define	MAX_MP3S   256
#define	MOH_CUSTOM   (1 << 2)
#define	MOH_MS_INTERVAL   100
#define	MOH_QUIET   (1 << 0)
#define	MOH_RANDOMIZE   (1 << 3)
#define	MOH_SINGLE   (1 << 1)
#define	MPG_123   "/usr/bin/mpg123"
Functions
	AST_LIST_HEAD_STATIC (mohclasses, mohclass)
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS,"Music On Hold Resource",.load=load_module,.unload=unload_module,.reload=reload,)
static void	ast_moh_destroy (void)
static int	ast_moh_files_next (struct ast_channel *chan)
static void	ast_moh_free_class (struct mohclass **mohclass)
static int	cli_files_show (int fd, int argc, char *argv[])
static struct mohclass *	get_mohbyname (const char *name)
static int	init_classes (int reload)
static int	load_module (void)
static int	load_moh_classes (int reload)
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 int	moh0_exec (struct ast_channel *chan, void *data)
static int	moh1_exec (struct ast_channel *chan, void *data)
static int	moh2_exec (struct ast_channel *chan, void *data)
static int	moh3_exec (struct ast_channel *chan, void *data)
static int	moh4_exec (struct ast_channel *chan, void *data)
static int	moh_add_file (struct mohclass *class, const char *filepath)
static void *	moh_alloc (struct ast_channel *chan, void *params)
static struct mohclass *	moh_class_malloc (void)
static int	moh_classes_show (int fd, int argc, char *argv[])
static int	moh_cli (int fd, int argc, char *argv[])
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 int	moh_generate (struct ast_channel *chan, void *data, int len, int samples)
static void	moh_on_off (int on)
static int	moh_register (struct mohclass *moh, int reload)
static void	moh_release (struct ast_channel *chan, void *data)
static int	moh_scan_files (struct mohclass *class)
static struct mohdata *	mohalloc (struct mohclass *cl)
static void *	monmp3thread (void *data)
static int	reload (void)
static int	spawn_mp3 (struct mohclass *class)
static int	unload_module (void)
Variables
static char *	app0 = "MusicOnHold"
static char *	app1 = "WaitMusicOnHold"
static char *	app2 = "SetMusicOnHold"
static char *	app3 = "StartMusicOnHold"
static char *	app4 = "StopMusicOnHold"
static struct ast_cli_entry	cli_moh []
static char *	descrip0
static char *	descrip1
static char *	descrip2
static char *	descrip3
static char *	descrip4
static struct ast_generator	moh_file_stream
static struct ast_generator	mohgen
static int	respawn_time = 20
static char *	synopsis0 = "Play Music On Hold indefinitely"
static char *	synopsis1 = "Wait, playing Music On Hold"
static char *	synopsis2 = "Set default Music On Hold class"
static char *	synopsis3 = "Play Music On Hold"
static char *	synopsis4 = "Stop Playing Music On Hold"

---

Define Documentation

#define INITIAL_NUM_FILES   8

Definition at line 73 of file res_musiconhold.c. Referenced by moh_add_file().

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

Definition at line 164 of file res_musiconhold.c.

#define MAX_MP3S   256

Definition at line 166 of file res_musiconhold.c. Referenced by spawn_mp3().

#define MOH_CUSTOM   (1 << 2)

Definition at line 125 of file res_musiconhold.c. Referenced by moh_classes_show(), moh_register(), and spawn_mp3().

#define MOH_MS_INTERVAL   100

#define MOH_QUIET   (1 << 0)

Definition at line 123 of file res_musiconhold.c. Referenced by moh_register(), and spawn_mp3().

#define MOH_RANDOMIZE   (1 << 3)

Definition at line 126 of file res_musiconhold.c. Referenced by ast_moh_files_next(), load_moh_classes(), moh_files_alloc(), and moh_register().

#define MOH_SINGLE   (1 << 1)

Definition at line 124 of file res_musiconhold.c. Referenced by moh_register(), and spawn_mp3().

#define MPG_123   "/usr/bin/mpg123"

Definition at line 165 of file res_musiconhold.c.

---

Function Documentation

AST_LIST_HEAD_STATIC (  mohclasses  , mohclass  )

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_GLOBAL_SYMBOLS  , "Music On Hold Resource"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

static void ast_moh_destroy (  void   )  [static]

Definition at line 1054 of file res_musiconhold.c. References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_log(), ast_moh_free_class(), ast_verbose(), ast_wait_for_input(), moh, option_debug, option_verbose, mohclass::pid, and VERBOSE_PREFIX_2. Referenced by load_module(), and moh_cli(). { struct mohclass *moh; char buff[8192]; int bytes, tbytes = 0, stime = 0, pid = 0; if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Destroying musiconhold processes\n"); AST_LIST_LOCK(&mohclasses); while ((moh = AST_LIST_REMOVE_HEAD(&mohclasses, list))) { if (moh->pid > 1) { if (option_debug) ast_log(LOG_DEBUG, "killing %d!\n", moh->pid); stime = time(NULL) + 2; pid = moh->pid; moh->pid = 0; /* Back when this was just mpg123, SIGKILL was fine. Now we need * to give the process a reason and time enough to kill off its * children. */ kill(pid, SIGHUP); usleep(100000); kill(pid, SIGTERM); usleep(100000); kill(pid, SIGKILL); while ((ast_wait_for_input(moh->srcfd, 100) > 0) && (bytes = read(moh->srcfd, buff, 8192)) && time(NULL) < stime) tbytes = tbytes + bytes; if (option_debug) ast_log(LOG_DEBUG, "mpg123 pid %d and child died after %d bytes read\n", pid, tbytes); close(moh->srcfd); } ast_moh_free_class(&moh); } AST_LIST_UNLOCK(&mohclasses); }

static int ast_moh_files_next (  struct ast_channel *  chan  )  [static]

Definition at line 214 of file res_musiconhold.c. References ast_closestream(), ast_fileexists(), ast_test_flag, moh_files_state::class, mohclass::filearray, MOH_RANDOMIZE, ast_channel::music_state, moh_files_state::pos, moh_files_state::samples, moh_files_state::save_pos, ast_channel::stream, and mohclass::total_files. Referenced by moh_files_readframe(). { struct moh_files_state *state = chan->music_state; int tries; if (state->save_pos) { state->pos = state->save_pos; state->save_pos = 0; } state->samples = 0; if (chan->stream) { ast_closestream(chan->stream); chan->stream = NULL; state->pos++; state->pos %= state->class->total_files; } if (ast_test_flag(state->class, MOH_RANDOMIZE)) { /* Try 20 times to find something good */ for (tries = 0; tries < 20; tries++) { state->pos = rand() % state->class->total_files; /* check to see if this file's format can be opened */ if (ast_fileexists(state->class->filearray[state->pos], NULL, NULL) > 0) break; } } if (!ast_openstream_full(chan, state->class->filearray[state->pos], chan->language, 1)) { ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", state->class->filearray[state->pos], strerror(errno)); state->pos++; state->pos %= state->class->total_files; return -1; } if (option_debug) ast_log(LOG_DEBUG, "%s Opened file %d '%s'\n", chan->name, state->pos, state->class->filearray[state->pos]); if (state->samples) ast_seekstream(chan->stream, state->samples, SEEK_SET); return 0; }

static void ast_moh_free_class (  struct mohclass **  mohclass  )  [static]

Definition at line 169 of file res_musiconhold.c. References AST_LIST_REMOVE_HEAD, and free. Referenced by ast_moh_destroy(), and moh_register(). { struct mohdata *member; struct mohclass *class = *mohclass; int i; while ((member = AST_LIST_REMOVE_HEAD(&class->members, list))) free(member); if (class->thread) { pthread_cancel(class->thread); class->thread = 0; } if (class->filearray) { for (i = 0; i < class->total_files; i++) free(class->filearray[i]); free(class->filearray); } free(class); *mohclass = NULL; }

static int cli_files_show (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1117 of file res_musiconhold.c. References ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, and AST_LIST_UNLOCK. { int i; struct mohclass *class; AST_LIST_LOCK(&mohclasses); AST_LIST_TRAVERSE(&mohclasses, class, list) { if (!class->total_files) continue; ast_cli(fd, "Class: %s\n", class->name); for (i = 0; i < class->total_files; i++) ast_cli(fd, "\tFile: %s\n", class->filearray[i]); } AST_LIST_UNLOCK(&mohclasses); return 0; }

static struct mohclass* get_mohbyname (  const char *  name  )  [static]

Note: This function should be called with the mohclasses list locked Definition at line 627 of file res_musiconhold.c. References AST_LIST_TRAVERSE, and moh. Referenced by local_ast_moh_start(), and moh_register(). { struct mohclass *moh = NULL; AST_LIST_TRAVERSE(&mohclasses, moh, list) { if (!strcasecmp(name, moh->name)) break; } return moh; }

static int init_classes (  int  reload  )  [static]

Definition at line 1169 of file res_musiconhold.c. References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, load_moh_classes(), moh, and moh_scan_files(). Referenced by load_module(), and reload(). { struct mohclass *moh; if (!load_moh_classes(reload)) /* Load classes from config */ return 0; /* Return if nothing is found */ AST_LIST_LOCK(&mohclasses); AST_LIST_TRAVERSE(&mohclasses, moh, list) { if (moh->total_files) moh_scan_files(moh); } AST_LIST_UNLOCK(&mohclasses); return 1; }

static int load_module (  void   )  [static]

Definition at line 1186 of file res_musiconhold.c. References ast_cli_register_multiple(), ast_install_music_functions(), ast_log(), ast_moh_destroy(), ast_register_application(), ast_register_atexit(), cli_moh, init_classes(), local_ast_moh_cleanup(), local_ast_moh_start(), local_ast_moh_stop(), LOG_WARNING, moh0_exec(), moh1_exec(), moh2_exec(), moh3_exec(), and moh4_exec(). { int res; res = ast_register_application(app0, moh0_exec, synopsis0, descrip0); ast_register_atexit(ast_moh_destroy); ast_cli_register_multiple(cli_moh, sizeof(cli_moh) / sizeof(struct ast_cli_entry)); if (!res) res = ast_register_application(app1, moh1_exec, synopsis1, descrip1); if (!res) res = ast_register_application(app2, moh2_exec, synopsis2, descrip2); if (!res) res = ast_register_application(app3, moh3_exec, synopsis3, descrip3); if (!res) res = ast_register_application(app4, moh4_exec, synopsis4, descrip4); if (!init_classes(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); } return 0; }

static int load_moh_classes (  int  reload  )  [static]

Definition at line 981 of file res_musiconhold.c. References ast_category_browse(), ast_config_load(), AST_FORMAT_SLINEAR, ast_getformatbyname(), ast_log(), ast_set2_flag, ast_strlen_zero(), ast_true(), ast_variable_browse(), free, LOG_WARNING, moh_class_malloc(), MOH_RANDOMIZE, moh_register(), and var. Referenced by init_classes(), and moh_cli(). { struct ast_config *cfg; struct ast_variable *var; struct mohclass *class; char *cat; int numclasses = 0; cfg = ast_config_load("musiconhold.conf"); if (!cfg) return 0; cat = ast_category_browse(cfg, NULL); for (; cat; cat = ast_category_browse(cfg, cat)) { /* These names were deprecated in 1.4 and should not be used until after the next major release. */ if (strcasecmp(cat, "classes") && strcasecmp(cat, "moh_files")) { if (!(class = moh_class_malloc())) { break; } ast_copy_string(class->name, cat, sizeof(class->name)); var = ast_variable_browse(cfg, cat); while (var) { if (!strcasecmp(var->name, "mode")) ast_copy_string(class->mode, var->value, sizeof(class->mode)); else if (!strcasecmp(var->name, "directory")) ast_copy_string(class->dir, var->value, sizeof(class->dir)); else if (!strcasecmp(var->name, "application")) ast_copy_string(class->args, var->value, sizeof(class->args)); else if (!strcasecmp(var->name, "random")) ast_set2_flag(class, ast_true(var->value), MOH_RANDOMIZE); else if (!strcasecmp(var->name, "format")) { class->format = ast_getformatbyname(var->value); if (!class->format) { ast_log(LOG_WARNING, "Unknown format '%s' -- defaulting to SLIN\n", var->value); class->format = AST_FORMAT_SLINEAR; } } var = var->next; } if (ast_strlen_zero(class->dir)) { if (!strcasecmp(class->mode, "custom")) { strcpy(class->dir, "nodir"); } else { ast_log(LOG_WARNING, "A directory must be specified for class '%s'!\n", class->name); free(class); continue; } } if (ast_strlen_zero(class->mode)) { ast_log(LOG_WARNING, "A mode must be specified for class '%s'!\n", class->name); free(class); 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); free(class); continue; } /* Don't leak a class when it's already registered */ moh_register(class, reload); numclasses++; } } ast_config_destroy(cfg); return numclasses; }

static void local_ast_moh_cleanup (  struct ast_channel *  chan  )  [static]

Definition at line 909 of file res_musiconhold.c. References free, and ast_channel::music_state. Referenced by load_module(), and reload(). { if (chan->music_state) { free(chan->music_state); chan->music_state = NULL; } }

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

Definition at line 917 of file res_musiconhold.c. References ast_activate_generator(), AST_FLAG_MOH, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_set_flag, ast_strlen_zero(), get_mohbyname(), LOG_WARNING, moh_file_stream, mohgen, and mohclass::total_files. Referenced by load_module(), moh_on_off(), and reload(). { struct mohclass *mohclass; const char *class; /* 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. * 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 interpclass argument. This would be from the mohinterpret * option from channel drivers. This is the same as the old musicclass * option. * 4) The default class. */ if (!ast_strlen_zero(chan->musicclass)) class = chan->musicclass; else if (!ast_strlen_zero(mclass)) class = mclass; else if (!ast_strlen_zero(interpclass)) class = interpclass; else class = "default"; AST_LIST_LOCK(&mohclasses); mohclass = get_mohbyname(class); AST_LIST_UNLOCK(&mohclasses); if (!mohclass) { ast_log(LOG_WARNING, "No class: %s\n", class); return -1; } ast_set_flag(chan, AST_FLAG_MOH); if (mohclass->total_files) { return ast_activate_generator(chan, &moh_file_stream, mohclass); } else return ast_activate_generator(chan, &mohgen, mohclass); }

static void local_ast_moh_stop (  struct ast_channel *  chan  )  [static]

Definition at line 958 of file res_musiconhold.c. References ast_clear_flag, ast_closestream(), ast_deactivate_generator(), AST_FLAG_MOH, ast_channel::music_state, and ast_channel::stream. Referenced by load_module(), and reload(). { ast_clear_flag(chan, AST_FLAG_MOH); ast_deactivate_generator(chan); if (chan->music_state) { if (chan->stream) { ast_closestream(chan->stream); chan->stream = NULL; } } }

static int moh0_exec (  struct ast_channel *  chan, void *  data )  [static]

Definition at line 571 of file res_musiconhold.c. References ast_log(), ast_moh_start(), ast_moh_stop(), ast_safe_sleep(), and LOG_WARNING. Referenced by load_module(). { if (ast_moh_start(chan, data, NULL)) { ast_log(LOG_WARNING, "Unable to start music on hold (class '%s') on channel %s\n", (char *)data, chan->name); return -1; } while (!ast_safe_sleep(chan, 10000)); ast_moh_stop(chan); return -1; }

static int moh1_exec (  struct ast_channel *  chan, void *  data )  [static]

Definition at line 582 of file res_musiconhold.c. References ast_log(), ast_moh_start(), ast_moh_stop(), ast_safe_sleep(), and LOG_WARNING. Referenced by load_module(). { int res; if (!data || !atoi(data)) { ast_log(LOG_WARNING, "WaitMusicOnHold requires an argument (number of seconds to wait)\n"); return -1; } if (ast_moh_start(chan, NULL, NULL)) { ast_log(LOG_WARNING, "Unable to start music on hold for %d seconds on channel %s\n", atoi(data), chan->name); return -1; } res = ast_safe_sleep(chan, atoi(data) * 1000); ast_moh_stop(chan); return res; }

static int moh2_exec (  struct ast_channel *  chan, void *  data )  [static]

Definition at line 598 of file res_musiconhold.c. References ast_log(), ast_string_field_set, ast_strlen_zero(), LOG_WARNING, and musicclass. Referenced by load_module(). { if (ast_strlen_zero(data)) { ast_log(LOG_WARNING, "SetMusicOnHold requires an argument (class)\n"); return -1; } ast_string_field_set(chan, musicclass, data); return 0; }

static int moh3_exec (  struct ast_channel *  chan, void *  data )  [static]

Definition at line 608 of file res_musiconhold.c. References ast_log(), ast_moh_start(), and LOG_NOTICE. Referenced by load_module(). { char *class = NULL; if (data && strlen(data)) class = data; if (ast_moh_start(chan, class, NULL)) ast_log(LOG_NOTICE, "Unable to start music on hold class '%s' on channel %s\n", class ? class : "default", chan->name); return 0; }

static int moh4_exec (  struct ast_channel *  chan, void *  data )  [static]

Definition at line 619 of file res_musiconhold.c. References ast_moh_stop(). Referenced by load_module(). { ast_moh_stop(chan); return 0; }

static int moh_add_file (  struct mohclass *  class, const char *  filepath )  [static]

Definition at line 746 of file res_musiconhold.c. References mohclass::allowed_files, ast_calloc, ast_realloc, ast_strdup, mohclass::filearray, INITIAL_NUM_FILES, and mohclass::total_files. Referenced by moh_scan_files(). { if (!class->allowed_files) { if (!(class->filearray = ast_calloc(1, INITIAL_NUM_FILES * sizeof(*class->filearray)))) return -1; class->allowed_files = INITIAL_NUM_FILES; } else if (class->total_files == class->allowed_files) { if (!(class->filearray = ast_realloc(class->filearray, class->allowed_files * sizeof(*class->filearray) * 2))) { class->allowed_files = 0; class->total_files = 0; return -1; } class->allowed_files *= 2; } if (!(class->filearray[class->total_files] = ast_strdup(filepath))) return -1; class->total_files++; return 0; }

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

Definition at line 690 of file res_musiconhold.c. References ast_codec2str(), ast_log(), ast_set_write_format(), ast_verbose(), LOG_WARNING, moh_release(), mohalloc(), option_verbose, mohdata::origwfmt, VERBOSE_PREFIX_3, and ast_channel::writeformat. { struct mohdata *res; struct mohclass *class = params; if ((res = mohalloc(class))) { res->origwfmt = chan->writeformat; if (ast_set_write_format(chan, class->format)) { ast_log(LOG_WARNING, "Unable to set channel '%s' to format '%s'\n", chan->name, ast_codec2str(class->format)); moh_release(NULL, res); res = NULL; } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Started music on hold, class '%s', on channel '%s'\n", class->name, chan->name); } return res; }

static struct mohclass* moh_class_malloc (  void   )  [static]

Definition at line 971 of file res_musiconhold.c. References ast_calloc, AST_FORMAT_SLINEAR, and mohclass::format. Referenced by load_moh_classes(). { struct mohclass *class; if ((class = ast_calloc(1, sizeof(*class)))) class->format = AST_FORMAT_SLINEAR; return class; }

static int moh_classes_show (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1136 of file res_musiconhold.c. References ast_cli(), ast_getformatname(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_test_flag, MOH_CUSTOM, and S_OR. { struct mohclass *class; AST_LIST_LOCK(&mohclasses); AST_LIST_TRAVERSE(&mohclasses, class, list) { ast_cli(fd, "Class: %s\n", class->name); ast_cli(fd, "\tMode: %s\n", S_OR(class->mode, "<none>")); ast_cli(fd, "\tDirectory: %s\n", S_OR(class->dir, "<none>")); if (ast_test_flag(class, MOH_CUSTOM)) ast_cli(fd, "\tApplication: %s\n", S_OR(class->args, "<none>")); if (strcasecmp(class->mode, "files")) ast_cli(fd, "\tFormat: %s\n", ast_getformatname(class->format)); } AST_LIST_UNLOCK(&mohclasses); return 0; }

static int moh_cli (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1105 of file res_musiconhold.c. References ast_cli(), ast_moh_destroy(), load_moh_classes(), and moh_on_off(). { int x; moh_on_off(0); ast_moh_destroy(); x = load_moh_classes(1); moh_on_off(1); ast_cli(fd, "\n%d class%s reloaded.\n", x, x == 1 ? "" : "es"); return 0; }

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

Definition at line 297 of file res_musiconhold.c. References ast_calloc, ast_random(), ast_test_flag, ast_verbose(), MOH_RANDOMIZE, ast_channel::music_state, option_verbose, VERBOSE_PREFIX_3, and ast_channel::writeformat. { struct moh_files_state *state; struct mohclass *class = params; if (!chan->music_state && (state = ast_calloc(1, sizeof(*state)))) { chan->music_state = state; state->class = class; } else state = chan->music_state; if (state) { if (state->class != class) { /* initialize */ memset(state, 0, sizeof(*state)); state->class = class; if (ast_test_flag(state->class, MOH_RANDOMIZE)) state->pos = ast_random() % class->total_files; } state->origwfmt = chan->writeformat; if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Started music on hold, class '%s', on %s\n", class->name, chan->name); } return chan->music_state; }

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

Definition at line 272 of file res_musiconhold.c. References ast_frfree(), ast_log(), ast_write(), LOG_WARNING, moh_files_readframe(), ast_channel::music_state, moh_files_state::sample_queue, ast_frame::samples, and moh_files_state::samples. { struct moh_files_state *state = chan->music_state; struct ast_frame *f = NULL; int res = 0; state->sample_queue += samples; while (state->sample_queue > 0) { if ((f = moh_files_readframe(chan))) { state->samples += f->samples; res = ast_write(chan, f); state->sample_queue -= f->samples; ast_frfree(f); if (res < 0) { ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", chan->name, strerror(errno)); return -1; } } else return -1; } return res; }

static struct ast_frame* moh_files_readframe (  struct ast_channel *  chan  )  [static]

Definition at line 260 of file res_musiconhold.c. References ast_moh_files_next(), ast_readframe(), and ast_channel::stream. Referenced by moh_files_generator(). { struct ast_frame *f = NULL; if (!(chan->stream && (f = ast_readframe(chan->stream)))) { if (!ast_moh_files_next(chan)) f = ast_readframe(chan->stream); } return f; }

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

Definition at line 194 of file res_musiconhold.c. References ast_closestream(), ast_log(), ast_set_write_format(), ast_verbose(), LOG_WARNING, ast_channel::music_state, option_verbose, moh_files_state::origwfmt, moh_files_state::pos, moh_files_state::save_pos, ast_channel::stream, and VERBOSE_PREFIX_3. { struct moh_files_state *state = chan->music_state; if (chan && state) { if (chan->stream) { ast_closestream(chan->stream); chan->stream = NULL; } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Stopped music on hold on %s\n", chan->name); if (state->origwfmt && ast_set_write_format(chan, state->origwfmt)) { ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, state->origwfmt); } state->save_pos = state->pos; } }

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

Definition at line 708 of file res_musiconhold.c. References ast_codec_get_len(), ast_codec_get_samples(), AST_FRIENDLY_OFFSET, ast_log(), ast_write(), LOG_WARNING, and moh. { struct mohdata *moh = data; short buf[1280 + AST_FRIENDLY_OFFSET / 2]; int res; if (!moh->parent->pid) return -1; len = ast_codec_get_len(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, chan->name); 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 = buf + AST_FRIENDLY_OFFSET / 2; moh->f.samples = ast_codec_get_samples(&moh->f); if (ast_write(chan, &moh->f) < 0) { ast_log(LOG_WARNING, "Failed to write frame to '%s': %s\n", chan->name, strerror(errno)); return -1; } return 0; }

static void moh_on_off (  int  on  )  [static]

Definition at line 1090 of file res_musiconhold.c. References ast_channel_unlock, ast_channel_walk_locked(), ast_deactivate_generator(), AST_FLAG_MOH, ast_test_flag, and local_ast_moh_start(). Referenced by moh_cli(). { struct ast_channel *chan = NULL; while ( (chan = ast_channel_walk_locked(chan)) != NULL) { if (ast_test_flag(chan, AST_FLAG_MOH)) { if (on) local_ast_moh_start(chan, NULL, NULL); else ast_deactivate_generator(chan); } ast_channel_unlock(chan); } }

static int moh_register (  struct mohclass *  moh, int  reload )  [static]

Definition at line 835 of file res_musiconhold.c. References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_moh_free_class(), ast_pthread_create_background, ast_set_flag, free, get_mohbyname(), LOG_WARNING, moh, MOH_CUSTOM, MOH_QUIET, MOH_RANDOMIZE, moh_scan_files(), MOH_SINGLE, monmp3thread(), and option_debug. Referenced by load_moh_classes(). { #ifdef HAVE_ZAPTEL int x; #endif AST_LIST_LOCK(&mohclasses); if (get_mohbyname(moh->name)) { if (reload) { if (option_debug) ast_log(LOG_DEBUG, "Music on Hold class '%s' left alone from initial load.\n", moh->name); } else { ast_log(LOG_WARNING, "Music on Hold class '%s' already exists\n", moh->name); } free(moh); AST_LIST_UNLOCK(&mohclasses); return -1; } AST_LIST_UNLOCK(&mohclasses); time(&moh->start); moh->start -= respawn_time; if (!strcasecmp(moh->mode, "files")) { if (!moh_scan_files(moh)) { ast_moh_free_class(&moh); return -1; } if (strchr(moh->args, 'r')) ast_set_flag(moh, MOH_RANDOMIZE); } 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 (!strcasecmp(moh->mode, "custom")) ast_set_flag(moh, MOH_CUSTOM); else if (!strcasecmp(moh->mode, "mp3nb")) ast_set_flag(moh, MOH_SINGLE); else if (!strcasecmp(moh->mode, "quietmp3nb")) ast_set_flag(moh, MOH_SINGLE | MOH_QUIET); else if (!strcasecmp(moh->mode, "quietmp3")) ast_set_flag(moh, MOH_QUIET); moh->srcfd = -1; #ifdef HAVE_ZAPTEL /* Open /dev/zap/pseudo for timing... Is there a better, yet reliable way to do this? */ moh->pseudofd = open("/dev/zap/pseudo", O_RDONLY); if (moh->pseudofd < 0) { ast_log(LOG_WARNING, "Unable to open pseudo channel for timing... Sound may be choppy.\n"); } else { x = 320; ioctl(moh->pseudofd, ZT_SET_BLOCKSIZE, &x); } #else moh->pseudofd = -1; #endif if (ast_pthread_create_background(&moh->thread, NULL, monmp3thread, moh)) { ast_log(LOG_WARNING, "Unable to create moh...\n"); if (moh->pseudofd > -1) close(moh->pseudofd); ast_moh_free_class(&moh); return -1; } } else { ast_log(LOG_WARNING, "Don't know how to do a mode '%s' music on hold\n", moh->mode); ast_moh_free_class(&moh); return -1; } AST_LIST_LOCK(&mohclasses); AST_LIST_INSERT_HEAD(&mohclasses, moh, list); AST_LIST_UNLOCK(&mohclasses); return 0; }

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

Definition at line 669 of file res_musiconhold.c. References ast_getformatname(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_log(), ast_set_write_format(), ast_verbose(), free, LOG_WARNING, moh, option_verbose, and VERBOSE_PREFIX_3. Referenced by moh_alloc(). { struct mohdata *moh = data; int oldwfmt; AST_LIST_LOCK(&mohclasses); AST_LIST_REMOVE(&moh->parent->members, moh, list); AST_LIST_UNLOCK(&mohclasses); close(moh->pipe[0]); close(moh->pipe[1]); oldwfmt = moh->origwfmt; free(moh); if (chan) { if (oldwfmt && ast_set_write_format(chan, oldwfmt)) ast_log(LOG_WARNING, "Unable to restore channel '%s' to format %s\n", chan->name, ast_getformatname(oldwfmt)); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Stopped music on hold on %s\n", chan->name); } }

static int moh_scan_files (  struct mohclass *  class  )  [static]

Definition at line 769 of file res_musiconhold.c. References ast_log(), mohclass::dir, ext, mohclass::filearray, free, LOG_WARNING, moh_add_file(), and mohclass::total_files. Referenced by init_classes(), and moh_register(). { DIR *files_DIR; struct dirent *files_dirent; char path[PATH_MAX]; char filepath[PATH_MAX]; char *ext; struct stat statbuf; int dirnamelen; int i; files_DIR = opendir(class->dir); if (!files_DIR) { ast_log(LOG_WARNING, "Cannot open dir %s or dir does not exist\n", class->dir); return -1; } for (i = 0; i < class->total_files; i++) free(class->filearray[i]); class->total_files = 0; dirnamelen = strlen(class->dir) + 2; getcwd(path, sizeof(path)); chdir(class->dir); while ((files_dirent = readdir(files_DIR))) { /* 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", class->dir, files_dirent->d_name); if (stat(filepath, &statbuf)) continue; if (!S_ISREG(statbuf.st_mode)) continue; if ((ext = strrchr(filepath, '.'))) { *ext = '\0'; ext++; } /* if the file is present in multiple formats, ensure we only put it into the list once */ for (i = 0; i < class->total_files; i++) if (!strcmp(filepath, class->filearray[i])) break; if (i == class->total_files) { if (moh_add_file(class, filepath)) break; } } closedir(files_DIR); chdir(path); return class->total_files; }

static struct mohdata* mohalloc (  struct mohclass *  cl  )  [static]

Definition at line 639 of file res_musiconhold.c. References ast_calloc, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, AST_LIST_INSERT_HEAD, ast_log(), mohclass::format, free, LOG_WARNING, moh, and mohdata::pipe. Referenced by moh_alloc(). { struct mohdata *moh; long flags; if (!(moh = ast_calloc(1, sizeof(*moh)))) return NULL; if (pipe(moh->pipe)) { ast_log(LOG_WARNING, "Failed to create pipe: %s\n", strerror(errno)); free(moh); return NULL; } /* Make entirely non-blocking */ flags = fcntl(moh->pipe[0], F_GETFL); fcntl(moh->pipe[0], F_SETFL, flags | O_NONBLOCK); flags = fcntl(moh->pipe[1], F_GETFL); fcntl(moh->pipe[1], F_SETFL, flags | O_NONBLOCK); moh->f.frametype = AST_FRAME_VOICE; moh->f.subclass = cl->format; moh->f.offset = AST_FRIENDLY_OFFSET; moh->parent = cl; AST_LIST_INSERT_HEAD(&cl->members, moh, list); return moh; }

static void* monmp3thread (  void *  data  )  [static]

Definition at line 484 of file res_musiconhold.c. References ast_log(), len, LOG_WARNING, moh, and spawn_mp3(). Referenced by moh_register(). { #define MOH_MS_INTERVAL 100 struct mohclass *class = data; struct mohdata *moh; char buf[8192]; short sbuf[8192]; int res, res2; int len; struct timeval tv, tv_tmp; tv.tv_sec = 0; tv.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); pthread_testcancel(); } } if (class->pseudofd > -1) { #ifdef SOLARIS thr_yield(); #endif /* Pause some amount of time */ res = read(class->pseudofd, buf, sizeof(buf)); pthread_testcancel(); } else { long delta; /* Reliable sleep */ tv_tmp = ast_tvnow(); if (ast_tvzero(tv)) tv = tv_tmp; delta = ast_tvdiff_ms(tv_tmp, tv); if (delta < MOH_MS_INTERVAL) { /* too early */ tv = ast_tvadd(tv, 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"); tv = tv_tmp; } res = 8 * MOH_MS_INTERVAL; /* 8 samples per millisecond */ } if (AST_LIST_EMPTY(&class->members)) continue; /* Read mp3 audio */ len = ast_codec_get_len(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) { kill(class->pid, SIGHUP); usleep(100000); kill(class->pid, SIGTERM); usleep(100000); kill(class->pid, SIGKILL); class->pid = 0; } } else { if (option_debug) ast_log(LOG_DEBUG, "Read %d bytes of audio while expecting %d\n", res2, len); } continue; } pthread_testcancel(); AST_LIST_LOCK(&mohclasses); AST_LIST_TRAVERSE(&class->members, moh, list) { /* Write data */ if ((res = write(moh->pipe[1], sbuf, res2)) != res2) { if (option_debug) ast_log(LOG_DEBUG, "Only wrote %d of %d bytes to pipe\n", res, res2); } } AST_LIST_UNLOCK(&mohclasses); } return NULL; }

static int reload (  void   )  [static]

Definition at line 1211 of file res_musiconhold.c. References ast_install_music_functions(), init_classes(), local_ast_moh_cleanup(), local_ast_moh_start(), and local_ast_moh_stop(). { if (init_classes(1)) ast_install_music_functions(local_ast_moh_start, local_ast_moh_stop, local_ast_moh_cleanup); return 0; }

static int spawn_mp3 (  struct mohclass *  class  )  [static]

Definition at line 333 of file res_musiconhold.c. References mohclass::args, ast_log(), ast_opt_high_priority, ast_set_priority(), ast_strlen_zero(), ast_test_flag, mohclass::dir, LOG_WARNING, MAX_MP3S, MOH_CUSTOM, MOH_QUIET, MOH_SINGLE, mohclass::pid, 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; sigset_t signal_set, old_set; if (!strcasecmp(class->dir, "nodir")) { files = 1; } else { dir = opendir(class->dir); if (!dir && !strstr(class->dir,"http://") && !strstr(class->dir,"HTTP://")) { 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 (strstr(class->dir,"http://") || strstr(class->dir,"HTTP://")) { 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 (time(NULL) - class->start < respawn_time) { sleep(respawn_time - (time(NULL) - class->start)); } /* Block signals during the fork() */ sigfillset(&signal_set); pthread_sigmask(SIG_BLOCK, &signal_set, &old_set); time(&class->start); class->pid = fork(); 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) { int x; if (ast_opt_high_priority) ast_set_priority(0); /* Reset ignored signals back to default */ signal(SIGPIPE, SIG_DFL); pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL); close(fds[0]); /* Stdout goes to pipe */ dup2(fds[1], STDOUT_FILENO); /* Close unused file descriptors */ for (x=3;x<8192;x++) { if (-1 != fcntl(x, F_GETFL)) { close(x); } } /* Child */ chdir(class->dir); 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); } ast_log(LOG_WARNING, "Exec failed: %s\n", strerror(errno)); close(fds[1]); _exit(1); } else { /* Parent */ pthread_sigmask(SIG_SETMASK, &old_set, NULL); close(fds[1]); } return fds[0]; }

static int unload_module (  void   )  [static]

Definition at line 1219 of file res_musiconhold.c. { return -1; }

---

Variable Documentation

char* app0 = "MusicOnHold" [static]

Definition at line 75 of file res_musiconhold.c.

char* app1 = "WaitMusicOnHold" [static]

Definition at line 76 of file res_musiconhold.c.

char* app2 = "SetMusicOnHold" [static]

Definition at line 77 of file res_musiconhold.c.

char* app3 = "StartMusicOnHold" [static]

Definition at line 78 of file res_musiconhold.c.

char* app4 = "StopMusicOnHold" [static]

Definition at line 79 of file res_musiconhold.c.

struct ast_cli_entry cli_moh[] [static]

Definition at line 1155 of file res_musiconhold.c. Referenced by load_module().

char* descrip0 [static]

Definition at line 87 of file res_musiconhold.c.

char* descrip1 [static]

Initial value: "WaitMusicOnHold(delay): " "Plays hold music specified number of seconds. Returns 0 when\n" "done, or -1 on hangup. If no hold music is available, the delay will\n" "still occur with no sound.\n" Definition at line 94 of file res_musiconhold.c.

char* descrip2 [static]

Initial value: "SetMusicOnHold(class): " "Sets the default class for music on hold for a given channel. When\n" "music on hold is activated, this class will be used to select which\n" "music is played.\n" Definition at line 99 of file res_musiconhold.c.

char* descrip3 [static]

Initial value: "StartMusicOnHold(class): " "Starts playing music on hold, uses default music class for channel.\n" "Starts playing music specified by class. If omitted, the default\n" "music source for the channel will be used. Always returns 0.\n" Definition at line 104 of file res_musiconhold.c.

char* descrip4 [static]

Initial value: "StopMusicOnHold: " "Stops playing music on hold.\n" Definition at line 109 of file res_musiconhold.c.

struct ast_generator moh_file_stream [static]

Definition at line 326 of file res_musiconhold.c. Referenced by local_ast_moh_start().

struct ast_generator mohgen [static]

Definition at line 739 of file res_musiconhold.c. Referenced by local_ast_moh_start().

int respawn_time = 20 [static]

Definition at line 112 of file res_musiconhold.c.

char* synopsis0 = "Play Music On Hold indefinitely" [static]

Definition at line 81 of file res_musiconhold.c.

char* synopsis1 = "Wait, playing Music On Hold" [static]

Definition at line 82 of file res_musiconhold.c.

char* synopsis2 = "Set default Music On Hold class" [static]

Definition at line 83 of file res_musiconhold.c.

char* synopsis3 = "Play Music On Hold" [static]

Definition at line 84 of file res_musiconhold.c.

char* synopsis4 = "Stop Playing Music On Hold" [static]

Definition at line 85 of file res_musiconhold.c.

---

Asterisk is a trademark for Digium, inc.. | Edvina.net | Asterisk.org | This documentation was generated with Doxygen