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