[asterisk/asterisk.git] / apps / app_voicemail.c

/*
 * 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
 *
 * \brief Comedian Mail - Voicemail System
 *
 * \author Mark Spencer <markster@digium.com>
 *
 * \extref Unixodbc - http://www.unixodbc.org
 * \extref A source distribution of University of Washington's IMAP
c-client (http://www.washington.edu/imap/
 * 
 * \par See also
 * \arg \ref Config_vm
 * \note For information about voicemail IMAP storage, read doc/imapstorage.txt
 * \ingroup applications
 * \note This module requires res_adsi to load. This needs to be optional
 * during compilation.
 *
 *
 *
 * \note  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.
 */

/*** MODULEINFO
        <depend>res_smdi</depend>
 ***/

/*** MAKEOPTS
<category name="MENUSELECT_OPTS_app_voicemail" displayname="Voicemail Build Options" positive_output="yes" remove_on_change="apps/app_voicemail.o apps/app_directory.o">
        <member name="ODBC_STORAGE" displayname="Storage of Voicemail using ODBC">
                <depend>unixodbc</depend>
                <depend>ltdl</depend>
                <conflict>IMAP_STORAGE</conflict>
                <defaultenabled>no</defaultenabled>
        </member>
        <member name="IMAP_STORAGE" displayname="Storage of Voicemail using IMAP4">
                <depend>imap_tk</depend>
                <conflict>ODBC_STORAGE</conflict>
                <use>ssl</use>
                <defaultenabled>no</defaultenabled>
        </member>
</category>
 ***/

/* It is important to include the IMAP_STORAGE related headers
 * before asterisk.h since asterisk.h includes logger.h. logger.h
 * and c-client.h have conflicting definitions for AST_LOG_WARNING and
 * AST_LOG_DEBUG, so it's important that we use Asterisk's definitions
 * here instead of the c-client's 
 */
#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.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#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>

#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/say.h"
#include "asterisk/module.h"
#include "asterisk/adsi.h"
#include "asterisk/app.h"
#include "asterisk/manager.h"
#include "asterisk/dsp.h"
#include "asterisk/localtime.h"
#include "asterisk/cli.h"
#include "asterisk/utils.h"
#include "asterisk/stringfields.h"
#include "asterisk/smdi.h"
#include "asterisk/event.h"
#include "asterisk/taskprocessor.h"

#ifdef ODBC_STORAGE
#include "asterisk/res_odbc.h"
#endif

#ifdef IMAP_STORAGE
static char imapserver[48];
static char imapport[8];
static char imapflags[128];
static char imapfolder[64];
static char imapparentfolder[64] = "\0";
static char greetingfolder[64];
static char authuser[32];
static char authpassword[42];

static int expungeonhangup = 1;
static int imapgreetings = 0;
static char delimiter = '\0';

struct vm_state;
struct ast_vm_user;

/* 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(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(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(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(char *dir, char *mailboxuser, char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag);
static void update_messages_by_imapuser(const char *user, unsigned long number);

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);
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 MAXMSG 100
#define MAXMSGLIMIT 9999

#define MINPASSWORD 0 /*!< Default minimum mailbox password length */

#define BASELINELEN 72
#define BASEMAXINLINE 256
#define eol "\r\n"

#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_DIRECFORWARD  (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 ERROR_LOCK_PATH  -100


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

enum {
        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)
} vm_option_flags;

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

AST_APP_OPTIONS(vm_app_options, {
        AST_APP_OPTION('s', OPT_SILENT),
        AST_APP_OPTION('b', OPT_BUSY_GREETING),
        AST_APP_OPTION('u', OPT_UNAVAIL_GREETING),
        AST_APP_OPTION_ARG('g', OPT_RECORDGAIN, OPT_ARG_RECORDGAIN),
        AST_APP_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)
});

static int load_config(int reload);

/*! \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

Ukrainian requires the following additional soundfile:
\arg \b vm-nove         'nove'
\arg \b vm-stare        'stare'
\arg \b digits/ua/1e    'odne'

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

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.

*/

struct baseio {
        int iocp;
        int iolen;
        int linelength;
        int ateof;
        unsigned char iobuf[BASEMAXINLINE];
};

/*! Structure for linked list of users 
 * Use ast_vm_user_destroy() to free one of these structures. */
struct ast_vm_user {
        char context[AST_MAX_CONTEXT];   /*!< Voicemail context */
        char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox id, unique within vm context */
        char password[80];               /*!< Secret pin code, numbers only */
        char fullname[80];               /*!< Full name, for directory app */
        char email[80];                  /*!< E-mail address */
        char pager[80];                  /*!< E-mail address to pager (no attachment) */
        char serveremail[80];            /*!< From: Mail address */
        char mailcmd[160];               /*!< Configurable mail command */
        char language[MAX_LANGUAGE];     /*!< Config: Language setting */
        char zonetag[80];                /*!< Time zone */
        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 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 */
#ifdef IMAP_STORAGE
        char imapuser[80];               /*!< IMAP server login */
        char imappassword[80];           /*!< IMAP server password if authpassword not defined */
#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 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[VMSTATE_MAX_MSG_ARRAY];
        MAILSTREAM *mailstream;
        int vmArrayIndex;
        char imapuser[80];                   /*!< IMAP server login */
        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];
static char odbc_table[80];
#define RETRIEVE(a,b,c,d) retrieve_file(a,b)
#define DISPOSE(a,b) remove_file(a,b)
#define STORE(a,b,c,d,e,f,g,h,i,j) store_file(a,b,c,d)
#define EXISTS(a,b,c,d) (message_exists(a,b))
#define RENAME(a,b,c,d,e,f,g,h) (rename_file(a,b,c,d,e,f))
#define COPY(a,b,c,d,e,f,g,h) (copy_file(a,b,c,d,e,f))
#define DELETE(a,b,c,d) (delete_file(a,b))
#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) (imap_store_file(a,b,c,d,e,f,g,h,i,j))
#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(b,d))
#else
#define RETRIEVE(a,b,c,d)
#define DISPOSE(a,b)
#define STORE(a,b,c,d,e,f,g,h,i,j)
#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))
#endif
#endif

static char VM_SPOOL_DIR[PATH_MAX];

static char ext_pass_cmd[128];
static char ext_pass_check_cmd[128];

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";

static char *synopsis_vm = "Leave a Voicemail message";

static char *descrip_vm =
        "  VoiceMail(mailbox[@context][&mailbox[@context]][...][,options]): This\n"
        "application allows the calling party to leave a message for the specified\n"
        "list of mailboxes. When multiple mailboxes are specified, the greeting will\n"
        "be taken from the first mailbox specified. Dialplan execution will stop if the\n"
        "specified mailbox does not exist.\n"
        "  The Voicemail application will exit if any of the following DTMF digits are\n"
        "received:\n"
        "    0 - Jump to the 'o' extension in the current dialplan context.\n"
        "    * - Jump to the 'a' extension in the current dialplan context.\n"
        "  This application will set the following channel variable upon completion:\n"
        "    VMSTATUS - This indicates the status of the execution of the VoiceMail\n"
        "               application. The possible values are:\n"
        "               SUCCESS | USEREXIT | FAILED\n\n"
        "  Options:\n"
        "    b    - Play the 'busy' greeting to the calling party.\n"
        "    d([c]) - Accept digits for a new extension in context c, if played during\n"
        "             the greeting.  Context defaults to the current context.\n"
        "    g(#) - Use the specified amount of gain when recording the voicemail\n"
        "           message. The units are whole-number decibels (dB).\n"
        "           Only works on supported technologies, which is DAHDI only.\n"
        "    s    - Skip the playback of instructions for leaving a message to the\n"
        "           calling party.\n"
        "    u    - Play the 'unavailable' greeting.\n"
        "    U    - Mark message as Urgent.\n"
        "    P    - Mark message as PRIORITY.\n";

static char *synopsis_vmain = "Check Voicemail messages";

