app_voicemail.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * 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
 * \author Mark Spencer <markster@digium.com>
 * \brief Comedian Mail - Voicemail System
 *
 * unixODBC (http://www.unixodbc.org/)
 * A source distribution of University of Washington's IMAP c-client
 *         (http://www.washington.edu/imap/)
 *
 * \par See also
 * \arg \ref voicemail.conf "Config_voicemail"
 * \note For information about voicemail IMAP storage, https://docs.asterisk.org/Configuration/Applications/Voicemail/IMAP-Voicemail-Storage/
 * \ingroup applications
 * \todo This module requires res_adsi to load. This needs to be optional
 * during compilation.
 *
 * \todo This file is now almost impossible to work with, due to all \#ifdefs.
 *       Feels like the database code before realtime. Someone - please come up
 *       with a plan to clean this up.
 */
 
/*! \li \ref app_voicemail.c uses configuration file \ref voicemail.conf
 * \addtogroup configuration_file Configuration Files
 */
 
/*!
 * \page voicemail.conf voicemail.conf
 * \verbinclude voicemail.conf.sample
 */
 
#include "asterisk.h"
 
#ifdef IMAP_STORAGE
#include <ctype.h>
#include <signal.h>
#include <pwd.h>
#ifdef USE_SYSTEM_IMAP
#include <imap/c-client.h>
#include <imap/imap4r1.h>
#include <imap/linkage.h>
#elif defined (USE_SYSTEM_CCLIENT)
#include <c-client/c-client.h>
#include <c-client/imap4r1.h>
#include <c-client/linkage.h>
#else
#include "c-client.h"
#include "imap4r1.h"
#include "linkage.h"
#endif
#endif
 
#include "asterisk/paths.h" /* use ast_config_AST_SPOOL_DIR */
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <time.h>
#include <dirent.h>
#if defined(__FreeBSD__) || defined(__OpenBSD__)
#include <sys/wait.h>
#endif
 
#include "asterisk/logger.h"
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/say.h"
#include "asterisk/module.h"
#include "asterisk/adsi.h"
#include "asterisk/app.h"
#include "asterisk/mwi.h"
#include "asterisk/manager.h"
#include "asterisk/dsp.h"
#include "asterisk/localtime.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/stringfields.h"
#include "asterisk/strings.h"
#include "asterisk/smdi.h"
#include "asterisk/astobj2.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/test.h"
#include "asterisk/format_cache.h"
 
#ifdef ODBC_STORAGE
#include "asterisk/res_odbc.h"
#endif
 
#ifdef IMAP_STORAGE
#include "asterisk/threadstorage.h"
#endif
 
/*** DOCUMENTATION
    <application name="VoiceMail" language="en_US">
        <synopsis>
            Leave a Voicemail message.
        </synopsis>
        <syntax>
            <parameter name="mailboxs" argsep="&amp;" required="true">
                <argument name="mailbox1" argsep="@" required="true">
                    <argument name="mailbox" required="true" />
                    <argument name="context" />
                </argument>
                <argument name="mailbox2" argsep="@" multiple="true">
                    <argument name="mailbox" required="true" />
                    <argument name="context" />
                </argument>
            </parameter>
            <parameter name="options">
                <optionlist>
                    <option name="b">
                        <para>Play the <literal>busy</literal> greeting to the calling party.</para>
                    </option>
                    <option name="d">
                        <argument name="c" />
                        <para>Accept digits for a new extension in context <replaceable>c</replaceable>,
                        if played during the greeting. Context defaults to the current context.</para>
                    </option>
                    <option name="e">
                        <para>Play greetings as early media -- only answer the channel just
                        before accepting the voice message.</para>
                    </option>
                    <option name="g">
                        <argument name="#" required="true" />
                        <para>Use the specified amount of gain when recording the voicemail
                        message. The units are whole-number decibels (dB). Only works on supported
                        technologies, which is DAHDI only.</para>
                    </option>
                    <option name="s">
                        <para>Skip the playback of instructions for leaving a message to the
                        calling party.</para>
                    </option>
                    <option name="S">
                        <para>Skip the playback of instructions for leaving a message to the
                        calling party, but only if a greeting has been recorded by the
                        mailbox user.</para>
                    </option>
                    <option name="t">
                        <argument name="x" required="false" />
                        <para>Play a custom beep tone to the caller instead of the default one.
                        If this option is used but no file is specified, the beep is suppressed.</para>
                    </option>
                    <option name="u">
                        <para>Play the <literal>unavailable</literal> greeting.</para>
                    </option>
                    <option name="U">
                        <para>Mark message as <literal>URGENT</literal>.</para>
                    </option>
                    <option name="P">
                        <para>Mark message as <literal>PRIORITY</literal>.</para>
                    </option>
                </optionlist>
            </parameter>
        </syntax>
        <description>
            <para>This application allows the calling party to leave a message for the specified
            list of mailboxes. When multiple mailboxes are specified, the greeting will be taken from
            the first mailbox specified. Dialplan execution will stop if the specified mailbox does not
            exist.</para>
            <para>The Voicemail application will exit if any of the following DTMF digits are received:</para>
            <enumlist>
                <enum name="0">
                    <para>Jump to the <literal>o</literal> extension in the current dialplan context.</para>
                </enum>
                <enum name="*">
                    <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
                </enum>
            </enumlist>
            <para>This application will set the following channel variable upon completion:</para>
            <variablelist>
                <variable name="VMSTATUS">
                    <para>This indicates the status of the execution of the VoiceMail application.</para>
                    <value name="SUCCESS" />
                    <value name="USEREXIT" />
                    <value name="FAILED" />
                </variable>
            </variablelist>
        </description>
        <see-also>
            <ref type="application">VoiceMailMain</ref>
        </see-also>
    </application>
    <application name="VoiceMailMain" language="en_US">
        <synopsis>
            Check Voicemail messages.
        </synopsis>
        <syntax>
            <parameter name="mailbox" required="true" argsep="@">
                <argument name="mailbox" />
                <argument name="context" />
            </parameter>
            <parameter name="options">
                <optionlist>
                    <option name="p">
                        <para>Consider the <replaceable>mailbox</replaceable> parameter as a prefix to
                        the mailbox that is entered by the caller.</para>
                    </option>
                    <option name="g">
                        <argument name="#" required="true" />
                        <para>Use the specified amount of gain when recording a voicemail message.
                        The units are whole-number decibels (dB).</para>
                    </option>
                    <option name="r">
                        <para>"Read only". Prevent user from deleting any messages.</para>
                        <para>This applies only to specific executions of VoiceMailMain, NOT the mailbox itself.</para>
                    </option>
                    <option name="s">
                        <para>Skip checking the passcode for the mailbox.</para>
                    </option>
                    <option name="a">
                        <argument name="folder" required="true" />
                        <para>Skip folder prompt and go directly to <replaceable>folder</replaceable> specified.
                        Defaults to <literal>INBOX</literal> (or <literal>0</literal>).</para>
                        <enumlist>
                            <enum name="0"><para>INBOX</para></enum>
                            <enum name="1"><para>Old</para></enum>
                            <enum name="2"><para>Work</para></enum>
                            <enum name="3"><para>Family</para></enum>
                            <enum name="4"><para>Friends</para></enum>
                            <enum name="5"><para>Cust1</para></enum>
                            <enum name="6"><para>Cust2</para></enum>
                            <enum name="7"><para>Cust3</para></enum>
                            <enum name="8"><para>Cust4</para></enum>
                            <enum name="9"><para>Cust5</para></enum>
                        </enumlist>
                    </option>
                </optionlist>
            </parameter>
        </syntax>
        <description>
            <para>This application allows the calling party to check voicemail messages. A specific
            <replaceable>mailbox</replaceable>, and optional corresponding <replaceable>context</replaceable>,
            may be specified. If a <replaceable>mailbox</replaceable> is not provided, the calling party will
            be prompted to enter one. If a <replaceable>context</replaceable> is not specified, the
            <literal>default</literal> context will be used.</para>
            <para>The VoiceMailMain application will exit if the following DTMF digit is entered as Mailbox
            or Password, and the extension exists:</para>
            <enumlist>
                <enum name="*">
                    <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
                </enum>
            </enumlist>
        </description>
        <see-also>
            <ref type="application">VoiceMail</ref>
        </see-also>
    </application>
    <application name="VMAuthenticate" language="en_US">
        <synopsis>
            Authenticate with Voicemail passwords.
        </synopsis>
        <syntax>
            <parameter name="mailbox" required="true" argsep="@">
                <argument name="mailbox" />
                <argument name="context" />
            </parameter>
            <parameter name="options">
                <optionlist>
                    <option name="s">
                        <para>Skip playing the initial prompts.</para>
                    </option>
                </optionlist>
            </parameter>
        </syntax>
        <description>
            <para>This application behaves the same way as the Authenticate application, but the passwords
            are taken from <filename>voicemail.conf</filename>. If the <replaceable>mailbox</replaceable> is
            specified, only that mailbox's password will be considered valid. If the <replaceable>mailbox</replaceable>
            is not specified, the channel variable <variable>AUTH_MAILBOX</variable> will be set with the authenticated
            mailbox.</para>
            <para>The VMAuthenticate application will exit if the following DTMF digit is entered as Mailbox
            or Password, and the extension exists:</para>
            <enumlist>
                <enum name="*">
                    <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
                </enum>
            </enumlist>
        </description>
    </application>
    <application name="VoiceMailPlayMsg" language="en_US">
        <synopsis>
            Play a single voice mail msg from a mailbox by msg id.
        </synopsis>
        <syntax>
            <parameter name="mailbox" required="true" argsep="@">
                <argument name="mailbox" />
                <argument name="context" />
            </parameter>
            <parameter name="msg_id" required="true">
                <para>The msg id of the msg to play back. </para>
            </parameter>
        </syntax>
        <description>
            <para>This application sets the following channel variable upon completion:</para>
            <variablelist>
                <variable name="VOICEMAIL_PLAYBACKSTATUS">
                    <para>The status of the playback attempt as a text string.</para>
                    <value name="SUCCESS"/>
                    <value name="FAILED"/>
                </variable>
            </variablelist>
        </description>
    </application>
    <application name="VMSayName" language="en_US">
        <synopsis>
            Play the name of a voicemail user
        </synopsis>
        <syntax>
            <parameter name="mailbox" required="true" argsep="@">
                <argument name="mailbox" />
                <argument name="context" />
            </parameter>
        </syntax>
        <description>
            <para>This application will say the recorded name of the voicemail user specified as the
            argument to this application. If no context is provided, <literal>default</literal> is assumed.</para>
            <para>Similar to the Background() application, playback of the recorded
            name can be interrupted by entering an extension, which will be searched
            for in the current context.</para>
        </description>
    </application>
    <function name="VM_INFO" language="en_US">
        <synopsis>
            Returns the selected attribute from a mailbox.
        </synopsis>
        <syntax argsep=",">
            <parameter name="mailbox" argsep="@" required="true">
                <argument name="mailbox" required="true" />
                <argument name="context" />
            </parameter>
            <parameter name="attribute" required="true">
                <optionlist>
                    <option name="count">
                        <para>Count of messages in specified <replaceable>folder</replaceable>.
                        If <replaceable>folder</replaceable> is not specified, defaults to <literal>INBOX</literal>.</para>
                    </option>
                    <option name="email">
                        <para>E-mail address associated with the mailbox.</para>
                    </option>
                    <option name="exists">
                        <para>Returns a boolean of whether the corresponding <replaceable>mailbox</replaceable> exists.</para>
                    </option>
                    <option name="fullname">
                        <para>Full name associated with the mailbox.</para>
                    </option>
                    <option name="language">
                        <para>Mailbox language if overridden, otherwise the language of the channel.</para>
                    </option>
                    <option name="locale">
                        <para>Mailbox locale if overridden, otherwise global locale.</para>
                    </option>
                    <option name="pager">
                        <para>Pager e-mail address associated with the mailbox.</para>
                    </option>
                    <option name="password">
                        <para>Mailbox access password.</para>
                    </option>
                    <option name="tz">
                        <para>Mailbox timezone if overridden, otherwise global timezone</para>
                    </option>
                </optionlist>
            </parameter>
            <parameter name="folder" required="false">
                <para>If not specified, <literal>INBOX</literal> is assumed.</para>
            </parameter>
        </syntax>
        <description>
            <para>Returns the selected attribute from the specified <replaceable>mailbox</replaceable>.
            If <replaceable>context</replaceable> is not specified, defaults to the <literal>default</literal>
            context. Where the <replaceable>folder</replaceable> can be specified, common folders
            include <literal>INBOX</literal>, <literal>Old</literal>, <literal>Work</literal>,
            <literal>Family</literal> and <literal>Friends</literal>.</para>
        </description>
    </function>
    <manager name="VoicemailUsersList" language="en_US">
        <synopsis>
            List All Voicemail User Information.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
        </syntax>
        <description>
        </description>
    </manager>
    <manager name="VoicemailUserStatus" language="en_US">
        <synopsis>
            Show the status of given voicemail user's info.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" required="true">
                <para>The context you want to check.</para>
            </parameter>
            <parameter name="Mailbox" required="true">
                <para>The mailbox you want to check.</para>
            </parameter>
        </syntax>
        <description>
            <para>Retrieves the status of the given voicemail user.</para>
        </description>
    </manager>
    <manager name="VoicemailRefresh" language="en_US">
        <synopsis>
            Tell Asterisk to poll mailboxes for a change
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" />
            <parameter name="Mailbox" />
        </syntax>
        <description>
            <para>Normally, MWI indicators are only sent when Asterisk itself
            changes a mailbox.  With external programs that modify the content
            of a mailbox from outside the application, an option exists called
            <literal>pollmailboxes</literal> that will cause voicemail to
            continually scan all mailboxes on a system for changes.  This can
            cause a large amount of load on a system.  This command allows
            external applications to signal when a particular mailbox has
            changed, thus permitting external applications to modify mailboxes
            and MWI to work without introducing considerable CPU load.</para>
            <para>If <replaceable>Context</replaceable> is not specified, all
            mailboxes on the system will be polled for changes.  If
            <replaceable>Context</replaceable> is specified, but
            <replaceable>Mailbox</replaceable> is omitted, then all mailboxes
            within <replaceable>Context</replaceable> will be polled.
            Otherwise, only a single mailbox will be polled for changes.</para>
        </description>
    </manager>
    <manager name="VoicemailBoxSummary" language="en_US">
        <synopsis>
            Show the mailbox contents of given voicemail user.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" required="true">
                <para>The context you want to check.</para>
            </parameter>
            <parameter name="Mailbox" required="true">
                <para>The mailbox you want to check.</para>
            </parameter>
        </syntax>
        <description>
            <para>Retrieves the contents of the given voicemail user's mailbox.</para>
        </description>
    </manager>
    <manager name="VoicemailMove" language="en_US">
        <synopsis>
            Move Voicemail between mailbox folders of given user.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" required="true">
                <para>The context of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="Mailbox" required="true">
                <para>The mailbox of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="Folder" required="true">
                <para>The Folder containing the Voicemail you want to move.</para>
            </parameter>
            <parameter name="ID" required="true">
                <para>The ID of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="ToFolder" required="true">
                <para>The Folder you want to move the Voicemail to.</para>
            </parameter>
        </syntax>
        <description>
            <para>Move a given Voicemail between Folders within a user's Mailbox.</para>
        </description>
    </manager>
    <manager name="VoicemailRemove" language="en_US">
        <synopsis>
            Remove Voicemail from mailbox folder.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" required="true">
                <para>The context of the Voicemail you want to remove.</para>
            </parameter>
            <parameter name="Mailbox" required="true">
                <para>The mailbox of the Voicemail you want to remove.</para>
            </parameter>
            <parameter name="Folder" required="true">
                <para>The Folder containing the Voicemail you want to remove.</para>
            </parameter>
            <parameter name="ID" required="true">
                <para>The ID of the Voicemail you want to remove.</para>
            </parameter>
        </syntax>
        <description>
            <para>Remove a given Voicemail from a user's Mailbox Folder.</para>
        </description>
    </manager>
    <manager name="VoicemailForward" language="en_US">
        <synopsis>
            Forward Voicemail from one mailbox folder to another between given users.
        </synopsis>
        <syntax>
            <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
            <parameter name="Context" required="true">
                <para>The context of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="Mailbox" required="true">
                <para>The mailbox of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="Folder" required="true">
                <para>The Folder containing the Voicemail you want to move.</para>
            </parameter>
            <parameter name="ID" required="true">
                <para>The ID of the Voicemail you want to move.</para>
            </parameter>
            <parameter name="ToContext" required="true">
                <para>The context you want to move the Voicemail to.</para>
            </parameter>
            <parameter name="ToMailbox" required="true">
                <para>The mailbox you want to move the Voicemail to.</para>
            </parameter>
            <parameter name="ToFolder" required="true">
                <para>The Folder you want to move the Voicemail to.</para>
            </parameter>
        </syntax>
        <description>
            <para>Forward a given Voicemail from a user's Mailbox Folder to
            another user's Mailbox Folder. Can be used to copy between
            Folders within a mailbox by specifying the to context and user
            as the same as the from.</para>
        </description>
    </manager>
    <managerEvent language="en_US" name="VoicemailPasswordChange">
        <managerEventInstance class="EVENT_FLAG_USER">
            <synopsis>Raised in response to a mailbox password change.</synopsis>
            <syntax>
                <parameter name="Context">
                    <para>Mailbox context.</para>
                </parameter>
                <parameter name="Mailbox">
                    <para>Mailbox name.</para>
                </parameter>
                <parameter name="NewPassword">
                    <para>New password for mailbox.</para>
                </parameter>
            </syntax>
        </managerEventInstance>
    </managerEvent>
 ***/
 
#ifdef IMAP_STORAGE
static char imapserver[48] = "localhost";
static char imapport[8] = "143";
static char imapflags[128];
static char imapfolder[64] = "INBOX";
static char imapparentfolder[64];
static char greetingfolder[64] = "INBOX";
static char authuser[32];
static char authpassword[42];
static int imapversion = 1;
 
static int expungeonhangup = 1;
static int imapgreetings;
static int imap_poll_logout;
static char delimiter;
 
/* mail_open cannot be protected on a stream basis */
ast_mutex_t mail_open_lock;
 
struct vm_state;
struct ast_vm_user;
 
AST_THREADSTORAGE(ts_vmstate);
 
/* Forward declarations for IMAP */
static int init_mailstream(struct vm_state *vms, int box);
static void write_file(char *filename, char *buffer, unsigned long len);
static char *get_header_by_tag(char *header, char *tag, char *buf, size_t len);
static void vm_imap_delete(char *file, int msgnum, struct ast_vm_user *vmu);
static char *get_user_by_mailbox(char *mailbox, char *buf, size_t len);
static struct vm_state *get_vm_state_by_imapuser(const char *user, int interactive);
static struct vm_state *get_vm_state_by_mailbox(const char *mailbox, const char *context, int interactive);
static struct vm_state *create_vm_state_from_user(struct ast_vm_user *vmu);
static void vmstate_insert(struct vm_state *vms);
static void vmstate_delete(struct vm_state *vms);
static void set_update(MAILSTREAM * stream);
static void init_vm_state(struct vm_state *vms);
static int save_body(BODY *body, struct vm_state *vms, char *section, char *format, int is_intro);
static void get_mailbox_delimiter(struct vm_state *vms, MAILSTREAM *stream);
static void mm_parsequota (MAILSTREAM *stream, unsigned char *msg, QUOTALIST *pquota);
static void imap_mailbox_name(char *spec, size_t len, struct vm_state *vms, int box, int target);
static int imap_store_file(const char *dir, const char *mailboxuser, const char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag, const char *msg_id);
static void vm_imap_update_msg_id(char *dir, int msgnum, const char *msg_id, struct ast_vm_user *vmu, struct ast_config *msg_cfg, int folder);
static void update_messages_by_imapuser(const char *user, unsigned long number);
static int vm_delete(char *file);
 
static int imap_remove_file (char *dir, int msgnum);
static int imap_retrieve_file (const char *dir, const int msgnum, const char *mailbox, const char *context);
static int imap_delete_old_greeting (char *dir, struct vm_state *vms);
static void check_quota(struct vm_state *vms, char *mailbox);
static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box);
static void imap_logout(const char *mailbox_id);
 
struct vmstate {
    struct vm_state *vms;
    AST_LIST_ENTRY(vmstate) list;
};
 
static AST_LIST_HEAD_STATIC(vmstates, vmstate);
 
#endif
 
#define SMDI_MWI_WAIT_TIMEOUT 1000 /* 1 second */
 
#define COMMAND_TIMEOUT 5000
/* Don't modify these here; set your umask at runtime instead */
#define VOICEMAIL_DIR_MODE  0777
#define VOICEMAIL_FILE_MODE 0666
#define CHUNKSIZE   65536
 
#define VOICEMAIL_CONFIG "voicemail.conf"
#define ASTERISK_USERNAME "asterisk"
 
/* Define fast-forward, pause, restart, and reverse keys
 * while listening to a voicemail message - these are
 * strings, not characters */
#define DEFAULT_LISTEN_CONTROL_FORWARD_KEY "#"
#define DEFAULT_LISTEN_CONTROL_REVERSE_KEY "*"
#define DEFAULT_LISTEN_CONTROL_PAUSE_KEY "0"
#define DEFAULT_LISTEN_CONTROL_RESTART_KEY "2"
#define DEFAULT_LISTEN_CONTROL_STOP_KEY "13456789"
#define VALID_DTMF "1234567890*#" /* Yes ABCD are valid dtmf but what phones have those? */
 
/* Default mail command to mail voicemail. Change it with the
 * mailcmd= command in voicemail.conf */
#define SENDMAIL "/usr/sbin/sendmail -t"
#define INTRO "vm-intro"
 
#define MAX_MAIL_BODY_CONTENT_SIZE 134217728L // 128 Mbyte
 
#define MAXMSG 100
#define MAXMSGLIMIT 9999
 
#define MINPASSWORD 0 /*!< Default minimum mailbox password length */
 
#ifdef IMAP_STORAGE
#define ENDL "\r\n"
#else
#define ENDL "\n"
#endif
 
#define MAX_DATETIME_FORMAT 512
#define MAX_NUM_CID_CONTEXTS 10
 
#define VM_REVIEW        (1 << 0)   /*!< After recording, permit the caller to review the recording before saving */
#define VM_OPERATOR      (1 << 1)   /*!< Allow 0 to be pressed to go to 'o' extension */
#define VM_SAYCID        (1 << 2)   /*!< Repeat the CallerID info during envelope playback */
#define VM_SVMAIL        (1 << 3)   /*!< Allow the user to compose a new VM from within VoicemailMain */
#define VM_ENVELOPE      (1 << 4)   /*!< Play the envelope information (who-from, time received, etc.) */
#define VM_SAYDURATION   (1 << 5)   /*!< Play the length of the message during envelope playback */
#define VM_SKIPAFTERCMD  (1 << 6)   /*!< After deletion, assume caller wants to go to the next message */
#define VM_FORCENAME     (1 << 7)   /*!< Have new users record their name */
#define VM_FORCEGREET    (1 << 8)   /*!< Have new users record their greetings */
#define VM_PBXSKIP       (1 << 9)   /*!< Skip the [PBX] preamble in the Subject line of emails */
#define VM_DIRECTFORWARD (1 << 10)  /*!< Permit caller to use the Directory app for selecting to which mailbox to forward a VM */
#define VM_ATTACH        (1 << 11)  /*!< Attach message to voicemail notifications? */
#define VM_DELETE        (1 << 12)  /*!< Delete message after sending notification */
#define VM_ALLOCED       (1 << 13)  /*!< Structure was malloc'ed, instead of placed in a return (usually static) buffer */
#define VM_SEARCH        (1 << 14)  /*!< Search all contexts for a matching mailbox */
#define VM_TEMPGREETWARN (1 << 15)  /*!< Remind user tempgreeting is set */
#define VM_MOVEHEARD     (1 << 16)  /*!< Move a "heard" message to Old after listening to it */
#define VM_MESSAGEWRAP   (1 << 17)  /*!< Wrap around from the last message to the first, and vice-versa */
#define VM_FWDURGAUTO    (1 << 18)  /*!< Autoset of Urgent flag on forwarded Urgent messages set globally */
#define VM_EMAIL_EXT_RECS (1 << 19)  /*!< Send voicemail emails when an external recording is added to a mailbox */
#define VM_MARK_URGENT   (1 << 20)  /*!< After recording, permit the caller to mark the message as urgent */
#define VM_ODBC_AUDIO_ON_DISK  (1 << 21) /*!< When using ODBC, leave the message and greeting recordings on disk instead of moving them into the table */
 
#define ERROR_LOCK_PATH  -100
#define ERROR_MAX_MSGS   -101
#define OPERATOR_EXIT     300
 
#define MSGFILE_LEN (7) /*!< Length of the message file name: msgXXXX */
 
enum vm_box {
    NEW_FOLDER =        0,
    OLD_FOLDER =        1,
    WORK_FOLDER =       2,
    FAMILY_FOLDER =     3,
    FRIENDS_FOLDER =    4,
    GREETINGS_FOLDER =  -1
};
 
enum vm_option_flags {
    OPT_SILENT =           (1 << 0),
    OPT_BUSY_GREETING =    (1 << 1),
    OPT_UNAVAIL_GREETING = (1 << 2),
    OPT_RECORDGAIN =       (1 << 3),
    OPT_PREPEND_MAILBOX =  (1 << 4),
    OPT_AUTOPLAY =         (1 << 6),
    OPT_DTMFEXIT =         (1 << 7),
    OPT_MESSAGE_Urgent =   (1 << 8),
    OPT_MESSAGE_PRIORITY = (1 << 9),
    OPT_EARLYM_GREETING =  (1 << 10),
    OPT_BEEP =             (1 << 11),
    OPT_SILENT_IF_GREET =  (1 << 12),
    OPT_READONLY =         (1 << 13),
};
 
enum vm_option_args {
    OPT_ARG_RECORDGAIN = 0,
    OPT_ARG_PLAYFOLDER = 1,
    OPT_ARG_DTMFEXIT   = 2,
    OPT_ARG_BEEP_TONE  = 3,
    /* This *must* be the last value in this enum! */
    OPT_ARG_ARRAY_SIZE = 4,
};
 
enum vm_passwordlocation {
    OPT_PWLOC_VOICEMAILCONF = 0,
    OPT_PWLOC_SPOOLDIR      = 1,
    OPT_PWLOC_USERSCONF     = 2,
};
 
AST_APP_OPTIONS(vm_app_options, {
    AST_APP_OPTION('s', OPT_SILENT),
    AST_APP_OPTION('S', OPT_SILENT_IF_GREET),
    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_OPTION_ARG('d', OPT_DTMFEXIT, OPT_ARG_DTMFEXIT),
    AST_APP_OPTION('p', OPT_PREPEND_MAILBOX),
    AST_APP_OPTION_ARG('a', OPT_AUTOPLAY, OPT_ARG_PLAYFOLDER),
    AST_APP_OPTION('U', OPT_MESSAGE_Urgent),
    AST_APP_OPTION('P', OPT_MESSAGE_PRIORITY),
    AST_APP_OPTION('e', OPT_EARLYM_GREETING),
    AST_APP_OPTION_ARG('t', OPT_BEEP, OPT_ARG_BEEP_TONE),
    AST_APP_OPTION('r', OPT_READONLY),
});
 
static const char * const mailbox_folders[] = {
#ifdef IMAP_STORAGE
    imapfolder,
#else
    "INBOX",
#endif
    "Old",
    "Work",
    "Family",
    "Friends",
    "Cust1",
    "Cust2",
    "Cust3",
    "Cust4",
    "Cust5",
    "Deleted",
    "Urgent",
};
 
/*!
 * \brief Reload voicemail.conf
 * \param reload Whether this is a reload as opposed to module load
 * \param force Forcefully reload the config, even it has not changed
 * \retval 0 on success, nonzero on failure
 */
static int load_config_force(int reload, int force);
 
/*! \brief Forcibly reload voicemail.conf, even if it has not changed.
 * This is necessary after running unit tests. */
#define force_reload_config() load_config_force(1, 1)
 
static int load_config(int reload);
#ifdef TEST_FRAMEWORK
static int load_config_from_memory(int reload, struct ast_config *cfg, struct ast_config *ucfg);
#endif
static int actual_load_config(int reload, struct ast_config *cfg, struct ast_config *ucfg);
 
/*! \page vmlang Voicemail Language Syntaxes Supported
 
    \par Syntaxes supported, not really language codes.
    \arg \b en    - English
    \arg \b de    - German
    \arg \b es    - Spanish
    \arg \b fr    - French
    \arg \b it    - Italian
    \arg \b nl    - Dutch
    \arg \b pt    - Portuguese
    \arg \b pt_BR - Portuguese (Brazil)
    \arg \b gr    - Greek
    \arg \b no    - Norwegian
    \arg \b se    - Swedish
    \arg \b tw    - Chinese (Taiwan)
    \arg \b ua - Ukrainian
 
German requires the following additional soundfile:
\arg \b 1F  einE (feminine)
 
Spanish requires the following additional soundfile:
\arg \b 1M      un (masculine)
 
Dutch, Portuguese & Spanish require the following additional soundfiles:
\arg \b vm-INBOXs   singular of 'new'
\arg \b vm-Olds     singular of 'old/heard/read'
 
NB these are plural:
\arg \b vm-INBOX    nieuwe (nl)
\arg \b vm-Old      oude (nl)
 
Polish uses:
\arg \b vm-new-a    'new', feminine singular accusative
\arg \b vm-new-e    'new', feminine plural accusative
\arg \b vm-new-ych  'new', feminine plural genitive
\arg \b vm-old-a    'old', feminine singular accusative
\arg \b vm-old-e    'old', feminine plural accusative
\arg \b vm-old-ych  'old', feminine plural genitive
\arg \b digits/1-a  'one', not always same as 'digits/1'
\arg \b digits/2-ie 'two', not always same as 'digits/2'
 
Swedish uses:
\arg \b vm-nytt     singular of 'new'
\arg \b vm-nya      plural of 'new'
\arg \b vm-gammalt  singular of 'old'
\arg \b vm-gamla    plural of 'old'
\arg \b digits/ett  'one', not always same as 'digits/1'
 
Norwegian uses:
\arg \b vm-ny       singular of 'new'
\arg \b vm-nye      plural of 'new'
\arg \b vm-gammel   singular of 'old'
\arg \b vm-gamle    plural of 'old'
 
Dutch also uses:
\arg \b nl-om       'at'?
 
Spanish also uses:
\arg \b vm-youhaveno
 
Italian requires the following additional soundfile:
 
For vm_intro_it:
\arg \b vm-nuovo    new
\arg \b vm-nuovi    new plural
\arg \b vm-vecchio  old
\arg \b vm-vecchi   old plural
 
Japanese requires the following additional soundfile:
\arg \b jp-arimasu          there is
\arg \b jp-arimasen         there is not
\arg \b jp-oshitekudasai    please press
\arg \b jp-ni               article ni
\arg \b jp-ga               article ga
\arg \b jp-wa               article wa
\arg \b jp-wo               article wo
 
Chinese (Taiwan) requires the following additional soundfile:
\arg \b vm-tong     A class-word for call (tong1)
\arg \b vm-ri       A class-word for day (ri4)
\arg \b vm-you      You (ni3)
\arg \b vm-haveno   Have no (mei2 you3)
\arg \b vm-have     Have (you3)
\arg \b vm-listen   To listen (yao4 ting1)
 
 
\note Don't use vm-INBOX or vm-Old, because they are the name of the INBOX and Old folders,
spelled among others when you have to change folder. For the above reasons, vm-INBOX
and vm-Old are spelled plural, to make them sound more as folder name than an adjective.
 
*/
 
#define MAX_VM_MBOX_ID_LEN (AST_MAX_EXTENSION)
#define MAX_VM_CONTEXT_LEN (AST_MAX_CONTEXT)
/* MAX_VM_MAILBOX_LEN allows enough room for the '@' and NULL terminator */
#define MAX_VM_MAILBOX_LEN (MAX_VM_MBOX_ID_LEN + MAX_VM_CONTEXT_LEN)
 
/*! Structure for linked list of users
 * Use ast_vm_user_destroy() to free one of these structures. */
struct ast_vm_user {
    char context[MAX_VM_CONTEXT_LEN];/*!< Voicemail context */
    char mailbox[MAX_VM_MBOX_ID_LEN];/*!< Mailbox id, unique within vm context */
    char password[80];               /*!< Secret pin code, numbers only */
    char fullname[80];               /*!< Full name, for directory app */
    char *email;                     /*!< E-mail address */
    char *emailsubject;              /*!< E-mail subject */
    char *emailbody;                 /*!< E-mail body */
    char pager[80];                  /*!< E-mail address to pager (no attachment) */
    char serveremail[80];            /*!< From: Mail address */
    char fromstring[100];            /*!< From: Username */
    char language[MAX_LANGUAGE];     /*!< Config: Language setting */
    char zonetag[80];                /*!< Time zone */
    char locale[20];                 /*!< The locale (for presentation of date/time) */
    char callback[80];
    char dialout[80];
    char uniqueid[80];               /*!< Unique integer identifier */
    char exit[80];
    char attachfmt[20];              /*!< Attachment format */
    unsigned int flags;              /*!< VM_ flags */
    int saydurationm;
    int minsecs;                     /*!< Minimum number of seconds per message for this mailbox */
    int maxmsg;                      /*!< Maximum number of msgs per folder for this mailbox */
    int maxdeletedmsg;               /*!< Maximum number of deleted msgs saved for this mailbox */
    int maxsecs;                     /*!< Maximum number of seconds per message for this mailbox */
    int passwordlocation;            /*!< Storage location of the password */
#ifdef IMAP_STORAGE
    char imapserver[48];             /*!< IMAP server address */
    char imapport[8];                /*!< IMAP server port */
    char imapflags[128];             /*!< IMAP optional flags */
    char imapuser[80];               /*!< IMAP server login */
    char imappassword[80];           /*!< IMAP server password if authpassword not defined */
    char imapfolder[64];             /*!< IMAP voicemail folder */
    char imapvmshareid[80];          /*!< Shared mailbox ID to use rather than the dialed one */
    int imapversion;                 /*!< If configuration changes, use the new values */
#endif
    double volgain;                  /*!< Volume gain for voicemails sent via email */
    AST_LIST_ENTRY(ast_vm_user) list;
};
 
/*! Voicemail time zones */
struct vm_zone {
    AST_LIST_ENTRY(vm_zone) list;
    char name[80];
    char timezone[80];
    char msg_format[512];
};
 
#define VMSTATE_MAX_MSG_ARRAY 256
 
/*! Voicemail mailbox state */
struct vm_state {
    char curbox[80];
    char username[80];
    char context[80];
    char curdir[PATH_MAX];
    char vmbox[PATH_MAX];
    char fn[PATH_MAX];
    char intro[PATH_MAX];
    int *deleted;
    int *heard;
    int dh_arraysize; /* used for deleted / heard allocation */
    int curmsg;
    int lastmsg;
    int newmessages;
    int oldmessages;
    int urgentmessages;
    int starting;
    int repeats;
#ifdef IMAP_STORAGE
    ast_mutex_t lock;
    int updated;                         /*!< decremented on each mail check until 1 -allows delay */
    long *msgArray;
    unsigned msg_array_max;
    MAILSTREAM *mailstream;
    int vmArrayIndex;
    char imapuser[80];                   /*!< IMAP server login */
    char imapfolder[64];                 /*!< IMAP voicemail folder */
    char imapserver[48];                 /*!< IMAP server address */
    char imapport[8];                    /*!< IMAP server port */
    char imapflags[128];                 /*!< IMAP optional flags */
    int imapversion;
    int interactive;
    char introfn[PATH_MAX];              /*!< Name of prepended file */
    unsigned int quota_limit;
    unsigned int quota_usage;
    struct vm_state *persist_vms;
#endif
};
 
#ifdef ODBC_STORAGE
static char odbc_database[80] = "asterisk";
static char odbc_table[80] = "voicemessages";
size_t odbc_table_len = sizeof(odbc_table);
#define COUNT(a, b) odbc_count_messages(a,b)
#define LAST_MSG_INDEX(a) odbc_last_message_index(a)
#define RETRIEVE(a,b,c,d) odbc_retrieve_message(a,b)
#define DISPOSE(a,b) odbc_remove_files(a,b)
#define STORE(a,b,c,d,e,f,g,h,i,j,k) odbc_store_message(a,b,c,d)
#define EXISTS(a,b,c,d) (odbc_message_exists(a,b))
#define RENAME(a,b,c,d,e,f,g,h) (odbc_rename_message(a,b,c,d,e,f))
#define COPY(a,b,c,d,e,f,g,h) (odbc_copy_message(a,b,c,d,e,f))
#define DELETE(a,b,c,d) (odbc_delete_message(a,b))
#define UPDATE_MSG_ID(a, b, c, d, e, f) (odbc_update_msg_id((a), (b), (c)))
#else
#ifdef IMAP_STORAGE
#define DISPOSE(a,b) (imap_remove_file(a,b))
#define STORE(a,b,c,d,e,f,g,h,i,j,k) (imap_store_file(a,b,c,d,e,f,g,h,i,j,k))
#define RETRIEVE(a,b,c,d) imap_retrieve_file(a,b,c,d)
#define EXISTS(a,b,c,d) (ast_fileexists(c,NULL,d) > 0)
#define RENAME(a,b,c,d,e,f,g,h) (rename_file(g,h));
#define COPY(a,b,c,d,e,f,g,h) (copy_file(g,h));
#define DELETE(a,b,c,d) (vm_imap_delete(a,b,d))
#define UPDATE_MSG_ID(a, b, c, d, e, f) (vm_imap_update_msg_id((a), (b), (c), (d), (e), (f)))
#else
#define COUNT(a, b) count_messages(a,b)
#define LAST_MSG_INDEX(a) last_message_index(a)
#define RETRIEVE(a,b,c,d)
#define DISPOSE(a,b)
#define STORE(a,b,c,d,e,f,g,h,i,j,k)
#define EXISTS(a,b,c,d) (ast_fileexists(c,NULL,d) > 0)
#define RENAME(a,b,c,d,e,f,g,h) (rename_file(g,h));
#define COPY(a,b,c,d,e,f,g,h) (copy_plain_file(g,h));
#define DELETE(a,b,c,d) (vm_delete(c))
#define UPDATE_MSG_ID(a, b, c, d, e, f)
#endif
#endif
 
static char VM_SPOOL_DIR[PATH_MAX];
 
static char ext_pass_cmd[128];
static char ext_pass_check_cmd[128];
 
static int my_umask;
 
#define PWDCHANGE_INTERNAL (1 << 1)
#define PWDCHANGE_EXTERNAL (1 << 2)
static int pwdchange = PWDCHANGE_INTERNAL;
 
#ifdef ODBC_STORAGE
#define tdesc "Comedian Mail (Voicemail System) with ODBC Storage"
#else
# ifdef IMAP_STORAGE
# define tdesc "Comedian Mail (Voicemail System) with IMAP Storage"
# else
# define tdesc "Comedian Mail (Voicemail System)"
# endif
#endif
 
static char userscontext[AST_MAX_EXTENSION] = "default";
 
static char *addesc = "Comedian Mail";
 
/* Leave a message */
static char *voicemail_app = "VoiceMail";
 
/* Check mail, control, etc */
static char *voicemailmain_app = "VoiceMailMain";
 
static char *vmauthenticate_app = "VMAuthenticate";
 
static char *playmsg_app = "VoiceMailPlayMsg";
 
static char *sayname_app = "VMSayName";
 
static AST_LIST_HEAD_STATIC(users, ast_vm_user);
static AST_LIST_HEAD_STATIC(zones, vm_zone);
static char zonetag[80];
static char locale[20];
static int maxsilence;
static int maxmsg = MAXMSG;
static int maxdeletedmsg;
static int silencethreshold = 128;
static char serveremail[80] = ASTERISK_USERNAME;
static char mailcmd[160] = SENDMAIL;    /* Configurable mail cmd */
static char externnotify[160];
static struct ast_smdi_interface *smdi_iface = NULL;
static char vmfmts[80] = "wav";
static double volgain;
static int vmminsecs;
static int vmmaxsecs;
static int maxgreet;
static int skipms = 3000;
static int maxlogins = 3;
static int minpassword = MINPASSWORD;
static int passwordlocation;
static char aliasescontext[MAX_VM_CONTEXT_LEN];
 
/*! Poll mailboxes for changes since there is something external to
 *  app_voicemail that may change them. */
static unsigned int poll_mailboxes;
 
/*! By default, poll every 30 seconds */
#define DEFAULT_POLL_FREQ 30
/*! Polling frequency */
static unsigned int poll_freq = DEFAULT_POLL_FREQ;
 
AST_MUTEX_DEFINE_STATIC(poll_lock);
static ast_cond_t poll_cond = PTHREAD_COND_INITIALIZER;
static pthread_t poll_thread = AST_PTHREADT_NULL;
static unsigned char poll_thread_run;
 
static struct ast_taskprocessor *mwi_subscription_tps;
 
struct alias_mailbox_mapping {
    char *alias;
    char *mailbox;
    char buf[0];
};
 
struct mailbox_alias_mapping {
    char *alias;
    char *mailbox;
    char buf[0];
};
 
#define MAPPING_BUCKETS 511
static struct ao2_container *alias_mailbox_mappings;
AO2_STRING_FIELD_HASH_FN(alias_mailbox_mapping, alias);
AO2_STRING_FIELD_CMP_FN(alias_mailbox_mapping, alias);
 
static struct ao2_container *mailbox_alias_mappings;
AO2_STRING_FIELD_HASH_FN(mailbox_alias_mapping, mailbox);
AO2_STRING_FIELD_CMP_FN(mailbox_alias_mapping, mailbox);
 
/* custom audio control prompts for voicemail playback */
static char listen_control_forward_key[12];
static char listen_control_reverse_key[12];
static char listen_control_pause_key[12];
static char listen_control_restart_key[12];
static char listen_control_stop_key[12];
 
/* custom password sounds */
static char vm_login[80] = "vm-login";
static char vm_newuser[80] = "vm-newuser";
static char vm_password[80] = "vm-password";
static char vm_newpassword[80] = "vm-newpassword";
static char vm_passchanged[80] = "vm-passchanged";
static char vm_reenterpassword[80] = "vm-reenterpassword";
static char vm_mismatch[80] = "vm-mismatch";
static char vm_invalid_password[80] = "vm-invalid-password";
static char vm_pls_try_again[80] = "vm-pls-try-again";
 
/*
 * XXX If we have the time, motivation, etc. to fix up this prompt, one of the following would be appropriate:
 * 1. create a sound along the lines of "Please try again.  When done, press the pound key" which could be spliced
 * from existing sound clips.  This would require some programming changes in the area of vm_forward options and also
 * app.c's __ast_play_and_record function
 * 2. create a sound prompt saying "Please try again.  When done recording, press any key to stop and send the prepended
 * message."  At the time of this comment, I think this would require new voice work to be commissioned.
 * 3. Something way different like providing instructions before a time out or a post-recording menu.  This would require
 * more effort than either of the other two.
 */
static char vm_prepend_timeout[80] = "vm-then-pound";
 
static struct ast_flags globalflags = {0};
 
static int saydurationminfo = 2;
 
static char dialcontext[AST_MAX_CONTEXT] = "";
static char callcontext[AST_MAX_CONTEXT] = "";
static char exitcontext[AST_MAX_CONTEXT] = "";
 
static char cidinternalcontexts[MAX_NUM_CID_CONTEXTS][64];
 
 
static char *emailbody;
static char *emailsubject;
static char *pagerbody;
static char *pagersubject;
static char fromstring[100];
static char pagerfromstring[100];
static char charset[32] = "ISO-8859-1";
 
static unsigned char adsifdn[4] = "\x00\x00\x00\x0F";
static unsigned char adsisec[4] = "\x9B\xDB\xF7\xAC";
static int adsiver = 1;
static char emaildateformat[32] = "%A, %B %d, %Y at %r";
static char pagerdateformat[32] = "%A, %B %d, %Y at %r";
 
/* Forward declarations - generic */
static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box);
static int close_mailbox(struct vm_state *vms, struct ast_vm_user *vmu);
static int advanced_options(struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int msg, int option, signed char record_gain);
static int dialout(struct ast_channel *chan, struct ast_vm_user *vmu, char *num, char *outgoing_context);
static int play_record_review(struct ast_channel *chan, char *playfile, char *recordfile, int maxtime,
            char *fmt, int outsidecaller, struct ast_vm_user *vmu, int *duration, int *sound_duration, const char *unlockdir,
            signed char record_gain, struct vm_state *vms, char *flag, const char *msg_id, int forwardintro);
