app_voicemail.c File Reference

Comedian Mail - Voicemail System. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <time.h>
#include <dirent.h>
#include "asterisk/logger.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/say.h"
#include "asterisk/module.h"
#include "asterisk/adsi.h"
#include "asterisk/app.h"
#include "asterisk/manager.h"
#include "asterisk/dsp.h"
#include "asterisk/localtime.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/stringfields.h"
#include "asterisk/smdi.h"
#include "asterisk/event.h"
#include "asterisk/taskprocessor.h"

Include dependency graph for app_voicemail.c:

Go to the source code of this file.

Data Structures
struct	ast_vm_user
struct	baseio
struct	leave_vm_options
	Options for leaving voicemail with the voicemail() application. More...
struct	mwi_sub
	An MWI subscription. More...
struct	mwi_sub_task
struct	mwi_subs
struct	users
	list of users found in the config file More...
struct	vm_state
struct	vm_zone
struct	zones
Defines
#define	ASTERISK_USERNAME   "asterisk"
#define	BASELINELEN   72
#define	BASEMAXINLINE   256
#define	CHUNKSIZE   65536
#define	COMMAND_TIMEOUT   5000
#define	COPY(a, b, c, d, e, f, g, h)   (copy_plain_file(g,h));
#define	DEFAULT_LISTEN_CONTROL_FORWARD_KEY   "#"
#define	DEFAULT_LISTEN_CONTROL_PAUSE_KEY   "0"
#define	DEFAULT_LISTEN_CONTROL_RESTART_KEY   "2"
#define	DEFAULT_LISTEN_CONTROL_REVERSE_KEY   "*"
#define	DEFAULT_LISTEN_CONTROL_STOP_KEY   "13456789"
#define	DEFAULT_POLL_FREQ   30
#define	DELETE(a, b, c, d)   (vm_delete(c))
#define	DISPOSE(a, b)
#define	ENDL   "\n"
#define	eol   "\r\n"
#define	ERROR_LOCK_PATH   -100
#define	EXISTS(a, b, c, d)   (ast_fileexists(c,NULL,d) > 0)
#define	HVSU_OUTPUT_FORMAT   "%-10s %-5s %-25s %-10s %6s\n"
#define	HVSZ_OUTPUT_FORMAT   "%-15s %-20s %-45s\n"
#define	INTRO   "vm-intro"
#define	MAX_DATETIME_FORMAT   512
#define	MAX_NUM_CID_CONTEXTS   10
#define	MAXMSG   100
#define	MAXMSGLIMIT   9999
#define	MINPASSWORD   0
#define	PWDCHANGE_EXTERNAL   (1 << 2)
#define	PWDCHANGE_INTERNAL   (1 << 1)
#define	RENAME(a, b, c, d, e, f, g, h)   (rename_file(g,h));
#define	RETRIEVE(a, b, c, d)
#define	SENDMAIL   "/usr/sbin/sendmail -t"
#define	SMDI_MWI_WAIT_TIMEOUT   1000
#define	STORE(a, b, c, d, e, f, g, h, i, j)
#define	tdesc   "Comedian Mail (Voicemail System)"
#define	VALID_DTMF   "1234567890*#"
#define	VM_ALLOCED   (1 << 13)
#define	VM_ATTACH   (1 << 11)
#define	VM_DELETE   (1 << 12)
#define	VM_DIRECFORWARD   (1 << 10)
#define	VM_ENVELOPE   (1 << 4)
#define	VM_FORCEGREET   (1 << 8)
#define	VM_FORCENAME   (1 << 7)
#define	VM_FWDURGAUTO   (1 << 18)
#define	VM_MESSAGEWRAP   (1 << 17)
#define	VM_MOVEHEARD   (1 << 16)
#define	VM_OPERATOR   (1 << 1)
#define	VM_PBXSKIP   (1 << 9)
#define	VM_REVIEW   (1 << 0)
#define	VM_SAYCID   (1 << 2)
#define	VM_SAYDURATION   (1 << 5)
#define	VM_SEARCH   (1 << 14)
#define	VM_SKIPAFTERCMD   (1 << 6)
#define	VM_SVMAIL   (1 << 3)
#define	VM_TEMPGREETWARN   (1 << 15)
#define	VMSTATE_MAX_MSG_ARRAY   256
#define	VOICEMAIL_CONFIG   "voicemail.conf"
#define	VOICEMAIL_DIR_MODE   0777
#define	VOICEMAIL_FILE_MODE   0666
Enumerations
enum	vm_box {   NEW_FOLDER, OLD_FOLDER, WORK_FOLDER, FAMILY_FOLDER,   FRIENDS_FOLDER, GREETINGS_FOLDER }
enum	vm_option_args { OPT_ARG_RECORDGAIN = 0, OPT_ARG_PLAYFOLDER = 1, OPT_ARG_DTMFEXIT = 2, OPT_ARG_ARRAY_SIZE = 3 }
enum	vm_option_flags {   OPT_SILENT = (1 << 0), OPT_BUSY_GREETING = (1 << 1), OPT_UNAVAIL_GREETING = (1 << 2), OPT_RECORDGAIN = (1 << 3),   OPT_PREPEND_MAILBOX = (1 << 4), OPT_AUTOPLAY = (1 << 6), OPT_DTMFEXIT = (1 << 7), OPT_MESSAGE_Urgent = (1 << 8),   OPT_MESSAGE_PRIORITY = (1 << 9) }
enum	vm_passwordlocation { OPT_PWLOC_VOICEMAILCONF = 0, OPT_PWLOC_SPOOLDIR = 1, OPT_PWLOC_USERSCONF = 2 }
Functions
static void	__fini_mwi_subs (void)
static int	__has_voicemail (const char *context, const char *mailbox, const char *folder, int shortcircuit)
static void	__init_mwi_subs (void)
static void	__reg_module (void)
static void	__unreg_module (void)
static int	acf_mailbox_exists (struct ast_channel *chan, const char *cmd, char *args, char *buf, size_t len)
static int	add_email_attachment (FILE *p, struct ast_vm_user *vmu, char *format, char *attach, char *greeting_attachment, char *mailbox, char *bound, char *filename, int last, int msgnum)
static void	adsi_begin (struct ast_channel *chan, int *useadsi)
static void	adsi_delete (struct ast_channel *chan, struct vm_state *vms)
static void	adsi_folders (struct ast_channel *chan, int start, char *label)
static void	adsi_goodbye (struct ast_channel *chan)
static int	adsi_load_vmail (struct ast_channel *chan, int *useadsi)
static void	adsi_login (struct ast_channel *chan)
static int	adsi_logo (unsigned char *buf)
static void	adsi_message (struct ast_channel *chan, struct vm_state *vms)
static void	adsi_password (struct ast_channel *chan)
static void	adsi_status (struct ast_channel *chan, struct vm_state *vms)
static void	adsi_status2 (struct ast_channel *chan, struct vm_state *vms)
static int	advanced_options (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int msg, int option, signed char record_gain)
	The advanced options within a message.
static int	append_mailbox (const char *context, const char *box, const char *data)
static void	apply_option (struct ast_vm_user *vmu, const char *var, const char *value)
	Sets a a specific property value.
static void	apply_options (struct ast_vm_user *vmu, const char *options)
	Destructively Parse options and apply.
static void	apply_options_full (struct ast_vm_user *retval, struct ast_variable *var)
	Loads the options specific to a voicemail user.
static const char *	ast_str_encode_mime (struct ast_str **end, ssize_t maxlen, const char *start, size_t preamble, size_t postamble)
	Encode a string according to the MIME rules for encoding strings that are not 7-bit clean or contain control characters.
static const char *	ast_str_quote (struct ast_str **buf, ssize_t maxlen, const char *from)
	Wraps a character sequence in double quotes, escaping occurences of quotes within the string.
static int	base_encode (char *filename, FILE *so)
	Performs a base 64 encode algorithm on the contents of a File.
static int	change_password_realtime (struct ast_vm_user *vmu, const char *password)
	Performs a change of the voicemail passowrd in the realtime engine.
static int	check_mime (const char *str)
	Check if the string would need encoding within the MIME standard, to avoid confusing certain mail software that expects messages to be 7-bit clean.
static int	check_password (struct ast_vm_user *vmu, char *password)
	Check that password meets minimum required length.
static int	close_mailbox (struct vm_state *vms, struct ast_vm_user *vmu)
static char *	complete_voicemail_show_users (const char *line, const char *word, int pos, int state)
static int	copy (char *infile, char *outfile)
	Utility function to copy a file.
static int	copy_message (struct ast_channel *chan, struct ast_vm_user *vmu, int imbox, int msgnum, long duration, struct ast_vm_user *recip, char *fmt, char *dir, const char *flag)
	Copies a message from one mailbox to another.
static void	copy_plain_file (char *frompath, char *topath)
	Copies a voicemail information (envelope) file.
static int	count_messages (struct ast_vm_user *vmu, char *dir)
	Find all .txt files - even if they are not in sequence from 0000.
static int	create_dirpath (char *dest, int len, const char *context, const char *ext, const char *folder)
	basically mkdir -p $dest/$context/$ext/$folder
static int	dialout (struct ast_channel *chan, struct ast_vm_user *vmu, char *num, char *outgoing_context)
static struct ast_vm_user *	find_or_create (const char *context, const char *box)
static struct ast_vm_user *	find_user (struct ast_vm_user *ivm, const char *context, const char *mailbox)
	Finds a voicemail user from the users file or the realtime engine.
static struct ast_vm_user *	find_user_realtime (struct ast_vm_user *ivm, const char *context, const char *mailbox)
	Finds a voicemail user from the realtime engine.
static int	forward_message (struct ast_channel *chan, char *context, struct vm_state *vms, struct ast_vm_user *sender, char *fmt, int is_new_message, signed char record_gain, int urgent)
	Sends a voicemail message to a mailbox recipient.
static void	free_user (struct ast_vm_user *vmu)
static void	free_vm_users (void)
	Free the users structure.
static void	free_vm_zones (void)
	Free the zones structure.
static void	free_zone (struct vm_zone *z)
static int	get_date (char *s, int len)
	Gets the current date and time, as formatted string.
static int	get_folder (struct ast_channel *chan, int start)
	get_folder: Folder menu Plays "press 1 for INBOX messages" etc. Should possibly be internationalized
static int	get_folder2 (struct ast_channel *chan, char *fn, int start)
	plays a prompt and waits for a keypress.