static char *descrip_vmain =
        "  VoiceMailMain([mailbox][@context][,options]): This application allows the\n"
        "calling party to check voicemail messages. A specific mailbox, and optional\n"
        "corresponding context, may be specified. If a mailbox is not provided, the\n"
        "calling party will be prompted to enter one. If a context is not specified,\n"
        "the 'default' context will be used.\n\n"
        "  Options:\n"
        "    p    - Consider the mailbox parameter as a prefix to the mailbox that\n"
        "           is entered by the caller.\n"
        "    g(#) - Use the specified amount of gain when recording a voicemail\n"
        "           message. The units are whole-number decibels (dB).\n"
        "    s    - Skip checking the passcode for the mailbox.\n"
        "    a(#) - Skip folder prompt and go directly to folder specified.\n"
        "           Defaults to INBOX\n";

static char *synopsis_vm_box_exists =
"Check to see if Voicemail mailbox exists";

static char *descrip_vm_box_exists =
        "  MailboxExists(mailbox[@context][,options]): Check to see if the specified\n"
        "mailbox exists. If no voicemail context is specified, the 'default' context\n"
        "will be used.\n"
        "  This application will set the following channel variable upon completion:\n"
        "    VMBOXEXISTSSTATUS - This will contain the status of the execution of the\n"
        "                        MailboxExists application. Possible values include:\n"
        "                        SUCCESS | FAILED\n\n"
        "  Options: (none)\n";

static char *synopsis_vmauthenticate = "Authenticate with Voicemail passwords";

static char *descrip_vmauthenticate =
        "  VMAuthenticate([mailbox][@context][,options]): This application behaves the\n"
        "same way as the Authenticate application, but the passwords are taken from\n"
        "voicemail.conf.\n"
        "  If the mailbox is specified, only that mailbox's password will be considered\n"
        "valid. If the mailbox is not specified, the channel variable AUTH_MAILBOX will\n"
        "be set with the authenticated mailbox.\n\n"
        "  Options:\n"
        "    s - Skip playing the initial prompts.\n";

/* Leave a message */
static char *app = "VoiceMail";

/* Check mail, control, etc */
static char *app2 = "VoiceMailMain";

static char *app3 = "MailboxExists";
static char *app4 = "VMAuthenticate";

static AST_LIST_HEAD_STATIC(users, ast_vm_user);
static AST_LIST_HEAD_STATIC(zones, vm_zone);
static int maxsilence;
static int maxmsg;
static int maxdeletedmsg;
static int silencethreshold = 128;
static char serveremail[80];
static char mailcmd[160];       /* Configurable mail cmd */
static char externnotify[160]; 
static struct ast_smdi_interface *smdi_iface = NULL;
static char vmfmts[80];
static double volgain;
static int vmminsecs;
static int vmmaxsecs;
static int maxgreet;
static int skipms;
static int maxlogins;
static int minpassword;

/*! Poll mailboxes for changes since there is something external to
 *  app_voicemail that may change them. */
static unsigned int poll_mailboxes;

/*! Polling frequency */
static unsigned int poll_freq;
/*! By default, poll every 30 seconds */
#define DEFAULT_POLL_FREQ 30

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;

/*! Subscription to ... MWI event subscriptions */
static struct ast_event_sub *mwi_sub_sub;
/*! Subscription to ... MWI event un-subscriptions */
static struct ast_event_sub *mwi_unsub_sub;

/*!
 * \brief An MWI subscription
 *
 * This is so we can keep track of which mailboxes are subscribed to.
 * This way, we know which mailboxes to poll when the pollmailboxes
 * option is being used.
 */
struct mwi_sub {
        AST_RWLIST_ENTRY(mwi_sub) entry;
        int old_urgent;
        int old_new;
        int old_old;
        uint32_t uniqueid;
        char mailbox[1];
};

struct mwi_sub_task {
        const char *mailbox;
        const char *context;
        uint32_t uniqueid;
};

static struct ast_taskprocessor *mwi_subscription_tps;

static AST_RWLIST_HEAD_STATIC(mwi_subs, mwi_sub);

/* 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_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 struct ast_flags globalflags = {0};

static int saydurationminfo;

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 = NULL;
static char *emailsubject = NULL;
static char *pagerbody = NULL;
static char *pagersubject = NULL;
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";

/* Forward declarations - generic */
static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box);
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, const char *unlockdir,
                        signed char record_gain, struct vm_state *vms, char *flag);
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, char *cidnum, char *cidname, char *attach, char *attach2, char *format, int duration, int attach_user_voicemail, struct ast_channel *chan, const char *category, int imap, const char *flag);
static 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);

#if !(defined(ODBC_STORAGE) || defined(IMAP_STORAGE))
static int __has_voicemail(const char *context, const char *mailbox, const char *folder, int shortcircuit);
#endif

static char *strip_control(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;
}


/*!
 * \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.
 */
static void populate_defaults(struct ast_vm_user *vmu)
{
        ast_copy_flags(vmu, (&globalflags), AST_FLAGS_ALL);     
        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));
        if (vmmaxsecs)
                vmu->maxsecs = vmmaxsecs;
        if (maxmsg)
                vmu->maxmsg = maxmsg;
        if (maxdeletedmsg)
                vmu->maxdeletedmsg = maxdeletedmsg;
        vmu->volgain = volgain;
}