static int vm_tempgreeting(struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, char *fmtc, signed char record_gain);
static int vm_play_folder_name(struct ast_channel *chan, char *mbox);
static int notify_new_message(struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, int msgnum, long duration, char *fmt, char *cidnum, char *cidname, const char *flag);
static void make_email_file(FILE *p, char *srcemail, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, char *attach, char *attach2, char *format, int duration, int attach_user_voicemail, struct ast_channel *chan, const char *category, int imap, const char *flag, const char *msg_id);
static void apply_options(struct ast_vm_user *vmu, const char *options);
static int add_email_attachment(FILE *p, struct ast_vm_user *vmu, char *format, char *attach, char *greeting_attachment, char *mailbox, char *bound, char *filename, int last, int msgnum);
static int is_valid_dtmf(const char *key);
static void read_password_from_file(const char *secretfn, char *password, int passwordlen);
static int write_password_to_file(const char *secretfn, const char *password);
static const char *substitute_escapes(const char *value);
static int message_range_and_existence_check(struct vm_state *vms, const char *msg_ids [], size_t num_msgs, int *msg_nums, struct ast_vm_user *vmu);
static void notify_new_state(struct ast_vm_user *vmu);
static int append_vmu_info_astman(struct mansession *s, struct ast_vm_user *vmu, const char* event_name, const char* actionid);
static int append_vmbox_info_astman(struct mansession *s, const struct message *m, struct ast_vm_user *vmu, const char* event_name, const char* actionid);
 
 
/*!
 * Place a message in the indicated folder
 *
 * \param vmu Voicemail user
 * \param vms Current voicemail state for the user
 * \param msg The message number to save
 * \param box The folder into which the message should be saved
 * \param[out] newmsg The new message number of the saved message
 * \param move Tells whether to copy or to move the message
 *
 * \note the "move" parameter is only honored for IMAP voicemail presently
 * \retval 0 Success
 * \retval other Failure
 */
