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