/*!
 * \brief Sets a 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, "serveremail")) {
                ast_copy_string(vmu->serveremail, value, sizeof(vmu->serveremail));
        } else if (!strcasecmp(var, "language")) {
                ast_copy_string(vmu->language, value, sizeof(vmu->language));
        } else if (!strcasecmp(var, "tz")) {
                ast_copy_string(vmu->zonetag, value, sizeof(vmu->zonetag));
#ifdef IMAP_STORAGE
        } else if (!strcasecmp(var, "imapuser")) {
                ast_copy_string(vmu->imapuser, value, sizeof(vmu->imapuser));
        } else if (!strcasecmp(var, "imappassword")) {
                ast_copy_string(vmu->imappassword, value, sizeof(vmu->imappassword));
#endif
        } else if (!strcasecmp(var, "delete") || !strcasecmp(var, "deletevoicemail")) {
                ast_set2_flag(vmu, ast_true(value), VM_DELETE); 
        } else if (!strcasecmp(var, "saycid")){
                ast_set2_flag(vmu, ast_true(value), VM_SAYCID); 
        } else if (!strcasecmp(var,"sendvoicemail")){
                ast_set2_flag(vmu, ast_true(value), VM_SVMAIL); 
        } else if (!strcasecmp(var, "review")){
                ast_set2_flag(vmu, ast_true(value), VM_REVIEW);
        } else if (!strcasecmp(var, "tempgreetwarn")){
                ast_set2_flag(vmu, ast_true(value), VM_TEMPGREETWARN);  
        } else if (!strcasecmp(var, "messagewrap")){
                ast_set2_flag(vmu, ast_true(value), VM_MESSAGEWRAP);    
        } else if (!strcasecmp(var, "operator")) {
                ast_set2_flag(vmu, ast_true(value), VM_OPERATOR);       
        } else if (!strcasecmp(var, "envelope")){
                ast_set2_flag(vmu, ast_true(value), VM_ENVELOPE);       
        } else if (!strcasecmp(var, "moveheard")){
                ast_set2_flag(vmu, ast_true(value), VM_MOVEHEARD);
        } else if (!strcasecmp(var, "sayduration")){
                ast_set2_flag(vmu, ast_true(value), VM_SAYDURATION);    
        } else if (!strcasecmp(var, "saydurationm")){
                if (sscanf(value, "%d", &x) == 1) {
                        vmu->saydurationm = x;
                } else {
                        ast_log(AST_LOG_WARNING, "Invalid min duration for say duration\n");
                }
        } else if (!strcasecmp(var, "forcename")){
                ast_set2_flag(vmu, ast_true(value), VM_FORCENAME);      
        } else if (!strcasecmp(var, "forcegreetings")){
                ast_set2_flag(vmu, ast_true(value), VM_FORCEGREET);     
        } else if (!strcasecmp(var, "callback")) {
                ast_copy_string(vmu->callback, value, sizeof(vmu->callback));
        } else if (!strcasecmp(var, "dialout")) {
                ast_copy_string(vmu->dialout, value, sizeof(vmu->dialout));
        } else if (!strcasecmp(var, "exitcontext")) {
                ast_copy_string(vmu->exit, value, sizeof(vmu->exit));
        } else if (!strcasecmp(var, "maxmessage") || !strcasecmp(var, "maxsecs")) {
                if (vmu->maxsecs <= 0) {
                        ast_log(AST_LOG_WARNING, "Invalid max message length of %s. Using global value %d\n", value, vmmaxsecs);
                        vmu->maxsecs = vmmaxsecs;
                } else {
                        vmu->maxsecs = atoi(value);
                }
                if (!strcasecmp(var, "maxmessage"))
                        ast_log(AST_LOG_WARNING, "Option 'maxmessage' has been deprecated in favor of 'maxsecs'.  Please make that change in your voicemail config.\n");
        } else if (!strcasecmp(var, "maxmsg")) {
                vmu->maxmsg = atoi(value);
                if (vmu->maxmsg <= 0) {
                        ast_log(AST_LOG_WARNING, "Invalid number of messages per folder maxmsg=%s. Using default value %d\n", value, MAXMSG);
                        vmu->maxmsg = MAXMSG;
                } else if (vmu->maxmsg > MAXMSGLIMIT) {
                        ast_log(AST_LOG_WARNING, "Maximum number of messages per folder is %d. Cannot accept value maxmsg=%s\n", MAXMSGLIMIT, value);
                        vmu->maxmsg = MAXMSGLIMIT;
                }
        } else if (!strcasecmp(var, "backupdeleted")) {
                if (sscanf(value, "%d", &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, "%lf", &vmu->volgain);
        } 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]);
                        read(fds[0], buf, len);
                        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;
        if (!ast_strlen_zero(ext_pass_check_cmd)) {
                char cmd[255], buf[255];

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

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

/*! 
 * \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 the voicemail user has a unique id, and 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;
        if (!ast_strlen_zero(vmu->uniqueid)) {
                if (strlen(password) > 10) {
                        ast_realtime_require_field("voicemail", "password", RQ_CHAR, strlen(password), SENTINEL);
                }
                res = ast_update_realtime("voicemail", "uniqueid", vmu->uniqueid, "password", password, SENTINEL);
                if (res > 0) {
                        ast_copy_string(vmu->password, password, sizeof(vmu->password));
                        res = 0;
                } else if (!res) {
                        res = -1;
                }
                return res;
        }
        return -1;
}

/*!
 * \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)
{
        struct ast_variable *tmp;
        tmp = var;
        while (tmp) {
                if (!strcasecmp(tmp->name, "vmsecret")) {
                        ast_copy_string(retval->password, tmp->value, sizeof(retval->password));
                } else if (!strcasecmp(tmp->name, "secret") || !strcasecmp(tmp->name, "password")) { /* don't overwrite vmsecret if it exists */
                        if (ast_strlen_zero(retval->password))
                                ast_copy_string(retval->password, tmp->value, sizeof(retval->password));
                } else if (!strcasecmp(tmp->name, "uniqueid")) {
                        ast_copy_string(retval->uniqueid, tmp->value, sizeof(retval->uniqueid));
                } else if (!strcasecmp(tmp->name, "pager")) {
                        ast_copy_string(retval->pager, tmp->value, sizeof(retval->pager));
                } else if (!strcasecmp(tmp->name, "email")) {
                        ast_copy_string(retval->email, tmp->value, sizeof(retval->email));
                } else if (!strcasecmp(tmp->name, "fullname")) {
                        ast_copy_string(retval->fullname, tmp->value, sizeof(retval->fullname));
                } else if (!strcasecmp(tmp->name, "context")) {
                        ast_copy_string(retval->context, tmp->value, sizeof(retval->context));
#ifdef IMAP_STORAGE
                } else if (!strcasecmp(tmp->name, "imapuser")) {
                        ast_copy_string(retval->imapuser, tmp->value, sizeof(retval->imapuser));
                } else if (!strcasecmp(tmp->name, "imappassword")) {
                        ast_copy_string(retval->imappassword, tmp->value, sizeof(retval->imappassword));
#endif
                } else
                        apply_option(retval, tmp->name, tmp->value);
                tmp = tmp->next;
        } 
}

/*!
 * \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)
                        ast_set_flag(retval, VM_ALLOCED);       
                else
                        memset(retval, 0, sizeof(*retval));
                if (mailbox) 
                        ast_copy_string(retval->mailbox, mailbox, sizeof(retval->mailbox));
                populate_defaults(retval);
                if (!context && ast_test_flag((&globalflags), VM_SEARCH))
                        var = ast_load_realtime("voicemail", "mailbox", mailbox, SENTINEL);
                else
                        var = ast_load_realtime("voicemail", "mailbox", mailbox, "context", context, SENTINEL);
                if (var) {
                        apply_options_full(retval, var);
                        ast_variables_destroy(var);
                } else { 
                        if (!ivm) 
                                ast_free(retval);
                        retval = NULL;
                }       
        } 
        return retval;
}

/*!
 * \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) {
                if (ast_test_flag((&globalflags), VM_SEARCH) && !strcasecmp(mailbox, cur->mailbox))
                        break;
                if (context && (!strcasecmp(context, cur->context)) && (!strcasecmp(mailbox, cur->mailbox)))
                        break;
        }
        if (cur) {
                /* Make a copy, so that on a reload, we have no race */
                if ((vmu = (ivm ? ivm : ast_malloc(sizeof(*vmu))))) {
                        memcpy(vmu, cur, sizeof(*vmu));
                        ast_set2_flag(vmu, !ivm, VM_ALLOCED);
                        AST_LIST_NEXT(vmu, list) = NULL;
                }
        } else
                vmu = find_user_realtime(ivm, context, mailbox);
        AST_LIST_UNLOCK(&users);
        return vmu;
}

/*!
 * \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);
        return res;
}

/*! 
 * \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, *value=NULL, *new=NULL;
        const char *tmp=NULL;
        struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS };
        if (!change_password_realtime(vmu, newpassword))
                return;

        /* check voicemail.conf */
        if ((cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags))) {
                while ((category = ast_category_browse(cfg, category))) {
                        if (!strcasecmp(category, vmu->context)) {
                                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) {
                                        ast_log(AST_LOG_WARNING, "variable has bad format.\n");
                                        break;
                                }
                                new = alloca((strlen(value)+strlen(newpassword)+1));
                                sprintf(new,"%s%s", newpassword, value);
                                if (!(cat = ast_category_get(cfg, category))) {
                                        ast_log(AST_LOG_WARNING, "Failed to get category structure.\n");
                                        break;
                                }
                                ast_variable_update(cat, vmu->mailbox, new, NULL, 0);
                        }
                }
                /* save the results */
                reset_user_pw(vmu->context, vmu->mailbox, newpassword);
                ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
                config_text_file_save(VOICEMAIL_CONFIG, cfg, "AppVoicemail");
        }
        category = NULL;
        var = NULL;
        /* 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))) {
                ast_debug(4, "we are looking for %s\n", vmu->mailbox);
                while ((category = ast_category_browse(cfg, category))) {
                        ast_debug(4, "users.conf: %s\n", category);
                        if (!strcasecmp(category, vmu->mailbox)) {
                                if (!(tmp = ast_variable_retrieve(cfg, category, "vmsecret"))) {
                                        ast_debug(3, "looks like we need to make vmsecret!\n");
                                        var = ast_variable_new("vmsecret", newpassword, "");
                                } 
                                new = alloca(strlen(newpassword)+1);
                                sprintf(new, "%s", newpassword);
                                if (!(cat = ast_category_get(cfg, category))) {
                                        ast_debug(4, "failed to get category!\n");
                                        break;
                                }
                                if (!var)               
                                        ast_variable_update(cat, "vmsecret", new, NULL, 0);
                                else
                                        ast_variable_append(cat, var);
                        }
                }
                /* save the results and clean things up */
                reset_user_pw(vmu->context, vmu->mailbox, newpassword); 
                ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
                config_text_file_save("users.conf", cfg, "AppVoicemail");
        }
}

static void vm_change_password_shell(struct ast_vm_user *vmu, char *newpassword)
{
        char buf[255];
        snprintf(buf,255,"%s %s %s %s",ext_pass_cmd,vmu->context,vmu->mailbox,newpassword);
        if (!ast_safe_system(buf)) {
                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.
 * 
 * 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.
 * 
 * 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);
}

