Migrate a large number of AMI events over to Stasis-Core
[asterisk/asterisk.git] / apps / app_voicemail.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \author Mark Spencer <markster@digium.com>
22  * \brief Comedian Mail - Voicemail System
23  *
24  * unixODBC (http://www.unixodbc.org/)
25  * A source distribution of University of Washington's IMAP c-client
26  *         (http://www.washington.edu/imap/)
27  *
28  * \par See also
29  * \arg \ref Config_vm
30  * \note For information about voicemail IMAP storage, https://wiki.asterisk.org/wiki/display/AST/IMAP+Voicemail+Storage
31  * \ingroup applications
32  * \todo This module requires res_adsi to load. This needs to be optional
33  * during compilation.
34  *
35  * \todo This file is now almost impossible to work with, due to all \#ifdefs.
36  *       Feels like the database code before realtime. Someone - please come up
37  *       with a plan to clean this up.
38  */
39
40 /*! \li \ref app_voicemail.c uses configuration file \ref voicemail.conf
41  * \addtogroup configuration_file Configuration Files
42  */
43
44 /*! 
45  * \page voicemail.conf voicemail.conf
46  * \verbinclude voicemail.conf.sample
47  */
48
49 /*** MODULEINFO
50         <use type="module">res_adsi</use>
51         <use type="module">res_smdi</use>
52         <support_level>core</support_level>
53  ***/
54
55 /*** MAKEOPTS
56 <category name="MENUSELECT_OPTS_app_voicemail" displayname="Voicemail Build Options" positive_output="yes" touch_on_change="apps/app_voicemail.c apps/app_directory.c">
57         <member name="FILE_STORAGE" displayname="Storage of Voicemail using filesystem">
58                 <conflict>ODBC_STORAGE</conflict>
59                 <conflict>IMAP_STORAGE</conflict>
60                 <defaultenabled>yes</defaultenabled>
61                 <support_level>core</support_level>
62         </member>
63         <member name="ODBC_STORAGE" displayname="Storage of Voicemail using ODBC">
64                 <depend>generic_odbc</depend>
65                 <depend>ltdl</depend>
66                 <conflict>IMAP_STORAGE</conflict>
67                 <conflict>FILE_STORAGE</conflict>
68                 <defaultenabled>no</defaultenabled>
69                 <support_level>core</support_level>
70         </member>
71         <member name="IMAP_STORAGE" displayname="Storage of Voicemail using IMAP4">
72                 <depend>imap_tk</depend>
73                 <conflict>ODBC_STORAGE</conflict>
74                 <conflict>FILE_STORAGE</conflict>
75                 <use type="external">openssl</use>
76                 <defaultenabled>no</defaultenabled>
77                 <support_level>core</support_level>
78         </member>
79 </category>
80 ***/
81
82 #include "asterisk.h"
83
84 #ifdef IMAP_STORAGE
85 #include <ctype.h>
86 #include <signal.h>
87 #include <pwd.h>
88 #ifdef USE_SYSTEM_IMAP
89 #include <imap/c-client.h>
90 #include <imap/imap4r1.h>
91 #include <imap/linkage.h>
92 #elif defined (USE_SYSTEM_CCLIENT)
93 #include <c-client/c-client.h>
94 #include <c-client/imap4r1.h>
95 #include <c-client/linkage.h>
96 #else
97 #include "c-client.h"
98 #include "imap4r1.h"
99 #include "linkage.h"
100 #endif
101 #endif
102
103 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
104
105 #include "asterisk/paths.h"     /* use ast_config_AST_SPOOL_DIR */
106 #include <sys/time.h>
107 #include <sys/stat.h>
108 #include <sys/mman.h>
109 #include <time.h>
110 #include <dirent.h>
111 #if defined(__FreeBSD__) || defined(__OpenBSD__)
112 #include <sys/wait.h>
113 #endif
114
115 #include "asterisk/logger.h"
116 #include "asterisk/lock.h"
117 #include "asterisk/file.h"
118 #include "asterisk/channel.h"
119 #include "asterisk/pbx.h"
120 #include "asterisk/config.h"
121 #include "asterisk/say.h"
122 #include "asterisk/module.h"
123 #include "asterisk/adsi.h"
124 #include "asterisk/app.h"
125 #include "asterisk/manager.h"
126 #include "asterisk/dsp.h"
127 #include "asterisk/localtime.h"
128 #include "asterisk/cli.h"
129 #include "asterisk/utils.h"
130 #include "asterisk/stringfields.h"
131 #include "asterisk/strings.h"
132 #include "asterisk/smdi.h"
133 #include "asterisk/astobj2.h"
134 #include "asterisk/event.h"
135 #include "asterisk/taskprocessor.h"
136 #include "asterisk/test.h"
137
138 #ifdef ODBC_STORAGE
139 #include "asterisk/res_odbc.h"
140 #endif
141
142 #ifdef IMAP_STORAGE
143 #include "asterisk/threadstorage.h"
144 #endif
145
146 /*** DOCUMENTATION
147         <application name="VoiceMail" language="en_US">
148                 <synopsis>
149                         Leave a Voicemail message.
150                 </synopsis>
151                 <syntax>
152                         <parameter name="mailboxs" argsep="&amp;" required="true">
153                                 <argument name="mailbox1" argsep="@" required="true">
154                                         <argument name="mailbox" required="true" />
155                                         <argument name="context" />
156                                 </argument>
157                                 <argument name="mailbox2" argsep="@" multiple="true">
158                                         <argument name="mailbox" required="true" />
159                                         <argument name="context" />
160                                 </argument>
161                         </parameter>
162                         <parameter name="options">
163                                 <optionlist>
164                                         <option name="b">
165                                                 <para>Play the <literal>busy</literal> greeting to the calling party.</para>
166                                         </option>
167                                         <option name="d">
168                                                 <argument name="c" />
169                                                 <para>Accept digits for a new extension in context <replaceable>c</replaceable>,
170                                                 if played during the greeting. Context defaults to the current context.</para>
171                                         </option>
172                                         <option name="g">
173                                                 <argument name="#" required="true" />
174                                                 <para>Use the specified amount of gain when recording the voicemail
175                                                 message. The units are whole-number decibels (dB). Only works on supported
176                                                 technologies, which is DAHDI only.</para>
177                                         </option>
178                                         <option name="s">
179                                                 <para>Skip the playback of instructions for leaving a message to the
180                                                 calling party.</para>
181                                         </option>
182                                         <option name="u">
183                                                 <para>Play the <literal>unavailable</literal> greeting.</para>
184                                         </option>
185                                         <option name="U">
186                                                 <para>Mark message as <literal>URGENT</literal>.</para>
187                                         </option>
188                                         <option name="P">
189                                                 <para>Mark message as <literal>PRIORITY</literal>.</para>
190                                         </option>
191                                 </optionlist>
192                         </parameter>
193                 </syntax>
194                 <description>
195                         <para>This application allows the calling party to leave a message for the specified
196                         list of mailboxes. When multiple mailboxes are specified, the greeting will be taken from
197                         the first mailbox specified. Dialplan execution will stop if the specified mailbox does not
198                         exist.</para>
199                         <para>The Voicemail application will exit if any of the following DTMF digits are received:</para>
200                         <enumlist>
201                                 <enum name="0">
202                                         <para>Jump to the <literal>o</literal> extension in the current dialplan context.</para>
203                                 </enum>
204                                 <enum name="*">
205                                         <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
206                                 </enum>
207                         </enumlist>
208                         <para>This application will set the following channel variable upon completion:</para>
209                         <variablelist>
210                                 <variable name="VMSTATUS">
211                                         <para>This indicates the status of the execution of the VoiceMail application.</para>
212                                         <value name="SUCCESS" />
213                                         <value name="USEREXIT" />
214                                         <value name="FAILED" />
215                                 </variable>
216                         </variablelist>
217                 </description>
218                 <see-also>
219                         <ref type="application">VoiceMailMain</ref>
220                 </see-also>
221         </application>
222         <application name="VoiceMailMain" language="en_US">
223                 <synopsis>
224                         Check Voicemail messages.
225                 </synopsis>
226                 <syntax>
227                         <parameter name="mailbox" required="true" argsep="@">
228                                 <argument name="mailbox" />
229                                 <argument name="context" />
230                         </parameter>
231                         <parameter name="options">
232                                 <optionlist>
233                                         <option name="p">
234                                                 <para>Consider the <replaceable>mailbox</replaceable> parameter as a prefix to
235                                                 the mailbox that is entered by the caller.</para>
236                                         </option>
237                                         <option name="g">
238                                                 <argument name="#" required="true" />
239                                                 <para>Use the specified amount of gain when recording a voicemail message.
240                                                 The units are whole-number decibels (dB).</para>
241                                         </option>
242                                         <option name="s">
243                                                 <para>Skip checking the passcode for the mailbox.</para>
244                                         </option>
245                                         <option name="a">
246                                                 <argument name="folder" required="true" />
247                                                 <para>Skip folder prompt and go directly to <replaceable>folder</replaceable> specified.
248                                                 Defaults to <literal>INBOX</literal> (or <literal>0</literal>).</para>
249                                                 <enumlist>
250                                                         <enum name="0"><para>INBOX</para></enum>
251                                                         <enum name="1"><para>Old</para></enum>
252                                                         <enum name="2"><para>Work</para></enum>
253                                                         <enum name="3"><para>Family</para></enum>
254                                                         <enum name="4"><para>Friends</para></enum>
255                                                         <enum name="5"><para>Cust1</para></enum>
256                                                         <enum name="6"><para>Cust2</para></enum>
257                                                         <enum name="7"><para>Cust3</para></enum>
258                                                         <enum name="8"><para>Cust4</para></enum>
259                                                         <enum name="9"><para>Cust5</para></enum>
260                                                 </enumlist>
261                                         </option>
262                                 </optionlist>
263                         </parameter>
264                 </syntax>
265                 <description>
266                         <para>This application allows the calling party to check voicemail messages. A specific
267                         <replaceable>mailbox</replaceable>, and optional corresponding <replaceable>context</replaceable>,
268                         may be specified. If a <replaceable>mailbox</replaceable> is not provided, the calling party will
269                         be prompted to enter one. If a <replaceable>context</replaceable> is not specified, the
270                         <literal>default</literal> context will be used.</para>
271                         <para>The VoiceMailMain application will exit if the following DTMF digit is entered as Mailbox
272                         or Password, and the extension exists:</para>
273                         <enumlist>
274                                 <enum name="*">
275                                         <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
276                                 </enum>
277                         </enumlist>
278                 </description>
279                 <see-also>
280                         <ref type="application">VoiceMail</ref>
281                 </see-also>
282         </application>
283         <application name="MailboxExists" language="en_US">
284                 <synopsis>
285                         Check to see if Voicemail mailbox exists.
286                 </synopsis>
287                 <syntax>
288                         <parameter name="mailbox" required="true" argsep="@">
289                                 <argument name="mailbox" required="true" />
290                                 <argument name="context" />
291                         </parameter>
292                         <parameter name="options">
293                                 <para>None options.</para>
294                         </parameter>
295                 </syntax>
296                 <description>
297                         <note><para>DEPRECATED. Use VM_INFO(mailbox[@context],exists) instead.</para></note>
298                         <para>Check to see if the specified <replaceable>mailbox</replaceable> exists. If no voicemail
299                         <replaceable>context</replaceable> is specified, the <literal>default</literal> context
300                         will be used.</para>
301                         <para>This application will set the following channel variable upon completion:</para>
302                         <variablelist>
303                                 <variable name="VMBOXEXISTSSTATUS">
304                                         <para>This will contain the status of the execution of the MailboxExists application.
305                                         Possible values include:</para>
306                                         <value name="SUCCESS" />
307                                         <value name="FAILED" />
308                                 </variable>
309                         </variablelist>
310                 </description>
311                 <see-also>
312                         <ref type="function">VM_INFO</ref>
313                 </see-also>
314         </application>
315         <application name="VMAuthenticate" language="en_US">
316                 <synopsis>
317                         Authenticate with Voicemail passwords.
318                 </synopsis>
319                 <syntax>
320                         <parameter name="mailbox" required="true" argsep="@">
321                                 <argument name="mailbox" />
322                                 <argument name="context" />
323                         </parameter>
324                         <parameter name="options">
325                                 <optionlist>
326                                         <option name="s">
327                                                 <para>Skip playing the initial prompts.</para>
328                                         </option>
329                                 </optionlist>
330                         </parameter>
331                 </syntax>
332                 <description>
333                         <para>This application behaves the same way as the Authenticate application, but the passwords
334                         are taken from <filename>voicemail.conf</filename>. If the <replaceable>mailbox</replaceable> is
335                         specified, only that mailbox's password will be considered valid. If the <replaceable>mailbox</replaceable>
336                         is not specified, the channel variable <variable>AUTH_MAILBOX</variable> will be set with the authenticated
337                         mailbox.</para>
338                         <para>The VMAuthenticate application will exit if the following DTMF digit is entered as Mailbox
339                         or Password, and the extension exists:</para>
340                         <enumlist>
341                                 <enum name="*">
342                                         <para>Jump to the <literal>a</literal> extension in the current dialplan context.</para>
343                                 </enum>
344                         </enumlist>
345                 </description>
346         </application>
347         <application name="VoiceMailPlayMsg" language="en_US">
348                 <synopsis>
349                         Play a single voice mail msg from a mailbox by msg id.
350                 </synopsis>
351                 <syntax>
352                         <parameter name="mailbox" required="true" argsep="@">
353                                 <argument name="mailbox" />
354                                 <argument name="context" />
355                         </parameter>
356                         <parameter name="msg_id" required="true">
357                                 <para>The msg id of the msg to play back. </para>
358                         </parameter>
359                 </syntax>
360                 <description>
361                         <para>This application sets the following channel variable upon completion:</para>
362                         <variablelist>
363                                 <variable name="VOICEMAIL_PLAYBACKSTATUS">
364                                         <para>The status of the playback attempt as a text string.</para>
365                                         <value name="SUCCESS"/>
366                                         <value name="FAILED"/>
367                                 </variable>
368                         </variablelist>
369                 </description>
370         </application>
371         <application name="VMSayName" language="en_US">
372                 <synopsis>
373                         Play the name of a voicemail user
374                 </synopsis>
375                 <syntax>
376                         <parameter name="mailbox" required="true" argsep="@">
377                                 <argument name="mailbox" />
378                                 <argument name="context" />
379                         </parameter>
380                 </syntax>
381                 <description>
382                         <para>This application will say the recorded name of the voicemail user specified as the
383                         argument to this application. If no context is provided, <literal>default</literal> is assumed.</para>
384                 </description>
385         </application>
386         <function name="MAILBOX_EXISTS" language="en_US">
387                 <synopsis>
388                         Tell if a mailbox is configured.
389                 </synopsis>
390                 <syntax argsep="@">
391                         <parameter name="mailbox" required="true" />
392                         <parameter name="context" />
393                 </syntax>
394                 <description>
395                         <note><para>DEPRECATED. Use VM_INFO(mailbox[@context],exists) instead.</para></note>
396                         <para>Returns a boolean of whether the corresponding <replaceable>mailbox</replaceable> exists.
397                         If <replaceable>context</replaceable> is not specified, defaults to the <literal>default</literal>
398                         context.</para>
399                 </description>
400                 <see-also>
401                         <ref type="function">VM_INFO</ref>
402                 </see-also>
403         </function>
404         <function name="VM_INFO" language="en_US">
405                 <synopsis>
406                         Returns the selected attribute from a mailbox.
407                 </synopsis>
408                 <syntax argsep=",">
409                         <parameter name="mailbox" argsep="@" required="true">
410                                 <argument name="mailbox" required="true" />
411                                 <argument name="context" />
412                         </parameter>
413                         <parameter name="attribute" required="true">
414                                 <optionlist>
415                                         <option name="count">
416                                                 <para>Count of messages in specified <replaceable>folder</replaceable>.
417                                                 If <replaceable>folder</replaceable> is not specified, defaults to <literal>INBOX</literal>.</para>
418                                         </option>
419                                         <option name="email">
420                                                 <para>E-mail address associated with the mailbox.</para>
421                                         </option>
422                                         <option name="exists">
423                                                 <para>Returns a boolean of whether the corresponding <replaceable>mailbox</replaceable> exists.</para>
424                                         </option>
425                                         <option name="fullname">
426                                                 <para>Full name associated with the mailbox.</para>
427                                         </option>
428                                         <option name="language">
429                                                 <para>Mailbox language if overridden, otherwise the language of the channel.</para>
430                                         </option>
431                                         <option name="locale">
432                                                 <para>Mailbox locale if overridden, otherwise global locale.</para>
433                                         </option>
434                                         <option name="pager">
435                                                 <para>Pager e-mail address associated with the mailbox.</para>
436                                         </option>
437                                         <option name="password">
438                                                 <para>Mailbox access password.</para>
439                                         </option>
440                                         <option name="tz">
441                                                 <para>Mailbox timezone if overridden, otherwise global timezone</para>
442                                         </option>
443                                 </optionlist>
444                         </parameter>
445                         <parameter name="folder" required="false">
446                                 <para>If not specified, <literal>INBOX</literal> is assumed.</para>
447                         </parameter>
448                 </syntax>
449                 <description>
450                         <para>Returns the selected attribute from the specified <replaceable>mailbox</replaceable>.
451                         If <replaceable>context</replaceable> is not specified, defaults to the <literal>default</literal>
452                         context. Where the <replaceable>folder</replaceable> can be specified, common folders
453                         include <literal>INBOX</literal>, <literal>Old</literal>, <literal>Work</literal>,
454                         <literal>Family</literal> and <literal>Friends</literal>.</para>
455                 </description>
456         </function>
457         <manager name="VoicemailUsersList" language="en_US">
458                 <synopsis>
459                         List All Voicemail User Information.
460                 </synopsis>
461                 <syntax>
462                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
463                 </syntax>
464                 <description>
465                 </description>
466         </manager>
467         <manager name="VoicemailRefresh" language="en_US">
468                 <synopsis>
469                         Tell Asterisk to poll mailboxes for a change
470                 </synopsis>
471                 <syntax>
472                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
473                         <parameter name="Context" />
474                         <parameter name="Mailbox" />
475                 </syntax>
476                 <description>
477                         <para>Normally, MWI indicators are only sent when Asterisk itself
478                         changes a mailbox.  With external programs that modify the content
479                         of a mailbox from outside the application, an option exists called
480                         <literal>pollmailboxes</literal> that will cause voicemail to
481                         continually scan all mailboxes on a system for changes.  This can
482                         cause a large amount of load on a system.  This command allows
483                         external applications to signal when a particular mailbox has
484                         changed, thus permitting external applications to modify mailboxes
485                         and MWI to work without introducing considerable CPU load.</para>
486                         <para>If <replaceable>Context</replaceable> is not specified, all
487                         mailboxes on the system will be polled for changes.  If
488                         <replaceable>Context</replaceable> is specified, but
489                         <replaceable>Mailbox</replaceable> is omitted, then all mailboxes
490                         within <replaceable>Context</replaceable> will be polled.
491                         Otherwise, only a single mailbox will be polled for changes.</para>
492                 </description>
493         </manager>
494  ***/
495
496 #ifdef IMAP_STORAGE
497 static char imapserver[48];
498 static char imapport[8];
499 static char imapflags[128];
500 static char imapfolder[64];
501 static char imapparentfolder[64] = "\0";
502 static char greetingfolder[64];
503 static char authuser[32];
504 static char authpassword[42];
505 static int imapversion = 1;
506
507 static int expungeonhangup = 1;
508 static int imapgreetings = 0;
509 static char delimiter = '\0';
510
511 struct vm_state;
512 struct ast_vm_user;
513
514 AST_THREADSTORAGE(ts_vmstate);
515
516 /* Forward declarations for IMAP */
517 static int init_mailstream(struct vm_state *vms, int box);
518 static void write_file(char *filename, char *buffer, unsigned long len);
519 static char *get_header_by_tag(char *header, char *tag, char *buf, size_t len);
520 static void vm_imap_delete(char *file, int msgnum, struct ast_vm_user *vmu);
521 static char *get_user_by_mailbox(char *mailbox, char *buf, size_t len);
522 static struct vm_state *get_vm_state_by_imapuser(const char *user, int interactive);
523 static struct vm_state *get_vm_state_by_mailbox(const char *mailbox, const char *context, int interactive);
524 static struct vm_state *create_vm_state_from_user(struct ast_vm_user *vmu);
525 static void vmstate_insert(struct vm_state *vms);
526 static void vmstate_delete(struct vm_state *vms);
527 static void set_update(MAILSTREAM * stream);
528 static void init_vm_state(struct vm_state *vms);
529 static int save_body(BODY *body, struct vm_state *vms, char *section, char *format, int is_intro);
530 static void get_mailbox_delimiter(struct vm_state *vms, MAILSTREAM *stream);
531 static void mm_parsequota (MAILSTREAM *stream, unsigned char *msg, QUOTALIST *pquota);
532 static void imap_mailbox_name(char *spec, size_t len, struct vm_state *vms, int box, int target);
533 static int imap_store_file(const char *dir, const char *mailboxuser, const char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag, const char *msg_id);
534 static void vm_imap_update_msg_id(char *dir, int msgnum, const char *msg_id, struct ast_vm_user *vmu, struct ast_config *msg_cfg, int folder);
535 static void update_messages_by_imapuser(const char *user, unsigned long number);
536 static int vm_delete(char *file);
537
538 static int imap_remove_file (char *dir, int msgnum);
539 static int imap_retrieve_file (const char *dir, const int msgnum, const char *mailbox, const char *context);
540 static int imap_delete_old_greeting (char *dir, struct vm_state *vms);
541 static void check_quota(struct vm_state *vms, char *mailbox);
542 static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box);
543 struct vmstate {
544         struct vm_state *vms;
545         AST_LIST_ENTRY(vmstate) list;
546 };
547
548 static AST_LIST_HEAD_STATIC(vmstates, vmstate);
549
550 #endif
551
552 #define SMDI_MWI_WAIT_TIMEOUT 1000 /* 1 second */
553
554 #define COMMAND_TIMEOUT 5000
555 /* Don't modify these here; set your umask at runtime instead */
556 #define VOICEMAIL_DIR_MODE      0777
557 #define VOICEMAIL_FILE_MODE     0666
558 #define CHUNKSIZE       65536
559
560 #define VOICEMAIL_CONFIG "voicemail.conf"
561 #define ASTERISK_USERNAME "asterisk"
562
563 /* Define fast-forward, pause, restart, and reverse keys
564  * while listening to a voicemail message - these are
565  * strings, not characters */
566 #define DEFAULT_LISTEN_CONTROL_FORWARD_KEY "#"
567 #define DEFAULT_LISTEN_CONTROL_REVERSE_KEY "*"
568 #define DEFAULT_LISTEN_CONTROL_PAUSE_KEY "0"
569 #define DEFAULT_LISTEN_CONTROL_RESTART_KEY "2"
570 #define DEFAULT_LISTEN_CONTROL_STOP_KEY "13456789"
571 #define VALID_DTMF "1234567890*#" /* Yes ABCD are valid dtmf but what phones have those? */
572
573 /* Default mail command to mail voicemail. Change it with the
574  * mailcmd= command in voicemail.conf */
575 #define SENDMAIL "/usr/sbin/sendmail -t"
576
577 #define INTRO "vm-intro"
578
579 #define MAXMSG 100
580 #define MAXMSGLIMIT 9999
581
582 #define MINPASSWORD 0 /*!< Default minimum mailbox password length */
583
584 #define BASELINELEN 72
585 #define BASEMAXINLINE 256
586 #ifdef IMAP_STORAGE
587 #define ENDL "\r\n"
588 #else
589 #define ENDL "\n"
590 #endif
591
592 #define MAX_DATETIME_FORMAT     512
593 #define MAX_NUM_CID_CONTEXTS 10
594
595 #define VM_REVIEW        (1 << 0)   /*!< After recording, permit the caller to review the recording before saving */
596 #define VM_OPERATOR      (1 << 1)   /*!< Allow 0 to be pressed to go to 'o' extension */
597 #define VM_SAYCID        (1 << 2)   /*!< Repeat the CallerID info during envelope playback */
598 #define VM_SVMAIL        (1 << 3)   /*!< Allow the user to compose a new VM from within VoicemailMain */
599 #define VM_ENVELOPE      (1 << 4)   /*!< Play the envelope information (who-from, time received, etc.) */
600 #define VM_SAYDURATION   (1 << 5)   /*!< Play the length of the message during envelope playback */
601 #define VM_SKIPAFTERCMD  (1 << 6)   /*!< After deletion, assume caller wants to go to the next message */
602 #define VM_FORCENAME     (1 << 7)   /*!< Have new users record their name */
603 #define VM_FORCEGREET    (1 << 8)   /*!< Have new users record their greetings */
604 #define VM_PBXSKIP       (1 << 9)   /*!< Skip the [PBX] preamble in the Subject line of emails */
605 #define VM_DIRECFORWARD  (1 << 10)  /*!< Permit caller to use the Directory app for selecting to which mailbox to forward a VM */
606 #define VM_ATTACH        (1 << 11)  /*!< Attach message to voicemail notifications? */
607 #define VM_DELETE        (1 << 12)  /*!< Delete message after sending notification */
608 #define VM_ALLOCED       (1 << 13)  /*!< Structure was malloc'ed, instead of placed in a return (usually static) buffer */
609 #define VM_SEARCH        (1 << 14)  /*!< Search all contexts for a matching mailbox */
610 #define VM_TEMPGREETWARN (1 << 15)  /*!< Remind user tempgreeting is set */
611 #define VM_MOVEHEARD     (1 << 16)  /*!< Move a "heard" message to Old after listening to it */
612 #define VM_MESSAGEWRAP   (1 << 17)  /*!< Wrap around from the last message to the first, and vice-versa */
613 #define VM_FWDURGAUTO    (1 << 18)  /*!< Autoset of Urgent flag on forwarded Urgent messages set globally */
614 #define ERROR_LOCK_PATH  -100
615 #define OPERATOR_EXIT     300
616
617 enum vm_box {
618         NEW_FOLDER,
619         OLD_FOLDER,
620         WORK_FOLDER,
621         FAMILY_FOLDER,
622         FRIENDS_FOLDER,
623         GREETINGS_FOLDER
624 };
625
626 enum vm_option_flags {
627         OPT_SILENT =           (1 << 0),
628         OPT_BUSY_GREETING =    (1 << 1),
629         OPT_UNAVAIL_GREETING = (1 << 2),
630         OPT_RECORDGAIN =       (1 << 3),
631         OPT_PREPEND_MAILBOX =  (1 << 4),
632         OPT_AUTOPLAY =         (1 << 6),
633         OPT_DTMFEXIT =         (1 << 7),
634         OPT_MESSAGE_Urgent =   (1 << 8),
635         OPT_MESSAGE_PRIORITY = (1 << 9)
636 };
637
638 enum vm_option_args {
639         OPT_ARG_RECORDGAIN = 0,
640         OPT_ARG_PLAYFOLDER = 1,
641         OPT_ARG_DTMFEXIT   = 2,
642         /* This *must* be the last value in this enum! */
643         OPT_ARG_ARRAY_SIZE = 3,
644 };
645
646 enum vm_passwordlocation {
647         OPT_PWLOC_VOICEMAILCONF = 0,
648         OPT_PWLOC_SPOOLDIR      = 1,
649         OPT_PWLOC_USERSCONF     = 2,
650 };
651
652 AST_APP_OPTIONS(vm_app_options, {
653         AST_APP_OPTION('s', OPT_SILENT),
654         AST_APP_OPTION('b', OPT_BUSY_GREETING),
655         AST_APP_OPTION('u', OPT_UNAVAIL_GREETING),
656         AST_APP_OPTION_ARG('g', OPT_RECORDGAIN, OPT_ARG_RECORDGAIN),
657         AST_APP_OPTION_ARG('d', OPT_DTMFEXIT, OPT_ARG_DTMFEXIT),
658         AST_APP_OPTION('p', OPT_PREPEND_MAILBOX),
659         AST_APP_OPTION_ARG('a', OPT_AUTOPLAY, OPT_ARG_PLAYFOLDER),
660         AST_APP_OPTION('U', OPT_MESSAGE_Urgent),
661         AST_APP_OPTION('P', OPT_MESSAGE_PRIORITY)
662 });
663
664 static const char * const mailbox_folders[] = {
665 #ifdef IMAP_STORAGE
666         imapfolder,
667 #else
668         "INBOX",
669 #endif
670         "Old",
671         "Work",
672         "Family",
673         "Friends",
674         "Cust1",
675         "Cust2",
676         "Cust3",
677         "Cust4",
678         "Cust5",
679         "Deleted",
680         "Urgent",
681 };
682
683 static int load_config(int reload);
684 #ifdef TEST_FRAMEWORK
685 static int load_config_from_memory(int reload, struct ast_config *cfg, struct ast_config *ucfg);
686 #endif
687 static int actual_load_config(int reload, struct ast_config *cfg, struct ast_config *ucfg);
688
689 /*! \page vmlang Voicemail Language Syntaxes Supported
690
691         \par Syntaxes supported, not really language codes.
692         \arg \b en    - English
693         \arg \b de    - German
694         \arg \b es    - Spanish
695         \arg \b fr    - French
696         \arg \b it    - Italian
697         \arg \b nl    - Dutch
698         \arg \b pt    - Portuguese
699         \arg \b pt_BR - Portuguese (Brazil)
700         \arg \b gr    - Greek
701         \arg \b no    - Norwegian
702         \arg \b se    - Swedish
703         \arg \b tw    - Chinese (Taiwan)
704         \arg \b ua - Ukrainian
705
706 German requires the following additional soundfile:
707 \arg \b 1F      einE (feminine)
708
709 Spanish requires the following additional soundfile:
710 \arg \b 1M      un (masculine)
711
712 Dutch, Portuguese & Spanish require the following additional soundfiles:
713 \arg \b vm-INBOXs       singular of 'new'
714 \arg \b vm-Olds         singular of 'old/heard/read'
715
716 NB these are plural:
717 \arg \b vm-INBOX        nieuwe (nl)
718 \arg \b vm-Old          oude (nl)
719
720 Polish uses:
721 \arg \b vm-new-a        'new', feminine singular accusative
722 \arg \b vm-new-e        'new', feminine plural accusative
723 \arg \b vm-new-ych      'new', feminine plural genitive
724 \arg \b vm-old-a        'old', feminine singular accusative
725 \arg \b vm-old-e        'old', feminine plural accusative
726 \arg \b vm-old-ych      'old', feminine plural genitive
727 \arg \b digits/1-a      'one', not always same as 'digits/1'
728 \arg \b digits/2-ie     'two', not always same as 'digits/2'
729
730 Swedish uses:
731 \arg \b vm-nytt         singular of 'new'
732 \arg \b vm-nya          plural of 'new'
733 \arg \b vm-gammalt      singular of 'old'
734 \arg \b vm-gamla        plural of 'old'
735 \arg \b digits/ett      'one', not always same as 'digits/1'
736
737 Norwegian uses:
738 \arg \b vm-ny           singular of 'new'
739 \arg \b vm-nye          plural of 'new'
740 \arg \b vm-gammel       singular of 'old'
741 \arg \b vm-gamle        plural of 'old'
742
743 Dutch also uses:
744 \arg \b nl-om           'at'?
745
746 Spanish also uses:
747 \arg \b vm-youhaveno
748
749 Italian requires the following additional soundfile:
750
751 For vm_intro_it:
752 \arg \b vm-nuovo        new
753 \arg \b vm-nuovi        new plural
754 \arg \b vm-vecchio      old
755 \arg \b vm-vecchi       old plural
756
757 Chinese (Taiwan) requires the following additional soundfile:
758 \arg \b vm-tong         A class-word for call (tong1)
759 \arg \b vm-ri           A class-word for day (ri4)
760 \arg \b vm-you          You (ni3)
761 \arg \b vm-haveno   Have no (mei2 you3)
762 \arg \b vm-have     Have (you3)
763 \arg \b vm-listen   To listen (yao4 ting1)
764
765
766 \note Don't use vm-INBOX or vm-Old, because they are the name of the INBOX and Old folders,
767 spelled among others when you have to change folder. For the above reasons, vm-INBOX
768 and vm-Old are spelled plural, to make them sound more as folder name than an adjective.
769
770 */
771
772 struct baseio {
773         int iocp;
774         int iolen;
775         int linelength;
776         int ateof;
777         unsigned char iobuf[BASEMAXINLINE];
778 };
779
780 /*! Structure for linked list of users 
781  * Use ast_vm_user_destroy() to free one of these structures. */
782 struct ast_vm_user {
783         char context[AST_MAX_CONTEXT];   /*!< Voicemail context */
784         char mailbox[AST_MAX_EXTENSION]; /*!< Mailbox id, unique within vm context */
785         char password[80];               /*!< Secret pin code, numbers only */
786         char fullname[80];               /*!< Full name, for directory app */
787         char email[80];                  /*!< E-mail address */
788         char *emailsubject;              /*!< E-mail subject */
789         char *emailbody;                 /*!< E-mail body */
790         char pager[80];                  /*!< E-mail address to pager (no attachment) */
791         char serveremail[80];            /*!< From: Mail address */
792         char language[MAX_LANGUAGE];     /*!< Config: Language setting */
793         char zonetag[80];                /*!< Time zone */
794         char locale[20];                 /*!< The locale (for presentation of date/time) */
795         char callback[80];
796         char dialout[80];
797         char uniqueid[80];               /*!< Unique integer identifier */
798         char exit[80];
799         char attachfmt[20];              /*!< Attachment format */
800         unsigned int flags;              /*!< VM_ flags */      
801         int saydurationm;
802         int minsecs;                     /*!< Minimum number of seconds per message for this mailbox */
803         int maxmsg;                      /*!< Maximum number of msgs per folder for this mailbox */
804         int maxdeletedmsg;               /*!< Maximum number of deleted msgs saved for this mailbox */
805         int maxsecs;                     /*!< Maximum number of seconds per message for this mailbox */
806         int passwordlocation;            /*!< Storage location of the password */
807 #ifdef IMAP_STORAGE
808         char imapserver[48];             /*!< IMAP server address */
809         char imapport[8];                /*!< IMAP server port */
810         char imapflags[128];             /*!< IMAP optional flags */
811         char imapuser[80];               /*!< IMAP server login */
812         char imappassword[80];           /*!< IMAP server password if authpassword not defined */
813         char imapfolder[64];             /*!< IMAP voicemail folder */
814         char imapvmshareid[80];          /*!< Shared mailbox ID to use rather than the dialed one */
815         int imapversion;                 /*!< If configuration changes, use the new values */
816 #endif
817         double volgain;                  /*!< Volume gain for voicemails sent via email */
818         AST_LIST_ENTRY(ast_vm_user) list;
819 };
820
821 /*! Voicemail time zones */
822 struct vm_zone {
823         AST_LIST_ENTRY(vm_zone) list;
824         char name[80];
825         char timezone[80];
826         char msg_format[512];
827 };
828
829 #define VMSTATE_MAX_MSG_ARRAY 256
830
831 /*! Voicemail mailbox state */
832 struct vm_state {
833         char curbox[80];
834         char username[80];
835         char context[80];
836         char curdir[PATH_MAX];
837         char vmbox[PATH_MAX];
838         char fn[PATH_MAX];
839         char intro[PATH_MAX];
840         int *deleted;
841         int *heard;
842         int dh_arraysize; /* used for deleted / heard allocation */
843         int curmsg;
844         int lastmsg;
845         int newmessages;
846         int oldmessages;
847         int urgentmessages;
848         int starting;
849         int repeats;
850 #ifdef IMAP_STORAGE
851         ast_mutex_t lock;
852         int updated;                         /*!< decremented on each mail check until 1 -allows delay */
853         long msgArray[VMSTATE_MAX_MSG_ARRAY];
854         MAILSTREAM *mailstream;
855         int vmArrayIndex;
856         char imapuser[80];                   /*!< IMAP server login */
857         char imapfolder[64];                 /*!< IMAP voicemail folder */
858         char imapserver[48];                 /*!< IMAP server address */
859         char imapport[8];                    /*!< IMAP server port */
860         char imapflags[128];                 /*!< IMAP optional flags */
861         int imapversion;
862         int interactive;
863         char introfn[PATH_MAX];              /*!< Name of prepended file */
864         unsigned int quota_limit;
865         unsigned int quota_usage;
866         struct vm_state *persist_vms;
867 #endif
868 };
869
870 #ifdef ODBC_STORAGE
871 static char odbc_database[80];
872 static char odbc_table[80];
873 #define RETRIEVE(a,b,c,d) retrieve_file(a,b)
874 #define DISPOSE(a,b) remove_file(a,b)
875 #define STORE(a,b,c,d,e,f,g,h,i,j,k) store_file(a,b,c,d)
876 #define EXISTS(a,b,c,d) (message_exists(a,b))
877 #define RENAME(a,b,c,d,e,f,g,h) (rename_file(a,b,c,d,e,f))
878 #define COPY(a,b,c,d,e,f,g,h) (copy_file(a,b,c,d,e,f))
879 #define DELETE(a,b,c,d) (delete_file(a,b))
880 #define UPDATE_MSG_ID(a, b, c, d, e, f) (odbc_update_msg_id((a), (b), (c)))
881 #else
882 #ifdef IMAP_STORAGE
883 #define DISPOSE(a,b) (imap_remove_file(a,b))
884 #define STORE(a,b,c,d,e,f,g,h,i,j,k) (imap_store_file(a,b,c,d,e,f,g,h,i,j,k))
885 #define RETRIEVE(a,b,c,d) imap_retrieve_file(a,b,c,d)
886 #define EXISTS(a,b,c,d) (ast_fileexists(c,NULL,d) > 0)
887 #define RENAME(a,b,c,d,e,f,g,h) (rename_file(g,h));
888 #define COPY(a,b,c,d,e,f,g,h) (copy_file(g,h));
889 #define DELETE(a,b,c,d) (vm_imap_delete(a,b,d))
890 #define UPDATE_MSG_ID(a, b, c, d, e, f) (vm_imap_update_msg_id((a), (b), (c), (d), (e), (f)))
891 #else
892 #define RETRIEVE(a,b,c,d)
893 #define DISPOSE(a,b)
894 #define STORE(a,b,c,d,e,f,g,h,i,j,k)
895 #define EXISTS(a,b,c,d) (ast_fileexists(c,NULL,d) > 0)
896 #define RENAME(a,b,c,d,e,f,g,h) (rename_file(g,h));
897 #define COPY(a,b,c,d,e,f,g,h) (copy_plain_file(g,h)); 
898 #define DELETE(a,b,c,d) (vm_delete(c))
899 #define UPDATE_MSG_ID(a, b, c, d, e, f)
900 #endif
901 #endif
902
903 static char VM_SPOOL_DIR[PATH_MAX];
904
905 static char ext_pass_cmd[128];
906 static char ext_pass_check_cmd[128];
907
908 static int my_umask;
909
910 #define PWDCHANGE_INTERNAL (1 << 1)
911 #define PWDCHANGE_EXTERNAL (1 << 2)
912 static int pwdchange = PWDCHANGE_INTERNAL;
913
914 #ifdef ODBC_STORAGE
915 #define tdesc "Comedian Mail (Voicemail System) with ODBC Storage"
916 #else
917 # ifdef IMAP_STORAGE
918 # define tdesc "Comedian Mail (Voicemail System) with IMAP Storage"
919 # else
920 # define tdesc "Comedian Mail (Voicemail System)"
921 # endif
922 #endif
923
924 static char userscontext[AST_MAX_EXTENSION] = "default";
925
926 static char *addesc = "Comedian Mail";
927
928 /* Leave a message */
929 static char *app = "VoiceMail";
930
931 /* Check mail, control, etc */
932 static char *app2 = "VoiceMailMain";
933
934 static char *app3 = "MailboxExists";
935 static char *app4 = "VMAuthenticate";
936
937 static char *playmsg_app = "VoiceMailPlayMsg";
938
939 static char *sayname_app = "VMSayName";
940
941 static AST_LIST_HEAD_STATIC(users, ast_vm_user);
942 static AST_LIST_HEAD_STATIC(zones, vm_zone);
943 static char zonetag[80];
944 static char locale[20];
945 static int maxsilence;
946 static int maxmsg;
947 static int maxdeletedmsg;
948 static int silencethreshold = 128;
949 static char serveremail[80];
950 static char mailcmd[160];       /* Configurable mail cmd */
951 static char externnotify[160]; 
952 static struct ast_smdi_interface *smdi_iface = NULL;
953 static char vmfmts[80];
954 static double volgain;
955 static int vmminsecs;
956 static int vmmaxsecs;
957 static int maxgreet;
958 static int skipms;
959 static int maxlogins;
960 static int minpassword;
961 static int passwordlocation;
962
963 /*! Poll mailboxes for changes since there is something external to
964  *  app_voicemail that may change them. */
965 static unsigned int poll_mailboxes;
966
967 /*! Polling frequency */
968 static unsigned int poll_freq;
969 /*! By default, poll every 30 seconds */
970 #define DEFAULT_POLL_FREQ 30
971
972 AST_MUTEX_DEFINE_STATIC(poll_lock);
973 static ast_cond_t poll_cond = PTHREAD_COND_INITIALIZER;
974 static pthread_t poll_thread = AST_PTHREADT_NULL;
975 static unsigned char poll_thread_run;
976
977 /*! Subscription to MWI event subscription changes */
978 static struct stasis_subscription *mwi_sub_sub;
979
980 /*!
981  * \brief An MWI subscription
982  *
983  * This is so we can keep track of which mailboxes are subscribed to.
984  * This way, we know which mailboxes to poll when the pollmailboxes
985  * option is being used.
986  */
987 struct mwi_sub {
988         AST_RWLIST_ENTRY(mwi_sub) entry;
989         int old_urgent;
990         int old_new;
991         int old_old;
992         char *uniqueid;
993         char mailbox[1];
994 };
995
996 struct mwi_sub_task {
997         const char *mailbox;
998         const char *context;
999         const char *uniqueid;
1000 };
1001
1002 static void mwi_sub_task_dtor(struct mwi_sub_task *mwist)
1003 {
1004         ast_free((void *) mwist->mailbox);
1005         ast_free((void *) mwist->context);
1006         ast_free((void *) mwist->uniqueid);
1007         ast_free(mwist);
1008 }
1009
1010 static struct ast_taskprocessor *mwi_subscription_tps;
1011
1012 static AST_RWLIST_HEAD_STATIC(mwi_subs, mwi_sub);
1013
1014 /* custom audio control prompts for voicemail playback */
1015 static char listen_control_forward_key[12];
1016 static char listen_control_reverse_key[12];
1017 static char listen_control_pause_key[12];
1018 static char listen_control_restart_key[12];
1019 static char listen_control_stop_key[12];
1020
1021 /* custom password sounds */
1022 static char vm_password[80] = "vm-password";
1023 static char vm_newpassword[80] = "vm-newpassword";
1024 static char vm_passchanged[80] = "vm-passchanged";
1025 static char vm_reenterpassword[80] = "vm-reenterpassword";
1026 static char vm_mismatch[80] = "vm-mismatch";
1027 static char vm_invalid_password[80] = "vm-invalid-password";
1028 static char vm_pls_try_again[80] = "vm-pls-try-again";
1029
1030 /*
1031  * XXX If we have the time, motivation, etc. to fix up this prompt, one of the following would be appropriate:
1032  * 1. create a sound along the lines of "Please try again.  When done, press the pound key" which could be spliced
1033  * from existing sound clips.  This would require some programming changes in the area of vm_forward options and also
1034  * app.c's __ast_play_and_record function
1035  * 2. create a sound prompt saying "Please try again.  When done recording, press any key to stop and send the prepended
1036  * message."  At the time of this comment, I think this would require new voice work to be commissioned.
1037  * 3. Something way different like providing instructions before a time out or a post-recording menu.  This would require
1038  * more effort than either of the other two.
1039  */
1040 static char vm_prepend_timeout[80] = "vm-then-pound";
1041
1042 static struct ast_flags globalflags = {0};
1043
1044 static int saydurationminfo;
1045
1046 static char dialcontext[AST_MAX_CONTEXT] = "";
1047 static char callcontext[AST_MAX_CONTEXT] = "";
1048 static char exitcontext[AST_MAX_CONTEXT] = "";
1049
1050 static char cidinternalcontexts[MAX_NUM_CID_CONTEXTS][64];
1051
1052
1053 static char *emailbody = NULL;
1054 static char *emailsubject = NULL;
1055 static char *pagerbody = NULL;
1056 static char *pagersubject = NULL;
1057 static char fromstring[100];
1058 static char pagerfromstring[100];
1059 static char charset[32] = "ISO-8859-1";
1060
1061 static unsigned char adsifdn[4] = "\x00\x00\x00\x0F";
1062 static unsigned char adsisec[4] = "\x9B\xDB\xF7\xAC";
1063 static int adsiver = 1;
1064 static char emaildateformat[32] = "%A, %B %d, %Y at %r";
1065 static char pagerdateformat[32] = "%A, %B %d, %Y at %r";
1066
1067 /* Forward declarations - generic */
1068 static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box);
1069 static int close_mailbox(struct vm_state *vms, struct ast_vm_user *vmu);
1070 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);
1071 static int dialout(struct ast_channel *chan, struct ast_vm_user *vmu, char *num, char *outgoing_context);
1072 static int play_record_review(struct ast_channel *chan, char *playfile, char *recordfile, int maxtime,
1073                         char *fmt, int outsidecaller, struct ast_vm_user *vmu, int *duration, int *sound_duration, const char *unlockdir,
1074                         signed char record_gain, struct vm_state *vms, char *flag, const char *msg_id);
1075 static int vm_tempgreeting(struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms, char *fmtc, signed char record_gain);
1076 static int vm_play_folder_name(struct ast_channel *chan, char *mbox);
1077 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);
1078 static void make_email_file(FILE *p, char *srcemail, struct ast_vm_user *vmu, int msgnum, char *context, char *mailbox, const char *fromfolder, char *cidnum, char *cidname, char *attach, char *attach2, char *format, int duration, int attach_user_voicemail, struct ast_channel *chan, const char *category, int imap, const char *flag, const char *msg_id);
1079 static void apply_options(struct ast_vm_user *vmu, const char *options);
1080 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);
1081 static int is_valid_dtmf(const char *key);
1082 static void read_password_from_file(const char *secretfn, char *password, int passwordlen);
1083 static int write_password_to_file(const char *secretfn, const char *password);
1084 static const char *substitute_escapes(const char *value);
1085 static int message_range_and_existence_check(struct vm_state *vms, const char *msg_ids [], size_t num_msgs, int *msg_nums, struct ast_vm_user *vmu);
1086 /*!
1087  * Place a message in the indicated folder
1088  *
1089  * \param vmu Voicemail user
1090  * \param vms Current voicemail state for the user
1091  * \param msg The message number to save
1092  * \param box The folder into which the message should be saved
1093  * \param[out] newmsg The new message number of the saved message
1094  * \param move Tells whether to copy or to move the message
1095  *
1096  * \note the "move" parameter is only honored for IMAP voicemail presently
1097  * \retval 0 Success
1098  * \retval other Failure
1099  */
1100 static int save_to_folder(struct ast_vm_user *vmu, struct vm_state *vms, int msg, int box, int *newmsg, int move);
1101
1102 static struct ast_vm_mailbox_snapshot *vm_mailbox_snapshot_create(const char *mailbox, const char *context, const char *folder, int descending, enum ast_vm_snapshot_sort_val sort_val, int combine_INBOX_and_OLD);
1103 static struct ast_vm_mailbox_snapshot *vm_mailbox_snapshot_destroy(struct ast_vm_mailbox_snapshot *mailbox_snapshot);
1104
1105 static int vm_msg_forward(const char *from_mailbox, const char *from_context, const char *from_folder, const char *to_mailbox, const char *to_context, const char *to_folder, size_t num_msgs, const char *msg_ids[], int delete_old);
1106 static int vm_msg_move(const char *mailbox, const char *context, size_t num_msgs, const char *oldfolder, const char *old_msg_ids[], const char *newfolder);
1107 static int vm_msg_remove(const char *mailbox, const char *context, size_t num_msgs, const char *folder, const char *msgs[]);
1108 static int vm_msg_play(struct ast_channel *chan, const char *mailbox, const char *context, const char *folder, const char *msg_num, ast_vm_msg_play_cb cb);
1109
1110 #ifdef TEST_FRAMEWORK
1111 static int vm_test_destroy_user(const char *context, const char *mailbox);
1112 static int vm_test_create_user(const char *context, const char *mailbox);
1113 #endif
1114
1115 struct ao2_container *inprocess_container;
1116
1117 struct inprocess {
1118         int count;
1119         char *context;
1120         char mailbox[0];
1121 };
1122
1123 static int inprocess_hash_fn(const void *obj, const int flags)
1124 {
1125         const struct inprocess *i = obj;
1126         return atoi(i->mailbox);
1127 }
1128
1129 static int inprocess_cmp_fn(void *obj, void *arg, int flags)
1130 {
1131         struct inprocess *i = obj, *j = arg;
1132         if (strcmp(i->mailbox, j->mailbox)) {
1133                 return 0;
1134         }
1135         return !strcmp(i->context, j->context) ? CMP_MATCH : 0;
1136 }
1137
1138 static int inprocess_count(const char *context, const char *mailbox, int delta)
1139 {
1140         struct inprocess *i, *arg = ast_alloca(sizeof(*arg) + strlen(context) + strlen(mailbox) + 2);
1141         arg->context = arg->mailbox + strlen(mailbox) + 1;
1142         strcpy(arg->mailbox, mailbox); /* SAFE */
1143         strcpy(arg->context, context); /* SAFE */
1144         ao2_lock(inprocess_container);
1145         if ((i = ao2_find(inprocess_container, arg, 0))) {
1146                 int ret = ast_atomic_fetchadd_int(&i->count, delta);
1147                 ao2_unlock(inprocess_container);
1148                 ao2_ref(i, -1);
1149                 return ret;
1150         }
1151         if (delta < 0) {
1152                 ast_log(LOG_WARNING, "BUG: ref count decrement on non-existing object???\n");
1153         }
1154         if (!(i = ao2_alloc(sizeof(*i) + strlen(context) + strlen(mailbox) + 2, NULL))) {
1155                 ao2_unlock(inprocess_container);
1156                 return 0;
1157         }
1158         i->context = i->mailbox + strlen(mailbox) + 1;
1159         strcpy(i->mailbox, mailbox); /* SAFE */
1160         strcpy(i->context, context); /* SAFE */
1161         i->count = delta;
1162         ao2_link(inprocess_container, i);
1163         ao2_unlock(inprocess_container);
1164         ao2_ref(i, -1);
1165         return 0;
1166 }
1167
1168 #if !(defined(ODBC_STORAGE) || defined(IMAP_STORAGE))
1169 static int __has_voicemail(const char *context, const char *mailbox, const char *folder, int shortcircuit);
1170 #endif
1171
1172 /*!
1173  * \brief Strips control and non 7-bit clean characters from input string.
1174  *
1175  * \note To map control and none 7-bit characters to a 7-bit clean characters
1176  *  please use ast_str_encode_mine().
1177  */
1178 static char *strip_control_and_high(const char *input, char *buf, size_t buflen)
1179 {
1180         char *bufptr = buf;
1181         for (; *input; input++) {
1182                 if (*input < 32) {
1183                         continue;
1184                 }
1185                 *bufptr++ = *input;
1186                 if (bufptr == buf + buflen - 1) {
1187                         break;
1188                 }
1189         }
1190         *bufptr = '\0';
1191         return buf;
1192 }
1193
1194
1195 /*!
1196  * \brief Sets default voicemail system options to a voicemail user.
1197  *
1198  * This applies select global settings to a newly created (dynamic) instance of a voicemail user.
1199  * - all the globalflags
1200  * - the saydurationminfo
1201  * - the callcontext
1202  * - the dialcontext
1203  * - the exitcontext
1204  * - vmmaxsecs, vmmaxmsg, maxdeletedmsg
1205  * - volume gain.
1206  * - emailsubject, emailbody set to NULL
1207  */
1208 static void populate_defaults(struct ast_vm_user *vmu)
1209 {
1210         ast_copy_flags(vmu, (&globalflags), AST_FLAGS_ALL);
1211         vmu->passwordlocation = passwordlocation;
1212         if (saydurationminfo) {
1213                 vmu->saydurationm = saydurationminfo;
1214         }
1215         ast_copy_string(vmu->callback, callcontext, sizeof(vmu->callback));
1216         ast_copy_string(vmu->dialout, dialcontext, sizeof(vmu->dialout));
1217         ast_copy_string(vmu->exit, exitcontext, sizeof(vmu->exit));
1218         ast_copy_string(vmu->zonetag, zonetag, sizeof(vmu->zonetag));
1219         ast_copy_string(vmu->locale, locale, sizeof(vmu->locale));
1220         if (vmminsecs) {
1221                 vmu->minsecs = vmminsecs;
1222         }
1223         if (vmmaxsecs) {
1224                 vmu->maxsecs = vmmaxsecs;
1225         }
1226         if (maxmsg) {
1227                 vmu->maxmsg = maxmsg;
1228         }
1229         if (maxdeletedmsg) {
1230                 vmu->maxdeletedmsg = maxdeletedmsg;
1231         }
1232         vmu->volgain = volgain;
1233         ast_free(vmu->emailsubject);
1234         vmu->emailsubject = NULL;
1235         ast_free(vmu->emailbody);
1236         vmu->emailbody = NULL;
1237 #ifdef IMAP_STORAGE
1238         ast_copy_string(vmu->imapfolder, imapfolder, sizeof(vmu->imapfolder));
1239         ast_copy_string(vmu->imapserver, imapserver, sizeof(vmu->imapserver));
1240         ast_copy_string(vmu->imapport, imapport, sizeof(vmu->imapport));
1241         ast_copy_string(vmu->imapflags, imapflags, sizeof(vmu->imapflags));
1242 #endif
1243 }
1244
1245 /*!
1246  * \brief Sets a a specific property value.
1247  * \param vmu The voicemail user object to work with.
1248  * \param var The name of the property to be set.
1249  * \param value The value to be set to the property.
1250  * 
1251  * The property name must be one of the understood properties. See the source for details.
1252  */
1253 static void apply_option(struct ast_vm_user *vmu, const char *var, const char *value)
1254 {
1255         int x;
1256         if (!strcasecmp(var, "attach")) {
1257                 ast_set2_flag(vmu, ast_true(value), VM_ATTACH);
1258         } else if (!strcasecmp(var, "attachfmt")) {
1259                 ast_copy_string(vmu->attachfmt, value, sizeof(vmu->attachfmt));
1260         } else if (!strcasecmp(var, "serveremail")) {
1261                 ast_copy_string(vmu->serveremail, value, sizeof(vmu->serveremail));
1262         } else if (!strcasecmp(var, "emailbody")) {
1263                 ast_free(vmu->emailbody);
1264                 vmu->emailbody = ast_strdup(substitute_escapes(value));
1265         } else if (!strcasecmp(var, "emailsubject")) {
1266                 ast_free(vmu->emailsubject);
1267                 vmu->emailsubject = ast_strdup(substitute_escapes(value));
1268         } else if (!strcasecmp(var, "language")) {
1269                 ast_copy_string(vmu->language, value, sizeof(vmu->language));
1270         } else if (!strcasecmp(var, "tz")) {
1271                 ast_copy_string(vmu->zonetag, value, sizeof(vmu->zonetag));
1272         } else if (!strcasecmp(var, "locale")) {
1273                 ast_copy_string(vmu->locale, value, sizeof(vmu->locale));
1274 #ifdef IMAP_STORAGE
1275         } else if (!strcasecmp(var, "imapuser")) {
1276                 ast_copy_string(vmu->imapuser, value, sizeof(vmu->imapuser));
1277                 vmu->imapversion = imapversion;
1278         } else if (!strcasecmp(var, "imapserver")) {
1279                 ast_copy_string(vmu->imapserver, value, sizeof(vmu->imapserver));
1280                 vmu->imapversion = imapversion;
1281         } else if (!strcasecmp(var, "imapport")) {
1282                 ast_copy_string(vmu->imapport, value, sizeof(vmu->imapport));
1283                 vmu->imapversion = imapversion;
1284         } else if (!strcasecmp(var, "imapflags")) {
1285                 ast_copy_string(vmu->imapflags, value, sizeof(vmu->imapflags));
1286                 vmu->imapversion = imapversion;
1287         } else if (!strcasecmp(var, "imappassword") || !strcasecmp(var, "imapsecret")) {
1288                 ast_copy_string(vmu->imappassword, value, sizeof(vmu->imappassword));
1289                 vmu->imapversion = imapversion;
1290         } else if (!strcasecmp(var, "imapfolder")) {
1291                 ast_copy_string(vmu->imapfolder, value, sizeof(vmu->imapfolder));
1292                 vmu->imapversion = imapversion;
1293         } else if (!strcasecmp(var, "imapvmshareid")) {
1294                 ast_copy_string(vmu->imapvmshareid, value, sizeof(vmu->imapvmshareid));
1295                 vmu->imapversion = imapversion;
1296 #endif
1297         } else if (!strcasecmp(var, "delete") || !strcasecmp(var, "deletevoicemail")) {
1298                 ast_set2_flag(vmu, ast_true(value), VM_DELETE); 
1299         } else if (!strcasecmp(var, "saycid")){
1300                 ast_set2_flag(vmu, ast_true(value), VM_SAYCID); 
1301         } else if (!strcasecmp(var, "sendvoicemail")){
1302                 ast_set2_flag(vmu, ast_true(value), VM_SVMAIL); 
1303         } else if (!strcasecmp(var, "review")){
1304                 ast_set2_flag(vmu, ast_true(value), VM_REVIEW);
1305         } else if (!strcasecmp(var, "tempgreetwarn")){
1306                 ast_set2_flag(vmu, ast_true(value), VM_TEMPGREETWARN);  
1307         } else if (!strcasecmp(var, "messagewrap")){
1308                 ast_set2_flag(vmu, ast_true(value), VM_MESSAGEWRAP);    
1309         } else if (!strcasecmp(var, "operator")) {
1310                 ast_set2_flag(vmu, ast_true(value), VM_OPERATOR);       
1311         } else if (!strcasecmp(var, "envelope")){
1312                 ast_set2_flag(vmu, ast_true(value), VM_ENVELOPE);       
1313         } else if (!strcasecmp(var, "moveheard")){
1314                 ast_set2_flag(vmu, ast_true(value), VM_MOVEHEARD);
1315         } else if (!strcasecmp(var, "sayduration")){
1316                 ast_set2_flag(vmu, ast_true(value), VM_SAYDURATION);    
1317         } else if (!strcasecmp(var, "saydurationm")){
1318                 if (sscanf(value, "%30d", &x) == 1) {
1319                         vmu->saydurationm = x;
1320                 } else {
1321                         ast_log(AST_LOG_WARNING, "Invalid min duration for say duration\n");
1322                 }
1323         } else if (!strcasecmp(var, "forcename")){
1324                 ast_set2_flag(vmu, ast_true(value), VM_FORCENAME);      
1325         } else if (!strcasecmp(var, "forcegreetings")){
1326                 ast_set2_flag(vmu, ast_true(value), VM_FORCEGREET);     
1327         } else if (!strcasecmp(var, "callback")) {
1328                 ast_copy_string(vmu->callback, value, sizeof(vmu->callback));
1329         } else if (!strcasecmp(var, "dialout")) {
1330                 ast_copy_string(vmu->dialout, value, sizeof(vmu->dialout));
1331         } else if (!strcasecmp(var, "exitcontext")) {
1332                 ast_copy_string(vmu->exit, value, sizeof(vmu->exit));
1333         } else if (!strcasecmp(var, "minsecs")) {
1334                 if (sscanf(value, "%30d", &x) == 1 && x >= 0) {
1335                         vmu->minsecs = x;
1336                 } else {
1337                         ast_log(LOG_WARNING, "Invalid min message length of %s. Using global value %d\n", value, vmminsecs);
1338                         vmu->minsecs = vmminsecs;
1339                 }
1340         } else if (!strcasecmp(var, "maxmessage") || !strcasecmp(var, "maxsecs")) {
1341                 vmu->maxsecs = atoi(value);
1342                 if (vmu->maxsecs <= 0) {
1343                         ast_log(AST_LOG_WARNING, "Invalid max message length of %s. Using global value %d\n", value, vmmaxsecs);
1344                         vmu->maxsecs = vmmaxsecs;
1345                 } else {
1346                         vmu->maxsecs = atoi(value);
1347                 }
1348                 if (!strcasecmp(var, "maxmessage"))
1349                         ast_log(AST_LOG_WARNING, "Option 'maxmessage' has been deprecated in favor of 'maxsecs'.  Please make that change in your voicemail config.\n");
1350         } else if (!strcasecmp(var, "maxmsg")) {
1351                 vmu->maxmsg = atoi(value);
1352                 /* Accept maxmsg=0 (Greetings only voicemail) */
1353                 if (vmu->maxmsg < 0) {
1354                         ast_log(AST_LOG_WARNING, "Invalid number of messages per folder maxmsg=%s. Using default value %d\n", value, MAXMSG);
1355                         vmu->maxmsg = MAXMSG;
1356                 } else if (vmu->maxmsg > MAXMSGLIMIT) {
1357                         ast_log(AST_LOG_WARNING, "Maximum number of messages per folder is %d. Cannot accept value maxmsg=%s\n", MAXMSGLIMIT, value);
1358                         vmu->maxmsg = MAXMSGLIMIT;
1359                 }
1360         } else if (!strcasecmp(var, "nextaftercmd")) {
1361                 ast_set2_flag(vmu, ast_true(value), VM_SKIPAFTERCMD);
1362         } else if (!strcasecmp(var, "backupdeleted")) {
1363                 if (sscanf(value, "%30d", &x) == 1)
1364                         vmu->maxdeletedmsg = x;
1365                 else if (ast_true(value))
1366                         vmu->maxdeletedmsg = MAXMSG;
1367                 else
1368                         vmu->maxdeletedmsg = 0;
1369
1370                 if (vmu->maxdeletedmsg < 0) {
1371                         ast_log(AST_LOG_WARNING, "Invalid number of deleted messages saved per mailbox backupdeleted=%s. Using default value %d\n", value, MAXMSG);
1372                         vmu->maxdeletedmsg = MAXMSG;
1373                 } else if (vmu->maxdeletedmsg > MAXMSGLIMIT) {
1374                         ast_log(AST_LOG_WARNING, "Maximum number of deleted messages saved per mailbox is %d. Cannot accept value backupdeleted=%s\n", MAXMSGLIMIT, value);
1375                         vmu->maxdeletedmsg = MAXMSGLIMIT;
1376                 }
1377         } else if (!strcasecmp(var, "volgain")) {
1378                 sscanf(value, "%30lf", &vmu->volgain);
1379         } else if (!strcasecmp(var, "passwordlocation")) {
1380                 if (!strcasecmp(value, "spooldir")) {
1381                         vmu->passwordlocation = OPT_PWLOC_SPOOLDIR;
1382                 } else {
1383                         vmu->passwordlocation = OPT_PWLOC_VOICEMAILCONF;
1384                 }
1385         } else if (!strcasecmp(var, "options")) {
1386                 apply_options(vmu, value);
1387         }
1388 }
1389
1390 static char *vm_check_password_shell(char *command, char *buf, size_t len) 
1391 {
1392         int fds[2], pid = 0;
1393
1394         memset(buf, 0, len);
1395
1396         if (pipe(fds)) {
1397                 snprintf(buf, len, "FAILURE: Pipe failed: %s", strerror(errno));
1398         } else {
1399                 /* good to go*/
1400                 pid = ast_safe_fork(0);
1401
1402                 if (pid < 0) {
1403                         /* ok maybe not */
1404                         close(fds[0]);
1405                         close(fds[1]);
1406                         snprintf(buf, len, "FAILURE: Fork failed");
1407                 } else if (pid) {
1408                         /* parent */
1409                         close(fds[1]);
1410                         if (read(fds[0], buf, len) < 0) {
1411                                 ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno));
1412                         }
1413                         close(fds[0]);
1414                 } else {
1415                         /*  child */
1416                         AST_DECLARE_APP_ARGS(arg,
1417                                 AST_APP_ARG(v)[20];
1418                         );
1419                         char *mycmd = ast_strdupa(command);
1420
1421                         close(fds[0]);
1422                         dup2(fds[1], STDOUT_FILENO);
1423                         close(fds[1]);
1424                         ast_close_fds_above_n(STDOUT_FILENO);
1425
1426                         AST_NONSTANDARD_APP_ARGS(arg, mycmd, ' ');
1427
1428                         execv(arg.v[0], arg.v); 
1429                         printf("FAILURE: %s", strerror(errno));
1430                         _exit(0);
1431                 }
1432         }
1433         return buf;
1434 }
1435
1436 /*!
1437  * \brief Check that password meets minimum required length
1438  * \param vmu The voicemail user to change the password for.
1439  * \param password The password string to check
1440  *
1441  * \return zero on ok, 1 on not ok.
1442  */
1443 static int check_password(struct ast_vm_user *vmu, char *password)
1444 {
1445         /* check minimum length */
1446         if (strlen(password) < minpassword)
1447                 return 1;
1448         /* check that password does not contain '*' character */
1449         if (!ast_strlen_zero(password) && password[0] == '*')
1450                 return 1;
1451         if (!ast_strlen_zero(ext_pass_check_cmd)) {
1452                 char cmd[255], buf[255];
1453
1454                 ast_debug(1, "Verify password policies for %s\n", password);
1455
1456                 snprintf(cmd, sizeof(cmd), "%s %s %s %s %s", ext_pass_check_cmd, vmu->mailbox, vmu->context, vmu->password, password);
1457                 if (vm_check_password_shell(cmd, buf, sizeof(buf))) {
1458                         ast_debug(5, "Result: %s\n", buf);
1459                         if (!strncasecmp(buf, "VALID", 5)) {
1460                                 ast_debug(3, "Passed password check: '%s'\n", buf);
1461                                 return 0;
1462                         } else if (!strncasecmp(buf, "FAILURE", 7)) {
1463                                 ast_log(AST_LOG_WARNING, "Unable to execute password validation script: '%s'.\n", buf);
1464                                 return 0;
1465                         } else {
1466                                 ast_log(AST_LOG_NOTICE, "Password doesn't match policies for user %s %s\n", vmu->mailbox, password);
1467                                 return 1;
1468                         }
1469                 }
1470         }
1471         return 0;
1472 }
1473
1474 /*! 
1475  * \brief Performs a change of the voicemail passowrd in the realtime engine.
1476  * \param vmu The voicemail user to change the password for.
1477  * \param password The new value to be set to the password for this user.
1478  * 
1479  * This only works if there is a realtime engine configured.
1480  * This is called from the (top level) vm_change_password.
1481  *
1482  * \return zero on success, -1 on error.
1483  */
1484 static int change_password_realtime(struct ast_vm_user *vmu, const char *password)
1485 {
1486         int res = -1;
1487         if (!strcmp(vmu->password, password)) {
1488                 /* No change (but an update would return 0 rows updated, so we opt out here) */
1489                 return 0;
1490         }
1491
1492         if (strlen(password) > 10) {
1493                 ast_realtime_require_field("voicemail", "password", RQ_CHAR, strlen(password), SENTINEL);
1494         }
1495         if (ast_update2_realtime("voicemail", "context", vmu->context, "mailbox", vmu->mailbox, SENTINEL, "password", password, SENTINEL) > 0) {
1496                 ast_test_suite_event_notify("PASSWORDCHANGED", "Message: realtime engine updated with new password\r\nPasswordSource: realtime");
1497                 ast_copy_string(vmu->password, password, sizeof(vmu->password));
1498                 res = 0;
1499         }
1500         return res;
1501 }
1502
1503 /*!
1504  * \brief Destructively Parse options and apply.
1505  */
1506 static void apply_options(struct ast_vm_user *vmu, const char *options)
1507 {       
1508         char *stringp;
1509         char *s;
1510         char *var, *value;
1511         stringp = ast_strdupa(options);
1512         while ((s = strsep(&stringp, "|"))) {
1513                 value = s;
1514                 if ((var = strsep(&value, "=")) && value) {
1515                         apply_option(vmu, var, value);
1516                 }
1517         }       
1518 }
1519
1520 /*!
1521  * \brief Loads the options specific to a voicemail user.
1522  * 
1523  * This is called when a vm_user structure is being set up, such as from load_options.
1524  */
1525 static void apply_options_full(struct ast_vm_user *retval, struct ast_variable *var)
1526 {
1527         for (; var; var = var->next) {
1528                 if (!strcasecmp(var->name, "vmsecret")) {
1529                         ast_copy_string(retval->password, var->value, sizeof(retval->password));
1530                 } else if (!strcasecmp(var->name, "secret") || !strcasecmp(var->name, "password")) { /* don't overwrite vmsecret if it exists */
1531                         if (ast_strlen_zero(retval->password)) {
1532                                 if (!ast_strlen_zero(var->value) && var->value[0] == '*') {
1533                                         ast_log(LOG_WARNING, "Invalid password detected for mailbox %s.  The password"
1534                                                 "\n\tmust be reset in voicemail.conf.\n", retval->mailbox);
1535                                 } else {
1536                                         ast_copy_string(retval->password, var->value, sizeof(retval->password));
1537                                 }
1538                         }
1539                 } else if (!strcasecmp(var->name, "uniqueid")) {
1540                         ast_copy_string(retval->uniqueid, var->value, sizeof(retval->uniqueid));
1541                 } else if (!strcasecmp(var->name, "pager")) {
1542                         ast_copy_string(retval->pager, var->value, sizeof(retval->pager));
1543                 } else if (!strcasecmp(var->name, "email")) {
1544                         ast_copy_string(retval->email, var->value, sizeof(retval->email));
1545                 } else if (!strcasecmp(var->name, "fullname")) {
1546                         ast_copy_string(retval->fullname, var->value, sizeof(retval->fullname));
1547                 } else if (!strcasecmp(var->name, "context")) {
1548                         ast_copy_string(retval->context, var->value, sizeof(retval->context));
1549                 } else if (!strcasecmp(var->name, "emailsubject")) {
1550                         ast_free(retval->emailsubject);
1551                         retval->emailsubject = ast_strdup(substitute_escapes(var->value));
1552                 } else if (!strcasecmp(var->name, "emailbody")) {
1553                         ast_free(retval->emailbody);
1554                         retval->emailbody = ast_strdup(substitute_escapes(var->value));
1555 #ifdef IMAP_STORAGE
1556                 } else if (!strcasecmp(var->name, "imapuser")) {
1557                         ast_copy_string(retval->imapuser, var->value, sizeof(retval->imapuser));
1558                         retval->imapversion = imapversion;
1559                 } else if (!strcasecmp(var->name, "imapserver")) {
1560                         ast_copy_string(retval->imapserver, var->value, sizeof(retval->imapserver));
1561                         retval->imapversion = imapversion;
1562                 } else if (!strcasecmp(var->name, "imapport")) {
1563                         ast_copy_string(retval->imapport, var->value, sizeof(retval->imapport));
1564                         retval->imapversion = imapversion;
1565                 } else if (!strcasecmp(var->name, "imapflags")) {
1566                         ast_copy_string(retval->imapflags, var->value, sizeof(retval->imapflags));
1567                         retval->imapversion = imapversion;
1568                 } else if (!strcasecmp(var->name, "imappassword") || !strcasecmp(var->name, "imapsecret")) {
1569                         ast_copy_string(retval->imappassword, var->value, sizeof(retval->imappassword));
1570                         retval->imapversion = imapversion;
1571                 } else if (!strcasecmp(var->name, "imapfolder")) {
1572                         ast_copy_string(retval->imapfolder, var->value, sizeof(retval->imapfolder));
1573                         retval->imapversion = imapversion;
1574                 } else if (!strcasecmp(var->name, "imapvmshareid")) {
1575                         ast_copy_string(retval->imapvmshareid, var->value, sizeof(retval->imapvmshareid));
1576                         retval->imapversion = imapversion;
1577 #endif
1578                 } else
1579                         apply_option(retval, var->name, var->value);
1580         }
1581 }
1582
1583 /*!
1584  * \brief Determines if a DTMF key entered is valid.
1585  * \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.
1586  *
1587  * Tests the character entered against the set of valid DTMF characters. 
1588  * \return 1 if the character entered is a valid DTMF digit, 0 if the character is invalid.
1589  */
1590 static int is_valid_dtmf(const char *key)
1591 {
1592         int i;
1593         char *local_key = ast_strdupa(key);
1594
1595         for (i = 0; i < strlen(key); ++i) {
1596                 if (!strchr(VALID_DTMF, *local_key)) {
1597                         ast_log(AST_LOG_WARNING, "Invalid DTMF key \"%c\" used in voicemail configuration file\n", *local_key);
1598                         return 0;
1599                 }
1600                 local_key++;
1601         }
1602         return 1;
1603 }
1604
1605 /*!
1606  * \brief Finds a voicemail user from the realtime engine.
1607  * \param ivm
1608  * \param context
1609  * \param mailbox
1610  *
1611  * 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.
1612  *
1613  * \return The ast_vm_user structure for the user that was found.
1614  */
1615 static struct ast_vm_user *find_user_realtime(struct ast_vm_user *ivm, const char *context, const char *mailbox)
1616 {
1617         struct ast_variable *var;
1618         struct ast_vm_user *retval;
1619
1620         if ((retval = (ivm ? ivm : ast_calloc(1, sizeof(*retval))))) {
1621                 if (ivm) {
1622                         memset(retval, 0, sizeof(*retval));
1623                 }
1624                 populate_defaults(retval);
1625                 if (!ivm) {
1626                         ast_set_flag(retval, VM_ALLOCED);
1627                 }
1628                 if (mailbox) {
1629                         ast_copy_string(retval->mailbox, mailbox, sizeof(retval->mailbox));
1630                 }
1631                 if (!context && ast_test_flag((&globalflags), VM_SEARCH)) {
1632                         var = ast_load_realtime("voicemail", "mailbox", mailbox, SENTINEL);
1633                 } else {
1634                         var = ast_load_realtime("voicemail", "mailbox", mailbox, "context", context, SENTINEL);
1635                 }
1636                 if (var) {
1637                         apply_options_full(retval, var);
1638                         ast_variables_destroy(var);
1639                 } else { 
1640                         if (!ivm) 
1641                                 ast_free(retval);
1642                         retval = NULL;
1643                 }       
1644         } 
1645         return retval;
1646 }
1647
1648 /*!
1649  * \brief Finds a voicemail user from the users file or the realtime engine.
1650  * \param ivm
1651  * \param context
1652  * \param mailbox
1653  * 
1654  * \return The ast_vm_user structure for the user that was found.
1655  */
1656 static struct ast_vm_user *find_user(struct ast_vm_user *ivm, const char *context, const char *mailbox)
1657 {
1658         /* This function could be made to generate one from a database, too */
1659         struct ast_vm_user *vmu = NULL, *cur;
1660         AST_LIST_LOCK(&users);
1661
1662         if (!context && !ast_test_flag((&globalflags), VM_SEARCH))
1663                 context = "default";
1664
1665         AST_LIST_TRAVERSE(&users, cur, list) {
1666 #ifdef IMAP_STORAGE
1667                 if (cur->imapversion != imapversion) {
1668                         continue;
1669                 }
1670 #endif
1671                 if (ast_test_flag((&globalflags), VM_SEARCH) && !strcasecmp(mailbox, cur->mailbox))
1672                         break;
1673                 if (context && (!strcasecmp(context, cur->context)) && (!strcasecmp(mailbox, cur->mailbox)))
1674                         break;
1675         }
1676         if (cur) {
1677                 /* Make a copy, so that on a reload, we have no race */
1678                 if ((vmu = (ivm ? ivm : ast_malloc(sizeof(*vmu))))) {
1679                         *vmu = *cur;
1680                         if (!ivm) {
1681                                 vmu->emailbody = ast_strdup(cur->emailbody);
1682                                 vmu->emailsubject = ast_strdup(cur->emailsubject);
1683                         }
1684                         ast_set2_flag(vmu, !ivm, VM_ALLOCED);
1685                         AST_LIST_NEXT(vmu, list) = NULL;
1686                 }
1687         } else
1688                 vmu = find_user_realtime(ivm, context, mailbox);
1689         AST_LIST_UNLOCK(&users);
1690         return vmu;
1691 }
1692
1693 /*!
1694  * \brief Resets a user password to a specified password.
1695  * \param context
1696  * \param mailbox
1697  * \param newpass
1698  *
1699  * This does the actual change password work, called by the vm_change_password() function.
1700  *
1701  * \return zero on success, -1 on error.
1702  */
1703 static int reset_user_pw(const char *context, const char *mailbox, const char *newpass)
1704 {
1705         /* This function could be made to generate one from a database, too */
1706         struct ast_vm_user *cur;
1707         int res = -1;
1708         AST_LIST_LOCK(&users);
1709         AST_LIST_TRAVERSE(&users, cur, list) {
1710                 if ((!context || !strcasecmp(context, cur->context)) &&
1711                         (!strcasecmp(mailbox, cur->mailbox)))
1712                                 break;
1713         }
1714         if (cur) {
1715                 ast_copy_string(cur->password, newpass, sizeof(cur->password));
1716                 res = 0;
1717         }
1718         AST_LIST_UNLOCK(&users);
1719         return res;
1720 }
1721
1722 /*!
1723  * \brief Check if configuration file is valid
1724  */
1725 static inline int valid_config(const struct ast_config *cfg)
1726 {
1727         return cfg && cfg != CONFIG_STATUS_FILEINVALID;
1728 }
1729
1730 /*! 
1731  * \brief The handler for the change password option.
1732  * \param vmu The voicemail user to work with.
1733  * \param newpassword The new password (that has been gathered from the appropriate prompting).
1734  * 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.
1735  * It is also called when the user wants to change their password from menu option '5' on the mailbox options menu.
1736  */
1737 static void vm_change_password(struct ast_vm_user *vmu, const char *newpassword)
1738 {
1739         struct ast_config   *cfg = NULL;
1740         struct ast_variable *var = NULL;
1741         struct ast_category *cat = NULL;
1742         char *category = NULL, *value = NULL, *new = NULL;
1743         const char *tmp = NULL;
1744         struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS };
1745         char secretfn[PATH_MAX] = "";
1746         int found = 0;
1747
1748         if (!change_password_realtime(vmu, newpassword))
1749                 return;
1750
1751         /* check if we should store the secret in the spool directory next to the messages */
1752         switch (vmu->passwordlocation) {
1753         case OPT_PWLOC_SPOOLDIR:
1754                 snprintf(secretfn, sizeof(secretfn), "%s%s/%s/secret.conf", VM_SPOOL_DIR, vmu->context, vmu->mailbox);
1755                 if (write_password_to_file(secretfn, newpassword) == 0) {
1756                         ast_test_suite_event_notify("PASSWORDCHANGED", "Message: secret.conf updated with new password\r\nPasswordSource: secret.conf");
1757                         ast_verb(4, "Writing voicemail password to file %s succeeded\n", secretfn);
1758                         reset_user_pw(vmu->context, vmu->mailbox, newpassword);
1759                         ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
1760                         break;
1761                 } else {
1762                         ast_verb(4, "Writing voicemail password to file %s failed, falling back to config file\n", secretfn);
1763                 }
1764                 /* Fall-through */
1765         case OPT_PWLOC_VOICEMAILCONF:
1766                 if ((cfg = ast_config_load(VOICEMAIL_CONFIG, config_flags)) && valid_config(cfg)) {
1767                         while ((category = ast_category_browse(cfg, category))) {
1768                                 if (!strcasecmp(category, vmu->context)) {
1769                                         if (!(tmp = ast_variable_retrieve(cfg, category, vmu->mailbox))) {
1770                                                 ast_log(AST_LOG_WARNING, "We could not find the mailbox.\n");
1771                                                 break;
1772                                         }
1773                                         value = strstr(tmp, ",");
1774                                         if (!value) {
1775                                                 new = ast_alloca(strlen(newpassword)+1);
1776                                                 sprintf(new, "%s", newpassword);
1777                                         } else {
1778                                                 new = ast_alloca((strlen(value) + strlen(newpassword) + 1));
1779                                                 sprintf(new, "%s%s", newpassword, value);
1780                                         }
1781                                         if (!(cat = ast_category_get(cfg, category))) {
1782                                                 ast_log(AST_LOG_WARNING, "Failed to get category structure.\n");
1783                                                 break;
1784                                         }
1785                                         ast_variable_update(cat, vmu->mailbox, new, NULL, 0);
1786                                         found = 1;
1787                                 }
1788                         }
1789                         /* save the results */
1790                         if (found) {
1791                                 ast_test_suite_event_notify("PASSWORDCHANGED", "Message: voicemail.conf updated with new password\r\nPasswordSource: voicemail.conf");
1792                                 reset_user_pw(vmu->context, vmu->mailbox, newpassword);
1793                                 ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
1794                                 ast_config_text_file_save(VOICEMAIL_CONFIG, cfg, "AppVoicemail");
1795                                 ast_config_destroy(cfg);
1796                                 break;
1797                         }
1798
1799                         ast_config_destroy(cfg);
1800                 }
1801                 /* Fall-through */
1802         case OPT_PWLOC_USERSCONF:
1803                 /* check users.conf and update the password stored for the mailbox */
1804                 /* if no vmsecret entry exists create one. */
1805                 if ((cfg = ast_config_load("users.conf", config_flags)) && valid_config(cfg)) {
1806                         ast_debug(4, "we are looking for %s\n", vmu->mailbox);
1807                         for (category = ast_category_browse(cfg, NULL); category; category = ast_category_browse(cfg, category)) {
1808                                 ast_debug(4, "users.conf: %s\n", category);
1809                                 if (!strcasecmp(category, vmu->mailbox)) {
1810                                         if (!ast_variable_retrieve(cfg, category, "vmsecret")) {
1811                                                 ast_debug(3, "looks like we need to make vmsecret!\n");
1812                                                 var = ast_variable_new("vmsecret", newpassword, "");
1813                                         } else {
1814                                                 var = NULL;
1815                                         }
1816                                         new = ast_alloca(strlen(newpassword) + 1);
1817                                         sprintf(new, "%s", newpassword);
1818                                         if (!(cat = ast_category_get(cfg, category))) {
1819                                                 ast_debug(4, "failed to get category!\n");
1820                                                 ast_free(var);
1821                                                 break;
1822                                         }
1823                                         if (!var) {
1824                                                 ast_variable_update(cat, "vmsecret", new, NULL, 0);
1825                                         } else {
1826                                                 ast_variable_append(cat, var);
1827                                         }
1828                                         found = 1;
1829                                         break;
1830                                 }
1831                         }
1832                         /* save the results and clean things up */
1833                         if (found) {
1834                                 ast_test_suite_event_notify("PASSWORDCHANGED", "Message: users.conf updated with new password\r\nPasswordSource: users.conf");
1835                                 reset_user_pw(vmu->context, vmu->mailbox, newpassword);
1836                                 ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
1837                                 ast_config_text_file_save("users.conf", cfg, "AppVoicemail");
1838                         }
1839
1840                         ast_config_destroy(cfg);
1841                 }
1842         }
1843 }
1844
1845 static void vm_change_password_shell(struct ast_vm_user *vmu, char *newpassword)
1846 {
1847         char buf[255];
1848         snprintf(buf, sizeof(buf), "%s %s %s %s", ext_pass_cmd, vmu->context, vmu->mailbox, newpassword);
1849         ast_debug(1, "External password: %s\n",buf);
1850         if (!ast_safe_system(buf)) {
1851                 ast_test_suite_event_notify("PASSWORDCHANGED", "Message: external script updated with new password\r\nPasswordSource: external");
1852                 ast_copy_string(vmu->password, newpassword, sizeof(vmu->password));
1853                 /* Reset the password in memory, too */
1854                 reset_user_pw(vmu->context, vmu->mailbox, newpassword);
1855         }
1856 }
1857
1858 /*! 
1859  * \brief Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
1860  * \param dest The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
1861  * \param len The length of the path string that was written out.
1862  * \param context
1863  * \param ext 
1864  * \param folder 
1865  * 
1866  * The path is constructed as 
1867  *      VM_SPOOL_DIRcontext/ext/folder
1868  *
1869  * \return zero on success, -1 on error.
1870  */
1871 static int make_dir(char *dest, int len, const char *context, const char *ext, const char *folder)
1872 {
1873         return snprintf(dest, len, "%s%s/%s/%s", VM_SPOOL_DIR, context, ext, folder);
1874 }
1875
1876 /*! 
1877  * \brief Creates a file system path expression for a folder within the voicemail data folder and the appropriate context.
1878  * \param dest The variable to hold the output generated path expression. This buffer should be of size PATH_MAX.
1879  * \param len The length of the path string that was written out.
1880  * \param dir 
1881  * \param num 
1882  * 
1883  * The path is constructed as 
1884  *      VM_SPOOL_DIRcontext/ext/folder
1885  *
1886  * \return zero on success, -1 on error.
1887  */
1888 static int make_file(char *dest, const int len, const char *dir, const int num)
1889 {
1890         return snprintf(dest, len, "%s/msg%04d", dir, num);
1891 }
1892
1893 /* same as mkstemp, but return a FILE * */
1894 static FILE *vm_mkftemp(char *template)
1895 {
1896         FILE *p = NULL;
1897         int pfd = mkstemp(template);
1898         chmod(template, VOICEMAIL_FILE_MODE & ~my_umask);
1899         if (pfd > -1) {
1900                 p = fdopen(pfd, "w+");
1901                 if (!p) {
1902                         close(pfd);
1903                         pfd = -1;
1904                 }
1905         }
1906         return p;
1907 }
1908
1909 /*! \brief basically mkdir -p $dest/$context/$ext/$folder
1910  * \param dest    String. base directory.
1911  * \param len     Length of dest.
1912  * \param context String. Ignored if is null or empty string.
1913  * \param ext     String. Ignored if is null or empty string.
1914  * \param folder  String. Ignored if is null or empty string. 
1915  * \return -1 on failure, 0 on success.
1916  */
1917 static int create_dirpath(char *dest, int len, const char *context, const char *ext, const char *folder)
1918 {
1919         mode_t  mode = VOICEMAIL_DIR_MODE;
1920         int res;
1921
1922         make_dir(dest, len, context, ext, folder);
1923         if ((res = ast_mkdir(dest, mode))) {
1924                 ast_log(AST_LOG_WARNING, "ast_mkdir '%s' failed: %s\n", dest, strerror(res));
1925                 return -1;
1926         }
1927         return 0;
1928 }
1929
1930 static const char *mbox(struct ast_vm_user *vmu, int id)
1931 {
1932 #ifdef IMAP_STORAGE
1933         if (vmu && id == 0) {
1934                 return vmu->imapfolder;
1935         }
1936 #endif
1937         return (id >= 0 && id < ARRAY_LEN(mailbox_folders)) ? mailbox_folders[id] : "Unknown";
1938 }
1939
1940 static const char *vm_index_to_foldername(int id)
1941 {
1942         return mbox(NULL, id);
1943 }
1944
1945
1946 static int get_folder_by_name(const char *name)
1947 {
1948         size_t i;
1949
1950         for (i = 0; i < ARRAY_LEN(mailbox_folders); i++) {
1951                 if (strcasecmp(name, mailbox_folders[i]) == 0) {
1952                         return i;
1953                 }
1954         }
1955
1956         return -1;
1957 }
1958
1959 static void free_user(struct ast_vm_user *vmu)
1960 {
1961         if (ast_test_flag(vmu, VM_ALLOCED)) {
1962
1963                 ast_free(vmu->emailbody);
1964                 vmu->emailbody = NULL;
1965
1966                 ast_free(vmu->emailsubject);
1967                 vmu->emailsubject = NULL;
1968
1969                 ast_free(vmu);
1970         }
1971 }
1972
1973 static int vm_allocate_dh(struct vm_state *vms, struct ast_vm_user *vmu, int count_msg) {
1974
1975         int arraysize = (vmu->maxmsg > count_msg ? vmu->maxmsg : count_msg);
1976
1977         /* remove old allocation */
1978         if (vms->deleted) {
1979                 ast_free(vms->deleted);
1980                 vms->deleted = NULL;
1981         }
1982         if (vms->heard) {
1983                 ast_free(vms->heard);
1984                 vms->heard = NULL;
1985         }
1986         vms->dh_arraysize = 0;
1987
1988         if (arraysize > 0) {
1989                 if (!(vms->deleted = ast_calloc(arraysize, sizeof(int)))) {
1990                         return -1;
1991                 }
1992                 if (!(vms->heard = ast_calloc(arraysize, sizeof(int)))) {
1993                         ast_free(vms->deleted);
1994                         vms->deleted = NULL;
1995                         return -1;
1996                 }
1997                 vms->dh_arraysize = arraysize;
1998         }
1999
2000         return 0;
2001 }
2002
2003 /* All IMAP-specific functions should go in this block. This
2004  * keeps them from being spread out all over the code */
2005 #ifdef IMAP_STORAGE
2006 static void vm_imap_delete(char *file, int msgnum, struct ast_vm_user *vmu)
2007 {
2008         char arg[10];
2009         struct vm_state *vms;
2010         unsigned long messageNum;
2011
2012         /* If greetings aren't stored in IMAP, just delete the file */
2013         if (msgnum < 0 && !imapgreetings) {
2014                 ast_filedelete(file, NULL);
2015                 return;
2016         }
2017
2018         if (!(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) && !(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
2019                 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);
2020                 return;
2021         }
2022
2023         if (msgnum < 0) {
2024                 imap_delete_old_greeting(file, vms);
2025                 return;
2026         }
2027
2028         /* find real message number based on msgnum */
2029         /* this may be an index into vms->msgArray based on the msgnum. */
2030         messageNum = vms->msgArray[msgnum];
2031         if (messageNum == 0) {
2032                 ast_log(LOG_WARNING, "msgnum %d, mailbox message %lu is zero.\n", msgnum, messageNum);
2033                 return;
2034         }
2035         ast_debug(3, "deleting msgnum %d, which is mailbox message %lu\n", msgnum, messageNum);
2036         /* delete message */
2037         snprintf (arg, sizeof(arg), "%lu", messageNum);
2038         ast_mutex_lock(&vms->lock);
2039         mail_setflag (vms->mailstream, arg, "\\DELETED");
2040         mail_expunge(vms->mailstream);
2041         ast_mutex_unlock(&vms->lock);
2042 }
2043
2044 static void vm_imap_update_msg_id(char *dir, int msgnum, const char *msg_id, struct ast_vm_user *vmu, struct ast_config *msg_cfg, int folder)
2045 {
2046         struct ast_channel *chan;
2047         char *cid;
2048         char *cid_name;
2049         char *cid_num;
2050         struct vm_state *vms;
2051         const char *duration_str;
2052         int duration = 0;
2053
2054         /*
2055          * First, get things initially set up. If any of this fails, then
2056          * back out before doing anything substantial
2057          */
2058         vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0);
2059         if (!vms) {
2060                 return;
2061         }
2062
2063         if (open_mailbox(vms, vmu, folder)) {
2064                 return;
2065         }
2066
2067         chan = ast_dummy_channel_alloc();
2068         if (!chan) {
2069                 close_mailbox(vms, vmu);
2070                 return;
2071         }
2072
2073         /*
2074          * We need to make sure the new message we save has the same
2075          * callerid, flag, and duration as the original message
2076          */
2077         cid = ast_strdupa(ast_variable_retrieve(msg_cfg, "message", "callerid"));
2078
2079         if (!ast_strlen_zero(cid)) {
2080                 ast_callerid_parse(cid, &cid_name, &cid_num);
2081                 ast_party_caller_init(ast_channel_caller(chan));
2082                 if (!ast_strlen_zero(cid_name)) {
2083                         ast_channel_caller(chan)->id.name.valid = 1;
2084                         ast_channel_caller(chan)->id.name.str = ast_strdup(cid_name);
2085                 }
2086                 if (!ast_strlen_zero(cid_num)) {
2087                         ast_channel_caller(chan)->id.number.valid = 1;
2088                         ast_channel_caller(chan)->id.number.str = ast_strdup(cid_num);
2089                 }
2090         }
2091
2092         duration_str = ast_variable_retrieve(msg_cfg, "message", "duration");
2093
2094         if (!ast_strlen_zero(duration_str)) {
2095                 sscanf(duration_str, "%30d", &duration);
2096         }
2097
2098         /*
2099          * IMAP messages cannot be altered once delivered. So we have to delete the
2100          * current message and then re-add it with the updated message ID.
2101          *
2102          * Furthermore, there currently is no atomic way to create a new message and to
2103          * store it in an arbitrary folder. So we have to save it to the INBOX and then
2104          * move to the appropriate folder.
2105          */
2106         if (!imap_store_file(dir, vmu->mailbox, vmu->context, msgnum, chan, vmu, vmfmts,
2107                         duration, vms, ast_variable_retrieve(msg_cfg, "message", "flag"), msg_id)) {
2108                 if (folder != NEW_FOLDER) {
2109                         save_to_folder(vmu, vms, msgnum, folder, NULL, 1);
2110                 }
2111                 vm_imap_delete(dir, msgnum, vmu);
2112         }
2113         close_mailbox(vms, vmu);
2114         ast_channel_unref(chan);
2115 }
2116
2117 static int imap_retrieve_greeting(const char *dir, const int msgnum, struct ast_vm_user *vmu)
2118 {
2119         struct vm_state *vms_p;
2120         char *file, *filename;
2121         char *attachment;
2122         int i;
2123         BODY *body;
2124
2125         /* This function is only used for retrieval of IMAP greetings
2126          * regular messages are not retrieved this way, nor are greetings
2127          * if they are stored locally*/
2128         if (msgnum > -1 || !imapgreetings) {
2129                 return 0;
2130         } else {
2131                 file = strrchr(ast_strdupa(dir), '/');
2132                 if (file)
2133                         *file++ = '\0';
2134                 else {
2135                         ast_debug(1, "Failed to procure file name from directory passed.\n");
2136                         return -1;
2137                 }
2138         }
2139
2140         /* check if someone is accessing this box right now... */
2141         if (!(vms_p = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) && 
2142                 !(vms_p = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
2143                 /* Unlike when retrieving a message, it is reasonable not to be able to find a 
2144                 * vm_state for a mailbox when trying to retrieve a greeting. Just create one,
2145                 * that's all we need to do.
2146                 */
2147                 if (!(vms_p = create_vm_state_from_user(vmu))) {
2148                         ast_log(LOG_NOTICE, "Unable to create vm_state object!\n");
2149                         return -1;
2150                 }
2151         }
2152
2153         /* Greetings will never have a prepended message */
2154         *vms_p->introfn = '\0';
2155
2156         ast_mutex_lock(&vms_p->lock);
2157         if (init_mailstream(vms_p, GREETINGS_FOLDER) || !vms_p->mailstream) {
2158                 ast_log(AST_LOG_ERROR, "IMAP mailstream is NULL or can't init_mailstream\n");
2159                 ast_mutex_unlock(&vms_p->lock);
2160                 return -1;
2161         }
2162
2163         /*XXX Yuck, this could probably be done a lot better */
2164         for (i = 0; i < vms_p->mailstream->nmsgs; i++) {
2165                 mail_fetchstructure(vms_p->mailstream, i + 1, &body);
2166                 /* We have the body, now we extract the file name of the first attachment. */
2167                 if (body->nested.part && body->nested.part->next && body->nested.part->next->body.parameter->value) {
2168                         attachment = ast_strdupa(body->nested.part->next->body.parameter->value);
2169                 } else {
2170                         ast_log(AST_LOG_ERROR, "There is no file attached to this IMAP message.\n");
2171                         ast_mutex_unlock(&vms_p->lock);
2172                         return -1;
2173                 }
2174                 filename = strsep(&attachment, ".");
2175                 if (!strcmp(filename, file)) {
2176                         ast_copy_string(vms_p->fn, dir, sizeof(vms_p->fn));
2177                         vms_p->msgArray[vms_p->curmsg] = i + 1;
2178                         save_body(body, vms_p, "2", attachment, 0);
2179                         ast_mutex_unlock(&vms_p->lock);
2180                         return 0;
2181                 }
2182         }
2183         ast_mutex_unlock(&vms_p->lock);
2184
2185         return -1;
2186 }
2187
2188 static int imap_retrieve_file(const char *dir, const int msgnum, const char *mailbox, const char *context)
2189 {
2190         BODY *body;
2191         char *header_content;
2192         char *attachedfilefmt;
2193         char buf[80];
2194         struct vm_state *vms;
2195         char text_file[PATH_MAX];
2196         FILE *text_file_ptr;
2197         int res = 0;
2198         struct ast_vm_user *vmu;
2199
2200         if (!(vmu = find_user(NULL, context, mailbox))) {
2201                 ast_log(LOG_WARNING, "Couldn't find user with mailbox %s@%s\n", mailbox, context);
2202                 return -1;
2203         }
2204         
2205         if (msgnum < 0) {
2206                 if (imapgreetings) {
2207                         res = imap_retrieve_greeting(dir, msgnum, vmu);
2208                         goto exit;
2209                 } else {
2210                         res = 0;
2211                         goto exit;
2212                 }
2213         }
2214
2215         /* Before anything can happen, we need a vm_state so that we can
2216          * actually access the imap server through the vms->mailstream
2217          */
2218         if (!(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 1)) && !(vms = get_vm_state_by_mailbox(vmu->mailbox, vmu->context, 0))) {
2219                 /* This should not happen. If it does, then I guess we'd
2220                  * need to create the vm_state, extract which mailbox to
2221                  * open, and then set up the msgArray so that the correct
2222                  * IMAP message could be accessed. If I have seen correctly
2223                  * though, the vms should be obtainable from the vmstates list
2224                  * and should have its msgArray properly set up.
2225                  */
2226                 ast_log(LOG_ERROR, "Couldn't find a vm_state for mailbox %s!!! Oh no!\n", vmu->mailbox);
2227                 res = -1;
2228                 goto exit;
2229         }
2230
2231         make_file(vms->fn, sizeof(vms->fn), dir, msgnum);
2232         snprintf(vms->introfn, sizeof(vms->introfn), "%sintro", vms->fn);
2233
2234         /* Don't try to retrieve a message from IMAP if it already is on the file system */
2235         if (ast_fileexists(vms->fn, NULL, NULL) > 0) {
2236                 res = 0;
2237                 goto exit;
2238         }
2239
2240         ast_debug(3, "Before mail_fetchheaders, curmsg is: %d, imap messages is %lu\n", msgnum, vms->msgArray[msgnum]);
2241         if (vms->msgArray[msgnum] == 0) {
2242                 ast_log(LOG_WARNING, "Trying to access unknown message\n");
2243                 res = -1;
2244                 goto exit;
2245         }
2246
2247         /* This will only work for new messages... */
2248         ast_mutex_lock(&vms->lock);
2249         header_content = mail_fetchheader (vms->mailstream, vms->msgArray[msgnum]);
2250         ast_mutex_unlock(&vms->lock);
2251         /* empty string means no valid header */
2252         if (ast_strlen_zero(header_content)) {
2253                 ast_log(LOG_ERROR, "Could not fetch header for message number %ld\n", vms->msgArray[msgnum]);
2254                 res = -1;
2255                 goto exit;
2256         }
2257
2258         ast_mutex_lock(&vms->lock);
2259         mail_fetchstructure(vms->mailstream, vms->msgArray[msgnum], &body);
2260         ast_mutex_unlock(&vms->lock);
2261
2262         /* We have the body, now we extract the file name of the first attachment. */
2263         if (body->nested.part && body->nested.part->next && body->nested.part->next->body.parameter->value) {
2264                 attachedfilefmt = ast_strdupa(body->nested.part->next->body.parameter->value);
2265         } else {
2266                 ast_log(LOG_ERROR, "There is no file attached to this IMAP message.\n");
2267                 res = -1;
2268                 goto exit;
2269         }
2270         
2271         /* Find the format of the attached file */
2272
2273         strsep(&attachedfilefmt, ".");
2274         if (!attachedfilefmt) {
2275                 ast_log(LOG_ERROR, "File format could not be obtained from IMAP message attachment\n");
2276                 res = -1;
2277                 goto exit;
2278         }
2279         
2280         save_body(body, vms, "2", attachedfilefmt, 0);
2281         if (save_body(body, vms, "3", attachedfilefmt, 1)) {
2282                 *vms->introfn = '\0';
2283         }
2284
2285         /* Get info from headers!! */
2286         snprintf(text_file, sizeof(text_file), "%s.%s", vms->fn, "txt");
2287
2288         if (!(text_file_ptr = fopen(text_file, "w"))) {
2289                 ast_log(LOG_WARNING, "Unable to open/create file %s: %s\n", text_file, strerror(errno));
2290         }
2291
2292         fprintf(text_file_ptr, "%s\n", "[message]");
2293
2294         if (get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Name:", buf, sizeof(buf))) {
2295                 fprintf(text_file_ptr, "callerid=\"%s\" ", S_OR(buf, ""));
2296         }
2297         if (get_header_by_tag(header_content, "X-Asterisk-VM-Caller-ID-Num:", buf, sizeof(buf))) {
2298                 fprintf(text_file_ptr, "<%s>\n", S_OR(buf, ""));
2299         }
2300         if (get_header_by_tag(header_content, "X-Asterisk-VM-Context:", buf, sizeof(buf))) {
2301                 fprintf(text_file_ptr, "context=%s\n", S_OR(buf, ""));
2302         }
2303         if (get_header_by_tag(header_content, "X-Asterisk-VM-Orig-time:", buf, sizeof(buf))) {
2304                 fprintf(text_file_ptr, "origtime=%s\n", S_OR(buf, ""));
2305         }
2306         if (get_header_by_tag(header_content, "X-Asterisk-VM-Duration:", buf, sizeof(buf))) {
2307                 fprintf(text_file_ptr, "duration=%s\n", S_OR(buf, ""));
2308         }
2309         if (get_header_by_tag(header_content, "X-Asterisk-VM-Category:", buf, sizeof(buf))) {
2310                 fprintf(text_file_ptr, "category=%s\n", S_OR(buf, ""));
2311         }
2312         if (get_header_by_tag(header_content, "X-Asterisk-VM-Flag:", buf, sizeof(buf))) {
2313                 fprintf(text_file_ptr, "flag=%s\n", S_OR(buf, ""));
2314         }
2315         if (get_header_by_tag(header_content, "X-Asterisk-VM-Message-ID:", buf, sizeof(buf))) {
2316                 fprintf(text_file_ptr, "msg_id=%s\n", S_OR(buf, ""));
2317         }
2318         fclose(text_file_ptr);
2319
2320 exit:
2321         free_user(vmu);
2322         return res;
2323 }
2324
2325 static int folder_int(const char *folder)
2326 {
2327         /*assume a NULL folder means INBOX*/
2328         if (!folder) {
2329                 return 0;
2330         }
2331         if (!strcasecmp(folder, imapfolder)) {
2332                 return 0;
2333         } else if (!strcasecmp(folder, "Old")) {
2334                 return 1;
2335         } else if (!strcasecmp(folder, "Work")) {
2336                 return 2;
2337         } else if (!strcasecmp(folder, "Family")) {
2338                 return 3;
2339         } else if (!strcasecmp(folder, "Friends")) {
2340                 return 4;
2341         } else if (!strcasecmp(folder, "Cust1")) {
2342                 return 5;
2343         } else if (!strcasecmp(folder, "Cust2")) {
2344                 return 6;
2345         } else if (!strcasecmp(folder, "Cust3")) {
2346                 return 7;
2347         } else if (!strcasecmp(folder, "Cust4")) {
2348                 return 8;
2349         } else if (!strcasecmp(folder, "Cust5")) {
2350                 return 9;
2351         } else if (!strcasecmp(folder, "Urgent")) {
2352                 return 11;
2353         } else { /*assume they meant INBOX if folder is not found otherwise*/
2354                 return 0;
2355         }
2356 }
2357
2358 static int __messagecount(const char *context, const char *mailbox, const char *folder)
2359 {
2360         SEARCHPGM *pgm;
2361         SEARCHHEADER *hdr;
2362
2363         struct ast_vm_user *vmu, vmus;
2364         struct vm_state *vms_p;
2365         int ret = 0;
2366         int fold = folder_int(folder);
2367         int urgent = 0;
2368         
2369         /* If URGENT, then look at INBOX */
2370         if (fold == 11) {
2371                 fold = NEW_FOLDER;
2372                 urgent = 1;
2373         }
2374
2375         if (ast_strlen_zero(mailbox))
2376                 return 0;
2377
2378         /* We have to get the user before we can open the stream! */
2379         vmu = find_user(&vmus, context, mailbox);
2380         if (!vmu) {
2381                 ast_log(AST_LOG_ERROR, "Couldn't find mailbox %s in context %s\n", mailbox, context);
2382                 return -1;
2383         } else {
2384                 /* No IMAP account available */
2385                 if (vmu->imapuser[0] == '\0') {
2386                         ast_log(AST_LOG_WARNING, "IMAP user not set for mailbox %s\n", vmu->mailbox);
2387                         return -1;
2388                 }
2389         }
2390
2391         /* No IMAP account available */
2392         if (vmu->imapuser[0] == '\0') {
2393                 ast_log(AST_LOG_WARNING, "IMAP user not set for mailbox %s\n", vmu->mailbox);
2394                 free_user(vmu);
2395                 return -1;
2396         }
2397
2398         /* check if someone is accessing this box right now... */
2399         vms_p = get_vm_state_by_imapuser(vmu->imapuser, 1);
2400         if (!vms_p) {
2401                 vms_p = get_vm_state_by_mailbox(mailbox, context, 1);
2402         }
2403         if (vms_p) {
2404                 ast_debug(3, "Returning before search - user is logged in\n");
2405                 if (fold == 0) { /* INBOX */
2406                         return urgent ? vms_p->urgentmessages : vms_p->newmessages;
2407                 }
2408                 if (fold == 1) { /* Old messages */
2409                         return vms_p->oldmessages;
2410                 }
2411         }
2412
2413         /* add one if not there... */
2414         vms_p = get_vm_state_by_imapuser(vmu->imapuser, 0);
2415         if (!vms_p) {
2416                 vms_p = get_vm_state_by_mailbox(mailbox, context, 0);
2417         }
2418
2419         if (!vms_p) {
2420                 vms_p = create_vm_state_from_user(vmu);
2421         }
2422         ret = init_mailstream(vms_p, fold);
2423         if (!vms_p->mailstream) {
2424                 ast_log(AST_LOG_ERROR, "Houston we have a problem - IMAP mailstream is NULL\n");
2425                 return -1;
2426         }
2427         if (ret == 0) {
2428                 ast_mutex_lock(&vms_p->lock);
2429                 pgm = mail_newsearchpgm ();
2430                 hdr = mail_newsearchheader ("X-Asterisk-VM-Extension", (char *)(!ast_strlen_zero(vmu->imapvmshareid) ? vmu->imapvmshareid : mailbox));
2431                 hdr->next = mail_newsearchheader("X-Asterisk-VM-Context", (char *) S_OR(context, "default"));
2432                 pgm->header = hdr;
2433                 if (fold != OLD_FOLDER) {
2434                         pgm->unseen = 1;
2435                         pgm->seen = 0;
2436                 }
2437                 /* In the special case where fold is 1 (old messages) we have to do things a bit
2438                  * differently. Old messages are stored in the INBOX but are marked as "seen"
2439                  */
2440                 else {
2441                         pgm->unseen = 0;
2442                         pgm->seen = 1;
2443                 }
2444                 /* look for urgent messages */
2445                 if (fold == NEW_FOLDER) {
2446                         if (urgent) {
2447                                 pgm->flagged = 1;
2448                                 pgm->unflagged = 0;
2449                         } else {
2450                                 pgm->flagged = 0;
2451                                 pgm->unflagged = 1;
2452                         }
2453                 }
2454                 pgm->undeleted = 1;
2455                 pgm->deleted = 0;
2456
2457                 vms_p->vmArrayIndex = 0;
2458                 mail_search_full (vms_p->mailstream, NULL, pgm, NIL);
2459                 if (fold == 0 && urgent == 0)
2460                         vms_p->newmessages = vms_p->vmArrayIndex;
2461                 if (fold == 1)
2462                         vms_p->oldmessages = vms_p->vmArrayIndex;
2463                 if (fold == 0 && urgent == 1)
2464                         vms_p->urgentmessages = vms_p->vmArrayIndex;
2465                 /*Freeing the searchpgm also frees the searchhdr*/
2466                 mail_free_searchpgm(&pgm);
2467                 ast_mutex_unlock(&vms_p->lock);
2468                 vms_p->updated = 0;
2469                 return vms_p->vmArrayIndex;
2470         } else {
2471                 ast_mutex_lock(&vms_p->lock);
2472                 mail_ping(vms_p->mailstream);
2473                 ast_mutex_unlock(&vms_p->lock);
2474         }
2475         return 0;
2476 }
2477
2478 static int imap_check_limits(struct ast_channel *chan, struct vm_state *vms, struct ast_vm_user *vmu, int msgnum)
2479 {
2480         /* Check if mailbox is full */
2481         check_quota(vms, vmu->imapfolder);
2482         if (vms->quota_limit && vms->quota_usage >= vms->quota_limit) {
2483                 ast_debug(1, "*** QUOTA EXCEEDED!! %u >= %u\n", vms->quota_usage, vms->quota_limit);
2484                 if (chan) {
2485                         ast_play_and_wait(chan, "vm-mailboxfull");
2486                 }
2487                 return -1;
2488         }
2489
2490         /* Check if we have exceeded maxmsg */
2491         ast_debug(3, "Checking message number quota: mailbox has %d messages, maximum is set to %d, current messages %d\n", msgnum, vmu->maxmsg, inprocess_count(vmu->mailbox, vmu->context, 0));
2492         if (msgnum >= vmu->maxmsg - inprocess_count(vmu->mailbox, vmu->context, +1)) {
2493                 ast_log(LOG_WARNING, "Unable to leave message since we will exceed the maximum number of messages allowed (%u >= %u)\n", msgnum, vmu->maxmsg);
2494                 if (chan) {
2495                         ast_play_and_wait(chan, "vm-mailboxfull");
2496                         pbx_builtin_setvar_helper(chan, "VMSTATUS", "FAILED");
2497                 }
2498                 return -1;
2499         }
2500
2501         return 0;
2502 }
2503
2504 /*!
2505  * \brief Gets the number of messages that exist in a mailbox folder.
2506  * \param context
2507  * \param mailbox
2508  * \param folder
2509  * 
2510  * This method is used when IMAP backend is used.
2511  * \return The number of messages in this mailbox folder (zero or more).
2512  */
2513 static int messagecount(const char *context, const char *mailbox, const char *folder)
2514 {
2515         if (ast_strlen_zero(folder) || !strcmp(folder, "INBOX")) {
2516                 return __messagecount(context, mailbox, "INBOX") + __messagecount(context, mailbox, "Urgent");
2517         } else {
2518                 return __messagecount(context, mailbox, folder);
2519         }
2520 }
2521
2522 static int imap_store_file(const char *dir, const char *mailboxuser, const char *mailboxcontext, int msgnum, struct ast_channel *chan, struct ast_vm_user *vmu, char *fmt, int duration, struct vm_state *vms, const char *flag, const char *msg_id)
2523 {
2524         char *myserveremail = serveremail;
2525         char fn[PATH_MAX];
2526         char introfn[PATH_MAX];
2527         char mailbox[256];
2528         char *stringp;
2529         FILE *p = NULL;
2530         char tmp[80] = "/tmp/astmail-XXXXXX";
2531         long len;
2532         void *buf;
2533         int tempcopy = 0;
2534         STRING str;
2535         int ret; /* for better error checking */
2536         char *imap_flags = NIL;
2537         int msgcount = (messagecount(vmu->context, vmu->mailbox, "INBOX") + messagecount(vmu->context, vmu->mailbox, "Old"));
2538         int box = NEW_FOLDER;
2539
2540         /* Back out early if this is a greeting and we don't want to store greetings in IMAP */
2541         if (msgnum < 0) {
2542                 if(!imapgreetings) {
2543                         return 0;
2544                 } else {
2545                         box = GREETINGS_FOLDER;
2546                 }
2547         }
2548
2549         if (imap_check_limits(chan, vms, vmu, msgcount)) {
2550                 return -1;
2551         }
2552
2553         /* Set urgent flag for IMAP message */
2554         if (!ast_strlen_zero(flag) && !strcmp(flag, "Urgent")) {
2555                 ast_debug(3, "Setting message flag \\\\FLAGGED.\n");
2556                 imap_flags = "\\FLAGGED";
2557         }
2558
2559         /* Attach only the first format */
2560         fmt = ast_strdupa(fmt);
2561         stringp = fmt;
2562         strsep(&stringp, "|");
2563
2564         if (!ast_strlen_zero(vmu->serveremail))
2565                 myserveremail = vmu->serveremail;
2566
2567         if (msgnum > -1)
2568                 make_file(fn, sizeof(fn), dir, msgnum);
2569         else
2570                 ast_copy_string (fn, dir, sizeof(fn));
2571
2572         snprintf(introfn, sizeof(introfn), "%sintro", fn);
2573         if (ast_fileexists(introfn, NULL, NULL) <= 0) {
2574                 *introfn = '\0';
2575         }
2576
2577         if (ast_strlen_zero(vmu->email)) {
2578                 /* We need the vmu->email to be set when we call make_email_file, but
2579                  * if we keep it set, a duplicate e-mail will be created. So at the end
2580                  * of this function, we will revert back to an empty string if tempcopy
2581                  * is 1.
2582                  */
2583                 ast_copy_string(vmu->email, vmu->imapuser, sizeof(vmu->email));
2584                 tempcopy = 1;
2585         }
2586
2587         if (!strcmp(fmt, "wav49"))
2588                 fmt = "WAV";
2589         ast_debug(3, "Storing file '%s', format '%s'\n", fn, fmt);
2590
2591         /* Make a temporary file instead of piping directly to sendmail, in case the mail
2592            command hangs. */
2593         if (!(p = vm_mkftemp(tmp))) {
2594                 ast_log(AST_LOG_WARNING, "Unable to store '%s' (can't create temporary file)\n", fn);
2595                 if (tempcopy)
2596                         *(vmu->email) = '\0';
2597                 return -1;
2598         }
2599
2600         if (msgnum < 0 && imapgreetings) {
2601                 if ((ret = init_mailstream(vms, GREETINGS_FOLDER))) {
2602                         ast_log(AST_LOG_WARNING, "Unable to open mailstream.\n");
2603                         return -1;
2604                 }
2605                 imap_delete_old_greeting(fn, vms);
2606         }
2607
2608         make_email_file(p, myserveremail, vmu, msgnum, vmu->context, vmu->mailbox, "INBOX",
2609                 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL),
2610                 S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, NULL),
2611                 fn, introfn, fmt, duration, 1, chan, NULL, 1, flag, msg_id);
2612         /* read mail file to memory */
2613         len = ftell(p);
2614         rewind(p);
2615         if (!(buf = ast_malloc(len + 1))) {
2616                 ast_log(AST_LOG_ERROR, "Can't allocate %ld bytes to read message\n", len + 1);
2617                 fclose(p);
2618                 if (tempcopy)
2619                         *(vmu->email) = '\0';
2620                 return -1;
2621         }
2622         if (fread(buf, len, 1, p) < len) {
2623                 if (ferror(p)) {
2624                         ast_log(LOG_ERROR, "Short read while reading in mail file.\n");
2625                         return -1;
2626                 }
2627         }
2628         ((char *) buf)[len] = '\0';
2629         INIT(&str, mail_string, buf, len);
2630         ret = init_mailstream(vms, box);
2631         if (ret == 0) {
2632                 imap_mailbox_name(mailbox, sizeof(mailbox), vms, box, 1);
2633                 ast_mutex_lock(&vms->lock);
2634                 if(!mail_append_full(vms->mailstream, mailbox, imap_flags, NIL, &str))
2635                         ast_log(LOG_ERROR, "Error while sending the message to %s\n", mailbox);
2636                 ast_mutex_unlock(&vms->lock);
2637                 fclose(p);
2638                 unlink(tmp);
2639                 ast_free(buf);
2640         } else {
2641                 ast_log(LOG_ERROR, "Could not initialize mailstream for %s\n", mailbox);
2642                 fclose(p);
2643                 unlink(tmp);
2644                 ast_free(buf);
2645                 return -1;
2646         }
2647         ast_debug(3, "%s stored\n", fn);
2648
2649         if (tempcopy)
2650                 *(vmu->email) = '\0';
2651         inprocess_count(vmu->mailbox, vmu->context, -1);
2652         return 0;
2653
2654 }
2655
2656 /*!
2657  * \brief Gets the number of messages that exist in the inbox folder.
2658  * \param mailbox_context
2659  * \param newmsgs The variable that is updated with the count of new messages within this inbox.
2660  * \param oldmsgs The variable that is updated with the count of old messages within this inbox.
2661  * \param urgentmsgs The variable that is updated with the count of urgent messages within this inbox.
2662  * 
2663  * This method is used when IMAP backend is used.
2664  * Simultaneously determines the count of new,old, and urgent messages. The total messages would then be the sum of these three.
2665  *
2666  * \return zero on success, -1 on error.
2667  */
2668
2669 static int inboxcount2(const char *mailbox_context, int *urgentmsgs, int *newmsgs, int *oldmsgs)
2670 {
2671         char tmp[PATH_MAX] = "";
2672         char *mailboxnc;
2673         char *context;
2674         char *mb;
2675         char *cur;
2676         if (newmsgs)
2677                 *newmsgs = 0;
2678         if (oldmsgs)
2679                 *oldmsgs = 0;
2680         if (urgentmsgs)
2681                 *urgentmsgs = 0;
2682
2683         ast_debug(3, "Mailbox is set to %s\n", mailbox_context);
2684         /* If no mailbox, return immediately */
2685         if (ast_strlen_zero(mailbox_context))
2686                 return 0;
2687
2688         ast_copy_string(tmp, mailbox_context, sizeof(tmp));
2689         context = strchr(tmp, '@');
2690         if (strchr(mailbox_context, ',')) {
2691                 int tmpnew, tmpold, tmpurgent;
2692                 ast_copy_string(tmp, mailbox_context, sizeof(tmp));
2693                 mb = tmp;
2694                 while ((cur = strsep(&mb, ", "))) {
2695                         if (!ast_strlen_zero(cur)) {
2696                                 if (inboxcount2(cur, urgentmsgs ? &tmpurgent : NULL, newmsgs ? &tmpnew : NULL, oldmsgs ? &tmpold : NULL))
2697                                         return -1;
2698                                 else {
2699                                         if (newmsgs)
2700                                                 *newmsgs += tmpnew; 
2701                                         if (oldmsgs)
2702                                                 *oldmsgs += tmpold;
2703                                         if (urgentmsgs)
2704                                                 *urgentmsgs += tmpurgent;
2705                                 }
2706                         }
2707                 }
2708                 return 0;
2709         }
2710         if (context) {
2711                 *context = '\0';
2712                 mailboxnc = tmp;
2713                 context++;
2714         } else {
2715                 context = "default";
2716                 mailboxnc = (char *) mailbox_context;
2717         }
2718
2719         if (newmsgs) {
2720                 struct ast_vm_user *vmu = find_user(NULL, context, mailboxnc);
2721                 if (!vmu) {
2722                         ast_log(AST_LOG_ERROR, "Couldn't find mailbox %s in context %s\n", mailboxnc, context);
2723                         return -1;
2724                 }
2725                 if ((*newmsgs = __messagecount(context, mailboxnc, vmu->imapfolder)) < 0) {
2726                         free_user(vmu);
2727                         return -1;
2728                 }
2729                 free_user(vmu);
2730         }
2731         if (oldmsgs) {
2732                 if ((*oldmsgs = __messagecount(context, mailboxnc, "Old")) < 0) {
2733                         return -1;
2734                 }
2735         }
2736         if (urgentmsgs) {
2737                 if ((*urgentmsgs = __messagecount(context, mailboxnc, "Urgent")) < 0) {
2738                         return -1;
2739                 }
2740         }
2741         return 0;
2742 }
2743
2744 /** 
2745  * \brief Determines if the given folder has messages.
2746  * \param mailbox The @ delimited string for user@context. If no context is found, uses 'default' for the context.
2747  * \param folder the folder to look in
2748  *
2749  * This function is used when the mailbox is stored in an IMAP back end.
2750  * This invokes the messagecount(). Here we are interested in the presence of messages (> 0) only, not the actual count.
2751  * \return 1 if the folder has one or more messages. zero otherwise.
2752  */
2753
2754 static int has_voicemail(const char *mailbox, const char *folder)
2755 {
2756         char tmp[256], *tmp2, *box, *context;
2757         ast_copy_string(tmp, mailbox, sizeof(tmp));
2758         tmp2 = tmp;
2759         if (strchr(tmp2, ',') || strchr(tmp2, '&')) {
2760                 while ((box = strsep(&tmp2, ",&"))) {
2761                         if (!ast_strlen_zero(box)) {
2762                                 if (has_voicemail(box, folder)) {
2763                                         return 1;
2764                                 }
2765                         }
2766                 }
2767         }
2768         if ((context = strchr(tmp, '@'))) {
2769                 *context++ = '\0';
2770         } else {
2771                 context = "default";
2772         }
2773         return __messagecount(context, tmp, folder) ? 1 : 0;
2774 }
2775
2776 /*!
2777  * \brief Copies a message from one mailbox to another.
2778  * \param chan
2779  * \param vmu
2780  * \param imbox
2781  * \param msgnum
2782  * \param duration
2783  * \param recip
2784  * \param fmt
2785  * \param dir
2786  *
2787  * This works with IMAP storage based mailboxes.
2788  *
2789  * \return zero on success, -1 on error.
2790  */
2791 static int copy_message(struct ast_channel *chan, struct ast_vm_user *vmu, int imbox, int msgnum, long duration, struct ast_vm_user *recip, char *fmt, char *dir, char *flag, const char *dest_folder)
2792 {
2793         struct vm_state *sendvms = NULL;
2794         char messagestring[10]; /*I guess this could be a problem if someone has more than 999999999 messages...*/
2795         if (msgnum >= recip->maxmsg) {
2796                 ast_log(LOG_WARNING, "Unable to copy mail, mailbox %s is full\n", recip->mailbox);
2797                 return -1;
2798         }
2799         if (!(sendvms = get_vm_state_by_imapuser(vmu->imapuser, 0))) {
2800                 ast_log(LOG_ERROR, "Couldn't get vm_state for originator's mailbox!!\n");
2801                 return -1;
2802         }
2803         if (!get_vm_state_by_imapuser(recip->imapuser, 0)) {
2804                 ast_log(LOG_ERROR, "Couldn't get vm_state for destination mailbox!\n");
2805                 return -1;
2806         }
2807         snprintf(messagestring, sizeof(messagestring), "%ld", sendvms->msgArray[msgnum]);
2808         ast_mutex_lock(&sendvms->lock);
2809         if ((mail_copy(sendvms->mailstream, messagestring, (char *) mbox(vmu, imbox)) == T)) {
2810                 ast_mutex_unlock(&sendvms->lock);
2811                 return 0;
2812         }
2813         ast_mutex_unlock(&sendvms->lock);
2814         ast_log(LOG_WARNING, "Unable to copy message from mailbox %s to mailbox %s\n", vmu->mailbox, recip->mailbox);
2815         return -1;
2816 }
2817
2818 static void imap_mailbox_name(char *spec, size_t len, struct vm_state *vms, int box, int use_folder)
2819 {
2820         char tmp[256], *t = tmp;
2821         size_t left = sizeof(tmp);
2822         
2823         if (box == OLD_FOLDER) {
2824                 ast_copy_string(vms->curbox, mbox(NULL, NEW_FOLDER), sizeof(vms->curbox));
2825         } else {
2826                 ast_copy_string(vms->curbox, mbox(NULL, box), sizeof(vms->curbox));
2827         }
2828
2829         if (box == NEW_FOLDER) {
2830                 ast_copy_string(vms->vmbox, "vm-INBOX", sizeof(vms->vmbox));
2831         } else {
2832                 snprintf(vms->vmbox, sizeof(vms->vmbox), "vm-%s", mbox(NULL, box));
2833         }
2834
2835         /* Build up server information */
2836         ast_build_string(&t, &left, "{%s:%s/imap", S_OR(vms->imapserver, imapserver), S_OR(vms->imapport, imapport));
2837
2838         /* Add authentication user if present */
2839         if (!ast_strlen_zero(authuser))
2840                 ast_build_string(&t, &left, "/authuser=%s", authuser);
2841
2842         /* Add flags if present */
2843         if (!ast_strlen_zero(imapflags) || !(ast_strlen_zero(vms->imapflags))) {
2844                 ast_build_string(&t, &left, "/%s", S_OR(vms->imapflags, imapflags));
2845         }
2846
2847         /* End with username */
2848 #if 1
2849         ast_build_string(&t, &left, "/user=%s}", vms->imapuser);
2850 #else
2851         ast_build_string(&t, &left, "/user=%s/novalidate-cert}", vms->imapuser);
2852 #endif
2853         if (box == NEW_FOLDER || box == OLD_FOLDER)
2854                 snprintf(spec, len, "%s%s", tmp, use_folder? vms->imapfolder: "INBOX");
2855         else if (box == GREETINGS_FOLDER)
2856                 snprintf(spec, len, "%s%s", tmp, greetingfolder);
2857         else {  /* Other folders such as Friends, Family, etc... */
2858                 if (!ast_strlen_zero(imapparentfolder)) {
2859                         /* imapparentfolder would typically be set to INBOX */
2860                         snprintf(spec, len, "%s%s%c%s", tmp, imapparentfolder, delimiter, mbox(NULL, box));
2861                 } else {
2862                         snprintf(spec, len, "%s%s", tmp, mbox(NULL, box));
2863                 }
2864         }
2865 }
2866
2867 static int init_mailstream(struct vm_state *vms, int box)
2868 {
2869         MAILSTREAM *stream = NIL;
2870         long debug;
2871         char tmp[256];
2872
2873         if (!vms) {
2874                 ast_log(LOG_ERROR, "vm_state is NULL!\n");
2875                 return -1;
2876         }
2877         ast_debug(3, "vm_state user is:%s\n", vms->imapuser);
2878         if (vms->mailstream == NIL || !vms->mailstream) {
2879                 ast_debug(1, "mailstream not set.\n");
2880         } else {
2881                 stream = vms->mailstream;
2882         }
2883         /* debug = T;  user wants protocol telemetry? */
2884         debug = NIL;  /* NO protocol telemetry? */
2885
2886         if (delimiter == '\0') {                /* did not probe the server yet */
2887                 char *cp;
2888 #ifdef USE_SYSTEM_IMAP
2889 #include <imap/linkage.c>
2890 #elif defined(USE_SYSTEM_CCLIENT)
2891 #include <c-client/linkage.c>
2892 #else
2893 #include "linkage.c"
2894 #endif
2895                 /* Connect to INBOX first to get folders delimiter */
2896                 imap_mailbox_name(tmp, sizeof(tmp), vms, 0, 1);
2897                 ast_mutex_lock(&vms->lock);
2898                 stream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
2899                 ast_mutex_unlock(&vms->lock);
2900                 if (stream == NIL) {
2901                         ast_log(LOG_ERROR, "Can't connect to imap server %s\n", tmp);
2902                         return -1;
2903                 }
2904                 get_mailbox_delimiter(vms, stream);
2905                 /* update delimiter in imapfolder */
2906                 for (cp = vms->imapfolder; *cp; cp++)
2907                         if (*cp == '/')
2908                                 *cp = delimiter;
2909         }
2910         /* Now connect to the target folder */
2911         imap_mailbox_name(tmp, sizeof(tmp), vms, box, 1);
2912         ast_debug(3, "Before mail_open, server: %s, box:%d\n", tmp, box);
2913         ast_mutex_lock(&vms->lock);
2914         vms->mailstream = mail_open (stream, tmp, debug ? OP_DEBUG : NIL);
2915         ast_mutex_unlock(&vms->lock);
2916         if (vms->mailstream == NIL) {
2917                 return -1;
2918         } else {
2919                 return 0;
2920         }
2921 }
2922
2923 static int open_mailbox(struct vm_state *vms, struct ast_vm_user *vmu, int box)
2924 {
2925         SEARCHPGM *pgm;
2926         SEARCHHEADER *hdr;
2927         int urgent = 0;
2928
2929         /* If Urgent, then look at INBOX */
2930         if (box == 11) {
2931                 box = NEW_FOLDER;
2932                 urgent = 1;
2933         }
2934
2935         ast_copy_string(vms->imapuser, vmu->imapuser, sizeof(vms->imapuser));
2936         ast_copy_string(vms->imapfolder, vmu->imapfolder, sizeof(vms->imapfolder));
2937         ast_copy_string(vms->imapserver, vmu->imapserver, sizeof(vms->imapserver));
2938         ast_copy_string(vms->imapport, vmu->imapport, sizeof(vms->imapport));
2939         ast_copy_string(vms->imapflags, vmu->imapflags, sizeof(vms->imapflags));
2940         vms->imapversion = vmu->imapversion;
2941         ast_debug(3, "Before init_mailstream, user is %s\n", vmu->imapuser);
2942
2943         if (init_mailstream(vms, box) || !vms->mailstream) {
2944                 ast_log(AST_LOG_ERROR, "Could not initialize mailstream\n");
2945                 return -1;
2946         }
2947
2948         create_dirpath(vms->curdir, sizeof(vms->curdir), vmu->context, vms->username, vms->curbox);
2949
2950         /* Check Quota */
2951         if  (box == 0)  {
2952                 ast_debug(3, "Mailbox name set to: %s, about to check quotas\n", mbox(vmu, box));
2953                 check_quota(vms, (char *) mbox(vmu, box));
2954         }
2955
2956         ast_mutex_lock(&vms->lock);
2957         pgm = mail_newsearchpgm();
2958
2959         /* Check IMAP folder for Asterisk messages only... */
2960         hdr = mail_newsearchheader("X-Asterisk-VM-Extension", (!ast_strlen_zero(vmu->imapvmshareid) ? vmu->imapvmshareid : vmu->mailbox));
2961         hdr->next = mail_newsearchheader("X-Asterisk-VM-Context", vmu->context);
2962         pgm->header = hdr;
2963         pgm->deleted = 0;
2964         pgm->undeleted = 1;
2965
2966         /* if box = NEW_FOLDER, check for new, if box = OLD_FOLDER, check for read */
2967         if (box == NEW_FOLDER && urgent == 1) {
2968                 pgm->unseen = 1;
2969                 pgm->seen = 0;
2970                 pgm->flagged = 1;
2971                 pgm->unflagged = 0;
2972         } else if (box == NEW_FOLDER && urgent == 0) {
2973                 pgm->unseen = 1;
2974                 pgm->seen = 0;
2975                 pgm->flagged = 0;
2976                 pgm->unflagged = 1;
2977         } else if (box == OLD_FOLDER) {
2978                 pgm->seen = 1;
2979                 pgm->unseen = 0;
2980         }
2981
2982         ast_debug(3, "Before mail_search_full, user is %s\n", vmu->imapuser);
2983
2984         vms->vmArrayIndex = 0;
2985         mail_search_full (vms->mailstream, NULL, pgm, NIL);
2986         vms->lastmsg = vms->vmArrayIndex - 1;
2987         mail_free_searchpgm(&pgm);
2988         /* Since IMAP storage actually stores both old and new messages in the same IMAP folder,
2989          * ensure to allocate enough space to account for all of them. Warn if old messages
2990          * have not been checked first as that is required.
2991          */
2992         if (box == 0 && !vms->dh_arraysize) {
2993                 ast_log(LOG_WARNING, "The code expects the old messages to be checked first, fix the code.\n");
2994         }
2995         if (vm_allocate_dh(vms, vmu, box == 0 ? vms->vmArrayIndex + vms->oldmessages : vms->lastmsg)) {
2996                 ast_mutex_unlock(&vms->lock);
2997                 return -1;
2998         }
2999
3000         ast_mutex_unlock(&vms->lock);
3001         return 0;
3002 }
3003
3004 static void write_file(char *filename, char *buffer, unsigned long len)
3005 {
3006         FILE *output;
3007
3008         output = fopen (filename, "w");
3009         if (fwrite(buffer, len, 1, output) != 1) {
3010                 if (ferror(output)) {
3011                         ast_log(LOG_ERROR, "Short write while writing e-mail body: %s.\n", strerror(errno));
3012                 }
3013         }
3014         fclose (output);
3015 }
3016
3017 static void update_messages_by_imapuser(const char *user, unsigned long number)
3018 {
3019         struct vm_state *vms = get_vm_state_by_imapuser(user, 1);
3020
3021         if (!vms && !(vms = get_vm_state_by_imapuser(user, 0))) {
3022                 return;
3023         }
3024
3025         ast_debug(3, "saving mailbox message number %lu as message %d. Interactive set to %d\n", number, vms->vmArrayIndex, vms->interactive);
3026         vms->msgArray[vms->vmArrayIndex++] = number;
3027 }
3028
3029 void mm_searched(MAILSTREAM *stream, unsigned long number)
3030 {
3031         char *mailbox = stream->mailbox, buf[1024] = "", *user;
3032
3033         if (!(user = get_user_by_mailbox(mailbox, buf, sizeof(buf))))
3034                 return;
3035
3036         update_messages_by_imapuser(user, number);
3037 }
3038
3039 static struct ast_vm_user *find_user_realtime_imapuser(const char *imapuser)
3040 {
3041         struct ast_variable *var;
3042         struct ast_vm_user *vmu;
3043
3044         vmu = ast_calloc(1, sizeof *vmu);
3045         if (!vmu)
3046                 return NULL;
3047
3048         populate_defaults(vmu);
3049         ast_set_flag(vmu, VM_ALLOCED);
3050
3051         var = ast_load_realtime("voicemail", "imapuser", imapuser, NULL);
3052         if (var) {
3053                 apply_options_full(vmu, var);
3054                 ast_variables_destroy(var);
3055                 return vmu;