who really need it. git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@89466 65c4cc65-6c06-0410-ace0-fbb531ad65f3
3113 lines
101 KiB
C
3113 lines
101 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 1999 - 2005, Digium, Inc.
|
|
* and Edvina AB, Sollentuna, Sweden
|
|
*
|
|
* Mark Spencer <markster@digium.com> (Comedian Mail)
|
|
* and Olle E. Johansson, Edvina.net <oej@edvina.net> (Mini-Voicemail changes)
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*! \file
|
|
*
|
|
* \brief MiniVoiceMail - A Minimal Voicemail System for Asterisk
|
|
*
|
|
* A voicemail system in small building blocks, working together
|
|
* based on the Comedian Mail voicemail system (app_voicemail.c).
|
|
*
|
|
* \par See also
|
|
* \arg \ref Config_minivm
|
|
* \arg \ref Config_minivm_examples
|
|
* \arg \ref App_minivm
|
|
*
|
|
* \ingroup applications
|
|
*
|
|
* \page App_minivm Asterisk Mini-voicemail - A minimal voicemail system
|
|
*
|
|
* This is a minimal voicemail system, building blocks for something
|
|
* else. It is built for multi-language systems.
|
|
* The current version is focused on accounts where voicemail is
|
|
* forwarded to users in e-mail. It's work in progress, with loosed ends hanging
|
|
* around from the old voicemail system and it's configuration.
|
|
*
|
|
* Hopefully, we can expand this to be a full replacement of voicemail() and voicemailmain()
|
|
* in the future.
|
|
*
|
|
* Dialplan applications
|
|
* - minivmRecord - record voicemail and send as e-mail ( \ref minivm_record_exec() )
|
|
* - minivmGreet - Play user's greeting or default greeting ( \ref minivm_greet_exec() )
|
|
* - minivmNotify - Notify user of message ( \ref minivm_notify_exec() )
|
|
* - minivmDelete - Delete voicemail message ( \ref minivm_delete_exec() )
|
|
* - minivmAccMess - Record personal messages (busy | unavailable | temporary)
|
|
*
|
|
* Dialplan functions
|
|
* - MINIVMACCOUNT() - A dialplan function
|
|
* - MINIVMCOUNTER() - Manage voicemail-related counters for accounts or domains
|
|
*
|
|
* CLI Commands
|
|
* - minivm list accounts
|
|
* - minivm list zones
|
|
* - minivm list templates
|
|
* - minivm show stats
|
|
* - minivm show settings
|
|
*
|
|
* Some notes
|
|
* - General configuration in minivm.conf
|
|
* - Users in realtime or configuration file
|
|
* - Or configured on the command line with just the e-mail address
|
|
*
|
|
* Voicemail accounts are identified by userid and domain
|
|
*
|
|
* Language codes are like setlocale - langcode_countrycode
|
|
* \note Don't use language codes like the rest of Asterisk, two letter countrycode. Use
|
|
* language_country like setlocale().
|
|
*
|
|
* Examples:
|
|
* - Swedish, Sweden sv_se
|
|
* - Swedish, Finland sv_fi
|
|
* - English, USA en_us
|
|
* - English, GB en_gb
|
|
*
|
|
* \par See also
|
|
* \arg \ref Config_minivm
|
|
* \arg \ref Config_minivm_examples
|
|
* \arg \ref Minivm_directories
|
|
* \arg \ref app_minivm.c
|
|
* \arg Comedian mail: app_voicemail.c
|
|
* \arg \ref descrip_minivm_accmess
|
|
* \arg \ref descrip_minivm_greet
|
|
* \arg \ref descrip_minivm_record
|
|
* \arg \ref descrip_minivm_delete
|
|
* \arg \ref descrip_minivm_notify
|
|
*
|
|
* \arg \ref App_minivm_todo
|
|
*/
|
|
/*! \page Minivm_directories Asterisk Mini-Voicemail Directory structure
|
|
*
|
|
* The directory structure for storing voicemail
|
|
* - AST_SPOOL_DIR - usually /var/spool/asterisk (configurable in asterisk.conf)
|
|
* - MVM_SPOOL_DIR - should be configurable, usually AST_SPOOL_DIR/voicemail
|
|
* - Domain MVM_SPOOL_DIR/domain
|
|
* - Username MVM_SPOOL_DIR/domain/username
|
|
* - /greet : Recording of account owner's name
|
|
* - /busy : Busy message
|
|
* - /unavailable : Unavailable message
|
|
* - /temp : Temporary message
|
|
*
|
|
* For account anita@localdomain.xx the account directory would as a default be
|
|
* \b /var/spool/asterisk/voicemail/localdomain.xx/anita
|
|
*
|
|
* To avoid transcoding, these sound files should be converted into several formats
|
|
* They are recorded in the format closest to the incoming streams
|
|
*
|
|
*
|
|
* Back: \ref App_minivm
|
|
*/
|
|
|
|
/*! \page Config_minivm_examples Example dialplan for Mini-Voicemail
|
|
* \section Example dialplan scripts for Mini-Voicemail
|
|
* \verbinclude extensions_minivm.conf.sample
|
|
*
|
|
* Back: \ref App_minivm
|
|
*/
|
|
|
|
/*! \page App_minivm_todo Asterisk Mini-Voicemail - todo
|
|
* - configure accounts from AMI?
|
|
* - test, test, test, test
|
|
* - fix "vm-theextensionis.gsm" voiceprompt from Allison in various formats
|
|
* "The extension you are calling"
|
|
* - For trunk, consider using channel storage for information passing between small applications
|
|
* - Set default directory for voicemail
|
|
* - New app for creating directory for account if it does not exist
|
|
* - Re-insert code for IMAP storage at some point
|
|
* - Jabber integration for notifications
|
|
* - Figure out how to handle video in voicemail
|
|
* - Integration with the HTTP server
|
|
* - New app for moving messages between mailboxes, and optionally mark it as "new"
|
|
*
|
|
* For Asterisk 1.4/trunk
|
|
* - Use string fields for minivm_account
|
|
*
|
|
* Back: \ref App_minivm
|
|
*/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
#include <ctype.h>
|
|
#include <sys/time.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
#include <time.h>
|
|
#include <dirent.h>
|
|
#include <locale.h>
|
|
|
|
|
|
#include "asterisk/paths.h" /* use various paths */
|
|
#include "asterisk/astobj.h"
|
|
#include "asterisk/lock.h"
|
|
#include "asterisk/file.h"
|
|
#include "asterisk/channel.h"
|
|
#include "asterisk/pbx.h"
|
|
#include "asterisk/options.h"
|
|
#include "asterisk/config.h"
|
|
#include "asterisk/say.h"
|
|
#include "asterisk/module.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/linkedlists.h"
|
|
#include "asterisk/callerid.h"
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
|
|
#define MVM_REVIEW (1 << 0) /*!< Review message */
|
|
#define MVM_OPERATOR (1 << 1) /*!< Operator exit during voicemail recording */
|
|
#define MVM_REALTIME (1 << 2) /*!< This user is a realtime account */
|
|
#define MVM_SVMAIL (1 << 3)
|
|
#define MVM_ENVELOPE (1 << 4)
|
|
#define MVM_PBXSKIP (1 << 9)
|
|
#define MVM_ALLOCED (1 << 13)
|
|
|
|
/*! \brief Default mail command to mail voicemail. Change it with the
|
|
mailcmd= command in voicemail.conf */
|
|
#define SENDMAIL "/usr/sbin/sendmail -t"
|
|
|
|
#define SOUND_INTRO "vm-intro"
|
|
#define B64_BASEMAXINLINE 256 /*!< Buffer size for Base 64 attachment encoding */
|
|
#define B64_BASELINELEN 72 /*!< Line length for Base 64 endoded messages */
|
|
#define EOL "\r\n"
|
|
|
|
#define MAX_DATETIME_FORMAT 512
|
|
#define MAX_NUM_CID_CONTEXTS 10
|
|
|
|
#define ERROR_LOCK_PATH -100
|
|
#define VOICEMAIL_DIR_MODE 0700
|
|
|
|
#define VOICEMAIL_CONFIG "minivm.conf"
|
|
#define ASTERISK_USERNAME "asterisk" /*!< Default username for sending mail is asterisk\@localhost */
|
|
|
|
/*! \brief Message types for notification */
|
|
enum mvm_messagetype {
|
|
MVM_MESSAGE_EMAIL,
|
|
MVM_MESSAGE_PAGE
|
|
/* For trunk: MVM_MESSAGE_JABBER, */
|
|
};
|
|
|
|
static char MVM_SPOOL_DIR[PATH_MAX];
|
|
|
|
/* Module declarations */
|
|
static char *app_minivm_record = "MinivmRecord"; /* Leave a message */
|
|
static char *app_minivm_greet = "MinivmGreet"; /* Play voicemail prompts */
|
|
static char *app_minivm_notify = "MinivmNotify"; /* Notify about voicemail by using one of several methods */
|
|
static char *app_minivm_delete = "MinivmDelete"; /* Notify about voicemail by using one of several methods */
|
|
static char *app_minivm_accmess = "MinivmAccMess"; /* Record personal voicemail messages */
|
|
|
|
static char *synopsis_minivm_record = "Receive Mini-Voicemail and forward via e-mail";
|
|
static char *descrip_minivm_record =
|
|
" MinivmRecord(username@domain[,options]):\n"
|
|
"This application is part of the Mini-Voicemail system, configured in minivm.conf.\n"
|
|
"MiniVM records audio file in configured format and forwards message to e-mail and pager.\n"
|
|
"If there's no user account for that address, a temporary account will\n"
|
|
"be used with default options.\n"
|
|
"The recorded file name and path will be stored in MINIVM_FILENAME and the \n"
|
|
"duration of the message will be stored in MINIVM_DURATION\n"
|
|
"\nNote: If the caller hangs up after the recording, the only way to send\n"
|
|
"the message and clean up is to execute in the \"h\" extension.\n"
|
|
"\nThe application will exit if any of the following DTMF digits are \n"
|
|
"received and the requested extension exist in the current context.\n"
|
|
" 0 - Jump to the 'o' extension in the current dialplan context.\n"
|
|
" * - Jump to the 'a' extension in the current dialplan context.\n"
|
|
"\n"
|
|
"Result is given in channel variable MINIVM_RECORD_STATUS\n"
|
|
" The possible values are: SUCCESS | USEREXIT | FAILED\n\n"
|
|
" Options:\n"
|
|
" g(#) - Use the specified amount of gain when recording the voicemail\n"
|
|
" message. The units are whole-number decibels (dB).\n"
|
|
"\n";
|
|
|
|
static char *synopsis_minivm_greet = "Play Mini-Voicemail prompts";
|
|
static char *descrip_minivm_greet =
|
|
" MinivmGreet(username@domain[,options]):\n"
|
|
"This application is part of the Mini-Voicemail system, configured in minivm.conf.\n"
|
|
"MinivmGreet() plays default prompts or user specific prompts for an account.\n"
|
|
"Busy and unavailable messages can be choosen, but will be overridden if a temporary\n"
|
|
"message exists for the account.\n"
|
|
"\n"
|
|
"Result is given in channel variable MINIVM_GREET_STATUS\n"
|
|
" The possible values are: SUCCESS | USEREXIT | FAILED\n\n"
|
|
" Options:\n"
|
|
" b - Play the 'busy' greeting to the calling party.\n"
|
|
" s - Skip the playback of instructions for leaving a message to the\n"
|
|
" calling party.\n"
|
|
" u - Play the 'unavailable greeting.\n"
|
|
"\n";
|
|
|
|
static char *synopsis_minivm_notify = "Notify voicemail owner about new messages.";
|
|
static char *descrip_minivm_notify =
|
|
" MinivmNotify(username@domain[,template]):\n"
|
|
"This application is part of the Mini-Voicemail system, configured in minivm.conf.\n"
|
|
"MiniVMnotify forwards messages about new voicemail to e-mail and pager.\n"
|
|
"If there's no user account for that address, a temporary account will\n"
|
|
"be used with default options (set in minivm.conf).\n"
|
|
"The recorded file name and path will be read from MVM_FILENAME and the \n"
|
|
"duration of the message will be accessed from MVM_DURATION (set by MinivmRecord() )\n"
|
|
"If the channel variable MVM_COUNTER is set, this will be used in the\n"
|
|
"message file name and available in the template for the message.\n"
|
|
"If not template is given, the default email template will be used to send email and\n"
|
|
"default pager template to send paging message (if the user account is configured with\n"
|
|
"a paging address.\n"
|
|
"\n"
|
|
"Result is given in channel variable MINIVM_NOTIFY_STATUS\n"
|
|
" The possible values are: SUCCESS | FAILED\n"
|
|
"\n";
|
|
|
|
static char *synopsis_minivm_delete = "Delete Mini-Voicemail voicemail messages";
|
|
static char *descrip_minivm_delete =
|
|
" MinivmDelete(filename):\n"
|
|
"This application is part of the Mini-Voicemail system, configured in minivm.conf.\n"
|
|
"It deletes voicemail file set in MVM_FILENAME or given filename.\n"
|
|
"\n"
|
|
"Result is given in channel variable MINIVM_DELETE_STATUS\n"
|
|
" The possible values are: SUCCESS | FAILED\n"
|
|
" FAILED is set if the file does not exist or can't be deleted.\n"
|
|
"\n";
|
|
|
|
static char *synopsis_minivm_accmess = "Record account specific messages";
|
|
static char *descrip_minivm_accmess =
|
|
" MinivmAccmess(username@domain,option):\n"
|
|
"This application is part of the Mini-Voicemail system, configured in minivm.conf.\n"
|
|
"Use this application to record account specific audio/video messages for\n"
|
|
"busy, unavailable and temporary messages.\n"
|
|
"Account specific directories will be created if they do not exist.\n"
|
|
"\nThe option selects message to be recorded:\n"
|
|
" u Unavailable\n"
|
|
" b Busy\n"
|
|
" t Temporary (overrides busy and unavailable)\n"
|
|
" n Account name\n"
|
|
"\n"
|
|
"Result is given in channel variable MINIVM_ACCMESS_STATUS\n"
|
|
" The possible values are: SUCCESS | FAILED\n"
|
|
" FAILED is set if the file can't be created.\n"
|
|
"\n";
|
|
|
|
enum {
|
|
OPT_SILENT = (1 << 0),
|
|
OPT_BUSY_GREETING = (1 << 1),
|
|
OPT_UNAVAIL_GREETING = (1 << 2),
|
|
OPT_TEMP_GREETING = (1 << 3),
|
|
OPT_NAME_GREETING = (1 << 4),
|
|
OPT_RECORDGAIN = (1 << 5),
|
|
} minivm_option_flags;
|
|
|
|
enum {
|
|
OPT_ARG_RECORDGAIN = 0,
|
|
OPT_ARG_ARRAY_SIZE = 1,
|
|
} minivm_option_args;
|
|
|
|
AST_APP_OPTIONS(minivm_app_options, {
|
|
AST_APP_OPTION('s', OPT_SILENT),
|
|
AST_APP_OPTION('b', OPT_BUSY_GREETING),
|
|
AST_APP_OPTION('u', OPT_UNAVAIL_GREETING),
|
|
AST_APP_OPTION_ARG('g', OPT_RECORDGAIN, OPT_ARG_RECORDGAIN),
|
|
});
|
|
|
|
AST_APP_OPTIONS(minivm_accmess_options, {
|
|
AST_APP_OPTION('b', OPT_BUSY_GREETING),
|
|
AST_APP_OPTION('u', OPT_UNAVAIL_GREETING),
|
|
AST_APP_OPTION('t', OPT_TEMP_GREETING),
|
|
AST_APP_OPTION('n', OPT_NAME_GREETING),
|
|
});
|
|
|
|
/*! \brief Structure for linked list of Mini-Voicemail users: \ref minivm_accounts */
|
|
struct minivm_account {
|
|
char username[AST_MAX_CONTEXT]; /*!< Mailbox username */
|
|
char domain[AST_MAX_CONTEXT]; /*!< Voicemail domain */
|
|
|
|
char pincode[10]; /*!< Secret pin code, numbers only */
|
|
char fullname[120]; /*!< Full name, for directory app */
|
|
char email[80]; /*!< E-mail address - override */
|
|
char pager[80]; /*!< E-mail address to pager (no attachment) */
|
|
char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Voicemail account account code */
|
|
char serveremail[80]; /*!< From: Mail address */
|
|
char externnotify[160]; /*!< Configurable notification command */
|
|
char language[MAX_LANGUAGE]; /*!< Config: Language setting */
|
|
char zonetag[80]; /*!< Time zone */
|
|
char uniqueid[20]; /*!< Unique integer identifier */
|
|
char exit[80]; /*!< Options for exiting from voicemail() */
|
|
char attachfmt[80]; /*!< Format for voicemail audio file attachment */
|
|
char etemplate[80]; /*!< Pager template */
|
|
char ptemplate[80]; /*!< Voicemail format */
|
|
unsigned int flags; /*!< MVM_ flags */
|
|
struct ast_variable *chanvars; /*!< Variables for e-mail template */
|
|
double volgain; /*!< Volume gain for voicemails sent via e-mail */
|
|
AST_LIST_ENTRY(minivm_account) list;
|
|
};
|
|
|
|
/*! \brief The list of e-mail accounts */
|
|
static AST_LIST_HEAD_STATIC(minivm_accounts, minivm_account);
|
|
|
|
/*! \brief Linked list of e-mail templates in various languages
|
|
These are used as templates for e-mails, pager messages and jabber messages
|
|
\ref message_templates
|
|
*/
|
|
struct minivm_template {
|
|
char name[80]; /*!< Template name */
|
|
char *body; /*!< Body of this template */
|
|
char fromaddress[100]; /*!< Who's sending the e-mail? */
|
|
char serveremail[80]; /*!< From: Mail address */
|
|
char subject[100]; /*!< Subject line */
|
|
char charset[32]; /*!< Default character set for this template */
|
|
char locale[20]; /*!< Locale for setlocale() */
|
|
char dateformat[80]; /*!< Date format to use in this attachment */
|
|
int attachment; /*!< Attachment of media yes/no - no for pager messages */
|
|
AST_LIST_ENTRY(minivm_template) list; /*!< List mechanics */
|
|
};
|
|
|
|
/*! \brief The list of e-mail templates */
|
|
static AST_LIST_HEAD_STATIC(message_templates, minivm_template);
|
|
|
|
/*! \brief Options for leaving voicemail with the voicemail() application */
|
|
struct leave_vm_options {
|
|
unsigned int flags;
|
|
signed char record_gain;
|
|
};
|
|
|
|
/*! \brief Structure for base64 encoding */
|
|
struct b64_baseio {
|
|
int iocp;
|
|
int iolen;
|
|
int linelength;
|
|
int ateof;
|
|
unsigned char iobuf[B64_BASEMAXINLINE];
|
|
};
|
|
|
|
/*! \brief Voicemail time zones */
|
|
struct minivm_zone {
|
|
char name[80]; /*!< Name of this time zone */
|
|
char timezone[80]; /*!< Timezone definition */
|
|
char msg_format[BUFSIZ]; /*!< Not used in minivm ...yet */
|
|
AST_LIST_ENTRY(minivm_zone) list; /*!< List mechanics */
|
|
};
|
|
|
|
/*! \brief The list of e-mail time zones */
|
|
static AST_LIST_HEAD_STATIC(minivm_zones, minivm_zone);
|
|
|
|
/*! \brief Structure for gathering statistics */
|
|
struct minivm_stats {
|
|
int voicemailaccounts; /*!< Number of static accounts */
|
|
int timezones; /*!< Number of time zones */
|
|
int templates; /*!< Number of templates */
|
|
|
|
struct timeval reset; /*!< Time for last reset */
|
|
int receivedmessages; /*!< Number of received messages since reset */
|
|
struct timeval lastreceived; /*!< Time for last voicemail sent */
|
|
};
|
|
|
|
/*! \brief Statistics for voicemail */
|
|
static struct minivm_stats global_stats;
|
|
|
|
AST_MUTEX_DEFINE_STATIC(minivmlock); /*!< Lock to protect voicemail system */
|
|
AST_MUTEX_DEFINE_STATIC(minivmloglock); /*!< Lock to protect voicemail system log file */
|
|
|
|
FILE *minivmlogfile; /*!< The minivm log file */
|
|
|
|
static int global_vmminmessage; /*!< Minimum duration of messages */
|
|
static int global_vmmaxmessage; /*!< Maximum duration of message */
|
|
static int global_maxsilence; /*!< Maximum silence during recording */
|
|
static int global_maxgreet; /*!< Maximum length of prompts */
|
|
static int global_silencethreshold = 128;
|
|
static char global_mailcmd[160]; /*!< Configurable mail cmd */
|
|
static char global_externnotify[160]; /*!< External notification application */
|
|
static char global_logfile[PATH_MAX]; /*!< Global log file for messages */
|
|
static char default_vmformat[80];
|
|
|
|
static struct ast_flags globalflags = {0}; /*!< Global voicemail flags */
|
|
static int global_saydurationminfo;
|
|
static char global_charset[32]; /*!< Global charset in messages */
|
|
|
|
static double global_volgain; /*!< Volume gain for voicmemail via e-mail */
|
|
|
|
/*! \brief Default dateformat, can be overridden in configuration file */
|
|
#define DEFAULT_DATEFORMAT "%A, %B %d, %Y at %r"
|
|
#define DEFAULT_CHARSET "ISO-8859-1"
|
|
|
|
/* Forward declarations */
|
|
static char *message_template_parse_filebody(const char *filename);
|
|
static char *message_template_parse_emailbody(const char *body);
|
|
static int create_vmaccount(char *name, struct ast_variable *var, int realtime);
|
|
static struct minivm_account *find_user_realtime(const char *domain, const char *username);
|
|
static char *handle_minivm_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
|
|
|
|
/*! \brief Create message template */
|
|
static struct minivm_template *message_template_create(const char *name)
|
|
{
|
|
struct minivm_template *template;
|
|
|
|
template = ast_calloc(1, sizeof(*template));
|
|
if (!template)
|
|
return NULL;
|
|
|
|
/* Set some defaults for templates */
|
|
ast_copy_string(template->name, name, sizeof(template->name));
|
|
ast_copy_string(template->dateformat, DEFAULT_DATEFORMAT, sizeof(template->dateformat));
|
|
ast_copy_string(template->charset, DEFAULT_CHARSET, sizeof(template->charset));
|
|
ast_copy_string(template->subject, "New message in mailbox ${MVM_USERNAME}@${MVM_DOMAIN}", sizeof(template->subject));
|
|
template->attachment = TRUE;
|
|
|
|
return template;
|
|
}
|
|
|
|
/*! \brief Release memory allocated by message template */
|
|
static void message_template_free(struct minivm_template *template)
|
|
{
|
|
if (template->body)
|
|
ast_free(template->body);
|
|
|
|
ast_free (template);
|
|
}
|
|
|
|
/*! \brief Build message template from configuration */
|
|
static int message_template_build(const char *name, struct ast_variable *var)
|
|
{
|
|
struct minivm_template *template;
|
|
int error = 0;
|
|
|
|
template = message_template_create(name);
|
|
if (!template) {
|
|
ast_log(LOG_ERROR, "Out of memory, can't allocate message template object %s.\n", name);
|
|
return -1;
|
|
}
|
|
|
|
while (var) {
|
|
ast_debug(3, "-_-_- Configuring template option %s = \"%s\" for template %s\n", var->name, var->value, name);
|
|
if (!strcasecmp(var->name, "fromaddress")) {
|
|
ast_copy_string(template->fromaddress, var->value, sizeof(template->fromaddress));
|
|
} else if (!strcasecmp(var->name, "fromemail")) {
|
|
ast_copy_string(template->serveremail, var->value, sizeof(template->serveremail));
|
|
} else if (!strcasecmp(var->name, "subject")) {
|
|
ast_copy_string(template->subject, var->value, sizeof(template->subject));
|
|
} else if (!strcasecmp(var->name, "locale")) {
|
|
ast_copy_string(template->locale, var->value, sizeof(template->locale));
|
|
} else if (!strcasecmp(var->name, "attachmedia")) {
|
|
template->attachment = ast_true(var->value);
|
|
} else if (!strcasecmp(var->name, "dateformat")) {
|
|
ast_copy_string(template->dateformat, var->value, sizeof(template->dateformat));
|
|
} else if (!strcasecmp(var->name, "charset")) {
|
|
ast_copy_string(template->charset, var->value, sizeof(template->charset));
|
|
} else if (!strcasecmp(var->name, "templatefile")) {
|
|
if (template->body)
|
|
ast_free(template->body);
|
|
template->body = message_template_parse_filebody(var->value);
|
|
if (!template->body) {
|
|
ast_log(LOG_ERROR, "Error reading message body definition file %s\n", var->value);
|
|
error++;
|
|
}
|
|
} else if (!strcasecmp(var->name, "messagebody")) {
|
|
if (template->body)
|
|
ast_free(template->body);
|
|
template->body = message_template_parse_emailbody(var->value);
|
|
if (!template->body) {
|
|
ast_log(LOG_ERROR, "Error parsing message body definition:\n %s\n", var->value);
|
|
error++;
|
|
}
|
|
} else {
|
|
ast_log(LOG_ERROR, "Unknown message template configuration option \"%s=%s\"\n", var->name, var->value);
|
|
error++;
|
|
}
|
|
var = var->next;
|
|
}
|
|
if (error)
|
|
ast_log(LOG_ERROR, "-- %d errors found parsing message template definition %s\n", error, name);
|
|
|
|
AST_LIST_LOCK(&message_templates);
|
|
AST_LIST_INSERT_TAIL(&message_templates, template, list);
|
|
AST_LIST_UNLOCK(&message_templates);
|
|
|
|
global_stats.templates++;
|
|
|
|
return error;
|
|
}
|
|
|
|
/*! \brief Find named template */
|
|
static struct minivm_template *message_template_find(const char *name)
|
|
{
|
|
struct minivm_template *this, *res = NULL;
|
|
|
|
if (ast_strlen_zero(name))
|
|
return NULL;
|
|
|
|
AST_LIST_LOCK(&message_templates);
|
|
AST_LIST_TRAVERSE(&message_templates, this, list) {
|
|
if (!strcasecmp(this->name, name)) {
|
|
res = this;
|
|
break;
|
|
}
|
|
}
|
|
AST_LIST_UNLOCK(&message_templates);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
/*! \brief Clear list of templates */
|
|
static void message_destroy_list(void)
|
|
{
|
|
struct minivm_template *this;
|
|
AST_LIST_LOCK(&message_templates);
|
|
while ((this = AST_LIST_REMOVE_HEAD(&message_templates, list)))
|
|
message_template_free(this);
|
|
|
|
AST_LIST_UNLOCK(&message_templates);
|
|
}
|
|
|
|
/*! \brief read buffer from file (base64 conversion) */
|
|
static int b64_inbuf(struct b64_baseio *bio, FILE *fi)
|
|
{
|
|
int l;
|
|
|
|
if (bio->ateof)
|
|
return 0;
|
|
|
|
if ((l = fread(bio->iobuf, 1, B64_BASEMAXINLINE,fi)) <= 0) {
|
|
if (ferror(fi))
|
|
return -1;
|
|
|
|
bio->ateof = 1;
|
|
return 0;
|
|
}
|
|
|
|
bio->iolen= l;
|
|
bio->iocp= 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*! \brief read character from file to buffer (base64 conversion) */
|
|
static int b64_inchar(struct b64_baseio *bio, FILE *fi)
|
|
{
|
|
if (bio->iocp >= bio->iolen) {
|
|
if (!b64_inbuf(bio, fi))
|
|
return EOF;
|
|
}
|
|
|
|
return bio->iobuf[bio->iocp++];
|
|
}
|
|
|
|
/*! \brief write buffer to file (base64 conversion) */
|
|
static int b64_ochar(struct b64_baseio *bio, int c, FILE *so)
|
|
{
|
|
if (bio->linelength >= B64_BASELINELEN) {
|
|
if (fputs(EOL,so) == EOF)
|
|
return -1;
|
|
|
|
bio->linelength= 0;
|
|
}
|
|
|
|
if (putc(((unsigned char) c), so) == EOF)
|
|
return -1;
|
|
|
|
bio->linelength++;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*! \brief Encode file to base64 encoding for email attachment (base64 conversion) */
|
|
static int base_encode(char *filename, FILE *so)
|
|
{
|
|
unsigned char dtable[B64_BASEMAXINLINE];
|
|
int i,hiteof= 0;
|
|
FILE *fi;
|
|
struct b64_baseio bio;
|
|
|
|
memset(&bio, 0, sizeof(bio));
|
|
bio.iocp = B64_BASEMAXINLINE;
|
|
|
|
if (!(fi = fopen(filename, "rb"))) {
|
|
ast_log(LOG_WARNING, "Failed to open file: %s: %s\n", filename, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
for (i= 0; i<9; i++) {
|
|
dtable[i]= 'A'+i;
|
|
dtable[i+9]= 'J'+i;
|
|
dtable[26+i]= 'a'+i;
|
|
dtable[26+i+9]= 'j'+i;
|
|
}
|
|
for (i= 0; i < 8; i++) {
|
|
dtable[i+18]= 'S'+i;
|
|
dtable[26+i+18]= 's'+i;
|
|
}
|
|
for (i= 0; i < 10; i++) {
|
|
dtable[52+i]= '0'+i;
|
|
}
|
|
dtable[62]= '+';
|
|
dtable[63]= '/';
|
|
|
|
while (!hiteof){
|
|
unsigned char igroup[3], ogroup[4];
|
|
int c,n;
|
|
|
|
igroup[0]= igroup[1]= igroup[2]= 0;
|
|
|
|
for (n= 0; n < 3; n++) {
|
|
if ((c = b64_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++)
|
|
b64_ochar(&bio, ogroup[i], so);
|
|
}
|
|
}
|
|
|
|
/* Put end of line - line feed */
|
|
if (fputs(EOL, so) == EOF)
|
|
return 0;
|
|
|
|
fclose(fi);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int get_date(char *s, int len)
|
|
{
|
|
struct ast_tm tm;
|
|
struct timeval tv = ast_tvnow();
|
|
|
|
ast_localtime(&tv, &tm, NULL);
|
|
return ast_strftime(s, len, "%a %b %e %r %Z %Y", &tm);
|
|
}
|
|
|
|
|
|
/*! \brief Free user structure - if it's allocated */
|
|
static void free_user(struct minivm_account *vmu)
|
|
{
|
|
if (vmu->chanvars)
|
|
ast_variables_destroy(vmu->chanvars);
|
|
ast_free(vmu);
|
|
}
|
|
|
|
|
|
|
|
/*! \brief Prepare for voicemail template by adding channel variables
|
|
to the channel
|
|
*/
|
|
static void prep_email_sub_vars(struct ast_channel *channel, const struct minivm_account *vmu, const char *cidnum, const char *cidname, const char *dur, const char *date, const char *counter)
|
|
{
|
|
char callerid[256];
|
|
struct ast_variable *var;
|
|
|
|
if (!channel) {
|
|
ast_log(LOG_ERROR, "No allocated channel, giving up...\n");
|
|
return;
|
|
}
|
|
|
|
for (var = vmu->chanvars ; var ; var = var->next)
|
|
pbx_builtin_setvar_helper(channel, var->name, var->value);
|
|
|
|
/* Prepare variables for substition in email body and subject */
|
|
pbx_builtin_setvar_helper(channel, "MVM_NAME", vmu->fullname);
|
|
pbx_builtin_setvar_helper(channel, "MVM_DUR", dur);
|
|
pbx_builtin_setvar_helper(channel, "MVM_DOMAIN", vmu->domain);
|
|
pbx_builtin_setvar_helper(channel, "MVM_USERNAME", vmu->username);
|
|
pbx_builtin_setvar_helper(channel, "MVM_CALLERID", ast_callerid_merge(callerid, sizeof(callerid), cidname, cidnum, "Unknown Caller"));
|
|
pbx_builtin_setvar_helper(channel, "MVM_CIDNAME", (cidname ? cidname : "an unknown caller"));
|
|
pbx_builtin_setvar_helper(channel, "MVM_CIDNUM", (cidnum ? cidnum : "an unknown caller"));
|
|
pbx_builtin_setvar_helper(channel, "MVM_DATE", date);
|
|
if (!ast_strlen_zero(counter))
|
|
pbx_builtin_setvar_helper(channel, "MVM_COUNTER", counter);
|
|
}
|
|
|
|
/*! \brief Set default values for Mini-Voicemail users */
|
|
static void populate_defaults(struct minivm_account *vmu)
|
|
{
|
|
ast_copy_flags(vmu, (&globalflags), AST_FLAGS_ALL);
|
|
ast_copy_string(vmu->attachfmt, default_vmformat, sizeof(vmu->attachfmt));
|
|
vmu->volgain = global_volgain;
|
|
}
|
|
|
|
/*! \brief Fix quote of mail headers for non-ascii characters */
|
|
static char *mailheader_quote(const char *from, char *to, size_t len)
|
|
{
|
|
char *ptr = to;
|
|
*ptr++ = '"';
|
|
for (; ptr < to + len - 1; from++) {
|
|
if (*from == '"')
|
|
*ptr++ = '\\';
|
|
else if (*from == '\0')
|
|
break;
|
|
*ptr++ = *from;
|
|
}
|
|
if (ptr < to + len - 1)
|
|
*ptr++ = '"';
|
|
*ptr = '\0';
|
|
return to;
|
|
}
|
|
|
|
|
|
/*! \brief Allocate new vm user and set default values */
|
|
static struct minivm_account *mvm_user_alloc(void)
|
|
{
|
|
struct minivm_account *new;
|
|
|
|
new = ast_calloc(1, sizeof(*new));
|
|
if (!new)
|
|
return NULL;
|
|
populate_defaults(new);
|
|
|
|
return new;
|
|
}
|
|
|
|
|
|
/*! \brief Clear list of users */
|
|
static void vmaccounts_destroy_list(void)
|
|
{
|
|
struct minivm_account *this;
|
|
AST_LIST_LOCK(&minivm_accounts);
|
|
while ((this = AST_LIST_REMOVE_HEAD(&minivm_accounts, list)))
|
|
ast_free(this);
|
|
AST_LIST_UNLOCK(&minivm_accounts);
|
|
}
|
|
|
|
|
|
/*! \brief Find user from static memory object list */
|
|
static struct minivm_account *find_account(const char *domain, const char *username, int createtemp)
|
|
{
|
|
struct minivm_account *vmu = NULL, *cur;
|
|
|
|
|
|
if (ast_strlen_zero(domain) || ast_strlen_zero(username)) {
|
|
ast_log(LOG_NOTICE, "No username or domain? \n");
|
|
return NULL;
|
|
}
|
|
ast_debug(3, "-_-_-_- Looking for voicemail user %s in domain %s\n", username, domain);
|
|
|
|
AST_LIST_LOCK(&minivm_accounts);
|
|
AST_LIST_TRAVERSE(&minivm_accounts, cur, list) {
|
|
/* Is this the voicemail account we're looking for? */
|
|
if (!strcasecmp(domain, cur->domain) && !strcasecmp(username, cur->username))
|
|
break;
|
|
}
|
|
AST_LIST_UNLOCK(&minivm_accounts);
|
|
|
|
if (cur) {
|
|
ast_debug(3, "-_-_- Found account for %s@%s\n", username, domain);
|
|
vmu = cur;
|
|
|
|
} else
|
|
vmu = find_user_realtime(domain, username);
|
|
|
|
if (createtemp && !vmu) {
|
|
/* Create a temporary user, send e-mail and be gone */
|
|
vmu = mvm_user_alloc();
|
|
ast_set2_flag(vmu, TRUE, MVM_ALLOCED);
|
|
if (vmu) {
|
|
ast_copy_string(vmu->username, username, sizeof(vmu->username));
|
|
ast_copy_string(vmu->domain, domain, sizeof(vmu->domain));
|
|
ast_debug(1, "--- Created temporary account\n");
|
|
}
|
|
|
|
}
|
|
return vmu;
|
|
}
|
|
|
|
/*! \brief Find user in realtime storage
|
|
Returns pointer to minivm_account structure
|
|
*/
|
|
static struct minivm_account *find_user_realtime(const char *domain, const char *username)
|
|
{
|
|
struct ast_variable *var;
|
|
struct minivm_account *retval;
|
|
char name[MAXHOSTNAMELEN];
|
|
|
|
retval = mvm_user_alloc();
|
|
if (!retval)
|
|
return NULL;
|
|
|
|
if (username)
|
|
ast_copy_string(retval->username, username, sizeof(retval->username));
|
|
|
|
populate_defaults(retval);
|
|
var = ast_load_realtime("minivm", "username", username, "domain", domain, NULL);
|
|
|
|
if (!var) {
|
|
ast_free(retval);
|
|
return NULL;
|
|
}
|
|
|
|
snprintf(name, sizeof(name), "%s@%s", username, domain);
|
|
create_vmaccount(name, var, TRUE);
|
|
|
|
ast_variables_destroy(var);
|
|
return retval;
|
|
}
|
|
|
|
/*! \brief Send voicemail with audio file as an attachment */
|
|
static int sendmail(struct minivm_template *template, struct minivm_account *vmu, char *cidnum, char *cidname, const char *filename, char *format, int duration, int attach_user_voicemail, enum mvm_messagetype type, const char *counter)
|
|
{
|
|
FILE *p = NULL;
|
|
int pfd;
|
|
char email[256] = "";
|
|
char who[256] = "";
|
|
char date[256];
|
|
char bound[256];
|
|
char fname[PATH_MAX];
|
|
char dur[PATH_MAX];
|
|
char tmp[80] = "/tmp/astmail-XXXXXX";
|
|
char tmp2[PATH_MAX];
|
|
struct timeval now;
|
|
struct ast_tm tm;
|
|
struct minivm_zone *the_zone = NULL;
|
|
int len_passdata;
|
|
struct ast_channel *ast;
|
|
char *finalfilename;
|
|
char *passdata = NULL;
|
|
char *passdata2 = NULL;
|
|
char *fromaddress;
|
|
char *fromemail;
|
|
|
|
if (type == MVM_MESSAGE_EMAIL) {
|
|
if (vmu && !ast_strlen_zero(vmu->email)) {
|
|
ast_copy_string(email, vmu->email, sizeof(email));
|
|
} else if (!ast_strlen_zero(vmu->username) && !ast_strlen_zero(vmu->domain))
|
|
snprintf(email, sizeof(email), "%s@%s", vmu->username, vmu->domain);
|
|
} else if (type == MVM_MESSAGE_PAGE) {
|
|
ast_copy_string(email, vmu->pager, sizeof(email));
|
|
}
|
|
|
|
if (ast_strlen_zero(email)) {
|
|
ast_log(LOG_WARNING, "No address to send message to.\n");
|
|
return -1;
|
|
}
|
|
|
|
ast_debug(3, "-_-_- Sending mail to %s@%s - Using template %s\n", vmu->username, vmu->domain, template->name);
|
|
|
|
if (!strcmp(format, "wav49"))
|
|
format = "WAV";
|
|
|
|
|
|
/* If we have a gain option, process it now with sox */
|
|
if (type == MVM_MESSAGE_EMAIL && (vmu->volgain < -.001 || vmu->volgain > .001) ) {
|
|
char newtmp[PATH_MAX];
|
|
char tmpcmd[PATH_MAX];
|
|
int tmpfd;
|
|
|
|
ast_copy_string(newtmp, "/tmp/XXXXXX", sizeof(newtmp));
|
|
ast_debug(3, "newtmp: %s\n", newtmp);
|
|
tmpfd = mkstemp(newtmp);
|
|
snprintf(tmpcmd, sizeof(tmpcmd), "sox -v %.4f %s.%s %s.%s", vmu->volgain, filename, format, newtmp, format);
|
|
ast_safe_system(tmpcmd);
|
|
finalfilename = newtmp;
|
|
ast_debug(3, "-- VOLGAIN: Stored at: %s.%s - Level: %.4f - Mailbox: %s\n", filename, format, vmu->volgain, vmu->username);
|
|
} else {
|
|
finalfilename = ast_strdupa(filename);
|
|
}
|
|
|
|
/* Create file name */
|
|
snprintf(fname, sizeof(fname), "%s.%s", finalfilename, format);
|
|
|
|
if (template->attachment)
|
|
ast_debug(1, "-- Attaching file '%s', format '%s', uservm is '%d'\n", finalfilename, format, attach_user_voicemail);
|
|
|
|
/* Make a temporary file instead of piping directly to sendmail, in case the mail
|
|
command hangs */
|
|
pfd = mkstemp(tmp);
|
|
if (pfd > -1) {
|
|
p = fdopen(pfd, "w");
|
|
if (!p) {
|
|
close(pfd);
|
|
pfd = -1;
|
|
}
|
|
ast_debug(1, "-_-_- Opening temp file for e-mail: %s\n", tmp);
|
|
}
|
|
if (!p) {
|
|
ast_log(LOG_WARNING, "Unable to open temporary file '%s'\n", tmp);
|
|
return -1;
|
|
}
|
|
/* Allocate channel used for chanvar substitution */
|
|
ast = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, 0);
|
|
|
|
|
|
snprintf(dur, sizeof(dur), "%d:%02d", duration / 60, duration % 60);
|
|
|
|
/* Does this user have a timezone specified? */
|
|
if (!ast_strlen_zero(vmu->zonetag)) {
|
|
/* Find the zone in the list */
|
|
struct minivm_zone *z;
|
|
AST_LIST_LOCK(&minivm_zones);
|
|
AST_LIST_TRAVERSE(&minivm_zones, z, list) {
|
|
if (strcmp(z->name, vmu->zonetag))
|
|
continue;
|
|
the_zone = z;
|
|
}
|
|
AST_LIST_UNLOCK(&minivm_zones);
|
|
}
|
|
|
|
now = ast_tvnow();
|
|
ast_localtime(&now, &tm, the_zone ? the_zone->timezone : NULL);
|
|
ast_strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", &tm);
|
|
|
|
/* Start printing the email to the temporary file */
|
|
fprintf(p, "Date: %s\n", date);
|
|
|
|
/* Set date format for voicemail mail */
|
|
ast_strftime(date, sizeof(date), template->dateformat, &tm);
|
|
|
|
|
|
/* Populate channel with channel variables for substitution */
|
|
prep_email_sub_vars(ast, vmu, cidnum, cidname, dur, date, counter);
|
|
|
|
/* Find email address to use */
|
|
/* If there's a server e-mail adress in the account, user that, othterwise template */
|
|
fromemail = ast_strlen_zero(vmu->serveremail) ? template->serveremail : vmu->serveremail;
|
|
|
|
/* Find name to user for server e-mail */
|
|
fromaddress = ast_strlen_zero(template->fromaddress) ? "" : template->fromaddress;
|
|
|
|
/* If needed, add hostname as domain */
|
|
if (ast_strlen_zero(fromemail))
|
|
fromemail = "asterisk";
|
|
|
|
if (strchr(fromemail, '@'))
|
|
ast_copy_string(who, fromemail, sizeof(who));
|
|
else {
|
|
char host[MAXHOSTNAMELEN];
|
|
gethostname(host, sizeof(host)-1);
|
|
snprintf(who, sizeof(who), "%s@%s", fromemail, host);
|
|
}
|
|
|
|
if (ast_strlen_zero(fromaddress)) {
|
|
fprintf(p, "From: Asterisk PBX <%s>\n", who);
|
|
} else {
|
|
/* Allocate a buffer big enough for variable substitution */
|
|
int vmlen = strlen(fromaddress) * 3 + 200;
|
|
|
|
ast_debug(4, "-_-_- Fromaddress template: %s\n", fromaddress);
|
|
if ((passdata = alloca(vmlen))) {
|
|
pbx_substitute_variables_helper(ast, fromaddress, passdata, vmlen);
|
|
len_passdata = strlen(passdata) * 2 + 3;
|
|
passdata2 = alloca(len_passdata);
|
|
fprintf(p, "From: %s <%s>\n", mailheader_quote(passdata, passdata2, len_passdata), who);
|
|
} else {
|
|
ast_log(LOG_WARNING, "Cannot allocate workspace for variable substitution\n");
|
|
fclose(p);
|
|
return -1;
|
|
}
|
|
}
|
|
ast_debug(4, "-_-_- Fromstring now: %s\n", ast_strlen_zero(passdata) ? "-default-" : passdata);
|
|
|
|
fprintf(p, "Message-ID: <Asterisk-%d-%s-%d-%s>\n", (unsigned int)rand(), vmu->username, (int)getpid(), who);
|
|
len_passdata = strlen(vmu->fullname) * 2 + 3;
|
|
passdata2 = alloca(len_passdata);
|
|
if (!ast_strlen_zero(vmu->email))
|
|
fprintf(p, "To: %s <%s>\n", mailheader_quote(vmu->fullname, passdata2, len_passdata), vmu->email);
|
|
else
|
|
fprintf(p, "To: %s <%s@%s>\n", mailheader_quote(vmu->fullname, passdata2, len_passdata), vmu->username, vmu->domain);
|
|
|
|
if (!ast_strlen_zero(template->subject)) {
|
|
char *passdata;
|
|
int vmlen = strlen(template->subject) * 3 + 200;
|
|
if ((passdata = alloca(vmlen))) {
|
|
pbx_substitute_variables_helper(ast, template->subject, passdata, vmlen);
|
|
fprintf(p, "Subject: %s\n", passdata);
|
|
} else {
|
|
ast_log(LOG_WARNING, "Cannot allocate workspace for variable substitution\n");
|
|
fclose(p);
|
|
return -1;
|
|
}
|
|
|
|
ast_debug(4, "-_-_- Subject now: %s\n", passdata);
|
|
|
|
} else {
|
|
fprintf(p, "Subject: New message in mailbox %s@%s\n", vmu->username, vmu->domain);
|
|
ast_debug(1, "-_-_- Using default subject for this email \n");
|
|
}
|
|
|
|
|
|
if (option_debug > 2)
|
|
fprintf(p, "X-Asterisk-debug: template %s user account %s@%s\n", template->name, vmu->username, vmu->domain);
|
|
fprintf(p, "MIME-Version: 1.0\n");
|
|
|
|
/* Something unique. */
|
|
snprintf(bound, sizeof(bound), "voicemail_%s%d%d", vmu->username, (int)getpid(), (unsigned int)rand());
|
|
|
|
fprintf(p, "Content-Type: multipart/mixed; boundary=\"%s\"\n\n\n", bound);
|
|
|
|
fprintf(p, "--%s\n", bound);
|
|
fprintf(p, "Content-Type: text/plain; charset=%s\nContent-Transfer-Encoding: 8bit\n\n", global_charset);
|
|
if (!ast_strlen_zero(template->body)) {
|
|
char *passdata;
|
|
int vmlen = strlen(template->body)*3 + 200;
|
|
if ((passdata = alloca(vmlen))) {
|
|
pbx_substitute_variables_helper(ast, template->body, passdata, vmlen);
|
|
ast_debug(3, "Message now: %s\n-----\n", passdata);
|
|
fprintf(p, "%s\n", passdata);
|
|
} else
|
|
ast_log(LOG_WARNING, "Cannot allocate workspace for variable substitution\n");
|
|
} else {
|
|
fprintf(p, "Dear %s:\n\n\tJust wanted to let you know you were just left a %s long message \n"
|
|
|
|
"in mailbox %s from %s, on %s so you might\n"
|
|
"want to check it when you get a chance. Thanks!\n\n\t\t\t\t--Asterisk\n\n", vmu->fullname,
|
|
dur, vmu->username, (cidname ? cidname : (cidnum ? cidnum : "an unknown caller")), date);
|
|
ast_debug(3, "Using default message body (no template)\n-----\n");
|
|
}
|
|
/* Eww. We want formats to tell us their own MIME type */
|
|
if (template->attachment) {
|
|
char *ctype = "audio/x-";
|
|
ast_debug(3, "-_-_- Attaching file to message: %s\n", fname);
|
|
if (!strcasecmp(format, "ogg"))
|
|
ctype = "application/";
|
|
|
|
fprintf(p, "--%s\n", bound);
|
|
fprintf(p, "Content-Type: %s%s; name=\"voicemailmsg.%s\"\n", ctype, format, format);
|
|
fprintf(p, "Content-Transfer-Encoding: base64\n");
|
|
fprintf(p, "Content-Description: Voicemail sound attachment.\n");
|
|
fprintf(p, "Content-Disposition: attachment; filename=\"voicemail%s.%s\"\n\n", counter ? counter : "", format);
|
|
|
|
base_encode(fname, p);
|
|
fprintf(p, "\n\n--%s--\n.\n", bound);
|
|
}
|
|
fclose(p);
|
|
snprintf(tmp2, sizeof(tmp2), "( %s < %s ; rm -f %s ) &", global_mailcmd, tmp, tmp);
|
|
ast_safe_system(tmp2);
|
|
ast_debug(1, "Sent message to %s with command '%s' - %s\n", vmu->email, global_mailcmd, template->attachment ? "(media attachment)" : "");
|
|
ast_debug(3, "-_-_- Actual command used: %s\n", tmp2);
|
|
if (ast)
|
|
ast_channel_free(ast);
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Create directory based on components */
|
|
static int make_dir(char *dest, int len, const char *domain, const char *username, const char *folder)
|
|
{
|
|
return snprintf(dest, len, "%s%s/%s%s%s", MVM_SPOOL_DIR, domain, username, ast_strlen_zero(folder) ? "" : "/", folder ? folder : "");
|
|
}
|
|
|
|
/*! \brief Checks if directory exists. Does not create directory, but builds string in dest
|
|
* \param dest String. base directory.
|
|
* \param len Int. Length base directory string.
|
|
* \param domain String. Ignored if is null or empty string.
|
|
* \param username String. Ignored if is null or empty string.
|
|
* \param folder String. Ignored if is null or empty string.
|
|
* \return 0 on failure, 1 on success.
|
|
*/
|
|
static int check_dirpath(char *dest, int len, char *domain, char *username, char *folder)
|
|
{
|
|
struct stat filestat;
|
|
make_dir(dest, len, domain, username, folder ? folder : "");
|
|
if (stat(dest, &filestat)== -1)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
/*! \brief basically mkdir -p $dest/$domain/$username/$folder
|
|
* \param dest String. base directory.
|
|
* \param len Length of directory string
|
|
* \param domain String. Ignored if is null or empty string.
|
|
* \param folder String. Ignored if is null or empty string.
|
|
* \param username String. Ignored if is null or empty string.
|
|
* \return -1 on failure, 0 on success.
|
|
*/
|
|
static int create_dirpath(char *dest, int len, char *domain, char *username, char *folder)
|
|
{
|
|
int res;
|
|
make_dir(dest, len, domain, username, folder);
|
|
if ((res = ast_mkdir(dest, 0777))) {
|
|
ast_log(LOG_WARNING, "ast_mkdir '%s' failed: %s\n", dest, strerror(res));
|
|
return -1;
|
|
}
|
|
ast_debug(2, "Creating directory for %s@%s folder %s : %s\n", username, domain, folder, dest);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*! \brief Play intro message before recording voicemail
|
|
*/
|
|
static int invent_message(struct ast_channel *chan, char *domain, char *username, int busy, char *ecodes)
|
|
{
|
|
int res;
|
|
char fn[PATH_MAX];
|
|
|
|
ast_debug(2, "-_-_- Still preparing to play message ...\n");
|
|
|
|
snprintf(fn, sizeof(fn), "%s%s/%s/greet", MVM_SPOOL_DIR, domain, username);
|
|
|
|
if (ast_fileexists(fn, NULL, NULL) > 0) {
|
|
res = ast_streamfile(chan, fn, chan->language);
|
|
if (res)
|
|
return -1;
|
|
res = ast_waitstream(chan, ecodes);
|
|
if (res)
|
|
return res;
|
|
} else {
|
|
int numericusername = 1;
|
|
char *i = username;
|
|
|
|
ast_debug(2, "-_-_- No personal prompts. Using default prompt set for language\n");
|
|
|
|
while (*i) {
|
|
ast_debug(2, "-_-_- Numeric? Checking %c\n", *i);
|
|
if (!isdigit(*i)) {
|
|
numericusername = FALSE;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (numericusername) {
|
|
if(ast_streamfile(chan, "vm-theperson", chan->language))
|
|
return -1;
|
|
if ((res = ast_waitstream(chan, ecodes)))
|
|
return res;
|
|
|
|
res = ast_say_digit_str(chan, username, ecodes, chan->language);
|
|
if (res)
|
|
return res;
|
|
} else {
|
|
if(ast_streamfile(chan, "vm-theextensionis", chan->language))
|
|
return -1;
|
|
if ((res = ast_waitstream(chan, ecodes)))
|
|
return res;
|
|
}
|
|
}
|
|
|
|
res = ast_streamfile(chan, busy ? "vm-isonphone" : "vm-isunavail", chan->language);
|
|
if (res)
|
|
return -1;
|
|
res = ast_waitstream(chan, ecodes);
|
|
return res;
|
|
}
|
|
|
|
/*! \brief Delete media files and attribute file */
|
|
static int vm_delete(char *file)
|
|
{
|
|
int res;
|
|
|
|
ast_debug(1, "-_-_- Deleting voicemail file %s\n", file);
|
|
|
|
res = unlink(file); /* Remove the meta data file */
|
|
res |= ast_filedelete(file, NULL); /* remove the media file */
|
|
return res;
|
|
}
|
|
|
|
|
|
/*! \brief Record voicemail message & let caller review or re-record it, or set options if applicable */
|
|
static int play_record_review(struct ast_channel *chan, char *playfile, char *recordfile, int maxtime, char *fmt,
|
|
int outsidecaller, struct minivm_account *vmu, int *duration, const char *unlockdir,
|
|
signed char record_gain)
|
|
{
|
|
int cmd = 0;
|
|
int max_attempts = 3;
|
|
int attempts = 0;
|
|
int recorded = 0;
|
|
int message_exists = 0;
|
|
signed char zero_gain = 0;
|
|
char *acceptdtmf = "#";
|
|
char *canceldtmf = "";
|
|
|
|
/* Note that urgent and private are for flagging messages as such in the future */
|
|
|
|
/* barf if no pointer passed to store duration in */
|
|
if (duration == NULL) {
|
|
ast_log(LOG_WARNING, "Error play_record_review called without duration pointer\n");
|
|
return -1;
|
|
}
|
|
|
|
cmd = '3'; /* Want to start by recording */
|
|
|
|
while ((cmd >= 0) && (cmd != 't')) {
|
|
switch (cmd) {
|
|
case '2':
|
|
/* Review */
|
|
if (option_verbose > 2)
|
|
ast_verbose(VERBOSE_PREFIX_3 "Reviewing the message\n");
|
|
ast_streamfile(chan, recordfile, chan->language);
|
|
cmd = ast_waitstream(chan, AST_DIGIT_ANY);
|
|
break;
|
|
case '3':
|
|
message_exists = 0;
|
|
/* Record */
|
|
if (option_verbose > 2) {
|
|
if (recorded == 1)
|
|
ast_verbose(VERBOSE_PREFIX_3 "Re-recording the message\n");
|
|
else
|
|
ast_verbose(VERBOSE_PREFIX_3 "Recording the message\n");
|
|
}
|
|
if (recorded && outsidecaller)
|
|
cmd = ast_play_and_wait(chan, "beep");
|
|
recorded = 1;
|
|
/* After an attempt has been made to record message, we have to take care of INTRO and beep for incoming messages, but not for greetings */
|
|
if (record_gain)
|
|
ast_channel_setoption(chan, AST_OPTION_RXGAIN, &record_gain, sizeof(record_gain), 0);
|
|
if (ast_test_flag(vmu, MVM_OPERATOR))
|
|
canceldtmf = "0";
|
|
cmd = ast_play_and_record_full(chan, playfile, recordfile, maxtime, fmt, duration, global_silencethreshold, global_maxsilence, unlockdir, acceptdtmf, canceldtmf);
|
|
if (record_gain)
|
|
ast_channel_setoption(chan, AST_OPTION_RXGAIN, &zero_gain, sizeof(zero_gain), 0);
|
|
if (cmd == -1) /* User has hung up, no options to give */
|
|
return cmd;
|
|
if (cmd == '0')
|
|
break;
|
|
else if (cmd == '*')
|
|
break;
|
|
else {
|
|
/* If all is well, a message exists */
|
|
message_exists = 1;
|
|
cmd = 0;
|
|
}
|
|
break;
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case '*':
|
|
case '#':
|
|
cmd = ast_play_and_wait(chan, "vm-sorry");
|
|
break;
|
|
case '0':
|
|
if(!ast_test_flag(vmu, MVM_OPERATOR)) {
|
|
cmd = ast_play_and_wait(chan, "vm-sorry");
|
|
break;
|
|
}
|
|
if (message_exists || recorded) {
|
|
cmd = ast_play_and_wait(chan, "vm-saveoper");
|
|
if (!cmd)
|
|
cmd = ast_waitfordigit(chan, 3000);
|
|
if (cmd == '1') {
|
|
ast_play_and_wait(chan, "vm-msgsaved");
|
|
cmd = '0';
|
|
} else {
|
|
ast_play_and_wait(chan, "vm-deleted");
|
|
vm_delete(recordfile);
|
|
cmd = '0';
|
|
}
|
|
}
|
|
return cmd;
|
|
default:
|
|
/* If the caller is an ouside caller, and the review option is enabled,
|
|
allow them to review the message, but let the owner of the box review
|
|
their OGM's */
|
|
if (outsidecaller && !ast_test_flag(vmu, MVM_REVIEW))
|
|
return cmd;
|
|
if (message_exists) {
|
|
cmd = ast_play_and_wait(chan, "vm-review");
|
|
} else {
|
|
cmd = ast_play_and_wait(chan, "vm-torerecord");
|
|
if (!cmd)
|
|
cmd = ast_waitfordigit(chan, 600);
|
|
}
|
|
|
|
if (!cmd && outsidecaller && ast_test_flag(vmu, MVM_OPERATOR)) {
|
|
cmd = ast_play_and_wait(chan, "vm-reachoper");
|
|
if (!cmd)
|
|
cmd = ast_waitfordigit(chan, 600);
|
|
}
|
|
if (!cmd)
|
|
cmd = ast_waitfordigit(chan, 6000);
|
|
if (!cmd) {
|
|
attempts++;
|
|
}
|
|
if (attempts > max_attempts) {
|
|
cmd = 't';
|
|
}
|
|
}
|
|
}
|
|
if (outsidecaller)
|
|
ast_play_and_wait(chan, "vm-goodbye");
|
|
if (cmd == 't')
|
|
cmd = 0;
|
|
return cmd;
|
|
}
|
|
|
|
/*! \brief Run external notification for voicemail message */
|
|
static void run_externnotify(struct ast_channel *chan, struct minivm_account *vmu)
|
|
{
|
|
char arguments[BUFSIZ];
|
|
|
|
if (ast_strlen_zero(vmu->externnotify) && ast_strlen_zero(global_externnotify))
|
|
return;
|
|
|
|
snprintf(arguments, sizeof(arguments), "%s %s@%s %s %s&",
|
|
ast_strlen_zero(vmu->externnotify) ? global_externnotify : vmu->externnotify,
|
|
vmu->username, vmu->domain,
|
|
chan->cid.cid_name, chan->cid.cid_num);
|
|
|
|
ast_debug(1, "Executing: %s\n", arguments);
|
|
ast_safe_system(arguments);
|
|
}
|
|
|
|
/*! \brief Send message to voicemail account owner */
|
|
static int notify_new_message(struct ast_channel *chan, const char *templatename, struct minivm_account *vmu, const char *filename, long duration, const char *format, char *cidnum, char *cidname)
|
|
{
|
|
char *stringp;
|
|
struct minivm_template *etemplate;
|
|
char *messageformat;
|
|
int res = 0;
|
|
char oldlocale[100];
|
|
const char *counter;
|
|
|
|
if (!ast_strlen_zero(vmu->attachfmt)) {
|
|
if (strstr(format, vmu->attachfmt)) {
|
|
format = vmu->attachfmt;
|
|
} else
|
|
ast_log(LOG_WARNING, "Attachment format '%s' is not one of the recorded formats '%s'. Falling back to default format for '%s@%s'.\n", vmu->attachfmt, format, vmu->username, vmu->domain);
|
|
}
|
|
|
|
etemplate = message_template_find(vmu->etemplate);
|
|
if (!etemplate)
|
|
etemplate = message_template_find(templatename);
|
|
if (!etemplate)
|
|
etemplate = message_template_find("email-default");
|
|
|
|
/* Attach only the first format */
|
|
stringp = messageformat = ast_strdupa(format);
|
|
strsep(&stringp, "|");
|
|
|
|
if (!ast_strlen_zero(etemplate->locale)) {
|
|
char *newlocale;
|
|
ast_copy_string(oldlocale, setlocale(LC_TIME, NULL), sizeof(oldlocale));
|
|
ast_debug(2, "-_-_- Changing locale from %s to %s\n", oldlocale, etemplate->locale);
|
|
newlocale = setlocale(LC_TIME, etemplate->locale);
|
|
if (newlocale == NULL) {
|
|
ast_log(LOG_WARNING, "-_-_- Changing to new locale did not work. Locale: %s\n", etemplate->locale);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Read counter if available */
|
|
counter = pbx_builtin_getvar_helper(chan, "MVM_COUNTER");
|
|
if (ast_strlen_zero(counter)) {
|
|
ast_debug(2, "-_-_- MVM_COUNTER not found\n");
|
|
} else {
|
|
ast_debug(2, "-_-_- MVM_COUNTER found - will use it with value %s\n", counter);
|
|
}
|
|
|
|
res = sendmail(etemplate, vmu, cidnum, cidname, filename, messageformat, duration, etemplate->attachment, MVM_MESSAGE_EMAIL, counter);
|
|
|
|
if (res == 0 && !ast_strlen_zero(vmu->pager)) {
|
|
/* Find template for paging */
|
|
etemplate = message_template_find(vmu->ptemplate);
|
|
if (!etemplate)
|
|
etemplate = message_template_find("pager-default");
|
|
if (etemplate->locale) {
|
|
ast_copy_string(oldlocale, setlocale(LC_TIME, ""), sizeof(oldlocale));
|
|
setlocale(LC_TIME, etemplate->locale);
|
|
}
|
|
|
|
res = sendmail(etemplate, vmu, cidnum, cidname, filename, messageformat, duration, etemplate->attachment, MVM_MESSAGE_PAGE, counter);
|
|
}
|
|
|
|
manager_event(EVENT_FLAG_CALL, "MiniVoiceMail", "Action: SentNotification\rn\nMailbox: %s@%s\r\nCounter: %s\r\n", vmu->username, vmu->domain, counter);
|
|
|
|
run_externnotify(chan, vmu); /* Run external notification */
|
|
|
|
if (etemplate->locale)
|
|
setlocale(LC_TIME, oldlocale); /* Rest to old locale */
|
|
return res;
|
|
}
|
|
|
|
|
|
/*! \brief Record voicemail message, store into file prepared for sending e-mail */
|
|
static int leave_voicemail(struct ast_channel *chan, char *username, struct leave_vm_options *options)
|
|
{
|
|
char tmptxtfile[PATH_MAX];
|
|
char callerid[256];
|
|
FILE *txt;
|
|
int res = 0, txtdes;
|
|
int msgnum;
|
|
int duration = 0;
|
|
char date[256];
|
|
char tmpdir[PATH_MAX];
|
|
char ext_context[256] = "";
|
|
char fmt[80];
|
|
char *domain;
|
|
char tmp[256] = "";
|
|
struct minivm_account *vmu;
|
|
int userdir;
|
|
|
|
ast_copy_string(tmp, username, sizeof(tmp));
|
|
username = tmp;
|
|
domain = strchr(tmp, '@');
|
|
if (domain) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
|
|
if (!(vmu = find_account(domain, username, TRUE))) {
|
|
/* We could not find user, let's exit */
|
|
ast_log(LOG_ERROR, "Can't allocate temporary account for '%s@%s'\n", username, domain);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
return 0;
|
|
}
|
|
|
|
/* Setup pre-file if appropriate */
|
|
if (strcmp(vmu->domain, "localhost"))
|
|
snprintf(ext_context, sizeof(ext_context), "%s@%s", username, vmu->domain);
|
|
else
|
|
ast_copy_string(ext_context, vmu->domain, sizeof(ext_context));
|
|
|
|
/* The meat of recording the message... All the announcements and beeps have been played*/
|
|
if (ast_strlen_zero(vmu->attachfmt))
|
|
ast_copy_string(fmt, default_vmformat, sizeof(fmt));
|
|
else
|
|
ast_copy_string(fmt, vmu->attachfmt, sizeof(fmt));
|
|
|
|
if (ast_strlen_zero(fmt)) {
|
|
ast_log(LOG_WARNING, "No format for saving voicemail? Default %s\n", default_vmformat);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
return res;
|
|
}
|
|
msgnum = 0;
|
|
|
|
userdir = check_dirpath(tmpdir, sizeof(tmpdir), vmu->domain, username, "tmp");
|
|
|
|
/* If we have no user directory, use generic temporary directory */
|
|
if (!userdir) {
|
|
create_dirpath(tmpdir, sizeof(tmpdir), "0000_minivm_temp", "mediafiles", "");
|
|
ast_debug(3, "Creating temporary directory %s\n", tmpdir);
|
|
}
|
|
|
|
|
|
snprintf(tmptxtfile, sizeof(tmptxtfile), "%s/XXXXXX", tmpdir);
|
|
|
|
|
|
/* XXX This file needs to be in temp directory */
|
|
txtdes = mkstemp(tmptxtfile);
|
|
if (txtdes < 0) {
|
|
ast_log(LOG_ERROR, "Unable to create message file %s: %s\n", tmptxtfile, strerror(errno));
|
|
res = ast_streamfile(chan, "vm-mailboxfull", chan->language);
|
|
if (!res)
|
|
res = ast_waitstream(chan, "");
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
return res;
|
|
}
|
|
|
|
if (res >= 0) {
|
|
/* Unless we're *really* silent, try to send the beep */
|
|
res = ast_streamfile(chan, "beep", chan->language);
|
|
if (!res)
|
|
res = ast_waitstream(chan, "");
|
|
}
|
|
|
|
/* OEJ XXX Maybe this can be turned into a log file? Hmm. */
|
|
/* Store information */
|
|
ast_debug(2, "Open file for metadata: %s\n", tmptxtfile);
|
|
|
|
res = play_record_review(chan, NULL, tmptxtfile, global_vmmaxmessage, fmt, 1, vmu, &duration, NULL, options->record_gain);
|
|
|
|
txt = fdopen(txtdes, "w+");
|
|
if (!txt) {
|
|
ast_log(LOG_WARNING, "Error opening text file for output\n");
|
|
} else {
|
|
struct ast_tm tm;
|
|
struct timeval now = ast_tvnow();
|
|
char timebuf[30];
|
|
char logbuf[BUFSIZ];
|
|
get_date(date, sizeof(date));
|
|
ast_localtime(&now, &tm, NULL);
|
|
ast_strftime(timebuf, sizeof(timebuf), "%H:%M:%S", &tm);
|
|
|
|
snprintf(logbuf, sizeof(logbuf),
|
|
/* "Mailbox:domain:macrocontext:exten:priority:callerchan:callerid:origdate:origtime:duration:durationstatus:accountcode" */
|
|
"%s:%s:%s:%s:%d:%s:%s:%s:%s:%d:%s:%s\n",
|
|
username,
|
|
chan->context,
|
|
chan->macrocontext,
|
|
chan->exten,
|
|
chan->priority,
|
|
chan->name,
|
|
ast_callerid_merge(callerid, sizeof(callerid), chan->cid.cid_name, chan->cid.cid_num, "Unknown"),
|
|
date,
|
|
timebuf,
|
|
duration,
|
|
duration < global_vmminmessage ? "IGNORED" : "OK",
|
|
vmu->accountcode
|
|
);
|
|
fprintf(txt, logbuf);
|
|
if (minivmlogfile) {
|
|
ast_mutex_lock(&minivmloglock);
|
|
fprintf(minivmlogfile, logbuf);
|
|
ast_mutex_unlock(&minivmloglock);
|
|
}
|
|
|
|
if (duration < global_vmminmessage) {
|
|
if (option_verbose > 2)
|
|
ast_verbose( VERBOSE_PREFIX_3 "Recording was %d seconds long but needs to be at least %d - abandoning\n", duration, global_vmminmessage);
|
|
fclose(txt);
|
|
ast_filedelete(tmptxtfile, NULL);
|
|
unlink(tmptxtfile);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
return 0;
|
|
}
|
|
fclose(txt); /* Close log file */
|
|
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);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
return 0;
|
|
}
|
|
|
|
/* Set channel variables for the notify application */
|
|
pbx_builtin_setvar_helper(chan, "MVM_FILENAME", tmptxtfile);
|
|
snprintf(timebuf, sizeof(timebuf), "%d", duration);
|
|
pbx_builtin_setvar_helper(chan, "MVM_DURATION", timebuf);
|
|
pbx_builtin_setvar_helper(chan, "MVM_FORMAT", fmt);
|
|
|
|
}
|
|
global_stats.lastreceived = ast_tvnow();
|
|
global_stats.receivedmessages++;
|
|
// /* Go ahead and delete audio files from system, they're not needed any more */
|
|
// if (ast_fileexists(tmptxtfile, NULL, NULL) <= 0) {
|
|
// ast_filedelete(tmptxtfile, NULL);
|
|
// /* Even not being used at the moment, it's better to convert ast_log to ast_debug anyway */
|
|
// ast_debug(2, "-_-_- Deleted audio file after notification :: %s \n", tmptxtfile);
|
|
// }
|
|
|
|
if (res > 0)
|
|
res = 0;
|
|
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "SUCCESS");
|
|
return res;
|
|
}
|
|
|
|
/*! \brief Notify voicemail account owners - either generic template or user specific */
|
|
static int minivm_notify_exec(struct ast_channel *chan, void *data)
|
|
{
|
|
int argc;
|
|
char *argv[2];
|
|
int res = 0;
|
|
char tmp[PATH_MAX];
|
|
char *domain;
|
|
char *tmpptr;
|
|
struct minivm_account *vmu;
|
|
char *username = argv[0];
|
|
const char *template = "";
|
|
const char *filename;
|
|
const char *format;
|
|
const char *duration_string;
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
ast_log(LOG_ERROR, "Minivm needs at least an account argument \n");
|
|
return -1;
|
|
}
|
|
tmpptr = ast_strdupa((char *)data);
|
|
if (!tmpptr) {
|
|
ast_log(LOG_ERROR, "Out of memory\n");
|
|
return -1;
|
|
}
|
|
argc = ast_app_separate_args(tmpptr, ',', argv, sizeof(argv) / sizeof(argv[0]));
|
|
|
|
if (argc == 2 && !ast_strlen_zero(argv[1]))
|
|
template = argv[1];
|
|
|
|
ast_copy_string(tmp, argv[0], sizeof(tmp));
|
|
username = tmp;
|
|
domain = strchr(tmp, '@');
|
|
if (domain) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
if (ast_strlen_zero(domain) || ast_strlen_zero(username)) {
|
|
ast_log(LOG_ERROR, "Need username@domain as argument. Sorry. Argument 0 %s\n", argv[0]);
|
|
return -1;
|
|
}
|
|
|
|
if(!(vmu = find_account(domain, username, TRUE))) {
|
|
/* We could not find user, let's exit */
|
|
ast_log(LOG_WARNING, "Could not allocate temporary memory for '%s@%s'\n", username, domain);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_NOTIFY_STATUS", "FAILED");
|
|
return -1;
|
|
}
|
|
|
|
filename = pbx_builtin_getvar_helper(chan, "MVM_FILENAME");
|
|
format = pbx_builtin_getvar_helper(chan, "MVM_FORMAT");
|
|
duration_string = pbx_builtin_getvar_helper(chan, "MVM_DURATION");
|
|
/* Notify of new message to e-mail and pager */
|
|
if (!ast_strlen_zero(filename)) {
|
|
res = notify_new_message(chan, template, vmu, filename, atoi(duration_string), format, chan->cid.cid_num, chan->cid.cid_name);
|
|
};
|
|
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_NOTIFY_STATUS", res == 0 ? "SUCCESS" : "FAILED");
|
|
|
|
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
|
|
/* Ok, we're ready to rock and roll. Return to dialplan */
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
/*! \brief Dialplan function to record voicemail */
|
|
static int minivm_record_exec(struct ast_channel *chan, void *data)
|
|
{
|
|
int res = 0;
|
|
char *tmp;
|
|
struct leave_vm_options leave_options;
|
|
int argc;
|
|
char *argv[2];
|
|
struct ast_flags flags = { 0 };
|
|
char *opts[OPT_ARG_ARRAY_SIZE];
|
|
|
|
memset(&leave_options, 0, sizeof(leave_options));
|
|
|
|
/* Answer channel if it's not already answered */
|
|
if (chan->_state != AST_STATE_UP)
|
|
ast_answer(chan);
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
ast_log(LOG_ERROR, "Minivm needs at least an account argument \n");
|
|
return -1;
|
|
}
|
|
tmp = ast_strdupa((char *)data);
|
|
if (!tmp) {
|
|
ast_log(LOG_ERROR, "Out of memory\n");
|
|
return -1;
|
|
}
|
|
argc = ast_app_separate_args(tmp, ',', argv, sizeof(argv) / sizeof(argv[0]));
|
|
if (argc == 2) {
|
|
if (ast_app_parse_options(minivm_app_options, &flags, opts, argv[1])) {
|
|
return -1;
|
|
}
|
|
ast_copy_flags(&leave_options, &flags, OPT_SILENT | OPT_BUSY_GREETING | OPT_UNAVAIL_GREETING );
|
|
if (ast_test_flag(&flags, OPT_RECORDGAIN)) {
|
|
int gain;
|
|
|
|
if (sscanf(opts[OPT_ARG_RECORDGAIN], "%d", &gain) != 1) {
|
|
ast_log(LOG_WARNING, "Invalid value '%s' provided for record gain option\n", opts[OPT_ARG_RECORDGAIN]);
|
|
return -1;
|
|
} else
|
|
leave_options.record_gain = (signed char) gain;
|
|
}
|
|
}
|
|
|
|
/* Now run the appliation and good luck to you! */
|
|
res = leave_voicemail(chan, argv[0], &leave_options);
|
|
|
|
if (res == ERROR_LOCK_PATH) {
|
|
ast_log(LOG_ERROR, "Could not leave voicemail. The path is already locked.\n");
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "FAILED");
|
|
res = 0;
|
|
}
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_RECORD_STATUS", "SUCCESS");
|
|
|
|
return res;
|
|
}
|
|
|
|
/*! \brief Play voicemail prompts - either generic or user specific */
|
|
static int minivm_greet_exec(struct ast_channel *chan, void *data)
|
|
{
|
|
struct leave_vm_options leave_options = { 0, '\0'};
|
|
int argc;
|
|
char *argv[2];
|
|
struct ast_flags flags = { 0 };
|
|
char *opts[OPT_ARG_ARRAY_SIZE];
|
|
int res = 0;
|
|
int ausemacro = 0;
|
|
int ousemacro = 0;
|
|
int ouseexten = 0;
|
|
char tmp[PATH_MAX];
|
|
char dest[PATH_MAX];
|
|
char prefile[PATH_MAX];
|
|
char tempfile[PATH_MAX] = "";
|
|
char ext_context[256] = "";
|
|
char *domain;
|
|
char ecodes[16] = "#";
|
|
char *tmpptr;
|
|
struct minivm_account *vmu;
|
|
char *username = argv[0];
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
ast_log(LOG_ERROR, "Minivm needs at least an account argument \n");
|
|
return -1;
|
|
}
|
|
tmpptr = ast_strdupa((char *)data);
|
|
if (!tmpptr) {
|
|
ast_log(LOG_ERROR, "Out of memory\n");
|
|
return -1;
|
|
}
|
|
argc = ast_app_separate_args(tmpptr, ',', argv, sizeof(argv) / sizeof(argv[0]));
|
|
|
|
if (argc == 2) {
|
|
if (ast_app_parse_options(minivm_app_options, &flags, opts, argv[1]))
|
|
return -1;
|
|
ast_copy_flags(&leave_options, &flags, OPT_SILENT | OPT_BUSY_GREETING | OPT_UNAVAIL_GREETING );
|
|
}
|
|
|
|
ast_copy_string(tmp, argv[0], sizeof(tmp));
|
|
username = tmp;
|
|
domain = strchr(tmp, '@');
|
|
if (domain) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
if (ast_strlen_zero(domain) || ast_strlen_zero(username)) {
|
|
ast_log(LOG_ERROR, "Need username@domain as argument. Sorry. Argument: %s\n", argv[0]);
|
|
return -1;
|
|
}
|
|
ast_debug(1, "-_-_- Trying to find configuration for user %s in domain %s\n", username, domain);
|
|
|
|
if (!(vmu = find_account(domain, username, TRUE))) {
|
|
ast_log(LOG_ERROR, "Could not allocate memory. \n");
|
|
return -1;
|
|
}
|
|
|
|
/* Answer channel if it's not already answered */
|
|
if (chan->_state != AST_STATE_UP)
|
|
ast_answer(chan);
|
|
|
|
/* Setup pre-file if appropriate */
|
|
if (strcmp(vmu->domain, "localhost"))
|
|
snprintf(ext_context, sizeof(ext_context), "%s@%s", username, vmu->domain);
|
|
else
|
|
ast_copy_string(ext_context, vmu->domain, sizeof(ext_context));
|
|
|
|
if (ast_test_flag(&leave_options, OPT_BUSY_GREETING)) {
|
|
res = check_dirpath(dest, sizeof(dest), vmu->domain, username, "busy");
|
|
if (res)
|
|
snprintf(prefile, sizeof(prefile), "%s%s/%s/busy", MVM_SPOOL_DIR, vmu->domain, username);
|
|
} else if (ast_test_flag(&leave_options, OPT_UNAVAIL_GREETING)) {
|
|
res = check_dirpath(dest, sizeof(dest), vmu->domain, username, "unavail");
|
|
if (res)
|
|
snprintf(prefile, sizeof(prefile), "%s%s/%s/unavail", MVM_SPOOL_DIR, vmu->domain, username);
|
|
}
|
|
/* Check for temporary greeting - it overrides busy and unavail */
|
|
snprintf(tempfile, sizeof(tempfile), "%s%s/%s/temp", MVM_SPOOL_DIR, vmu->domain, username);
|
|
if (!(res = check_dirpath(dest, sizeof(dest), vmu->domain, username, "temp"))) {
|
|
ast_debug(2, "Temporary message directory does not exist, using default (%s)\n", tempfile);
|
|
ast_copy_string(prefile, tempfile, sizeof(prefile));
|
|
}
|
|
ast_debug(2, "-_-_- Preparing to play message ...\n");
|
|
|
|
/* Check current or macro-calling context for special extensions */
|
|
if (ast_test_flag(vmu, MVM_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;
|
|
}
|
|
|
|
res = 0; /* Reset */
|
|
/* Play the beginning intro if desired */
|
|
if (!ast_strlen_zero(prefile)) {
|
|
if (ast_streamfile(chan, prefile, chan->language) > -1)
|
|
res = ast_waitstream(chan, ecodes);
|
|
} else {
|
|
ast_debug(2, "%s doesn't exist, doing what we can\n", prefile);
|
|
res = invent_message(chan, vmu->domain, username, ast_test_flag(&leave_options, OPT_BUSY_GREETING), ecodes);
|
|
}
|
|
if (res < 0) {
|
|
ast_debug(2, "Hang up during prefile playback\n");
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_GREET_STATUS", "FAILED");
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
return -1;
|
|
}
|
|
if (res == '#') {
|
|
/* On a '#' we skip the instructions */
|
|
ast_set_flag(&leave_options, OPT_SILENT);
|
|
res = 0;
|
|
}
|
|
if (!res && !ast_test_flag(&leave_options, OPT_SILENT)) {
|
|
res = ast_streamfile(chan, SOUND_INTRO, chan->language);
|
|
if (!res)
|
|
res = ast_waitstream(chan, ecodes);
|
|
if (res == '#') {
|
|
ast_set_flag(&leave_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;
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_GREET_STATUS", "USEREXIT");
|
|
res = 0;
|
|
} else if (res == '0') { /* Check for a '0' here */
|
|
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;
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_GREET_STATUS", "USEREXIT");
|
|
}
|
|
res = 0;
|
|
} else if (res < 0) {
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_GREET_STATUS", "FAILED");
|
|
res = -1;
|
|
} else
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_GREET_STATUS", "SUCCESS");
|
|
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
|
|
|
|
/* Ok, we're ready to rock and roll. Return to dialplan */
|
|
return res;
|
|
|
|
}
|
|
|
|
/*! \brief Dialplan application to delete voicemail */
|
|
static int minivm_delete_exec(struct ast_channel *chan, void *data)
|
|
{
|
|
int res = 0;
|
|
char filename[BUFSIZ];
|
|
|
|
if (!ast_strlen_zero(data))
|
|
ast_copy_string(filename, (char *) data, sizeof(filename));
|
|
else
|
|
ast_copy_string(filename, pbx_builtin_getvar_helper(chan, "MVM_FILENAME"), sizeof(filename));
|
|
|
|
if (ast_strlen_zero(filename)) {
|
|
ast_log(LOG_ERROR, "No filename given in application arguments or channel variable MVM_FILENAME\n");
|
|
return res;
|
|
}
|
|
|
|
/* Go ahead and delete audio files from system, they're not needed any more */
|
|
/* We should look for both audio and text files here */
|
|
if (ast_fileexists(filename, NULL, NULL) > 0) {
|
|
res = vm_delete(filename);
|
|
if (res) {
|
|
ast_debug(2, "-_-_- Can't delete file: %s\n", filename);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_DELETE_STATUS", "FAILED");
|
|
} else {
|
|
ast_debug(2, "-_-_- Deleted voicemail file :: %s \n", filename);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_DELETE_STATUS", "SUCCESS");
|
|
}
|
|
} else {
|
|
ast_debug(2, "-_-_- Filename does not exist: %s\n", filename);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_DELETE_STATUS", "FAILED");
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/*! \brief Record specific messages for voicemail account */
|
|
static int minivm_accmess_exec(struct ast_channel *chan, void *data)
|
|
{
|
|
int argc = 0;
|
|
char *argv[2];
|
|
int res = 0;
|
|
char filename[PATH_MAX];
|
|
char tmp[PATH_MAX];
|
|
char *domain;
|
|
char *tmpptr = NULL;
|
|
struct minivm_account *vmu;
|
|
char *username = argv[0];
|
|
struct ast_flags flags = { 0 };
|
|
char *opts[OPT_ARG_ARRAY_SIZE];
|
|
int error = FALSE;
|
|
char *message = NULL;
|
|
char *prompt = NULL;
|
|
int duration;
|
|
int cmd;
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
ast_log(LOG_ERROR, "MinivmAccmess needs at least two arguments: account and option\n");
|
|
error = TRUE;
|
|
} else
|
|
tmpptr = ast_strdupa((char *)data);
|
|
if (!error) {
|
|
if (!tmpptr) {
|
|
ast_log(LOG_ERROR, "Out of memory\n");
|
|
error = TRUE;
|
|
} else
|
|
argc = ast_app_separate_args(tmpptr, ',', argv, sizeof(argv) / sizeof(argv[0]));
|
|
}
|
|
|
|
if (argc <=1) {
|
|
ast_log(LOG_ERROR, "MinivmAccmess needs at least two arguments: account and option\n");
|
|
error = TRUE;
|
|
}
|
|
if (!error && strlen(argv[1]) > 1) {
|
|
ast_log(LOG_ERROR, "MinivmAccmess can only handle one option at a time. Bad option string: %s\n", argv[1]);
|
|
error = TRUE;
|
|
}
|
|
|
|
if (!error && ast_app_parse_options(minivm_accmess_options, &flags, opts, argv[1])) {
|
|
ast_log(LOG_ERROR, "Can't parse option %s\n", argv[1]);
|
|
error = TRUE;
|
|
}
|
|
|
|
if (error)
|
|
return -1;
|
|
|
|
ast_copy_string(tmp, argv[0], sizeof(tmp));
|
|
username = tmp;
|
|
domain = strchr(tmp, '@');
|
|
if (domain) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
if (ast_strlen_zero(domain) || ast_strlen_zero(username)) {
|
|
ast_log(LOG_ERROR, "Need username@domain as argument. Sorry. Argument 0 %s\n", argv[0]);
|
|
return -1;
|
|
}
|
|
|
|
if(!(vmu = find_account(domain, username, TRUE))) {
|
|
/* We could not find user, let's exit */
|
|
ast_log(LOG_WARNING, "Could not allocate temporary memory for '%s@%s'\n", username, domain);
|
|
pbx_builtin_setvar_helper(chan, "MINIVM_NOTIFY_STATUS", "FAILED");
|
|
return -1;
|
|
}
|
|
|
|
/* Answer channel if it's not already answered */
|
|
if (chan->_state != AST_STATE_UP)
|
|
ast_answer(chan);
|
|
|
|
/* Here's where the action is */
|
|
if (ast_test_flag(&flags, OPT_BUSY_GREETING)) {
|
|
message = "busy";
|
|
prompt = "vm-rec-busy";
|
|
} else if (ast_test_flag(&flags, OPT_UNAVAIL_GREETING)) {
|
|
message = "unavailable";
|
|
prompt = "vm-rec-unavail";
|
|
} else if (ast_test_flag(&flags, OPT_TEMP_GREETING)) {
|
|
message = "temp";
|
|
prompt = "vm-temp-greeting";
|
|
} else if (ast_test_flag(&flags, OPT_NAME_GREETING)) {
|
|
message = "greet";
|
|
prompt = "vm-rec-name";
|
|
}
|
|
snprintf(filename,sizeof(filename), "%s%s/%s/%s", MVM_SPOOL_DIR, vmu->domain, vmu->username, message);
|
|
/* Maybe we should check the result of play_record_review ? */
|
|
cmd = play_record_review(chan, prompt, filename, global_maxgreet, default_vmformat, 0, vmu, &duration, NULL, FALSE);
|
|
|
|
ast_debug(1, "Recorded new %s message in %s (duration %d)\n", message, filename, duration);
|
|
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
|
|
|
|
/* Ok, we're ready to rock and roll. Return to dialplan */
|
|
return res;
|
|
|
|
}
|
|
|
|
/*! \brief Append new mailbox to mailbox list from configuration file */
|
|
static int create_vmaccount(char *name, struct ast_variable *var, int realtime)
|
|
{
|
|
struct minivm_account *vmu;
|
|
char *domain;
|
|
char *username;
|
|
char accbuf[BUFSIZ];
|
|
|
|
ast_debug(3, "Creating %s account for [%s]\n", realtime ? "realtime" : "static", name);
|
|
|
|
ast_copy_string(accbuf, name, sizeof(accbuf));
|
|
username = accbuf;
|
|
domain = strchr(accbuf, '@');
|
|
if (domain) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
if (ast_strlen_zero(domain)) {
|
|
ast_log(LOG_ERROR, "No domain given for mini-voicemail account %s. Not configured.\n", name);
|
|
return 0;
|
|
}
|
|
|
|
ast_debug(3, "Creating static account for user %s domain %s\n", username, domain);
|
|
|
|
/* Allocate user account */
|
|
vmu = ast_calloc(1, sizeof(*vmu));
|
|
if (!vmu)
|
|
return 0;
|
|
|
|
ast_copy_string(vmu->domain, domain, sizeof(vmu->domain));
|
|
ast_copy_string(vmu->username, username, sizeof(vmu->username));
|
|
|
|
populate_defaults(vmu);
|
|
|
|
ast_debug(3, "...Configuring account %s\n", name);
|
|
|
|
while (var) {
|
|
ast_debug(3, "---- Configuring %s = \"%s\" for account %s\n", var->name, var->value, name);
|
|
if (!strcasecmp(var->name, "serveremail")) {
|
|
ast_copy_string(vmu->serveremail, var->value, sizeof(vmu->serveremail));
|
|
} else if (!strcasecmp(var->name, "email")) {
|
|
ast_copy_string(vmu->email, var->value, sizeof(vmu->email));
|
|
} else if (!strcasecmp(var->name, "accountcode")) {
|
|
ast_copy_string(vmu->accountcode, var->value, sizeof(vmu->accountcode));
|
|
} else if (!strcasecmp(var->name, "pincode")) {
|
|
ast_copy_string(vmu->pincode, var->value, sizeof(vmu->pincode));
|
|
} else if (!strcasecmp(var->name, "domain")) {
|
|
ast_copy_string(vmu->domain, var->value, sizeof(vmu->domain));
|
|
} else if (!strcasecmp(var->name, "language")) {
|
|
ast_copy_string(vmu->language, var->value, sizeof(vmu->language));
|
|
} else if (!strcasecmp(var->name, "timezone")) {
|
|
ast_copy_string(vmu->zonetag, var->value, sizeof(vmu->zonetag));
|
|
} else if (!strcasecmp(var->name, "externnotify")) {
|
|
ast_copy_string(vmu->externnotify, var->value, sizeof(vmu->externnotify));
|
|
} else if (!strcasecmp(var->name, "etemplate")) {
|
|
ast_copy_string(vmu->etemplate, var->value, sizeof(vmu->etemplate));
|
|
} else if (!strcasecmp(var->name, "ptemplate")) {
|
|
ast_copy_string(vmu->ptemplate, var->value, sizeof(vmu->ptemplate));
|
|
} else if (!strcasecmp(var->name, "fullname")) {
|
|
ast_copy_string(vmu->fullname, var->value, sizeof(vmu->fullname));
|
|
} else if (!strcasecmp(var->name, "setvar")) {
|
|
char *varval;
|
|
char *varname = ast_strdupa(var->value);
|
|
struct ast_variable *tmpvar;
|
|
|
|
if (varname && (varval = strchr(varname, '='))) {
|
|
*varval = '\0';
|
|
varval++;
|
|
if ((tmpvar = ast_variable_new(varname, varval, ""))) {
|
|
tmpvar->next = vmu->chanvars;
|
|
vmu->chanvars = tmpvar;
|
|
}
|
|
}
|
|
} else if (!strcasecmp(var->name, "pager")) {
|
|
ast_copy_string(vmu->pager, var->value, sizeof(vmu->pager));
|
|
} else if (!strcasecmp(var->name, "volgain")) {
|
|
sscanf(var->value, "%lf", &vmu->volgain);
|
|
} else {
|
|
ast_log(LOG_ERROR, "Unknown configuration option for minivm account %s : %s\n", name, var->name);
|
|
}
|
|
var = var->next;
|
|
}
|
|
ast_debug(3, "...Linking account %s\n", name);
|
|
|
|
AST_LIST_LOCK(&minivm_accounts);
|
|
AST_LIST_INSERT_TAIL(&minivm_accounts, vmu, list);
|
|
AST_LIST_UNLOCK(&minivm_accounts);
|
|
|
|
global_stats.voicemailaccounts++;
|
|
|
|
ast_debug(2, "MINIVM :: Created account %s@%s - tz %s etemplate %s %s\n", username, domain, ast_strlen_zero(vmu->zonetag) ? "" : vmu->zonetag, ast_strlen_zero(vmu->etemplate) ? "" : vmu->etemplate, realtime ? "(realtime)" : "");
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Free Mini Voicemail timezone */
|
|
static void free_zone(struct minivm_zone *z)
|
|
{
|
|
ast_free(z);
|
|
}
|
|
|
|
/*! \brief Clear list of timezones */
|
|
static void timezone_destroy_list(void)
|
|
{
|
|
struct minivm_zone *this;
|
|
|
|
AST_LIST_LOCK(&minivm_zones);
|
|
while ((this = AST_LIST_REMOVE_HEAD(&minivm_zones, list)))
|
|
free_zone(this);
|
|
|
|
AST_LIST_UNLOCK(&minivm_zones);
|
|
}
|
|
|
|
/*! \brief Add time zone to memory list */
|
|
static int timezone_add(const char *zonename, const char *config)
|
|
{
|
|
|
|
struct minivm_zone *newzone;
|
|
char *msg_format, *timezone;
|
|
|
|
newzone = ast_calloc(1, sizeof(*newzone));
|
|
if (newzone == NULL)
|
|
return 0;
|
|
|
|
msg_format = ast_strdupa(config);
|
|
if (msg_format == NULL) {
|
|
ast_log(LOG_WARNING, "Out of memory.\n");
|
|
ast_free(newzone);
|
|
return 0;
|
|
}
|
|
|
|
timezone = strsep(&msg_format, "|");
|
|
if (!msg_format) {
|
|
ast_log(LOG_WARNING, "Invalid timezone definition : %s\n", zonename);
|
|
ast_free(newzone);
|
|
return 0;
|
|
}
|
|
|
|
ast_copy_string(newzone->name, zonename, sizeof(newzone->name));
|
|
ast_copy_string(newzone->timezone, timezone, sizeof(newzone->timezone));
|
|
ast_copy_string(newzone->msg_format, msg_format, sizeof(newzone->msg_format));
|
|
|
|
AST_LIST_LOCK(&minivm_zones);
|
|
AST_LIST_INSERT_TAIL(&minivm_zones, newzone, list);
|
|
AST_LIST_UNLOCK(&minivm_zones);
|
|
|
|
global_stats.timezones++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Read message template from file */
|
|
static char *message_template_parse_filebody(const char *filename) {
|
|
char buf[BUFSIZ * 6];
|
|
char readbuf[BUFSIZ];
|
|
char filenamebuf[BUFSIZ];
|
|
char *writepos;
|
|
char *messagebody;
|
|
FILE *fi;
|
|
int lines = 0;
|
|
|
|
if (ast_strlen_zero(filename))
|
|
return NULL;
|
|
if (*filename == '/')
|
|
ast_copy_string(filenamebuf, filename, sizeof(filenamebuf));
|
|
else
|
|
snprintf(filenamebuf, sizeof(filenamebuf), "%s/%s", ast_config_AST_CONFIG_DIR, filename);
|
|
|
|
if (!(fi = fopen(filenamebuf, "r"))) {
|
|
ast_log(LOG_ERROR, "Can't read message template from file: %s\n", filenamebuf);
|
|
return NULL;
|
|
}
|
|
writepos = buf;
|
|
while (fgets(readbuf, sizeof(readbuf), fi)) {
|
|
lines ++;
|
|
if (writepos != buf) {
|
|
*writepos = '\n'; /* Replace EOL with new line */
|
|
writepos++;
|
|
}
|
|
ast_copy_string(writepos, readbuf, sizeof(buf) - (writepos - buf));
|
|
writepos += strlen(readbuf) - 1;
|
|
}
|
|
fclose(fi);
|
|
messagebody = ast_calloc(1, strlen(buf + 1));
|
|
ast_copy_string(messagebody, buf, strlen(buf) + 1);
|
|
ast_debug(4, "---> Size of allocation %d\n", (int) strlen(buf + 1) );
|
|
ast_debug(4, "---> Done reading message template : \n%s\n---- END message template--- \n", messagebody);
|
|
|
|
return messagebody;
|
|
}
|
|
|
|
/*! \brief Parse emailbody template from configuration file */
|
|
static char *message_template_parse_emailbody(const char *configuration)
|
|
{
|
|
char *tmpread, *tmpwrite;
|
|
char *emailbody = ast_strdup(configuration);
|
|
|
|
/* substitute strings \t and \n into the apropriate characters */
|
|
tmpread = tmpwrite = emailbody;
|
|
while ((tmpwrite = strchr(tmpread,'\\'))) {
|
|
int len = strlen("\n");
|
|
switch (tmpwrite[1]) {
|
|
case 'n':
|
|
memmove(tmpwrite + len, tmpwrite + 2, strlen(tmpwrite + 2) + 1);
|
|
strncpy(tmpwrite, "\n", len);
|
|
break;
|
|
case 't':
|
|
memmove(tmpwrite + len, tmpwrite + 2, strlen(tmpwrite + 2) + 1);
|
|
strncpy(tmpwrite, "\t", len);
|
|
break;
|
|
default:
|
|
ast_log(LOG_NOTICE, "Substitution routine does not support this character: %c\n", tmpwrite[1]);
|
|
}
|
|
tmpread = tmpwrite + len;
|
|
}
|
|
return emailbody;
|
|
}
|
|
|
|
/*! \brief Apply general configuration options */
|
|
static int apply_general_options(struct ast_variable *var)
|
|
{
|
|
int error = 0;
|
|
|
|
while (var) {
|
|
/* Mail command */
|
|
if (!strcmp(var->name, "mailcmd")) {
|
|
ast_copy_string(global_mailcmd, var->value, sizeof(global_mailcmd)); /* User setting */
|
|
} else if (!strcmp(var->name, "maxgreet")) {
|
|
global_maxgreet = atoi(var->value);
|
|
} else if (!strcmp(var->name, "maxsilence")) {
|
|
global_maxsilence = atoi(var->value);
|
|
if (global_maxsilence > 0)
|
|
global_maxsilence *= 1000;
|
|
} else if (!strcmp(var->name, "logfile")) {
|
|
if (!ast_strlen_zero(var->value) ) {
|
|
if(*(var->value) == '/')
|
|
ast_copy_string(global_logfile, var->value, sizeof(global_logfile));
|
|
else
|
|
snprintf(global_logfile, sizeof(global_logfile), "%s/%s", ast_config_AST_LOG_DIR, var->value);
|
|
}
|
|
} else if (!strcmp(var->name, "externnotify")) {
|
|
/* External voicemail notify application */
|
|
ast_copy_string(global_externnotify, var->value, sizeof(global_externnotify));
|
|
} else if (!strcmp(var->name, "silencetreshold")) {
|
|
/* Silence treshold */
|
|
global_silencethreshold = atoi(var->value);
|
|
} else if (!strcmp(var->name, "maxmessage")) {
|
|
int x;
|
|
if (sscanf(var->value, "%d", &x) == 1) {
|
|
global_vmmaxmessage = x;
|
|
} else {
|
|
error ++;
|
|
ast_log(LOG_WARNING, "Invalid max message time length\n");
|
|
}
|
|
} else if (!strcmp(var->name, "minmessage")) {
|
|
int x;
|
|
if (sscanf(var->value, "%d", &x) == 1) {
|
|
global_vmminmessage = x;
|
|
if (global_maxsilence <= global_vmminmessage)
|
|
ast_log(LOG_WARNING, "maxsilence should be less than minmessage or you may get empty messages\n");
|
|
} else {
|
|
error ++;
|
|
ast_log(LOG_WARNING, "Invalid min message time length\n");
|
|
}
|
|
} else if (!strcmp(var->name, "format")) {
|
|
ast_copy_string(default_vmformat, var->value, sizeof(default_vmformat));
|
|
} else if (!strcmp(var->name, "review")) {
|
|
ast_set2_flag((&globalflags), ast_true(var->value), MVM_REVIEW);
|
|
} else if (!strcmp(var->name, "operator")) {
|
|
ast_set2_flag((&globalflags), ast_true(var->value), MVM_OPERATOR);
|
|
}
|
|
var = var->next;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
/*! \brief Load minivoicemail configuration */
|
|
static int load_config(int reload)
|
|
{
|
|
struct ast_config *cfg;
|
|
struct ast_variable *var;
|
|
char *cat;
|
|
const char *chanvar;
|
|
int error = 0;
|
|
struct minivm_template *template;
|
|
struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
|
|
|
|
cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags);
|
|
if (cfg == CONFIG_STATUS_FILEUNCHANGED)
|
|
return 0;
|
|
|
|
ast_mutex_lock(&minivmlock);
|
|
|
|
/* Destroy lists to reconfigure */
|
|
message_destroy_list(); /* Destroy list of voicemail message templates */
|
|
timezone_destroy_list(); /* Destroy list of timezones */
|
|
vmaccounts_destroy_list(); /* Destroy list of voicemail accounts */
|
|
ast_debug(2, "Destroyed memory objects...\n");
|
|
|
|
/* First, set some default settings */
|
|
global_externnotify[0] = '\0';
|
|
global_logfile[0] = '\0';
|
|
global_silencethreshold = 256;
|
|
global_vmmaxmessage = 2000;
|
|
global_maxgreet = 2000;
|
|
global_vmminmessage = 0;
|
|
strcpy(global_mailcmd, SENDMAIL);
|
|
global_maxsilence = 0;
|
|
global_saydurationminfo = 2;
|
|
ast_copy_string(default_vmformat, "wav", sizeof(default_vmformat));
|
|
ast_set2_flag((&globalflags), FALSE, MVM_REVIEW);
|
|
ast_set2_flag((&globalflags), FALSE, MVM_OPERATOR);
|
|
strcpy(global_charset, "ISO-8859-1");
|
|
/* Reset statistics */
|
|
memset(&global_stats, 0, sizeof(global_stats));
|
|
global_stats.reset = ast_tvnow();
|
|
|
|
/* Make sure we could load configuration file */
|
|
if (!cfg) {
|
|
ast_log(LOG_WARNING, "Failed to load configuration file. Module activated with default settings.\n");
|
|
ast_mutex_unlock(&minivmlock);
|
|
return 0;
|
|
}
|
|
|
|
ast_debug(2, "-_-_- Loaded configuration file, now parsing\n");
|
|
|
|
/* General settings */
|
|
|
|
cat = ast_category_browse(cfg, NULL);
|
|
while (cat) {
|
|
ast_debug(3, "-_-_- Found configuration section [%s]\n", cat);
|
|
if (!strcasecmp(cat, "general")) {
|
|
/* Nothing right now */
|
|
error += apply_general_options(ast_variable_browse(cfg, cat));
|
|
} else if (!strncasecmp(cat, "template-", 9)) {
|
|
/* Template */
|
|
char *name = cat + 9;
|
|
|
|
/* Now build and link template to list */
|
|
error += message_template_build(name, ast_variable_browse(cfg, cat));
|
|
} else {
|
|
var = ast_variable_browse(cfg, cat);
|
|
if (!strcasecmp(cat, "zonemessages")) {
|
|
/* Timezones in this context */
|
|
while (var) {
|
|
timezone_add(var->name, var->value);
|
|
var = var->next;
|
|
}
|
|
} else {
|
|
/* Create mailbox from this */
|
|
error += create_vmaccount(cat, var, FALSE);
|
|
}
|
|
}
|
|
/* Find next section in configuration file */
|
|
cat = ast_category_browse(cfg, cat);
|
|
}
|
|
|
|
/* Configure the default email template */
|
|
message_template_build("email-default", NULL);
|
|
template = message_template_find("email-default");
|
|
|
|
/* Load date format config for voicemail mail */
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emaildateformat")))
|
|
ast_copy_string(template->dateformat, chanvar, sizeof(template->dateformat));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emailfromstring")))
|
|
ast_copy_string(template->fromaddress, chanvar, sizeof(template->fromaddress));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emailaaddress")))
|
|
ast_copy_string(template->serveremail, chanvar, sizeof(template->serveremail));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emailcharset")))
|
|
ast_copy_string(template->charset, chanvar, sizeof(template->charset));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emailsubject")))
|
|
ast_copy_string(template->subject, chanvar, sizeof(template->subject));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "emailbody")))
|
|
template->body = message_template_parse_emailbody(chanvar);
|
|
template->attachment = TRUE;
|
|
|
|
message_template_build("pager-default", NULL);
|
|
template = message_template_find("pager-default");
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "pagerfromstring")))
|
|
ast_copy_string(template->fromaddress, chanvar, sizeof(template->fromaddress));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "pageraddress")))
|
|
ast_copy_string(template->serveremail, chanvar, sizeof(template->serveremail));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "pagercharset")))
|
|
ast_copy_string(template->charset, chanvar, sizeof(template->charset));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "pagersubject")))
|
|
ast_copy_string(template->subject, chanvar,sizeof(template->subject));
|
|
if ((chanvar = ast_variable_retrieve(cfg, "general", "pagerbody")))
|
|
template->body = message_template_parse_emailbody(chanvar);
|
|
template->attachment = FALSE;
|
|
|
|
if (error)
|
|
ast_log(LOG_ERROR, "--- A total of %d errors found in mini-voicemail configuration\n", error);
|
|
|
|
ast_mutex_unlock(&minivmlock);
|
|
ast_config_destroy(cfg);
|
|
|
|
/* Close log file if it's open and disabled */
|
|
if(minivmlogfile)
|
|
fclose(minivmlogfile);
|
|
|
|
/* Open log file if it's enabled */
|
|
if(!ast_strlen_zero(global_logfile)) {
|
|
minivmlogfile = fopen(global_logfile, "a");
|
|
if(!minivmlogfile)
|
|
ast_log(LOG_ERROR, "Failed to open minivm log file %s : %s\n", global_logfile, strerror(errno));
|
|
if (minivmlogfile)
|
|
ast_debug(3, "-_-_- Opened log file %s \n", global_logfile);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief CLI routine for listing templates */
|
|
static char *handle_minivm_list_templates(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
struct minivm_template *this;
|
|
char *output_format = "%-15s %-10s %-10s %-15.15s %-50s\n";
|
|
int count = 0;
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "minivm list templates";
|
|
e->usage =
|
|
"Usage: minivm list templates\n"
|
|
" Lists message templates for e-mail, paging and IM\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
if (a->argc > 3)
|
|
return CLI_SHOWUSAGE;
|
|
|
|
AST_LIST_LOCK(&message_templates);
|
|
if (AST_LIST_EMPTY(&message_templates)) {
|
|
ast_cli(a->fd, "There are no message templates defined\n");
|
|
AST_LIST_UNLOCK(&message_templates);
|
|
return CLI_FAILURE;
|
|
}
|
|
ast_cli(a->fd, output_format, "Template name", "Charset", "Locale", "Attach media", "Subject");
|
|
ast_cli(a->fd, output_format, "-------------", "-------", "------", "------------", "-------");
|
|
AST_LIST_TRAVERSE(&message_templates, this, list) {
|
|
ast_cli(a->fd, output_format, this->name,
|
|
this->charset ? this->charset : "-",
|
|
this->locale ? this->locale : "-",
|
|
this->attachment ? "Yes" : "No",
|
|
this->subject ? this->subject : "-");
|
|
count++;
|
|
}
|
|
AST_LIST_UNLOCK(&message_templates);
|
|
ast_cli(a->fd, "\n * Total: %d minivoicemail message templates\n", count);
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
static char *complete_minivm_show_users(const char *line, const char *word, int pos, int state)
|
|
{
|
|
int which = 0;
|
|
int wordlen;
|
|
struct minivm_account *vmu;
|
|
const char *domain = "";
|
|
|
|
/* 0 - voicemail; 1 - list; 2 - accounts; 3 - for; 4 - <domain> */
|
|
if (pos > 4)
|
|
return NULL;
|
|
if (pos == 3)
|
|
return (state == 0) ? ast_strdup("for") : NULL;
|
|
wordlen = strlen(word);
|
|
AST_LIST_TRAVERSE(&minivm_accounts, vmu, list) {
|
|
if (!strncasecmp(word, vmu->domain, wordlen)) {
|
|
if (domain && strcmp(domain, vmu->domain) && ++which > state)
|
|
return ast_strdup(vmu->domain);
|
|
/* ignore repeated domains ? */
|
|
domain = vmu->domain;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*! \brief CLI command to list voicemail accounts */
|
|
static char *handle_minivm_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
struct minivm_account *vmu;
|
|
char *output_format = "%-23s %-15s %-15s %-10s %-10s %-50s\n";
|
|
int count = 0;
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "minivm list accounts";
|
|
e->usage =
|
|
"Usage: minivm list accounts\n"
|
|
" Lists all mailboxes currently set up\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return complete_minivm_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) && strcmp(a->argv[3],"for"))
|
|
return CLI_SHOWUSAGE;
|
|
|
|
AST_LIST_LOCK(&minivm_accounts);
|
|
if (AST_LIST_EMPTY(&minivm_accounts)) {
|
|
ast_cli(a->fd, "There are no voicemail users currently defined\n");
|
|
AST_LIST_UNLOCK(&minivm_accounts);
|
|
return CLI_FAILURE;
|
|
}
|
|
ast_cli(a->fd, output_format, "User", "E-Template", "P-template", "Zone", "Format", "Full name");
|
|
ast_cli(a->fd, output_format, "----", "----------", "----------", "----", "------", "---------");
|
|
AST_LIST_TRAVERSE(&minivm_accounts, vmu, list) {
|
|
char tmp[256] = "";
|
|
if ((a->argc == 3) || ((a->argc == 5) && !strcmp(a->argv[4], vmu->domain))) {
|
|
count++;
|
|
snprintf(tmp, sizeof(tmp), "%s@%s", vmu->username, vmu->domain);
|
|
ast_cli(a->fd, output_format, tmp, vmu->etemplate ? vmu->etemplate : "-",
|
|
vmu->ptemplate ? vmu->ptemplate : "-",
|
|
vmu->zonetag ? vmu->zonetag : "-",
|
|
vmu->attachfmt ? vmu->attachfmt : "-",
|
|
vmu->fullname);
|
|
}
|
|
}
|
|
AST_LIST_UNLOCK(&minivm_accounts);
|
|
ast_cli(a->fd, "\n * Total: %d minivoicemail accounts\n", count);
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
/*! \brief Show a list of voicemail zones in the CLI */
|
|
static char *handle_minivm_show_zones(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
struct minivm_zone *zone;
|
|
char *output_format = "%-15s %-20s %-45s\n";
|
|
char *res = CLI_SUCCESS;
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "minivm list zones";
|
|
e->usage =
|
|
"Usage: minivm list zones\n"
|
|
" Lists zone message formats\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
if (a->argc != 3)
|
|
return CLI_SHOWUSAGE;
|
|
|
|
AST_LIST_LOCK(&minivm_zones);
|
|
if (!AST_LIST_EMPTY(&minivm_zones)) {
|
|
ast_cli(a->fd, output_format, "Zone", "Timezone", "Message Format");
|
|
ast_cli(a->fd, output_format, "----", "--------", "--------------");
|
|
AST_LIST_TRAVERSE(&minivm_zones, zone, list) {
|
|
ast_cli(a->fd, 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(&minivm_zones);
|
|
|
|
return res;
|
|
}
|
|
|
|
/*! \brief CLI Show settings */
|
|
static char *handle_minivm_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "minivm show settings";
|
|
e->usage =
|
|
"Usage: minivm show settings\n"
|
|
" Display Mini-Voicemail general settings\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
ast_cli(a->fd, "* Mini-Voicemail general settings\n");
|
|
ast_cli(a->fd, " -------------------------------\n");
|
|
ast_cli(a->fd, "\n");
|
|
ast_cli(a->fd, " Mail command (shell): %s\n", global_mailcmd);
|
|
ast_cli(a->fd, " Max silence: %d\n", global_maxsilence);
|
|
ast_cli(a->fd, " Silence treshold: %d\n", global_silencethreshold);
|
|
ast_cli(a->fd, " Max message length (secs): %d\n", global_vmmaxmessage);
|
|
ast_cli(a->fd, " Min message length (secs): %d\n", global_vmminmessage);
|
|
ast_cli(a->fd, " Default format: %s\n", default_vmformat);
|
|
ast_cli(a->fd, " Extern notify (shell): %s\n", global_externnotify);
|
|
ast_cli(a->fd, " Logfile: %s\n", global_logfile[0] ? global_logfile : "<disabled>");
|
|
ast_cli(a->fd, " Operator exit: %s\n", ast_test_flag(&globalflags, MVM_OPERATOR) ? "Yes" : "No");
|
|
ast_cli(a->fd, " Message review: %s\n", ast_test_flag(&globalflags, MVM_REVIEW) ? "Yes" : "No");
|
|
|
|
ast_cli(a->fd, "\n");
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
/*! \brief Show stats */
|
|
static char *handle_minivm_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
struct ast_tm time;
|
|
char buf[BUFSIZ];
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
e->command = "minivm show stats";
|
|
e->usage =
|
|
"Usage: minivm show stats\n"
|
|
" Display Mini-Voicemail counters\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
ast_cli(a->fd, "* Mini-Voicemail statistics\n");
|
|
ast_cli(a->fd, " -------------------------\n");
|
|
ast_cli(a->fd, "\n");
|
|
ast_cli(a->fd, " Voicemail accounts: %5d\n", global_stats.voicemailaccounts);
|
|
ast_cli(a->fd, " Templates: %5d\n", global_stats.templates);
|
|
ast_cli(a->fd, " Timezones: %5d\n", global_stats.timezones);
|
|
if (global_stats.receivedmessages == 0) {
|
|
ast_cli(a->fd, " Received messages since last reset: <none>\n");
|
|
} else {
|
|
ast_cli(a->fd, " Received messages since last reset: %d\n", global_stats.receivedmessages);
|
|
ast_localtime(&global_stats.lastreceived, &time, NULL);
|
|
ast_strftime(buf, sizeof(buf), "%a %b %e %r %Z %Y", &time);
|
|
ast_cli(a->fd, " Last received voicemail: %s\n", buf);
|
|
}
|
|
ast_localtime(&global_stats.reset, &time, NULL);
|
|
ast_strftime(buf, sizeof(buf), "%a %b %e %r %Z %Y", &time);
|
|
ast_cli(a->fd, " Last reset: %s\n", buf);
|
|
|
|
ast_cli(a->fd, "\n");
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
/*! \brief ${MINIVMACCOUNT()} Dialplan function - reads account data */
|
|
static int minivm_account_func_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
|
|
{
|
|
struct minivm_account *vmu;
|
|
char *username, *domain, *colname;
|
|
|
|
if (!(username = ast_strdupa(data))) {
|
|
ast_log(LOG_ERROR, "Memory Error!\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((colname = strchr(username, ':'))) {
|
|
*colname = '\0';
|
|
colname++;
|
|
} else {
|
|
colname = "path";
|
|
}
|
|
if ((domain = strchr(username, '@'))) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
if (ast_strlen_zero(username) || ast_strlen_zero(domain)) {
|
|
ast_log(LOG_ERROR, "This function needs a username and a domain: username@domain\n");
|
|
return 0;
|
|
}
|
|
|
|
if (!(vmu = find_account(domain, username, TRUE)))
|
|
return 0;
|
|
|
|
if (!strcasecmp(colname, "hasaccount")) {
|
|
ast_copy_string(buf, (ast_test_flag(vmu, MVM_ALLOCED) ? "0" : "1"), len);
|
|
} else if (!strcasecmp(colname, "fullname")) {
|
|
ast_copy_string(buf, vmu->fullname, len);
|
|
} else if (!strcasecmp(colname, "email")) {
|
|
if (!ast_strlen_zero(vmu->email))
|
|
ast_copy_string(buf, vmu->email, len);
|
|
else
|
|
snprintf(buf, len, "%s@%s", vmu->username, vmu->domain);
|
|
} else if (!strcasecmp(colname, "pager")) {
|
|
ast_copy_string(buf, vmu->pager, len);
|
|
} else if (!strcasecmp(colname, "etemplate")) {
|
|
if (!ast_strlen_zero(vmu->etemplate))
|
|
ast_copy_string(buf, vmu->etemplate, len);
|
|
else
|
|
ast_copy_string(buf, "email-default", len);
|
|
} else if (!strcasecmp(colname, "language")) {
|
|
ast_copy_string(buf, vmu->language, len);
|
|
} else if (!strcasecmp(colname, "timezone")) {
|
|
ast_copy_string(buf, vmu->zonetag, len);
|
|
} else if (!strcasecmp(colname, "ptemplate")) {
|
|
if (!ast_strlen_zero(vmu->ptemplate))
|
|
ast_copy_string(buf, vmu->ptemplate, len);
|
|
else
|
|
ast_copy_string(buf, "email-default", len);
|
|
} else if (!strcasecmp(colname, "accountcode")) {
|
|
ast_copy_string(buf, vmu->accountcode, len);
|
|
} else if (!strcasecmp(colname, "pincode")) {
|
|
ast_copy_string(buf, vmu->pincode, len);
|
|
} else if (!strcasecmp(colname, "path")) {
|
|
check_dirpath(buf, len, vmu->domain, vmu->username, NULL);
|
|
} else { /* Look in channel variables */
|
|
struct ast_variable *var;
|
|
int found = 0;
|
|
|
|
for (var = vmu->chanvars ; var ; var = var->next)
|
|
if (!strcmp(var->name, colname)) {
|
|
ast_copy_string(buf, var->value, len);
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(ast_test_flag(vmu, MVM_ALLOCED))
|
|
free_user(vmu);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief lock directory
|
|
|
|
only return failure if ast_lock_path returns 'timeout',
|
|
not if the path does not exist or any other reason
|
|
*/
|
|
static int vm_lock_path(const char *path)
|
|
{
|
|
switch (ast_lock_path(path)) {
|
|
case AST_LOCK_TIMEOUT:
|
|
return -1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*! \brief Access counter file, lock directory, read and possibly write it again changed
|
|
\param directory Directory to crate file in
|
|
\param countername filename
|
|
\param value If set to zero, we only read the variable
|
|
\param operand 0 to read, 1 to set new value, 2 to change
|
|
\return -1 on error, otherwise counter value
|
|
*/
|
|
static int access_counter_file(char *directory, char *countername, int value, int operand)
|
|
{
|
|
char filename[BUFSIZ];
|
|
char readbuf[BUFSIZ];
|
|
FILE *counterfile;
|
|
int old = 0, counter = 0;
|
|
|
|
/* Lock directory */
|
|
if (vm_lock_path(directory)) {
|
|
return -1; /* Could not lock directory */
|
|
}
|
|
snprintf(filename, sizeof(filename), "%s/%s.counter", directory, countername);
|
|
if (operand != 1) {
|
|
counterfile = fopen(filename, "r");
|
|
if (counterfile) {
|
|
if(fgets(readbuf, sizeof(readbuf), counterfile)) {
|
|
ast_debug(3, "Read this string from counter file: %s\n", readbuf);
|
|
old = counter = atoi(readbuf);
|
|
}
|
|
fclose(counterfile);
|
|
}
|
|
}
|
|
switch (operand) {
|
|
case 0: /* Read only */
|
|
ast_unlock_path(directory);
|
|
ast_debug(2, "MINIVM Counter %s/%s: Value %d\n", directory, countername, counter);
|
|
return counter;
|
|
break;
|
|
case 1: /* Set new value */
|
|
counter = value;
|
|
break;
|
|
case 2: /* Change value */
|
|
counter += value;
|
|
if (counter < 0) /* Don't allow counters to fall below zero */
|
|
counter = 0;
|
|
break;
|
|
}
|
|
|
|
/* Now, write the new value to the file */
|
|
counterfile = fopen(filename, "w");
|
|
if (!counterfile) {
|
|
ast_log(LOG_ERROR, "Could not open counter file for writing : %s - %s\n", filename, strerror(errno));
|
|
ast_unlock_path(directory);
|
|
return -1; /* Could not open file for writing */
|
|
}
|
|
fprintf(counterfile, "%d\n\n", counter);
|
|
fclose(counterfile);
|
|
ast_unlock_path(directory);
|
|
ast_debug(2, "MINIVM Counter %s/%s: Old value %d New value %d\n", directory, countername, old, counter);
|
|
return counter;
|
|
}
|
|
|
|
/*! \brief ${MINIVMCOUNTER()} Dialplan function - read counters */
|
|
static int minivm_counter_func_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
|
|
{
|
|
char *username, *domain, *countername;
|
|
struct minivm_account *vmu = NULL;
|
|
char userpath[BUFSIZ];
|
|
int res;
|
|
|
|
*buf = '\0';
|
|
|
|
if (!(username = ast_strdupa(data))) { /* Copy indata to local buffer */
|
|
ast_log(LOG_WARNING, "Memory error!\n");
|
|
return -1;
|
|
}
|
|
if ((countername = strchr(username, ':'))) {
|
|
*countername = '\0';
|
|
countername++;
|
|
}
|
|
|
|
if ((domain = strchr(username, '@'))) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
|
|
/* If we have neither username nor domain now, let's give up */
|
|
if (ast_strlen_zero(username) && ast_strlen_zero(domain)) {
|
|
ast_log(LOG_ERROR, "No account given\n");
|
|
return -1;
|
|
}
|
|
|
|
if (ast_strlen_zero(countername)) {
|
|
ast_log(LOG_ERROR, "This function needs two arguments: Account:countername\n");
|
|
return -1;
|
|
}
|
|
|
|
/* We only have a domain, no username */
|
|
if (!ast_strlen_zero(username) && ast_strlen_zero(domain)) {
|
|
domain = username;
|
|
username = NULL;
|
|
}
|
|
|
|
/* If we can't find account or if the account is temporary, return. */
|
|
if (!ast_strlen_zero(username) && !(vmu = find_account(domain, username, FALSE))) {
|
|
ast_log(LOG_ERROR, "Minivm account does not exist: %s@%s\n", username, domain);
|
|
return 0;
|
|
}
|
|
|
|
create_dirpath(userpath, sizeof(userpath), domain, username, NULL);
|
|
|
|
/* We have the path, now read the counter file */
|
|
res = access_counter_file(userpath, countername, 0, 0);
|
|
if (res >= 0)
|
|
snprintf(buf, len, "%d", res);
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief ${MINIVMCOUNTER()} Dialplan function - changes counter data */
|
|
static int minivm_counter_func_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
|
|
{
|
|
char *username, *domain, *countername, *operand;
|
|
char userpath[BUFSIZ];
|
|
struct minivm_account *vmu;
|
|
int change = 0;
|
|
int operation = 0;
|
|
|
|
if(!value)
|
|
return -1;
|
|
change = atoi(value);
|
|
|
|
if (!(username = ast_strdupa(data))) { /* Copy indata to local buffer */
|
|
ast_log(LOG_WARNING, "Memory error!\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((countername = strchr(username, ':'))) {
|
|
*countername = '\0';
|
|
countername++;
|
|
}
|
|
if ((operand = strchr(countername, ':'))) {
|
|
*operand = '\0';
|
|
operand++;
|
|
}
|
|
|
|
if ((domain = strchr(username, '@'))) {
|
|
*domain = '\0';
|
|
domain++;
|
|
}
|
|
|
|
/* If we have neither username nor domain now, let's give up */
|
|
if (ast_strlen_zero(username) && ast_strlen_zero(domain)) {
|
|
ast_log(LOG_ERROR, "No account given\n");
|
|
return -1;
|
|
}
|
|
|
|
/* We only have a domain, no username */
|
|
if (!ast_strlen_zero(username) && ast_strlen_zero(domain)) {
|
|
domain = username;
|
|
username = NULL;
|
|
}
|
|
|
|
if (ast_strlen_zero(operand) || ast_strlen_zero(countername)) {
|
|
ast_log(LOG_ERROR, "Writing to this function requires three arguments: Account:countername:operand\n");
|
|
return -1;
|
|
}
|
|
|
|
/* If we can't find account or if the account is temporary, return. */
|
|
if (!ast_strlen_zero(username) && !(vmu = find_account(domain, username, FALSE))) {
|
|
ast_log(LOG_ERROR, "Minivm account does not exist: %s@%s\n", username, domain);
|
|
return 0;
|
|
}
|
|
|
|
create_dirpath(userpath, sizeof(userpath), domain, username, NULL);
|
|
/* Now, find out our operator */
|
|
if (*operand == 'i') /* Increment */
|
|
operation = 2;
|
|
else if (*operand == 'd') {
|
|
change = change * -1;
|
|
operation = 2;
|
|
} else if (*operand == 's')
|
|
operation = 1;
|
|
else {
|
|
ast_log(LOG_ERROR, "Unknown operator: %s\n", operand);
|
|
return -1;
|
|
}
|
|
|
|
/* We have the path, now read the counter file */
|
|
access_counter_file(userpath, countername, change, operation);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*! \brief CLI commands for Mini-voicemail */
|
|
static struct ast_cli_entry cli_minivm[] = {
|
|
AST_CLI_DEFINE(handle_minivm_show_users, "List defined mini-voicemail boxes"),
|
|
AST_CLI_DEFINE(handle_minivm_show_zones, "List zone message formats"),
|
|
AST_CLI_DEFINE(handle_minivm_list_templates, "List message templates"),
|
|
AST_CLI_DEFINE(handle_minivm_reload, "Reload Mini-voicemail configuration"),
|
|
AST_CLI_DEFINE(handle_minivm_show_stats, "Show some mini-voicemail statistics"),
|
|
AST_CLI_DEFINE(handle_minivm_show_settings, "Show mini-voicemail general settings"),
|
|
};
|
|
|
|
static struct ast_custom_function minivm_counter_function = {
|
|
.name = "MINIVMCOUNTER",
|
|
.synopsis = "Reads or sets counters for MiniVoicemail message",
|
|
.syntax = "MINIVMCOUNTER(<account>:name[:operand])",
|
|
.read = minivm_counter_func_read,
|
|
.write = minivm_counter_func_write,
|
|
.desc = "Valid operands for changing the value of a counter when assigning a value are:\n"
|
|
"- i Increment by value\n"
|
|
"- d Decrement by value\n"
|
|
"- s Set to value\n"
|
|
"\nThe counters never goes below zero.\n"
|
|
"- The name of the counter is a string, up to 10 characters\n"
|
|
"- If account is given and it exists, the counter is specific for the account\n"
|
|
"- If account is a domain and the domain directory exists, counters are specific for a domain\n"
|
|
"The operation is atomic and the counter is locked while changing the value\n"
|
|
"\nThe counters are stored as text files in the minivm account directories. It might be better to use\n"
|
|
"realtime functions if you are using a database to operate your Asterisk\n",
|
|
};
|
|
|
|
static struct ast_custom_function minivm_account_function = {
|
|
.name = "MINIVMACCOUNT",
|
|
.synopsis = "Gets MiniVoicemail account information",
|
|
.syntax = "MINIVMACCOUNT(<account>:item)",
|
|
.read = minivm_account_func_read,
|
|
.desc = "Valid items are:\n"
|
|
"- path Path to account mailbox (if account exists, otherwise temporary mailbox)\n"
|
|
"- hasaccount 1 if static Minivm account exists, 0 otherwise\n"
|
|
"- fullname Full name of account owner\n"
|
|
"- email Email address used for account\n"
|
|
"- etemplate E-mail template for account (default template if none is configured)\n"
|
|
"- ptemplate Pager template for account (default template if none is configured)\n"
|
|
"- accountcode Account code for voicemail account\n"
|
|
"- pincode Pin code for voicemail account\n"
|
|
"- timezone Time zone for voicemail account\n"
|
|
"- language Language for voicemail account\n"
|
|
"- <channel variable name> Channel variable value (set in configuration for account)\n"
|
|
"\n",
|
|
};
|
|
|
|
/*! \brief Load mini voicemail module */
|
|
static int load_module(void)
|
|
{
|
|
int res;
|
|
|
|
res = ast_register_application(app_minivm_record, minivm_record_exec, synopsis_minivm_record, descrip_minivm_record);
|
|
res = ast_register_application(app_minivm_greet, minivm_greet_exec, synopsis_minivm_greet, descrip_minivm_greet);
|
|
res = ast_register_application(app_minivm_notify, minivm_notify_exec, synopsis_minivm_notify, descrip_minivm_notify);
|
|
res = ast_register_application(app_minivm_delete, minivm_delete_exec, synopsis_minivm_delete, descrip_minivm_delete);
|
|
res = ast_register_application(app_minivm_accmess, minivm_accmess_exec, synopsis_minivm_accmess, descrip_minivm_accmess);
|
|
|
|
ast_custom_function_register(&minivm_account_function);
|
|
ast_custom_function_register(&minivm_counter_function);
|
|
if (res)
|
|
return(res);
|
|
|
|
if ((res = load_config(0)))
|
|
return(res);
|
|
|
|
ast_cli_register_multiple(cli_minivm, sizeof(cli_minivm)/sizeof(cli_minivm[0]));
|
|
|
|
/* compute the location of the voicemail spool directory */
|
|
snprintf(MVM_SPOOL_DIR, sizeof(MVM_SPOOL_DIR), "%s/voicemail/", ast_config_AST_SPOOL_DIR);
|
|
|
|
return res;
|
|
}
|
|
|
|
/*! \brief Reload mini voicemail module */
|
|
static int reload(void)
|
|
{
|
|
return(load_config(1));
|
|
}
|
|
|
|
/*! \brief Reload cofiguration */
|
|
static char *handle_minivm_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
{
|
|
|
|
switch (cmd) {
|
|
case CLI_INIT:
|
|
e->command = "minivm reload";
|
|
e->usage =
|
|
"Usage: minivm reload\n"
|
|
" Reload mini-voicemail configuration and reset statistics\n";
|
|
return NULL;
|
|
case CLI_GENERATE:
|
|
return NULL;
|
|
}
|
|
|
|
reload();
|
|
ast_cli(a->fd, "\n-- Mini voicemail re-configured \n");
|
|
return CLI_SUCCESS;
|
|
}
|
|
|
|
/*! \brief Unload mini voicemail module */
|
|
static int unload_module(void)
|
|
{
|
|
int res;
|
|
|
|
res = ast_unregister_application(app_minivm_record);
|
|
res |= ast_unregister_application(app_minivm_greet);
|
|
res |= ast_unregister_application(app_minivm_notify);
|
|
res |= ast_unregister_application(app_minivm_delete);
|
|
res |= ast_unregister_application(app_minivm_accmess);
|
|
ast_cli_unregister_multiple(cli_minivm, sizeof(cli_minivm)/sizeof(cli_minivm[0]));
|
|
ast_custom_function_unregister(&minivm_account_function);
|
|
ast_custom_function_unregister(&minivm_counter_function);
|
|
|
|
message_destroy_list(); /* Destroy list of voicemail message templates */
|
|
timezone_destroy_list(); /* Destroy list of timezones */
|
|
vmaccounts_destroy_list(); /* Destroy list of voicemail accounts */
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Mini VoiceMail (A minimal Voicemail e-mail System)",
|
|
.load = load_module,
|
|
.unload = unload_module,
|
|
.reload = reload,
|
|
);
|