/* same as mkstemp, but return a FILE * */
static FILE *vm_mkftemp(char *template)
{
        FILE *p = NULL;
        int pfd = mkstemp(template);
        chmod(template, VOICEMAIL_FILE_MODE & ~my_umask);
        if (pfd > -1) {
                p = fdopen(pfd, "w+");
                if (!p) {
                        close(pfd);
                        pfd = -1;
                }
        }
        return p;
}

/*! \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(int id)
{
        static const char *msgs[] = {
#ifdef IMAP_STORAGE
                imapfolder,
#else
                "INBOX",
#endif
                "Old",
                "Work",
                "Family",
                "Friends",
                "Cust1",
                "Cust2",
                "Cust3",
                "Cust4",
                "Cust5",
                "Deleted",
                "Urgent"
        };
        return (id >= 0 && id < (sizeof(msgs)/sizeof(msgs[0]))) ? msgs[id] : "Unknown";
}

static void free_user(struct ast_vm_user *vmu)
{
        if (ast_test_flag(vmu, VM_ALLOCED))
                ast_free(vmu);
}

/* 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(int msgnum, struct ast_vm_user *vmu)
{
        char arg[10];
        struct vm_state *vms;
        unsigned long messageNum;

        /* Greetings aren't stored in IMAP, so we can't delete them there */
        if (msgnum < 0) {
                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;
        }

        /* 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;
        }
        if (option_debug > 2)
                ast_log(LOG_DEBUG, "deleting msgnum %d, which is mailbox message %lu\n",msgnum,messageNum);
        /* delete message */
        snprintf (arg, sizeof(arg), "%lu",messageNum);
        mail_setflag (vms->mailstream,arg,"\\DELETED");
}

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 *attachment;
        int ret = 0, i;
        BODY *body;

        /* 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))) {
                ast_log(AST_LOG_ERROR, "Voicemail state not found!\n");
                return -1;
        }
        
        /* Greetings will never have a prepended message */
        *vms_p->introfn = '\0';
        
        ret = init_mailstream(vms_p, GREETINGS_FOLDER);
        if (!vms_p->mailstream) {
                ast_log(AST_LOG_ERROR, "IMAP mailstream is NULL\n");
                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) {
                        attachment = ast_strdupa(body->nested.part->next->body.parameter->value);
                } else {
                        ast_log(AST_LOG_ERROR, "There is no file attached to this IMAP message.\n");
                        return -1;
                }
                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;
                        save_body(body, vms_p, "2", attachment, 0);
                        return 0;
                }
        }

        return -1;
}

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;

        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;
        }
        
        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;
        }

        if (option_debug > 2)
                ast_log (LOG_DEBUG,"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... */
        header_content = mail_fetchheader (vms->mailstream, vms->msgArray[msgnum]);
        /* 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;
        }

        mail_fetchstructure (vms->mailstream,vms->msgArray[msgnum],&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) {
                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_WARNING, "Unable to open/create file %s: %s\n", text_file, strerror(errno));
        }

        fprintf(text_file_ptr, "%s\n", "[message]");

        get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Num:", buf, sizeof(buf));
        fprintf(text_file_ptr, "callerid=\"%s\" ", S_OR(buf, ""));
        get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Name:", buf, sizeof(buf));
        fprintf(text_file_ptr, "<%s>\n", S_OR(buf, ""));
        get_header_by_tag(header_content, "X-Asterisk-VM-Context:", buf, sizeof(buf));
        fprintf(text_file_ptr, "context=%s\n", S_OR(buf, ""));
        get_header_by_tag(header_content, "X-Asterisk-VM-Orig-time:", buf, sizeof(buf));
        fprintf(text_file_ptr, "origtime=%s\n", S_OR(buf, ""));
        get_header_by_tag(header_content, "X-Asterisk-VM-Duration:", buf, sizeof(buf));
        fprintf(text_file_ptr, "duration=%s\n", S_OR(buf, ""));
        get_header_by_tag(header_content, "X-Asterisk-VM-Category:", buf, sizeof(buf));
        fprintf(text_file_ptr, "category=%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;
#ifdef IMAP_STORAGE
        if (!strcasecmp(folder, imapfolder))
#else
        if (!strcasecmp(folder, "INBOX"))
#endif
                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 /*assume they meant INBOX if folder is not found otherwise*/
                return 0;
}

/*!
 * \brief Gets the number of messages that exist in a mailbox folder.
 * \param context
 * \param mailbox
 * \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 *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 (ast_strlen_zero(mailbox))
                return 0;

        /* We have to get the user before we can open the stream! */
        vmu = find_user(&vmus, context, mailbox);
        if (!vmu) {
                ast_log(AST_LOG_ERROR, "Couldn't find mailbox %s in context %s\n", mailbox, context);
                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);
                        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 */
                        return vms_p->newmessages;
                }
                if (fold == 1) { /* Old messages */
                        return vms_p->oldmessages;
                }
                if (fold == 11) {/*Urgent messages*/
                        return vms_p->urgentmessages;
                }
        }

        /* 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 URGENT, then look at INBOX */
        if (fold == 11) {
                fold = NEW_FOLDER;
                urgent = 1;
        }

        if (!vms_p) {
                ast_debug(3,"Adding new vmstate for %s\n",vmu->imapuser);
                if (!(vms_p = ast_calloc(1, sizeof(*vms_p)))) {
                        return -1;
                }
                ast_copy_string(vms_p->imapuser,vmu->imapuser, sizeof(vms_p->imapuser));
                ast_copy_string(vms_p->username, mailbox, sizeof(vms_p->username)); /* save for access from interactive entry point */
                vms_p->mailstream = NIL; /* save for access from interactive entry point */
                ast_debug(3, "Copied %s to %s\n",vmu->imapuser,vms_p->imapuser);
                vms_p->updated = 1;
                ast_copy_string(vms_p->curbox, mbox(fold), sizeof(vms_p->curbox));
                init_vm_state(vms_p);
                vmstate_insert(vms_p);
        }
        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");
                return -1;
        }
        if (ret == 0) {
                pgm = mail_newsearchpgm ();
                hdr = mail_newsearchheader ("X-Asterisk-VM-Extension", (char *)mailbox);
                pgm->header = hdr;
                if (fold != 1) {
                        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 (urgent) {
                        pgm->flagged = 1;
                        pgm->unflagged = 0;
                }
                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);
                vms_p->updated = 0;
                return vms_p->vmArrayIndex;
        } else {  
                mail_ping(vms_p->mailstream);
        }
        return 0;
}