static int save_to_folder(struct ast_vm_user *vmu, struct vm_state *vms, int msg, int box, int *newmsg, int move);
 
static struct ast_vm_mailbox_snapshot *vm_mailbox_snapshot_create(const char *mailbox, const char *context, const char *folder, int descending, enum ast_vm_snapshot_sort_val sort_val, int combine_INBOX_and_OLD);
static struct ast_vm_mailbox_snapshot *vm_mailbox_snapshot_destroy(struct ast_vm_mailbox_snapshot *mailbox_snapshot);
 
static int vm_msg_forward(const char *from_mailbox, const char *from_context, const char *from_folder, const char *to_mailbox, const char *to_context, const char *to_folder, size_t num_msgs, const char *msg_ids[], int delete_old);
static int vm_msg_move(const char *mailbox, const char *context, size_t num_msgs, const char *oldfolder, const char *old_msg_ids[], const char *newfolder);
static int vm_msg_remove(const char *mailbox, const char *context, size_t num_msgs, const char *folder, const char *msgs[]);
static int vm_msg_play(struct ast_channel *chan, const char *mailbox, const char *context, const char *folder, const char *msg_num, ast_vm_msg_play_cb cb);
 
#ifdef TEST_FRAMEWORK
static int vm_test_destroy_user(const char *context, const char *mailbox);
static int vm_test_create_user(const char *context, const char *mailbox);
#endif
 
/*!
 * \internal
 * \brief Parse the given mailbox_id into mailbox and context.
 * \since 12.0.0
 *
 * \param mailbox_id The mailbox\@context string to separate.
 * \param mailbox Where the mailbox part will start.
 * \param context Where the context part will start.  ("default" if not present)
 *
 * \retval 0 on success.
 * \retval -1 on error.
 */
static int separate_mailbox(char *mailbox_id, char **mailbox, char **context)
{
    if (ast_strlen_zero(mailbox_id) || !mailbox || !context) {
        return -1;
    }
    *context = mailbox_id;
    *mailbox = strsep(context, "@");
    if (ast_strlen_zero(*mailbox)) {
        return -1;
    }
    if (ast_strlen_zero(*context)) {
        *context = "default";
    }
    return 0;
}
 
struct ao2_container *inprocess_container;
 
struct inprocess {
    int count;
    char *context;
    char mailbox[0];
};
 
static int inprocess_hash_fn(const void *obj, const int flags)
{
    const struct inprocess *i = obj;
    return atoi(i->mailbox);
}
 
static int inprocess_cmp_fn(void *obj, void *arg, int flags)
{
    struct inprocess *i = obj, *j = arg;
    if (strcmp(i->mailbox, j->mailbox)) {
        return 0;
    }
    return !strcmp(i->context, j->context) ? CMP_MATCH : 0;
}
 
static int inprocess_count(const char *context, const char *mailbox, int delta)
{
    int context_len = strlen(context) + 1;
    int mailbox_len = strlen(mailbox) + 1;
    struct inprocess *i, *arg = ast_alloca(sizeof(*arg) + context_len + mailbox_len);
    arg->context = arg->mailbox + mailbox_len;
    ast_copy_string(arg->mailbox, mailbox, mailbox_len); /* SAFE */
    ast_copy_string(arg->context, context, context_len); /* SAFE */
    ao2_lock(inprocess_container);
    if ((i = ao2_find(inprocess_container, arg, 0))) {
        int ret = ast_atomic_fetchadd_int(&i->count, delta);
        ao2_unlock(inprocess_container);
        ao2_ref(i, -1);
        return ret;
    }
    if (delta < 0) {
        ast_log(LOG_WARNING, "BUG: ref count decrement on non-existing object???\n");
    }
    if (!(i = ao2_alloc(sizeof(*i) + context_len + mailbox_len, NULL))) {
        ao2_unlock(inprocess_container);
        return 0;
    }
    i->context = i->mailbox + mailbox_len;
    ast_copy_string(i->mailbox, mailbox, mailbox_len); /* SAFE */
    ast_copy_string(i->context, context, context_len); /* SAFE */
    i->count = delta;
    ao2_link(inprocess_container, i);
    ao2_unlock(inprocess_container);
    ao2_ref(i, -1);
    return 0;
}
 
#if !(defined(ODBC_STORAGE) || defined(IMAP_STORAGE))
static int __has_voicemail(const char *context, const char *mailbox, const char *folder, int shortcircuit);
#endif
 
/*!
 * \brief Strips control and non 7-bit clean characters from input string.
 *
 * \note To map control and none 7-bit characters to a 7-bit clean characters
 *  please use ast_str_encode_mine().
 */
static char *strip_control_and_high(const char *input, char *buf, size_t buflen)
{
    char *bufptr = buf;
    for (; *input; input++) {
        if (*input < 32) {
            continue;
        }
        *bufptr++ = *input;
        if (bufptr == buf + buflen - 1) {
            break;
        }
    }
    *bufptr = '\0';
    return buf;
}
 
/*
 * These macros are currently only used by the ODBC code but
 * should be used anyplace we're allocating a PATH_MAX
 * sized buffer for something which will be much smaller
 * in practice.
 */
#ifdef ODBC_STORAGE
/*!
 * \internal
 * \brief Get the length needed for a message path base.
 *
 * \param dir The absolute path to a directory
 *
 * \note The directory provided should include all components
 * down to the folder level.  For example:
 *  /var/spool/asterisk/voicemail/default/1234/INBOX
 *
 * \returns Number of bytes needed for the message path base.
 */
static size_t get_msg_path_len(const char *dir)
{
    if (ast_strlen_zero(dir)) {
        return 0;
    }
    /* dir + '/' + MSGFILE_LEN + '\0' */
    return strlen(dir) + 1 + MSGFILE_LEN + 1;
}
 
/*
 * The longest sound file extension we currently
 * have is "siren14" which is 7 characters long
 * but we'll make this 12 to be extra safe.
 */
#define MAX_SOUND_EXTEN_LEN 12
/*!
 * \internal
 * \brief Get the length needed for a message sound or metadata file path.
 *
 * \param dir The absolute path to a directory
 *
 * \note The directory provided should include all components
 * down to the folder level.  For example:
 *  /var/spool/asterisk/voicemail/default/1234/INBOX
 *
 * \returns Number of bytes needed for the message sound or metadata file path.
 */
static size_t get_msg_path_ext_len(const char *dir)
{
    if (ast_strlen_zero(dir)) {
        return 0;
    }
    /* dir + '/' + MSGFILE_LEN + extlen(including '.') + '\0' */
    return strlen(dir) + 1 + MSGFILE_LEN + MAX_SOUND_EXTEN_LEN + 1;
}
 
/*!
 * \internal
 * \brief Allocate a buffer on the stack containing a message file path base.
 *
 * \param dir The absolute path to a directory
 * \param msgnum The message number or -1 for a prompt file
 *
 * \note The returned buffer will automatically be freed when it
 * goes out of scope.
 *
 * If passed (/var/spool/asterisk/voicemail/default/1234/INBOX, 0)
 * the returned path would be:
 * /var/spool/asterisk/voicemail/default/1234/INBOX/msg0000
 *
 * If passed (/var/spool/asterisk/voicemail/default/1234/unavail, -1)
 * the returned path would be:
 * /var/spool/asterisk/voicemail/default/1234/unavail
 * (no change)
 *
 * \returns A pointer to the buffer containing the path.
 */
#define MAKE_FILE_PTRA(dir, msgnum) \
({ \
    size_t __len = get_msg_path_len(dir); \
    char *__var; \
    if (msgnum < 0) { \
        __var = ast_strdupa(dir); \
    } else { \
        __var = ast_alloca(__len); \
        snprintf(__var, __len, "%s/msg%04d", dir, msgnum); \
    } \
    __var; \
})
 
/*!
 * \internal
 * \brief Allocate a buffer on the stack for a message sound or metadata file path.
 *
 * \param dir The absolute path to a directory
 * \param msgnum The message number or -1 for a prompt file
 *
 * \note The returned buffer will automatically be freed when it
 * goes out of scope.
 *
 * If passed (/var/spool/asterisk/voicemail/default/1234/INBOX, 0, "txt")
 * the returned path would be:
 * /var/spool/asterisk/voicemail/default/1234/INBOX/msg0000.txt
 *
 * If passed (/var/spool/asterisk/voicemail/default/1234/unavail, -1, "WAV")
 * the returned path would be:
 * /var/spool/asterisk/voicemail/default/1234/unavail.WAV
 *
 * The buffer returned has enough space that you can safely re-use it
 * for other sound file extensions.  For instance:
 *
 *  char *fn = MAKE_FILE_PTRA(dir, msgnum);
 *  char *full_fn = MAKE_FILE_EXT_PTRA(dir, msgnum, "txt");
 *  char *fmt = "g722";
 *  ...do domething with full_fn then re-use it...
 *  sprintf(full_fn, "%s.%s", fn, fmt); * Safe since the same dir and msgnum were used *
 *
 * \returns A pointer to the allocated buffer
 */
#define MAKE_FILE_EXT_PTRA(dir, msgnum, ext) \
({ \
    size_t __len = get_msg_path_ext_len(dir); \
    char *__var = ast_alloca(__len); \
    if (msgnum < 0) { \
        snprintf(__var, __len, "%s.%s", dir, ext); \
    } else { \
        snprintf(__var, __len, "%s/msg%04d.%s", dir, msgnum, ext); \
    } \
    __var; \
})
#endif
 
/*!
 * \brief Sets default voicemail system options to a voicemail user.
 *
 * This applies select global settings to a newly created (dynamic) instance of a voicemail user.
 * - all the globalflags
 * - the saydurationminfo
 * - the callcontext
 * - the dialcontext
 * - the exitcontext
 * - vmmaxsecs, vmmaxmsg, maxdeletedmsg
 * - volume gain.
 * - emailsubject, emailbody set to NULL
 */
static void populate_defaults(struct ast_vm_user *vmu)
{
    ast_copy_flags(vmu, (&globalflags), AST_FLAGS_ALL);
    vmu->passwordlocation = passwordlocation;
    if (saydurationminfo) {
        vmu->saydurationm = saydurationminfo;
    }
    ast_copy_string(vmu->callback, callcontext, sizeof(vmu->callback));
    ast_copy_string(vmu->dialout, dialcontext, sizeof(vmu->dialout));
    ast_copy_string(vmu->exit, exitcontext, sizeof(vmu->exit));
    ast_copy_string(vmu->zonetag, zonetag, sizeof(vmu->zonetag));
    ast_copy_string(vmu->locale, locale, sizeof(vmu->locale));
    if (vmminsecs) {
        vmu->minsecs = vmminsecs;
    }
    if (vmmaxsecs) {
        vmu->maxsecs = vmmaxsecs;
    }
    if (maxmsg) {
        vmu->maxmsg = maxmsg;
    }
    if (maxdeletedmsg) {
        vmu->maxdeletedmsg = maxdeletedmsg;
    }
    vmu->volgain = volgain;
    ast_free(vmu->email);
    vmu->email = NULL;
    ast_free(vmu->emailsubject);
    vmu->emailsubject = NULL;
    ast_free(vmu->emailbody);
    vmu->emailbody = NULL;
#ifdef IMAP_STORAGE
    ast_copy_string(vmu->imapfolder, imapfolder, sizeof(vmu->imapfolder));
    ast_copy_string(vmu->imapserver, imapserver, sizeof(vmu->imapserver));
    ast_copy_string(vmu->imapport, imapport, sizeof(vmu->imapport));
    ast_copy_string(vmu->imapflags, imapflags, sizeof(vmu->imapflags));
#endif
}
 
/*!
 * \brief Sets a specific property value.
 * \param vmu The voicemail user object to work with.
 * \param var The name of the property to be set.
 * \param value The value to be set to the property.
 *
 * The property name must be one of the understood properties. See the source for details.
 */
static void apply_option(struct ast_vm_user *vmu, const char *var, const char *value)
{
    int x;
    if (!strcasecmp(var, "attach")) {
        ast_set2_flag(vmu, ast_true(value), VM_ATTACH);
    } else if (!strcasecmp(var, "attachfmt")) {
        ast_copy_string(vmu->attachfmt, value, sizeof(vmu->attachfmt));
    } else if (!strcasecmp(var, "attachextrecs")) {
        ast_set2_flag(vmu, ast_true(value), VM_EMAIL_EXT_RECS);
    } else if (!strcasecmp(var, "serveremail")) {
        ast_copy_string(vmu->serveremail, value, sizeof(vmu->serveremail));
    } else if (!strcasecmp(var, "fromstring")) {
        ast_copy_string(vmu->fromstring, value, sizeof(vmu->fromstring));
    } else if (!strcasecmp(var, "emailbody")) {
        ast_free(vmu->emailbody);
        vmu->emailbody = ast_strdup(substitute_escapes(value));
    } else if (!strcasecmp(var, "emailsubject")) {
        ast_free(vmu->emailsubject);
        vmu->emailsubject = ast_strdup(substitute_escapes(value));
    } else if (!strcasecmp(var, "language")) {
        ast_copy_string(vmu->language, value, sizeof(vmu->language));
    } else if (!strcasecmp(var, "tz")) {
        ast_copy_string(vmu->zonetag, value, sizeof(vmu->zonetag));
    } else if (!strcasecmp(var, "locale")) {
        ast_copy_string(vmu->locale, value, sizeof(vmu->locale));
#ifdef IMAP_STORAGE
    } else if (!strcasecmp(var, "imapuser")) {
        ast_copy_string(vmu->imapuser, value, sizeof(vmu->imapuser));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imapserver")) {
        ast_copy_string(vmu->imapserver, value, sizeof(vmu->imapserver));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imapport")) {
        ast_copy_string(vmu->imapport, value, sizeof(vmu->imapport));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imapflags")) {
        ast_copy_string(vmu->imapflags, value, sizeof(vmu->imapflags));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imappassword") || !strcasecmp(var, "imapsecret")) {
        ast_copy_string(vmu->imappassword, value, sizeof(vmu->imappassword));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imapfolder")) {
        ast_copy_string(vmu->imapfolder, value, sizeof(vmu->imapfolder));
        vmu->imapversion = imapversion;
    } else if (!strcasecmp(var, "imapvmshareid")) {
        ast_copy_string(vmu->imapvmshareid, value, sizeof(vmu->imapvmshareid));
        vmu->imapversion = imapversion;
#endif
    } else if (!strcasecmp(var, "delete") || !strcasecmp(var, "deletevoicemail")) {
        ast_set2_flag(vmu, ast_true(value), VM_DELETE);
    } else if (!strcasecmp(var, "saycid")){
        ast_set2_flag(vmu, ast_true(value), VM_SAYCID);
    } else if (!strcasecmp(var, "sendvoicemail")){
        ast_set2_flag(vmu, ast_true(value), VM_SVMAIL);
    } else if (!strcasecmp(var, "review")){
        ast_set2_flag(vmu, ast_true(value), VM_REVIEW);
    } else if (!strcasecmp(var, "leaveurgent")){
        ast_set2_flag(vmu, ast_true(value), VM_MARK_URGENT);
    } else if (!strcasecmp(var, "tempgreetwarn")){
        ast_set2_flag(vmu, ast_true(value), VM_TEMPGREETWARN);
    } else if (!strcasecmp(var, "messagewrap")){
        ast_set2_flag(vmu, ast_true(value), VM_MESSAGEWRAP);
    } else if (!strcasecmp(var, "operator")) {
        ast_set2_flag(vmu, ast_true(value), VM_OPERATOR);
    } else if (!strcasecmp(var, "envelope")){
        ast_set2_flag(vmu, ast_true(value), VM_ENVELOPE);
    } else if (!strcasecmp(var, "moveheard")){
        ast_set2_flag(vmu, ast_true(value), VM_MOVEHEARD);
    } else if (!strcasecmp(var, "sayduration")){
        ast_set2_flag(vmu, ast_true(value), VM_SAYDURATION);
    } else if (!strcasecmp(var, "saydurationm")){
        if (sscanf(value, "%30d", &x) == 1) {
            vmu->saydurationm = x;
        } else {
            ast_log(AST_LOG_WARNING, "Invalid min duration for say duration\n");
        }
    } else if (!strcasecmp(var, "forcename")){
        ast_set2_flag(vmu, ast_true(value), VM_FORCENAME);
    } else if (!strcasecmp(var, "forcegreetings")){
        ast_set2_flag(vmu, ast_true(value), VM_FORCEGREET);
    } else if (!strcasecmp(var, "callback")) {
        ast_copy_string(vmu->callback, value, sizeof(vmu->callback));
    } else if (!strcasecmp(var, "dialout")) {
        ast_copy_string(vmu->dialout, value, sizeof(vmu->dialout));
    } else if (!strcasecmp(var, "exitcontext")) {
        ast_copy_string(vmu->exit, value, sizeof(vmu->exit));
    } else if (!strcasecmp(var, "minsecs")) {
        if (sscanf(value, "%30d", &x) == 1 && x >= 0) {
            vmu->minsecs = x;
        } else {
            ast_log(LOG_WARNING, "Invalid min message length of %s. Using global value %d\n", value, vmminsecs);
            vmu->minsecs = vmminsecs;
        }
    } else if (!strcasecmp(var, "maxmessage") || !strcasecmp(var, "maxsecs")) {
        vmu->maxsecs = atoi(value);
        if (vmu->maxsecs <= 0) {
            ast_log(AST_LOG_WARNING, "Invalid max message length of %s. Using global value %d\n", value, vmmaxsecs);
            vmu->maxsecs = vmmaxsecs;
        } else {
            vmu->maxsecs = atoi(value);
        }
        if (!strcasecmp(var, "maxmessage"))
            ast_log(AST_LOG_WARNING, "Option 'maxmessage' has been deprecated in favor of 'maxsecs'.  Please make that change in your voicemail config.\n");
    } else if (!strcasecmp(var, "maxmsg")) {
        vmu->maxmsg = atoi(value);
        /* Accept maxmsg=0 (Greetings only voicemail) */
        if (vmu->maxmsg < 0) {
            ast_log(AST_LOG_WARNING, "Invalid number of messages per folder maxmsg=%s. Using default value %d\n", value, MAXMSG);
            vmu->maxmsg = MAXMSG;
        } else if (vmu->maxmsg > MAXMSGLIMIT) {
            ast_log(AST_LOG_WARNING, "Maximum number of messages per folder is %d. Cannot accept value maxmsg=%s\n", MAXMSGLIMIT, value);
            vmu->maxmsg = MAXMSGLIMIT;
        }
    } else if (!strcasecmp(var, "nextaftercmd")) {
        ast_set2_flag(vmu, ast_true(value), VM_SKIPAFTERCMD);
    } else if (!strcasecmp(var, "backupdeleted")) {
        if (sscanf(value, "%30d", &x) == 1)
            vmu->maxdeletedmsg = x;
        else if (ast_true(value))
            vmu->maxdeletedmsg = MAXMSG;
        else
            vmu->maxdeletedmsg = 0;
 
        if (vmu->maxdeletedmsg < 0) {
            ast_log(AST_LOG_WARNING, "Invalid number of deleted messages saved per mailbox backupdeleted=%s. Using default value %d\n", value, MAXMSG);
            vmu->maxdeletedmsg = MAXMSG;
        } else if (vmu->maxdeletedmsg > MAXMSGLIMIT) {
            ast_log(AST_LOG_WARNING, "Maximum number of deleted messages saved per mailbox is %d. Cannot accept value backupdeleted=%s\n", MAXMSGLIMIT, value);
            vmu->maxdeletedmsg = MAXMSGLIMIT;
        }
    } else if (!strcasecmp(var, "volgain")) {
        sscanf(value, "%30lf", &vmu->volgain);
    } else if (!strcasecmp(var, "passwordlocation")) {
        if (!strcasecmp(value, "spooldir")) {
            vmu->passwordlocation = OPT_PWLOC_SPOOLDIR;
        } else {
            vmu->passwordlocation = OPT_PWLOC_VOICEMAILCONF;
        }
    } else if (!strcasecmp(var, "options")) {
        apply_options(vmu, value);
    }
}
 