static int	get_folder_by_name (const char *name)
static int	handle_subscribe (void *datap)
static int	handle_unsubscribe (void *datap)
static char *	handle_voicemail_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Reload voicemail configuration from the CLI.
static char *	handle_voicemail_show_users (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Show a list of voicemail users in the CLI.
static char *	handle_voicemail_show_zones (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	Show a list of voicemail zones in the CLI.
static int	has_voicemail (const char *mailbox, const char *folder)
	Determines if the given folder has messages.
static int	inboxcount (const char *mailbox, int *newmsgs, int *oldmsgs)
static int	inboxcount2 (const char *mailbox, int *urgentmsgs, int *newmsgs, int *oldmsgs)
static int	inbuf (struct baseio *bio, FILE *fi)
	utility used by inchar(), for base_encode()
static int	inchar (struct baseio *bio, FILE *fi)
	utility used by base_encode()
static int	invent_message (struct ast_channel *chan, char *context, char *ext, int busy, char *ecodes)
static int	is_valid_dtmf (const char *key)
	Determines if a DTMF key entered is valid.
static int	last_message_index (struct ast_vm_user *vmu, char *dir)
	Determines the highest message number in use for a given user and mailbox folder.
static int	leave_voicemail (struct ast_channel *chan, char *ext, struct leave_vm_options *options)
	Prompts the user and records a voicemail to a mailbox.
static int	load_config (int reload)
static int	load_module (void)
static int	make_dir (char *dest, int len, const char *context, const char *ext, const char *folder)
	Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
static void	make_email_file (FILE *p, char *srcemail, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, char *attach, char *attach2, char *format, int duration, int attach_user_voicemail, struct ast_channel *chan, const char *category, int imap, const char *flag)
	Creates the email file to be sent to indicate a new voicemail exists for a user.
static int	make_file (char *dest, const int len, const char *dir, const int num)
	Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
static int	manager_list_voicemail_users (struct mansession *s, const struct message *m)
	Manager list voicemail users command.
static void *	mb_poll_thread (void *data)
static const char *	mbox (int id)
static int	messagecount (const char *context, const char *mailbox, const char *folder)
static void	mwi_sub_destroy (struct mwi_sub *mwi_sub)
static void	mwi_sub_event_cb (const struct ast_event *event, void *userdata)
static void	mwi_unsub_event_cb (const struct ast_event *event, void *userdata)
static int	notify_new_message (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int msgnum, long duration, char *fmt, char *cidnum, char *cidname, const char *flag)
	Sends email notification that a user has a new voicemail waiting for them.
static int	ochar (struct baseio *bio, int c, FILE *so)
	utility used by base_encode()
static int	open_mailbox (struct vm_state *vms, struct ast_vm_user *vmu, int box)
static int	play_message (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms)
static int	play_message_callerid (struct ast_channel *chan, struct vm_state *vms, char *cid, const char *context, int callback)
static int	play_message_category (struct ast_channel *chan, const char *category)
static int	play_message_datetime (struct ast_channel *chan, struct ast_vm_user *vmu, const char *origtime, const char *filename)
static int	play_message_duration (struct ast_channel *chan, struct vm_state *vms, const char *duration, int minduration)
static int	play_record_review (struct ast_channel *chan, char *playfile, char *recordfile, int maxtime, char *fmt, int outsidecaller, struct ast_vm_user *vmu, int *duration, const char *unlockdir, signed char record_gain, struct vm_state *vms, char *flag)
static void	poll_subscribed_mailbox (struct mwi_sub *mwi_sub)
static void	poll_subscribed_mailboxes (void)
static void	populate_defaults (struct ast_vm_user *vmu)
	Sets default voicemail system options to a voicemail user.
static void	prep_email_sub_vars (struct ast_channel *ast, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, char *dur, char *date, const char *category, const char *flag)
static void	queue_mwi_event (const char *box, int urgent, int new, int old)
static void	read_password_from_file (const char *secretfn, char *password, int passwordlen)
static int	reload (void)
static void	rename_file (char *sfn, char *dfn)
	Renames a message in a mailbox folder.
static int	reset_user_pw (const char *context, const char *mailbox, const char *newpass)
	Resets a user password to a specified password.
static void	run_externnotify (char *context, char *extension, const char *flag)
static int	save_to_folder (struct ast_vm_user *vmu, struct vm_state *vms, int msg, int box)
static int	say_and_wait (struct ast_channel *chan, int num, const char *language)
static int	sayname (struct ast_channel *chan, const char *mailbox, const char *context)
static int	sendmail (char *srcemail, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, char *attach, char *attach2, char *format, int duration, int attach_user_voicemail, struct ast_channel *chan, const char *category, const char *flag)
static int	sendpage (char *srcemail, char *pager, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, int duration, struct ast_vm_user *vmu, const char *category, const char *flag)
static char *	show_users_realtime (int fd, const char *context)
static void	start_poll_thread (void)
static void	stop_poll_thread (void)
static char *	strip_control (const char *input, char *buf, size_t buflen)
static const char *	substitute_escapes (const char *value)
static int	unload_module (void)
static int	vm_authenticate (struct ast_channel *chan, char *mailbox, int mailbox_size, struct ast_vm_user *res_vmu, const char *context, const char *prefix, int skipuser, int max_logins, int silent)
static int	vm_box_exists (struct ast_channel *chan, const char *data)
static int	vm_browse_messages (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Top level method to invoke the language variant vm_browse_messages_XX function.
static int	vm_browse_messages_en (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Default English syntax for 'You have N messages' greeting.
static int	vm_browse_messages_es (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Spanish syntax for 'You have N messages' greeting.
static int	vm_browse_messages_gr (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Greek syntax for 'You have N messages' greeting.
static int	vm_browse_messages_he (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
static int	vm_browse_messages_it (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Italian syntax for 'You have N messages' greeting.
static int	vm_browse_messages_pt (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Portuguese syntax for 'You have N messages' greeting.
static int	vm_browse_messages_zh (struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu)
	Chinese (Taiwan)syntax for 'You have N messages' greeting.
static void	vm_change_password (struct ast_vm_user *vmu, const char *newpassword)
	The handler for the change password option.
static void	vm_change_password_shell (struct ast_vm_user *vmu, char *newpassword)
static char *	vm_check_password_shell (char *command, char *buf, size_t len)
static int	vm_delete (char *file)
	Removes the voicemail sound and information file.
static int	vm_exec (struct ast_channel *chan, const char *data)
static int	vm_execmain (struct ast_channel *chan, const char *data)
static int	vm_forwardoptions (struct ast_channel *chan, struct ast_vm_user *vmu, char *curdir, int curmsg, char *vm_fmts, char *context, signed char record_gain, long *duration, struct vm_state *vms, char *flag)
	presents the option to prepend to an existing message when forwarding it.
static int	vm_instructions (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int skipadvanced, int in_urgent)
static int	vm_instructions_en (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int skipadvanced, int in_urgent)
static int	vm_instructions_zh (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int skipadvanced, int in_urgent)
static int	vm_intro (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms)
static int	vm_intro_cz (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_de (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_en (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_es (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_fr (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_gr (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_he (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_it (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_multilang (struct ast_channel *chan, struct vm_state *vms, const char message_gender[])
static int	vm_intro_nl (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_no (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_pl (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_pt (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_pt_BR (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_se (struct ast_channel *chan, struct vm_state *vms)
static int	vm_intro_zh (struct ast_channel *chan, struct vm_state *vms)
static int	vm_lock_path (const char *path)
	Lock file path only return failure if ast_lock_path returns 'timeout', not if the path does not exist or any other reason.
static FILE *	vm_mkftemp (char *template)
static int	vm_newuser (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, char *fmtc, signed char record_gain)
static int	vm_options (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, char *fmtc, signed char record_gain)
static int	vm_play_folder_name (struct ast_channel *chan, char *mbox)
static int	vm_play_folder_name_gr (struct ast_channel *chan, char *box)
static int	vm_play_folder_name_pl (struct ast_channel *chan, char *box)
static int	vm_play_folder_name_ua (struct ast_channel *chan, char *box)
static int	vm_tempgreeting (struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, char *fmtc, signed char record_gain)
	The handler for 'record a temporary greeting'.
static int	vmauthenticate (struct ast_channel *chan, const char *data)
static struct ast_tm *	vmu_tm (const struct ast_vm_user *vmu, struct ast_tm *tm)
	fill in *tm for current time according to the proper timezone, if any.
static int	wait_file (struct ast_channel *chan, struct vm_state *vms, char *file)
static int	wait_file2 (struct ast_channel *chan, struct vm_state *vms, char *file)
static int	write_password_to_file (const char *secretfn, const char *password)
Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Comedian Mail (Voicemail System)" , .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, .load = load_module, .unload = unload_module, .reload = reload, }
static char *	addesc = "Comedian Mail"
static unsigned char	adsifdn [4] = "\x00\x00\x00\x0F"
static unsigned char	adsisec [4] = "\x9B\xDB\xF7\xAC"
static int	adsiver = 1
static char *	app = "VoiceMail"
static char *	app2 = "VoiceMailMain"
static char *	app3 = "MailboxExists"
static char *	app4 = "VMAuthenticate"
static struct ast_module_info *	ast_module_info = &__mod_info
static char	callcontext [AST_MAX_CONTEXT] = ""
static char	charset [32] = "ISO-8859-1"
static char	cidinternalcontexts [MAX_NUM_CID_CONTEXTS][64]
static struct ast_cli_entry	cli_voicemail []
static char	dialcontext [AST_MAX_CONTEXT] = ""
static char *	emailbody = NULL
static char	emaildateformat [32] = "%A, %B %d, %Y at %r"
static char *	emailsubject = NULL
static char	exitcontext [AST_MAX_CONTEXT] = ""
static char	ext_pass_check_cmd [128]
static char	ext_pass_cmd [128]
static char	externnotify [160]
static char	fromstring [100]
static struct ast_flags	globalflags = {0}
static char	listen_control_forward_key [12]
static char	listen_control_pause_key [12]
static char	listen_control_restart_key [12]
static char	listen_control_reverse_key [12]
static char	listen_control_stop_key [12]
static struct ast_custom_function	mailbox_exists_acf
static const char *const	mailbox_folders []
static char	mailcmd [160]
static int	maxdeletedmsg
static int	maxgreet
static int	maxlogins
static int	maxmsg
static int	maxsilence
static int	minpassword
static struct ast_event_sub *	mwi_sub_sub
static struct ast_taskprocessor *	mwi_subscription_tps
static struct ast_event_sub *	mwi_unsub_sub
static int	my_umask
static char *	pagerbody = NULL
static char	pagerfromstring [100]
static char *	pagersubject = NULL
static int	passwordlocation
static ast_cond_t	poll_cond = PTHREAD_COND_INITIALIZER
static unsigned int	poll_freq
static ast_mutex_t	poll_lock = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER )
static unsigned int	poll_mailboxes
static pthread_t	poll_thread = AST_PTHREADT_NULL
static unsigned char	poll_thread_run
static int	pwdchange = PWDCHANGE_INTERNAL
static int	saydurationminfo
static char	serveremail [80]
static int	silencethreshold = 128
static int	skipms
static struct ast_smdi_interface *	smdi_iface = NULL
static char	userscontext [AST_MAX_EXTENSION] = "default"
static struct ast_app_option	vm_app_options [128] = { [ 's' ] = { .flag = OPT_SILENT }, [ 'b' ] = { .flag = OPT_BUSY_GREETING }, [ 'u' ] = { .flag = OPT_UNAVAIL_GREETING }, [ 'g' ] = { .flag = OPT_RECORDGAIN , .arg_index = OPT_ARG_RECORDGAIN + 1 }, [ 'd' ] = { .flag = OPT_DTMFEXIT , .arg_index = OPT_ARG_DTMFEXIT + 1 }, [ 'p' ] = { .flag = OPT_PREPEND_MAILBOX }, [ 'a' ] = { .flag = OPT_AUTOPLAY , .arg_index = OPT_ARG_PLAYFOLDER + 1 }, [ 'U' ] = { .flag = OPT_MESSAGE_Urgent }, [ 'P' ] = { .flag = OPT_MESSAGE_PRIORITY }}
static char	vm_invalid_password [80] = "vm-invalid-password"
static char	vm_mismatch [80] = "vm-mismatch"
static char	vm_newpassword [80] = "vm-newpassword"
static char	vm_passchanged [80] = "vm-passchanged"
static char	vm_password [80] = "vm-password"
static char	vm_pls_try_again [80] = "vm-pls-try-again"
static char	vm_reenterpassword [80] = "vm-reenterpassword"
static char	VM_SPOOL_DIR [PATH_MAX]
static char	vmfmts [80]
static int	vmmaxsecs
static int	vmminsecs
static double	volgain
static char	zonetag [80]

---

Detailed Description

Comedian Mail - Voicemail System.

Author:

Mark Spencer <markster@digium.com>

ExtRef:

unixODBC (http://www.unixodbc.org/)

ExtRef:

A source distribution of University of Washington's IMAP c-client (http://www.washington.edu/imap/)

See also

• VoiceMail configuration

Note:

For information about voicemail IMAP storage, read doc/imapstorage.txt

This module requires res_adsi to load. This needs to be optional during compilation.

This file is now almost impossible to work with, due to all #ifdefs. Feels like the database code before realtime. Someone - please come up with a plan to clean this up.

Definition in file app_voicemail.c.

---

Define Documentation

#define ASTERISK_USERNAME   "asterisk"

Definition at line 393 of file app_voicemail.c.

#define BASELINELEN   72

Definition at line 416 of file app_voicemail.c.

Referenced by ochar().

#define BASEMAXINLINE   256

Definition at line 417 of file app_voicemail.c.

Referenced by base_encode(), and inbuf().

#define CHUNKSIZE   65536

Definition at line 390 of file app_voicemail.c.

#define COMMAND_TIMEOUT   5000

Definition at line 386 of file app_voicemail.c.

#define COPY	(	a,
		b,
		c,
		d,
		e,
		f,
		g,
		h		)	(copy_plain_file(g,h));

Definition at line 690 of file app_voicemail.c.

Referenced by copy_message(), and save_to_folder().

#define DEFAULT_LISTEN_CONTROL_FORWARD_KEY   "#"

Definition at line 398 of file app_voicemail.c.

Referenced by load_config().

#define DEFAULT_LISTEN_CONTROL_PAUSE_KEY   "0"

Definition at line 400 of file app_voicemail.c.

Referenced by load_config().

#define DEFAULT_LISTEN_CONTROL_RESTART_KEY   "2"

Definition at line 401 of file app_voicemail.c.

Referenced by load_config().

#define DEFAULT_LISTEN_CONTROL_REVERSE_KEY   "*"

Definition at line 399 of file app_voicemail.c.

Referenced by load_config().

#define DEFAULT_LISTEN_CONTROL_STOP_KEY   "13456789"

Definition at line 402 of file app_voicemail.c.

Referenced by load_config().

#define DEFAULT_POLL_FREQ   30

By default, poll every 30 seconds

Definition at line 757 of file app_voicemail.c.

Referenced by load_config().

#define DELETE	(	a,
		b,
		c,
		d		)	(vm_delete(c))

Definition at line 691 of file app_voicemail.c.

Referenced by close_mailbox(), notify_new_message(), play_record_review(), and vm_tempgreeting().

#define DISPOSE	(	a,
		b		)

Definition at line 686 of file app_voicemail.c.

Referenced by advanced_options(), forward_message(), invent_message(), leave_voicemail(), notify_new_message(), play_message(), play_record_review(), sayname(), vm_intro(), vm_options(), and vm_tempgreeting().

#define ENDL   "\n"

Referenced by add_email_attachment(), make_email_file(), and sendpage().

#define eol   "\r\n"

Definition at line 418 of file app_voicemail.c.

Referenced by base_encode(), and ochar().

#define ERROR_LOCK_PATH   -100

Definition at line 442 of file app_voicemail.c.

#define EXISTS	(	a,
		b,
		c,
		d		)	(ast_fileexists(c,NULL,d) > 0)

Definition at line 688 of file app_voicemail.c.

Referenced by close_mailbox(), copy_message(), and save_to_folder().

#define HVSU_OUTPUT_FORMAT   "%-10s %-5s %-25s %-10s %6s\n"

Referenced by handle_voicemail_show_users().

#define HVSZ_OUTPUT_FORMAT   "%-15s %-20s %-45s\n"

Referenced by handle_voicemail_show_zones().

#define INTRO   "vm-intro"

Definition at line 409 of file app_voicemail.c.

Referenced by leave_voicemail(), play_record_review(), and vm_forwardoptions().

#define MAX_DATETIME_FORMAT   512

Definition at line 420 of file app_voicemail.c.

#define MAX_NUM_CID_CONTEXTS   10

Definition at line 421 of file app_voicemail.c.

#define MAXMSG   100

Definition at line 411 of file app_voicemail.c.

Referenced by apply_option(), and load_config().

#define MAXMSGLIMIT   9999

Definition at line 412 of file app_voicemail.c.

Referenced by apply_option(), last_message_index(), and load_config().

#define MINPASSWORD   0

Default minimum mailbox password length

Definition at line 414 of file app_voicemail.c.

Referenced by load_config().

#define PWDCHANGE_EXTERNAL   (1 << 2)

Definition at line 703 of file app_voicemail.c.

Referenced by load_config(), vm_newuser(), and vm_options().

#define PWDCHANGE_INTERNAL   (1 << 1)

Definition at line 702 of file app_voicemail.c.

Referenced by load_config(), vm_newuser(), and vm_options().

#define RENAME	(	a,
		b,
		c,
		d,
		e,
		f,
		g,
		h		)	(rename_file(g,h));

Definition at line 689 of file app_voicemail.c.

Referenced by close_mailbox(), leave_voicemail(), and save_to_folder().

#define RETRIEVE	(	a,
		b,
		c,
		d		)

Definition at line 685 of file app_voicemail.c.

Referenced by advanced_options(), forward_message(), invent_message(), leave_voicemail(), notify_new_message(), play_message(), sayname(), vm_intro(), vm_options(), and vm_tempgreeting().

#define SENDMAIL   "/usr/sbin/sendmail -t"

Definition at line 407 of file app_voicemail.c.

#define SMDI_MWI_WAIT_TIMEOUT   1000

Definition at line 384 of file app_voicemail.c.

Referenced by run_externnotify().

#define STORE	(	a,
		b,
		c,
		d,
		e,
		f,
		g,
		h,
		i,
		j		)

Definition at line 687 of file app_voicemail.c.

Referenced by copy_message(), forward_message(), leave_voicemail(), and play_record_review().

#define tdesc   "Comedian Mail (Voicemail System)"

Definition at line 712 of file app_voicemail.c.

#define VALID_DTMF   "1234567890*#"

Definition at line 403 of file app_voicemail.c.

Referenced by is_valid_dtmf().

#define VM_ALLOCED   (1 << 13)

Structure was malloc'ed, instead of placed in a return (usually static) buffer

Definition at line 436 of file app_voicemail.c.

Referenced by find_user(), find_user_realtime(), free_user(), and free_vm_users().

#define VM_ATTACH   (1 << 11)

Attach message to voicemail notifications?

Definition at line 434 of file app_voicemail.c.

Referenced by apply_option(), forward_message(), load_config(), manager_list_voicemail_users(), notify_new_message(), and sendmail().

#define VM_DELETE   (1 << 12)

Delete message after sending notification

Definition at line 435 of file app_voicemail.c.

Referenced by apply_option(), manager_list_voicemail_users(), and notify_new_message().

#define VM_DIRECFORWARD   (1 << 10)

Permit caller to use the Directory app for selecting to which mailbox to forward a VM

Definition at line 433 of file app_voicemail.c.

Referenced by forward_message(), and load_config().

#define VM_ENVELOPE   (1 << 4)

Play the envelope information (who-from, time received, etc.)

Definition at line 427 of file app_voicemail.c.

Referenced by apply_option(), load_config(), manager_list_voicemail_users(), and play_message().

#define VM_FORCEGREET   (1 << 8)

Have new users record their greetings

Definition at line 431 of file app_voicemail.c.

Referenced by apply_option(), load_config(), vm_execmain(), and vm_newuser().

#define VM_FORCENAME   (1 << 7)

Have new users record their name

Definition at line 430 of file app_voicemail.c.

Referenced by apply_option(), load_config(), vm_execmain(), and vm_newuser().

#define VM_FWDURGAUTO   (1 << 18)

Autoset of Urgent flag on forwarded Urgent messages set globally

Definition at line 441 of file app_voicemail.c.

Referenced by forward_message(), and load_config().

#define VM_MESSAGEWRAP   (1 << 17)

Wrap around from the last message to the first, and vice-versa

Definition at line 440 of file app_voicemail.c.

Referenced by apply_option(), load_config(), vm_execmain(), and vm_instructions_en().

#define VM_MOVEHEARD   (1 << 16)

Move a "heard" message to Old after listening to it

Definition at line 439 of file app_voicemail.c.

Referenced by apply_option(), close_mailbox(), and load_config().

#define VM_OPERATOR   (1 << 1)

Allow 0 to be pressed to go to 'o' extension

Definition at line 424 of file app_voicemail.c.

Referenced by apply_option(), leave_voicemail(), load_config(), manager_list_voicemail_users(), and play_record_review().

#define VM_PBXSKIP   (1 << 9)

Skip the [PBX] preamble in the Subject line of emails

Definition at line 432 of file app_voicemail.c.

Referenced by load_config(), and make_email_file().

#define VM_REVIEW   (1 << 0)

After recording, permit the caller to review the recording before saving

Definition at line 423 of file app_voicemail.c.

Referenced by apply_option(), load_config(), manager_list_voicemail_users(), and play_record_review().

#define VM_SAYCID   (1 << 2)

Repeat the CallerID info during envelope playback

Definition at line 425 of file app_voicemail.c.

Referenced by apply_option(), load_config(), manager_list_voicemail_users(), and play_message().

#define VM_SAYDURATION   (1 << 5)

Play the length of the message during envelope playback

Definition at line 428 of file app_voicemail.c.

Referenced by apply_option(), load_config(), and play_message().

#define VM_SEARCH   (1 << 14)

Search all contexts for a matching mailbox

Definition at line 437 of file app_voicemail.c.

Referenced by find_or_create(), find_user(), find_user_realtime(), and load_config().

#define VM_SKIPAFTERCMD   (1 << 6)

After deletion, assume caller wants to go to the next message

Definition at line 429 of file app_voicemail.c.

Referenced by load_config(), and vm_execmain().

#define VM_SVMAIL   (1 << 3)

Allow the user to compose a new VM from within VoicemailMain

Definition at line 426 of file app_voicemail.c.

Referenced by apply_option(), load_config(), and vm_execmain().

#define VM_TEMPGREETWARN   (1 << 15)

Remind user tempgreeting is set

Definition at line 438 of file app_voicemail.c.

Referenced by apply_option(), load_config(), and vm_intro().

#define VMSTATE_MAX_MSG_ARRAY   256

Definition at line 629 of file app_voicemail.c.

#define VOICEMAIL_CONFIG   "voicemail.conf"

Definition at line 392 of file app_voicemail.c.

#define VOICEMAIL_DIR_MODE   0777

Definition at line 388 of file app_voicemail.c.

#define VOICEMAIL_FILE_MODE   0666

Definition at line 389 of file app_voicemail.c.

Referenced by add_email_attachment(), copy(), leave_voicemail(), and vm_mkftemp().

---

Enumeration Type Documentation

enum vm_box

Enumerator:

NEW_FOLDER
OLD_FOLDER
WORK_FOLDER
FAMILY_FOLDER
FRIENDS_FOLDER
GREETINGS_FOLDER

Definition at line 445 of file app_voicemail.c.

            {
   NEW_FOLDER,
   OLD_FOLDER,
   WORK_FOLDER,
   FAMILY_FOLDER,
   FRIENDS_FOLDER,
   GREETINGS_FOLDER
};

enum vm_option_args

Enumerator:

OPT_ARG_RECORDGAIN
OPT_ARG_PLAYFOLDER
OPT_ARG_DTMFEXIT
OPT_ARG_ARRAY_SIZE

Definition at line 466 of file app_voicemail.c.

                    {
   OPT_ARG_RECORDGAIN = 0,
   OPT_ARG_PLAYFOLDER = 1,
   OPT_ARG_DTMFEXIT   = 2,
   /* This *must* be the last value in this enum! */
   OPT_ARG_ARRAY_SIZE = 3,
};

enum vm_option_flags

Enumerator:

OPT_SILENT
OPT_BUSY_GREETING
OPT_UNAVAIL_GREETING
OPT_RECORDGAIN
OPT_PREPEND_MAILBOX
OPT_AUTOPLAY
OPT_DTMFEXIT
OPT_MESSAGE_Urgent
OPT_MESSAGE_PRIORITY

Definition at line 454 of file app_voicemail.c.

                     {
   OPT_SILENT =           (1 << 0),
   OPT_BUSY_GREETING =    (1 << 1),
   OPT_UNAVAIL_GREETING = (1 << 2),
   OPT_RECORDGAIN =       (1 << 3),
   OPT_PREPEND_MAILBOX =  (1 << 4),
   OPT_AUTOPLAY =         (1 << 6),
   OPT_DTMFEXIT =         (1 << 7),
   OPT_MESSAGE_Urgent =   (1 << 8),
   OPT_MESSAGE_PRIORITY = (1 << 9)
};

enum vm_passwordlocation

Enumerator:

OPT_PWLOC_VOICEMAILCONF
OPT_PWLOC_SPOOLDIR
OPT_PWLOC_USERSCONF

Definition at line 474 of file app_voicemail.c.

                         {
   OPT_PWLOC_VOICEMAILCONF = 0,
   OPT_PWLOC_SPOOLDIR      = 1,
   OPT_PWLOC_USERSCONF     = 2,
};

---

Function Documentation

static void __fini_mwi_subs

(

void

)

[static]

Definition at line 793 of file app_voicemail.c.

{0};

static int __has_voicemail	(	const char *	context,
		const char *	mailbox,
		const char *	folder,
		int	shortcircuit
	)			[static]

Definition at line 4991 of file app_voicemail.c.

References ast_strlen_zero().

Referenced by has_voicemail(), inboxcount2(), and messagecount().

{
   DIR *dir;
   struct dirent *de;
   char fn[256];
   int ret = 0;

   /* If no mailbox, return immediately */
   if (ast_strlen_zero(mailbox))
      return 0;

   if (ast_strlen_zero(folder))
      folder = "INBOX";
   if (ast_strlen_zero(context))
      context = "default";

   snprintf(fn, sizeof(fn), "%s%s/%s/%s", VM_SPOOL_DIR, context, mailbox, folder);

   if (!(dir = opendir(fn)))
      return 0;

   while ((de = readdir(dir))) {
      if (!strncasecmp(de->d_name, "msg", 3)) {
         if (shortcircuit) {
            ret = 1;
            break;
         } else if (!strncasecmp(de->d_name + 8, "txt", 3)) {
            if (shortcircuit) return 1;
            ret++;
         }
      }
   }

   closedir(dir);

   /* If we are checking INBOX, we should check Urgent as well */
   if (strcmp(folder, "INBOX") == 0) {
      return (ret + __has_voicemail(context, mailbox, "Urgent", shortcircuit));
   } else {
      return ret;
   }
}

static void __init_mwi_subs

(

void

)

[static]

Definition at line 793 of file app_voicemail.c.

{0};

static void __reg_module

(

void

)

[static]

Definition at line 11897 of file app_voicemail.c.

static void __unreg_module

(

void

)

[static]

Definition at line 11897 of file app_voicemail.c.

static int acf_mailbox_exists	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	args,
		char *	buf,
		size_t	len
	)			[static]

Definition at line 9992 of file app_voicemail.c.

References AST_APP_ARG, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_log(), AST_NONSTANDARD_APP_ARGS, ast_strlen_zero(), find_user(), LOG_ERROR, and mbox().

{
   struct ast_vm_user svm;
   AST_DECLARE_APP_ARGS(arg,
      AST_APP_ARG(mbox);
      AST_APP_ARG(context);
   );

   AST_NONSTANDARD_APP_ARGS(arg, args, '@');

   if (ast_strlen_zero(arg.mbox)) {
      ast_log(LOG_ERROR, "MAILBOX_EXISTS requires an argument (<mailbox>[@<context>])\n");
      return -1;
   }

   ast_copy_string(buf, find_user(&svm, ast_strlen_zero(arg.context) ? "default" : arg.context, arg.mbox) ? "1" : "0", len);
   return 0;
}

static int add_email_attachment	(	FILE *	p,
		struct ast_vm_user *	vmu,
		char *	format,
		char *	attach,
		char *	greeting_attachment,
		char *	mailbox,
		char *	bound,
		char *	filename,
		int	last,
		int	msgnum
	)			[static]

Definition at line 4424 of file app_voicemail.c.

References ast_debug, ast_log(), ast_safe_system(), base_encode(), ast_vm_user::context, create_dirpath(), ENDL, LOG_WARNING, ast_vm_user::mailbox, VOICEMAIL_FILE_MODE, and ast_vm_user::volgain.

Referenced by make_email_file().

{
   char tmpdir[256], newtmp[256];
   char fname[256];
   char tmpcmd[256];
   int tmpfd = -1;

   /* Eww. We want formats to tell us their own MIME type */
   char *ctype = (!strcasecmp(format, "ogg")) ? "application/" : "audio/x-";

   if (vmu->volgain < -.001 || vmu->volgain > .001) {
      create_dirpath(tmpdir, sizeof(tmpdir), vmu->context, vmu->mailbox, "tmp");
      snprintf(newtmp, sizeof(newtmp), "%s/XXXXXX", tmpdir);
      tmpfd = mkstemp(newtmp);
      chmod(newtmp, VOICEMAIL_FILE_MODE & ~my_umask);
      ast_debug(3, "newtmp: %s\n", newtmp);
      if (tmpfd > -1) {
         int soxstatus;
         snprintf(tmpcmd, sizeof(tmpcmd), "sox -v %.4f %s.%s %s.%s", vmu->volgain, attach, format, newtmp, format);
         if ((soxstatus = ast_safe_system(tmpcmd)) == 0) {
            attach = newtmp;
            ast_debug(3, "VOLGAIN: Stored at: %s.%s - Level: %.4f - Mailbox: %s\n", attach, format, vmu->volgain, mailbox);
         } else {
            ast_log(LOG_WARNING, "Sox failed to reencode %s.%s: %s (have you installed support for all sox file formats?)\n", attach, format,
               soxstatus == 1 ? "Problem with command line options" : "An error occurred during file processing");
            ast_log(LOG_WARNING, "Voicemail attachment will have no volume gain.\n");
         }
      }
   }
   fprintf(p, "--%s" ENDL, bound);
   if (msgnum > -1)
      fprintf(p, "Content-Type: %s%s; name=\"%s\"" ENDL, ctype, format, filename);
   else
      fprintf(p, "Content-Type: %s%s; name=\"%s.%s\"" ENDL, ctype, format, greeting_attachment, format);
   fprintf(p, "Content-Transfer-Encoding: base64" ENDL);
   fprintf(p, "Content-Description: Voicemail sound attachment." ENDL);
   if (msgnum > -1)
      fprintf(p, "Content-Disposition: attachment; filename=\"%s\"" ENDL ENDL, filename);
   else
      fprintf(p, "Content-Disposition: attachment; filename=\"%s.%s\"" ENDL ENDL, greeting_attachment, format);
   snprintf(fname, sizeof(fname), "%s.%s", attach, format);
   base_encode(fname, p);
   if (last)
      fprintf(p, ENDL ENDL "--%s--" ENDL "." ENDL, bound);
   if (tmpfd > -1) {
      unlink(fname);
      close(tmpfd);
      unlink(newtmp);
   }
   return 0;
}

static void adsi_begin	(	struct ast_channel *	chan,
		int *	useadsi
	)			[static]

Definition at line 5910 of file app_voicemail.c.

References adsi_load_vmail(), adsifdn, adsiver, ast_adsi_available, ast_adsi_load_session, ast_log(), and AST_LOG_WARNING.

Referenced by vm_authenticate(), and vm_execmain().

{
   int x;
   if (!ast_adsi_available(chan))
      return;
   x = ast_adsi_load_session(chan, adsifdn, adsiver, 1);
   if (x < 0)
      return;
   if (!x) {
      if (adsi_load_vmail(chan, useadsi)) {
         ast_log(AST_LOG_WARNING, "Unable to upload voicemail scripts\n");
         return;
      }
   } else
      *useadsi = 1;
}

static void adsi_delete	(	struct ast_channel *	chan,
		struct vm_state *	vms
	)			[static]

Definition at line 6099 of file app_voicemail.c.

References ADSI_KEY_APPS, ADSI_KEY_SKT, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_set_keys, ast_adsi_transmit_message, ast_adsi_voice_mode, vm_state::curmsg, vm_state::deleted, and vm_state::lastmsg.

Referenced by vm_execmain().

{
   int bytes = 0;
   unsigned char buf[256];
   unsigned char keys[8];

   int x;

   if (!ast_adsi_available(chan))
      return;

   /* New meaning for keys */
   for (x = 0; x < 5; x++)
      keys[x] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 6 + x);

   keys[6] = 0x0;
   keys[7] = 0x0;

   if (!vms->curmsg) {
      /* No prev key, provide "Folder" instead */
      keys[0] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 1);
   }
   if (vms->curmsg >= vms->lastmsg) {
      /* If last message ... */
      if (vms->curmsg) {
         /* but not only message, provide "Folder" instead */
         keys[3] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 1);
      } else {
         /* Otherwise if only message, leave blank */
         keys[3] = 1;
      }
   }

   /* If deleted, show "undeleted" */
   if (vms->deleted[vms->curmsg]) 
      keys[1] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 11);

   /* Except "Exit" */
   keys[5] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 5);
   bytes += ast_adsi_set_keys(buf + bytes, keys);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static void adsi_folders	(	struct ast_channel *	chan,
		int	start,
		char *	label
	)			[static]

Definition at line 5975 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_CENT, ADSI_KEY_APPS, ADSI_KEY_SKT, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, and ast_adsi_voice_mode.

Referenced by vm_execmain().

{
   unsigned char buf[256];
   int bytes = 0;
   unsigned char keys[8];
   int x, y;

   if (!ast_adsi_available(chan))
      return;

   for (x = 0; x < 5; x++) {
      y = ADSI_KEY_APPS + 12 + start + x;
      if (y > ADSI_KEY_APPS + 12 + 4)
         y = 0;
      keys[x] = ADSI_KEY_SKT | y;
   }
   keys[5] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 17);
   keys[6] = 0;
   keys[7] = 0;

   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 1, ADSI_JUST_CENT, 0, label, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 2, ADSI_JUST_CENT, 0, " ", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_set_keys(buf + bytes, keys);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static void adsi_goodbye

(

struct ast_channel *

chan

)

[static]

Definition at line 6247 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_CENT, ADSI_JUST_LEFT, adsi_logo(), ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_set_line, ast_adsi_transmit_message, and ast_adsi_voice_mode.

Referenced by vm_execmain().

{
   unsigned char buf[256];
   int bytes = 0;

   if (!ast_adsi_available(chan))
      return;
   bytes += adsi_logo(buf + bytes);
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_LEFT, 0, " ", "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_CENT, 0, "Goodbye", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static int adsi_load_vmail	(	struct ast_channel *	chan,
		int *	useadsi
	)			[static]

Definition at line 5781 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_CENT, ADSI_JUST_LEFT, ADSI_KEY_APPS, adsi_logo(), ADSI_MSG_DISPLAY, ADSI_MSG_DOWNLOAD, adsifdn, adsisec, adsiver, ast_adsi_begin_download, ast_adsi_data_mode, ast_adsi_display, ast_adsi_download_disconnect, ast_adsi_end_download, ast_adsi_load_session, ast_adsi_load_soft_key, ast_adsi_set_line, ast_adsi_transmit_message, ast_adsi_voice_mode, ast_debug, mbox(), and num.

Referenced by adsi_begin().

{
   unsigned char buf[256];
   int bytes = 0;
   int x;
   char num[5];

   *useadsi = 0;
   bytes += ast_adsi_data_mode(buf + bytes);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);

   bytes = 0;
   bytes += adsi_logo(buf);
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Downloading Scripts", "");
#ifdef DISPLAY
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, "   .", "");
#endif
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_data_mode(buf + bytes);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);

   if (ast_adsi_begin_download(chan, addesc, adsifdn, adsisec, adsiver)) {
      bytes = 0;
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Load Cancelled.", "");
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_CENT, 0, "ADSI Unavailable", "");
      bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
      bytes += ast_adsi_voice_mode(buf + bytes, 0);
      ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
      return 0;
   }

#ifdef DISPLAY
   /* Add a dot */
   bytes = 0;
   bytes += ast_adsi_logo(buf);
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Downloading Scripts", "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, "   ..", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
#endif
   bytes = 0;
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 0, "Listen", "Listen", "1", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 1, "Folder", "Folder", "2", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 2, "Advanced", "Advnced", "3", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 3, "Options", "Options", "0", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 4, "Help", "Help", "*", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 5, "Exit", "Exit", "#", 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD);

#ifdef DISPLAY
   /* Add another dot */
   bytes = 0;
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, "   ...", "");
   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
#endif

   bytes = 0;
   /* These buttons we load but don't use yet */
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 6, "Previous", "Prev", "4", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 8, "Repeat", "Repeat", "5", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 7, "Delete", "Delete", "7", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 9, "Next", "Next", "6", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 10, "Save", "Save", "9", 1);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 11, "Undelete", "Restore", "7", 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD);

#ifdef DISPLAY
   /* Add another dot */
   bytes = 0;
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, "   ....", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
#endif

   bytes = 0;
   for (x = 0; x < 5; x++) {
      snprintf(num, sizeof(num), "%d", x);
      bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 12 + x, mbox(x), mbox(x), num, 1);
   }
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 12 + 5, "Cancel", "Cancel", "#", 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD);

#ifdef DISPLAY
   /* Add another dot */
   bytes = 0;
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, "   .....", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
#endif

   if (ast_adsi_end_download(chan)) {
      bytes = 0;
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Download Unsuccessful.", "");
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_CENT, 0, "ADSI Unavailable", "");
      bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
      bytes += ast_adsi_voice_mode(buf + bytes, 0);
      ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
      return 0;
   }
   bytes = 0;
   bytes += ast_adsi_download_disconnect(buf + bytes);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD);

   ast_debug(1, "Done downloading scripts...\n");

#ifdef DISPLAY
   /* Add last dot */
   bytes = 0;
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_CENT, 0, "   ......", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
#endif
   ast_debug(1, "Restarting session...\n");

   bytes = 0;
   /* Load the session now */
   if (ast_adsi_load_session(chan, adsifdn, adsiver, 1) == 1) {
      *useadsi = 1;
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Scripts Loaded!", "");
   } else
      bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, "Load Failed!", "");

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
   return 0;
}

static void adsi_login

(

struct ast_channel *

chan

)

[static]

Definition at line 5927 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_DIR_FROM_LEFT, ADSI_JUST_CENT, ADSI_JUST_LEFT, ADSI_KEY_APPS, adsi_logo(), ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_input_control, ast_adsi_input_format, ast_adsi_load_soft_key, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, and ast_adsi_voice_mode.

Referenced by vm_authenticate().

{
   unsigned char buf[256];
   int bytes = 0;
   unsigned char keys[8];
   int x;
   if (!ast_adsi_available(chan))
      return;

   for (x = 0; x < 8; x++)
      keys[x] = 0;
   /* Set one key for next */
   keys[3] = ADSI_KEY_APPS + 3;

   bytes += adsi_logo(buf + bytes);
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_CENT, 0, " ", "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_CENT, 0, " ", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_input_format(buf + bytes, 1, ADSI_DIR_FROM_LEFT, 0, "Mailbox: ******", "");
   bytes += ast_adsi_input_control(buf + bytes, ADSI_COMM_PAGE, 4, 1, 1, ADSI_JUST_LEFT);
   bytes += ast_adsi_load_soft_key(buf + bytes, ADSI_KEY_APPS + 3, "Enter", "Enter", "#", 1);
   bytes += ast_adsi_set_keys(buf + bytes, keys);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static int adsi_logo

(

unsigned char *

buf

)

[static]

Definition at line 5773 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_CENT, and ast_adsi_display.

Referenced by adsi_goodbye(), adsi_load_vmail(), adsi_login(), vm_newuser(), vm_options(), and vm_tempgreeting().

{
   int bytes = 0;
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 1, ADSI_JUST_CENT, 0, "Comedian Mail", "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 2, ADSI_JUST_CENT, 0, "(C)2002-2006 Digium, Inc.", "");
   return bytes;
}

static void adsi_message	(	struct ast_channel *	chan,
		struct vm_state *	vms
	)			[static]

Definition at line 6004 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_LEFT, ADSI_KEY_APPS, ADSI_KEY_SKT, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, ast_adsi_voice_mode, ast_callerid_parse(), ast_copy_string(), ast_strlen_zero(), buf1, buf2, vm_state::curbox, vm_state::curmsg, vm_state::deleted, vm_state::fn, vm_state::lastmsg, num, and strsep().

Referenced by play_message(), and vm_execmain().

{
   int bytes = 0;
   unsigned char buf[256]; 
   char buf1[256], buf2[256];
   char fn2[PATH_MAX];

   char cid[256] = "";
   char *val;
   char *name, *num;
   char datetime[21] = "";
   FILE *f;

   unsigned char keys[8];

   int x;

   if (!ast_adsi_available(chan))
      return;

   /* Retrieve important info */
   snprintf(fn2, sizeof(fn2), "%s.txt", vms->fn);
   f = fopen(fn2, "r");
   if (f) {
      while (!feof(f)) {   
         if (!fgets((char *) buf, sizeof(buf), f)) {
            continue;
         }
         if (!feof(f)) {
            char *stringp = NULL;
            stringp = (char *) buf;
            strsep(&stringp, "=");
            val = strsep(&stringp, "=");
            if (!ast_strlen_zero(val)) {
               if (!strcmp((char *) buf, "callerid"))
                  ast_copy_string(cid, val, sizeof(cid));
               if (!strcmp((char *) buf, "origdate"))
                  ast_copy_string(datetime, val, sizeof(datetime));
            }
         }
      }
      fclose(f);
   }
   /* New meaning for keys */
   for (x = 0; x < 5; x++)
      keys[x] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 6 + x);
   keys[6] = 0x0;
   keys[7] = 0x0;

   if (!vms->curmsg) {
      /* No prev key, provide "Folder" instead */
      keys[0] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 1);
   }
   if (vms->curmsg >= vms->lastmsg) {
      /* If last message ... */
      if (vms->curmsg) {
         /* but not only message, provide "Folder" instead */
         keys[3] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 1);
         bytes += ast_adsi_voice_mode(buf + bytes, 0);

      } else {
         /* Otherwise if only message, leave blank */
         keys[3] = 1;
      }
   }

   if (!ast_strlen_zero(cid)) {
      ast_callerid_parse(cid, &name, &num);
      if (!name)
         name = num;
   } else
      name = "Unknown Caller";

   /* If deleted, show "undeleted" */

   if (vms->deleted[vms->curmsg])
      keys[1] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 11);

   /* Except "Exit" */
   keys[5] = ADSI_KEY_SKT | (ADSI_KEY_APPS + 5);
   snprintf(buf1, sizeof(buf1), "%s%s", vms->curbox,
      strcasecmp(vms->curbox, "INBOX") ? " Messages" : "");
   snprintf(buf2, sizeof(buf2), "Message %d of %d", vms->curmsg + 1, vms->lastmsg + 1);

   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 1, ADSI_JUST_LEFT, 0, buf1, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 2, ADSI_JUST_LEFT, 0, buf2, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_LEFT, 0, name, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 4, ADSI_JUST_LEFT, 0, datetime, "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_set_keys(buf + bytes, keys);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static void adsi_password

(

struct ast_channel *

chan

)

[static]

Definition at line 5953 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_DIR_FROM_LEFT, ADSI_JUST_LEFT, ADSI_KEY_APPS, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_input_control, ast_adsi_input_format, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, and ast_adsi_voice_mode.

Referenced by vm_authenticate().

{
   unsigned char buf[256];
   int bytes = 0;
   unsigned char keys[8];
   int x;
   if (!ast_adsi_available(chan))
      return;

   for (x = 0; x < 8; x++)
      keys[x] = 0;
   /* Set one key for next */
   keys[3] = ADSI_KEY_APPS + 3;

   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_input_format(buf + bytes, 1, ADSI_DIR_FROM_LEFT, 0, "Password: ******", "");
   bytes += ast_adsi_input_control(buf + bytes, ADSI_COMM_PAGE, 4, 0, 1, ADSI_JUST_LEFT);
   bytes += ast_adsi_set_keys(buf + bytes, keys);
   bytes += ast_adsi_voice_mode(buf + bytes, 0);
   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static void adsi_status	(	struct ast_channel *	chan,
		struct vm_state *	vms
	)			[static]

Definition at line 6144 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_LEFT, ADSI_KEY_APPS, ADSI_KEY_SKT, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, ast_adsi_voice_mode, buf1, buf2, vm_state::lastmsg, vm_state::newmessages, and vm_state::oldmessages.

Referenced by vm_execmain().

{
   unsigned char buf[256] = "";
   char buf1[256] = "", buf2[256] = "";
   int bytes = 0;
   unsigned char keys[8];
   int x;

   char *newm = (vms->newmessages == 1) ? "message" : "messages";
   char *oldm = (vms->oldmessages == 1) ? "message" : "messages";
   if (!ast_adsi_available(chan))
      return;
   if (vms->newmessages) {
      snprintf(buf1, sizeof(buf1), "You have %d new", vms->newmessages);
      if (vms->oldmessages) {
         strncat(buf1, " and", sizeof(buf1) - strlen(buf1) - 1);
         snprintf(buf2, sizeof(buf2), "%d old %s.", vms->oldmessages, oldm);
      } else {
         snprintf(buf2, sizeof(buf2), "%s.", newm);
      }
   } else if (vms->oldmessages) {
      snprintf(buf1, sizeof(buf1), "You have %d old", vms->oldmessages);
      snprintf(buf2, sizeof(buf2), "%s.", oldm);
   } else {
      strcpy(buf1, "You have no messages.");
      buf2[0] = ' ';
      buf2[1] = '\0';
   }
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 1, ADSI_JUST_LEFT, 0, buf1, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 2, ADSI_JUST_LEFT, 0, buf2, "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);

   for (x = 0; x < 6; x++)
      keys[x] = ADSI_KEY_SKT | (ADSI_KEY_APPS + x);
   keys[6] = 0;
   keys[7] = 0;

   /* Don't let them listen if there are none */
   if (vms->lastmsg < 0)
      keys[0] = 1;
   bytes += ast_adsi_set_keys(buf + bytes, keys);

   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
}

static void adsi_status2	(	struct ast_channel *	chan,
		struct vm_state *	vms
	)			[static]

Definition at line 6191 of file app_voicemail.c.

References ADSI_COMM_PAGE, ADSI_JUST_LEFT, ADSI_KEY_APPS, ADSI_KEY_SKT, ADSI_MSG_DISPLAY, ast_adsi_available, ast_adsi_display, ast_adsi_set_keys, ast_adsi_set_line, ast_adsi_transmit_message, ast_adsi_voice_mode, buf1, buf2, vm_state::curbox, and vm_state::lastmsg.

Referenced by vm_execmain().

{
   unsigned char buf[256] = "";
   char buf1[256] = "", buf2[256] = "";
   int bytes = 0;
   unsigned char keys[8];
   int x;

   char *mess = (vms->lastmsg == 0) ? "message" : "messages";

   if (!ast_adsi_available(chan))
      return;

   /* Original command keys */
   for (x = 0; x < 6; x++)
      keys[x] = ADSI_KEY_SKT | (ADSI_KEY_APPS + x);

   keys[6] = 0;
   keys[7] = 0;

   if ((vms->lastmsg + 1) < 1)
      keys[0] = 0;

   snprintf(buf1, sizeof(buf1), "%s%s has", vms->curbox,
      strcasecmp(vms->curbox, "INBOX") ? " folder" : "");

   if (vms->lastmsg + 1)
      snprintf(buf2, sizeof(buf2), "%d %s.", vms->lastmsg + 1, mess);
   else
      strcpy(buf2, "no messages.");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 1, ADSI_JUST_LEFT, 0, buf1, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 2, ADSI_JUST_LEFT, 0, buf2, "");
   bytes += ast_adsi_display(buf + bytes, ADSI_COMM_PAGE, 3, ADSI_JUST_LEFT, 0, "", "");
   bytes += ast_adsi_set_line(buf + bytes, ADSI_COMM_PAGE, 1);
   bytes += ast_adsi_set_keys(buf + bytes, keys);

   bytes += ast_adsi_voice_mode(buf + bytes, 0);

   ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY);
   
}