static int imap_store_file(char *dir, char *mailboxuser, char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag)
{
        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;

        /* 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.
                 */
                ast_copy_string(vmu->email, vmu->imapuser, sizeof(vmu->email));
                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 = vm_mkftemp(tmp))) {
                ast_log(AST_LOG_WARNING, "Unable to store '%s' (can't create temporary file)\n", fn);
                if (tempcopy)
                        *(vmu->email) = '\0';
                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, S_OR(chan->cid.cid_num, NULL), S_OR(chan->cid.cid_name, NULL), fn, introfn, fmt, duration, 1, chan, NULL, 1, flag);
        /* 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;
        }
        fread(buf, len, 1, p);
        ((char *)buf)[len] = '\0';
        INIT(&str, mail_string, buf, len);
        ret = init_mailstream(vms, NEW_FOLDER);
        if (ret == 0) {
                imap_mailbox_name(mailbox, sizeof(mailbox), vms, NEW_FOLDER, 1);
                if(!mail_append_full(vms->mailstream, mailbox, imap_flags, NIL, &str))
                        ast_log(LOG_ERROR, "Error while sending the message to %s\n", mailbox);
                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';
        
        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;
        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) {
                if ((*newmsgs = messagecount(context, mailboxnc, imapfolder)) < 0)
                        return -1;
        }
        if (oldmsgs) {
                if ((*oldmsgs = messagecount(context, mailboxnc, "Old")) < 0)
                        return -1;
        }
        if (urgentmsgs) {
                if((*urgentmsgs = messagecount(context, mailboxnc, "Urgent")) < 0)
                        return -1;
        }
        return 0;
}

static int inboxcount(const char *mailbox_context, int *newmsgs, int *oldmsgs)
{
        return inboxcount2(mailbox_context, NULL, newmsgs, oldmsgs);
}

/** 
 * \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, ',')) {
                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) ? 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
 *
 * 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)
{
        struct vm_state *sendvms = NULL, *destvms = 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 (!(destvms = 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]);
        if ((mail_copy(sendvms->mailstream, messagestring, (char *) mbox(imbox)) == T))
                return 0;
        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(NEW_FOLDER), sizeof(vms->curbox));
        } else {
                ast_copy_string(vms->curbox, mbox(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(box));
        }

        /* Build up server information */
        ast_build_string(&t, &left, "{%s:%s/imap", imapserver, 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_build_string(&t, &left, "/%s", imapflags);

        /* End with username */
        ast_build_string(&t, &left, "/user=%s}", vms->imapuser);
        if (box == NEW_FOLDER || box == OLD_FOLDER)
                snprintf(spec, len, "%s%s", tmp, use_folder? 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(box));
                } else {
                        snprintf(spec, len, "%s%s", tmp, mbox(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;
        }
        if (option_debug > 2)
                ast_log (LOG_DEBUG,"vm_state user is:%s\n",vms->imapuser);
        if (vms->mailstream == NIL || !vms->mailstream) {
                if (option_debug)
                        ast_log (LOG_DEBUG,"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);
                stream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
                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(stream);
                /* update delimiter in imapfolder */
                for (cp = imapfolder; *cp; cp++)
                        if (*cp == '/')
                                *cp = delimiter;
        }
        /* Now connect to the target folder */
        imap_mailbox_name(tmp, sizeof(tmp), vms, box, 1);
        if (option_debug > 2)
                ast_log (LOG_DEBUG,"Before mail_open, server: %s, box:%d\n", tmp, box);
        ast_mutex_lock(&vms->lock);
        vms->mailstream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
        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 ret, 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_debug(3,"Before init_mailstream, user is %s\n",vmu->imapuser);

        if ((ret = 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(box));
                check_quota(vms,(char *)mbox(box));
        }

        pgm = mail_newsearchpgm();

        /* Check IMAP folder for Asterisk messages only... */
        hdr = mail_newsearchheader("X-Asterisk-VM-Extension", vmu->mailbox);
        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);

        return 0;
}

static void write_file(char *filename, char *buffer, unsigned long len)
{
        FILE *output;

        output = fopen (filename, "w");
        fwrite (buffer, len, 1, output);
        fclose (output);
}

static void update_messages_by_imapuser(const char *user, unsigned long number)
{
        struct vmstate *vlist = NULL;

        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->imapuser) {
                        ast_debug(3, "error: imapuser is NULL for %s\n", user);
                        continue;
                }
                ast_debug(3, "saving mailbox message number %lu as message %d. Interactive set to %d\n", number, vlist->vms->vmArrayIndex, vlist->vms->interactive);
                vlist->vms->msgArray[vlist->vms->vmArrayIndex++] = number;
        }
        AST_LIST_UNLOCK(&vmstates);
}

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;
        ast_set_flag(vmu, VM_ALLOCED);
        populate_defaults(vmu);

        var = ast_load_realtime("voicemail", "imapuser", imapuser, NULL);
        if (var) {
                apply_options_full(vmu, var);
                ast_variables_destroy(var);
                return vmu;
        } else {
                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)
{
        ast_log(AST_LOG_NOTICE, " Mailbox %s", mailbox);
        if (status->flags & SA_MESSAGES)
                ast_log(AST_LOG_NOTICE, ", %lu messages", status->messages);
        if (status->flags & SA_RECENT)
                ast_log(AST_LOG_NOTICE, ", %lu recent", status->recent);
        if (status->flags & SA_UNSEEN)
                ast_log(AST_LOG_NOTICE, ", %lu unseen", status->unseen);
        if (status->flags & SA_UIDVALIDITY)
                ast_log(AST_LOG_NOTICE, ", %lu UID validity", status->uidvalidity);
        if (status->flags & SA_UIDNEXT)
                ast_log(AST_LOG_NOTICE, ", %lu next UID", status->uidnext);
        ast_log(AST_LOG_NOTICE, "\n");
}


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))) {
                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 = strstr(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, *quote, *eol_pnt;

        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 {
                eol_pnt = strchr(buf+1,'\"');
                *eol_pnt = '\0';
                return buf+1;
        }
}

static struct vm_state *create_vm_state_from_user(struct ast_vm_user *vmu)
{
        struct vm_state *vms_p;

        if (option_debug > 4)
                ast_log(AST_LOG_DEBUG,"Adding new vmstate for %s\n",vmu->imapuser);
        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->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 */
        if (option_debug > 4)
                ast_log(AST_LOG_DEBUG,"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(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(char *user, int interactive)
{
        struct vmstate *vlist = NULL;

        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->imapuser) {
                        ast_debug(3, "error: imapuser is NULL for %s\n", user);
                        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");

        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->username || !vlist->vms->context) {
                        ast_debug(3, "error: username is NULL for %s\n", mailbox);
                        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;
                        vms->lastmsg = altvms->lastmsg;
                        vms->curmsg = altvms->curmsg;
                        /* get a pointer to the persistent store */
                        vms->persist_vms = altvms;
                        /* Reuse the mailstream? */
                        vms->mailstream = altvms->mailstream;
                        /* vms->mailstream = NIL; */
                }
        }

        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;
        }
        
        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);
        }
        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 && option_debug > 2)
                        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) 
{
        int x;
        vms->vmArrayIndex = 0;
        for (x = 0; x < VMSTATE_MAX_MSG_ARRAY; x++) {
                vms->msgArray[x] = 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;
        unsigned long newlen;
        char filename[256];
        
        if (!body || body == NIL)
                return -1;

        body_content = mail_fetchbody(vms->mailstream, vms->msgArray[vms->curmsg], section, &len);
        if (body_content != NIL) {
                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) {
                        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 stream
 *
 * Determines the delimiter character that is used by the underlying IMAP based mail store.
 */
static void get_mailbox_delimiter(MAILSTREAM *stream) {
        char tmp[50];
        snprintf(tmp, sizeof(tmp), "{%s}", 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) {
        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);
        }
}

#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;
        }
}


#ifdef ODBC_STORAGE
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 ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                ast_log(AST_LOG_WARNING, "SQL Alloc Handle failed!\n");
                return NULL;
        }
        res = SQLPrepare(stmt, (unsigned char *)gps->sql, SQL_NTS);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                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;
}

/*!
 * \brief Retrieves a file from an ODBC data store.
 * \param dir the path to the file to be retreived.
 * \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 retrieve_file(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[PATH_MAX];
        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[PATH_MAX];
        char full_fn[PATH_MAX];
        char msgnums[80];
        char *argv[] = { dir, msgnums };
        struct generic_prepare_struct gps = { .sql = sql, .argc = 2, .argv = argv };

        struct odbc_obj *obj;
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                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);
                if (msgnum > -1)
                        make_file(fn, sizeof(fn), dir, msgnum);
                else
                        ast_copy_string(fn, dir, sizeof(fn));

                /* Create the information file */
                snprintf(full_fn, sizeof(full_fn), "%s.txt", fn);
                
                if (!(f = fopen(full_fn, "w+"))) {
                        ast_log(AST_LOG_WARNING, "Failed to open/create '%s'\n", full_fn);
                        goto yuck;
                }
                
                snprintf(full_fn, sizeof(full_fn), "%s.%s", fn, fmt);
                snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE dir=? AND msgnum=?",odbc_table);
                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);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLFetch(stmt);
                if (res == SQL_NO_DATA) {
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                } else if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                        ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                fd = open(full_fn, O_RDWR | O_CREAT | O_TRUNC, VOICEMAIL_FILE_MODE);
                if (fd < 0) {
                        ast_log(AST_LOG_WARNING, "Failed to write '%s': %s\n", full_fn, strerror(errno));
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLNumResultCols(stmt, &colcount);
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {   
                        ast_log(AST_LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                if (f) 
                        fprintf(f, "[message]\n");
                for (x=0;x<colcount;x++) {
                        rowdata[0] = '\0';
                        collen = sizeof(coltitle);
                        res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen, 
                                                &datatype, &colsize, &decimaldigits, &nullable);
                        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                                ast_log(AST_LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
                                SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                                ast_odbc_release_obj(obj);
                                goto yuck;
                        }
                        if (!strcasecmp(coltitle, "recording")) {
                                off_t offset;
                                res = SQLGetData(stmt, x + 1, SQL_BINARY, rowdata, 0, &colsize2);
                                fdlen = colsize2;
                                if (fd > -1) {
                                        char tmp[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);
                                                        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                                                        ast_odbc_release_obj(obj);
                                                        goto yuck;
                                                } else {
                                                        res = SQLGetData(stmt, x + 1, SQL_BINARY, fdm, CHUNKSIZE, NULL);
                                                        munmap(fdm, CHUNKSIZE);
                                                        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                                                                ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
                                                                unlink(full_fn);
                                                                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                                                                ast_odbc_release_obj(obj);
                                                                goto yuck;
                                                        }
                                                }
                                        }
                                        truncate(full_fn, fdlen);
                                }
                        } else {
                                res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
                                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                                        ast_log(AST_LOG_WARNING, "SQL Get Data error! coltitle=%s\n[%s]\n\n", coltitle, sql);
                                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                                        ast_odbc_release_obj(obj);
                                        goto yuck;
                                }
                                if (strcasecmp(coltitle, "msgnum") && strcasecmp(coltitle, "dir") && f)
                                        fprintf(f, "%s=%s\n", coltitle, rowdata);
                        }
                }
                SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                ast_odbc_release_obj(obj);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