static char *vm_check_password_shell(char *command, char *buf, size_t len)
{
    int fds[2], pid = 0;
 
    memset(buf, 0, len);
 
    if (pipe(fds)) {
        snprintf(buf, len, "FAILURE: Pipe failed: %s", strerror(errno));
    } else {
        /* good to go*/
        pid = ast_safe_fork(0);
 
        if (pid < 0) {
            /* ok maybe not */
            close(fds[0]);
            close(fds[1]);
            snprintf(buf, len, "FAILURE: Fork failed");
        } else if (pid) {
            /* parent */
            close(fds[1]);
            if (read(fds[0], buf, len) < 0) {
                ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno));
            }
            close(fds[0]);
        } else {
            /*  child */
            AST_DECLARE_APP_ARGS(arg,
                AST_APP_ARG(v)[20];
            );
            char *mycmd = ast_strdupa(command);
 
            close(fds[0]);
            dup2(fds[1], STDOUT_FILENO);
            close(fds[1]);
            ast_close_fds_above_n(STDOUT_FILENO);
 
            AST_NONSTANDARD_APP_ARGS(arg, mycmd, ' ');
 
            execv(arg.v[0], arg.v);
            printf("FAILURE: %s", strerror(errno));
            _exit(0);
        }
    }
    return buf;
}
 
/*!
 * \brief Check that password meets minimum required length
 * \param vmu The voicemail user to change the password for.
 * \param password The password string to check
 *
 * \return zero on ok, 1 on not ok.
 */
static int check_password(struct ast_vm_user *vmu, char *password)
{
    /* check minimum length */
    if (strlen(password) < minpassword)
        return 1;
    /* check that password does not contain '*' character */
    if (!ast_strlen_zero(password) && password[0] == '*')
        return 1;
    if (!ast_strlen_zero(ext_pass_check_cmd)) {
        char cmd[255], buf[255];
 
        ast_debug(1, "Verify password policies for %s\n", password);
 
        snprintf(cmd, sizeof(cmd), "%s %s %s %s %s", ext_pass_check_cmd, vmu->mailbox, vmu->context, vmu->password, password);
        if (vm_check_password_shell(cmd, buf, sizeof(buf))) {
            ast_debug(5, "Result: %s\n", buf);
            if (!strncasecmp(buf, "VALID", 5)) {
                ast_debug(3, "Passed password check: '%s'\n", buf);
                return 0;
            } else if (!strncasecmp(buf, "FAILURE", 7)) {
                ast_log(AST_LOG_WARNING, "Unable to execute password validation script: '%s'.\n", buf);
                return 0;
            } else {
                ast_log(AST_LOG_NOTICE, "Password doesn't match policies for user %s %s\n", vmu->mailbox, password);
                return 1;
            }
        }
    }
    return 0;
}
 
/*!
 * \brief Performs a change of the voicemail passowrd in the realtime engine.
 * \param vmu The voicemail user to change the password for.
 * \param password The new value to be set to the password for this user.
 *
 * This only works if there is a realtime engine configured.
 * This is called from the (top level) vm_change_password.
 *
 * \return zero on success, -1 on error.
 */
static int change_password_realtime(struct ast_vm_user *vmu, const char *password)
{
    int res = -1;
    if (!strcmp(vmu->password, password)) {
        /* No change (but an update would return 0 rows updated, so we opt out here) */
        return 0;
    }
 
    if (strlen(password) > 10) {
        ast_realtime_require_field("voicemail", "password", RQ_CHAR, strlen(password), SENTINEL);
    }
    if (ast_update2_realtime("voicemail", "context", vmu->context, "mailbox", vmu->mailbox, SENTINEL, "password", password, SENTINEL) > 0) {
        ast_test_suite_event_notify("PASSWORDCHANGED", "Message: realtime engine updated with new password\r\nPasswordSource: realtime");
        ast_copy_string(vmu->password, password, sizeof(vmu->password));
        res = 0;
    }
    return res;
}
 
/*!
 * \brief Destructively Parse options and apply.
 */
static void apply_options(struct ast_vm_user *vmu, const char *options)
{
    char *stringp;
    char *s;
    char *var, *value;
    stringp = ast_strdupa(options);
    while ((s = strsep(&stringp, "|"))) {
        value = s;
        if ((var = strsep(&value, "=")) && value) {
            apply_option(vmu, var, value);
        }
    }
}
 
/*!
 * \brief Loads the options specific to a voicemail user.
 *
 * This is called when a vm_user structure is being set up, such as from load_options.
 */
static void apply_options_full(struct ast_vm_user *retval, struct ast_variable *var)
{
    for (; var; var = var->next) {
        if (!strcasecmp(var->name, "vmsecret")) {
            ast_copy_string(retval->password, var->value, sizeof(retval->password));
        } else if (!strcasecmp(var->name, "secret") || !strcasecmp(var->name, "password")) { /* don't overwrite vmsecret if it exists */
            if (ast_strlen_zero(retval->password)) {
                if (!ast_strlen_zero(var->value) && var->value[0] == '*') {
                    ast_log(LOG_WARNING, "Invalid password detected for mailbox %s.  The password"
                        "\n\tmust be reset in voicemail.conf.\n", retval->mailbox);
                } else {
                    ast_copy_string(retval->password, var->value, sizeof(retval->password));
                }
            }
        } else if (!strcasecmp(var->name, "uniqueid")) {
            ast_copy_string(retval->uniqueid, var->value, sizeof(retval->uniqueid));
        } else if (!strcasecmp(var->name, "pager")) {
            ast_copy_string(retval->pager, var->value, sizeof(retval->pager));
        } else if (!strcasecmp(var->name, "email")) {
            ast_free(retval->email);
            retval->email = ast_strdup(var->value);
        } else if (!strcasecmp(var->name, "fullname")) {
            ast_copy_string(retval->fullname, var->value, sizeof(retval->fullname));
        } else if (!strcasecmp(var->name, "context")) {
            ast_copy_string(retval->context, var->value, sizeof(retval->context));
        } else if (!strcasecmp(var->name, "emailsubject")) {
            ast_free(retval->emailsubject);
            retval->emailsubject = ast_strdup(substitute_escapes(var->value));
        } else if (!strcasecmp(var->name, "emailbody")) {
            ast_free(retval->emailbody);
            retval->emailbody = ast_strdup(substitute_escapes(var->value));
#ifdef IMAP_STORAGE
        } else if (!strcasecmp(var->name, "imapuser")) {
            ast_copy_string(retval->imapuser, var->value, sizeof(retval->imapuser));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imapserver")) {
            ast_copy_string(retval->imapserver, var->value, sizeof(retval->imapserver));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imapport")) {
            ast_copy_string(retval->imapport, var->value, sizeof(retval->imapport));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imapflags")) {
            ast_copy_string(retval->imapflags, var->value, sizeof(retval->imapflags));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imappassword") || !strcasecmp(var->name, "imapsecret")) {
            ast_copy_string(retval->imappassword, var->value, sizeof(retval->imappassword));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imapfolder")) {
            ast_copy_string(retval->imapfolder, var->value, sizeof(retval->imapfolder));
            retval->imapversion = imapversion;
        } else if (!strcasecmp(var->name, "imapvmshareid")) {
            ast_copy_string(retval->imapvmshareid, var->value, sizeof(retval->imapvmshareid));
            retval->imapversion = imapversion;
#endif
        } else
            apply_option(retval, var->name, var->value);
    }
}
 
/*!
 * \brief Determines if a DTMF key entered is valid.
 * \param key The character to be compared. expects a single character. Though is capable of handling a string, this is internally copies using ast_strdupa.
 *
 * Tests the character entered against the set of valid DTMF characters.
 * \return 1 if the character entered is a valid DTMF digit, 0 if the character is invalid.
 */
static int is_valid_dtmf(const char *key)
{
    int i;
    char *local_key = ast_strdupa(key);
 
    for (i = 0; i < strlen(key); ++i) {
        if (!strchr(VALID_DTMF, *local_key)) {
            ast_log(AST_LOG_WARNING, "Invalid DTMF key \"%c\" used in voicemail configuration file\n", *local_key);
            return 0;
        }
        local_key++;
    }
    return 1;
}
 
/*!
 * \brief Finds a voicemail user from the realtime engine.
 * \param ivm
 * \param context
 * \param mailbox
 *
 * This is called as a fall through case when the normal find_user() was not able to find a user. That is, the default it so look in the usual voicemail users file first.
 *
 * \return The ast_vm_user structure for the user that was found.
 */
static struct ast_vm_user *find_user_realtime(struct ast_vm_user *ivm, const char *context, const char *mailbox)
{
    struct ast_variable *var;
    struct ast_vm_user *retval;
 
    if ((retval = (ivm ? ivm : ast_calloc(1, sizeof(*retval))))) {
        if (ivm) {
            memset(retval, 0, sizeof(*retval));
        }
        populate_defaults(retval);
        if (!ivm) {
            ast_set_flag(retval, VM_ALLOCED);
        }
        if (mailbox) {
            ast_copy_string(retval->mailbox, mailbox, sizeof(retval->mailbox));
        }
        if (!context && ast_test_flag((&globalflags), VM_SEARCH)) {
            var = ast_load_realtime("voicemail", "mailbox", mailbox, SENTINEL);
        } else {
            var = ast_load_realtime("voicemail", "mailbox", mailbox, "context", context, SENTINEL);
        }
        if (var) {
            apply_options_full(retval, var);
            ast_variables_destroy(var);
        } else {
            if (!ivm)
                ast_free(retval);
            retval = NULL;
        }
    }
    return retval;
}
 
/*!
 * \brief Finds a voicemail user from the users file or the realtime engine.
 * \param ivm
 * \param context
 * \param mailbox
 *
 * \return The ast_vm_user structure for the user that was found.
 */
static struct ast_vm_user *find_user(struct ast_vm_user *ivm, const char *context, const char *mailbox)
{
    /* This function could be made to generate one from a database, too */
    struct ast_vm_user *vmu = NULL, *cur;
    AST_LIST_LOCK(&users);
 
    if (!context && !ast_test_flag((&globalflags), VM_SEARCH))
        context = "default";
 
    AST_LIST_TRAVERSE(&users, cur, list) {
#ifdef IMAP_STORAGE
        if (cur->imapversion != imapversion) {
            continue;
        }
#endif
        if (ast_test_flag((&globalflags), VM_SEARCH) && !strcasecmp(mailbox, cur->mailbox))
            break;
        if (context && (!strcasecmp(context, cur->context)) && (!strcasecmp(mailbox, cur->mailbox)))
            break;
    }
    if (cur) {
        /* Make a copy, so that on a reload, we have no race */
        if ((vmu = (ivm ? ivm : ast_calloc(1, sizeof(*vmu))))) {
            ast_free(vmu->email);
            ast_free(vmu->emailbody);
            ast_free(vmu->emailsubject);
            *vmu = *cur;
            vmu->email = ast_strdup(cur->email);
            vmu->emailbody = ast_strdup(cur->emailbody);
            vmu->emailsubject = ast_strdup(cur->emailsubject);
            ast_set2_flag(vmu, !ivm, VM_ALLOCED);
            AST_LIST_NEXT(vmu, list) = NULL;
        }
    }
    AST_LIST_UNLOCK(&users);
    if (!vmu) {
        vmu = find_user_realtime(ivm, context, mailbox);
    }
    if (!vmu && !ast_strlen_zero(aliasescontext)) {
        struct alias_mailbox_mapping *mapping;
        char *search_string = ast_alloca(MAX_VM_MAILBOX_LEN);
 
        snprintf(search_string, MAX_VM_MAILBOX_LEN, "%s%s%s",
            mailbox,
            ast_strlen_zero(context) ? "" : "@",
            S_OR(context, ""));
 
        mapping = ao2_find(alias_mailbox_mappings, search_string, OBJ_SEARCH_KEY);
        if (mapping) {
            char *search_mailbox = NULL;
            char *search_context = NULL;
 
            separate_mailbox(ast_strdupa(mapping->mailbox), &search_mailbox, &search_context);
            ao2_ref(mapping, -1);
            vmu = find_user(ivm, search_mailbox, search_context);
        }
    }
 
    return vmu;
}
 
/*!
 * \brief Resets a user password to a specified password.
 * \param context
 * \param mailbox
 * \param newpass
 *
 * This does the actual change password work, called by the vm_change_password() function.
 *
 * \return zero on success, -1 on error.
 */
static int reset_user_pw(const char *context, const char *mailbox, const char *newpass)
{
    /* This function could be made to generate one from a database, too */
    struct ast_vm_user *cur;
    int res = -1;
    AST_LIST_LOCK(&users);
    AST_LIST_TRAVERSE(&users, cur, list) {
        if ((!context || !strcasecmp(context, cur->context)) &&
            (!strcasecmp(mailbox, cur->mailbox)))
                break;
    }
    if (cur) {
        ast_copy_string(cur->password, newpass, sizeof(cur->password));
        res = 0;
    }
    AST_LIST_UNLOCK(&users);
    if (!res) {
        struct ast_json *json_object;
 
        json_object = ast_json_pack("{s: s, s: s, s: s}",
            "Context", S_OR(context, "default"),
            "Mailbox", mailbox,
            "NewPassword", newpass);
        ast_manager_publish_event("VoicemailPasswordChange", EVENT_FLAG_SYSTEM | EVENT_FLAG_USER, json_object);
        ast_json_unref(json_object);
    }
    return res;
}
 
/*!
 * \brief Check if configuration file is valid
 */
static inline int valid_config(const struct ast_config *cfg)
{
    return cfg && cfg != CONFIG_STATUS_FILEINVALID;
}
 
/*!
 * \brief The handler for the change password option.
 * \param vmu The voicemail user to work with.
 * \param newpassword The new password (that has been gathered from the appropriate prompting).
 * This is called when a new user logs in for the first time and the option to force them to change their password is set.
 * It is also called when the user wants to change their password from menu option '5' on the mailbox options menu.
 */
static void vm_change_password(struct ast_vm_user *vmu, const char *newpassword)
{
    struct ast_config   *cfg = NULL;
    struct ast_variable *var = NULL;
    struct ast_category *cat = NULL;
    char *category = NULL;
    const char *tmp = NULL;
    struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS };
    char secretfn[PATH_MAX] = "";
    int found = 0;
 
    if (!change_password_realtime(vmu, newpassword))
        return;
 
    /* check if we should store the secret in the spool directory next to the messages */
    switch (vmu->passwordlocation) {
    case OPT_PWLOC_SPOOLDIR:
        snprintf(secretfn, sizeof(secretfn), "%s%s/%s/secret.conf", VM_SPOOL_DIR, vmu->context, vmu->mailbox);
        if (write_password_to_file(secretfn, newpassword) == 0) {
            ast_test_suite_event_notify("PASSWORDCHANGED", "Message: secret.conf updated with new password\r\nPasswordSource: secret.conf");
            ast_verb(4, "Writing voicemail password to file %s succeeded\n", secretfn);
            reset_user_pw(vmu->context, vmu->mailbox, newpassword);
            ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
            break;
        } else {
            ast_log(LOG_WARNING, "Writing voicemail password to file %s failed, falling back to config file\n", secretfn);
        }
        /* Fall-through */
    case OPT_PWLOC_VOICEMAILCONF:
        if ((cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags)) && valid_config(cfg)) {
            while ((category = ast_category_browse(cfg, category))) {
                if (!strcasecmp(category, vmu->context)) {
                    char *value = NULL;
                    char *new = NULL;
                    if (!(tmp = ast_variable_retrieve(cfg, category, vmu->mailbox))) {
                        ast_log(AST_LOG_WARNING, "We could not find the mailbox.\n");
                        break;
                    }
                    value = strstr(tmp, ",");
                    if (!value) {
                        new = ast_malloc(strlen(newpassword) + 1);
                        sprintf(new, "%s", newpassword);
                    } else {
                        new = ast_malloc((strlen(value) + strlen(newpassword) + 1));
                        sprintf(new, "%s%s", newpassword, value);
                    }
                    if (!(cat = ast_category_get(cfg, category, NULL))) {
                        ast_log(AST_LOG_WARNING, "Failed to get category structure.\n");
                        ast_free(new);
                        break;
                    }
                    ast_variable_update(cat, vmu->mailbox, new, NULL, 0);
                    found = 1;
                    ast_free(new);
                }
            }
            /* save the results */
            if (found) {
                ast_test_suite_event_notify("PASSWORDCHANGED", "Message: voicemail.conf updated with new password\r\nPasswordSource: voicemail.conf");
                reset_user_pw(vmu->context, vmu->mailbox, newpassword);
                ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
                ast_config_text_file_save(VOICEMAIL_CONFIG, cfg, "app_voicemail");
                ast_config_destroy(cfg);
                break;
            }
 
            ast_config_destroy(cfg);
        }
        /* Fall-through */
    case OPT_PWLOC_USERSCONF:
        /* check users.conf and update the password stored for the mailbox */
        /* if no vmsecret entry exists create one. */
        if ((cfg = ast_config_load("users.conf", config_flags)) && valid_config(cfg)) {
            ast_debug(4, "we are looking for %s\n", vmu->mailbox);
            for (category = ast_category_browse(cfg, NULL); category; category = ast_category_browse(cfg, category)) {
                ast_debug(4, "users.conf: %s\n", category);
                if (!strcasecmp(category, vmu->mailbox)) {
                    char new[strlen(newpassword) + 1];
                    if (!ast_variable_retrieve(cfg, category, "vmsecret")) {
                        ast_debug(3, "looks like we need to make vmsecret!\n");
                        var = ast_variable_new("vmsecret", newpassword, "");
                    } else {
                        var = NULL;
                    }
 
                    sprintf(new, "%s", newpassword);
                    if (!(cat = ast_category_get(cfg, category, NULL))) {
                        ast_debug(4, "failed to get category!\n");
                        ast_free(var);
                        break;
                    }
                    if (!var) {
                        ast_variable_update(cat, "vmsecret", new, NULL, 0);
                    } else {
                        ast_variable_append(cat, var);
                    }
                    found = 1;
                    break;
                }
            }
            /* save the results and clean things up */
            if (found) {
                ast_test_suite_event_notify("PASSWORDCHANGED", "Message: users.conf updated with new password\r\nPasswordSource: users.conf");
                reset_user_pw(vmu->context, vmu->mailbox, newpassword);
                ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
                ast_config_text_file_save("users.conf", cfg, "app_voicemail");
            }
 
            ast_config_destroy(cfg);
        }
    }
}
 
static void vm_change_password_shell(struct ast_vm_user *vmu, char *newpassword)
{
    char buf[255];
    snprintf(buf, sizeof(buf), "%s %s %s %s", ext_pass_cmd, vmu->context, vmu->mailbox, newpassword);
    ast_debug(1, "External password: %s\n",buf);
    if (!ast_safe_system(buf)) {
        ast_test_suite_event_notify("PASSWORDCHANGED", "Message: external script updated with new password\r\nPasswordSource: external");
        ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
        /* Reset the password in memory, too */
        reset_user_pw(vmu->context, vmu->mailbox, newpassword);
    }
}
 
