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