yuck:   
        if (f)
                fclose(f);
        if (fd > -1)
                close(fd);
        return x - 1;
}

/*!
 * \brief Determines the highest message number in use for a given user and mailbox folder.
 * \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.
 * 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 greaterto indicate the last message index in use, -1 to indicate none.
 */
static int last_message_index(struct ast_vm_user *vmu, char *dir)
{
        int x = 0;
        int res;
        SQLHSTMT stmt;
        char sql[PATH_MAX];
        char rowdata[20];
        char *argv[] = { dir };
        struct generic_prepare_struct gps = { .sql = sql, .argc = 1, .argv = argv };

        struct odbc_obj *obj;
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                snprintf(sql, sizeof(sql), "SELECT COUNT(*) FROM %s WHERE dir=?",odbc_table);
                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);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLFetch(stmt);
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                        ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLGetData(stmt, 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                        ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                if (sscanf(rowdata, "%d", &x) != 1)
                        ast_log(AST_LOG_WARNING, "Failed to read message count!\n");
                SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                ast_odbc_release_obj(obj);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
yuck:   
        return x - 1;
}

/*!
 * \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 message_exists(char *dir, int msgnum)
{
        int x = 0;
        int res;
        SQLHSTMT stmt;
        char sql[PATH_MAX];
        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;
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                snprintf(msgnums, sizeof(msgnums), "%d", msgnum);
                snprintf(sql, sizeof(sql), "SELECT COUNT(*) FROM %s WHERE dir=? AND msgnum=?",odbc_table);
                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);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLFetch(stmt);
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                        ast_log(AST_LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                res = SQLGetData(stmt, 1, SQL_CHAR, rowdata, sizeof(rowdata), NULL);
                if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                        ast_log(AST_LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                        ast_odbc_release_obj(obj);
                        goto yuck;
                }
                if (sscanf(rowdata, "%d", &x) != 1)
                        ast_log(AST_LOG_WARNING, "Failed to read message count!\n");
                SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                ast_odbc_release_obj(obj);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
yuck:   
        return x;
}

/*!
 * \brief returns the one-based count for messages.
 * \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.
 * The message index is zero-based, the first message will be index 0. For convenient display it is good to have the
 * one-based messages.
 * This method just calls last_message_index and returns +1 of its value.
 *
 * \return the value greater than zero on success to indicate the one-based count of messages, less than zero on error.
 */
static int count_messages(struct ast_vm_user *vmu, char *dir)
{
        return last_message_index(vmu, dir) + 1;
}

/*!
 * \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.
 * 
 * \return the value greater than zero on success to indicate the number of messages, less than zero on error.
 */
static void delete_file(char *sdir, int smsg)
{
        SQLHSTMT stmt;
        char sql[PATH_MAX];
        char msgnums[20];
        char *argv[] = { sdir, msgnums };
        struct generic_prepare_struct gps = { .sql = sql, .argc = 2, .argv = argv };

        struct odbc_obj *obj;
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                snprintf(msgnums, sizeof(msgnums), "%d", smsg);
                snprintf(sql, sizeof(sql), "DELETE FROM %s WHERE dir=? AND msgnum=?",odbc_table);
                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);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
        return; 
}

/*!
 * \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.
 */
static void copy_file(char *sdir, int smsg, char *ddir, int dmsg, char *dmailboxuser, char *dmailboxcontext)
{
        SQLHSTMT stmt;
        char sql[512];
        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 };

        delete_file(ddir, dmsg);
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                snprintf(msgnums, sizeof(msgnums), "%d", smsg);
                snprintf(msgnumd, sizeof(msgnumd), "%d", dmsg);
                snprintf(sql, sizeof(sql), "INSERT INTO %s (dir, msgnum, context, macrocontext, callerid, origtime, duration, recording, mailboxuser, mailboxcontext, flag) SELECT ?,?,context,macrocontext,callerid,origtime,duration,recording,flag,?,? FROM %s WHERE dir=? AND msgnum=?",odbc_table,odbc_table);
                stmt = ast_odbc_prepare_and_execute(obj, generic_prepare, &gps);
                if (!stmt)
                        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s] (You probably don't have MySQL 4.1 or later installed)\n\n", sql);
                else
                        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                ast_odbc_release_obj(obj);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
        return; 
}

struct insert_data {
        char *sql;
        char *dir;
        char *msgnums;
        void *data;
        SQLLEN datalen;
        SQLLEN indlen;
        const char *context;
        const char *macrocontext;
        const char *callerid;
        const char *origtime;
        const char *duration;
        char *mailboxuser;
        char *mailboxcontext;
        const char *category;
        const char *flag;
};

static SQLHSTMT insert_data_cb(struct odbc_obj *obj, void *vdata)
{
        struct insert_data *data = vdata;
        int res;
        SQLHSTMT stmt;

        res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                ast_log(AST_LOG_WARNING, "SQL Alloc Handle failed!\n");
                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                return NULL;
        }

        SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->dir), 0, (void *)data->dir, 0, NULL);
        SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->msgnums), 0, (void *)data->msgnums, 0, NULL);
        SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY, data->datalen, 0, (void *)data->data, data->datalen, &data->indlen);
        SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->context), 0, (void *)data->context, 0, NULL);
        SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->macrocontext), 0, (void *)data->macrocontext, 0, NULL);
        SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->callerid), 0, (void *)data->callerid, 0, NULL);
        SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->origtime), 0, (void *)data->origtime, 0, NULL);
        SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->duration), 0, (void *)data->duration, 0, NULL);
        SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->mailboxuser), 0, (void *)data->mailboxuser, 0, NULL);
        SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->mailboxcontext), 0, (void *)data->mailboxcontext, 0, NULL);
        SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->flag), 0, (void *)data->flag, 0, NULL);
        if (!ast_strlen_zero(data->category)) {
                SQLBindParameter(stmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(data->category), 0, (void *)data->category, 0, NULL);
        }
        res = SQLExecDirect(stmt, (unsigned char *)data->sql, SQL_NTS);
        if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
                ast_log(AST_LOG_WARNING, "SQL Direct Execute failed!\n");
                SQLFreeHandle(SQL_HANDLE_STMT, stmt);
                return NULL;
        }

        return stmt;
}

/*!
 * \brief Stores a voicemail into the database.
 * \param dir the folder the mailbox folder to store the message.
 * \param mailboxuser the user owning the mailbox folder.
 * \param mailboxcontext
 * \param msgnum the message index for the message to be stored.
 *
 * This method is used when mailboxes are stored in an ODBC back end.
 * The message sound file and information file is looked up on the file system. 
 * A SQL query is invoked to store the message into the (MySQL) database.
 *
 * \return the zero on success -1 on error.
 */
