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