static int advanced_options	(	struct ast_channel *	chan,
		struct ast_vm_user *	vmu,
		struct vm_state *	vms,
		int	msg,
		int	option,
		signed char	record_gain
	)			[static]

The advanced options within a message.

Parameters:

	chan
	vmu
	vms
	msg
	option
	record_gain	Provides handling for the play message envelope, call the person back, or reply to message.

Returns:

zero on success, -1 on error.

Definition at line 11473 of file app_voicemail.c.

References ast_callerid_parse(), ast_config_destroy(), ast_config_load, ast_log(), AST_LOG_WARNING, AST_MAX_EXTENSION, ast_play_and_wait(), ast_strdupa, ast_strlen_zero(), ast_variable_retrieve(), ast_verb, ast_waitfordigit(), ast_vm_user::callback, CONFIG_FLAG_NOCACHE, CONFIG_STATUS_FILEINVALID, ast_vm_user::context, vm_state::curdir, vm_state::curmsg, ast_vm_user::dialout, dialout(), DISPOSE, find_user(), vm_state::fn, vm_state::heard, leave_voicemail(), ast_vm_user::mailbox, make_file(), num, play_message_callerid(), play_message_datetime(), leave_vm_options::record_gain, RETRIEVE, vm_state::starting, and wait_file().

Referenced by vm_execmain().

{
   int res = 0;
   char filename[PATH_MAX];
   struct ast_config *msg_cfg = NULL;
   const char *origtime, *context;
   char *name, *num;
   int retries = 0;
   char *cid;
   struct ast_flags config_flags = { CONFIG_FLAG_NOCACHE, };

   vms->starting = 0; 

   make_file(vms->fn, sizeof(vms->fn), vms->curdir, msg);

   /* Retrieve info from VM attribute file */
   snprintf(filename, sizeof(filename), "%s.txt", vms->fn);
   RETRIEVE(vms->curdir, vms->curmsg, vmu->mailbox, vmu->context);
   msg_cfg = ast_config_load(filename, config_flags);
   DISPOSE(vms->curdir, vms->curmsg);
   if (!msg_cfg || msg_cfg == CONFIG_STATUS_FILEINVALID) {
      ast_log(AST_LOG_WARNING, "No message attribute file?!! (%s)\n", filename);
      return 0;
   }

   if (!(origtime = ast_variable_retrieve(msg_cfg, "message", "origtime"))) {
      ast_config_destroy(msg_cfg);
      return 0;
   }

   cid = ast_strdupa(ast_variable_retrieve(msg_cfg, "message", "callerid"));

   context = ast_variable_retrieve(msg_cfg, "message", "context");
   if (!strncasecmp("macro", context, 5)) /* Macro names in contexts are useless for our needs */
      context = ast_variable_retrieve(msg_cfg, "message", "macrocontext");
   switch (option) {
   case 3: /* Play message envelope */
      if (!res)
         res = play_message_datetime(chan, vmu, origtime, filename);
      if (!res)
         res = play_message_callerid(chan, vms, cid, context, 0);

      res = 't';
      break;

   case 2:  /* Call back */

      if (ast_strlen_zero(cid))
         break;

      ast_callerid_parse(cid, &name, &num);
      while ((res > -1) && (res != 't')) {
         switch (res) {
         case '1':
            if (num) {
               /* Dial the CID number */
               res = dialout(chan, vmu, num, vmu->callback);
               if (res) {
                  ast_config_destroy(msg_cfg);
                  return 9;
               }
            } else {
               res = '2';
            }
            break;

         case '2':
            /* Want to enter a different number, can only do this if there's a dialout context for this user */
            if (!ast_strlen_zero(vmu->dialout)) {
               res = dialout(chan, vmu, NULL, vmu->dialout);
               if (res) {
                  ast_config_destroy(msg_cfg);
                  return 9;
               }
            } else {
               ast_verb(3, "Caller can not specify callback number - no dialout context available\n");
               res = ast_play_and_wait(chan, "vm-sorry");
            }
            ast_config_destroy(msg_cfg);
            return res;
         case '*':
            res = 't';
            break;
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9':
         case '0':

            res = ast_play_and_wait(chan, "vm-sorry");
            retries++;
            break;
         default:
            if (num) {
               ast_verb(3, "Confirm CID number '%s' is number to use for callback\n", num);
               res = ast_play_and_wait(chan, "vm-num-i-have");
               if (!res)
                  res = play_message_callerid(chan, vms, num, vmu->context, 1);
               if (!res)
                  res = ast_play_and_wait(chan, "vm-tocallnum");
               /* Only prompt for a caller-specified number if there is a dialout context specified */
               if (!ast_strlen_zero(vmu->dialout)) {
                  if (!res)
                     res = ast_play_and_wait(chan, "vm-calldiffnum");
               }
            } else {
               res = ast_play_and_wait(chan, "vm-nonumber");
               if (!ast_strlen_zero(vmu->dialout)) {
                  if (!res)
                     res = ast_play_and_wait(chan, "vm-toenternumber");
               }
            }
            if (!res)
               res = ast_play_and_wait(chan, "vm-star-cancel");
            if (!res)
               res = ast_waitfordigit(chan, 6000);
            if (!res) {
               retries++;
               if (retries > 3)
                  res = 't';
            }
            break; 
            
         }
         if (res == 't')
            res = 0;
         else if (res == '*')
            res = -1;
      }
      break;
      
   case 1:  /* Reply */
      /* Send reply directly to sender */
      if (ast_strlen_zero(cid))
         break;

      ast_callerid_parse(cid, &name, &num);
      if (!num) {
         ast_verb(3, "No CID number available, no reply sent\n");
         if (!res)
            res = ast_play_and_wait(chan, "vm-nonumber");
         ast_config_destroy(msg_cfg);
         return res;
      } else {
         struct ast_vm_user vmu2;
         if (find_user(&vmu2, vmu->context, num)) {
            struct leave_vm_options leave_options;
            char mailbox[AST_MAX_EXTENSION * 2 + 2];
            snprintf(mailbox, sizeof(mailbox), "%s@%s", num, vmu->context);

            ast_verb(3, "Leaving voicemail for '%s' in context '%s'\n", num, vmu->context);
            
            memset(&leave_options, 0, sizeof(leave_options));
            leave_options.record_gain = record_gain;
            res = leave_voicemail(chan, mailbox, &leave_options);
            if (!res)
               res = 't';
            ast_config_destroy(msg_cfg);
            return res;
         } else {
            /* Sender has no mailbox, can't reply */
            ast_verb(3, "No mailbox number '%s' in context '%s', no reply sent\n", num, vmu->context);
            ast_play_and_wait(chan, "vm-nobox");
            res = 't';
            ast_config_destroy(msg_cfg);
            return res;
         }
      } 
      res = 0;

      break;
   }

#ifndef IMAP_STORAGE
   ast_config_destroy(msg_cfg);

   if (!res) {
      make_file(vms->fn, sizeof(vms->fn), vms->curdir, msg);
      vms->heard[msg] = 1;
      res = wait_file(chan, vms, vms->fn);
   }
#endif
   return res;
}

static int append_mailbox	(	const char *	context,
		const char *	box,
		const char *	data
	)			[static]

Definition at line 9900 of file app_voicemail.c.

References apply_options(), ast_copy_string(), ast_strdupa, ast_vm_user::context, ast_vm_user::email, find_or_create(), ast_vm_user::fullname, inboxcount2(), ast_vm_user::mailbox, OPT_PWLOC_SPOOLDIR, ast_vm_user::pager, ast_vm_user::password, ast_vm_user::passwordlocation, populate_defaults(), queue_mwi_event(), read_password_from_file(), s, and strsep().

Referenced by load_config().

{
   /* Assumes lock is already held */
   char *tmp;
   char *stringp;
   char *s;
   struct ast_vm_user *vmu;
   char *mailbox_full;
   int new = 0, old = 0, urgent = 0;
   char secretfn[PATH_MAX] = "";

   tmp = ast_strdupa(data);

   if (!(vmu = find_or_create(context, box)))
      return -1;

   populate_defaults(vmu);

   stringp = tmp;
   if ((s = strsep(&stringp, ","))) {
      ast_copy_string(vmu->password, s, sizeof(vmu->password));
   }
   if (stringp && (s = strsep(&stringp, ","))) {
      ast_copy_string(vmu->fullname, s, sizeof(vmu->fullname));
   }
   if (stringp && (s = strsep(&stringp, ","))) {
      ast_copy_string(vmu->email, s, sizeof(vmu->email));
   }
   if (stringp && (s = strsep(&stringp, ","))) {
      ast_copy_string(vmu->pager, s, sizeof(vmu->pager));
   }
   if (stringp && (s = strsep(&stringp, ","))) {
      apply_options(vmu, s);
   }

   switch (vmu->passwordlocation) {
   case OPT_PWLOC_SPOOLDIR:
      snprintf(secretfn, sizeof(secretfn), "%s%s/%s/secret.conf", VM_SPOOL_DIR, vmu->context, vmu->mailbox);
      read_password_from_file(secretfn, vmu->password, sizeof(vmu->password));
   }

   mailbox_full = alloca(strlen(box) + strlen(context) + 1);
   strcpy(mailbox_full, box);
   strcat(mailbox_full, "@");
   strcat(mailbox_full, context);

   inboxcount2(mailbox_full, &urgent, &new, &old);
   queue_mwi_event(mailbox_full, urgent, new, old);

   return 0;
}

static void apply_option	(	struct ast_vm_user *	vmu,
		const char *	var,
		const char *	value
	)			[static]

Sets a a specific property value.

Parameters:

	vmu	The voicemail user object to work with.
	var	The name of the property to be set.
	value	The value to be set to the property.

The property name must be one of the understood properties. See the source for details.

Definition at line 914 of file app_voicemail.c.

References apply_options(), ast_copy_string(), ast_log(), AST_LOG_WARNING, ast_set2_flag, ast_true(), ast_vm_user::attachfmt, ast_vm_user::callback, ast_vm_user::dialout, ast_vm_user::exit, ast_vm_user::language, ast_vm_user::maxdeletedmsg, MAXMSG, ast_vm_user::maxmsg, MAXMSGLIMIT, ast_vm_user::maxsecs, OPT_PWLOC_SPOOLDIR, OPT_PWLOC_VOICEMAILCONF, ast_vm_user::passwordlocation, ast_vm_user::saydurationm, ast_vm_user::serveremail, VM_ATTACH, VM_DELETE, VM_ENVELOPE, VM_FORCEGREET, VM_FORCENAME, VM_MESSAGEWRAP, VM_MOVEHEARD, VM_OPERATOR, VM_REVIEW, VM_SAYCID, VM_SAYDURATION, VM_SVMAIL, VM_TEMPGREETWARN, ast_vm_user::volgain, and ast_vm_user::zonetag.

Referenced by apply_options(), and apply_options_full().

{
   int x;
   if (!strcasecmp(var, "attach")) {
      ast_set2_flag(vmu, ast_true(value), VM_ATTACH);
   } else if (!strcasecmp(var, "attachfmt")) {
      ast_copy_string(vmu->attachfmt, value, sizeof(vmu->attachfmt));
   } else if (!strcasecmp(var, "serveremail")) {
      ast_copy_string(vmu->serveremail, value, sizeof(vmu->serveremail));
   } else if (!strcasecmp(var, "language")) {
      ast_copy_string(vmu->language, value, sizeof(vmu->language));
   } else if (!strcasecmp(var, "tz")) {
      ast_copy_string(vmu->zonetag, value, sizeof(vmu->zonetag));
#ifdef IMAP_STORAGE
   } else if (!strcasecmp(var, "imapuser")) {
      ast_copy_string(vmu->imapuser, value, sizeof(vmu->imapuser));
      vmu->imapversion = imapversion;
   } else if (!strcasecmp(var, "imappassword") || !strcasecmp(var, "imapsecret")) {
      ast_copy_string(vmu->imappassword, value, sizeof(vmu->imappassword));
      vmu->imapversion = imapversion;
   } else if (!strcasecmp(var, "imapvmshareid")) {
      ast_copy_string(vmu->imapvmshareid, value, sizeof(vmu->imapvmshareid));
      vmu->imapversion = imapversion;
#endif
   } else if (!strcasecmp(var, "delete") || !strcasecmp(var, "deletevoicemail")) {
      ast_set2_flag(vmu, ast_true(value), VM_DELETE); 
   } else if (!strcasecmp(var, "saycid")){
      ast_set2_flag(vmu, ast_true(value), VM_SAYCID); 
   } else if (!strcasecmp(var, "sendvoicemail")){
      ast_set2_flag(vmu, ast_true(value), VM_SVMAIL); 
   } else if (!strcasecmp(var, "review")){
      ast_set2_flag(vmu, ast_true(value), VM_REVIEW);
   } else if (!strcasecmp(var, "tempgreetwarn")){
      ast_set2_flag(vmu, ast_true(value), VM_TEMPGREETWARN);   
   } else if (!strcasecmp(var, "messagewrap")){
      ast_set2_flag(vmu, ast_true(value), VM_MESSAGEWRAP);  
   } else if (!strcasecmp(var, "operator")) {
      ast_set2_flag(vmu, ast_true(value), VM_OPERATOR);  
   } else if (!strcasecmp(var, "envelope")){
      ast_set2_flag(vmu, ast_true(value), VM_ENVELOPE);  
   } else if (!strcasecmp(var, "moveheard")){
      ast_set2_flag(vmu, ast_true(value), VM_MOVEHEARD);
   } else if (!strcasecmp(var, "sayduration")){
      ast_set2_flag(vmu, ast_true(value), VM_SAYDURATION);  
   } else if (!strcasecmp(var, "saydurationm")){
      if (sscanf(value, "%30d", &x) == 1) {
         vmu->saydurationm = x;
      } else {
         ast_log(AST_LOG_WARNING, "Invalid min duration for say duration\n");
      }
   } else if (!strcasecmp(var, "forcename")){
      ast_set2_flag(vmu, ast_true(value), VM_FORCENAME); 
   } else if (!strcasecmp(var, "forcegreetings")){
      ast_set2_flag(vmu, ast_true(value), VM_FORCEGREET);   
   } else if (!strcasecmp(var, "callback")) {
      ast_copy_string(vmu->callback, value, sizeof(vmu->callback));
   } else if (!strcasecmp(var, "dialout")) {
      ast_copy_string(vmu->dialout, value, sizeof(vmu->dialout));
   } else if (!strcasecmp(var, "exitcontext")) {
      ast_copy_string(vmu->exit, value, sizeof(vmu->exit));
   } else if (!strcasecmp(var, "maxmessage") || !strcasecmp(var, "maxsecs")) {
      vmu->maxsecs = atoi(value);
      if (vmu->maxsecs <= 0) {
         ast_log(AST_LOG_WARNING, "Invalid max message length of %s. Using global value %d\n", value, vmmaxsecs);
         vmu->maxsecs = vmmaxsecs;
      } else {
         vmu->maxsecs = atoi(value);
      }
      if (!strcasecmp(var, "maxmessage"))
         ast_log(AST_LOG_WARNING, "Option 'maxmessage' has been deprecated in favor of 'maxsecs'.  Please make that change in your voicemail config.\n");
   } else if (!strcasecmp(var, "maxmsg")) {
      vmu->maxmsg = atoi(value);
      if (vmu->maxmsg <= 0) {
         ast_log(AST_LOG_WARNING, "Invalid number of messages per folder maxmsg=%s. Using default value %d\n", value, MAXMSG);
         vmu->maxmsg = MAXMSG;
      } else if (vmu->maxmsg > MAXMSGLIMIT) {
         ast_log(AST_LOG_WARNING, "Maximum number of messages per folder is %d. Cannot accept value maxmsg=%s\n", MAXMSGLIMIT, value);
         vmu->maxmsg = MAXMSGLIMIT;
      }
   } else if (!strcasecmp(var, "backupdeleted")) {
      if (sscanf(value, "%30d", &x) == 1)
         vmu->maxdeletedmsg = x;
      else if (ast_true(value))
         vmu->maxdeletedmsg = MAXMSG;
      else
         vmu->maxdeletedmsg = 0;

      if (vmu->maxdeletedmsg < 0) {
         ast_log(AST_LOG_WARNING, "Invalid number of deleted messages saved per mailbox backupdeleted=%s. Using default value %d\n", value, MAXMSG);
         vmu->maxdeletedmsg = MAXMSG;
      } else if (vmu->maxdeletedmsg > MAXMSGLIMIT) {
         ast_log(AST_LOG_WARNING, "Maximum number of deleted messages saved per mailbox is %d. Cannot accept value backupdeleted=%s\n", MAXMSGLIMIT, value);
         vmu->maxdeletedmsg = MAXMSGLIMIT;
      }
   } else if (!strcasecmp(var, "volgain")) {
      sscanf(value, "%30lf", &vmu->volgain);
   } else if (!strcasecmp(var, "passwordlocation")) {
      if (!strcasecmp(value, "spooldir")) {
         vmu->passwordlocation = OPT_PWLOC_SPOOLDIR;
      } else {
         vmu->passwordlocation = OPT_PWLOC_VOICEMAILCONF;
      }
   } else if (!strcasecmp(var, "options")) {
      apply_options(vmu, value);
   }
}

static void apply_options	(	struct ast_vm_user *	vmu,
		const char *	options
	)			[static]

Destructively Parse options and apply.

Definition at line 1133 of file app_voicemail.c.

References apply_option(), ast_strdupa, s, strsep(), value, and var.

Referenced by append_mailbox(), and apply_option().

{  
   char *stringp;
   char *s;
   char *var, *value;
   stringp = ast_strdupa(options);
   while ((s = strsep(&stringp, "|"))) {
      value = s;
      if ((var = strsep(&value, "=")) && value) {
         apply_option(vmu, var, value);
      }
   }  
}

static void apply_options_full	(	struct ast_vm_user *	retval,
		struct ast_variable *	var
	)			[static]

Loads the options specific to a voicemail user.

This is called when a vm_user structure is being set up, such as from load_options.

Definition at line 1152 of file app_voicemail.c.

References apply_option(), ast_copy_string(), ast_strdup, ast_strlen_zero(), ast_vm_user::context, ast_vm_user::email, ast_vm_user::emailbody, ast_vm_user::emailsubject, ast_vm_user::fullname, ast_variable::name, ast_variable::next, ast_vm_user::pager, ast_vm_user::password, ast_vm_user::uniqueid, and ast_variable::value.

Referenced by find_user_realtime(), and load_config().

{
   for (; var; var = var->next) {
      if (!strcasecmp(var->name, "vmsecret")) {
         ast_copy_string(retval->password, var->value, sizeof(retval->password));
      } else if (!strcasecmp(var->name, "secret") || !strcasecmp(var->name, "password")) { /* don't overwrite vmsecret if it exists */
         if (ast_strlen_zero(retval->password))
            ast_copy_string(retval->password, var->value, sizeof(retval->password));
      } else if (!strcasecmp(var->name, "uniqueid")) {
         ast_copy_string(retval->uniqueid, var->value, sizeof(retval->uniqueid));
      } else if (!strcasecmp(var->name, "pager")) {
         ast_copy_string(retval->pager, var->value, sizeof(retval->pager));
      } else if (!strcasecmp(var->name, "email")) {
         ast_copy_string(retval->email, var->value, sizeof(retval->email));
      } else if (!strcasecmp(var->name, "fullname")) {
         ast_copy_string(retval->fullname, var->value, sizeof(retval->fullname));
      } else if (!strcasecmp(var->name, "context")) {
         ast_copy_string(retval->context, var->value, sizeof(retval->context));
      } else if (!strcasecmp(var->name, "emailsubject")) {
         retval->emailsubject = ast_strdup(var->value);
      } else if (!strcasecmp(var->name, "emailbody")) {
         retval->emailbody = ast_strdup(var->value);
#ifdef IMAP_STORAGE
      } else if (!strcasecmp(var->name, "imapuser")) {
         ast_copy_string(retval->imapuser, var->value, sizeof(retval->imapuser));
         retval->imapversion = imapversion;
      } else if (!strcasecmp(var->name, "imappassword") || !strcasecmp(var->name, "imapsecret")) {
         ast_copy_string(retval->imappassword, var->value, sizeof(retval->imappassword));
         retval->imapversion = imapversion;
      } else if (!strcasecmp(var->name, "imapvmshareid")) {
         ast_copy_string(retval->imapvmshareid, var->value, sizeof(retval->imapvmshareid));
         retval->imapversion = imapversion;
#endif
      } else
         apply_option(retval, var->name, var->value);
   }
}

static const char* ast_str_encode_mime	(	struct ast_str **	end,
		ssize_t	maxlen,
		const char *	start,
		size_t	preamble,
		size_t	postamble
	)			[static]

Encode a string according to the MIME rules for encoding strings that are not 7-bit clean or contain control characters.

Additionally, if the encoded string would exceed the MIME limit of 76 characters per line, then the encoding will be broken up into multiple sections, separated by a space character, in order to facilitate breaking up the associated header across multiple lines.

Parameters:

	end	An expandable buffer for holding the result
	maxlen	Always zero, but see

See also:

ast_str

Parameters:

	start	A string to be encoded
	preamble	The length of the first line already used for this string, to ensure that each line maintains a maximum length of 76 chars.
	postamble	the length of any additional characters appended to the line, used to ensure proper field wrapping.

Return values:

The

encoded string.

Definition at line 4112 of file app_voicemail.c.

References ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_set(), ast_str_strlen(), and charset.

{
   struct ast_str *tmp = ast_str_alloca(80);
   int first_section = 1;

   ast_str_reset(*end);
   ast_str_set(&tmp, -1, "=?%s?Q?", charset);
   for (; *start; start++) {
      int need_encoding = 0;
      if (*start < 33 || *start > 126 || strchr("()<>@,:;/\"[]?.=_", *start)) {
         need_encoding = 1;
      }
      if ((first_section && need_encoding && preamble + ast_str_strlen(tmp) > 70) ||
         (first_section && !need_encoding && preamble + ast_str_strlen(tmp) > 72) ||
         (!first_section && need_encoding && ast_str_strlen(tmp) > 70) ||
         (!first_section && !need_encoding && ast_str_strlen(tmp) > 72)) {
         /* Start new line */
         ast_str_append(end, maxlen, "%s%s?=", first_section ? "" : " ", ast_str_buffer(tmp));
         ast_str_set(&tmp, -1, "=?%s?Q?", charset);
         first_section = 0;
      }
      if (need_encoding && *start == ' ') {
         ast_str_append(&tmp, -1, "_");
      } else if (need_encoding) {
         ast_str_append(&tmp, -1, "=%hhX", *start);
      } else {
         ast_str_append(&tmp, -1, "%c", *start);
      }
   }
   ast_str_append(end, maxlen, "%s%s?=%s", first_section ? "" : " ", ast_str_buffer(tmp), ast_str_strlen(tmp) + postamble > 74 ? " " : "");
   return ast_str_buffer(*end);
}

static const char* ast_str_quote	(	struct ast_str **	buf,
		ssize_t	maxlen,
		const char *	from
	)			[static]

Wraps a character sequence in double quotes, escaping occurences of quotes within the string.

Parameters:

	from	The string to work with.
	buf	The buffer into which to write the modified quoted string.
	maxlen	Always zero, but see

See also:

ast_str

Returns:

The destination string with quotes wrapped on it (the to field).

Definition at line 4040 of file app_voicemail.c.

References ast_str_append(), ast_str_buffer(), and ast_str_set().

{
   const char *ptr;

   /* We're only ever passing 0 to maxlen, so short output isn't possible */
   ast_str_set(buf, maxlen, "\"");
   for (ptr = from; *ptr; ptr++) {
      if (*ptr == '"' || *ptr == '\\') {
         ast_str_append(buf, maxlen, "\\%c", *ptr);
      } else {
         ast_str_append(buf, maxlen, "%c", *ptr);
      }
   }
   ast_str_append(buf, maxlen, "\"");

   return ast_str_buffer(*buf);
}

static int base_encode	(	char *	filename,
		FILE *	so
	)			[static]

Performs a base 64 encode algorithm on the contents of a File.

Parameters:

	filename	The path to the file to be encoded. Must be readable, file is opened in read mode.
	so	A FILE handle to the output file to receive the base 64 encoded contents of the input file, identified by filename.

TODO: shouldn't this (and the above 3 support functions) be put into some kind of external utility location, such as funcs/func_base64.c ?

Returns:

zero on success, -1 on error.

Definition at line 3917 of file app_voicemail.c.

References ast_log(), AST_LOG_WARNING, BASEMAXINLINE, eol, errno, inchar(), baseio::iocp, and ochar().