static int store_file(char *dir, char *mailboxuser, char *mailboxcontext, int msgnum)
{
        int res = 0;
        int fd = -1;
        void *fdm = MAP_FAILED;
        size_t fdlen = -1;
        SQLHSTMT stmt;
        char sql[PATH_MAX];
        char msgnums[20];
        char fn[PATH_MAX];
        char full_fn[PATH_MAX];
        char fmt[80]="";
        char *c;
        struct ast_config *cfg=NULL;
        struct odbc_obj *obj;
        struct insert_data idata = { .sql = sql, .msgnums = msgnums, .dir = dir, .mailboxuser = mailboxuser, .mailboxcontext = mailboxcontext };
        struct ast_flags config_flags = { CONFIG_FLAG_NOCACHE };

        delete_file(dir, msgnum);
        if (!(obj = ast_odbc_request_obj(odbc_database, 0))) {
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
                return -1;
        }

        do {
                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);
                if (msgnum > -1)
                        make_file(fn, sizeof(fn), dir, msgnum);
                else
                        ast_copy_string(fn, dir, sizeof(fn));
                snprintf(full_fn, sizeof(full_fn), "%s.txt", fn);
                cfg = ast_config_load(full_fn, config_flags);
                snprintf(full_fn, sizeof(full_fn), "%s.%s", fn, fmt);
                fd = open(full_fn, O_RDWR);
                if (fd < 0) {
                        ast_log(AST_LOG_WARNING, "Open of sound file '%s' failed: %s\n", full_fn, strerror(errno));
                        res = -1;
                        break;
                }
                if (cfg) {
                        if (!(idata.context = ast_variable_retrieve(cfg, "message", "context"))) {
                                idata.context = "";
                        }
                        if (!(idata.macrocontext = ast_variable_retrieve(cfg, "message", "macrocontext"))) {
                                idata.macrocontext = "";
                        }
                        if (!(idata.callerid = ast_variable_retrieve(cfg, "message", "callerid"))) {
                                idata.callerid = "";
                        }
                        if (!(idata.origtime = ast_variable_retrieve(cfg, "message", "origtime"))) {
                                idata.origtime = "";
                        }
                        if (!(idata.duration = ast_variable_retrieve(cfg, "message", "duration"))) {
                                idata.duration = "";
                        }
                        if (!(idata.category = ast_variable_retrieve(cfg, "message", "category"))) {
                                idata.category = "";
                        }
                        if (!(idata.flag = ast_variable_retrieve(cfg, "message", "flag"))) {
                                idata.flag = "";
                        }
                }
                fdlen = lseek(fd, 0, SEEK_END);
                lseek(fd, 0, SEEK_SET);
                printf("Length is %zd\n", fdlen);
                fdm = mmap(NULL, fdlen, PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0);
                if (fdm == MAP_FAILED) {
                        ast_log(AST_LOG_WARNING, "Memory map failed!\n");
                        res = -1;
                        break;
                } 
                idata.data = fdm;
                idata.datalen = idata.indlen = fdlen;

                if (!ast_strlen_zero(idata.category)) 
                        snprintf(sql, sizeof(sql), "INSERT INTO %s (dir,msgnum,recording,context,macrocontext,callerid,origtime,duration,mailboxuser,mailboxcontext,flag,category) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",odbc_table); 
                else
                        snprintf(sql, sizeof(sql), "INSERT INTO %s (dir,msgnum,recording,context,macrocontext,callerid,origtime,duration,mailboxuser,mailboxcontext,flag) VALUES (?,?,?,?,?,?,?,?,?,?,?)",odbc_table);

                if ((stmt = ast_odbc_direct_execute(obj, insert_data_cb, &idata))) {
                        SQLFreeHandle (SQL_HANDLE_STMT, stmt);
                } else {
                        ast_log(AST_LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
                        res = -1;
                }
        } while (0);
        if (obj) {
                ast_odbc_release_obj(obj);
        }
        if (cfg)
                ast_config_destroy(cfg);
        if (fdm != MAP_FAILED)
                munmap(fdm, fdlen);
        if (fd > -1)
                close(fd);
        return res;
}

/*!
 * \brief Renames a message in a mailbox folder.
 * \param sdir The folder of the message to be renamed.
 * \param smsg The index of the message to be renamed.
 * \param mailboxuser The user to become the owner of the message after it is renamed. Usually this will be the same as the original owner.
 * \param mailboxcontext The context to be set for the message. Usually this will be the same as the original context.
 * \param ddir The destination folder for the message to be renamed into
 * \param dmsg The destination message for the message to be renamed.
 *
 * This method is used by the RENAME macro when mailboxes are stored in an ODBC back end.
 * The is usually used to resequence the messages in the mailbox, such as to delete messag index 0, it would be called successively to slide all the other messages down one index.
 * But in theory, because the SQL query performs an update on (dir, msgnum, mailboxuser, mailboxcontext) in the database, it should be possible to have the message relocated to another mailbox or context as well.
 */
static void rename_file(char *sdir, int smsg, char *mailboxuser, char *mailboxcontext, char *ddir, int dmsg)
{
        SQLHSTMT stmt;
        char sql[PATH_MAX];
        char msgnums[20];
        char msgnumd[20];
        struct odbc_obj *obj;
        char *argv[] = { ddir, msgnumd, mailboxuser, mailboxcontext, sdir, msgnums };
        struct generic_prepare_struct gps = { .sql = sql, .argc = 6, .argv = argv };

        delete_file(ddir, dmsg);
        obj = ast_odbc_request_obj(odbc_database, 0);
        if (obj) {
                snprintf(msgnums, sizeof(msgnums), "%d", smsg);
                snprintf(msgnumd, sizeof(msgnumd), "%d", dmsg);
                snprintf(sql, sizeof(sql), "UPDATE %s SET dir=?, msgnum=?, mailboxuser=?, mailboxcontext=? WHERE dir=? AND msgnum=?",odbc_table);
                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);
        } else
                ast_log(AST_LOG_WARNING, "Failed to obtain database object for '%s'!\n", odbc_database);
        return; 
}

/*!
 * \brief Removes a voicemail message file.
 * \param dir the path to the message file.
 * \param msgnum the unique number for the message within the mailbox.
 *
 * Removes the message content file and the information file.
 * This method is used by the DISPOSE macro when mailboxes are stored in an ODBC back end.
 * Typical use is to clean up after a RETRIEVE operation. 
 * Note that this does not remove the message from the mailbox folders, to do that we would use delete_file().
 * \return zero on success, -1 on error.
 */
static int remove_file(char *dir, int msgnum)
{
        char fn[PATH_MAX];
        char full_fn[PATH_MAX];
        char msgnums[80];
        
        if (msgnum > -1) {
                snprintf(msgnums, sizeof(msgnums), "%d", msgnum);
                make_file(fn, sizeof(fn), dir, msgnum);
        } else
                ast_copy_string(fn, dir, sizeof(fn));
        ast_filedelete(fn, NULL);       
        snprintf(full_fn, sizeof(full_fn), "%s.txt", fn);
        unlink(full_fn);
        return 0;
}
#else
#ifndef IMAP_STORAGE
/*!
 * \brief Find all .txt files - even if they are not in sequence from 0000.
 * \param vmu
 * \param dir
 *
 * This method is used when mailboxes are stored on the filesystem. (not ODBC and not IMAP).
 *
 * \return the count of messages, zero or more.
 */
