Version 0.1.7 from FTP
[asterisk/asterisk.git] / apps / app_voicemail.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Voicemail System (did you ever think it could be so easy?)
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <asterisk/file.h>
15 #include <asterisk/logger.h>
16 #include <asterisk/channel.h>
17 #include <asterisk/pbx.h>
18 #include <asterisk/options.h>
19 #include <asterisk/config.h>
20 #include <asterisk/say.h>
21 #include <asterisk/module.h>
22 #include <stdlib.h>
23 #include <errno.h>
24 #include <unistd.h>
25 #include <string.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <sys/time.h>
29 #include <sys/stat.h>
30 #include <time.h>
31
32 #include <pthread.h>
33 #include "../asterisk.h"
34
35 #define COMMAND_TIMEOUT 5000
36
37 #define VOICEMAIL_CONFIG "voicemail.conf"
38 #define ASTERISK_USERNAME "asterisk"
39
40 /*
41 #define HOSTNAME_OVERRIDE "linux-support.net"
42 */
43
44 #define SENDMAIL "/usr/sbin/sendmail -t"
45
46 #define INTRO "vm-intro"
47
48 #define MAXMSG 100
49
50 #define MAX_OTHER_FORMATS 10
51
52 #define VM_SPOOL_DIR AST_SPOOL_DIR "/vm"
53
54
55 static char *tdesc = "Comedian Mail (Voicemail System)";
56
57 /* Leave a message */
58 static char *app = "VoiceMail";
59
60 /* Check mail, control, etc */
61 static char *app2 = "VoiceMailMain";
62
63 STANDARD_LOCAL_USER;
64
65 LOCAL_USER_DECL;
66
67 static char *get_dir(char *ext, char *mailbox)
68 {
69         char *tmp = malloc(strlen(ext) + strlen(VM_SPOOL_DIR) + 3 + strlen(mailbox));
70         sprintf(tmp, "%s/%s/%s", VM_SPOOL_DIR, ext, mailbox);
71         return tmp;
72 }
73 static char *get_fn(char *dir, int num)
74 {
75         char *tmp = malloc(strlen(dir) + 10);
76         sprintf(tmp, "%s/msg%04d", dir, num);
77         return tmp;
78 }
79
80 static int announce_message(struct ast_channel *chan, char *dir, int msgcnt)
81 {
82         char *fn;
83         int res;
84         res = ast_streamfile(chan, "vm-message", chan->language);
85         if (!res) {
86                 res = ast_waitstream(chan, AST_DIGIT_ANY);
87                 if (!res) {
88                         res = ast_say_number(chan, msgcnt+1, chan->language);
89                         if (!res) {
90                                 fn = get_fn(dir, msgcnt);
91                                 if (fn) {
92                                         res = ast_streamfile(chan, fn, chan->language);
93                                         free(fn);
94                                 }
95                         }
96                 }
97         }
98         if (res < 0)
99                 ast_log(LOG_WARNING, "Unable to announce message\n");
100         return res;
101 }
102 static int sendmail(char *email, char *name, int msgnum, char *mailbox)
103 {
104         FILE *p;
105         char date[256];
106         char host[256];
107         time_t t;
108         struct tm *tm;
109         p = popen(SENDMAIL, "w");
110         if (p) {
111                 gethostname(host, sizeof(host));
112                 time(&t);
113                 tm = localtime(&t);
114                 strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %z", tm);
115                 fprintf(p, "Date: %s\n", date);
116                 fprintf(p, "Message-ID: <Asterisk-%d-%s-%d@%s>\n", msgnum, mailbox, getpid(), host);
117                 fprintf(p, "From: Asterisk PBX <%s@%s>\n", ASTERISK_USERNAME,
118 #ifdef HOSTNAME_OVERRIDE
119                                 HOSTNAME_OVERRIDE
120 #else
121                                 host
122 #endif
123                                 );
124                 fprintf(p, "To: %s <%s>\n", name, email);
125                 fprintf(p, "Subject: [PBX]: New message %d in mailbox %s\n\n", msgnum, mailbox);
126                 strftime(date, sizeof(date), "%A, %B %d, %Y at %r", tm);
127                 fprintf(p, "Dear %s:\n\n\tJust wanted to let you know you were just left a message (number %d)\n"
128                            "in mailbox %s, on %s so you might\n"
129                                    "want to check it when you get a chance.  Thanks!\n\n\t\t\t\t--Asterisk\n", name, msgnum, mailbox, date);
130                 fprintf(p, ".\n");
131                 pclose(p);
132         } else {
133                 ast_log(LOG_WARNING, "Unable to launch '%s'\n", SENDMAIL);
134                 return -1;
135         }
136         return 0;
137 }
138
139 static int leave_voicemail(struct ast_channel *chan, char *ext, int silent)
140 {
141         struct ast_config *cfg;
142         char *copy, *name, *passwd, *email, *dir, *fmt, *fmts, *fn=NULL;
143         char comment[256];
144         struct ast_filestream *writer=NULL, *others[MAX_OTHER_FORMATS];
145         char *sfmt[MAX_OTHER_FORMATS];
146         int res = -1, fmtcnt=0, x;
147         int msgnum;
148         int outmsg=0;
149         struct ast_frame *f;
150         
151         cfg = ast_load(VOICEMAIL_CONFIG);
152         if (!cfg) {
153                 ast_log(LOG_WARNING, "No such configuration file %s\n", VOICEMAIL_CONFIG);
154                 return -1;
155         }
156         if ((copy = ast_variable_retrieve(cfg, NULL, ext))) {
157                 /* Make sure they have an entry in the config */
158                 copy = strdup(copy);
159                 passwd = strtok(copy, ",");
160                 name = strtok(NULL, ",");
161                 email = strtok(NULL, ",");
162                 dir = get_dir(ext, "");
163                 /* It's easier just to try to make it than to check for its existence */
164                 if (mkdir(dir, 0700) && (errno != EEXIST))
165                         ast_log(LOG_WARNING, "mkdir '%s' failed: %s\n", dir, strerror(errno));
166                 dir = get_dir(ext, "INBOX");
167                 if (mkdir(dir, 0700) && (errno != EEXIST))
168                         ast_log(LOG_WARNING, "mkdir '%s' failed: %s\n", dir, strerror(errno));
169                 /* Stream an info message */
170                 if (silent || !ast_streamfile(chan, INTRO, chan->language)) {
171                         /* Wait for the message to finish */
172                         if (silent || !ast_waitstream(chan, "")) {
173                                 fmt = ast_variable_retrieve(cfg, "general", "format");
174                                 if (fmt) {
175                                         fmts = strdup(fmt);
176                                         fmt = strtok(fmts, "|");
177                                         msgnum = 0;
178                                         do {
179                                                 if (fn)
180                                                         free(fn);
181                                                 fn = get_fn(dir, msgnum);
182                                                 snprintf(comment, sizeof(comment), "Voicemail from %s to %s (%s) on %s\n",
183                                                                                         (chan->callerid ? chan->callerid : "Unknown"), 
184                                                                                         name, ext, chan->name);
185                                                 if (ast_fileexists(fn, NULL, chan->language) > 0) {
186                                                         msgnum++;
187                                                         continue;
188                                                 }
189                                                 writer = ast_writefile(fn, fmt, comment, O_EXCL, 1 /* check for other formats */, 0700);
190                                                 if (!writer)
191                                                         break;
192                                                 msgnum++;
193                                         } while(!writer && (msgnum < MAXMSG));
194                                         if (writer) {
195                                                 /* We need to reset these values */
196                                                 free(fmts);
197                                                 fmt = ast_variable_retrieve(cfg, "general", "format");
198                                                 fmts = strdup(fmt);
199                                                 strtok(fmts, "|");
200                                                 while((fmt = strtok(NULL, "|"))) {
201                                                         if (fmtcnt > MAX_OTHER_FORMATS - 1) {
202                                                                 ast_log(LOG_WARNING, "Please increase MAX_OTHER_FORMATS in app_voicemail.c\n");
203                                                                 break;
204                                                         }
205                                                         sfmt[fmtcnt++] = strdup(fmt);
206                                                 }
207                                                 for (x=0;x<fmtcnt;x++) {
208                                                         others[x] = ast_writefile(fn, sfmt[x], comment, 0, 0, 0700);
209                                                         if (!others[x]) {
210                                                                 /* Ick, the other format didn't work, but be sure not
211                                                                    to leak memory here */
212                                                                 int y;
213                                                                 for(y=x+1;y < fmtcnt;y++)
214                                                                         free(sfmt[y]);
215                                                                 break;
216                                                         }
217                                                         free(sfmt[x]);
218                                                 }
219                                                 if (x == fmtcnt) {
220                                                         /* Loop forever, writing the packets we read to the writer(s), until
221                                                            we read a # or get a hangup */
222                                                         if (option_verbose > 2) 
223                                                                 ast_verbose( VERBOSE_PREFIX_3 "Recording to %s\n", fn);
224                                                         while((f = ast_read(chan))) {
225                                                                 if (f->frametype == AST_FRAME_VOICE) {
226                                                                         /* Write the primary format */
227                                                                         res = ast_writestream(writer, f);
228                                                                         if (res) {
229                                                                                 ast_log(LOG_WARNING, "Error writing primary frame\n");
230                                                                                 break;
231                                                                         }
232                                                                         /* And each of the others */
233                                                                         for (x=0;x<fmtcnt;x++) {
234                                                                                 res |= ast_writestream(others[x], f);
235                                                                         }
236                                                                         ast_frfree(f);
237                                                                         /* Exit on any error */
238                                                                         if (res) {
239                                                                                 ast_log(LOG_WARNING, "Error writing frame\n");
240                                                                                 break;
241                                                                         }
242                                                                 }
243                                                                 if (f->frametype == AST_FRAME_DTMF) {
244                                                                         if (f->subclass == '#') {
245                                                                                 if (option_verbose > 2) 
246                                                                                         ast_verbose( VERBOSE_PREFIX_3 "User ended message by pressing %c\n", f->subclass);
247                                                                                 outmsg=2;
248                                                                                 break;
249                                                                         }
250                                                                 }
251                                                         }
252                                                         if (!f) {
253                                                                 if (option_verbose > 2) 
254                                                                         ast_verbose( VERBOSE_PREFIX_3 "User hung up\n");
255                                                                 res = -1;
256                                                                 outmsg=1;
257                                                         }
258                                                 } else {
259                                                         ast_log(LOG_WARNING, "Error creating writestream '%s', format '%s'\n", fn, sfmt[x]); 
260                                                         free(sfmt[x]);
261                                                 }
262                                                 ast_closestream(writer);
263                                                 for (x=0;x<fmtcnt;x++) {
264                                                         if (!others[x])
265                                                                 break;
266                                                         ast_closestream(others[x]);
267                                                 }
268                                                 if (outmsg) {
269                                                         if (outmsg > 1) {
270                                                                 /* Let them know it worked */
271                                                                 ast_streamfile(chan, "vm-msgsaved", chan->language);
272                                                                 ast_waitstream(chan, "");
273                                                         }
274                                                         /* Send e-mail if applicable */
275                                                         if (email) 
276                                                                 sendmail(email, name, msgnum, ext);
277                                                 }
278                                         } else {
279                                                 if (msgnum < MAXMSG)
280                                                         ast_log(LOG_WARNING, "Error writing to mailbox %s\n", ext);
281                                                 else
282                                                         ast_log(LOG_WARNING, "Too many messages in mailbox %s\n", ext);
283                                         }
284                                         if (fn)
285                                                 free(fn);
286                                         free(fmts);
287                                 } else 
288                                         ast_log(LOG_WARNING, "No format to save messages in \n");
289                         }
290                 } else
291                         ast_log(LOG_WARNING, "Unable to playback instructions\n");
292                         
293                 free(dir);
294                 free(copy);
295         } else
296                 ast_log(LOG_WARNING, "No entry in voicemail config file for '%s'\n", ext);
297         ast_destroy(cfg);
298         /* Leave voicemail for someone */
299         return res;
300 }
301
302 static int vm_execmain(struct ast_channel *chan, void *data)
303 {
304         /* XXX This is, admittedly, some pretty horrendus code XXX */
305         int res=-1;
306         int valid = 0;
307         int curmsg = 0;
308         int maxmsg = 0;
309         int x;
310         char *fn, *nfn;
311         char d;
312         struct localuser *u;
313         char username[80];
314         char password[80], *copy;
315         int deleted[MAXMSG];
316         struct ast_config *cfg;
317         int state;
318         char *dir=NULL;
319         
320         LOCAL_USER_ADD(u);
321         cfg = ast_load(VOICEMAIL_CONFIG);
322         if (!cfg) {
323                 ast_log(LOG_WARNING, "No voicemail configuration\n");
324                 goto out;
325         }
326         if (ast_streamfile(chan, "vm-login", chan->language)) {
327                 ast_log(LOG_WARNING, "Couldn't stream login file\n");
328                 goto out;
329         }
330         do {
331                 /* Prompt for, and read in the username */
332                 if (ast_readstring(chan, username, sizeof(username), 2000, 10000, "#")) {
333                         ast_log(LOG_WARNING, "Couldn't read username\n");
334                         goto out;
335                 }                       
336                 if (!strlen(username)) {
337                         if (option_verbose > 2)
338                                 ast_verbose(VERBOSE_PREFIX_3 "Username not entered\n");
339                         res = 0;
340                         goto out;
341                 }
342                 if (ast_streamfile(chan, "vm-password", chan->language)) {
343                         ast_log(LOG_WARNING, "Unable to stream password file\n");
344                         goto out;
345                 }
346                 if (ast_readstring(chan, password, sizeof(password), 2000, 10000, "#")) {
347                         ast_log(LOG_WARNING, "Unable to read password\n");
348                         goto out;
349                 }
350                 copy = ast_variable_retrieve(cfg, NULL, username);
351                 if (copy) {
352                         copy = strdup(copy);
353                         strtok(copy, ",");
354                         if (!strcmp(password,copy))
355                                 valid++;
356                         else if (option_verbose > 2)
357                                 ast_verbose( VERBOSE_PREFIX_3 "Incorrect password '%s' for user '%s'\n", password, username);
358                         free(copy);
359                 } else if (option_verbose > 2)
360                         ast_verbose( VERBOSE_PREFIX_3 "No such user '%s' in config file\n", username);
361                 if (!valid) {
362                         if (ast_streamfile(chan, "vm-incorrect", chan->language))
363                                 break;
364                         if (ast_waitstream(chan, ""))
365                                 break;
366                 }
367         } while (!valid);
368         if (valid) {
369                 dir = get_dir(username, "INBOX");
370                 if (!dir) 
371                         goto out;
372
373                 deleted[0] = 0;
374                 /* Find out how many messages are there, mark all as
375                    not deleted. */
376                 do {
377                         fn = get_fn(dir, maxmsg);
378                         if ((res = ast_fileexists(fn, NULL, chan->language))>0) {
379                                 maxmsg++;
380                                 deleted[maxmsg] = 0;
381                         }
382                         free(fn);
383                 } while(res > 0);
384                 if (ast_streamfile(chan, "vm-youhave", chan->language))
385                         goto out;
386                 if ((d=ast_waitstream(chan, AST_DIGIT_ANY)) < 0)
387                         goto out;
388                 ast_stopstream(chan);
389                 if (!d) {
390                         /* If they haven't interrupted us, play the message count */
391                         if (maxmsg > 0) {
392                                 if ((d = ast_say_number(chan, maxmsg, chan->language)) < 0)
393                                         goto out;
394                         } else {
395                                 if (ast_streamfile(chan, "vm-no", chan->language))
396                                         goto out;
397                                 if ((d=ast_waitstream(chan, AST_DIGIT_ANY)) < 0)
398                                         goto out;
399                                 ast_stopstream(chan);
400                         }
401                         if (!d) {
402                                 /* And if they still haven't, give them the last word */
403                                 if (ast_streamfile(chan, ((maxmsg == 1) ? "vm-message" : "vm-messages"), chan->language))
404                                         goto out;
405                                 if (ast_waitstream(chan, AST_DIGIT_ANY) < 0)
406                                         goto out;
407                                 ast_stopstream(chan);
408                         }
409                 }
410                 res = -1;
411                                 
412 #define STATE_STARTING 1
413 #define STATE_MESSAGE 2
414 #define STATE_MESSAGE_PLAYING 3
415                 state = STATE_STARTING;
416                 ast_log(LOG_EVENT, "User '%s' logged in on channel '%s' with %d message(s).\n", username, chan->name, maxmsg);
417                 if (option_verbose > 2)
418                         ast_verbose( VERBOSE_PREFIX_3 "User '%s' logged in on channel %s with %d messages\n", username, chan->name, maxmsg);
419                 if (!ast_streamfile(chan, "vm-instructions", chan->language)) {
420                         for(;;) {
421                                 if (chan->stream) {
422                                         d = ast_waitstream(chan, AST_DIGIT_ANY);
423                                         ast_stopstream(chan);
424                                         if (!d && (state == STATE_MESSAGE_PLAYING)) {
425                                                 state  = STATE_MESSAGE;
426                                                 /* If it runs out playing a message, then give directions */
427                                                 if (!(d = ast_streamfile(chan, "vm-msginstruct", chan->language)))
428                                                         d = ast_waitstream(chan, AST_DIGIT_ANY);
429                                                 ast_stopstream(chan);
430                                         }
431                                         if (!d)
432                                                 d = ast_waitfordigit(chan, COMMAND_TIMEOUT);
433                                 } else
434                                         d = ast_waitfordigit(chan, COMMAND_TIMEOUT);
435                                 if (d < 0)
436                                         goto out;
437 restart:
438                                 if (!d || (d == '*')) {
439                                         /* If they don't say anything, play back a message.  We'll decide which one is
440                                            best based up on where they are.  Ditto if they press the '*' key. */
441                                         switch(state) {
442                                         case STATE_STARTING:
443                                                 if (ast_streamfile(chan, "vm-instructions", chan->language))
444                                                         goto out;
445                                                 break;
446                                         case STATE_MESSAGE:
447                                         case STATE_MESSAGE_PLAYING:
448                                                 if (ast_streamfile(chan, "vm-msginstruct", chan->language))
449                                                         goto out;
450                                                 break;
451                                         default:
452                                                 ast_log(LOG_WARNING, "What do I do when they timeout/* in state %d?\n", state);
453                                         }
454                                 } else {
455                                         /* XXX Should we be command-compatible with Meridian mail?  Their system seems
456                                                very confusing, but also widely used XXX */
457                                         /* They've entered (or started to enter) a command */
458                                         switch(d) {
459                                         case '0':
460                                                 if (curmsg < maxmsg) {
461                                                         deleted[curmsg] = !deleted[curmsg];
462                                                         if (deleted[curmsg]) {
463                                                                 if (ast_streamfile(chan, "vm-deleted", chan->language))
464                                                                         goto out;
465                                                         } else {
466                                                                 if (ast_streamfile(chan, "vm-undeleted", chan->language))
467                                                                         goto out;
468                                                         }
469                                                 } else {
470                                                         if (ast_streamfile(chan, "vm-nomore", chan->language))
471                                                                 goto out;
472                                                 }
473                                                 break;
474                                         case '1':
475                                                 curmsg = 0;
476                                                 if (maxmsg > 0) {
477                                                         /* Yuck */
478                                                         if ((d = announce_message(chan, dir, curmsg)) > 0)
479                                                                 goto restart;
480                                                         else if (d < 0)
481                                                                 goto out;
482                                                 } else {
483                                                         if (ast_streamfile(chan, "vm-nomore", chan->language))
484                                                                 goto out;
485                                                 }
486                                                 state = STATE_MESSAGE_PLAYING;
487                                                 break;
488                                         case '4':
489                                                 if (curmsg > 0)
490                                                         curmsg--;
491                                                 /* Yuck */
492                                                 if ((d = announce_message(chan, dir, curmsg)) > 0)
493                                                         goto restart;
494                                                 else if (d < 0)
495                                                         goto out;
496                                                 state = STATE_MESSAGE_PLAYING;
497                                                 break;
498                                         case '5':
499                                                 if ((d = announce_message(chan, dir, curmsg)) > 0)
500                                                         goto restart;
501                                                 else if (d < 0)
502                                                         goto out;
503                                                 state = STATE_MESSAGE_PLAYING;
504                                                 break;
505                                         case '6':
506                                                 if (curmsg < maxmsg - 1) {
507                                                         curmsg++;
508                                                         if ((d = announce_message(chan, dir, curmsg)) > 0)
509                                                                 goto restart;
510                                                         else if (d < 0)
511                                                                 goto out;
512                                                 } else {
513                                                         if (ast_streamfile(chan, "vm-nomore", chan->language))
514                                                                 goto out;
515                                                 }
516                                                 state = STATE_MESSAGE_PLAYING;
517                                                 break;
518                                         /* XXX Message compose? It's easy!  Just read their # and, assuming it's in the config, 
519                                                call the routine as if it were called from the PBX proper XXX */
520                                         case '#':
521                                                 if (ast_streamfile(chan, "vm-goodbye", chan->language))
522                                                         goto out;
523                                                 if (ast_waitstream(chan, ""))
524                                                         goto out;
525                                                 res = 0;
526                                                 goto out;
527                                                 break;
528                                         default:
529                                                 /* Double yuck */
530                                                 d = '*';
531                                                 goto restart;
532                                         }
533                                 }
534                         }
535                 }
536         }
537         
538 out:
539         ast_stopstream(chan);
540         if (maxmsg) {
541                 /* Get the deleted messages fixed */
542                 curmsg = -1;
543                 for (x=0;x<maxmsg;x++) {
544                         if (!deleted[x]) {
545                                 curmsg++;
546                                 fn = get_fn(dir, x);
547                                 nfn = get_fn(dir, curmsg);
548                                 if (strcmp(fn, nfn))
549                                         ast_filerename(fn, nfn, NULL);
550                                 free(fn);
551                                 free(nfn);
552                         }
553                 }
554                 for (x = curmsg + 1; x<maxmsg; x++) {
555                         fn = get_fn(dir, x);
556                         if (fn) {
557                                 ast_filedelete(fn, NULL);
558                                 free(fn);
559                         }
560                 }
561         }
562         if (dir)
563                 free(dir);
564         if (cfg)
565                 ast_destroy(cfg);
566         LOCAL_USER_REMOVE(u);
567         return res;
568 }
569
570 static int vm_exec(struct ast_channel *chan, void *data)
571 {
572         int res=0, silent=0;
573         struct localuser *u;
574         char *ext = (char *)data;
575         
576         if (!data) {
577                 ast_log(LOG_WARNING, "vm requires an argument (extension)\n");
578                 return -1;
579         }
580         LOCAL_USER_ADD(u);
581         if (*ext == 's') {
582                 silent++;
583                 ext++;
584         }
585         res = leave_voicemail(chan, ext, silent);
586         LOCAL_USER_REMOVE(u);
587         return res;
588 }
589
590 int unload_module(void)
591 {
592         int res;
593         STANDARD_HANGUP_LOCALUSERS;
594         res = ast_unregister_application(app);
595         res |= ast_unregister_application(app2);
596         return res;
597 }
598
599 int load_module(void)
600 {
601         int res;
602         res = ast_register_application(app, vm_exec);
603         if (!res)
604                 res = ast_register_application(app2, vm_execmain);
605         return res;
606 }
607
608 char *description(void)
609 {
610         return tdesc;
611 }
612
613 int usecount(void)
614 {
615         int res;
616         STANDARD_USECOUNT(res);
617         return res;
618 }
619
620 char *key()
621 {
622         return ASTERISK_GPL_KEY;
623 }