{
   static const unsigned char dtable[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
      'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
      '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
   int i, hiteof = 0;
   FILE *fi;
   struct baseio bio;

   memset(&bio, 0, sizeof(bio));
   bio.iocp = BASEMAXINLINE;

   if (!(fi = fopen(filename, "rb"))) {
      ast_log(AST_LOG_WARNING, "Failed to open file: %s: %s\n", filename, strerror(errno));
      return -1;
   }

   while (!hiteof){
      unsigned char igroup[3], ogroup[4];
      int c, n;

      memset(igroup, 0, sizeof(igroup));

      for (n = 0; n < 3; n++) {
         if ((c = inchar(&bio, fi)) == EOF) {
            hiteof = 1;
            break;
         }

         igroup[n] = (unsigned char) c;
      }

      if (n > 0) {
         ogroup[0]= dtable[igroup[0] >> 2];
         ogroup[1]= dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
         ogroup[2]= dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
         ogroup[3]= dtable[igroup[2] & 0x3F];

         if (n < 3) {
            ogroup[3] = '=';

            if (n < 2)
               ogroup[2] = '=';
         }

         for (i = 0; i < 4; i++)
            ochar(&bio, ogroup[i], so);
      }
   }

   fclose(fi);
   
   if (fputs(eol, so) == EOF)
      return 0;

   return 1;
}

static int change_password_realtime	(	struct ast_vm_user *	vmu,
		const char *	password
	)			[static]

Performs a change of the voicemail passowrd in the realtime engine.

Parameters:

	vmu	The voicemail user to change the password for.
	password	The new value to be set to the password for this user.

This only works if there is a realtime engine configured. This is called from the (top level) vm_change_password.

Returns:

zero on success, -1 on error.

Definition at line 1112 of file app_voicemail.c.

References ast_copy_string(), ast_realtime_require_field(), ast_update2_realtime(), ast_vm_user::context, ast_vm_user::mailbox, ast_vm_user::password, RQ_CHAR, and SENTINEL.

Referenced by vm_change_password().

{
   int res = -1;
   if (!strcmp(vmu->password, password)) {
      /* No change (but an update would return 0 rows updated, so we opt out here) */
      return 0;
   }

   if (strlen(password) > 10) {
      ast_realtime_require_field("voicemail", "password", RQ_CHAR, strlen(password), SENTINEL);
   }
   if (ast_update2_realtime("voicemail", "context", vmu->context, "mailbox", vmu->mailbox, SENTINEL, "password", password, SENTINEL) > 0) {
      ast_copy_string(vmu->password, password, sizeof(vmu->password));
      res = 0;
   }
   return res;
}

static int check_mime

(

const char *

str

)

[static]

Check if the string would need encoding within the MIME standard, to avoid confusing certain mail software that expects messages to be 7-bit clean.

Definition at line 4085 of file app_voicemail.c.

{
   for (; *str; str++) {
      if (*str > 126 || *str < 32 || strchr("()<>@,:;/\"[]?.=", *str)) {
         return 1;
      }
   }
   return 0;
}

static int check_password	(	struct ast_vm_user *	vmu,
		char *	password
	)			[static]

Check that password meets minimum required length.

Parameters:

	vmu	The voicemail user to change the password for.
	password	The password string to check

Returns:

zero on ok, 1 on not ok.

Definition at line 1074 of file app_voicemail.c.

References ast_debug, ast_log(), AST_LOG_DEBUG, AST_LOG_NOTICE, AST_LOG_WARNING, ast_strlen_zero(), buf, ast_vm_user::context, ast_vm_user::mailbox, ast_vm_user::password, and vm_check_password_shell().

Referenced by network_thread(), vm_newuser(), and vm_options().

{
   /* check minimum length */
   if (strlen(password) < minpassword)
      return 1;
   if (!ast_strlen_zero(ext_pass_check_cmd)) {
      char cmd[255], buf[255];

      ast_log(AST_LOG_DEBUG, "Verify password policies for %s\n", password);

      snprintf(cmd, sizeof(cmd), "%s %s %s %s %s", ext_pass_check_cmd, vmu->mailbox, vmu->context, vmu->password, password);
      if (vm_check_password_shell(cmd, buf, sizeof(buf))) {
         ast_debug(5, "Result: %s\n", buf);
         if (!strncasecmp(buf, "VALID", 5)) {
            ast_debug(3, "Passed password check: '%s'\n", buf);
            return 0;
         } else if (!strncasecmp(buf, "FAILURE", 7)) {
            ast_log(AST_LOG_WARNING, "Unable to execute password validation script: '%s'.\n", buf);
            return 0;
         } else {
            ast_log(AST_LOG_NOTICE, "Password doesn't match policies for user %s %s\n", vmu->mailbox, password);
            return 1;
         }
      }
   }
   return 0;
}

static int close_mailbox	(	struct vm_state *	vms,
		struct ast_vm_user *	vmu
	)			[static]

Definition at line 7300 of file app_voicemail.c.

References ast_check_realtime(), ast_debug, ast_log(), AST_LOG_WARNING, ast_test_flag, ast_unlock_path(), ast_vm_user::context, vm_state::curbox, vm_state::curdir, vm_state::curmsg, DELETE, vm_state::deleted, ERROR_LOCK_PATH, EXISTS, vm_state::fn, vm_state::heard, vm_state::lastmsg, ast_vm_user::mailbox, make_file(), ast_vm_user::maxdeletedmsg, ast_vm_user::maxmsg, RENAME, save_to_folder(), vm_lock_path(), and VM_MOVEHEARD.

Referenced by vm_execmain().

{
   int x = 0;
#ifndef IMAP_STORAGE
   int res = 0, nummsg;
   char fn2[PATH_MAX];
#endif

   if (vms->lastmsg <= -1)
      goto done;

   vms->curmsg = -1; 
#ifndef IMAP_STORAGE
   /* Get the deleted messages fixed */ 
   if (vm_lock_path(vms->curdir))
      return ERROR_LOCK_PATH;

   for (x = 0; x < vmu->maxmsg; x++) { 
      if (!vms->deleted[x] && ((strcasecmp(vms->curbox, "INBOX") && strcasecmp(vms->curbox, "Urgent")) || !vms->heard[x] || (vms->heard[x] && !ast_test_flag(vmu, VM_MOVEHEARD)))) { 
         /* Save this message.  It's not in INBOX or hasn't been heard */ 
         make_file(vms->fn, sizeof(vms->fn), vms->curdir, x); 
         if (!EXISTS(vms->curdir, x, vms->fn, NULL)) 
            break;
         vms->curmsg++; 
         make_file(fn2, sizeof(fn2), vms->curdir, vms->curmsg); 
         if (strcmp(vms->fn, fn2)) { 
            RENAME(vms->curdir, x, vmu->mailbox, vmu->context, vms->curdir, vms->curmsg, vms->fn, fn2);
         } 
      } else if ((!strcasecmp(vms->curbox, "INBOX") || !strcasecmp(vms->curbox, "Urgent")) && vms->heard[x] && ast_test_flag(vmu, VM_MOVEHEARD) && !vms->deleted[x]) { 
         /* Move to old folder before deleting */ 
         res = save_to_folder(vmu, vms, x, 1);
         if (res == ERROR_LOCK_PATH) {
            /* If save failed do not delete the message */
            ast_log(AST_LOG_WARNING, "Save failed.  Not moving message: %s.\n", res == ERROR_LOCK_PATH ? "unable to lock path" : "destination folder full");
            vms->deleted[x] = 0;
            vms->heard[x] = 0;
            --x;
         }
      } else if (vms->deleted[x] && vmu->maxdeletedmsg) {
         /* Move to deleted folder */ 
         res = save_to_folder(vmu, vms, x, 10);
         if (res == ERROR_LOCK_PATH) {
            /* If save failed do not delete the message */
            vms->deleted[x] = 0;
            vms->heard[x] = 0;
            --x;
         }
      } else if (vms->deleted[x] && ast_check_realtime("voicemail_data")) {
         /* If realtime storage enabled - we should explicitly delete this message,
         cause RENAME() will overwrite files, but will keep duplicate records in RT-storage */
         make_file(vms->fn, sizeof(vms->fn), vms->curdir, x);
         if (EXISTS(vms->curdir, x, vms->fn, NULL))
            DELETE(vms->curdir, x, vms->fn, vmu);
      }
   } 

   /* Delete ALL remaining messages */
   nummsg = x - 1;
   for (x = vms->curmsg + 1; x <= nummsg; x++) {
      make_file(vms->fn, sizeof(vms->fn), vms->curdir, x);
      if (EXISTS(vms->curdir, x, vms->fn, NULL))
         DELETE(vms->curdir, x, vms->fn, vmu);
   }
   ast_unlock_path(vms->curdir);
#else
   if (vms->deleted) {
      for (x = 0; x < vmu->maxmsg; x++) { 
         if (vms->deleted[x]) { 
            ast_debug(3, "IMAP delete of %d\n", x);
            DELETE(vms->curdir, x, vms->fn, vmu);
         }
      }
   }
#endif

done:
   if (vms->deleted)
      memset(vms->deleted, 0, vmu->maxmsg * sizeof(int)); 
   if (vms->heard)
      memset(vms->heard, 0, vmu->maxmsg * sizeof(int)); 

   return 0;
}

static char* complete_voicemail_show_users	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)			[static]

Definition at line 10091 of file app_voicemail.c.

References AST_LIST_TRAVERSE, ast_strdup, and ast_vm_user::context.

Referenced by handle_voicemail_show_users().

{
   int which = 0;
   int wordlen;
   struct ast_vm_user *vmu;
   const char *context = "";

   /* 0 - show; 1 - voicemail; 2 - users; 3 - for; 4 - <context> */
   if (pos > 4)
      return NULL;
   if (pos == 3)
      return (state == 0) ? ast_strdup("for") : NULL;
   wordlen = strlen(word);
   AST_LIST_TRAVERSE(&users, vmu, list) {
      if (!strncasecmp(word, vmu->context, wordlen)) {
         if (context && strcmp(context, vmu->context) && ++which > state)
            return ast_strdup(vmu->context);
         /* ignore repeated contexts ? */
         context = vmu->context;
      }
   }
   return NULL;
}

static int copy	(	char *	infile,
		char *	outfile
	)			[static]

Utility function to copy a file.

Parameters:

	infile	The path to the file to be copied. The file must be readable, it is opened in read only mode.
	outfile	The path for which to copy the file to. The directory permissions must allow the creation (or truncation) of the file, and allow for opening the file in write only mode.

When the compiler option HARDLINK_WHEN_POSSIBLE is set, the copy operation will attempt to use the hard link facility instead of copy the file (to save disk space). If the link operation fails, it falls back to the copy operation. The copy operation copies up to 4096 bytes at once.

Returns:

zero on success, -1 on error.

Definition at line 3723 of file app_voicemail.c.

References ast_log(), AST_LOG_WARNING, errno, and VOICEMAIL_FILE_MODE.

Referenced by ast_filehelper(), ast_func_read(), ast_func_read2(), ast_func_write(), copy_plain_file(), and iax2_register().

{
   int ifd;
   int ofd;
   int res;
   int len;
   char buf[4096];

#ifdef HARDLINK_WHEN_POSSIBLE
   /* Hard link if possible; saves disk space & is faster */
   if (link(infile, outfile)) {
#endif
      if ((ifd = open(infile, O_RDONLY)) < 0) {
         ast_log(AST_LOG_WARNING, "Unable to open %s in read-only mode: %s\n", infile, strerror(errno));
         return -1;
      }
      if ((ofd = open(outfile, O_WRONLY | O_TRUNC | O_CREAT, VOICEMAIL_FILE_MODE)) < 0) {
         ast_log(AST_LOG_WARNING, "Unable to open %s in write-only mode: %s\n", outfile, strerror(errno));
         close(ifd);
         return -1;
      }
      do {
         len = read(ifd, buf, sizeof(buf));
         if (len < 0) {
            ast_log(AST_LOG_WARNING, "Read failed on %s: %s\n", infile, strerror(errno));
            close(ifd);
            close(ofd);
            unlink(outfile);
         }
         if (len) {
            res = write(ofd, buf, len);
            if (errno == ENOMEM || errno == ENOSPC || res != len) {
               ast_log(AST_LOG_WARNING, "Write failed on %s (%d of %d): %s\n", outfile, res, len, strerror(errno));
               close(ifd);
               close(ofd);
               unlink(outfile);
            }
         }
      } while (len);
      close(ifd);
      close(ofd);
      return 0;
#ifdef HARDLINK_WHEN_POSSIBLE
   } else {
      /* Hard link succeeded */
      return 0;
   }
#endif
}

static int copy_message	(	struct ast_channel *	chan,
		struct ast_vm_user *	vmu,
		int	imbox,
		int	msgnum,
		long	duration,
		struct ast_vm_user *	recip,
		char *	fmt,
		char *	dir,
		const char *	flag
	)			[static]

Copies a message from one mailbox to another.

Parameters:

	chan
	vmu
	imbox
	msgnum
	duration
	recip
	fmt
	dir	This is only used by file storage based mailboxes.

Returns:

zero on success, -1 on error.

Definition at line 4935 of file app_voicemail.c.

References ast_copy_string(), ast_log(), AST_LOG_ERROR, AST_LOG_NOTICE, ast_strlen_zero(), ast_unlock_path(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, ast_vm_user::context, COPY, copy_plain_file(), create_dirpath(), ERROR_LOCK_PATH, EXISTS, ast_channel::language, last_message_index(), ast_vm_user::mailbox, make_dir(), make_file(), mbox(), notify_new_message(), S_OR, STORE, vm_delete(), and vm_lock_path().

Referenced by forward_message(), and leave_voicemail().

{
   char fromdir[PATH_MAX], todir[PATH_MAX], frompath[PATH_MAX], topath[PATH_MAX];
   const char *frombox = mbox(imbox);
   int recipmsgnum;

   ast_log(AST_LOG_NOTICE, "Copying message from %s@%s to %s@%s\n", vmu->mailbox, vmu->context, recip->mailbox, recip->context);

   if (!ast_strlen_zero(flag) && !strcmp(flag, "Urgent")) { /* If urgent, copy to Urgent folder */
      create_dirpath(todir, sizeof(todir), recip->context, recip->mailbox, "Urgent");
   } else {
      create_dirpath(todir, sizeof(todir), recip->context, recip->mailbox, "INBOX");
   }
   
   if (!dir)
      make_dir(fromdir, sizeof(fromdir), vmu->context, vmu->mailbox, frombox);
   else
      ast_copy_string(fromdir, dir, sizeof(fromdir));

   make_file(frompath, sizeof(frompath), fromdir, msgnum);
   make_dir(todir, sizeof(todir), recip->context, recip->mailbox, "INBOX");

   if (vm_lock_path(todir))
      return ERROR_LOCK_PATH;

   recipmsgnum = last_message_index(recip, todir) + 1;
   if (recipmsgnum < recip->maxmsg) {
      make_file(topath, sizeof(topath), todir, recipmsgnum);
      if (EXISTS(fromdir, msgnum, frompath, chan->language)) {
         COPY(fromdir, msgnum, todir, recipmsgnum, recip->mailbox, recip->context, frompath, topath);
      } else {
         /* For ODBC storage, if the file we want to copy isn't yet in the database, then the SQL
          * copy will fail. Instead, we need to create a local copy, store it, and delete the local
          * copy. We don't have to #ifdef this because if file storage reaches this point, there's a
          * much worse problem happening and IMAP storage doesn't call this function
          */
         copy_plain_file(frompath, topath);
         STORE(todir, recip->mailbox, recip->context, recipmsgnum, chan, recip, fmt, duration, NULL, NULL);
         vm_delete(topath);
      }
   } else {
      ast_log(AST_LOG_ERROR, "Recipient mailbox %s@%s is full\n", recip->mailbox, recip->context);
   }
   ast_unlock_path(todir);
   notify_new_message(chan, recip, NULL, recipmsgnum, duration, fmt, S_OR(chan->cid.cid_num, NULL), S_OR(chan->cid.cid_name, NULL), flag);
   
   return 0;
}

static void copy_plain_file	(	char *	frompath,
		char *	topath
	)			[static]

Copies a voicemail information (envelope) file.

Parameters:

	frompath
	topath

Every voicemail has the data (.wav) file, and the information file. This function performs the file system copying of the information file for a voicemail, handling the internal fields and their values. This is used by the COPY macro when not using IMAP storage.

Definition at line 3782 of file app_voicemail.c.

References ast_check_realtime(), ast_filecopy(), ast_load_realtime(), ast_store_realtime(), ast_variables_destroy(), copy(), exten, ast_variable::name, ast_variable::next, SENTINEL, and ast_variable::value.

Referenced by copy_message().

{
   char frompath2[PATH_MAX], topath2[PATH_MAX];
   struct ast_variable *tmp,*var = NULL;
   const char *origmailbox = NULL, *context = NULL, *macrocontext = NULL, *exten = NULL, *priority = NULL, *callerchan = NULL, *callerid = NULL, *origdate = NULL, *origtime = NULL, *category = NULL, *duration = NULL;
   ast_filecopy(frompath, topath, NULL);
   snprintf(frompath2, sizeof(frompath2), "%s.txt", frompath);
   snprintf(topath2, sizeof(topath2), "%s.txt", topath);
   if (ast_check_realtime("voicemail_data")) {
      var = ast_load_realtime("voicemail_data", "filename", frompath, SENTINEL);
      /* This cycle converts ast_variable linked list, to va_list list of arguments, may be there is a better way to do it? */
      for (tmp = var; tmp; tmp = tmp->next) {
         if (!strcasecmp(tmp->name, "origmailbox")) {
            origmailbox = tmp->value;
         } else if (!strcasecmp(tmp->name, "context")) {
            context = tmp->value;
         } else if (!strcasecmp(tmp->name, "macrocontext")) {
            macrocontext = tmp->value;
         } else if (!strcasecmp(tmp->name, "exten")) {
            exten = tmp->value;
         } else if (!strcasecmp(tmp->name, "priority")) {
            priority = tmp->value;
         } else if (!strcasecmp(tmp->name, "callerchan")) {
            callerchan = tmp->value;
         } else if (!strcasecmp(tmp->name, "callerid")) {
            callerid = tmp->value;
         } else if (!strcasecmp(tmp->name, "origdate")) {
            origdate = tmp->value;
         } else if (!strcasecmp(tmp->name, "origtime")) {
            origtime = tmp->value;
         } else if (!strcasecmp(tmp->name, "category")) {
            category = tmp->value;
         } else if (!strcasecmp(tmp->name, "duration")) {
            duration = tmp->value;
         }
      }
      ast_store_realtime("voicemail_data", "filename", topath, "origmailbox", origmailbox, "context", context, "macrocontext", macrocontext, "exten", exten, "priority", priority, "callerchan", callerchan, "callerid", callerid, "origdate", origdate, "origtime", origtime, "category", category, "duration", duration, SENTINEL);
   }
   copy(frompath2, topath2);
   ast_variables_destroy(var);
}

static int count_messages	(	struct ast_vm_user *	vmu,
		char *	dir
	)			[static]

Find all .txt files - even if they are not in sequence from 0000.

Parameters:

	vmu
	dir	This method is used when mailboxes are stored on the filesystem. (not ODBC and not IMAP).

Returns:

the count of messages, zero or more.

Definition at line 3626 of file app_voicemail.c.

References ast_unlock_path(), ERROR_LOCK_PATH, and vm_lock_path().

Referenced by leave_voicemail(), manager_list_voicemail_users(), and open_mailbox().

{

   int vmcount = 0;
   DIR *vmdir = NULL;
   struct dirent *vment = NULL;

   if (vm_lock_path(dir))
      return ERROR_LOCK_PATH;

   if ((vmdir = opendir(dir))) {
      while ((vment = readdir(vmdir))) {
         if (strlen(vment->d_name) > 7 && !strncmp(vment->d_name + 7, ".txt", 4)) {
            vmcount++;
         }
      }
      closedir(vmdir);
   }
   ast_unlock_path(dir);
   
   return vmcount;
}

static int create_dirpath	(	char *	dest,
		int	len,
		const char *	context,
		const char *	ext,
		const char *	folder
	)			[static]

basically mkdir -p $dest/$context/$ext/$folder

Parameters:

	dest	String. base directory.
	len	Length of dest.
	context	String. Ignored if is null or empty string.
	ext	String. Ignored if is null or empty string.
	folder	String. Ignored if is null or empty string.

Returns:

-1 on failure, 0 on success.

Definition at line 1492 of file app_voicemail.c.

References ast_log(), AST_LOG_WARNING, ast_mkdir(), make_dir(), and VOICEMAIL_DIR_MODE.

{
   mode_t   mode = VOICEMAIL_DIR_MODE;
   int res;

   make_dir(dest, len, context, ext, folder);
   if ((res = ast_mkdir(dest, mode))) {
      ast_log(AST_LOG_WARNING, "ast_mkdir '%s' failed: %s\n", dest, strerror(res));
      return -1;
   }
   return 0;
}

static int dialout	(	struct ast_channel *	chan,
		struct ast_vm_user *	vmu,
		char *	num,
		char *	outgoing_context
	)			[static]

Definition at line 11401 of file app_voicemail.c.

References ast_copy_string(), ast_play_and_wait(), ast_readstring(), ast_strlen_zero(), ast_verb, ast_verbose, ast_waitfordigit(), ast_channel::context, ast_channel::exten, option_verbose, ast_channel::priority, and VERBOSE_PREFIX_3.

Referenced by advanced_options(), and vm_execmain().

{
   int cmd = 0;
   char destination[80] = "";
   int retries = 0;

   if (!num) {
      ast_verb(3, "Destination number will be entered manually\n");
      while (retries < 3 && cmd != 't') {
         destination[1] = '\0';
         destination[0] = cmd = ast_play_and_wait(chan, "vm-enter-num-to-call");
         if (!cmd)
            destination[0] = cmd = ast_play_and_wait(chan, "vm-then-pound");
         if (!cmd)
            destination[0] = cmd = ast_play_and_wait(chan, "vm-star-cancel");
         if (!cmd) {
            cmd = ast_waitfordigit(chan, 6000);
            if (cmd)
               destination[0] = cmd;
         }
         if (!cmd) {
            retries++;
         } else {

            if (cmd < 0)
               return 0;
            if (cmd == '*') {
               ast_verb(3, "User hit '*' to cancel outgoing call\n");
               return 0;
            }
            if ((cmd = ast_readstring(chan, destination + strlen(destination), sizeof(destination) - 1, 6000, 10000, "#")) < 0) 
               retries++;
            else
               cmd = 't';
         }
      }
      if (retries >= 3) {
         return 0;
      }
      
   } else {
      if (option_verbose > 2)
         ast_verbose( VERBOSE_PREFIX_3 "Destination number is CID number '%s'\n", num);
      ast_copy_string(destination, num, sizeof(destination));
   }

   if (!ast_strlen_zero(destination)) {
      if (destination[strlen(destination) -1 ] == '*')
         return 0; 
      if (option_verbose > 2)
         ast_verbose( VERBOSE_PREFIX_3 "Placing outgoing call to extension '%s' in context '%s' from context '%s'\n", destination, outgoing_context, chan->context);
      ast_copy_string(chan->exten, destination, sizeof(chan->exten));
      ast_copy_string(chan->context, outgoing_context, sizeof(chan->context));
      chan->priority = 0;
      return 9;
   }
   return 0;
}

static struct ast_vm_user* find_or_create	(	const char *	context,
		const char *	box
	)			[static, read]

Definition at line 9868 of file app_voicemail.c.

References ast_calloc, ast_copy_string(), AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_test_flag, ast_vm_user::context, globalflags, LOG_WARNING, ast_vm_user::mailbox, and VM_SEARCH.

Referenced by append_mailbox(), and load_config().

{
   struct ast_vm_user *vmu;

   AST_LIST_TRAVERSE(&users, vmu, list) {
      if (ast_test_flag((&globalflags), VM_SEARCH) && !strcasecmp(box, vmu->mailbox)) {
         if (strcasecmp(vmu->context, context)) {
            ast_log(LOG_WARNING, "\nIt has been detected that you have defined mailbox '%s' in separate\
                  \n\tcontexts and that you have the 'searchcontexts' option on. This type of\
                  \n\tconfiguration creates an ambiguity that you likely do not want. Please\
                  \n\tamend your voicemail.conf file to avoid this situation.\n", box);
         }
         ast_log(LOG_WARNING, "Ignoring duplicated mailbox %s\n", box);
         return NULL;
      }
      if (!strcasecmp(context, vmu->context) && !strcasecmp(box, vmu->mailbox)) {
         ast_log(LOG_WARNING, "Ignoring duplicated mailbox %s in context %s\n", box, context);
         return NULL;
      }
   }
   
   if (!(vmu = ast_calloc(1, sizeof(*vmu))))
      return NULL;
   
   ast_copy_string(vmu->context, context, sizeof(vmu->context));
   ast_copy_string(vmu->mailbox, box, sizeof(vmu->mailbox));

   AST_LIST_INSERT_TAIL(&users, vmu, list);
   
   return vmu;
}

static struct ast_vm_user* find_user	(	struct ast_vm_user *	ivm,
		const char *	context,
		const char *	mailbox
	)			[static, read]

Finds a voicemail user from the users file or the realtime engine.

Parameters:

	ivm
	context
	mailbox

Returns:

The ast_vm_user structure for the user that was found.

Definition at line 1259 of file app_voicemail.c.

References AST_LIST_LOCK, AST_LIST_NEXT, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_malloc, ast_set2_flag, ast_test_flag, find_user_realtime(), globalflags, VM_ALLOCED, and VM_SEARCH.

{
   /* This function could be made to generate one from a database, too */
   struct ast_vm_user *vmu = NULL, *cur;
   AST_LIST_LOCK(&users);

   if (!context && !ast_test_flag((&globalflags), VM_SEARCH))
      context = "default";

   AST_LIST_TRAVERSE(&users, cur, list) {
#ifdef IMAP_STORAGE
      if (cur->imapversion != imapversion) {
         continue;
      }
#endif
      if (ast_test_flag((&globalflags), VM_SEARCH) && !strcasecmp(mailbox, cur->mailbox))
         break;
      if (context && (!strcasecmp(context, cur->context)) && (!strcasecmp(mailbox, cur->mailbox)))
         break;
   }
   if (cur) {
      /* Make a copy, so that on a reload, we have no race */
      if ((vmu = (ivm ? ivm : ast_malloc(sizeof(*vmu))))) {
         memcpy(vmu, cur, sizeof(*vmu));
         ast_set2_flag(vmu, !ivm, VM_ALLOCED);
         AST_LIST_NEXT(vmu, list) = NULL;
      }
   } else
      vmu = find_user_realtime(ivm, context, mailbox);
   AST_LIST_UNLOCK(&users);
   return vmu;
}

static struct ast_vm_user* find_user_realtime	(	struct ast_vm_user *	ivm,
		const char *	context,
		const char *	mailbox
	)			[static, read]

Finds a voicemail user from the realtime engine.

Parameters:

	ivm
	context
	mailbox	This is called as a fall through case when the normal find_user() was not able to find a user. That is, the default it so look in the usual voicemail users file first.

Returns:

The ast_vm_user structure for the user that was found.

Definition at line 1222 of file app_voicemail.c.

References apply_options_full(), ast_calloc, ast_copy_string(), ast_free, ast_load_realtime(), ast_set_flag, ast_test_flag, ast_variables_destroy(), globalflags, ast_vm_user::mailbox, populate_defaults(), SENTINEL, var, VM_ALLOCED, and VM_SEARCH.

{
   struct ast_variable *var;
   struct ast_vm_user *retval;

   if ((retval = (ivm ? ivm : ast_calloc(1, sizeof(*retval))))) {
      if (!ivm)
         ast_set_flag(retval, VM_ALLOCED);   
      else
         memset(retval, 0, sizeof(*retval));
      if (mailbox) 
         ast_copy_string(retval->mailbox, mailbox, sizeof(retval->mailbox));
      populate_defaults(retval);
      if (!context && ast_test_flag((&globalflags), VM_SEARCH))
         var = ast_load_realtime("voicemail", "mailbox", mailbox, SENTINEL);
      else
         var = ast_load_realtime("voicemail", "mailbox", mailbox, "context", context, SENTINEL);
      if (var) {
         apply_options_full(retval, var);
         ast_variables_destroy(var);
      } else { 
         if (!ivm) 
            ast_free(retval);
         retval = NULL;
      }  
   } 
   return retval;
}

static int forward_message	(	struct ast_channel *	chan,
		char *	context,
		struct vm_state *	vms,
		struct ast_vm_user *	sender,
		char *	fmt,
		int	is_new_message,
		signed char	record_gain,
		int	urgent
	)			[static]

Sends a voicemail message to a mailbox recipient.

Parameters:

	ast_channel
	context
	vms
	sender
	fmt
	is_new_message	Used to indicate the mode for which this method was invoked. Will be 0 when called to forward an existing message (option 8) Will be 1 when called to leave a message (option 3->5)
	record_gain

Reads the destination mailbox(es) from keypad input for CID, or if use_directory feature is enabled, the Directory.

When in the leave message mode (is_new_message == 1):

• allow the leaving of a message for ourselves. (Will not allow us to forward a message to ourselves, when is_new_message == 0).
• attempt to determine the context and and mailbox, and then invoke leave_message() function to record and store the message.

When in the forward message mode (is_new_message == 0):

• retreives the current message to be forwarded
• copies the original message to a temporary file, so updates to the envelope can be done.
• determines the target mailbox and folders
• copies the message into the target mailbox, using copy_message() or by generating the message into an email attachment if using imap folders.

Returns:

zero on success, -1 on error.

Definition at line 6601 of file app_voicemail.c.

References ast_clear_flag, ast_copy_string(), ast_fileexists(), AST_LIST_EMPTY, AST_LIST_HEAD_NOLOCK_STATIC, AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), AST_LOG_ERROR, AST_LOG_WARNING, AST_MAX_EXTENSION, ast_play_and_wait(), ast_readstring(), ast_say_digit_str(), ast_stream_and_wait(), ast_streamfile(), ast_strlen_zero(), ast_test_flag, ast_waitfordigit(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, ast_vm_user::context, ast_channel::context, copy_message(), vm_state::curbox, vm_state::curdir, vm_state::curmsg, DISPOSE, ast_channel::exten, find_user(), vm_state::fn, free_user(), globalflags, ast_channel::language, leave_voicemail(), LOG_NOTICE, ast_vm_user::mailbox, pbx_exec(), pbx_findapp(), ast_channel::priority, leave_vm_options::record_gain, RETRIEVE, run_externnotify(), s, S_OR, sendmail(), STORE, strsep(), vm_state::username, VM_ATTACH, VM_DIRECFORWARD, vm_forwardoptions(), and VM_FWDURGAUTO.

Referenced by vm_execmain().

{
#ifdef IMAP_STORAGE
   int todircount = 0;
   struct vm_state *dstvms;
#endif
   char username[70]="";
   char fn[PATH_MAX]; /* for playback of name greeting */
   char ecodes[16] = "#";
   int res = 0, cmd = 0;
   struct ast_vm_user *receiver = NULL, *vmtmp;
   AST_LIST_HEAD_NOLOCK_STATIC(extensions, ast_vm_user);
   char *stringp;
   const char *s;
   int saved_messages = 0, found = 0;
   int valid_extensions = 0;
   char *dir;
   int curmsg;
   char urgent_str[7] = "";
   char tmptxtfile[PATH_MAX];

   if (ast_test_flag((&globalflags), VM_FWDURGAUTO)) {
      ast_copy_string(urgent_str, urgent ? "Urgent" : "", sizeof(urgent_str));
   }

   if (vms == NULL) return -1;
   dir = vms->curdir;
   curmsg = vms->curmsg;

   tmptxtfile[0] = '\0';
   while (!res && !valid_extensions) {
      int use_directory = 0;
      if (ast_test_flag((&globalflags), VM_DIRECFORWARD)) {
         int done = 0;
         int retries = 0;
         cmd = 0;
         while ((cmd >= 0) && !done ){
            if (cmd)
               retries = 0;
            switch (cmd) {
            case '1': 
               use_directory = 0;
               done = 1;
               break;
            case '2': 
               use_directory = 1;
               done = 1;
               break;
            case '*': 
               cmd = 't';
               done = 1;
               break;
            default: 
               /* Press 1 to enter an extension press 2 to use the directory */
               cmd = ast_play_and_wait(chan, "vm-forward");
               if (!cmd)
                  cmd = ast_waitfordigit(chan, 3000);
               if (!cmd)
                  retries++;
               if (retries > 3) {
                  cmd = 't';
                  done = 1;
               }
               
            }
         }
         if (cmd < 0 || cmd == 't')
            break;
      }
      
      if (use_directory) {
         /* use app_directory */
         
         char old_context[sizeof(chan->context)];
         char old_exten[sizeof(chan->exten)];
         int old_priority;
         struct ast_app* directory_app;

         directory_app = pbx_findapp("Directory");
         if (directory_app) {
            char vmcontext[256];
            /* make backup copies */
            memcpy(old_context, chan->context, sizeof(chan->context));
            memcpy(old_exten, chan->exten, sizeof(chan->exten));
            old_priority = chan->priority;
            
            /* call the the Directory, changes the channel */
            snprintf(vmcontext, sizeof(vmcontext), "%s,,v", context ? context : "default");
            res = pbx_exec(chan, directory_app, vmcontext);
            
            ast_copy_string(username, chan->exten, sizeof(username));
            
            /* restore the old context, exten, and priority */
            memcpy(chan->context, old_context, sizeof(chan->context));
            memcpy(chan->exten, old_exten, sizeof(chan->exten));
            chan->priority = old_priority;
         } else {
            ast_log(AST_LOG_WARNING, "Could not find the Directory application, disabling directory_forward\n");
            ast_clear_flag((&globalflags), VM_DIRECFORWARD);
         }
      } else {
         /* Ask for an extension */
         res = ast_streamfile(chan, "vm-extension", chan->language); /* "extension" */
         if (res)
            break;
         if ((res = ast_readstring(chan, username, sizeof(username) - 1, 2000, 10000, "#") < 0))
            break;
      }
      
      /* start all over if no username */
      if (ast_strlen_zero(username))
         continue;
      stringp = username;
      s = strsep(&stringp, "*");
      /* start optimistic */
      valid_extensions = 1;
      while (s) {
         if ((is_new_message == 1 || strcmp(s, sender->mailbox)) && (receiver = find_user(NULL, context, s))) {
            AST_LIST_INSERT_HEAD(&extensions, receiver, list);
            found++;
         } else {
            /* XXX Optimization for the future.  When we encounter a single bad extension,
             * bailing out on all of the extensions may not be the way to go.  We should
             * probably just bail on that single extension, then allow the user to enter
             * several more. XXX
             */
            while ((receiver = AST_LIST_REMOVE_HEAD(&extensions, list))) {
               free_user(receiver);
            }
            ast_log(LOG_NOTICE, "'%s' is not a valid mailbox\n", s);
            valid_extensions = 0;
            break;
         }

         /* play name if available, else play extension number */
         snprintf(fn, sizeof(fn), "%s%s/%s/greet", VM_SPOOL_DIR, receiver->context, s);
         RETRIEVE(fn, -1, s, receiver->context);
         if (ast_fileexists(fn, NULL, NULL) > 0) {
            res = ast_stream_and_wait(chan, fn, ecodes);
            if (res) {
               DISPOSE(fn, -1);
               return res;
            }
         } else {
            res = ast_say_digit_str(chan, s, ecodes, chan->language);
         }
         DISPOSE(fn, -1);

         s = strsep(&stringp, "*");
      }
      /* break from the loop of reading the extensions */
      if (valid_extensions)
         break;
      /* "I am sorry, that's not a valid extension.  Please try again." */
      res = ast_play_and_wait(chan, "pbx-invalid");
   }
   /* check if we're clear to proceed */
   if (AST_LIST_EMPTY(&extensions) || !valid_extensions)
      return res;
   if (is_new_message == 1) {
      struct leave_vm_options leave_options;
      char mailbox[AST_MAX_EXTENSION * 2 + 2];
      snprintf(mailbox, sizeof(mailbox), "%s@%s", username, context);

      /* Send VoiceMail */
      memset(&leave_options, 0, sizeof(leave_options));
      leave_options.record_gain = record_gain;
      cmd = leave_voicemail(chan, mailbox, &leave_options);
   } else {
      /* Forward VoiceMail */
      long duration = 0;
      struct vm_state vmstmp;
      memcpy(&vmstmp, vms, sizeof(vmstmp));

      RETRIEVE(dir, curmsg, sender->mailbox, sender->context);

      cmd = vm_forwardoptions(chan, sender, vmstmp.curdir, curmsg, vmfmts, S_OR(context, "default"), record_gain, &duration, &vmstmp, urgent_str);
      if (!cmd) {
         AST_LIST_TRAVERSE_SAFE_BEGIN(&extensions, vmtmp, list) {
#ifdef IMAP_STORAGE
            int attach_user_voicemail;
            char *myserveremail = serveremail;
            
            /* get destination mailbox */
            dstvms = get_vm_state_by_mailbox(vmtmp->mailbox, vmtmp->context, 0);
            if (!dstvms) {
               dstvms = create_vm_state_from_user(vmtmp);
            }
            if (dstvms) {
               init_mailstream(dstvms, 0);
               if (!dstvms->mailstream) {
                  ast_log(AST_LOG_ERROR, "IMAP mailstream for %s is NULL\n", vmtmp->mailbox);
               } else {
                  STORE(vmstmp.curdir, vmtmp->mailbox, vmtmp->context, dstvms->curmsg, chan, vmtmp, fmt, duration, dstvms, urgent_str);
                  run_externnotify(vmtmp->context, vmtmp->mailbox, urgent_str); 
               }
            } else {
               ast_log(AST_LOG_ERROR, "Could not find state information for mailbox %s\n", vmtmp->mailbox);
            }
            if (!ast_strlen_zero(vmtmp->serveremail))
               myserveremail = vmtmp->serveremail;
            attach_user_voicemail = ast_test_flag(vmtmp, VM_ATTACH);
            /* NULL category for IMAP storage */
            sendmail(myserveremail, vmtmp, todircount, vmtmp->context, vmtmp->mailbox, dstvms->curbox, S_OR(chan->cid.cid_num, NULL), S_OR(chan->cid.cid_name, NULL), vmstmp.fn, vmstmp.introfn, fmt, duration, attach_user_voicemail, chan, NULL, urgent_str);
#else
            copy_message(chan, sender, 0, curmsg, duration, vmtmp, fmt, dir, urgent_str);
#endif
            saved_messages++;
            AST_LIST_REMOVE_CURRENT(list);
            free_user(vmtmp);
            if (res)
               break;
         }
         AST_LIST_TRAVERSE_SAFE_END;
         if (saved_messages > 0) {
            /* give confirmation that the message was saved */
            /* commented out since we can't forward batches yet
            if (saved_messages == 1)
               res = ast_play_and_wait(chan, "vm-message");
            else
               res = ast_play_and_wait(chan, "vm-messages");
            if (!res)
               res = ast_play_and_wait(chan, "vm-saved"); */
#ifdef IMAP_STORAGE
            /* If forwarded with intro, DON'T PLAY THIS MESSAGE AGAIN! */
            if (ast_strlen_zero(vmstmp.introfn))
#endif
            res = ast_play_and_wait(chan, "vm-msgsaved");
         }  
      }
      DISPOSE(dir, curmsg);
   }

   /* If anything failed above, we still have this list to free */
   while ((vmtmp = AST_LIST_REMOVE_HEAD(&extensions, list)))
      free_user(vmtmp);
   return res ? res : cmd;
}

static void free_user

(

struct ast_vm_user *

vmu

)

[static]

Definition at line 1542 of file app_voicemail.c.

References ast_free, ast_test_flag, ast_vm_user::emailbody, ast_vm_user::emailsubject, and VM_ALLOCED.

{
   if (ast_test_flag(vmu, VM_ALLOCED)) {
      if (vmu->emailbody != NULL) {
         ast_free(vmu->emailbody);
         vmu->emailbody = NULL;
      }
      if (vmu->emailsubject != NULL) {
         ast_free(vmu->emailsubject);
         vmu->emailsubject = NULL;
      }
      ast_free(vmu);
   }
}

static void free_vm_users

(

void

)

[static]

Free the users structure.

Definition at line 10548 of file app_voicemail.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_set_flag, free_user(), and VM_ALLOCED.

Referenced by load_config(), and unload_module().

{
   struct ast_vm_user *current;
   AST_LIST_LOCK(&users);
   while ((current = AST_LIST_REMOVE_HEAD(&users, list))) {
      ast_set_flag(current, VM_ALLOCED);
      free_user(current);
   }
   AST_LIST_UNLOCK(&users);
}

static void free_vm_zones

(

void

)

[static]

Free the zones structure.

Definition at line 10560 of file app_voicemail.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and free_zone().

Referenced by load_config(), and unload_module().

{
   struct vm_zone *zcur;
   AST_LIST_LOCK(&zones);
   while ((zcur = AST_LIST_REMOVE_HEAD(&zones, list)))
      free_zone(zcur);
   AST_LIST_UNLOCK(&zones);
}

static void free_zone

(

struct vm_zone *

z

)

[static]

Definition at line 4702 of file app_voicemail.c.

References ast_free.

{
   ast_free(z);
}

static int get_date	(	char *	s,
		int	len
	)			[static]

Gets the current date and time, as formatted string.

Parameters:

	s	The buffer to hold the output formatted date.
	len	the length of the buffer. Used to prevent buffer overflow in ast_strftime.

The date format string used is "%a %b %e %r UTC %Y".

Returns:

zero on success, -1 on error.

Definition at line 4658 of file app_voicemail.c.

References ast_localtime(), ast_strftime(), and ast_tvnow().

{
   struct ast_tm tm;
   struct timeval t = ast_tvnow();
   
   ast_localtime(&t, &tm, "UTC");

   return ast_strftime(s, len, "%a %b %e %r UTC %Y", &tm);
}

static int get_folder	(	struct ast_channel *	chan,
		int	start
	)			[static]

get_folder: Folder menu Plays "press 1 for INBOX messages" etc. Should possibly be internationalized

Definition at line 6267 of file app_voicemail.c.

References AST_DIGIT_ANY, ast_play_and_wait(), ast_say_number(), ast_waitfordigit(), ast_channel::language, mbox(), and vm_play_folder_name().

Referenced by get_folder2().

{
   int x;
   int d;
   char fn[PATH_MAX];
   d = ast_play_and_wait(chan, "vm-press");  /* "Press" */
   if (d)
      return d;
   for (x = start; x < 5; x++) { /* For all folders */
      if ((d = ast_say_number(chan, x, AST_DIGIT_ANY, chan->language, NULL)))
         return d;
      d = ast_play_and_wait(chan, "vm-for"); /* "for" */
      if (d)
         return d;
      snprintf(fn, sizeof(fn), "vm-%s", mbox(x));  /* Folder name */
      d = vm_play_folder_name(chan, fn);
      if (d)
         return d;
      d = ast_waitfordigit(chan, 500);
      if (d)
         return d;
   }
   d = ast_play_and_wait(chan, "vm-tocancel"); /* "or pound to cancel" */
   if (d)
      return d;
   d = ast_waitfordigit(chan, 4000);
   return d;
}

static int get_folder2	(	struct ast_channel *	chan,
		char *	fn,
		int	start
	)			[static]

plays a prompt and waits for a keypress.

Parameters:

	chan
	fn	the name of the voice prompt file to be played. For example, 'vm-changeto', 'vm-savefolder'
	start	Does not appear to be used at this time.

This is used by the main menu option to move a message to a folder or to save a message into a folder. After playing the message identified by the fn parameter value, it calls get_folder(), which plays the prompting for the number inputs that correspond to the available folders.

Returns:

zero on success, or -1 on error.

Definition at line 6308 of file app_voicemail.c.

References ast_play_and_wait(), and get_folder().

Referenced by vm_execmain().

{
   int res = 0;
   res = ast_play_and_wait(chan, fn);  /* Folder name */
   while (((res < '0') || (res > '9')) &&
         (res != '#') && (res >= 0)) {
      res = get_folder(chan, 0);
   }
   return res;
}

static int get_folder_by_name

(

const char *

name

)

[static]

Definition at line 1529 of file app_voicemail.c.

References ARRAY_LEN, and mailbox_folders.

Referenced by vm_execmain().

{
   size_t i;

   for (i = 0; i < ARRAY_LEN(mailbox_folders); i++) {
      if (strcasecmp(name, mailbox_folders[i]) == 0) {
         return i;
      }
   }

   return -1;
}

static int handle_subscribe

(

void *

datap

)

[static]

Definition at line 10331 of file app_voicemail.c.

References ast_calloc, ast_free, AST_RWLIST_INSERT_TAIL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), mwi_sub_task::context, mwi_sub::mailbox, mwi_sub_task::mailbox, poll_subscribed_mailbox(), mwi_sub_task::uniqueid, and mwi_sub::uniqueid.