static int count_messages(struct ast_vm_user *vmu, char *dir)
{

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

        if (vm_lock_path(dir))
                return ERROR_LOCK_PATH;

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

/*!
 * \brief Renames a message in a mailbox folder.
 * \param sfn The path to the mailbox information and data file to be renamed.
 * \param dfn The path for where the message data and information files will be renamed to.
 *
 * This method is used by the RENAME macro when mailboxes are stored on the filesystem. (not ODBC and not IMAP).
 */
static void rename_file(char *sfn, char *dfn)
{
        char stxt[PATH_MAX];
        char dtxt[PATH_MAX];
        ast_filerename(sfn,dfn,NULL);
        snprintf(stxt, sizeof(stxt), "%s.txt", sfn);
        snprintf(dtxt, sizeof(dtxt), "%s.txt", dfn);
        if (ast_check_realtime("voicemail_data")) {
                ast_update_realtime("voicemail_data", "filename", sfn, "filename", dfn, SENTINEL);
        }
        rename(stxt, dtxt);
}

/*! 
 * \brief Determines the highest message number in use for a given user and mailbox folder.
 * \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 on the filesystem. (not ODBC and not IMAP).
 * Typical use to set the msgnum would be to take the value returned from this method and add one to it.
 *
 * \note Should always be called with a lock already set on dir.
 * \return the value of zero or greaterto indicate the last message index in use, -1 to indicate none.
 */
static int last_message_index(struct ast_vm_user *vmu, char *dir)
{
        int x;
        unsigned char map[MAXMSGLIMIT] = "";
        DIR *msgdir;
        struct dirent *msgdirent;
        int msgdirint;

        /* Reading the entire directory into a file map scales better than
         * doing a stat repeatedly on a predicted sequence.  I suspect this
         * is partially due to stat(2) internally doing a readdir(2) itself to
         * find each file. */
        msgdir = opendir(dir);
        while ((msgdirent = readdir(msgdir))) {
                if (sscanf(msgdirent->d_name, "msg%d", &msgdirint) == 1 && msgdirint < MAXMSGLIMIT)
                        map[msgdirint] = 1;
        }
        closedir(msgdir);

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

        return x - 1;
}

/*!
 * \brief Utility function to copy a file.
 * \param infile The path to the file to be copied. The file must be readable, it is opened in read only mode.
 * \param outfile The path for which to copy the file to. The directory permissions must allow the creation (or truncation) of the file, and allow for opening the file in write only mode.
 *
 * When the compiler option HARDLINK_WHEN_POSSIBLE is set, the copy operation will attempt to use the hard link facility instead of copy the file (to save disk space). If the link operation fails, it falls back to the copy operation.
 * The copy operation copies up to 4096 bytes at once.
 *
 * \return zero on success, -1 on error.
 */
static int copy(char *infile, char *outfile)
{
        int ifd;
        int ofd;
        int res;
        int len;
        char buf[4096];

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

/*!
 * \brief Copies a voicemail information (envelope) file.
 * \param frompath
 * \param topath 
 *
 * Every voicemail has the data (.wav) file, and the information file.
 * This function performs the file system copying of the information file for a voicemail, handling the internal fields and their values.
 * This is used by the COPY macro when not using IMAP storage.
 */
static void copy_plain_file(char *frompath, char *topath)
{
        char frompath2[PATH_MAX], topath2[PATH_MAX];
        struct ast_variable *tmp,*var = NULL;
        const char *origmailbox = NULL, *context = NULL, *macrocontext = NULL, *exten = NULL, *priority = NULL, *callerchan = NULL, *callerid = NULL, *origdate = NULL, *origtime = NULL, *category = NULL, *duration = NULL;
        ast_filecopy(frompath, topath, NULL);
        snprintf(frompath2, sizeof(frompath2), "%s.txt", frompath);
        snprintf(topath2, sizeof(topath2), "%s.txt", topath);
        if (ast_check_realtime("voicemail_data")) {
                var = ast_load_realtime("voicemail_data", "filename", frompath, SENTINEL);
                /* This cycle converts ast_variable linked list, to va_list list of arguments, may be there is a better way to do it? */
                for (tmp = var; tmp; tmp = tmp->next) {
                        if (!strcasecmp(tmp->name, "origmailbox")) {
                                origmailbox = tmp->value;
                        } else if (!strcasecmp(tmp->name, "context")) {
                                context = tmp->value;
                        } else if (!strcasecmp(tmp->name, "macrocontext")) {
                                macrocontext = tmp->value;
                        } else if (!strcasecmp(tmp->name, "exten")) {
                                exten = tmp->value;
                        } else if (!strcasecmp(tmp->name, "priority")) {
                                priority = tmp->value;
                        } else if (!strcasecmp(tmp->name, "callerchan")) {
                                callerchan = tmp->value;
                        } else if (!strcasecmp(tmp->name, "callerid")) {
                                callerid = tmp->value;
                        } else if (!strcasecmp(tmp->name, "origdate")) {
                                origdate = tmp->value;
                        } else if (!strcasecmp(tmp->name, "origtime")) {
                                origtime = tmp->value;
                        } else if (!strcasecmp(tmp->name, "category")) {
                                category = tmp->value;
                        } else if (!strcasecmp(tmp->name, "duration")) {
                                duration = tmp->value;
                        }
                }
                ast_store_realtime("voicemail_data", "filename", topath, "origmailbox", origmailbox, "context", context, "macrocontext", macrocontext, "exten", exten, "priority", priority, "callerchan", callerchan, "callerid", callerid, "origdate", origdate, "origtime", origtime, "category", category, "duration", duration, SENTINEL);
        }
        copy(frompath2, topath2);
        ast_variables_destroy(var);
}

#endif /* #ifndef IMAP_STORAGE */
#endif /* #else of #ifdef ODBC_STORAGE */

#if (!defined(ODBC_STORAGE) && !defined(IMAP_STORAGE))
/*! 
 * \brief Removes the voicemail sound and information file.
 * \param file The path to the sound file. This will be the the folder and message index, without the extension.
 *
 * This is used by the DELETE macro when voicemails are stored on the file system.
 *
 * \return zero on success, -1 on error.
 */
static int vm_delete(char *file)
{
        char *txt;
        int txtsize = 0;

        txtsize = (strlen(file) + 5)*sizeof(char);
        txt = alloca(txtsize);
        /* Sprintf here would safe because we alloca'd exactly the right length,
         * but trying to eliminate all sprintf's anyhow
         */
        if (ast_check_realtime("voicemail_data")) {
                ast_destroy_realtime("voicemail_data", "filename", file, SENTINEL);
        }
        snprintf(txt, txtsize, "%s.txt", file);
        unlink(txt);
        return ast_filedelete(file, NULL);
}
#endif

/*!
 * \brief utility used by inchar(), for base_encode()
 */
static int inbuf(struct baseio *bio, FILE *fi)
{
        int l;

        if (bio->ateof)
                return 0;

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

                bio->ateof = 1;
                return 0;
        }

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

        return 1;
}

/*!
 * \brief utility used by base_encode()
 */
static int inchar(struct baseio *bio, FILE *fi)
{
        if (bio->iocp>=bio->iolen) {
                if (!inbuf(bio, fi))
                        return EOF;
        }

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

/*!
 * \brief utility used by base_encode()
 */
static int ochar(struct baseio *bio, int c, FILE *so)
{
        if (bio->linelength >= BASELINELEN) {
                if (fputs(eol,so) == EOF)
                        return -1;

                bio->linelength= 0;
        }

        if (putc(((unsigned char)c),so) == EOF)
                return -1;

        bio->linelength++;

        return 1;
}

/*!
 * \brief Performs a base 64 encode algorithm on the contents of a File
 * \param filename The path to the file to be encoded. Must be readable, file is opened in read mode.
 * \param so A FILE handle to the output file to receive the base 64 encoded contents of the input file, identified by filename.
 *
 * TODO: shouldn't this (and the above 3 support functions) be put into some kind of external utility location, such as funcs/func_base64.c ?
 *
 * \return zero on success, -1 on error.
 */
static int base_encode(char *filename, FILE *so)
{
        static const unsigned char dtable[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
                'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
                'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0',
                '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
        int i,hiteof= 0;
        FILE *fi;
        struct baseio bio;

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

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

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

                igroup[0]= igroup[1]= igroup[2]= 0;

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

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

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

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

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

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

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

        return 1;
}

static void prep_email_sub_vars(struct ast_channel *ast, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, char *cidnum, char *cidname, char *dur, char *date, char *passdata, size_t passdatasize, const char *category, const char *flag)
{
        char callerid[256];
        /* Prepare variables for substitution in email body and subject */
        pbx_builtin_setvar_helper(ast, "VM_NAME", vmu->fullname);
        pbx_builtin_setvar_helper(ast, "VM_DUR", dur);
        snprintf(passdata, passdat