/*!
 * \brief Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
 * \param dest The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
 * \param len The length of the path string that was written out.
 * \param context
 * \param ext
 * \param folder
 *
 * The path is constructed as
 *  VM_SPOOL_DIRcontext/ext/folder
 *
 * \return zero on success, -1 on error.
 */
static int make_dir(char *dest, int len, const char *context, const char *ext, const char *folder)
{
    return snprintf(dest, len, "%s%s/%s/%s", VM_SPOOL_DIR, context, ext, folder);
}
 
/*!
 * \brief Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
 * \param dest The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
 * \param len The length of the path string that was written out.
 * \param dir
 * \param num
 *
 * The path is constructed as
 *  VM_SPOOL_DIRcontext/ext/folder
 *
 * \return zero on success, -1 on error.
 */
static int make_file(char *dest, const int len, const char *dir, const int num)
{
    return snprintf(dest, len, "%s/msg%04d", dir, num);
}
 
/*! \brief basically mkdir -p $dest/$context/$ext/$folder
 * \param dest    String. base directory.
 * \param len     Length of dest.
 * \param context String. Ignored if is null or empty string.
 * \param ext     String. Ignored if is null or empty string.
 * \param folder  String. Ignored if is null or empty string.
 * \return -1 on failure, 0 on success.
 */
static int create_dirpath(char *dest, int len, const char *context, const char *ext, const char *folder)
{
    mode_t  mode = VOICEMAIL_DIR_MODE;
    int res;
 
    make_dir(dest, len, context, ext, folder);
    if ((res = ast_mkdir(dest, mode))) {
        ast_log(AST_LOG_WARNING, "ast_mkdir '%s' failed: %s\n", dest, strerror(res));
        return -1;
    }
    return 0;
}
 
static const char *mbox(struct ast_vm_user *vmu, int id)
{
#ifdef IMAP_STORAGE
    if (vmu && id == 0) {
        return vmu->imapfolder;
    }
#endif
    return (id >= 0 && id < ARRAY_LEN(mailbox_folders)) ? mailbox_folders[id] : "Unknown";
}
 
static const char *vm_index_to_foldername(int id)
{
    return mbox(NULL, id);
}
 
 
static int get_folder_by_name(const char *name)
{
    size_t i;
 
    for (i = 0; i < ARRAY_LEN(mailbox_folders); i++) {
        if (strcasecmp(name, mailbox_folders[i]) == 0) {
            return i;
        }
    }
 
    return -1;
}
 
static void free_user(struct ast_vm_user *vmu)
{
    if (!vmu) {
        return;
    }
 
    ast_free(vmu->email);
    vmu->email = NULL;
    ast_free(vmu->emailbody);
    vmu->emailbody = NULL;
    ast_free(vmu->emailsubject);
    vmu->emailsubject = NULL;
 
    if (ast_test_flag(vmu, VM_ALLOCED)) {
        ast_free(vmu);
    }
}
 
static void free_user_final(struct ast_vm_user *vmu)
{
    if (!vmu) {
        return;
    }
 
    if (!ast_strlen_zero(vmu->mailbox)) {
        ast_delete_mwi_state_full(vmu->mailbox, vmu->context, NULL);
    }
 
    free_user(vmu);
}
 
static int vm_allocate_dh(struct vm_state *vms, struct ast_vm_user *vmu, int count_msg) {
 
    int arraysize = (vmu->maxmsg > count_msg ? vmu->maxmsg : count_msg);
 
    /* remove old allocation */
    if (vms->deleted) {
        ast_free(vms->deleted);
        vms->deleted = NULL;
    }
    if (vms->heard) {
        ast_free(vms->heard);
        vms->heard = NULL;
    }
    vms->dh_arraysize = 0;
 
    if (arraysize > 0) {
        if (!(vms->deleted = ast_calloc(arraysize, sizeof(int)))) {
            return -1;
        }
        if (!(vms->heard = ast_calloc(arraysize, sizeof(int)))) {
            ast_free(vms->deleted);
            vms->deleted = NULL;
            return -1;
        }
        vms->dh_arraysize = arraysize;
    }
 
    return 0;
}
 
/* All IMAP-specific functions should go in this block. This
 * keeps them from being spread out all over the code */
#ifdef IMAP_STORAGE
static void vm_imap_delete(char *file, int msgnum, struct ast_vm_user *vmu)
{
    char arg[10];
    struct vm_state *vms;
    unsigned long messageNum;
 
    /* If greetings aren't stored in IMAP, just delete the file */
    if (msgnum < 0 && !imapgreetings) {
        ast_filedelete(file, NULL);
        return;
    }
 
    if (!(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) && !(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
        ast_log(LOG_WARNING, "Couldn't find a vm_state for mailbox %s. Unable to set \\DELETED flag for message %d\n", vmu->mailbox, msgnum);
        return;
    }
 
    if (msgnum < 0) {
        imap_delete_old_greeting(file, vms);
        return;
    }
 
    /* find real message number based on msgnum */
    /* this may be an index into vms->msgArray based on the msgnum. */
    messageNum = vms->msgArray[msgnum];
    if (messageNum == 0) {
        ast_log(LOG_WARNING, "msgnum %d, mailbox message %lu is zero.\n", msgnum, messageNum);
        return;
    }
    ast_debug(3, "deleting msgnum %d, which is mailbox message %lu\n", msgnum, messageNum);
    /* delete message */
    snprintf (arg, sizeof(arg), "%lu", messageNum);
    ast_mutex_lock(&vms->lock);
    mail_setflag (vms->mailstream, arg, "\\DELETED");
    mail_expunge(vms->mailstream);
    ast_mutex_unlock(&vms->lock);
}
 
static void vm_imap_update_msg_id(char *dir, int msgnum, const char *msg_id, struct ast_vm_user *vmu, struct ast_config *msg_cfg, int folder)
{
    struct ast_channel *chan;
    char *cid;
    char *cid_name;
    char *cid_num;
    struct vm_state *vms;
    const char *duration_str;
    int duration = 0;
 
    /*
     * First, get things initially set up. If any of this fails, then
     * back out before doing anything substantial
     */
    vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0);
    if (!vms) {
        return;
    }
 
    if (open_mailbox(vms, vmu, folder)) {
        return;
    }
 
    chan = ast_dummy_channel_alloc();
    if (!chan) {
        close_mailbox(vms, vmu);
        return;
    }
 
    /*
     * We need to make sure the new message we save has the same
     * callerid, flag, and duration as the original message
     */
    cid = ast_strdupa(ast_variable_retrieve(msg_cfg, "message", "callerid"));
 
    if (!ast_strlen_zero(cid)) {
        ast_callerid_parse(cid, &cid_name, &cid_num);
        ast_party_caller_init(ast_channel_caller(chan));
        if (!ast_strlen_zero(cid_name)) {
            ast_channel_caller(chan)->id.name.valid = 1;
            ast_channel_caller(chan)->id.name.str = ast_strdup(cid_name);
        }
        if (!ast_strlen_zero(cid_num)) {
            ast_channel_caller(chan)->id.number.valid = 1;
            ast_channel_caller(chan)->id.number.str = ast_strdup(cid_num);
        }
    }
 
    duration_str = ast_variable_retrieve(msg_cfg, "message", "duration");
 
    if (!ast_strlen_zero(duration_str)) {
        sscanf(duration_str, "%30d", &duration);
    }
 
    /*
     * IMAP messages cannot be altered once delivered. So we have to delete the
     * current message and then re-add it with the updated message ID.
     *
     * Furthermore, there currently is no atomic way to create a new message and to
     * store it in an arbitrary folder. So we have to save it to the INBOX and then
     * move to the appropriate folder.
     */
    if (!imap_store_file(dir, vmu->mailbox, vmu->context, msgnum, chan, vmu, vmfmts,
            duration, vms, ast_variable_retrieve(msg_cfg, "message", "flag"), msg_id)) {
        if (folder != NEW_FOLDER) {
            save_to_folder(vmu, vms, msgnum, folder, NULL, 1);
        }
        vm_imap_delete(dir, msgnum, vmu);
    }
    close_mailbox(vms, vmu);
    ast_channel_unref(chan);
}
 
static int imap_retrieve_greeting(const char *dir, const int msgnum, struct ast_vm_user *vmu)
{
    struct vm_state *vms_p;
    char *file, *filename;
    char dest[PATH_MAX];
    int i;
    BODY *body;
    int ret = 0;
    int curr_mbox;
 
    /* This function is only used for retrieval of IMAP greetings
     * regular messages are not retrieved this way, nor are greetings
     * if they are stored locally*/
    if (msgnum > -1 || !imapgreetings) {
        return 0;
    } else {
        file = strrchr(ast_strdupa(dir), '/');
        if (file)
            *file++ = '\0';
        else {
            ast_debug(1, "Failed to procure file name from directory passed.\n");
            return -1;
        }
    }
 
    /* check if someone is accessing this box right now... */
    if (!(vms_p = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) &&
        !(vms_p = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
        /* Unlike when retrieving a message, it is reasonable not to be able to find a
        * vm_state for a mailbox when trying to retrieve a greeting. Just create one,
        * that's all we need to do.
        */
        if (!(vms_p = create_vm_state_from_user(vmu))) {
            ast_log(LOG_NOTICE, "Unable to create vm_state object!\n");
            return -1;
        }
    }
 
    /* Greetings will never have a prepended message */
    *vms_p->introfn = '\0';
 
    ast_mutex_lock(&vms_p->lock);
 
    /* get the current mailbox so that we can point the mailstream back to it later */
    curr_mbox = get_folder_by_name(vms_p->curbox);
 
    if (init_mailstream(vms_p, GREETINGS_FOLDER) || !vms_p->mailstream) {
        ast_log(AST_LOG_ERROR, "IMAP mailstream is NULL or can't init_mailstream\n");
        ast_mutex_unlock(&vms_p->lock);
        return -1;
    }
 
    /*XXX Yuck, this could probably be done a lot better */
    for (i = 0; i < vms_p->mailstream->nmsgs; i++) {
        mail_fetchstructure(vms_p->mailstream, i + 1, &body);
        /* We have the body, now we extract the file name of the first attachment. */
        if (body->nested.part && body->nested.part->next && body->nested.part->next->body.parameter->value) {
            char *attachment = body->nested.part->next->body.parameter->value;
            char copy[strlen(attachment) + 1];
 
            strcpy(copy, attachment); /* safe */
            attachment = copy;
 
            filename = strsep(&attachment, ".");
            if (!strcmp(filename, file)) {
                ast_copy_string(vms_p->fn, dir, sizeof(vms_p->fn));
                vms_p->msgArray[vms_p->curmsg] = i + 1;
                create_dirpath(dest, sizeof(dest), vmu->context, vms_p->username, "");
                save_body(body, vms_p, "2", attachment, 0);
                ret = 0;
                break;
            }
        } else {
            ast_log(AST_LOG_ERROR, "There is no file attached to this IMAP message.\n");
            ret = -1;
            break;
        }
    }
 
    if (curr_mbox != -1) {
        /* restore previous mbox stream */
        if (init_mailstream(vms_p, curr_mbox) || !vms_p->mailstream) {
            ast_log(AST_LOG_ERROR, "IMAP mailstream is NULL or can't init_mailstream\n");
            ret = -1;
        }
    }
    ast_mutex_unlock(&vms_p->lock);
    return ret;
}
 
static int imap_retrieve_file(const char *dir, const int msgnum, const char *mailbox, const char *context)
{
    BODY *body;
    char *header_content;
    char *attachedfilefmt;
    char buf[80];
    struct vm_state *vms;
    char text_file[PATH_MAX];
    FILE *text_file_ptr;
    int res = 0;
    struct ast_vm_user *vmu;
    int curr_mbox;
 
    if (!(vmu = find_user(NULL, context, mailbox))) {
        ast_log(LOG_WARNING, "Couldn't find user with mailbox %s@%s\n", mailbox, context);
        return -1;
    }
 
    if (msgnum < 0) {
        if (imapgreetings) {
            res = imap_retrieve_greeting(dir, msgnum, vmu);
            goto exit;
        } else {
            res = 0;
            goto exit;
        }
    }
 
    /* Before anything can happen, we need a vm_state so that we can
     * actually access the imap server through the vms->mailstream
     */
    if (!(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) && !(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
        /* This should not happen. If it does, then I guess we'd
         * need to create the vm_state, extract which mailbox to
         * open, and then set up the msgArray so that the correct
         * IMAP message could be accessed. If I have seen correctly
         * though, the vms should be obtainable from the vmstates list
         * and should have its msgArray properly set up.
         */
        ast_log(LOG_ERROR, "Couldn't find a vm_state for mailbox %s!!! Oh no!\n", vmu->mailbox);
        res = -1;
        goto exit;
    }
 
    /* Ensure we have the correct mailbox open and have a valid mailstream for it */
    curr_mbox = get_folder_by_name(vms->curbox);
    if (curr_mbox < 0) {
        ast_debug(3, "Mailbox folder curbox not set, defaulting to Inbox\n");
        curr_mbox = 0;
    }
    init_mailstream(vms, curr_mbox);
    if (!vms->mailstream) {
        ast_log(AST_LOG_ERROR, "IMAP mailstream for %s is NULL\n", vmu->mailbox);
        res = -1;
        goto exit;
    }
 
    make_file(vms->fn, sizeof(vms->fn), dir, msgnum);
    snprintf(vms->introfn, sizeof(vms->introfn), "%sintro", vms->fn);
 
    /* Don't try to retrieve a message from IMAP if it already is on the file system */
    if (ast_fileexists(vms->fn, NULL, NULL) > 0) {
        res = 0;
        goto exit;
    }
 
    ast_debug(3, "Before mail_fetchheaders, curmsg is: %d, imap messages is %lu\n", msgnum, vms->msgArray[msgnum]);
    if (vms->msgArray[msgnum] == 0) {
        ast_log(LOG_WARNING, "Trying to access unknown message\n");
        res = -1;
        goto exit;
    }
 
    /* This will only work for new messages... */
    ast_mutex_lock(&vms->lock);
    header_content = mail_fetchheader (vms->mailstream, vms->msgArray[msgnum]);
    ast_mutex_unlock(&vms->lock);
    /* empty string means no valid header */
    if (ast_strlen_zero(header_content)) {
        ast_log(LOG_ERROR, "Could not fetch header for message number %ld\n", vms->msgArray[msgnum]);
        res = -1;
        goto exit;
    }
 
    ast_mutex_lock(&vms->lock);
    mail_fetchstructure(vms->mailstream, vms->msgArray[msgnum], &body);
    ast_mutex_unlock(&vms->lock);
 
    /* We have the body, now we extract the file name of the first attachment. */
    if (body->nested.part && body->nested.part->next && body->nested.part->next->body.parameter->value) {
        attachedfilefmt = ast_strdupa(body->nested.part->next->body.parameter->value);
    } else {
        ast_log(LOG_ERROR, "There is no file attached to this IMAP message.\n");
        res = -1;
        goto exit;
    }
 
    /* Find the format of the attached file */
 
    strsep(&attachedfilefmt, ".");
    if (!attachedfilefmt) {
        ast_log(LOG_ERROR, "File format could not be obtained from IMAP message attachment\n");
        res = -1;
        goto exit;
    }
 
    save_body(body, vms, "2", attachedfilefmt, 0);
    if (save_body(body, vms, "3", attachedfilefmt, 1)) {
        *vms->introfn = '\0';
    }
 
    /* Get info from headers!! */
    snprintf(text_file, sizeof(text_file), "%s.%s", vms->fn, "txt");
 
    if (!(text_file_ptr = fopen(text_file, "w"))) {
        ast_log(LOG_ERROR, "Unable to open/create file %s: %s\n", text_file, strerror(errno));
        goto exit;
    }
 
    fprintf(text_file_ptr, "%s\n", "[message]");
 
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Name:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "callerid=\"%s\" ", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Num:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "<%s>\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Context:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "context=%s\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Orig-time:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "origtime=%s\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Duration:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "duration=%s\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Category:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "category=%s\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Flag:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "flag=%s\n", S_OR(buf, ""));
    }
    if (get_header_by_tag(header_content, "X-Asterisk-VM-Message-ID:", buf, sizeof(buf))) {
        fprintf(text_file_ptr, "msg_id=%s\n", S_OR(buf, ""));
    }
    fclose(text_file_ptr);
 
exit:
    free_user(vmu);
    return res;
}
 
static int folder_int(const char *folder)
{
    /*assume a NULL folder means INBOX*/
    if (!folder) {
        return 0;
    }
    if (!strcasecmp(folder, imapfolder)) {
        return 0;
    } else if (!strcasecmp(folder, "Old")) {
        return 1;
    } else if (!strcasecmp(folder, "Work")) {
        return 2;
    } else if (!strcasecmp(folder, "Family")) {
        return 3;
    } else if (!strcasecmp(folder, "Friends")) {
        return 4;
    } else if (!strcasecmp(folder, "Cust1")) {
        return 5;
    } else if (!strcasecmp(folder, "Cust2")) {
        return 6;
    } else if (!strcasecmp(folder, "Cust3")) {
        return 7;
    } else if (!strcasecmp(folder, "Cust4")) {
        return 8;
    } else if (!strcasecmp(folder, "Cust5")) {
        return 9;
    } else if (!strcasecmp(folder, "Urgent")) {
        return 11;
    } else { /*assume they meant INBOX if folder is not found otherwise*/
        return 0;
    }
}
 
static int __messagecount(const char *context, const char *mailbox, const char *folder)
{
    SEARCHPGM *pgm;
    SEARCHHEADER *hdr;
 
    struct ast_vm_user *vmu, vmus;
    struct vm_state *vms_p;
    int ret = 0;
    int fold = folder_int(folder);
    int urgent = 0;
 
    /* If URGENT, then look at INBOX */
    if (fold == 11) {
        fold = NEW_FOLDER;
        urgent = 1;
    }
 
    if (ast_strlen_zero(mailbox))
        return 0;
 
    /* We have to get the user before we can open the stream! */
    memset(&vmus, 0, sizeof(vmus));
    vmu = find_user(&vmus, context, mailbox);
    if (!vmu) {
        ast_log(AST_LOG_WARNING, "Couldn't find mailbox %s in context %s\n", mailbox, context);
        free_user(vmu);
        return -1;
    } else {
        /* No IMAP account available */
        if (vmu->imapuser[0] == '\0') {
            ast_log(AST_LOG_WARNING, "IMAP user not set for mailbox %s\n", vmu->mailbox);
            free_user(vmu);
            return -1;
        }
    }
 
    /* No IMAP account available */
    if (vmu->imapuser[0] == '\0') {
        ast_log(AST_LOG_WARNING, "IMAP user not set for mailbox %s\n", vmu->mailbox);
        free_user(vmu);
        return -1;
    }
 
    /* check if someone is accessing this box right now... */
    vms_p = get_vm_state_by_imapuser(vmu->imapuser, 1);
    if (!vms_p) {
        vms_p = get_vm_state_by_mailbox(mailbox, context, 1);
    }
    if (vms_p) {
        ast_debug(3, "Returning before search - user is logged in\n");
        if (fold == 0) { /* INBOX */
            free_user(vmu);
            return urgent ? vms_p->urgentmessages : vms_p->newmessages;
        }
        if (fold == 1) { /* Old messages */
            free_user(vmu);
            return vms_p->oldmessages;
        }
    }
 
    /* add one if not there... */
    vms_p = get_vm_state_by_imapuser(vmu->imapuser, 0);
    if (!vms_p) {
        vms_p = get_vm_state_by_mailbox(mailbox, context, 0);
    }
 
    if (!vms_p) {
        vms_p = create_vm_state_from_user(vmu);
    }
    ret = init_mailstream(vms_p, fold);
    if (!vms_p->mailstream) {
        ast_log(AST_LOG_ERROR, "Houston we have a problem - IMAP mailstream is NULL\n");
        free_user(vmu);
        return -1;
    }
    if (ret == 0) {
        ast_mutex_lock(&vms_p->lock);
        pgm = mail_newsearchpgm ();
        hdr = mail_newsearchheader ("X-Asterisk-VM-Extension", (char *)(!ast_strlen_zero(vmu->imapvmshareid) ? vmu->imapvmshareid : mailbox));
        hdr->next = mail_newsearchheader("X-Asterisk-VM-Context", (char *) S_OR(context, "default"));
        pgm->header = hdr;
        if (fold != OLD_FOLDER) {
            pgm->unseen = 1;
            pgm->seen = 0;
        }
        /* In the special case where fold is 1 (old messages) we have to do things a bit
         * differently. Old messages are stored in the INBOX but are marked as "seen"
         */
        else {
            pgm->unseen = 0;
            pgm->seen = 1;
        }
        /* look for urgent messages */
        if (fold == NEW_FOLDER) {
            if (urgent) {
                pgm->flagged = 1;
                pgm->unflagged = 0;
            } else {
                pgm->flagged = 0;
                pgm->unflagged = 1;
            }
        }
        pgm->undeleted = 1;
        pgm->deleted = 0;
 
        vms_p->vmArrayIndex = 0;
        mail_search_full (vms_p->mailstream, NULL, pgm, NIL);
        if (fold == 0 && urgent == 0)
            vms_p->newmessages = vms_p->vmArrayIndex;
        if (fold == 1)
            vms_p->oldmessages = vms_p->vmArrayIndex;
        if (fold == 0 && urgent == 1)
            vms_p->urgentmessages = vms_p->vmArrayIndex;
        /*Freeing the searchpgm also frees the searchhdr*/
        mail_free_searchpgm(&pgm);
        ast_mutex_unlock(&vms_p->lock);
        free_user(vmu);
        vms_p->updated = 0;
        return vms_p->vmArrayIndex;
    } else {
        ast_mutex_lock(&vms_p->lock);
        mail_ping(vms_p->mailstream);
        ast_mutex_unlock(&vms_p->lock);
    }
    free_user(vmu);
    return 0;
}
 
static int imap_check_limits(struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu, int msgnum)
{
    /* Check if mailbox is full */
    check_quota(vms, vmu->imapfolder);
    if (vms->quota_limit && vms->quota_usage >= vms->quota_limit) {
        ast_debug(1, "*** QUOTA EXCEEDED!! %u >= %u\n", vms->quota_usage, vms->quota_limit);
        if (chan) {
            ast_play_and_wait(chan, "vm-mailboxfull");
        }
        return -1;
    }
 
    /* Check if we have exceeded maxmsg */
    ast_debug(3, "Checking message number quota: mailbox has %d messages, maximum is set to %d, current messages %d\n", msgnum, vmu->maxmsg, inprocess_count(vmu->mailbox, vmu->context, 0));
    if (msgnum >= vmu->maxmsg - inprocess_count(vmu->mailbox, vmu->context, +1)) {
        ast_log(LOG_WARNING, "Unable to leave message since we will exceed the maximum number of messages allowed (%u >= %u)\n", msgnum, vmu->maxmsg);
        if (chan) {
            ast_play_and_wait(chan, "vm-mailboxfull");
            pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
        }
        return -1;
    }
 
    return 0;
}
 
/*!
 * \brief Gets the number of messages that exist in a mailbox folder.
 * \param mailbox_id
 * \param folder
 *
 * This method is used when IMAP backend is used.
 * \return The number of messages in this mailbox folder (zero or more).
 */
static int messagecount(const char *mailbox_id, const char *folder)
{
    char *context;
    char *mailbox;
    int count;
 
    if (ast_strlen_zero(mailbox_id)
        || separate_mailbox(ast_strdupa(mailbox_id), &mailbox, &context)) {
        return 0;
    }
 
    if (ast_strlen_zero(folder) || !strcmp(folder, "INBOX")) {
        count = __messagecount(context, mailbox, "INBOX") + __messagecount(context, mailbox, "Urgent");
    } else {
        count = __messagecount(context, mailbox, folder);
    }
    return count < 0 ? 0 : count;
}
 
static int imap_store_file(const char *dir, const char *mailboxuser, const char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag, const char *msg_id)
{
    char *myserveremail = serveremail;
    char fn[PATH_MAX];
    char introfn[PATH_MAX];
    char mailbox[256];
    char *stringp;
    FILE *p = NULL;
    char tmp[80] = "/tmp/astmail-XXXXXX";
    long len;
    void *buf;
    int tempcopy = 0;
    STRING str;
    int ret; /* for better error checking */
    char *imap_flags = NIL;
    int msgcount;
    int box = NEW_FOLDER;
 
    snprintf(mailbox, sizeof(mailbox), "%s@%s", vmu->mailbox, vmu->context);
    msgcount = messagecount(mailbox, "INBOX") + messagecount(mailbox, "Old");
 
    /* Back out early if this is a greeting and we don't want to store greetings in IMAP */
    if (msgnum < 0) {
        if(!imapgreetings) {
            return 0;
        } else {
            box = GREETINGS_FOLDER;
        }
    }
 
    if (imap_check_limits(chan, vms, vmu, msgcount)) {
        return -1;
    }
 
    /* Set urgent flag for IMAP message */
    if (!ast_strlen_zero(flag) && !strcmp(flag, "Urgent")) {
        ast_debug(3, "Setting message flag \\\\FLAGGED.\n");
        imap_flags = "\\FLAGGED";
    }
 
    /* Attach only the first format */
    fmt = ast_strdupa(fmt);
    stringp = fmt;
    strsep(&stringp, "|");
 
    if (!ast_strlen_zero(vmu->serveremail))
        myserveremail = vmu->serveremail;
 
    if (msgnum > -1)
        make_file(fn, sizeof(fn), dir, msgnum);
    else
        ast_copy_string (fn, dir, sizeof(fn));
 
    snprintf(introfn, sizeof(introfn), "%sintro", fn);
    if (ast_fileexists(introfn, NULL, NULL) <= 0) {
        *introfn = '\0';
    }
 
    if (ast_strlen_zero(vmu->email)) {
        /* We need the vmu->email to be set when we call make_email_file, but
         * if we keep it set, a duplicate e-mail will be created. So at the end
         * of this function, we will revert back to an empty string if tempcopy
         * is 1.
         */
        vmu->email = ast_strdup(vmu->imapuser);
        tempcopy = 1;
    }
 
    if (!strcmp(fmt, "wav49"))
        fmt = "WAV";
    ast_debug(3, "Storing file '%s', format '%s'\n", fn, fmt);
 
    /* Make a temporary file instead of piping directly to sendmail, in case the mail
       command hangs. */
    if (!(p = ast_file_mkftemp(tmp, VOICEMAIL_FILE_MODE & ~my_umask))) {
        ast_log(AST_LOG_WARNING, "Unable to store '%s' (can't create temporary file)\n", fn);
        if (tempcopy) {
            ast_free(vmu->email);
            vmu->email = NULL;
        }
        return -1;
    }
 
    if (msgnum < 0 && imapgreetings) {
        if ((ret = init_mailstream(vms, GREETINGS_FOLDER))) {
            ast_log(AST_LOG_WARNING, "Unable to open mailstream.\n");
            return -1;
        }
        imap_delete_old_greeting(fn, vms);
    }
 
    make_email_file(p, myserveremail, vmu, msgnum, vmu->context, vmu->mailbox, "INBOX",
        chan ? S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL) : NULL,
        chan ? S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, NULL) : NULL,
        fn, introfn, fmt, duration, 1, chan, NULL, 1, flag, msg_id);
    /* read mail file to memory */
    len = ftell(p);
    rewind(p);
    if (!(buf = ast_malloc(len + 1))) {
        ast_log(AST_LOG_ERROR, "Can't allocate %ld bytes to read message\n", len + 1);
        fclose(p);
        if (tempcopy)
            *(vmu->email) = '\0';
        return -1;
    }
    if (fread(buf, 1, len, p) != len) {
        if (ferror(p)) {
            ast_log(LOG_ERROR, "Error while reading mail file: %s\n", tmp);
            return -1;
        }
    }
    ((char *) buf)[len] = '\0';
    INIT(&str, mail_string, buf, len);
    ret = init_mailstream(vms, box);
    if (ret == 0) {
        imap_mailbox_name(mailbox, sizeof(mailbox), vms, box, 1);
        ast_mutex_lock(&vms->lock);
        if(!mail_append_full(vms->mailstream, mailbox, imap_flags, NIL, &str))
            ast_log(LOG_ERROR, "Error while sending the message to %s\n", mailbox);
        ast_mutex_unlock(&vms->lock);
        fclose(p);
        unlink(tmp);
        ast_free(buf);
    } else {
        ast_log(LOG_ERROR, "Could not initialize mailstream for %s\n", mailbox);
        fclose(p);
        unlink(tmp);
        ast_free(buf);
        return -1;
    }
    ast_debug(3, "%s stored\n", fn);
 
    if (tempcopy)
        *(vmu->email) = '\0';
    inprocess_count(vmu->mailbox, vmu->context, -1);
    return 0;
 
}
 