Referenced by mwi_sub_event_cb().

{
   unsigned int len;
   struct mwi_sub *mwi_sub;
   struct mwi_sub_task *p = datap;

   len = sizeof(*mwi_sub);
   if (!ast_strlen_zero(p->mailbox))
      len += strlen(p->mailbox);

   if (!ast_strlen_zero(p->context))
      len += strlen(p->context) + 1; /* Allow for seperator */

   if (!(mwi_sub = ast_calloc(1, len)))
      return -1;

   mwi_sub->uniqueid = p->uniqueid;
   if (!ast_strlen_zero(p->mailbox))
      strcpy(mwi_sub->mailbox, p->mailbox);

   if (!ast_strlen_zero(p->context)) {
      strcat(mwi_sub->mailbox, "@");
      strcat(mwi_sub->mailbox, p->context);
   }

   AST_RWLIST_WRLOCK(&mwi_subs);
   AST_RWLIST_INSERT_TAIL(&mwi_subs, mwi_sub, entry);
   AST_RWLIST_UNLOCK(&mwi_subs);
   ast_free((void *) p->mailbox);
   ast_free((void *) p->context);
   ast_free(p);
   poll_subscribed_mailbox(mwi_sub);
   return 0;
}

static int handle_unsubscribe

(

void *

datap

)

[static]

Definition at line 10309 of file app_voicemail.c.

References ast_free, AST_LIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, mwi_sub::entry, mwi_sub_destroy(), and mwi_sub::uniqueid.

Referenced by mwi_unsub_event_cb().

{
   struct mwi_sub *mwi_sub;
   uint32_t *uniqueid = datap;
   
   AST_RWLIST_WRLOCK(&mwi_subs);
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&mwi_subs, mwi_sub, entry) {
      if (mwi_sub->uniqueid == *uniqueid) {
         AST_LIST_REMOVE_CURRENT(entry);
         break;
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END
   AST_RWLIST_UNLOCK(&mwi_subs);

   if (mwi_sub)
      mwi_sub_destroy(mwi_sub);

   ast_free(uniqueid);  
   return 0;
}

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

Reload voicemail configuration from the CLI.

Definition at line 10226 of file app_voicemail.c.

References ast_cli_args::argc, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, load_config(), and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "voicemail reload";
      e->usage =
         "Usage: voicemail reload\n"
         "       Reload voicemail configuration\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 2)
      return CLI_SHOWUSAGE;

   ast_cli(a->fd, "Reloading voicemail configuration...\n");   
   load_config(1);
   
   return CLI_SUCCESS;
}

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

Show a list of voicemail users in the CLI.

Definition at line 10116 of file app_voicemail.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_check_realtime(), ast_cli(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_voicemail_show_users(), ast_vm_user::context, ast_cli_args::fd, ast_vm_user::fullname, HVSU_OUTPUT_FORMAT, inboxcount(), ast_cli_args::line, ast_vm_user::mailbox, ast_cli_args::n, ast_cli_args::pos, show_users_realtime(), ast_cli_entry::usage, ast_cli_args::word, and ast_vm_user::zonetag.

{
   struct ast_vm_user *vmu;
#define HVSU_OUTPUT_FORMAT "%-10s %-5s %-25s %-10s %6s\n"
   const char *context = NULL;
   int users_counter = 0;

   switch (cmd) {
   case CLI_INIT:
      e->command = "voicemail show users";
      e->usage =
         "Usage: voicemail show users [for <context>]\n"
         "       Lists all mailboxes currently set up\n";
      return NULL;
   case CLI_GENERATE:
      return complete_voicemail_show_users(a->line, a->word, a->pos, a->n);
   }  

   if ((a->argc < 3) || (a->argc > 5) || (a->argc == 4))
      return CLI_SHOWUSAGE;
   if (a->argc == 5) {
      if (strcmp(a->argv[3],"for"))
         return CLI_SHOWUSAGE;
      context = a->argv[4];
   }

   if (ast_check_realtime("voicemail")) {
      if (!context) {
         ast_cli(a->fd, "You must specify a specific context to show users from realtime!\n");
         return CLI_SHOWUSAGE;
      }
      return show_users_realtime(a->fd, context);
   }

   AST_LIST_LOCK(&users);
   if (AST_LIST_EMPTY(&users)) {
      ast_cli(a->fd, "There are no voicemail users currently defined\n");
      AST_LIST_UNLOCK(&users);
      return CLI_FAILURE;
   }
   if (a->argc == 3)
      ast_cli(a->fd, HVSU_OUTPUT_FORMAT, "Context", "Mbox", "User", "Zone", "NewMsg");
   else {
      int count = 0;
      AST_LIST_TRAVERSE(&users, vmu, list) {
         if (!strcmp(context, vmu->context))
            count++;
      }
      if (count) {
         ast_cli(a->fd, HVSU_OUTPUT_FORMAT, "Context", "Mbox", "User", "Zone", "NewMsg");
      } else {
         ast_cli(a->fd, "No such voicemail context \"%s\"\n", context);
         AST_LIST_UNLOCK(&users);
         return CLI_FAILURE;
      }
   }
   AST_LIST_TRAVERSE(&users, vmu, list) {
      int newmsgs = 0, oldmsgs = 0;
      char count[12], tmp[256] = "";

      if ((a->argc == 3) || ((a->argc == 5) && !strcmp(context, vmu->context))) {
         snprintf(tmp, sizeof(tmp), "%s@%s", vmu->mailbox, ast_strlen_zero(vmu->context) ? "default" : vmu->context);
         inboxcount(tmp, &newmsgs, &oldmsgs);
         snprintf(count, sizeof(count), "%d", newmsgs);
         ast_cli(a->fd, HVSU_OUTPUT_FORMAT, vmu->context, vmu->mailbox, vmu->fullname, vmu->zonetag, count);
         users_counter++;
      }
   }
   AST_LIST_UNLOCK(&users);
   ast_cli(a->fd, "%d voicemail users configured.\n", users_counter);
   return CLI_SUCCESS;
}

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

Show a list of voicemail zones in the CLI.

Definition at line 10190 of file app_voicemail.c.

References ast_cli_args::argc, ast_cli(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, HVSZ_OUTPUT_FORMAT, vm_zone::msg_format, vm_zone::name, vm_zone::timezone, and ast_cli_entry::usage.

{
   struct vm_zone *zone;
#define HVSZ_OUTPUT_FORMAT "%-15s %-20s %-45s\n"
   char *res = CLI_SUCCESS;

   switch (cmd) {
   case CLI_INIT:
      e->command = "voicemail show zones";
      e->usage =
         "Usage: voicemail show zones\n"
         "       Lists zone message formats\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 3)
      return CLI_SHOWUSAGE;

   AST_LIST_LOCK(&zones);
   if (!AST_LIST_EMPTY(&zones)) {
      ast_cli(a->fd, HVSZ_OUTPUT_FORMAT, "Zone", "Timezone", "Message Format");
      AST_LIST_TRAVERSE(&zones, zone, list) {
         ast_cli(a->fd, HVSZ_OUTPUT_FORMAT, zone->name, zone->timezone, zone->msg_format);
      }
   } else {
      ast_cli(a->fd, "There are no voicemail zones currently defined\n");
      res = CLI_FAILURE;
   }
   AST_LIST_UNLOCK(&zones);

   return res;
}

static int has_voicemail	(	const char *	mailbox,
		const char *	folder
	)			[static]

Determines if the given folder has messages.

Parameters:

	mailbox	The @ delimited string for user. If no context is found, uses 'default' for the context.
	folder	the folder to look in

This function is used when the mailbox is stored in a filesystem back end. This invokes the messagecount(). Here we are interested in the presence of messages (> 0) only, not the actual count.

Returns:

1 if the folder has one or more messages. zero otherwise.

Definition at line 5043 of file app_voicemail.c.

References __has_voicemail(), ast_copy_string(), and strsep().

Referenced by dahdi_handle_event(), do_monitor(), handle_hd_hf(), handle_init_event(), handle_request(), load_module(), mgcp_hangup(), mgcp_request(), mwi_send_init(), my_has_voicemail(), and vm_execmain().

{
   char tmp[256], *tmp2 = tmp, *box, *context;
   ast_copy_string(tmp, mailbox, sizeof(tmp));
   while ((box = strsep(&tmp2, ","))) {
      if ((context = strchr(box, '@')))
         *context++ = '\0';
      else
         context = "default";
      if (__has_voicemail(context, box, folder, 1))
         return 1;
   }
   return 0;
}

static int inboxcount	(	const char *	mailbox,
		int *	newmsgs,
		int *	oldmsgs
	)			[static]

Definition at line 5115 of file app_voicemail.c.

References inboxcount2().

Referenced by handle_voicemail_show_users(), leave_voicemail(), load_module(), and manager_list_voicemail_users().

{
   return inboxcount2(mailbox, NULL, newmsgs, oldmsgs);
}

static int inboxcount2	(	const char *	mailbox,
		int *	urgentmsgs,
		int *	newmsgs,
		int *	oldmsgs
	)			[static]

Definition at line 5059 of file app_voicemail.c.

References __has_voicemail(), ast_copy_string(), ast_strlen_zero(), and strsep().

Referenced by append_mailbox(), inboxcount(), load_module(), poll_subscribed_mailbox(), and run_externnotify().

{
   char tmp[256];
   char *context;

   /* If no mailbox, return immediately */
   if (ast_strlen_zero(mailbox))
      return 0;

   if (newmsgs)
      *newmsgs = 0;
   if (oldmsgs)
      *oldmsgs = 0;
   if (urgentmsgs)
      *urgentmsgs = 0;

   if (strchr(mailbox, ',')) {
      int tmpnew, tmpold, tmpurgent;
      char *mb, *cur;

      ast_copy_string(tmp, mailbox, sizeof(tmp));
      mb = tmp;
      while ((cur = strsep(&mb, ", "))) {
         if (!ast_strlen_zero(cur)) {
            if (inboxcount2(cur, urgentmsgs ? &tmpurgent : NULL, newmsgs ? &tmpnew : NULL, oldmsgs ? &tmpold : NULL))
               return -1;
            else {
               if (newmsgs)
                  *newmsgs += tmpnew; 
               if (oldmsgs)
                  *oldmsgs += tmpold;
               if (urgentmsgs)
                  *urgentmsgs += tmpurgent;
            }
         }
      }
      return 0;
   }

   ast_copy_string(tmp, mailbox, sizeof(tmp));
   
   if ((context = strchr(tmp, '@')))
      *context++ = '\0';
   else
      context = "default";

   if (newmsgs)
      *newmsgs = __has_voicemail(context, tmp, "INBOX", 0);
   if (oldmsgs)
      *oldmsgs = __has_voicemail(context, tmp, "Old", 0);
   if (urgentmsgs)
      *urgentmsgs = __has_voicemail(context, tmp, "Urgent", 0);

   return 0;
}

static int inbuf	(	struct baseio *	bio,
		FILE *	fi
	)			[static]

utility used by inchar(), for base_encode()

Definition at line 3854 of file app_voicemail.c.

References baseio::ateof, BASEMAXINLINE, baseio::iobuf, baseio::iocp, and baseio::iolen.

Referenced by ast_eivr_getvariable(), ast_eivr_setvariable(), inchar(), sip_addheader(), and sip_removeheader().

{
   int l;

   if (bio->ateof)
      return 0;

   if ((l = fread(bio->iobuf, 1, BASEMAXINLINE, fi)) <= 0) {
      if (ferror(fi))
         return -1;

      bio->ateof = 1;
      return 0;
   }

   bio->iolen = l;
   bio->iocp = 0;

   return 1;
}

static int inchar	(	struct baseio *	bio,
		FILE *	fi
	)			[static]

utility used by base_encode()

Definition at line 3878 of file app_voicemail.c.

References inbuf(), baseio::iobuf, baseio::iocp, and baseio::iolen.

Referenced by base_encode().

{
   if (bio->iocp>=bio->iolen) {
      if (!inbuf(bio, fi))
         return EOF;
   }

   return bio->iobuf[bio->iocp++];
}

static int invent_message	(	struct ast_channel *	chan,
		char *	context,
		char *	ext,
		int	busy,
		char *	ecodes
	)			[static]

Definition at line 4668 of file app_voicemail.c.

References ast_fileexists(), ast_log(), AST_LOG_WARNING, ast_say_digit_str(), ast_stream_and_wait(), create_dirpath(), DISPOSE, ast_channel::language, and RETRIEVE.

{
   int res;
   char fn[PATH_MAX];
   char dest[PATH_MAX];

   snprintf(fn, sizeof(fn), "%s%s/%s/greet", VM_SPOOL_DIR, context, ext);

   if ((res = create_dirpath(dest, sizeof(dest), context, ext, ""))) {
      ast_log(AST_LOG_WARNING, "Failed to make directory(%s)\n", fn);
      return -1;
   }

   RETRIEVE(fn, -1, ext, context);
   if (ast_fileexists(fn, NULL, NULL) > 0) {
      res = ast_stream_and_wait(chan, fn, ecodes);
      if (res) {
         DISPOSE(fn, -1);
         return res;
      }
   } else {
      /* Dispose just in case */
      DISPOSE(fn, -1);
      res = ast_stream_and_wait(chan, "vm-theperson", ecodes);
      if (res)
         return res;
      res = ast_say_digit_str(chan, ext, ecodes, chan->language);
      if (res)
         return res;
   }
   res = ast_stream_and_wait(chan, busy ? "vm-isonphone" : "vm-isunavail", ecodes);
   return res;
}

static int is_valid_dtmf

(

const char *

key

)

[static]

Determines if a DTMF key entered is valid.

Parameters:

key

The character to be compared. expects a single character. Though is capable of handling a string, this is internally copies using ast_strdupa.

Tests the character entered against the set of valid DTMF characters.

Returns:

1 if the character entered is a valid DTMF digit, 0 if the character is invalid.

Definition at line 1197 of file app_voicemail.c.

References ast_log(), AST_LOG_WARNING, ast_strdupa, and VALID_DTMF.

Referenced by load_config().

{
   int i;
   char *local_key = ast_strdupa(key);

   for (i = 0; i < strlen(key); ++i) {
      if (!strchr(VALID_DTMF, *local_key)) {
         ast_log(AST_LOG_WARNING, "Invalid DTMF key \"%c\" used in voicemail configuration file\n", *local_key);
         return 0;
      }
      local_key++;
   }
   return 1;
}

static int last_message_index	(	struct ast_vm_user *	vmu,
		char *	dir
	)			[static]

Determines the highest message number in use for a given user and mailbox folder.

Parameters:

	vmu
	dir	the folder the mailbox folder to look for messages. Used to construct the SQL where clause.

This method is used when mailboxes are stored on the filesystem. (not ODBC and not IMAP). Typical use to set the msgnum would be to take the value returned from this method and add one to it.

Note:

Should always be called with a lock already set on dir.

Returns:

the value of zero or greaterto indicate the last message index in use, -1 to indicate none.

Definition at line 3680 of file app_voicemail.c.

References map, ast_vm_user::maxmsg, and MAXMSGLIMIT.

Referenced by copy_message(), leave_voicemail(), open_mailbox(), and save_to_folder().

{
   int x;
   unsigned char map[MAXMSGLIMIT] = "";
   DIR *msgdir;
   struct dirent *msgdirent;
   int msgdirint;

   /* Reading the entire directory into a file map scales better than
    * doing a stat repeatedly on a predicted sequence.  I suspect this
    * is partially due to stat(2) internally doing a readdir(2) itself to
    * find each file. */
   if (!(msgdir = opendir(dir))) {
      return -1;
   }

   while ((msgdirent = readdir(msgdir))) {
      if (sscanf(msgdirent->d_name, "msg%30d", &msgdirint) == 1 && msgdirint < MAXMSGLIMIT)
         map[msgdirint] = 1;
   }
   closedir(msgdir);

   for (x = 0; x < vmu->maxmsg; x++) {
      if (map[x] == 0)
         break;
   }

   return x - 1;
}

static int leave_voicemail	(	struct ast_channel *	chan,
		char *	ext,
		struct leave_vm_options *	options
	)			[static]

Prompts the user and records a voicemail to a mailbox.

Parameters:

	chan
	ext
	options	OPT_BUSY_GREETING, OPT_UNAVAIL_GREETING

Returns:

zero on success, -1 on error.

Definition at line 5185 of file app_voicemail.c.

References ast_callerid_merge(), ast_canmatch_extension(), ast_channel_lock, ast_channel_unlock, ast_check_realtime(), ast_copy_string(), ast_debug, ast_destroy_realtime(), ast_exists_extension(), ast_filedelete(), ast_fileexists(), ast_filerename(), ast_free, ast_log(), AST_LOG_ERROR, AST_LOG_NOTICE, AST_LOG_WARNING, ast_mutex_lock(), ast_mutex_unlock(), ast_play_and_wait(), ast_set_flag, ast_stopstream(), ast_store_realtime(), ast_str_create(), ast_strdupa, ast_stream_and_wait(), ast_streamfile(), ast_strlen_zero(), ast_test_flag, ast_unlock_path(), ast_update_realtime(), ast_verbose, ast_waitstream(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, ast_channel::context, ast_vm_user::context, copy_message(), count_messages(), create_dirpath(), DISPOSE, errno, ast_vm_user::exit, leave_vm_options::exitcontext, exten, ast_channel::exten, find_user(), free_user(), get_date(), inboxcount(), INTRO, invent_message(), ast_channel::language, last_message_index(), ast_channel::macrocontext, ast_vm_user::mailbox, make_file(), ast_vm_user::maxmsg, ast_vm_user::maxsecs, ast_channel::name, vm_state::newmessages, notify_new_message(), OPT_BUSY_GREETING, OPT_DTMFEXIT, OPT_MESSAGE_PRIORITY, OPT_MESSAGE_Urgent, OPT_SILENT, OPT_UNAVAIL_GREETING, option_verbose, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), play_record_review(), ast_channel::priority, leave_vm_options::record_gain, RENAME, RETRIEVE, S_OR, SENTINEL, STORE, strsep(), transfer, VERBOSE_PREFIX_3, vm_lock_path(), VM_OPERATOR, and VOICEMAIL_FILE_MODE.

{
#ifdef IMAP_STORAGE
   int newmsgs, oldmsgs;
#else
   char urgdir[PATH_MAX];
#endif
   char txtfile[PATH_MAX];
   char tmptxtfile[PATH_MAX];
   struct vm_state *vms = NULL;
   char callerid[256];
   FILE *txt;
   char date[256];
   int txtdes;
   int res = 0;
   int msgnum;
   int duration = 0;
   int ausemacro = 0;
   int ousemacro = 0;
   int ouseexten = 0;
   char tmpdur[16];
   char priority[16];
   char origtime[16];
   char dir[PATH_MAX];
   char tmpdir[PATH_MAX];
   char fn[PATH_MAX];
   char prefile[PATH_MAX] = "";
   char tempfile[PATH_MAX] = "";
   char ext_context[256] = "";
   char fmt[80];
   char *context;
   char ecodes[17] = "#";
   struct ast_str *tmp = ast_str_create(16);
   char *tmpptr;
   struct ast_vm_user *vmu;
   struct ast_vm_user svm;
   const char *category = NULL;
   const char *code;
   const char *alldtmf = "0123456789ABCD*#";
   char flag[80];

   if (!tmp) {
      return -1;
   }

   ext = ast_strdupa(ext);
   if ((context = strchr(ext, '@'))) {
      *context++ = '\0';
      tmpptr = strchr(context, '&');
   } else {
      tmpptr = strchr(ext, '&');
   }

   if (tmpptr)
      *tmpptr++ = '\0';

   ast_channel_lock(chan);
   if ((category = pbx_builtin_getvar_helper(chan, "VM_CATEGORY"))) {
      category = ast_strdupa(category);
   }
   ast_channel_unlock(chan);

   if (ast_test_flag(options, OPT_MESSAGE_Urgent)) {
      ast_copy_string(flag, "Urgent", sizeof(flag));
   } else if (ast_test_flag(options, OPT_MESSAGE_PRIORITY)) {
      ast_copy_string(flag, "PRIORITY", sizeof(flag));
   } else {
      flag[0] = '\0';
   }

   ast_debug(3, "Before find_user\n");
   if (!(vmu = find_user(&svm, context, ext))) {
      ast_log(AST_LOG_WARNING, "No entry in voicemail config file for '%s'\n", ext);
      pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
      ast_free(tmp);
      return res;
   }
   /* Setup pre-file if appropriate */
   if (strcmp(vmu->context, "default"))
      snprintf(ext_context, sizeof(ext_context), "%s@%s", ext, vmu->context);
   else
      ast_copy_string(ext_context, vmu->mailbox, sizeof(ext_context));

   /* Set the path to the prefile. Will be one of 
      VM_SPOOL_DIRcontext/ext/busy
      VM_SPOOL_DIRcontext/ext/unavail
      Depending on the flag set in options.
   */
   if (ast_test_flag(options, OPT_BUSY_GREETING)) {
      snprintf(prefile, sizeof(prefile), "%s%s/%s/busy", VM_SPOOL_DIR, vmu->context, ext);
   } else if (ast_test_flag(options, OPT_UNAVAIL_GREETING)) {
      snprintf(prefile, sizeof(prefile), "%s%s/%s/unavail", VM_SPOOL_DIR, vmu->context, ext);
   }
   /* Set the path to the tmpfile as
      VM_SPOOL_DIR/context/ext/temp
      and attempt to create the folder structure.
   */
   snprintf(tempfile, sizeof(tempfile), "%s%s/%s/temp", VM_SPOOL_DIR, vmu->context, ext);
   if ((res = create_dirpath(tmpdir, sizeof(tmpdir), vmu->context, ext, "tmp"))) {
      ast_log(AST_LOG_WARNING, "Failed to make directory (%s)\n", tempfile);
      ast_free(tmp);
      return -1;
   }
   RETRIEVE(tempfile, -1, vmu->mailbox, vmu->context);
   if (ast_fileexists(tempfile, NULL, NULL) > 0)
      ast_copy_string(prefile, tempfile, sizeof(prefile));

   DISPOSE(tempfile, -1);
   /* It's easier just to try to make it than to check for its existence */
   create_dirpath(dir, sizeof(dir), vmu->context, ext, "INBOX");

   /* Check current or macro-calling context for special extensions */
   if (ast_test_flag(vmu, VM_OPERATOR)) {
      if (!ast_strlen_zero(vmu->exit)) {
         if (ast_exists_extension(chan, vmu->exit, "o", 1, chan->cid.cid_num)) {
            strncat(ecodes, "0", sizeof(ecodes) - strlen(ecodes) - 1);
            ouseexten = 1;
         }
      } else if (ast_exists_extension(chan, chan->context, "o", 1, chan->cid.cid_num)) {
         strncat(ecodes, "0", sizeof(ecodes) - strlen(ecodes) - 1);
         ouseexten = 1;
      } else if (!ast_strlen_zero(chan->macrocontext) && ast_exists_extension(chan, chan->macrocontext, "o", 1, chan->cid.cid_num)) {
         strncat(ecodes, "0", sizeof(ecodes) - strlen(ecodes) - 1);
         ousemacro = 1;
      }
   }

   if (!ast_strlen_zero(vmu->exit)) {
      if (ast_exists_extension(chan, vmu->exit, "a", 1, chan->cid.cid_num))
         strncat(ecodes, "*", sizeof(ecodes) - strlen(ecodes) - 1);
   } else if (ast_exists_extension(chan, chan->context, "a", 1, chan->cid.cid_num))
      strncat(ecodes, "*", sizeof(ecodes) - strlen(ecodes) - 1);
   else if (!ast_strlen_zero(chan->macrocontext) && ast_exists_extension(chan, chan->macrocontext, "a", 1, chan->cid.cid_num)) {
      strncat(ecodes, "*", sizeof(ecodes) - strlen(ecodes) - 1);
      ausemacro = 1;
   }

   if (ast_test_flag(options, OPT_DTMFEXIT)) {
      for (code = alldtmf; *code; code++) {
         char e[2] = "";
         e[0] = *code;
         if (strchr(ecodes, e[0]) == NULL && ast_canmatch_extension(chan, chan->context, e, 1, chan->cid.cid_num))
            strncat(ecodes, e, sizeof(ecodes) - strlen(ecodes) - 1);
      }
   }

   /* Play the beginning intro if desired */
   if (!ast_strlen_zero(prefile)) {
#ifdef ODBC_STORAGE
      int success = 
#endif
         RETRIEVE(prefile, -1, ext, context);
      if (ast_fileexists(prefile, NULL, NULL) > 0) {
         if (ast_streamfile(chan, prefile, chan->language) > -1) 
            res = ast_waitstream(chan, ecodes);
#ifdef ODBC_STORAGE
         if (success == -1) {
            /* We couldn't retrieve the file from the database, but we found it on the file system. Let's put it in the database. */
            ast_debug(1, "Greeting not retrieved from database, but found in file storage. Inserting into database\n");
            store_file(prefile, vmu->mailbox, vmu->context, -1);
         }
#endif
      } else {
         ast_debug(1, "%s doesn't exist, doing what we can\n", prefile);
         res = invent_message(chan, vmu->context, ext, ast_test_flag(options, OPT_BUSY_GREETING), ecodes);
      }
      DISPOSE(prefile, -1);
      if (res < 0) {
         ast_debug(1, "Hang up during prefile playback\n");
         free_user(vmu);
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
         ast_free(tmp);
         return -1;
      }
   }
   if (res == '#') {
      /* On a '#' we skip the instructions */
      ast_set_flag(options, OPT_SILENT);
      res = 0;
   }
   if (!res && !ast_test_flag(options, OPT_SILENT)) {
      res = ast_stream_and_wait(chan, INTRO, ecodes);
      if (res == '#') {
         ast_set_flag(options, OPT_SILENT);
         res = 0;
      }
   }
   if (res > 0)
      ast_stopstream(chan);
   /* Check for a '*' here in case the caller wants to escape from voicemail to something
    other than the operator -- an automated attendant or mailbox login for example */
   if (res == '*') {
      chan->exten[0] = 'a';
      chan->exten[1] = '\0';
      if (!ast_strlen_zero(vmu->exit)) {
         ast_copy_string(chan->context, vmu->exit, sizeof(chan->context));
      } else if (ausemacro && !ast_strlen_zero(chan->macrocontext)) {
         ast_copy_string(chan->context, chan->macrocontext, sizeof(chan->context));
      }
      chan->priority = 0;
      free_user(vmu);
      pbx_builtin_setvar_helper(chan, "VMSTATUS", "USEREXIT");
      ast_free(tmp);
      return 0;
   }

   /* Check for a '0' here */
   if (ast_test_flag(vmu, VM_OPERATOR) && res == '0') {
   transfer:
      if (ouseexten || ousemacro) {
         chan->exten[0] = 'o';
         chan->exten[1] = '\0';
         if (!ast_strlen_zero(vmu->exit)) {
            ast_copy_string(chan->context, vmu->exit, sizeof(chan->context));
         } else if (ousemacro && !ast_strlen_zero(chan->macrocontext)) {
            ast_copy_string(chan->context, chan->macrocontext, sizeof(chan->context));
         }
         ast_play_and_wait(chan, "transfer");
         chan->priority = 0;
         free_user(vmu);
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "USEREXIT");
      }
      ast_free(tmp);
      return 0;
   }

   /* Allow all other digits to exit Voicemail and return to the dialplan */
   if (ast_test_flag(options, OPT_DTMFEXIT) && res > 0) {
      if (!ast_strlen_zero(options->exitcontext))
         ast_copy_string(chan->context, options->exitcontext, sizeof(chan->context));
      free_user(vmu);
      pbx_builtin_setvar_helper(chan, "VMSTATUS", "USEREXIT");
      ast_free(tmp);
      return res;
   }

   if (res < 0) {
      free_user(vmu);
      pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
      ast_free(tmp);
      return -1;
   }
   /* The meat of recording the message...  All the announcements and beeps have been played*/
   ast_copy_string(fmt, vmfmts, sizeof(fmt));
   if (!ast_strlen_zero(fmt)) {
      msgnum = 0;

#ifdef IMAP_STORAGE
      /* Is ext a mailbox? */
      /* must open stream for this user to get info! */
      res = inboxcount(ext_context, &newmsgs, &oldmsgs);
      if (res < 0) {
         ast_log(AST_LOG_NOTICE, "Can not leave voicemail, unable to count messages\n");
         ast_free(tmp);
         return -1;
      }
      if (!(vms = get_vm_state_by_mailbox(ext, context, 0))) {
      /* It is possible under certain circumstances that inboxcount did not
       * create a vm_state when it was needed. This is a catchall which will
       * rarely be used.
       */
         if (!(vms = create_vm_state_from_user(vmu))) {
            ast_log(AST_LOG_ERROR, "Couldn't allocate necessary space\n");
            ast_free(tmp);
            return -1;
         }
      }
      vms->newmessages++;
      
      /* here is a big difference! We add one to it later */
      msgnum = newmsgs + oldmsgs;
      ast_debug(3, "Messagecount set to %d\n", msgnum);
      snprintf(fn, sizeof(fn), "%s/imap/msg%s%04d", VM_SPOOL_DIR, vmu->mailbox, msgnum);
      /* set variable for compatibility */
      pbx_builtin_setvar_helper(chan, "VM_MESSAGEFILE", "IMAP_STORAGE");

      /* Check if mailbox is full */
      check_quota(vms, imapfolder);
      if (vms->quota_limit && vms->quota_usage >= vms->quota_limit) {
         ast_debug(1, "*** QUOTA EXCEEDED!! %u >= %u\n", vms->quota_usage, vms->quota_limit);
         ast_play_and_wait(chan, "vm-mailboxfull");
         ast_free(tmp);
         return -1;
      }
      
      /* Check if we have exceeded maxmsg */
      if (msgnum >= vmu->maxmsg) {
         ast_log(AST_LOG_WARNING, "Unable to leave message since we will exceed the maximum number of messages allowed (%u > %u)\n", msgnum, vmu->maxmsg);
         ast_play_and_wait(chan, "vm-mailboxfull");
         ast_free(tmp);
         return -1;
      }
#else
      if (count_messages(vmu, dir) >= vmu->maxmsg) {
         res = ast_streamfile(chan, "vm-mailboxfull", chan->language);
         if (!res)
            res = ast_waitstream(chan, "");
         ast_log(AST_LOG_WARNING, "No more messages possible\n");
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
         goto leave_vm_out;
      }

#endif
      snprintf(tmptxtfile, sizeof(tmptxtfile), "%s/XXXXXX", tmpdir);
      txtdes = mkstemp(tmptxtfile);
      chmod(tmptxtfile, VOICEMAIL_FILE_MODE & ~my_umask);
      if (txtdes < 0) {
         res = ast_streamfile(chan, "vm-mailboxfull", chan->language);
         if (!res)
            res = ast_waitstream(chan, "");
         ast_log(AST_LOG_ERROR, "Unable to create message file: %s\n", strerror(errno));
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
         goto leave_vm_out;
      }

      /* Now play the beep once we have the message number for our next message. */
      if (res >= 0) {
         /* Unless we're *really* silent, try to send the beep */
         res = ast_stream_and_wait(chan, "beep", "");
      }
            
      /* Store information in real-time storage */
      if (ast_check_realtime("voicemail_data")) {
         snprintf(priority, sizeof(priority), "%d", chan->priority);
         snprintf(origtime, sizeof(origtime), "%ld", (long) time(NULL));
         get_date(date, sizeof(date));
         ast_store_realtime("voicemail_data", "origmailbox", ext, "context", chan->context, "macrocontext", chan->macrocontext, "exten", chan->exten, "priority", priority, "callerchan", chan->name, "callerid", ast_callerid_merge(callerid, sizeof(callerid), chan->cid.cid_name, chan->cid.cid_num, "Unknown"), "origdate", date, "origtime", origtime, "category", S_OR(category, ""), "filename", tmptxtfile, SENTINEL);
      }

      /* Store information */
      txt = fdopen(txtdes, "w+");
      if (txt) {
         get_date(date, sizeof(date));
         fprintf(txt, 
            ";\n"
            "; Message Information file\n"
            ";\n"
            "[message]\n"
            "origmailbox=%s\n"
            "context=%s\n"
            "macrocontext=%s\n"
            "exten=%s\n"
            "priority=%d\n"
            "callerchan=%s\n"
            "callerid=%s\n"
            "origdate=%s\n"
            "origtime=%ld\n"
            "category=%s\n",
            ext,
            chan->context,
            chan->macrocontext, 
            chan->exten,
            chan->priority,
            chan->name,
            ast_callerid_merge(callerid, sizeof(callerid), S_OR(chan->cid.cid_name, NULL), S_OR(chan->cid.cid_num, NULL), "Unknown"),
            date, (long) time(NULL),
            category ? category : "");
      } else
         ast_log(AST_LOG_WARNING, "Error opening text file for output\n");
      res = play_record_review(chan, NULL, tmptxtfile, vmu->maxsecs, fmt, 1, vmu, &duration, NULL, options->record_gain, vms, flag);

      if (txt) {
         fprintf(txt, "flag=%s\n", flag);
         if (duration < vmminsecs) {
            fclose(txt);
            if (option_verbose > 2) 
               ast_verbose( VERBOSE_PREFIX_3 "Recording was %d seconds long but needs to be at least %d - abandoning\n", duration, vmminsecs);
            ast_filedelete(tmptxtfile, NULL);
            unlink(tmptxtfile);
            if (ast_check_realtime("voicemail_data")) {
               ast_destroy_realtime("voicemail_data", "filename", tmptxtfile, SENTINEL);
            }
         } else {
            fprintf(txt, "duration=%d\n", duration);
            fclose(txt);
            if (vm_lock_path(dir)) {
               ast_log(AST_LOG_ERROR, "Couldn't lock directory %s.  Voicemail will be lost.\n", dir);
               /* Delete files */
               ast_filedelete(tmptxtfile, NULL);
               unlink(tmptxtfile);
            } else if (ast_fileexists(tmptxtfile, NULL, NULL) <= 0) {
               ast_debug(1, "The recorded media file is gone, so we should remove the .txt file too!\n");
               unlink(tmptxtfile);
               ast_unlock_path(dir);
               if (ast_check_realtime("voicemail_data")) {
                  ast_destroy_realtime("voicemail_data", "filename", tmptxtfile, SENTINEL);
               }
            } else {
#ifndef IMAP_STORAGE
               msgnum = last_message_index(vmu, dir) + 1;
#endif
               make_file(fn, sizeof(fn), dir, msgnum);

               /* assign a variable with the name of the voicemail file */ 
#ifndef IMAP_STORAGE
               pbx_builtin_setvar_helper(chan, "VM_MESSAGEFILE", fn);
#else
               pbx_builtin_setvar_helper(chan, "VM_MESSAGEFILE", "IMAP_STORAGE");
#endif

               snprintf(txtfile, sizeof(txtfile), "%s.txt", fn);
               ast_filerename(tmptxtfile, fn, NULL);
               rename(tmptxtfile, txtfile);

               /* Properly set permissions on voicemail text descriptor file.
                  Unfortunately mkstemp() makes this file 0600 on most unix systems. */
               if (chmod(txtfile, VOICEMAIL_FILE_MODE) < 0)
                  ast_log(AST_LOG_ERROR, "Couldn't set permissions on voicemail text file %s: %s", txtfile, strerror(errno));

               ast_unlock_path(dir);
               if (ast_check_realtime("voicemail_data")) {
                  snprintf(tmpdur, sizeof(tmpdur), "%d", duration);
                  ast_update_realtime("voicemail_data", "filename", tmptxtfile, "filename", fn, "duration", tmpdur, SENTINEL);
               }
               /* We must store the file first, before copying the message, because
                * ODBC storage does the entire copy with SQL.
                */
               if (ast_fileexists(fn, NULL, NULL) > 0) {
                  STORE(dir, vmu->mailbox, vmu->context, msgnum, chan, vmu, fmt, duration, vms, flag);
               }

               /* Are there to be more recipients of this message? */
               while (tmpptr) {
                  struct ast_vm_user recipu, *recip;
                  char *exten, *cntx;
               
                  exten = strsep(&tmpptr, "&");
                  cntx = strchr(exten, '@');
                  if (cntx) {
                     *cntx = '\0';
                     cntx++;
                  }
                  if ((recip = find_user(&recipu, cntx, exten))) {
                     copy_message(chan, vmu, 0, msgnum, duration, recip, fmt, dir, flag);
                     free_user(recip);
                  }
               }
#ifndef IMAP_STORAGE
               if (!ast_strlen_zero(flag) && !strcmp(flag, "Urgent")) { /* If this is an Urgent message */
                  /* Move the message from INBOX to Urgent folder if this is urgent! */
                  char sfn[PATH_MAX];
                  char dfn[PATH_MAX];
                  int x;
                  /* It's easier just to try to make it than to check for its existence */
                  create_dirpath(urgdir, sizeof(urgdir), vmu->context, ext, "Urgent");
                  ast_debug(5, "Created an Urgent message, moving file from %s to %s.\n", sfn, dfn);
                  x = last_message_index(vmu, urgdir) + 1;
                  make_file(sfn, sizeof(sfn), dir, msgnum);
                  make_file(dfn, sizeof(dfn), urgdir, x);
                  RENAME(dir, msgnum, vmu->mailbox, vmu->context, urgdir, x, sfn, dfn);
               }
#endif
               /* Notification needs to happen after the copy, though. */
               if (ast_fileexists(fn, NULL, NULL)) {
#ifdef IMAP_STORAGE
                  notify_new_message(chan, vmu, vms, msgnum, duration, fmt, S_OR(chan->cid.cid_num, NULL), S_OR(chan->cid.cid_name, NULL), flag);
#else
                  notify_new_message(chan, vmu, NULL, msgnum, duration, fmt, S_OR(chan->cid.cid_num, NULL), S_OR(chan->cid.cid_name, NULL), flag);
#endif
               }

               /* Disposal needs to happen after the optional move and copy */
               if (ast_fileexists(fn, NULL, NULL)) {
                  DISPOSE(dir, msgnum);
               }
            }
         }
      }
      if (res == '0') {
         goto transfer;
      } else if (res > 0)
         res = 0;

      if (duration < vmminsecs)
         /* XXX We should really give a prompt too short/option start again, with leave_vm_out called only after a timeout XXX */
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
      else
         pbx_builtin_setvar_helper(chan, "VMSTATUS", "SUCCESS");
   } else
      ast_log(AST_LOG_WARNING, "No format for saving voicemail?\n");
leave_vm_out:
   free_user(vmu);

#ifdef IMAP_STORAGE
   /* expunge message - use UID Expunge if supported on IMAP server*/
   ast_debug(3, "*** Checking if we can expunge, expungeonhangup set to %d\n", expungeonhangup);
   if (expungeonhangup == 1) {
      ast_mutex_lock(&vms->lock);
#ifdef HAVE_IMAP_TK2006
      if (LEVELUIDPLUS (vms->mailstream)) {
         mail_expunge_full(vms->mailstream, NIL, EX_UID);
      } else 
#endif
         mail_expunge(vms->mailstream);
      ast_mutex_unlock(&vms->lock);
   }
#endif

   ast_free(tmp);
   return res;
}

static int load_config

(

int

reload

)

[static]

Definition at line 10613 of file app_voicemail.c.

References adsifdn, adsisec, adsiver, append_mailbox(), apply_options_full(), ast_category_browse(), ast_clear_flag, ast_config_destroy(), ast_config_load, ast_config_option(), ast_copy_string(), ast_debug, ast_dsp_get_threshold_from_settings(), ast_false(), ast_free, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), AST_LOG_DEBUG, AST_LOG_ERROR, AST_LOG_WARNING, ast_malloc, AST_PTHREADT_NULL, ast_set2_flag, ast_smdi_interface_find(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_true(), ast_unload_realtime(), ast_variable_browse(), ast_variable_retrieve(), ASTERISK_USERNAME, callcontext, charset, cidinternalcontexts, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, ast_vm_user::context, DEFAULT_LISTEN_CONTROL_FORWARD_KEY, DEFAULT_LISTEN_CONTROL_PAUSE_KEY, DEFAULT_LISTEN_CONTROL_RESTART_KEY, DEFAULT_LISTEN_CONTROL_REVERSE_KEY, DEFAULT_LISTEN_CONTROL_STOP_KEY, DEFAULT_POLL_FREQ, dialcontext, emailbody, emaildateformat, emailsubject, exitcontext, find_or_create(), free_vm_users(), free_vm_zones(), fromstring, globalflags, is_valid_dtmf(), ast_variable::lineno, listen_control_forward_key, listen_control_pause_key, listen_control_restart_key, listen_control_reverse_key, listen_control_stop_key, LOG_ERROR, ast_vm_user::mailbox, MAX_NUM_CID_CONTEXTS, MAXMSG, MAXMSGLIMIT, MINPASSWORD, vm_zone::msg_format, vm_zone::name, ast_variable::name, ast_variable::next, OPT_PWLOC_SPOOLDIR, OPT_PWLOC_USERSCONF, OPT_PWLOC_VOICEMAILCONF, pagerbody, pagerfromstring, pagersubject, ast_vm_user::password, ast_vm_user::passwordlocation, populate_defaults(), PWDCHANGE_EXTERNAL, PWDCHANGE_INTERNAL, read_password_from_file(), saydurationminfo, SENDMAIL, start_poll_thread(), stop_poll_thread(), strsep(), substitute_escapes(), THRESHOLD_SILENCE, vm_zone::timezone, ast_variable::value, VM_ATTACH, VM_DIRECFORWARD, VM_ENVELOPE, VM_FORCEGREET, VM_FORCENAME, VM_FWDURGAUTO, vm_invalid_password, VM_MESSAGEWRAP, vm_mismatch, VM_MOVEHEARD, vm_newpassword, VM_OPERATOR, vm_passchanged, vm_password, VM_PBXSKIP, vm_pls_try_again, vm_reenterpassword, VM_REVIEW, VM_SAYCID, VM_SAYDURATION, VM_SEARCH, VM_SKIPAFTERCMD, VM_SVMAIL, VM_TEMPGREETWARN, and VOICEMAIL_CONFIG.

{
   struct ast_vm_user *current;
   struct ast_config *cfg, *ucfg;
   char *cat;
   struct ast_variable *var;
   const char *val;
   char *q, *stringp;
   int x;
   int tmpadsi[4];
   struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
   char secretfn[PATH_MAX] = "";

   ast_unload_realtime("voicemail");
   ast_unload_realtime("voicemail_data");

   if ((cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags)) == CONFIG_STATUS_FILEUNCHANGED) {
      if ((ucfg = ast_config_load("users.conf", config_flags)) == CONFIG_STATUS_FILEUNCHANGED) {
         return 0;
      } else if (ucfg == CONFIG_STATUS_FILEINVALID) {
         ast_log(LOG_ERROR, "Config file users.conf is in an invalid format.  Avoiding.\n");
         ucfg = NULL;
      }
      ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
      if ((cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags)) == CONFIG_STATUS_FILEINVALID) {
         ast_config_destroy(ucfg);
         ast_log(LOG_ERROR, "Config file " VOICEMAIL_CONFIG " is in an invalid format.  Aborting.\n");
         return 0;
      }
   } else if (cfg == CONFIG_STATUS_FILEINVALID) {
      ast_log(LOG_ERROR, "Config file " VOICEMAIL_CONFIG " is in an invalid format.  Aborting.\n");
      return 0;
   } else {
      ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
      if ((ucfg = ast_config_load("users.conf", config_flags)) == CONFIG_STATUS_FILEINVALID) {
         ast_log(LOG_ERROR, "Config file users.conf is in an invalid format.  Avoiding.\n");
         ucfg = NULL;
      }
   }
#ifdef IMAP_STORAGE
   ast_copy_string(imapparentfolder, "\0", sizeof(imapparentfolder));
#endif
   /* set audio control prompts */
   strcpy(listen_control_forward_key, DEFAULT_LISTEN_CONTROL_FORWARD_KEY);
   strcpy(listen_control_reverse_key, DEFAULT_LISTEN_CONTROL_REVERSE_KEY);
   strcpy(listen_control_pause_key, DEFAULT_LISTEN_CONTROL_PAUSE_KEY);
   strcpy(listen_control_restart_key, DEFAULT_LISTEN_CONTROL_RESTART_KEY);
   strcpy(listen_control_stop_key, DEFAULT_LISTEN_CONTROL_STOP_KEY);

   /* Free all the users structure */  
   free_vm_users();

   /* Free all the zones structure */
   free_vm_zones();

   AST_LIST_LOCK(&users);  

   memset(ext_pass_cmd, 0, sizeof(ext_pass_cmd));
   memset(ext_pass_check_cmd, 0, sizeof(ext_pass_check_cmd));

   if (cfg) {
      /* General settings */

      if (!(val = ast_variable_retrieve(cfg, "general", "userscontext")))
         val = "default";
      ast_copy_string(userscontext, val, sizeof(userscontext));
      /* Attach voice message to mail message ? */
      if (!(val = ast_variable_retrieve(cfg, "general", "attach"))) 
         val = "yes";
      ast_set2_flag((&globalflags), ast_true(val), VM_ATTACH); 

      if (!(val = ast_variable_retrieve(cfg, "general", "searchcontexts")))
         val = "no";
      ast_set2_flag((&globalflags), ast_true(val), VM_SEARCH);

      volgain = 0.0;
      if ((val = ast_variable_retrieve(cfg, "general", "volgain")))
         sscanf(val, "%30lf", &volgain);

#ifdef ODBC_STORAGE
      strcpy(odbc_database, "asterisk");
      if ((val = ast_variable_retrieve(cfg, "general", "odbcstorage"))) {
         ast_copy_string(odbc_database, val, sizeof(odbc_database));
      }
      strcpy(odbc_table, "voicemessages");
      if ((val = ast_variable_retrieve(cfg, "general", "odbctable"))) {
         ast_copy_string(odbc_table, val, sizeof(odbc_table));
      }
#endif      
      /* Mail command */
      strcpy(mailcmd, SENDMAIL);
      if ((val = ast_variable_retrieve(cfg, "general", "mailcmd")))
         ast_copy_string(mailcmd, val, sizeof(mailcmd)); /* User setting */

      maxsilence = 0;
      if ((val = ast_variable_retrieve(cfg, "general", "maxsilence"))) {
         maxsilence = atoi(val);
         if (maxsilence > 0)
            maxsilence *= 1000;
      }
      
      if (!(val = ast_variable_retrieve(cfg, "general", "maxmsg"))) {
         maxmsg = MAXMSG;
      } else {
         maxmsg = atoi(val);
         if (maxmsg <= 0) {
            ast_log(AST_LOG_WARNING, "Invalid number of messages per folder '%s'. Using default value %i\n", val, MAXMSG);
            maxmsg = MAXMSG;
         } else if (maxmsg > MAXMSGLIMIT) {
            ast_log(AST_LOG_WARNING, "Maximum number of messages per folder is %i. Cannot accept value '%s'\n", MAXMSGLIMIT, val);
            maxmsg = MAXMSGLIMIT;
         }
      }

      if (!(val = ast_variable_retrieve(cfg, "general", "backupdeleted"))) {
         maxdeletedmsg = 0;
      } else {
         if (sscanf(val, "%30d", &x) == 1)
            maxdeletedmsg = x;
         else if (ast_true(val))
            maxdeletedmsg = MAXMSG;
         else
            maxdeletedmsg = 0;

         if (maxdeletedmsg < 0) {
            ast_log(AST_LOG_WARNING, "Invalid number of deleted messages saved per mailbox '%s'. Using default value %i\n", val, MAXMSG);
            maxdeletedmsg = MAXMSG;
         } else if (maxdeletedmsg > MAXMSGLIMIT) {
            ast_log(AST_LOG_WARNING, "Maximum number of deleted messages saved per mailbox is %i. Cannot accept value '%s'\n", MAXMSGLIMIT, val);
            maxdeletedmsg = MAXMSGLIMIT;
         }
      }

      /* Load date format config for voicemail mail */
      if ((val = ast_variable_retrieve(cfg, "general", "emaildateformat"))) {
         ast_copy_string(emaildateformat, val, sizeof(emaildateformat));
      }

      /* External password changing command */
      if ((val = ast_variable_retrieve(cfg, "general", "externpass"))) {
         ast_copy_string(ext_pass_cmd, val, sizeof(ext_pass_cmd));
         pwdchange = PWDCHANGE_EXTERNAL;
      } else if ((val = ast_variable_retrieve(cfg, "general", "externpassnotify"))) {
         ast_copy_string(ext_pass_cmd, val, sizeof(ext_pass_cmd));
         pwdchange = PWDCHANGE_EXTERNAL | PWDCHANGE_INTERNAL;
      }
 
      /* External password validation command */
      if ((val = ast_variable_retrieve(cfg, "general", "externpasscheck"))) {
         ast_copy_string(ext_pass_check_cmd, val, sizeof(ext_pass_check_cmd));
         ast_log(AST_LOG_DEBUG, "found externpasscheck: %s\n", ext_pass_check_cmd);
      }

#ifdef IMAP_STORAGE
      /* IMAP server address */
      if ((val = ast_variable_retrieve(cfg, "general", "imapserver"))) {
         ast_copy_string(imapserver, val, sizeof(imapserver));
      } else {
         ast_copy_string(imapserver, "localhost", sizeof(imapserver));
      }
      /* IMAP server port */
      if ((val = ast_variable_retrieve(cfg, "general", "imapport"))) {
         ast_copy_string(imapport, val, sizeof(imapport));
      } else {
         ast_copy_string(imapport, "143", sizeof(imapport));
      }
      /* IMAP server flags */
      if ((val = ast_variable_retrieve(cfg, "general", "imapflags"))) {
         ast_copy_string(imapflags, val, sizeof(imapflags));
      }
      /* IMAP server master username */
      if ((val = ast_variable_retrieve(cfg, "general", "authuser"))) {
         ast_copy_string(authuser, val, sizeof(authuser));
      }
      /* IMAP server master password */
      if ((val = ast_variable_retrieve(cfg, "general", "authpassword"))) {
         ast_copy_string(authpassword, val, sizeof(authpassword));
      }
      /* Expunge on exit */
      if ((val = ast_variable_retrieve(cfg, "general", "expungeonhangup"))) {
         if (ast_false(val))
            expungeonhangup = 0;
         else
            expungeonhangup = 1;
      } else {
         expungeonhangup = 1;
      }
      /* IMAP voicemail folder */
      if ((val = ast_variable_retrieve(cfg, "general", "imapfolder"))) {
         ast_copy_string(imapfolder, val, sizeof(imapfolder));
      } else {
         ast_copy_string(imapfolder, "INBOX", sizeof(imapfolder));
      }
      if ((val = ast_variable_retrieve(cfg, "general", "imapparentfolder"))) {
         ast_copy_string(imapparentfolder, val, sizeof(imapparentfolder));
      }
      if ((val = ast_variable_retrieve(cfg, "general", "imapgreetings"))) {
         imapgreetings = ast_true(val);
      } else {
         imapgreetings = 0;
      }
      if ((val = ast_variable_retrieve(cfg, "general", "greetingfolder"))) {
         ast_copy_string(greetingfolder, val, sizeof(greetingfolder));
      } else {
         ast_copy_string(greetingfolder, imapfolder, sizeof(greetingfolder));
      }

      /* There is some very unorthodox casting done here. This is due
       * to the way c-client handles the argument passed in. It expects a 
       * void pointer and casts the pointer directly to a long without
       * first dereferencing it. */
      if ((val = ast_variable_retrieve(cfg, "general", "imapreadtimeout"))) {
         mail_parameters(NIL, SET_READTIMEOUT, (void *) (atol(val)));
      } else {
         mail_parameters(NIL, SET_READTIMEOUT, (void *) 60L);
      }

      if ((val = ast_variable_retrieve(cfg, "general", "imapwritetimeout"))) {
         mail_parameters(NIL, SET_WRITETIMEOUT, (void *) (atol(val)));
      } else {
         mail_parameters(NIL, SET_WRITETIMEOUT, (void *) 60L);
      }

      if ((val = ast_variable_retrieve(cfg, "general", "imapopentimeout"))) {
         mail_parameters(NIL, SET_OPENTIMEOUT, (void *) (atol(val)));
      } else {
         mail_parameters(NIL, SET_OPENTIMEOUT, (void *) 60L);
      }

      if ((val = ast_variable_retrieve(cfg, "general", "imapclosetimeout"))) {
         mail_parameters(NIL, SET_CLOSETIMEOUT, (void *) (atol(val)));
      } else {
         mail_parameters(NIL, SET_CLOSETIMEOUT, (void *) 60L);
      }

      /* Increment configuration version */
      imapversion++;
#endif
      /* External voicemail notify application */
      if ((val = ast_variable_retrieve(cfg, "general", "externnotify"))) {
         ast_copy_string(externnotify, val, sizeof(externnotify));
         ast_debug(1, "found externnotify: %s\n", externnotify);
      } else {
         externnotify[0] = '\0';
      }

      /* SMDI voicemail notification */
      if ((val = ast_variable_retrieve(cfg, "general", "smdienable")) && ast_true(val)) {
         ast_debug(1, "Enabled SMDI voicemail notification\n");
         if ((val = ast_variable_retrieve(cfg, "general", "smdiport"))) {
            smdi_iface = ast_smdi_interface_find(val);
         } else {
            ast_debug(1, "No SMDI interface set, trying default (/dev/ttyS0)\n");
            smdi_iface = ast_smdi_interface_find("/dev/ttyS0");
         }
         if (!smdi_iface) {
            ast_log(AST_LOG_ERROR, "No valid SMDI interface specfied, disabling SMDI voicemail notification\n");
         } 
      }

      /* Silence treshold */
      silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
      if ((val = ast_variable_retrieve(cfg, "general", "silencethreshold")))
         silencethreshold = atoi(val);
      
      if (!(val = ast_variable_retrieve(cfg, "general", "serveremail"))) 
         val = ASTERISK_USERNAME;
      ast_copy_string(serveremail, val, sizeof(serveremail));
      
      vmmaxsecs = 0;
      if ((val = ast_variable_retrieve(cfg, "general", "maxsecs"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            vmmaxsecs = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid max message time length\n");
         }
      } else if ((val = ast_variable_retrieve(cfg, "general", "maxmessage"))) {
         static int maxmessage_deprecate = 0;
         if (maxmessage_deprecate == 0) {
            maxmessage_deprecate = 1;
            ast_log(AST_LOG_WARNING, "Setting 'maxmessage' has been deprecated in favor of 'maxsecs'.\n");
         }
         if (sscanf(val, "%30d", &x) == 1) {
            vmmaxsecs = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid max message time length\n");
         }
      }

      vmminsecs = 0;
      if ((val = ast_variable_retrieve(cfg, "general", "minsecs"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            vmminsecs = x;
            if (maxsilence / 1000 >= vmminsecs) {
               ast_log(AST_LOG_WARNING, "maxsilence should be less than minmessage or you may get empty messages\n");
            }
         } else {
            ast_log(AST_LOG_WARNING, "Invalid min message time length\n");
         }
      } else if ((val = ast_variable_retrieve(cfg, "general", "minmessage"))) {
         static int maxmessage_deprecate = 0;
         if (maxmessage_deprecate == 0) {
            maxmessage_deprecate = 1;
            ast_log(AST_LOG_WARNING, "Setting 'minmessage' has been deprecated in favor of 'minsecs'.\n");
         }
         if (sscanf(val, "%30d", &x) == 1) {
            vmminsecs = x;
            if (maxsilence / 1000 >= vmminsecs) {
               ast_log(AST_LOG_WARNING, "maxsilence should be less than minmessage or you may get empty messages\n");
            }
         } else {
            ast_log(AST_LOG_WARNING, "Invalid min message time length\n");
         }
      }

      val = ast_variable_retrieve(cfg, "general", "format");
      if (!val)
         val = "wav";   
      ast_copy_string(vmfmts, val, sizeof(vmfmts));

      skipms = 3000;
      if ((val = ast_variable_retrieve(cfg, "general", "maxgreet"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            maxgreet = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid max message greeting length\n");
         }
      }

      if ((val = ast_variable_retrieve(cfg, "general", "skipms"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            skipms = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid skipms value\n");
         }
      }

      maxlogins = 3;
      if ((val = ast_variable_retrieve(cfg, "general", "maxlogins"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            maxlogins = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid max failed login attempts\n");
         }
      }

      minpassword = MINPASSWORD;
      if ((val = ast_variable_retrieve(cfg, "general", "minpassword"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            minpassword = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid minimum password length.  Default to %d\n", minpassword);
         }
      }

      /* Force new user to record name ? */
      if (!(val = ast_variable_retrieve(cfg, "general", "forcename"))) 
         val = "no";
      ast_set2_flag((&globalflags), ast_true(val), VM_FORCENAME);

      /* Force new user to record greetings ? */
      if (!(val = ast_variable_retrieve(cfg, "general", "forcegreetings"))) 
         val = "no";
      ast_set2_flag((&globalflags), ast_true(val), VM_FORCEGREET);

      if ((val = ast_variable_retrieve(cfg, "general", "cidinternalcontexts"))) {
         ast_debug(1, "VM_CID Internal context string: %s\n", val);
         stringp = ast_strdupa(val);
         for (x = 0 ; x < MAX_NUM_CID_CONTEXTS ; x++){
            if (!ast_strlen_zero(stringp)) {
               q = strsep(&stringp, ",");
               while ((*q == ' ')||(*q == '\t')) /* Eat white space between contexts */
                  q++;
               ast_copy_string(cidinternalcontexts[x], q, sizeof(cidinternalcontexts[x]));
               ast_debug(1, "VM_CID Internal context %d: %s\n", x, cidinternalcontexts[x]);
            } else {
               cidinternalcontexts[x][0] = '\0';
            }
         }
      }
      if (!(val = ast_variable_retrieve(cfg, "general", "review"))){
         ast_debug(1, "VM Review Option disabled globally\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_REVIEW); 

      /* Temporary greeting reminder */
      if (!(val = ast_variable_retrieve(cfg, "general", "tempgreetwarn"))) {
         ast_debug(1, "VM Temporary Greeting Reminder Option disabled globally\n");
         val = "no";
      } else {
         ast_debug(1, "VM Temporary Greeting Reminder Option enabled globally\n");
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_TEMPGREETWARN);
      if (!(val = ast_variable_retrieve(cfg, "general", "messagewrap"))){
         ast_debug(1, "VM next message wrap disabled globally\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_MESSAGEWRAP);  

      if (!(val = ast_variable_retrieve(cfg, "general", "operator"))){
         ast_debug(1, "VM Operator break disabled globally\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_OPERATOR);  

      if (!(val = ast_variable_retrieve(cfg, "general", "saycid"))) {
         ast_debug(1, "VM CID Info before msg disabled globally\n");
         val = "no";
      } 
      ast_set2_flag((&globalflags), ast_true(val), VM_SAYCID); 

      if (!(val = ast_variable_retrieve(cfg, "general", "sendvoicemail"))){
         ast_debug(1, "Send Voicemail msg disabled globally\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_SVMAIL);
   
      if (!(val = ast_variable_retrieve(cfg, "general", "envelope"))) {
         ast_debug(1, "ENVELOPE before msg enabled globally\n");
         val = "yes";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_ENVELOPE);  

      if (!(val = ast_variable_retrieve(cfg, "general", "moveheard"))) {
         ast_debug(1, "Move Heard enabled globally\n");
         val = "yes";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_MOVEHEARD); 

      if (!(val = ast_variable_retrieve(cfg, "general", "forward_urgent_auto"))) {
         ast_debug(1, "Autoset of Urgent flag on forwarded Urgent messages disabled globally\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_FWDURGAUTO);   

      if (!(val = ast_variable_retrieve(cfg, "general", "sayduration"))) {
         ast_debug(1, "Duration info before msg enabled globally\n");
         val = "yes";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_SAYDURATION);  

      saydurationminfo = 2;
      if ((val = ast_variable_retrieve(cfg, "general", "saydurationm"))) {
         if (sscanf(val, "%30d", &x) == 1) {
            saydurationminfo = x;
         } else {
            ast_log(AST_LOG_WARNING, "Invalid min duration for say duration\n");
         }
      }

      if (!(val = ast_variable_retrieve(cfg, "general", "nextaftercmd"))) {
         ast_debug(1, "We are not going to skip to the next msg after save/delete\n");
         val = "no";
      }
      ast_set2_flag((&globalflags), ast_true(val), VM_SKIPAFTERCMD);

      if ((val = ast_variable_retrieve(cfg, "general", "dialout"))) {
         ast_copy_string(dialcontext, val, sizeof(dialcontext));
         ast_debug(1, "found dialout context: %s\n", dialcontext);
      } else {
         dialcontext[0] = '\0';  
      }
      
      if ((val = ast_variable_retrieve(cfg, "general", "callback"))) {
         ast_copy_string(callcontext, val, sizeof(callcontext));
         ast_debug(1, "found callback context: %s\n", callcontext);
      } else {
         callcontext[0] = '\0';
      }

      if ((val = ast_variable_retrieve(cfg, "general", "exitcontext"))) {
         ast_copy_string(exitcontext, val, sizeof(exitcontext));
         ast_debug(1, "found operator context: %s\n", exitcontext);
      } else {
         exitcontext[0] = '\0';
      }
      
      /* load password sounds configuration */
      if ((val = ast_variable_retrieve(cfg, "general", "vm-password")))
         ast_copy_string(vm_password, val, sizeof(vm_password));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-newpassword")))
         ast_copy_string(vm_newpassword, val, sizeof(vm_newpassword));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-invalid-password")))
         ast_copy_string(vm_invalid_password, val, sizeof(vm_invalid_password));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-passchanged")))
         ast_copy_string(vm_passchanged, val, sizeof(vm_passchanged));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-reenterpassword")))
         ast_copy_string(vm_reenterpassword, val, sizeof(vm_reenterpassword));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-mismatch")))
         ast_copy_string(vm_mismatch, val, sizeof(vm_mismatch));
      if ((val = ast_variable_retrieve(cfg, "general", "vm-pls-try-again"))) {
         ast_copy_string(vm_pls_try_again, val, sizeof(vm_pls_try_again));
      }
      /* load configurable audio prompts */
      if ((val = ast_variable_retrieve(cfg, "general", "listen-control-forward-key")) && is_valid_dtmf(val))
         ast_copy_string(listen_control_forward_key, val, sizeof(listen_control_forward_key));
      if ((val = ast_variable_retrieve(cfg, "general", "listen-control-reverse-key")) && is_valid_dtmf(val))
         ast_copy_string(listen_control_reverse_key, val, sizeof(listen_control_reverse_key));
      if ((val = ast_variable_retrieve(cfg, "general", "listen-control-pause-key")) && is_valid_dtmf(val))
         ast_copy_string(listen_control_pause_key, val, sizeof(listen_control_pause_key));
      if ((val = ast_variable_retrieve(cfg, "general", "listen-control-restart-key")) && is_valid_dtmf(val))
         ast_copy_string(listen_control_restart_key, val, sizeof(listen_control_restart_key));
      if ((val = ast_variable_retrieve(cfg, "general", "listen-control-stop-key")) && is_valid_dtmf(val))
         ast_copy_string(listen_control_stop_key, val, sizeof(listen_control_stop_key));

      if (!(val = ast_variable_retrieve(cfg, "general", "usedirectory"))) 
         val = "no";
      ast_set2_flag((&globalflags), ast_true(val), VM_DIRECFORWARD); 

      if (!(val = ast_variable_retrieve(cfg, "general", "passwordlocation"))) {
         val = "voicemail.conf";
      }
      if (!(strcmp(val, "spooldir"))) {
         passwordlocation = OPT_PWLOC_SPOOLDIR;
      } else {
         passwordlocation = OPT_PWLOC_VOICEMAILCONF;
      }

      poll_freq = DEFAULT_POLL_FREQ;
      if ((val = ast_variable_retrieve(cfg, "general", "pollfreq"))) {
         if (sscanf(val, "%30u", &poll_freq) != 1) {
            poll_freq = DEFAULT_POLL_FREQ;
            ast_log(AST_LOG_ERROR, "'%s' is not a valid value for the pollfreq option!\n", val);
         }
      }

      poll_mailboxes = 0;
      if ((val = ast_variable_retrieve(cfg, "general", "pollmailboxes")))
         poll_mailboxes = ast_true(val);

      if (ucfg) { 
         for (cat = ast_category_browse(ucfg, NULL); cat ; cat = ast_category_browse(ucfg, cat)) {
            if (!ast_true(ast_config_option(ucfg, cat, "hasvoicemail")))
               continue;
            if ((current = find_or_create(userscontext, cat))) {
               populate_defaults(current);
               apply_options_full(current, ast_variable_browse(ucfg, cat));
               ast_copy_string(current->context, userscontext, sizeof(current->context));
               if (!ast_strlen_zero(current->password) && current->passwordlocation == OPT_PWLOC_VOICEMAILCONF) {
                  current->passwordlocation = OPT_PWLOC_USERSCONF;
               }

               switch (current->passwordlocation) {
               case OPT_PWLOC_SPOOLDIR:
                  snprintf(secretfn, sizeof(secretfn), "%s%s/%s/secret.conf", VM_SPOOL_DIR, current->context, current->mailbox);
                  read_password_from_file(secretfn, current->password, sizeof(current->password));
               }
            }
         }
         ast_config_destroy(ucfg);
      }
      cat = ast_category_browse(cfg, NULL);
      while (cat) {
         if (strcasecmp(cat, "general")) {
            var = ast_variable_browse(cfg, cat);
            if (strcasecmp(cat, "zonemessages")) {
               /* Process mailboxes in this context */
               while (var) {
                  append_mailbox(cat, var->name, var->value);
                  var = var->next;
               }
            } else {
               /* Timezones in this context */
               while (var) {
                  struct vm_zone *z;
                  if ((z = ast_malloc(sizeof(*z)))) {
                     char *msg_format, *tzone;
                     msg_format = ast_strdupa(var->value);
                     tzone = strsep(&msg_format, "|");
                     if (msg_format) {
                        ast_copy_string(z->name, var->name, sizeof(z->name));
                        ast_copy_string(z->timezone, tzone, sizeof(z->timezone));
                        ast_copy_string(z->msg_format, msg_format, sizeof(z->msg_format));
                        AST_LIST_LOCK(&zones);
                        AST_LIST_INSERT_HEAD(&zones, z, list);
                        AST_LIST_UNLOCK(&zones);
                     } else {
                        ast_log(AST_LOG_WARNING, "Invalid timezone definition at line %d\n", var->lineno);
                        ast_free(z);
                     }
                  } else {
                     AST_LIST_UNLOCK(&users);
                     ast_config_destroy(cfg);
                     return -1;
                  }
                  var = var->next;
               }
            }
         }
         cat = ast_category_browse(cfg, cat);
      }
      memset(fromstring, 0, sizeof(fromstring));
      memset(pagerfromstring, 0, sizeof(pagerfromstring));
      strcpy(charset, "ISO-8859-1");
      if (emailbody) {
         ast_free(emailbody);
         emailbody = NULL;
      }
      if (emailsubject) {
         ast_free(emailsubject);
         emailsubject = NULL;
      }
      if (pagerbody) {
         ast_free(pagerbody);
         pagerbody = NULL;
      }
      if (pagersubject) {
         ast_free(pagersubject);
         pagersubject = NULL;
      }
      if ((val = ast_variable_retrieve(cfg, "general", "pbxskip")))
         ast_set2_flag((&globalflags), ast_true(val), VM_PBXSKIP);
      if ((val = ast_variable_retrieve(cfg, "general", "fromstring")))
         ast_copy_string(fromstring, val, sizeof(fromstring));
      if ((val = ast_variable_retrieve(cfg, "general", "pagerfromstring")))
         ast_copy_string(pagerfromstring, val, sizeof(pagerfromstring));
      if ((val = ast_variable_retrieve(cfg, "general", "charset")))
         ast_copy_string(charset, val, sizeof(charset));
      if ((val = ast_variable_retrieve(cfg, "general", "adsifdn"))) {
         sscanf(val, "%2x%2x%2x%2x", &tmpadsi[0], &tmpadsi[1], &tmpadsi[2], &tmpadsi[3]);
         for (x = 0; x < 4; x++) {
            memcpy(&adsifdn[x], &tmpadsi[x], 1);
         }
      }
      if ((val = ast_variable_retrieve(cfg, "general", "adsisec"))) {
         sscanf(val, "%2x%2x%2x%2x", &tmpadsi[0], &tmpadsi[1], &tmpadsi[2], &tmpadsi[3]);
         for (x = 0; x < 4; x++) {
            memcpy(&adsisec[x], &tmpadsi[x], 1);
         }
      }
      if ((val = ast_variable_retrieve(cfg, "general", "adsiver"))) {
         if (atoi(val)) {
            adsiver = atoi(val);
         }
      }
      if ((val = ast_variable_retrieve(cfg, "general", "tz"))) {
         ast_copy_string(zonetag, val, sizeof(zonetag));
      }
      if ((val = ast_variable_retrieve(cfg, "general", "emailsubject"))) {
         emailsubject = ast_strdup(val);
      }
      if ((val = ast_variable_retrieve(cfg, "general", "emailbody"))) {
         emailbody = ast_strdup(substitute_escapes(val));
      }
      if ((val = ast_variable_retrieve(cfg, "general", "pagersubject"))) {
         pagersubject = ast_strdup(val);
      }
      if ((val = ast_variable_retrieve(cfg, "general", "pagerbody"))) {
         pagerbody = ast_strdup(substitute_escapes(val));
      }
      AST_LIST_UNLOCK(&users);
      ast_config_destroy(cfg);

      if (poll_mailboxes && poll_thread == AST_PTHREADT_NULL)
         start_poll_thread();
      if (!poll_mailboxes && poll_thread != AST_PTHREADT_NULL)
         stop_poll_thread();;

      return 0;
   } else {
      AST_LIST_UNLOCK(&users);
      ast_log(AST_LOG_WARNING, "Failed to load configuration file.\n");
      if (ucfg)
         ast_config_destroy(ucfg);
      return 0;
   }
}

static int load_module

(

void

)

[static]

Definition at line 11367 of file app_voicemail.c.

References ARRAY_LEN, ast_cli_register_multiple(), ast_config_AST_SPOOL_DIR, ast_custom_function_register, ast_install_vm_functions(), ast_log(), AST_LOG_WARNING, ast_manager_register_xml, ast_realtime_require_field(), ast_register_application_xml, ast_taskprocessor_get(), cli_voicemail, EVENT_FLAG_CALL, EVENT_FLAG_REPORTING, has_voicemail(), inboxcount(), inboxcount2(), load_config(), mailbox_exists_acf, manager_list_voicemail_users(), messagecount(), mwi_subscription_tps, RQ_CHAR, RQ_UINTEGER3, sayname(), SENTINEL, vm_box_exists(), vm_exec(), vm_execmain(), and vmauthenticate().

{
   int res;
   my_umask = umask(0);
   umask(my_umask);

   /* compute the location of the voicemail spool directory */
   snprintf(VM_SPOOL_DIR, sizeof(VM_SPOOL_DIR), "%s/voicemail/", ast_config_AST_SPOOL_DIR);
   
   if (!(mwi_subscription_tps = ast_taskprocessor_get("app_voicemail", 0))) {
      ast_log(AST_LOG_WARNING, "failed to reference mwi subscription taskprocessor.  MWI will not work\n");
   }

   if ((res = load_config(0)))
      return res;

   res = ast_register_application_xml(app, vm_exec);
   res |= ast_register_application_xml(app2, vm_execmain);
   res |= ast_register_application_xml(app3, vm_box_exists);
   res |= ast_register_application_xml(app4, vmauthenticate);
   res |= ast_custom_function_register(&mailbox_exists_acf);
   res |= ast_manager_register_xml("VoicemailUsersList", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, manager_list_voicemail_users);
   if (res)
      return res;

   ast_cli_register_multiple(cli_voicemail, ARRAY_LEN(cli_voicemail));

   ast_install_vm_functions(has_voicemail, inboxcount, inboxcount2, messagecount, sayname);
   ast_realtime_require_field("voicemail", "uniqueid", RQ_UINTEGER3, 11, "password", RQ_CHAR, 10, SENTINEL);
   ast_realtime_require_field("voicemail_data", "filename", RQ_CHAR, 30, "duration", RQ_UINTEGER3, 5, SENTINEL);

   return res;
}

static int make_dir	(	char *	dest,
		int	len,
		const char *	context,
		const char *	ext,
		const char *	folder
	)			[static]

Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.

Parameters:

	dest	The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
	len	The length of the path string that was written out.

The path is constructed as VM_SPOOL_DIRcontext/ext/folder

Returns:

zero on success, -1 on error.

Definition at line 1448 of file app_voicemail.c.

{
   return snprintf(dest, len, "%s%s/%s/%s", VM_SPOOL_DIR, context, ext, folder);
}

static void make_email_file	(	FILE *	p,
		char *	srcemail,
		struct ast_vm_user *	vmu,
		int	msgnum,
		char *	context,
		char *	mailbox,
		const char *	fromfolder,
		char *	cidnum,
		char *	cidname,
		char *	attach,
		char *	attach2,
		char *	format,
		int	duration,
		int	attach_user_voicemail,
		struct ast_channel *	chan,
		const char *	category,
		int	imap,
		const char *	flag
	)			[static]

Creates the email file to be sent to indicate a new voicemail exists for a user.

Parameters:

	p	The output file to generate the email contents into.
	srcemail	The email address to send the email to, presumably the email address for the owner of the mailbox.
	vmu	The voicemail user who is sending the voicemail.
	msgnum	The message index in the mailbox folder.
	context
	mailbox	The voicemail box to read the voicemail to be notified in this email.
	cidnum	The caller ID number.
	cidname	The caller ID name.
	attach	the name of the sound file to be attached to the email, if attach_user_voicemail == 1.
	format	The message sound file format. i.e. .wav
	duration	The time of the message content, in seconds.
	attach_user_voicemail	if 1, the sound file is attached to the email.
	chan
	category
	imap	if == 1, indicates the target folder for the email notification to be sent to will be an IMAP mailstore. This causes additional mailbox headers to be set, which would facilitate searching for the email in the destination IMAP folder.

The email body, and base 64 encoded attachement (if any) are stored to the file identified by *p. This method does not actually send the email. That is done by invoking the configure 'mailcmd' and piping this generated file into it, or with the sendemail() function.

Definition at line 4165 of file app_voicemail.c.

References add_email_attachment(), ast_channel_release(), ast_config_destroy(), ast_config_load, ast_copy_string(), ast_debug, ast_dummy_channel_alloc(), ast_free, ast_localtime(), ast_log(), AST_LOG_WARNING, ast_random(), ast_str_buffer(), ast_str_create(), ast_str_encode_mime(), ast_str_quote(), ast_str_set(), ast_str_substitute_variables(), ast_strdupa, ast_strftime(), ast_strlen_zero(), ast_test_flag, ast_variable_retrieve(), charset, check_mime(), CONFIG_FLAG_NOCACHE, ast_vm_user::context, ast_vm_user::email, ast_vm_user::emailbody, emailbody, emaildateformat, ast_vm_user::emailsubject, emailsubject, ENDL, fromstring, ast_vm_user::fullname, globalflags, ast_vm_user::mailbox, make_dir(), make_file(), MAXHOSTNAMELEN, ast_channel::name, prep_email_sub_vars(), ast_channel::priority, strip_control(), VM_PBXSKIP, and vmu_tm().

Referenced by sendmail().

{
   char date[256];
   char host[MAXHOSTNAMELEN] = "";
   char who[256];
   char bound[256];
   char dur[256];
   struct ast_tm tm;
   char enc_cidnum[256] = "", enc_cidname[256] = "";
   struct ast_str *str1 = ast_str_create(16), *str2 = ast_str_create(16);
   char *greeting_attachment; 
   char filename[256];

   if (!str1 || !str2) {
      ast_free(str1);
      ast_free(str2);
      return;
   }
#ifdef IMAP_STORAGE
#define ENDL "\r\n"
#else
#define ENDL "\n"
#endif

   if (cidnum) {
      strip_control(cidnum, enc_cidnum, sizeof(enc_cidnum));
   }
   if (cidname) {
      strip_control(cidname, enc_cidname, sizeof(enc_cidname));
   }
   gethostname(host, sizeof(host) - 1);

   if (strchr(srcemail, '@')) {
      ast_copy_string(who, srcemail, sizeof(who));
   } else {
      snprintf(who, sizeof(who), "%s@%s", srcemail, host);
   }
   
   greeting_attachment = strrchr(ast_strdupa(attach), '/');
   if (greeting_attachment) {
      *greeting_attachment++ = '\0';
   }

   snprintf(dur, sizeof(dur), "%d:%02d", duration / 60, duration % 60);
   ast_strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", vmu_tm(vmu, &tm));
   fprintf(p, "Date: %s" ENDL, date);

   /* Set date format for voicemail mail */
   ast_strftime(date, sizeof(date), emaildateformat, &tm);

   if (!ast_strlen_zero(fromstring)) {
      struct ast_channel *ast;
      if ((ast = ast_dummy_channel_alloc())) {
         char *ptr;
         prep_email_sub_vars(ast, vmu, msgnum + 1, context, mailbox, fromfolder, enc_cidnum, enc_cidname, dur, date, category, flag);
         ast_str_substitute_variables(&str1, 0, ast, fromstring);

         if (check_mime(ast_str_buffer(str1))) {
            int first_line = 1;
            ast_str_encode_mime(&str2, 0, ast_str_buffer(str1), strlen("From: "), strlen(who) + 3);
            while ((ptr = strchr(ast_str_buffer(str2), ' '))) {
               *ptr = '\0';
               fprintf(p, "%s %s" ENDL, first_line ? "From:" : "", ast_str_buffer(str2));
               first_line = 0;
               /* Substring is smaller, so this will never grow */
               ast_str_set(&str2, 0, "%s", ptr + 1);
            }
            fprintf(p, "%s %s <%s>" ENDL, first_line ? "From:" : "", ast_str_buffer(str2), who);
         } else {
            fprintf(p, "From: %s <%s>" ENDL, ast_str_quote(&str2, 0, ast_str_buffer(str1)), who);
         }
         ast = ast_channel_release(ast);
      } else {
         ast_log(AST_LOG_WARNING, "Cannot allocate the channel for variables substitution\n");
      }
   } else {
      fprintf(p, "From: Asterisk PBX <%s>" ENDL, who);
   }

   if (check_mime(vmu->fullname)) {
      int first_line = 1;
      char *ptr;
      ast_str_encode_mime(&str2, 0, vmu->fullname, strlen("To: "), strlen(vmu->email) + 3);
      while ((ptr = strchr(ast_str_buffer(str2), ' '))) {
         *ptr = '\0';
         fprintf(p, "%s %s" ENDL, first_line ? "To:" : "", ast_str_buffer(str2));
         first_line = 0;
         /* Substring is smaller, so this will never grow */
         ast_str_set(&str2, 0, "%s", ptr + 1);
      }
      fprintf(p, "%s %s <%s>" ENDL, first_line ? "To:" : "", ast_str_buffer(str2), vmu->email);
   } else {
      fprintf(p, "To: %s <%s>" ENDL, ast_str_quote(&str2, 0, vmu->fullname), vmu->email);
   }

   if (!ast_strlen_zero(emailsubject) || !ast_strlen_zero(vmu->emailsubject)) {
      char *e_subj = !ast_strlen_zero(vmu->emailsubject) ? vmu->emailsubject : emailsubject;
      struct ast_channel *ast;
      if ((ast = ast_dummy_channel_alloc())) {
         prep_email_sub_vars(ast, vmu, msgnum + 1, context, mailbox, fromfolder, cidnum, cidname, dur, date, category, flag);
         ast_str_substitute_variables(&str1, 0, ast, e_subj);
         if (check_mime(ast_str_buffer(str1))) {
            int first_line = 1;
            char *ptr;
            ast_str_encode_mime(&str2, 0, ast_str_buffer(str1), strlen("Subject: "), 0);
            while ((ptr = strchr(ast_str_buffer(str2), ' '))) {
               *ptr = '\0';
               fprintf(p, "%s %s" ENDL, first_line ? "Subject:" : "", ast_str_buffer(str2));
               first_line = 0;
               /* Substring is smaller, so this will never grow */
               ast_str_set(&str2, 0, "%s", ptr + 1);
            }
            fprintf(p, "%s %s" ENDL, first_line ? "Subject:" : "", ast_str_buffer(str2));
         } else {
            fprintf(p, "Subject: %s" ENDL, ast_str_buffer(str1));
         }
         ast = ast_channel_release(ast);
      } else {
         ast_log(AST_LOG_WARNING, "Cannot allocate the channel for variables substitution\n");
      }
   } else if (ast_test_flag((&globalflags), VM_PBXSKIP)) {
      if (ast_strlen_zero(flag)) {
         fprintf(p, "Subject: New message %d in mailbox %s" ENDL, msgnum + 1, mailbox);
      } else {
         fprintf(p, "Subject: New %s message %d in mailbox %s" ENDL, flag, msgnum + 1, mailbox);
      }
   } else {
      if (ast_strlen_zero(flag)) {
         fprintf(p, "Subject: [PBX]: New message %d in mailbox %s" ENDL, msgnum + 1, mailbox);
      } else {
         fprintf(p, "Subject: [PBX]: New %s message %d in mailbox %s" ENDL, flag, msgnum + 1, mailbox);
      }
   }

   fprintf(p, "Message-ID: <Asterisk-%d-%d-%s-%d@%s>" ENDL, msgnum + 1,
      (unsigned int) ast_random(), mailbox, (int) getpid(), host);
   if (imap) {
      /* additional information needed for IMAP searching */
      fprintf(p, "X-Asterisk-VM-Message-Num: %d" ENDL, msgnum + 1);
      /* fprintf(p, "X-Asterisk-VM-Orig-Mailbox: %s" ENDL, ext); */
      fprintf(p, "X-Asterisk-VM-Server-Name: %s" ENDL, fromstring);
      fprintf(p, "X-Asterisk-VM-Context: %s" ENDL, context);
#ifdef IMAP_STORAGE
      fprintf(p, "X-Asterisk-VM-Extension: %s" ENDL, (!ast_strlen_zero(vmu->imapvmshareid) ? vmu->imapvmshareid : mailbox));
#else
      fprintf(p, "X-Asterisk-VM-Extension: %s" ENDL, mailbox);
#endif
      /* flag added for Urgent */
      fprintf(p, "X-Asterisk-VM-Flag: %s" ENDL, flag);
      fprintf(p, "X-Asterisk-VM-Priority: %d" ENDL, chan->priority);
      fprintf(p, "X-Asterisk-VM-Caller-channel: %s" ENDL, chan->name);
      fprintf(p, "X-Asterisk-VM-Caller-ID-Num: %s" ENDL, enc_cidnum);
      fprintf(p, "X-Asterisk-VM-Caller-ID-Name: %s" ENDL, enc_cidname);
      fprintf(p, "X-Asterisk-VM-Duration: %d" ENDL, duration);
      if (!ast_strlen_zero(category)) {
         fprintf(p, "X-Asterisk-VM-Category: %s" ENDL, category);
      } else {
         fprintf(p, "X-Asterisk-VM-Category: " ENDL);
      }
      fprintf(p, "X-Asterisk-VM-Message-Type: %s" ENDL, msgnum > -1 ? "Message" : greeting_attachment);
      fprintf(p, "X-Asterisk-VM-Orig-date: %s" ENDL, date);
      fprintf(p, "X-Asterisk-VM-Orig-time: %ld" ENDL, (long) time(NULL));
   }
   if (!ast_strlen_zero(cidnum)) {
      fprintf(p, "X-Asterisk-CallerID: %s" ENDL, enc_cidnum);
   }
   if (!ast_strlen_zero(cidname)) {
      fprintf(p, "X-Asterisk-CallerIDName: %s" ENDL, enc_cidname);
   }
   fprintf(p, "MIME-Version: 1.0" ENDL);
   if (attach_user_voicemail) {
      /* Something unique. */
      snprintf(bound, sizeof(bound), "----voicemail_%d%s%d%d", msgnum + 1, mailbox,
         (int) getpid(), (unsigned int) ast_random());

      fprintf(p, "Content-Type: multipart/mixed; boundary=\"%s\"" ENDL, bound);
      fprintf(p, ENDL ENDL "This is a multi-part message in MIME format." ENDL ENDL);
      fprintf(p, "--%s" ENDL, bound);
   }
   fprintf(p, "Content-Type: text/plain; charset=%s" ENDL "Content-Transfer-Encoding: 8bit" ENDL ENDL, charset);
   if (emailbody || vmu->emailbody) {
      char* e_body = vmu->emailbody ? vmu->emailbody : emailbody;
      struct ast_channel *ast;
      if ((ast = ast_dummy_channel_alloc())) {
         prep_email_sub_vars(ast, vmu, msgnum + 1, context, mailbox, fromfolder, cidnum, cidname, dur, date, category, flag);
         ast_str_substitute_variables(&str1, 0, ast, e_body);
         fprintf(p, "%s" ENDL, ast_str_buffer(str1));
         ast = ast_channel_release(ast);
      } else {
         ast_log(AST_LOG_WARNING, "Cannot allocate the channel for variables substitution\n");
      }
   } else if (msgnum > -1) {
      if (strcmp(vmu->mailbox, mailbox)) {
         /* Forwarded type */
         struct ast_config *msg_cfg;
         const char *v;
         int inttime;
         char fromdir[256], fromfile[256], origdate[80] = "", origcallerid[80] = "";
         struct ast_flags config_flags = { CONFIG_FLAG_NOCACHE };
         /* Retrieve info from VM attribute file */
         make_dir(fromdir, sizeof(fromdir), vmu->context, vmu->mailbox, fromfolder);
         make_file(fromfile, sizeof(fromfile), fromdir, msgnum);
         if (strlen(fromfile) < sizeof(fromfile) - 5) {
            strcat(fromfile, ".txt");
         }
         if ((msg_cfg = ast_config_load(fromfile, config_flags))) {
            if ((v = ast_variable_retrieve(msg_cfg, "message", "callerid"))) {
               ast_copy_string(origcallerid, v, sizeof(origcallerid));
            }

            /* You might be tempted to do origdate, except that a) it's in the wrong
             * format, and b) it's missing for IMAP recordings. */
            if ((v = ast_variable_retrieve(msg_cfg, "message", "origtime")) && sscanf(v, "%30d", &inttime) == 1) {
               struct timeval tv = { inttime, };
               struct ast_tm tm;
               ast_localtime(&tv, &tm, NULL);
               ast_strftime(origdate, sizeof(origdate), emaildateformat, &tm);
            }
            fprintf(p, "Dear %s:" ENDL ENDL "\tJust wanted to let you know you were just forwarded"
               " a %s long message (number %d)" ENDL "in mailbox %s from %s, on %s" ENDL
               "(originally sent by %s on %s)" ENDL "so you might want to check it when you get a"
               " chance.  Thanks!" ENDL ENDL "\t\t\t\t--Asterisk" ENDL ENDL, vmu->fullname, dur,
               msgnum + 1, mailbox, (cidname ? cidname : (cidnum ? cidnum : "an unknown caller")),
               date, origcallerid, origdate);
            ast_config_destroy(msg_cfg);
         } else {
            goto plain_message;
         }
      } else {
plain_message:
         fprintf(p, "Dear %s:" ENDL ENDL "\tJust wanted to let you know you were just left a "
            "%s long message (number %d)" ENDL "in mailbox %s from %s, on %s so you might" ENDL
            "want to check it when you get a chance.  Thanks!" ENDL ENDL "\t\t\t\t--Asterisk"
            ENDL ENDL, vmu->fullname, dur, msgnum + 1, mailbox,
            (cidname ? cidname : (cidnum ? cidnum : "an unknown caller")), date);
      }
   } else {
      fprintf(p, "This message is to let you know that your greeting was changed on %s." ENDL
            "Please do not delete this message, lest your greeting vanish with it." ENDL ENDL, date);
   }

   if (imap || attach_user_voicemail) {
      if (!ast_strlen_zero(attach2)) {
         snprintf(filename, sizeof(filename), "msg%04d.%s", msgnum, format);
         ast_debug(5, "creating second attachment filename %s\n", filename);
         add_email_attachment(p, vmu, format, attach, greeting_attachment, mailbox, bound, filename, 0, msgnum);
         snprintf(filename, sizeof(filename), "msgintro%04d.%s", msgnum, format);
         ast_debug(5, "creating attachment filename %s\n", filename);
         add_email_attachment(p, vmu, format, attach2, greeting_attachment, mailbox, bound, filename, 1, msgnum);
      } else {
         snprintf(filename, sizeof(filename), "msg%04d.%s", msgnum, format);
         ast_debug(5, "creating attachment filename %s, no second attachment.\n", filename);
         add_email_attachment(p, vmu, format, attach, greeting_attachment, mailbox, bound, filename, 1, msgnum);
      }
   }
   ast_free(str1);
   ast_free(str2);
}

static int make_file	(	char *	dest,
		const int	len,
		const char *	dir,
		const int	num
	)			[static]

Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.

Parameters:

	dest	The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
	len	The length of the path string that was written out.

The path is constructed as VM_SPOOL_DIRcontext/ext/folder

Returns:

zero on success, -1 on error.

Definition at line 1463 of file app_voicemail.c.

Referenced by advanced_options(), close_mailbox(), copy_message(), leave_voicemail(), make_email_file(), notify_new_message(), play_message(), prep_email_sub_vars(), save_to_folder(), vm_execmain(), and vm_forwardoptions().

{
   return snprintf(dest, len, "%s/msg%04d", dir, num);
}

static int manager_list_voicemail_users	(	struct mansession *	s,
		const struct message *	m
	)			[static]

Manager list voicemail users command.

Definition at line 10447 of file app_voicemail.c.

References AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_test_flag, astman_append(), astman_get_header(), astman_send_ack(), ast_vm_user::attachfmt, ast_vm_user::callback, ast_vm_user::context, count_messages(), ast_vm_user::dialout, ast_vm_user::email, ast_vm_user::exit, ast_vm_user::fullname, inboxcount(), ast_vm_user::language, ast_vm_user::mailbox, ast_vm_user::mailcmd, make_dir(), ast_vm_user::maxmsg, ast_vm_user::maxsecs, ast_vm_user::pager, RESULT_SUCCESS, ast_vm_user::saydurationm, ast_vm_user::serveremail, ast_vm_user::uniqueid, VM_ATTACH, VM_DELETE, VM_ENVELOPE, VM_OPERATOR, VM_REVIEW, VM_SAYCID, ast_vm_user::volgain, and ast_vm_user::zonetag.

Referenced by load_module().

{
   struct ast_vm_user *vmu = NULL;
   const char *id = astman_get_header(m, "ActionID");
   char actionid[128] = "";

   if (!ast_strlen_zero(id))
      snprintf(actionid, sizeof(actionid), "ActionID: %s\r\n", id);

   AST_LIST_LOCK(&users);

   if (AST_LIST_EMPTY(&users)) {
      astman_send_ack(s, m, "There are no voicemail users currently defined.");
      AST_LIST_UNLOCK(&users);
      return RESULT_SUCCESS;
   }
   
   astman_send_ack(s, m, "Voicemail user list will follow");
   
   AST_LIST_TRAVERSE(&users, vmu, list) {
      char dirname[256];

#ifdef IMAP_STORAGE
      int new, old;
      inboxcount(vmu->mailbox, &new, &old);
#endif
      
      make_dir(dirname, sizeof(dirname), vmu->context, vmu->mailbox, "INBOX");
      astman_append(s,
         "%s"
         "Event: VoicemailUserEntry\r\n"
         "VMContext: %s\r\n"
         "VoiceMailbox: %s\r\n"
         "Fullname: %s\r\n"
         "Email: %s\r\n"
         "Pager: %s\r\n"
         "ServerEmail: %s\r\n"
         "MailCommand: %s\r\n"
         "Language: %s\r\n"
         "TimeZone: %s\r\n"
         "Callback: %s\r\n"
         "Dialout: %s\r\n"
         "UniqueID: %s\r\n"
         "ExitContext: %s\r\n"
         "SayDurationMinimum: %d\r\n"
         "SayEnvelope: %s\r\n"
         "SayCID: %s\r\n"
         "AttachMessage: %s\r\n"
         "AttachmentFormat: %s\r\n"
         "DeleteMessage: %s\r\n"
         "VolumeGain: %.2f\r\n"
         "CanReview: %s\r\n"
         "CallOperator: %s\r\n"
         "MaxMessageCount: %d\r\n"
         "MaxMessageLength: %d\r\n"
         "NewMessageCount: %d\r\n"
#ifdef IMAP_STORAGE
         "OldMessageCount: %d\r\n"
         "IMAPUser: %s\r\n"
#endif
         "\r\n",
         actionid,
         vmu->context,
         vmu->mailbox,
         vmu->fullname,
         vmu->email,
         vmu->pager,
         vmu->serveremail,
         vmu->mailcmd,
         vmu->language,
         vmu->zonetag,
         vmu->callback,
         vmu->dialout,
         vmu->uniqueid,
         vmu->exit,
         vmu->saydurationm,
         ast_test_flag(vmu, VM_ENVELOPE) ? "Yes" : "No",
         ast_test_flag(vmu, VM_SAYCID) ? "Yes" : "No",
         ast_test_flag(vmu, VM_ATTACH) ? "Yes" : "No",
         vmu->attachfmt,
         ast_test_flag(vmu, VM_DELETE) ? "Yes" : "No",
         vmu->volgain,
         ast_test_flag(vmu, VM_REVIEW) ? "Yes" : "No",
         ast_test_flag(vmu, VM_OPERATOR) ? "Yes" : "No",
         vmu->maxmsg,
         vmu->maxsecs,
#ifdef IMAP_STORAGE
         new, old, vmu->imapuser
#else
         count_messages(vmu, dirname)
#endif
         );
   }     
   astman_append(s, "Event: VoicemailUserEntryComplete\r\n%s\r\n", actionid);

   AST_LIST_UNLOCK(&users);

   return RESULT_SUCCESS;
}

static void* mb_poll_thread

(

void *

data

)

[static]

Definition at line 10281 of file app_voicemail.c.

References ast_cond_timedwait(), ast_mutex_lock(), ast_mutex_unlock(), ast_samp2tv(), ast_tvadd(), ast_tvnow(), poll_lock, and poll_subscribed_mailboxes().

Referenced by start_poll_thread().

{
   while (poll_thread_run) {
      struct timespec ts = { 0, };
      struct timeval wait;

      wait = ast_tvadd(ast_tvnow(), ast_samp2tv(poll_freq, 1));
      ts.tv_sec = wait.tv_sec;
      ts.tv_nsec = wait.tv_usec * 1000;

      ast_mutex_lock(&poll_lock);
      ast_cond_timedwait(&poll_cond, &poll_lock, &ts);
      ast_mutex_unlock(&poll_lock);

      if (!poll_thread_run)
         break;

      poll_subscribed_mailboxes();
   }

   return NULL;
}

static const char* mbox

(

int

id

)

[static]

Definition at line 1524 of file app_voicemail.c.

References ARRAY_LEN, and mailbox_folders.

Referenced by acf_mailbox_exists(), add_peer_mailboxes(), adsi_load_vmail(), build_gateway(), copy_message(), get_folder(), has_voicemail(), notify_new_message(), open_mailbox(), save_to_folder(), vm_box_exists(), and vm_execmain().

{
   return (id >= 0 && id < ARRAY_LEN(mailbox_folders)) ? mailbox_folders[id] : "Unknown";
}

static int messagecount	(	const char *	context,
		const char *	mailbox,
		const char *	folder
	)			[static]

Definition at line 4986 of file app_voicemail.c.

References __has_voicemail().

Referenced by load_module().

{
   return __has_voicemail(context, mailbox, folder, 0);
}

static void mwi_sub_destroy

(

struct mwi_sub *

mwi_sub

)

[static]

Definition at line 10304 of file app_voicemail.c.

References ast_free.

Referenced by handle_unsubscribe().

{
   ast_free(mwi_sub);
}

static void mwi_sub_event_cb	(	const struct ast_event *	event,
		void *	userdata
	)			[static]

Definition at line 10382 of file app_voicemail.c.

References ast_calloc, ast_event_get_ie_str(), ast_event_get_ie_uint(), ast_event_get_type(), AST_EVENT_IE_CONTEXT, AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_MAILBOX, AST_EVENT_IE_UNIQUEID, AST_EVENT_MWI, AST_EVENT_SUB, ast_free, ast_log(), ast_strdup, ast_taskprocessor_push(), mwi_sub_task::context, handle_subscribe(), LOG_ERROR, mwi_sub_task::mailbox, mwi_subscription_tps, and mwi_sub_task::uniqueid.

Referenced by start_poll_thread().

{
   struct mwi_sub_task *mwist;
   
   if (ast_event_get_type(event) != AST_EVENT_SUB)
      return;

   if (ast_event_get_ie_uint(event, AST_EVENT_IE_EVENTTYPE) != AST_EVENT_MWI)
      return;

   if ((mwist = ast_calloc(1, (sizeof(*mwist)))) == NULL) {
      ast_log(LOG_ERROR, "could not allocate a mwi_sub_task\n");
      return;
   }
   mwist->mailbox = ast_strdup(ast_event_get_ie_str(event, AST_EVENT_IE_MAILBOX));
   mwist->context = ast_strdup(ast_event_get_ie_str(event, AST_EVENT_IE_CONTEXT));
   mwist->uniqueid = ast_event_get_ie_uint(event, AST_EVENT_IE_UNIQUEID);
   
   if (ast_taskprocessor_push(mwi_subscription_tps, handle_subscribe, mwist) < 0) {
      ast_free(mwist);
   }
}

static void mwi_unsub_event_cb	(	const struct ast_event *	event,
		void *	userdata
	)			[static]

Definition at line 10366 of file app_voicemail.c.

References ast_calloc, ast_event_get_ie_uint(), ast_event_get_type(), AST_EVENT_IE_EVENTTYPE, AST_EVENT_IE_UNIQUEID, AST_EVENT_MWI, AST_EVENT_UNSUB, ast_free, ast_taskprocessor_push(), handle_unsubscribe(), mwi_subscription_tps, and mwi_sub_task::uniqueid.

Referenced by start_poll_thread().

{
   uint32_t u, *uniqueid = ast_calloc(1, sizeof(*uniqueid));
   if (ast_event_get_type(event) != AST_EVENT_UNSUB)
      return;

   if (ast_event_get_ie_uint(event, AST_EVENT_IE_EVENTTYPE) != AST_EVENT_MWI)
      return;

   u = ast_event_get_ie_uint(event, AST_EVENT_IE_UNIQUEID);
   *uniqueid = u;
   if (ast_taskprocessor_push(mwi_subscription_tps, handle_unsubscribe, uniqueid) < 0) {
      ast_free(uniqueid);
   }
}

static int notify_new_message	(	struct ast_channel *	chan,
		struct ast_vm_user *	vmu,
		struct vm_state *	vms,
		int	msgnum,
		long	duration,
		char *	fmt,
		char *	cidnum,
		char *	cidname,
		const char *	flag
	)			[static]

Sends email notification that a user has a new voicemail waiting for them.

Parameters:

	chan
	vmu
	vms
	msgnum
	duration
	fmt
	cidnum	The Caller ID phone number value.
	cidname	The Caller ID name value.

Returns:

zero on success, -1 on error.

Definition at line 6501 of file app_voicemail.c.

References ast_app_has_voicemail(), ast_app_inboxcount2(), ast_channel_lock, ast_channel_unlock, ast_log(), AST_LOG_WARNING, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_vm_user::attachfmt, ast_vm_user::context, vm_state::curmsg, DELETE, DISPOSE, ast_vm_user::email, EVENT_FLAG_CALL, globalflags, ast_vm_user::mailbox, make_dir(), make_file(), manager_event, mbox(), vm_state::newmessages, ast_vm_user::pager, pbx_builtin_getvar_helper(), queue_mwi_event(), RETRIEVE, run_externnotify(), sendmail(), sendpage(), ast_vm_user::serveremail, strsep(), VM_ATTACH, vm_delete(), and VM_DELETE.

{
   char todir[PATH_MAX], fn[PATH_MAX], ext_context[PATH_MAX], *stringp;
   int newmsgs = 0, oldmsgs = 0, urgentmsgs = 0;
   const char *category;
   char *myserveremail = serveremail;

   ast_channel_lock(chan);
   if ((category = pbx_builtin_getvar_helper(chan, "VM_CATEGORY"))) {
      category = ast_strdupa(category);
   }
   ast_channel_unlock(chan);

   make_dir(todir, sizeof(todir), vmu->context, vmu->mailbox, "INBOX");
   make_file(fn, sizeof(fn), todir, msgnum);
   snprintf(ext_context, sizeof(ext_context), "%s@%s", vmu->mailbox, vmu->context);

   if (!ast_strlen_zero(vmu->attachfmt)) {
      if (strstr(fmt, vmu->attachfmt))
         fmt = vmu->attachfmt;
      else
         ast_log(AST_LOG_WARNING, "Attachment format '%s' is not one of the recorded formats '%s'.  Falling back to default format for '%s@%s'.\n", vmu->attachfmt, fmt, vmu->mailbox, vmu->context);
   }

   /* Attach only the first format */
   fmt = ast_strdupa(fmt);
   stringp = fmt;
   strsep(&stringp, "|");

   if (!