/*!
 * \brief Gets the number of messages that exist in the inbox folder.
 * \param mailbox_context
 * \param newmsgs The variable that is updated with the count of new messages within this inbox.
 * \param oldmsgs The variable that is updated with the count of old messages within this inbox.
 * \param urgentmsgs The variable that is updated with the count of urgent messages within this inbox.
 *
 * This method is used when IMAP backend is used.
 * Simultaneously determines the count of new,old, and urgent messages. The total messages would then be the sum of these three.
 *
 * \return zero on success, -1 on error.
 */
 
static int inboxcount2(const char *mailbox_context, int *urgentmsgs, int *newmsgs, int *oldmsgs)
{
    char tmp[PATH_MAX] = "";
    char *mailboxnc;
    char *context;
    char *mb;
    char *cur;
    int count = 0;
    if (newmsgs)
        *newmsgs = 0;
    if (oldmsgs)
        *oldmsgs = 0;
    if (urgentmsgs)
        *urgentmsgs = 0;
 
    ast_debug(3, "Mailbox is set to %s\n", mailbox_context);
    /* If no mailbox, return immediately */
    if (ast_strlen_zero(mailbox_context))
        return 0;
 
    ast_copy_string(tmp, mailbox_context, sizeof(tmp));
    context = strchr(tmp, '@');
    if (strchr(mailbox_context, ',')) {
        int tmpnew, tmpold, tmpurgent;
        ast_copy_string(tmp, mailbox_context, sizeof(tmp));
        mb = tmp;
        while ((cur = strsep(&mb, ", "))) {
            if (!ast_strlen_zero(cur)) {
                if (inboxcount2(cur, urgentmsgs ? &tmpurgent : NULL, newmsgs ? &tmpnew : NULL, oldmsgs ? &tmpold : NULL))
                    return -1;
                else {
                    if (newmsgs)
                        *newmsgs += tmpnew;
                    if (oldmsgs)
                        *oldmsgs += tmpold;
                    if (urgentmsgs)
                        *urgentmsgs += tmpurgent;
                }
            }
        }
        return 0;
    }
    if (context) {
        *context = '\0';
        mailboxnc = tmp;
        context++;
    } else {
        context = "default";
        mailboxnc = (char *) mailbox_context;
    }
 
    if (newmsgs) {
        struct ast_vm_user *vmu = find_user(NULL, context, mailboxnc);
        if (!vmu) {
            ast_log(AST_LOG_ERROR, "Couldn't find mailbox %s in context %s\n", mailboxnc, context);
            return -1;
        }
        if ((count = __messagecount(context, mailboxnc, vmu->imapfolder)) < 0) {
            free_user(vmu);
            return -1;
        }
        *newmsgs = count;
        free_user(vmu);
    }
    if (oldmsgs) {
        if ((count = __messagecount(context, mailboxnc, "Old")) < 0) {
            return -1;
        }
        *oldmsgs = count;
    }
    if (urgentmsgs) {
        if ((count = __messagecount(context, mailboxnc, "Urgent")) < 0) {
            return -1;
        }
        *urgentmsgs = count;
    }
    return 0;
}
 
/*!
 * \brief Determines if the given folder has messages.
 * \param mailbox The \@ delimited string for user\@context. If no context is found, uses 'default' for the context.
 * \param folder the folder to look in
 *
 * This function is used when the mailbox is stored in an IMAP back end.
 * This invokes the messagecount(). Here we are interested in the presence of messages (> 0) only, not the actual count.
 * \return 1 if the folder has one or more messages. zero otherwise.
 */
 
static int has_voicemail(const char *mailbox, const char *folder)
{
    char tmp[256], *tmp2, *box, *context;
    ast_copy_string(tmp, mailbox, sizeof(tmp));
    tmp2 = tmp;
    if (strchr(tmp2, ',') || strchr(tmp2, '&')) {
        while ((box = strsep(&tmp2, ",&"))) {
            if (!ast_strlen_zero(box)) {
                if (has_voicemail(box, folder)) {
                    return 1;
                }
            }
        }
    }
    if ((context = strchr(tmp, '@'))) {
        *context++ = '\0';
    } else {
        context = "default";
    }
    return __messagecount(context, tmp, folder) > 0 ? 1 : 0;
}
 
/*!
 * \brief Copies a message from one mailbox to another.
 * \param chan
 * \param vmu
 * \param imbox
 * \param msgnum
 * \param duration
 * \param recip
 * \param fmt
 * \param dir
 * \param flag, dest_folder
 *
 * This works with IMAP storage based mailboxes.
 *
 * \return zero on success, -1 on error.
 */
static int copy_message(struct ast_channel *chan, struct ast_vm_user *vmu, int imbox, int msgnum, long duration, struct ast_vm_user *recip, char *fmt, char *dir, char *flag, const char *dest_folder)
{
    struct vm_state *sendvms = NULL;
    char messagestring[10]; /*I guess this could be a problem if someone has more than 999999999 messages...*/
    if (msgnum >= recip->maxmsg) {
        ast_log(LOG_WARNING, "Unable to copy mail, mailbox %s is full\n", recip->mailbox);
        return -1;
    }
    if (!(sendvms = get_vm_state_by_imapuser(vmu->imapuser, 0))) {
        ast_log(LOG_ERROR, "Couldn't get vm_state for originator's mailbox!!\n");
        return -1;
    }
    if (!get_vm_state_by_imapuser(recip->imapuser, 0)) {
        ast_log(LOG_ERROR, "Couldn't get vm_state for destination mailbox!\n");
        return -1;
    }
    snprintf(messagestring, sizeof(messagestring), "%ld", sendvms->msgArray[msgnum]);
    ast_mutex_lock(&sendvms->lock);
    if ((mail_copy(sendvms->mailstream, messagestring, (char *) mbox(vmu, imbox)) == T)) {
        ast_mutex_unlock(&sendvms->lock);
        return 0;
    }
    ast_mutex_unlock(&sendvms->lock);
    ast_log(LOG_WARNING, "Unable to copy message from mailbox %s to mailbox %s\n", vmu->mailbox, recip->mailbox);
    return -1;
}
 
static void imap_mailbox_name(char *spec, size_t len, struct vm_state *vms, int box, int use_folder)
{
    char tmp[256], *t = tmp;
    size_t left = sizeof(tmp);
 
    if (box == OLD_FOLDER) {
        ast_copy_string(vms->curbox, mbox(NULL, NEW_FOLDER), sizeof(vms->curbox));
    } else {
        ast_copy_string(vms->curbox, mbox(NULL, box), sizeof(vms->curbox));
    }
 
    if (box == NEW_FOLDER) {
        ast_copy_string(vms->vmbox, "vm-INBOX", sizeof(vms->vmbox));
    } else {
        snprintf(vms->vmbox, sizeof(vms->vmbox), "vm-%s", mbox(NULL, box));
    }
 
    /* Build up server information */
    ast_build_string(&t, &left, "{%s:%s/imap", S_OR(vms->imapserver, imapserver), S_OR(vms->imapport, imapport));
 
    /* Add authentication user if present */
    if (!ast_strlen_zero(authuser))
        ast_build_string(&t, &left, "/authuser=%s", authuser);
 
    /* Add flags if present */
    if (!ast_strlen_zero(imapflags) || !(ast_strlen_zero(vms->imapflags))) {
        ast_build_string(&t, &left, "/%s", S_OR(vms->imapflags, imapflags));
    }
 
    /* End with username */
#if 1
    ast_build_string(&t, &left, "/user=%s}", vms->imapuser);
#else
    ast_build_string(&t, &left, "/user=%s/novalidate-cert}", vms->imapuser);
#endif
    if (box == NEW_FOLDER || box == OLD_FOLDER)
        snprintf(spec, len, "%s%s", tmp, use_folder? vms->imapfolder: "INBOX");
    else if (box == GREETINGS_FOLDER)
        snprintf(spec, len, "%s%s", tmp, greetingfolder);
    else {  /* Other folders such as Friends, Family, etc... */
        if (!ast_strlen_zero(imapparentfolder)) {
            /* imapparentfolder would typically be set to INBOX */
            snprintf(spec, len, "%s%s%c%s", tmp, imapparentfolder, delimiter, mbox(NULL, box));
        } else {
            snprintf(spec, len, "%s%s", tmp, mbox(NULL, box));
        }
    }
}
 
static int init_mailstream(struct vm_state *vms, int box)
{
    MAILSTREAM *stream = NIL;
    long debug;
    char tmp[256];
 
    if (!vms) {
        ast_log(LOG_ERROR, "vm_state is NULL!\n");
        return -1;
    }
    ast_debug(3, "vm_state user is:%s\n", vms->imapuser);
    if (vms->mailstream == NIL || !vms->mailstream) {
        ast_debug(1, "mailstream not set.\n");
    } else {
        stream = vms->mailstream;
    }
    /* debug = T;  user wants protocol telemetry? */
    debug = NIL;  /* NO protocol telemetry? */
 
    if (delimiter == '\0') {        /* did not probe the server yet */
        char *cp;
#ifdef USE_SYSTEM_IMAP
#include <imap/linkage.c>
#elif defined(USE_SYSTEM_CCLIENT)
#include <c-client/linkage.c>
#else
#include "linkage.c"
#endif
        /* Connect to INBOX first to get folders delimiter */
        imap_mailbox_name(tmp, sizeof(tmp), vms, 0, 1);
        ast_mutex_lock(&vms->lock);
        ast_mutex_lock(&mail_open_lock);
        stream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
        ast_mutex_unlock(&mail_open_lock);
        ast_mutex_unlock(&vms->lock);
        if (stream == NIL) {
            ast_log(LOG_ERROR, "Can't connect to imap server %s\n", tmp);
            return -1;
        }
        get_mailbox_delimiter(vms, stream);
        /* update delimiter in imapfolder */
        for (cp = vms->imapfolder; *cp; cp++)
            if (*cp == '/')
                *cp = delimiter;
    }
    /* Now connect to the target folder */
    imap_mailbox_name(tmp, sizeof(tmp), vms, box, 1);
    ast_debug(3, "Before mail_open, server: %s, box:%d\n", tmp, box);
    ast_mutex_lock(&vms->lock);
    ast_mutex_lock(&mail_open_lock);
    vms->mailstream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
    /* Create the folder if it doesn't exist */
    if (vms->mailstream && !mail_status(vms->mailstream, tmp, SA_UIDNEXT)) {
        mail_create(vms->mailstream, tmp);
    }
    ast_mutex_unlock(&mail_open_lock);
    ast_mutex_unlock(&vms->lock);
    if (vms->mailstream == NIL) {
        return -1;
    } else {
        return 0;
    }
}
 
static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box)
{
    SEARCHPGM *pgm;
    SEARCHHEADER *hdr;
    int urgent = 0;
 
    /* If Urgent, then look at INBOX */
    if (box == 11) {
        box = NEW_FOLDER;
        urgent = 1;
    }
 
    ast_copy_string(vms->imapuser, vmu->imapuser, sizeof(vms->imapuser));
    ast_copy_string(vms->imapfolder, vmu->imapfolder, sizeof(vms->imapfolder));
    ast_copy_string(vms->imapserver, vmu->imapserver, sizeof(vms->imapserver));
    ast_copy_string(vms->imapport, vmu->imapport, sizeof(vms->imapport));
    ast_copy_string(vms->imapflags, vmu->imapflags, sizeof(vms->imapflags));
    vms->imapversion = vmu->imapversion;
    ast_debug(3, "Before init_mailstream, user is %s\n", vmu->imapuser);
 
    if (init_mailstream(vms, box) || !vms->mailstream) {
        ast_log(AST_LOG_ERROR, "Could not initialize mailstream\n");
        return -1;
    }
 
    create_dirpath(vms->curdir, sizeof(vms->curdir), vmu->context, vms->username, vms->curbox);
 
    /* Check Quota */
    if  (box == 0)  {
        ast_debug(3, "Mailbox name set to: %s, about to check quotas\n", mbox(vmu, box));
        check_quota(vms, (char *) mbox(vmu, box));
    }
 
    ast_mutex_lock(&vms->lock);
    pgm = mail_newsearchpgm();
 
    /* Check IMAP folder for Asterisk messages only... */
    hdr = mail_newsearchheader("X-Asterisk-VM-Extension", (!ast_strlen_zero(vmu->imapvmshareid) ? vmu->imapvmshareid : vmu->mailbox));
    hdr->next = mail_newsearchheader("X-Asterisk-VM-Context", vmu->context);
    pgm->header = hdr;
    pgm->deleted = 0;
    pgm->undeleted = 1;
 
    /* if box = NEW_FOLDER, check for new, if box = OLD_FOLDER, check for read */
    if (box == NEW_FOLDER && urgent == 1) {
        pgm->unseen = 1;
        pgm->seen = 0;
        pgm->flagged = 1;
        pgm->unflagged = 0;
    } else if (box == NEW_FOLDER && urgent == 0) {
        pgm->unseen = 1;
        pgm->seen = 0;
        pgm->flagged = 0;
        pgm->unflagged = 1;
    } else if (box == OLD_FOLDER) {
        pgm->seen = 1;
        pgm->unseen = 0;
    }
 
    ast_debug(3, "Before mail_search_full, user is %s\n", vmu->imapuser);
 
    vms->vmArrayIndex = 0;
    mail_search_full (vms->mailstream, NULL, pgm, NIL);
    vms->lastmsg = vms->vmArrayIndex - 1;
    mail_free_searchpgm(&pgm);
    /* Since IMAP storage actually stores both old and new messages in the same IMAP folder,
     * ensure to allocate enough space to account for all of them. Warn if old messages
     * have not been checked first as that is required.
     */
    if (box == 0 && !vms->dh_arraysize) {
        ast_log(LOG_WARNING, "The code expects the old messages to be checked first, fix the code.\n");
    }
    if (vm_allocate_dh(vms, vmu, box == 0 ? vms->vmArrayIndex + vms->oldmessages : vms->lastmsg)) {
        ast_mutex_unlock(&vms->lock);
        return -1;
    }
 
    ast_mutex_unlock(&vms->lock);
    return 0;
}
 
static void write_file(char *filename, char *buffer, unsigned long len)
{
    FILE *output;
 
    if (!filename || !buffer) {
        return;
    }
 
    if (!(output = fopen(filename, "w"))) {
        ast_log(LOG_ERROR, "Unable to open/create file %s: %s\n", filename, strerror(errno));
        return;
    }
 
    if (fwrite(buffer, len, 1, output) != 1) {
        if (ferror(output)) {
            ast_log(LOG_ERROR, "Short write while writing e-mail body: %s.\n", strerror(errno));
        }
    }
    fclose (output);
}
 
static void update_messages_by_imapuser(const char *user, unsigned long number)
{
    struct vm_state *vms = get_vm_state_by_imapuser(user, 1);
 
    if (!vms && !(vms = get_vm_state_by_imapuser(user, 0))) {
        return;
    }
 
    ast_debug(3, "saving mailbox message number %lu as message %d. Interactive set to %d\n", number, vms->vmArrayIndex, vms->interactive);
 
    /* Ensure we have room for the next message. */
    if (vms->vmArrayIndex >= vms->msg_array_max) {
        long *new_mem = ast_realloc(vms->msgArray, 2 * vms->msg_array_max * sizeof(long));
        if (!new_mem) {
            return;
        }
        vms->msgArray = new_mem;
        vms->msg_array_max *= 2;
    }
 
    vms->msgArray[vms->vmArrayIndex++] = number;
}
 
void mm_searched(MAILSTREAM *stream, unsigned long number)
{
    char *mailbox = stream->mailbox, buf[1024] = "", *user;
 
    if (!(user = get_user_by_mailbox(mailbox, buf, sizeof(buf))))
        return;
 
    update_messages_by_imapuser(user, number);
}
 
static struct ast_vm_user *find_user_realtime_imapuser(const char *imapuser)
{
    struct ast_variable *var;
    struct ast_vm_user *vmu;
 
    vmu = ast_calloc(1, sizeof *vmu);
    if (!vmu)
        return NULL;
 
    populate_defaults(vmu);
    ast_set_flag(vmu, VM_ALLOCED);
 
    var = ast_load_realtime("voicemail", "imapuser", imapuser, NULL);
    if (var) {
        apply_options_full(vmu, var);
        ast_variables_destroy(var);
        return vmu;
    } else {
        ast_free(vmu);
        return NULL;
    }
}
 
/* Interfaces to C-client */
 
void mm_exists(MAILSTREAM * stream, unsigned long number)
{
    /* mail_ping will callback here if new mail! */
    ast_debug(4, "Entering EXISTS callback for message %ld\n", number);
    if (number == 0) return;
    set_update(stream);
}
 
 
void mm_expunged(MAILSTREAM * stream, unsigned long number)
{
    /* mail_ping will callback here if expunged mail! */
    ast_debug(4, "Entering EXPUNGE callback for message %ld\n", number);
    if (number == 0) return;
    set_update(stream);
}
 
 
void mm_flags(MAILSTREAM * stream, unsigned long number)
{
    /* mail_ping will callback here if read mail! */
    ast_debug(4, "Entering FLAGS callback for message %ld\n", number);
    if (number == 0) return;
    set_update(stream);
}
 
 
void mm_notify(MAILSTREAM * stream, char *string, long errflg)
{
    ast_debug(5, "Entering NOTIFY callback, errflag is %ld, string is %s\n", errflg, string);
    mm_log (string, errflg);
}
 
 
void mm_list(MAILSTREAM * stream, int delim, char *mailbox, long attributes)
{
    if (delimiter == '\0') {
        delimiter = delim;
    }
 
    ast_debug(5, "Delimiter set to %c and mailbox %s\n", delim, mailbox);
    if (attributes & LATT_NOINFERIORS)
        ast_debug(5, "no inferiors\n");
    if (attributes & LATT_NOSELECT)
        ast_debug(5, "no select\n");
    if (attributes & LATT_MARKED)
        ast_debug(5, "marked\n");
    if (attributes & LATT_UNMARKED)
        ast_debug(5, "unmarked\n");
}
 
 
void mm_lsub(MAILSTREAM * stream, int delim, char *mailbox, long attributes)
{
    ast_debug(5, "Delimiter set to %c and mailbox %s\n", delim, mailbox);
    if (attributes & LATT_NOINFERIORS)
        ast_debug(5, "no inferiors\n");
    if (attributes & LATT_NOSELECT)
        ast_debug(5, "no select\n");
    if (attributes & LATT_MARKED)
        ast_debug(5, "marked\n");
    if (attributes & LATT_UNMARKED)
        ast_debug(5, "unmarked\n");
}
 
 
void mm_status(MAILSTREAM * stream, char *mailbox, MAILSTATUS * status)
{
    struct ast_str *str;
 
    if (!DEBUG_ATLEAST(5) || !(str = ast_str_create(256))) {
        return;
    }
 
    ast_str_append(&str, 0, " Mailbox %s", mailbox);
    if (status->flags & SA_MESSAGES) {
        ast_str_append(&str, 0, ", %lu messages", status->messages);
    }
    if (status->flags & SA_RECENT) {
        ast_str_append(&str, 0, ", %lu recent", status->recent);
    }
    if (status->flags & SA_UNSEEN) {
        ast_str_append(&str, 0, ", %lu unseen", status->unseen);
    }
    if (status->flags & SA_UIDVALIDITY) {
        ast_str_append(&str, 0, ", %lu UID validity", status->uidvalidity);
    }
    if (status->flags & SA_UIDNEXT) {
        ast_str_append(&str, 0, ", %lu next UID", status->uidnext);
    }
    ast_log(LOG_DEBUG, "%s\n", ast_str_buffer(str));
 
    ast_free(str);
}
 
 
void mm_log(char *string, long errflg)
{
    switch ((short) errflg) {
        case NIL:
            ast_debug(1, "IMAP Info: %s\n", string);
            break;
        case PARSE:
        case WARN:
            ast_log(AST_LOG_WARNING, "IMAP Warning: %s\n", string);
            break;
        case ERROR:
            ast_log(AST_LOG_ERROR, "IMAP Error: %s\n", string);
            break;
    }
}
 
 
void mm_dlog(char *string)
{
    ast_log(AST_LOG_NOTICE, "%s\n", string);
}
 
 
void mm_login(NETMBX * mb, char *user, char *pwd, long trial)
{
    struct ast_vm_user *vmu;
 
    ast_debug(4, "Entering callback mm_login\n");
 
    ast_copy_string(user, mb->user, MAILTMPLEN);
 
    /* We should only do this when necessary */
    if (!ast_strlen_zero(authpassword)) {
        ast_copy_string(pwd, authpassword, MAILTMPLEN);
    } else {
        AST_LIST_TRAVERSE(&users, vmu, list) {
            if (!strcasecmp(mb->user, vmu->imapuser)) {
                ast_copy_string(pwd, vmu->imappassword, MAILTMPLEN);
                break;
            }
        }
        if (!vmu) {
            if ((vmu = find_user_realtime_imapuser(mb->user))) {
                ast_copy_string(pwd, vmu->imappassword, MAILTMPLEN);
                free_user(vmu);
            }
        }
    }
}
 
 
void mm_critical(MAILSTREAM * stream)
{
}
 
 
void mm_nocritical(MAILSTREAM * stream)
{
}
 
 
long mm_diskerror(MAILSTREAM * stream, long errcode, long serious)
{
    kill (getpid (), SIGSTOP);
    return NIL;
}
 
 
void mm_fatal(char *string)
{
    ast_log(AST_LOG_ERROR, "IMAP access FATAL error: %s\n", string);
}
 
/* C-client callback to handle quota */
static void mm_parsequota(MAILSTREAM *stream, unsigned char *msg, QUOTALIST *pquota)
{
    struct vm_state *vms;
    char *mailbox = stream->mailbox, *user;
    char buf[1024] = "";
    unsigned long usage = 0, limit = 0;
 
    while (pquota) {
        usage = pquota->usage;
        limit = pquota->limit;
        pquota = pquota->next;
    }
 
    if (!(user = get_user_by_mailbox(mailbox, buf, sizeof(buf))) || (!(vms = get_vm_state_by_imapuser(user, 2)) && !(vms = get_vm_state_by_imapuser(user, 0)))) {
        ast_log(AST_LOG_ERROR, "No state found.\n");
        return;
    }
 
    ast_debug(3, "User %s usage is %lu, limit is %lu\n", user, usage, limit);
 
    vms->quota_usage = usage;
    vms->quota_limit = limit;
}
 
static char *get_header_by_tag(char *header, char *tag, char *buf, size_t len)
{
    char *start, *eol_pnt;
    int taglen;
 
    if (ast_strlen_zero(header) || ast_strlen_zero(tag))
        return NULL;
 
    taglen = strlen(tag) + 1;
    if (taglen < 1)
        return NULL;
 
    if (!(start = strcasestr(header, tag)))
        return NULL;
 
    /* Since we can be called multiple times we should clear our buffer */
    memset(buf, 0, len);
 
    ast_copy_string(buf, start+taglen, len);
    if ((eol_pnt = strchr(buf,'\r')) || (eol_pnt = strchr(buf,'\n')))
        *eol_pnt = '\0';
    return buf;
}
 
static char *get_user_by_mailbox(char *mailbox, char *buf, size_t len)
{
    char *start, *eol_pnt, *quote;
 
    if (ast_strlen_zero(mailbox))
        return NULL;
 
    if (!(start = strstr(mailbox, "/user=")))
        return NULL;
 
    ast_copy_string(buf, start+6, len);
 
    if (!(quote = strchr(buf, '"'))) {
        if ((eol_pnt = strchr(buf, '/')) || (eol_pnt = strchr(buf, '}'))) {
            *eol_pnt = '\0';
        }
        return buf;
    } else {
        if ((eol_pnt = strchr(quote + 1, '"'))) {
            *eol_pnt = '\0';
        }
        return quote + 1;
    }
}
 
static struct vm_state *create_vm_state_from_user(struct ast_vm_user *vmu)
{
    struct vm_state *vms_p;
 
    pthread_once(&ts_vmstate.once, ts_vmstate.key_init);
    if ((vms_p = pthread_getspecific(ts_vmstate.key)) && !strcmp(vms_p->imapuser, vmu->imapuser) && !strcmp(vms_p->username, vmu->mailbox)) {
        return vms_p;
    }
    ast_debug(5, "Adding new vmstate for %s\n", vmu->imapuser);
    /* XXX: Is this correctly freed always? */
    if (!(vms_p = ast_calloc(1, sizeof(*vms_p))))
        return NULL;
    ast_copy_string(vms_p->imapuser, vmu->imapuser, sizeof(vms_p->imapuser));
    ast_copy_string(vms_p->imapfolder, vmu->imapfolder, sizeof(vms_p->imapfolder));
    ast_copy_string(vms_p->imapserver, vmu->imapserver, sizeof(vms_p->imapserver));
    ast_copy_string(vms_p->imapport, vmu->imapport, sizeof(vms_p->imapport));
    ast_copy_string(vms_p->imapflags, vmu->imapflags, sizeof(vms_p->imapflags));
    ast_copy_string(vms_p->username, vmu->mailbox, sizeof(vms_p->username)); /* save for access from interactive entry point */
    ast_copy_string(vms_p->context, vmu->context, sizeof(vms_p->context));
    vms_p->mailstream = NIL; /* save for access from interactive entry point */
    vms_p->imapversion = vmu->imapversion;
    ast_debug(5, "Copied %s to %s\n", vmu->imapuser, vms_p->imapuser);
    vms_p->updated = 1;
    /* set mailbox to INBOX! */
    ast_copy_string(vms_p->curbox, mbox(vmu, 0), sizeof(vms_p->curbox));
    init_vm_state(vms_p);
    vmstate_insert(vms_p);
    return vms_p;
}
 
static struct vm_state *get_vm_state_by_imapuser(const char *user, int interactive)
{
    struct vmstate *vlist = NULL;
 
    if (interactive) {
        struct vm_state *vms;
        pthread_once(&ts_vmstate.once, ts_vmstate.key_init);
        if ((vms = pthread_getspecific(ts_vmstate.key)) && !strcmp(vms->imapuser, user)) {
            return vms;
        }
    }
 
    AST_LIST_LOCK(&vmstates);
    AST_LIST_TRAVERSE(&vmstates, vlist, list) {
        if (!vlist->vms) {
            ast_debug(3, "error: vms is NULL for %s\n", user);
            continue;
        }
        if (vlist->vms->imapversion != imapversion) {
            continue;
        }
 
        if (!strcmp(vlist->vms->imapuser, user) && (interactive == 2 || vlist->vms->interactive == interactive)) {
            AST_LIST_UNLOCK(&vmstates);
            return vlist->vms;
        }
    }
    AST_LIST_UNLOCK(&vmstates);
 
    ast_debug(3, "%s not found in vmstates\n", user);
 
    return NULL;
}
 
static struct vm_state *get_vm_state_by_mailbox(const char *mailbox, const char *context, int interactive)
{
 
    struct vmstate *vlist = NULL;
    const char *local_context = S_OR(context, "default");
 
    if (interactive) {
        struct vm_state *vms;
        pthread_once(&ts_vmstate.once, ts_vmstate.key_init);
        if ((vms = pthread_getspecific(ts_vmstate.key)) &&
            !strcmp(vms->username,mailbox) && !strcmp(vms->context, local_context)) {
            return vms;
        }
    }
 
    AST_LIST_LOCK(&vmstates);
    AST_LIST_TRAVERSE(&vmstates, vlist, list) {
        if (!vlist->vms) {
            ast_debug(3, "error: vms is NULL for %s\n", mailbox);
            continue;
        }
        if (vlist->vms->imapversion != imapversion) {
            continue;
        }
 
        ast_debug(3, "comparing mailbox %s@%s (i=%d) to vmstate mailbox %s@%s (i=%d)\n", mailbox, local_context, interactive, vlist->vms->username, vlist->vms->context, vlist->vms->interactive);
 
        if (!strcmp(vlist->vms->username, mailbox) && !strcmp(vlist->vms->context, local_context) && vlist->vms->interactive == interactive) {
            ast_debug(3, "Found it!\n");
            AST_LIST_UNLOCK(&vmstates);
            return vlist->vms;
        }
    }
    AST_LIST_UNLOCK(&vmstates);
 
    ast_debug(3, "%s not found in vmstates\n", mailbox);
 
    return NULL;
}
 
static void vmstate_insert(struct vm_state *vms)
{
    struct vmstate *v;
    struct vm_state *altvms;
 
    /* If interactive, it probably already exists, and we should
       use the one we already have since it is more up to date.
       We can compare the username to find the duplicate */
    if (vms->interactive == 1) {
        altvms = get_vm_state_by_mailbox(vms->username, vms->context, 0);
        if (altvms) {
            ast_debug(3, "Duplicate mailbox %s, copying message info...\n", vms->username);
            vms->newmessages = altvms->newmessages;
            vms->oldmessages = altvms->oldmessages;
            vms->vmArrayIndex = altvms->vmArrayIndex;
            /* XXX: no msgArray copying? */
            vms->lastmsg = altvms->lastmsg;
            vms->curmsg = altvms->curmsg;
            /* get a pointer to the persistent store */
            vms->persist_vms = altvms;
            /* Reuse the mailstream? */
#ifdef REALLY_FAST_EVEN_IF_IT_MEANS_RESOURCE_LEAKS
            vms->mailstream = altvms->mailstream;
#else
            vms->mailstream = NIL;
#endif
        }
        return;
    }
 
    if (!(v = ast_calloc(1, sizeof(*v))))
        return;
 
    v->vms = vms;
 
    ast_debug(3, "Inserting vm_state for user:%s, mailbox %s\n", vms->imapuser, vms->username);
 
    AST_LIST_LOCK(&vmstates);
    AST_LIST_INSERT_TAIL(&vmstates, v, list);
    AST_LIST_UNLOCK(&vmstates);
}
 
static void vmstate_delete(struct vm_state *vms)
{
    struct vmstate *vc = NULL;
    struct vm_state *altvms = NULL;
 
    /* If interactive, we should copy pertinent info
       back to the persistent state (to make update immediate) */
    if (vms->interactive == 1 && (altvms = vms->persist_vms)) {
        ast_debug(3, "Duplicate mailbox %s, copying message info...\n", vms->username);
        altvms->newmessages = vms->newmessages;
        altvms->oldmessages = vms->oldmessages;
        altvms->updated = 1;
        vms->mailstream = mail_close(vms->mailstream);
 
        /* Interactive states are not stored within the persistent list */
        return;
    }
 
    ast_debug(3, "Removing vm_state for user:%s, mailbox %s\n", vms->imapuser, vms->username);
 
    AST_LIST_LOCK(&vmstates);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&vmstates, vc, list) {
        if (vc->vms == vms) {
            AST_LIST_REMOVE_CURRENT(list);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END
    AST_LIST_UNLOCK(&vmstates);
 
    if (vc) {
        ast_mutex_destroy(&vc->vms->lock);
        ast_free(vc->vms->msgArray);
        vc->vms->msgArray = NULL;
        vc->vms->msg_array_max = 0;
        /* XXX: is no one supposed to free vms itself? */
        ast_free(vc);
    } else {
        ast_log(AST_LOG_ERROR, "No vmstate found for user:%s, mailbox %s\n", vms->imapuser, vms->username);
    }
}
 
static void set_update(MAILSTREAM * stream)
{
    struct vm_state *vms;
    char *mailbox = stream->mailbox, *user;
    char buf[1024] = "";
 
    if (!(user = get_user_by_mailbox(mailbox, buf, sizeof(buf))) || !(vms = get_vm_state_by_imapuser(user, 0))) {
        if (user && DEBUG_ATLEAST(3))
            ast_log(AST_LOG_WARNING, "User %s mailbox not found for update.\n", user);
        return;
    }
 
    ast_debug(3, "User %s mailbox set for update.\n", user);
 
    vms->updated = 1; /* Set updated flag since mailbox changed */
}
 
static void init_vm_state(struct vm_state *vms)
{
    vms->msg_array_max = VMSTATE_MAX_MSG_ARRAY;
    vms->msgArray = ast_calloc(vms->msg_array_max, sizeof(long));
    if (!vms->msgArray) {
        /* Out of mem? This can't be good. */
        vms->msg_array_max = 0;
    }
    vms->vmArrayIndex = 0;
    ast_mutex_init(&vms->lock);
}
 
static int save_body(BODY *body, struct vm_state *vms, char *section, char *format, int is_intro)
{
    char *body_content;
    char *body_decoded;
    char *fn = is_intro ? vms->introfn : vms->fn;
    unsigned long len = 0;
    unsigned long newlen = 0;
    char filename[256];
 
    if (!body || body == NIL)
        return -1;
 
    ast_mutex_lock(&vms->lock);
    body_content = mail_fetchbody(vms->mailstream, vms->msgArray[vms->curmsg], section, &len);
    ast_mutex_unlock(&vms->lock);
    if (len > MAX_MAIL_BODY_CONTENT_SIZE) {
        ast_log(AST_LOG_ERROR,
            "Msgno %ld, section %s. The body's content size %ld is huge (max %ld). User:%s, mailbox %s\n",
            vms->msgArray[vms->curmsg], section, len, MAX_MAIL_BODY_CONTENT_SIZE, vms->imapuser, vms->username);
        return -1;
    }
    if (body_content != NIL && len) {
        snprintf(filename, sizeof(filename), "%s.%s", fn, format);
        /* ast_debug(1, body_content); */
        body_decoded = rfc822_base64((unsigned char *) body_content, len, &newlen);
        /* If the body of the file is empty, return an error */
        if (!newlen || !body_decoded) {
            return -1;
        }
        write_file(filename, (char *) body_decoded, newlen);
    } else {
        ast_debug(5, "Body of message is NULL.\n");
        return -1;
    }
    return 0;
}
 
/*!
 * \brief Get delimiter via mm_list callback
 * \param vms       The voicemail state object
 * \param stream
 *
 * Determines the delimiter character that is used by the underlying IMAP based mail store.
 */
/* MUTEX should already be held */
static void get_mailbox_delimiter(struct vm_state *vms, MAILSTREAM *stream) {
    char tmp[50];
    snprintf(tmp, sizeof(tmp), "{%s}", S_OR(vms->imapserver, imapserver));
    mail_list(stream, tmp, "*");
}
 
/*!
 * \brief Check Quota for user
 * \param vms a pointer to a vm_state struct, will use the mailstream property of this.
 * \param mailbox the mailbox to check the quota for.
 *
 * Calls imap_getquotaroot, which will populate its results into the vm_state vms input structure.
 */
static void check_quota(struct vm_state *vms, char *mailbox) {
    ast_mutex_lock(&vms->lock);
    mail_parameters(NULL, SET_QUOTA, (void *) mm_parsequota);
    ast_debug(3, "Mailbox name set to: %s, about to check quotas\n", mailbox);
    if (vms && vms->mailstream != NULL) {
        imap_getquotaroot(vms->mailstream, mailbox);
    } else {
        ast_log(AST_LOG_WARNING, "Mailstream not available for mailbox: %s\n", mailbox);
    }
    ast_mutex_unlock(&vms->lock);
}
 
#endif /* IMAP_STORAGE */
 
/*! \brief Lock file path
 * 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;
    }
}
 
#define MSG_ID_LEN 256
 
/* Used to attach a unique identifier to an msg_id */
static int msg_id_incrementor;
 
/*!
 * \brief Sets the destination string to a uniquely identifying msg_id string
 * \param dst pointer to a character buffer that should contain MSG_ID_LEN characters.
 */
static void generate_msg_id(char *dst);
 
#ifdef ODBC_STORAGE
 
/*!
 * \internal
 * \brief Create a buffer containing the SQL statement with the table name inserted.
 *
 * \param __sql_fmt The SQL statement with a single '%s' where the table name should be inserted.
 *
 * \note The buffer is allocated on the stack and should not be freed.
 *
 * \return A pointer to a buffer containing the SQL statement with the table name inserted.
 */
#define MAKE_SQL_PTRA(__sql_fmt) \
({ \
    /* The NULL terminator is included in odbc_table_len. */ \
    char *__sql = ast_alloca(strlen(__sql_fmt) + odbc_table_len); \
    sprintf(__sql, __sql_fmt, odbc_table); /* Safe */ \
    __sql; \
})
 
/*!
 * \internal
 * \brief Create a buffer containing the SQL statement with the table name inserted twice.
 *
 * \param __sql_fmt The SQL statement with two '%s' where the table name should be inserted.
 *
 * \note The buffer is allocated on the stack and should not be freed.
 *
 * \return A pointer to a buffer containing the SQL statement with the table name inserted.
 */
#define MAKE_SQL_PTRA2(__sql_fmt) \
({ \
    /* The NULL terminator is included in odbc_table_len. */ \
    char *__sql = ast_alloca(strlen(__sql_fmt) + (odbc_table_len * 2)); \
    sprintf(__sql, __sql_fmt, odbc_table, odbc_table); /* Safe */ \
    __sql; \
})
 
struct generic_prepare_struct {
    char *sql;
    int argc;
    char **argv;
};
 
static SQLHSTMT generic_prepare(struct odbc_obj *obj, void *data)
{
    struct generic_prepare_struct *gps = data;
    int res, i;
    SQLHSTMT stmt;
 
    res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Alloc Handle failed!\n");
        return NULL;
    }
    res = ast_odbc_prepare(obj, stmt, gps->sql);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Prepare failed![%s]\n", gps->sql);
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
        return NULL;
    }
    for (i = 0; i < gps->argc; i++)
        SQLBindParameter(stmt, i + 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(gps->argv[i]), 0, gps->argv[i], 0, NULL);
 
    return stmt;
}
 
static void odbc_update_msg_id(char *dir, int msg_num, char *msg_id)
{
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("UPDATE %s SET msg_id=? WHERE dir=? AND msgnum=?");
    struct odbc_obj *obj;
    char msg_num_str[20];
    char *argv[] = { msg_id, dir, msg_num_str };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 3, .argv = argv };
    SCOPE_ENTER(3, "dir: %s msg_num: %d msg_id: %s\n", dir, msg_num, msg_id);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN(LOG_WARNING, "Unable to update message ID for message %d in %s\n", msg_num, dir);
    }
 
    snprintf(msg_num_str, sizeof(msg_num_str), "%d", msg_num);
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
    } else {
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    }
    ast_odbc_release_obj(obj);
    SCOPE_EXIT_RTN();
}
 
#define AUDIO_ON_DISK_MAGIC "AUDMAGIC"
#define AUDIO_ON_DISK_MAGIC_LEN 8
 
static void odbc_update_set_audmagic(char *dir, int msg_num)
{
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("UPDATE %s SET recording=? WHERE dir=? AND msgnum=?");
    struct odbc_obj *obj;
    SQLLEN datalen = AUDIO_ON_DISK_MAGIC_LEN;
    SQLLEN indlen = datalen;
    int res;
    char msg_num_str[20];
    SCOPE_ENTER(3, "dir: %s msg_num: %d\n", dir, msg_num);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN(LOG_WARNING, "Unable to request obj for message %d in %s\n", msg_num, dir);
    }
 
    res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
    if (!SQL_SUCCEEDED(res)) {
        ast_odbc_release_obj(obj);
        SCOPE_EXIT_LOG_RTN(LOG_WARNING, "Unable to allocate stmt for message %d in %s\n", msg_num, dir);
    }
 
    snprintf(msg_num_str, sizeof(msg_num_str), "%d", msg_num);
 
    SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY,
        datalen, 0, (void *) AUDIO_ON_DISK_MAGIC,
        datalen, &indlen);
 
    SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR,
        strlen(dir), 0, (void *) dir, 0, NULL);
 
    SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR,
        strlen(msg_num_str), 0, (void *) msg_num_str, 0, NULL);
 
    res = ast_odbc_execute_sql(obj, stmt, sql);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(LOG_WARNING, "Unable to execute stmt for message %d in %s\n", msg_num, dir);
        ast_odbc_print_errors(SQL_HANDLE_STMT, stmt, "SQL Execute");
    }
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    stmt = NULL;
 
    ast_odbc_release_obj(obj);
    SCOPE_EXIT_RTN("Done\n");
}
 
static int odbc_store_message(const char *dir, const char *mailboxuser, const char *mailboxcontext, int msgnum);
 
/*!
 * \brief Retrieves a file from an ODBC data store.
 * \param dir the path to the file to be retrieved.
 * \param msgnum the message number, such as within a mailbox folder.
 *
 * This method is used by the RETRIEVE macro when mailboxes are stored in an ODBC back end.
 * The purpose is to get the message from the database store to the local file system, so that the message may be played, or the information file may be read.
 *
 * The file is looked up by invoking a SQL on the odbc_table (default 'voicemessages') using the dir and msgnum input parameters.
 * The output is the message information file with the name msgnum and the extension .txt
 * and the message file with the extension of its format, in the directory with base file name of the msgnum.
 *
 * \return 0 on success, -1 on error.
 */
static int odbc_retrieve_message(char *dir, int msgnum)
{
    int x = 0;
    int res;
    int fd = -1;
    size_t fdlen = 0;
    void *fdm = MAP_FAILED;
    SQLSMALLINT colcount = 0;
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("SELECT * FROM %s WHERE dir=? AND msgnum=?");
    char fmt[80] = "";
    char *c;
    char coltitle[256];
    SQLSMALLINT collen;
    SQLSMALLINT datatype;
    SQLSMALLINT decimaldigits;
    SQLSMALLINT nullable;
    SQLULEN colsize;
    SQLLEN colsize2;
    FILE *f = NULL;
    char rowdata[80];
    char *fn = MAKE_FILE_PTRA(dir, msgnum);
    char *full_fn = MAKE_FILE_EXT_PTRA(dir, msgnum, "txt");
    char msgnums[80];
    char *mailboxuser = NULL;
    char *mailboxcontext = NULL;
    char msg_id[MSG_ID_LEN] = "";
    char *argv[] = { dir, msgnums };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 2, .argv = argv };
    struct odbc_obj *obj;
    int storage_conversion_to_disk = 0;
    int storage_conversion_to_odbc = 0;
    SCOPE_ENTER(3, "dir: %s msgnum: %d  msgtype: %s\n", dir, msgnum, msgnum < 0 ? "Greeting" : "Message");
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN_VALUE(-1, AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    ast_copy_string(fmt, vmfmts, sizeof(fmt));
    c = strchr(fmt, '|');
    if (c)
        *c = '\0';
    if (!strcasecmp(fmt, "wav49"))
        strcpy(fmt, "WAV");
 
    snprintf(msgnums, sizeof(msgnums), "%d", msgnum);
 
    ast_trace(-1, "Opening '%s' for writing\n", full_fn);
    if (!(f = fopen(full_fn, "w+"))) {
        ast_log(AST_LOG_WARNING, "Failed to open/create '%s'\n", full_fn);
        goto bail;
    }
 
    sprintf(full_fn, "%s.%s", fn, fmt); /* Safe.  We're just replacing the file exten. */
 
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
        goto bail;
    }
 
    res = SQLFetch(stmt);
    if (!SQL_SUCCEEDED(res)) {
        if (res != SQL_NO_DATA) {
            ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
        }
        goto bail_with_handle;
    }
 
    res = SQLNumResultCols(stmt, &colcount);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    fprintf(f, "[message]\n");
    for (x = 0; x < colcount; x++) {
        rowdata[0] = '\0';
        colsize = 0;
        collen = sizeof(coltitle);
        res = SQLDescribeCol(stmt, x + 1, (unsigned char *) coltitle, sizeof(coltitle), &collen,
                            &datatype, &colsize, &decimaldigits, &nullable);
        if (!SQL_SUCCEEDED(res)) {
            ast_log(AST_LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
            goto bail_with_handle;
        }
 
        if (!strcasecmp(coltitle, "recording")) {
            off_t offset;
            char tmp[1] = "";
 
            res = SQLGetData(stmt, x + 1, SQL_BINARY, rowdata, 0, &colsize2);
            fdlen = colsize2;
            ast_trace(-1, "Audio size: %ld\n", colsize2);
            if (colsize2 == AUDIO_ON_DISK_MAGIC_LEN) {
                res = SQLGetData(stmt, x + 1, SQL_BINARY, rowdata, AUDIO_ON_DISK_MAGIC_LEN, NULL);
                if (memcmp(rowdata, AUDIO_ON_DISK_MAGIC, AUDIO_ON_DISK_MAGIC_LEN) != 0) {
                    ast_log(AST_LOG_WARNING, "Invalid audio magic number '0x%02X%02X%02X%02X%02X%02X%02X%02X' for '%s'\n",
                        rowdata[0], rowdata[1], rowdata[2], rowdata[3], rowdata[4], rowdata[5], rowdata[6],
                        rowdata[7], full_fn);
                    goto bail_with_handle;
                }
                ast_trace(-1, "Audio is stored on disk.  No need to write '%s'\n", full_fn);
                if (!ast_test_flag((&globalflags), VM_ODBC_AUDIO_ON_DISK)) {
                    storage_conversion_to_odbc = 1;
                }
 
                continue;
            }
 
            ast_trace(-1, "Opening '%s' for writing\n", full_fn);
            fd = open(full_fn, O_RDWR | O_CREAT | O_TRUNC, VOICEMAIL_FILE_MODE);
            if (fd < 0) {
                ast_log(AST_LOG_WARNING, "Failed to open '%s' for writing: %s\n", full_fn, strerror(errno));
                goto bail_with_handle;
            }
            if (ast_test_flag((&globalflags), VM_ODBC_AUDIO_ON_DISK)) {
                storage_conversion_to_disk = 1;
            }
 
            lseek(fd, fdlen - 1, SEEK_SET);
            if (write(fd, tmp, 1) != 1) {
                close(fd);
                fd = -1;
                continue;
            }
            /* Read out in small chunks */
            for (offset = 0; offset < colsize2; offset += CHUNKSIZE) {
                if ((fdm = mmap(NULL, CHUNKSIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset)) == MAP_FAILED) {
                    ast_log(AST_LOG_WARNING, "Could not mmap the output file: %s (%d)\n", strerror(errno), errno);
                    goto bail_with_handle;
                }
                res = SQLGetData(stmt, x + 1, SQL_BINARY, fdm, CHUNKSIZE, NULL);
                munmap(fdm, CHUNKSIZE);
                if (!SQL_SUCCEEDED(res)) {
                    ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
                    unlink(full_fn);
                    goto bail_with_handle;
                }
            }
            if (truncate(full_fn, fdlen) < 0) {
                ast_log(LOG_WARNING, "Unable to truncate '%s': %s\n", full_fn, strerror(errno));
            }
            ast_trace(-1, "Wrote %d bytes to '%s'\n", (int)fdlen, full_fn);
        } else {
            res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
            if (res == SQL_NULL_DATA && !strcasecmp(coltitle, "msg_id")) {
                /*
                 * Generate msg_id if there wasn't one, but don't store it until we're
                 * done with this connection.
                 */
                generate_msg_id(msg_id);
                ast_trace(-1, "msg_id was NULL.  Generating new one: %s\n", msg_id);
                snprintf(rowdata, sizeof(rowdata), "%s", msg_id);
            } else if (!strcasecmp(coltitle, "mailboxuser")) {
                mailboxuser = ast_strdupa(rowdata);
            } else if (!strcasecmp(coltitle, "mailboxcontext")) {
                mailboxcontext = ast_strdupa(rowdata);
            } else if (res == SQL_NULL_DATA && !strcasecmp(coltitle, "category")) {
                /* Ignore null column value for category */
                ast_trace(-1, "Ignoring null category column in ODBC voicemail retrieve_file.\n");
                continue;
            } else if (!SQL_SUCCEEDED(res)) {
                ast_log(AST_LOG_WARNING, "SQL Get Data error! coltitle=%s\n[%s]\n\n", coltitle, sql);
                goto bail_with_handle;
            }
            if (strcasecmp(coltitle, "msgnum") && strcasecmp(coltitle, "dir")) {
                fprintf(f, "%s=%s\n", coltitle, rowdata);
            }
        }
    }
 
bail_with_handle:
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
bail:
    if (f)
        fclose(f);
    if (fd > -1)
        close(fd);
 
    ast_odbc_release_obj(obj);
 
    /* If res_odbc is configured to only allow a single database connection, we
       will deadlock if we try to do this before releasing the connection we
       were just using. */
    if (!ast_strlen_zero(msg_id)) {
        odbc_update_msg_id(dir, msgnum, msg_id);
    }
 
    if (SQL_SUCCEEDED(res)) {
        if (storage_conversion_to_disk) {
            /*
             * If we're currently storing audio on disk but there was pre-existing
             * audio in the database, we need to update the database to set the
             * 'recording' column to AUDIO_ON_DISK_MAGIC.
             */
            SCOPE_CALL(-1, odbc_update_set_audmagic, dir, msgnum);
        }
        if (storage_conversion_to_odbc) {
            /*
             * If we're currently storing audio in the database but there was
             * pre-existing audio on disk, we need to add the audio back
             * into the database overwriting the AUDIO_ON_DISK_MAGIC
             * magic number.
             */
            SCOPE_CALL(-1, odbc_store_message, dir, mailboxuser, mailboxcontext, msgnum);
        }
    }
 
    SCOPE_EXIT_RTN_VALUE(x - 1, "Done.  msg_id: %s RC: %d\n", msg_id, x - 1);
}
 
/*!
 * \brief Determines the highest message number in use for a given user and mailbox folder.
 * \param dir the folder the mailbox folder to look for messages. Used to construct the SQL where clause.
 *
 * This method is used when mailboxes are stored in an ODBC back end.
 * Typical use to set the msgnum would be to take the value returned from this method and add one to it.
 *
 * \return the value of zero or greater to indicate the last message index in use, -1 to indicate none.
 */
static int odbc_last_message_index(char *dir)
{
    int x = -1;
    int res;
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("SELECT msgnum FROM %s WHERE dir=? order by msgnum desc");
    char rowdata[20];
    char *argv[] = { dir };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 1, .argv = argv };
    struct odbc_obj *obj;
    SCOPE_ENTER(3, "dir: %s\n", dir);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN_VALUE(-1, AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
        goto bail;
    }
 
    res = SQLFetch(stmt);
    if (!SQL_SUCCEEDED(res)) {
        if (res == SQL_NO_DATA) {
            ast_trace(-1, "Directory '%s' has no messages and therefore no index was retrieved.\n", dir);
        } else {
            ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
        }
        goto bail_with_handle;
    }
 
    res = SQLGetData(stmt, 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    if (sscanf(rowdata, "%30d", &x) != 1) {
        ast_log(AST_LOG_WARNING, "Failed to read message index!\n");
    }
 
bail_with_handle:
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
bail:
    ast_odbc_release_obj(obj);
 
    SCOPE_EXIT_RTN_VALUE(x, "Done.  Last message index: %d\n", x);
}
 
/*!
 * \brief Determines if the specified message exists.
 * \param dir the folder the mailbox folder to look for messages.
 * \param msgnum the message index to query for.
 *
 * This method is used when mailboxes are stored in an ODBC back end.
 *
 * \return greater than zero if the message exists, zero when the message does not exist or on error.
 */
static int odbc_message_exists(char *dir, int msgnum)
{
    int x = 0;
    int res;
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("SELECT COUNT(*) FROM %s WHERE dir=? AND msgnum=?");
    char rowdata[20];
    char msgnums[20];
    char *argv[] = { dir, msgnums };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 2, .argv = argv };
    struct odbc_obj *obj;
    SCOPE_ENTER(3, "dir: %s msgnum: %d\n", dir, msgnum);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN_VALUE(0, AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    snprintf(msgnums, sizeof(msgnums), "%d", msgnum);
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
        goto bail;
    }
 
    res = SQLFetch(stmt);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    res = SQLGetData(stmt, 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    if (sscanf(rowdata, "%30d", &x) != 1) {
        ast_log(AST_LOG_WARNING, "Failed to read message count!\n");
    }
 
bail_with_handle:
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
bail:
    ast_odbc_release_obj(obj);
    SCOPE_EXIT_RTN_VALUE(x, "Done.  Msg %s\n", x ? "exists" : "does not exist");
}
 
/*!
 * \brief returns the number of messages found.
 * \param vmu
 * \param dir the folder the mailbox folder to look for messages. Used to construct the SQL where clause.
 *
 * This method is used when mailboxes are stored in an ODBC back end.
 *
 * \return The count of messages being zero or more, less than zero on error.
 */
static int odbc_count_messages(struct ast_vm_user *vmu, char *dir)
{
    int x = -1;
    int res;
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA("SELECT COUNT(*) FROM %s WHERE dir=?");
    char rowdata[20];
    char *argv[] = { dir };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 1, .argv = argv };
    struct odbc_obj *obj;
    SCOPE_ENTER(3, "dir: %s\n", dir);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN_VALUE(-1, AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
        goto bail;
    }
 
    res = SQLFetch(stmt);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    res = SQLGetData(stmt, 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
    if (!SQL_SUCCEEDED(res)) {
        ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
        goto bail_with_handle;
    }
 
    if (sscanf(rowdata, "%30d", &x) != 1) {
        ast_log(AST_LOG_WARNING, "Failed to read message count!\n");
    }
 
bail_with_handle:
    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 
bail:
    ast_odbc_release_obj(obj);
    SCOPE_EXIT_RTN_VALUE(x, "Done.  Count %d\n", x);
}
 
/*!
 * \brief Deletes a message from the mailbox folder.
 * \param sdir The mailbox folder to work in.
 * \param smsg The message index to be deleted.
 *
 * This method is used when mailboxes are stored in an ODBC back end.
 * The specified message is directly deleted from the database 'voicemessages' table.
 */
#define DELETE_SQL_FMT "DELETE FROM %s WHERE dir=? AND msgnum=?"
static void odbc_delete_message(const char *sdir, int smsg)
{
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA(DELETE_SQL_FMT);
    char msgnums[20];
    char *argv[] = { NULL, msgnums };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 2, .argv = argv };
    struct odbc_obj *obj;
    SCOPE_ENTER(3, "sdir: %s smsg: %d\n", sdir, smsg);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    argv[0] = ast_strdupa(sdir);
 
    snprintf(msgnums, sizeof(msgnums), "%d", smsg);
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt) {
        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
    } else {
        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
    }
    ast_odbc_release_obj(obj);
 
    if (ast_test_flag((&globalflags), VM_ODBC_AUDIO_ON_DISK)) {
        char *src_fn = MAKE_FILE_PTRA(sdir, smsg);
        ast_trace(-1, "Audio stored on disk. Deleting '%s'\n", src_fn);
        ast_filedelete(src_fn, NULL);
    }
 
    SCOPE_EXIT_RTN("Done\n");
}
 
/*!
 * \brief Copies a voicemail from one mailbox to another.
 * \param sdir the folder for which to look for the message to be copied.
 * \param smsg the index of the message to be copied.
 * \param ddir the destination folder to copy the message into.
 * \param dmsg the index to be used for the copied message.
 * \param dmailboxuser The user who owns the mailbox tha contains the destination folder.
 * \param dmailboxcontext The context for the destination user.
 *
 * This method is used for the COPY macro when mailboxes are stored in an ODBC back end.
 */
#define COPY_SQL_FMT "INSERT INTO %s (dir, msgnum, msg_id, context, callerid, origtime, " \
    "duration, recording, flag, mailboxuser, mailboxcontext) " \
    "SELECT ?,?,msg_id,context,callerid,origtime,duration,recording,flag,?,? " \
        "FROM %s WHERE dir=? AND msgnum=?"
static void odbc_copy_message(char *sdir, int smsg, char *ddir, int dmsg, char *dmailboxuser, char *dmailboxcontext)
{
    SQLHSTMT stmt;
    char *sql = MAKE_SQL_PTRA2(COPY_SQL_FMT);
    char msgnums[20];
    char msgnumd[20];
    struct odbc_obj *obj;
    char *argv[] = { ddir, msgnumd, dmailboxuser, dmailboxcontext, sdir, msgnums };
    struct generic_prepare_struct gps = { .sql = sql, .argc = 6, .argv = argv };
    SCOPE_ENTER(3, "sdir: %s smsg: %d duser: %s dcontext: %s ddir: %s dmsg: %d\n",
        sdir, smsg, dmailboxuser, dmailboxcontext, ddir, dmsg);
 
    SCOPE_CALL(-1, odbc_delete_message, ddir, dmsg);
 
    obj = ast_odbc_request_obj(odbc_database, 0);
    if (!obj) {
        SCOPE_EXIT_LOG_RTN(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
    }
 
    snprintf(msgnums, sizeof(msgnums), "%d", smsg);
    snprintf(msgnumd, sizeof(msgnumd), "%d", dmsg);
 
    stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
    if (!stmt)
        ast_log(