Merge "res_pjsip: New endpoint option "refer_blind_progress""
[asterisk/asterisk.git] / res / res_smdi.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005-2008, Digium, Inc.
5  *
6  * Matthew A. Nicholson <mnicholson@digium.com>
7  * Russell Bryant <russell@digium.com>
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19
20 /*!
21  * \file
22  * \brief SMDI support for Asterisk.
23  * \author Matthew A. Nicholson <mnicholson@digium.com>
24  * \author Russell Bryant <russell@digium.com>
25  *
26  * Here is a useful mailing list post that describes SMDI protocol details:
27  * http://lists.digium.com/pipermail/asterisk-dev/2003-June/000884.html
28  *
29  * \todo This module currently has its own mailbox monitoring thread.  This should
30  * be converted to MWI subscriptions and just let the optional global voicemail
31  * polling thread handle it.
32  */
33
34 /*! \li \ref res_smdi.c uses the configuration file \ref smdi.conf
35  * \addtogroup configuration_file Configuration Files
36  */
37
38 /*!
39  * \page smdi.conf smdi.conf
40  * \verbinclude smdi.conf.sample
41  */
42
43 /*** MODULEINFO
44         <support_level>core</support_level>
45  ***/
46
47 #include "asterisk.h"
48
49 #include <termios.h>
50 #include <sys/time.h>
51 #include <time.h>
52 #include <ctype.h>
53
54 #include "asterisk/module.h"
55 #include "asterisk/lock.h"
56 #include "asterisk/utils.h"
57 #define AST_API_MODULE
58 #include "asterisk/smdi.h"
59 #include "asterisk/config.h"
60 #include "asterisk/io.h"
61 #include "asterisk/stringfields.h"
62 #include "asterisk/linkedlists.h"
63 #include "asterisk/app.h"
64 #include "asterisk/pbx.h"
65 #include "asterisk/channel.h"
66
67 /* Message expiry time in milliseconds */
68 #define SMDI_MSG_EXPIRY_TIME    30000 /* 30 seconds */
69
70 /*** DOCUMENTATION
71
72         <function name="SMDI_MSG_RETRIEVE" language="en_US">
73                 <synopsis>
74                         Retrieve an SMDI message.
75                 </synopsis>
76                 <syntax>
77                         <parameter name="smdi port" required="true" />
78                         <parameter name="search key" required="true" />
79                         <parameter name="timeout" />
80                         <parameter name="options">
81                                 <enumlist>
82                                         <enum name="t">
83                                                 <para>Instead of searching on the forwarding station, search on the message desk terminal.</para>
84                                         </enum>
85                                         <enum name="n">
86                                                 <para>Instead of searching on the forwarding station, search on the message desk number.</para>
87                                         </enum>
88                                 </enumlist>
89                         </parameter>
90                 </syntax>
91                 <description>
92                         <para>This function is used to retrieve an incoming SMDI message. It returns
93                         an ID which can be used with the SMDI_MSG() function to access details of
94                         the message.  Note that this is a destructive function in the sense that
95                         once an SMDI message is retrieved using this function, it is no longer in
96                         the global SMDI message queue, and can not be accessed by any other Asterisk
97                         channels.  The timeout for this function is optional, and the default is
98                         3 seconds.  When providing a timeout, it should be in milliseconds.
99                         </para>
100                         <para>The default search is done on the forwarding station ID. However, if
101                         you set one of the search key options in the options field, you can change
102                         this behavior.
103                         </para>
104                 </description>
105                 <see-also>
106                         <ref type="function">SMDI_MSG</ref>
107                 </see-also>
108         </function>
109         <function name="SMDI_MSG" language="en_US">
110                 <synopsis>
111                         Retrieve details about an SMDI message.
112                 </synopsis>
113                 <syntax>
114                         <parameter name="message_id" required="true" />
115                         <parameter name="component" required="true">
116                                 <para>Valid message components are:</para>
117                                 <enumlist>
118                                         <enum name="number">
119                                                 <para>The message desk number</para>
120                                         </enum>
121                                         <enum name="terminal">
122                                                 <para>The message desk terminal</para>
123                                         </enum>
124                                         <enum name="station">
125                                                 <para>The forwarding station</para>
126                                         </enum>
127                                         <enum name="callerid">
128                                                 <para>The callerID of the calling party that was forwarded</para>
129                                         </enum>
130                                         <enum name="type">
131                                                 <para>The call type.  The value here is the exact character
132                                                 that came in on the SMDI link.  Typically, example values
133                                                 are:</para>
134                                                 <para>Options:</para>
135                                                 <enumlist>
136                                                         <enum name="D">
137                                                                 <para>Direct Calls</para>
138                                                         </enum>
139                                                         <enum name="A">
140                                                                 <para>Forward All Calls</para>
141                                                         </enum>
142                                                         <enum name="B">
143                                                                 <para>Forward Busy Calls</para>
144                                                         </enum>
145                                                         <enum name="N">
146                                                                 <para>Forward No Answer Calls</para>
147                                                         </enum>
148                                                 </enumlist>
149                                         </enum>
150                                 </enumlist>
151                         </parameter>
152                 </syntax>
153                 <description>
154                         <para>This function is used to access details of an SMDI message that was
155                         pulled from the incoming SMDI message queue using the SMDI_MSG_RETRIEVE()
156                         function.</para>
157                 </description>
158                 <see-also>
159                         <ref type="function">SMDI_MSG_RETRIEVE</ref>
160                 </see-also>
161         </function>
162  ***/
163
164 static const char config_file[] = "smdi.conf";
165 static int smdi_loaded;
166
167 struct ast_smdi_interface {
168         char name[SMDI_MAX_FILENAME_LEN];
169         struct ao2_container *md_q;
170         ast_mutex_t md_q_lock;
171         ast_cond_t md_q_cond;
172         struct ao2_container *mwi_q;
173         ast_mutex_t mwi_q_lock;
174         ast_cond_t mwi_q_cond;
175         FILE *file;
176         int fd;
177         pthread_t thread;
178         struct termios mode;
179         int msdstrip;
180         long msg_expiry;
181 };
182
183 static AO2_GLOBAL_OBJ_STATIC(smdi_ifaces);
184
185 /*! \brief A mapping between an SMDI mailbox ID and an Asterisk mailbox */
186 struct mailbox_mapping {
187         /*! This is the current state of the mailbox.  It is simply on or
188          *  off to indicate if there are messages waiting or not. */
189         unsigned int cur_state:1;
190         /*! A Pointer to the appropriate SMDI interface */
191         struct ast_smdi_interface *iface;
192         AST_DECLARE_STRING_FIELDS(
193                 /*! The Name of the mailbox for the SMDI link. */
194                 AST_STRING_FIELD(smdi);
195                 /*! The name of the mailbox on the Asterisk side */
196                 AST_STRING_FIELD(mailbox);
197                 /*! The name of the voicemail context in use */
198                 AST_STRING_FIELD(context);
199         );
200         AST_LIST_ENTRY(mailbox_mapping) entry;
201 };
202
203 /*! 10 seconds */
204 #define DEFAULT_POLLING_INTERVAL 10
205
206 /*! \brief Data that gets used by the SMDI MWI monitoring thread */
207 static struct {
208         /*! The thread ID */
209         pthread_t thread;
210         ast_mutex_t lock;
211         ast_cond_t cond;
212         /*! A list of mailboxes that need to be monitored */
213         AST_LIST_HEAD_NOLOCK(, mailbox_mapping) mailbox_mappings;
214         /*! Polling Interval for checking mailbox status */
215         unsigned int polling_interval;
216         /*! Set to 1 to tell the polling thread to stop */
217         unsigned int stop:1;
218         /*! The time that the last poll began */
219         struct timeval last_poll;
220 } mwi_monitor = {
221         .thread = AST_PTHREADT_NULL,
222 };
223
224 static void smdi_interface_destroy(void *obj)
225 {
226         struct ast_smdi_interface *iface = obj;
227
228         if (iface->thread != AST_PTHREADT_NULL && iface->thread != AST_PTHREADT_STOP) {
229                 pthread_cancel(iface->thread);
230                 pthread_join(iface->thread, NULL);
231         }
232
233         iface->thread = AST_PTHREADT_STOP;
234
235         if (iface->file) {
236                 fclose(iface->file);
237         }
238
239         ao2_cleanup(iface->md_q);
240         ast_mutex_destroy(&iface->md_q_lock);
241         ast_cond_destroy(&iface->md_q_cond);
242
243         ao2_cleanup(iface->mwi_q);
244         ast_mutex_destroy(&iface->mwi_q_lock);
245         ast_cond_destroy(&iface->mwi_q_cond);
246
247         ast_free(iface);
248
249         ast_module_unref(ast_module_info->self);
250 }
251
252 /*! 
253  * \internal
254  * \brief Push an SMDI message to the back of an interface's message queue.
255  * \param iface a pointer to the interface to use.
256  * \param md_msg a pointer to the message to use.
257  */
258 static void ast_smdi_md_message_push(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
259 {
260         ast_mutex_lock(&iface->md_q_lock);
261         ao2_link(iface->md_q, md_msg);
262         ast_cond_broadcast(&iface->md_q_cond);
263         ast_mutex_unlock(&iface->md_q_lock);
264 }
265
266 /*!
267  * \internal
268  * \brief Push an SMDI message to the back of an interface's message queue.
269  * \param iface a pointer to the interface to use.
270  * \param mwi_msg a pointer to the message to use.
271  */
272 static void ast_smdi_mwi_message_push(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
273 {
274         ast_mutex_lock(&iface->mwi_q_lock);
275         ao2_link(iface->mwi_q, mwi_msg);
276         ast_cond_broadcast(&iface->mwi_q_cond);
277         ast_mutex_unlock(&iface->mwi_q_lock);
278 }
279
280 static int smdi_toggle_mwi(struct ast_smdi_interface *iface, const char *mailbox, int on)
281 {
282         FILE *file;
283         int i;
284
285         if (!(file = fopen(iface->name, "w"))) {
286                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s) for writing\n", iface->name, strerror(errno));
287                 return 1;
288         }
289
290         ao2_wrlock(iface);
291
292         fprintf(file, "%s:MWI ", on ? "OP" : "RMV");
293
294         for (i = 0; i < iface->msdstrip; i++)
295                 fprintf(file, "0");
296
297         fprintf(file, "%s!\x04", mailbox);
298
299         fclose(file);
300
301         ao2_unlock(iface);
302         ast_debug(1, "Sent MWI set message for %s on %s\n", mailbox, iface->name);
303
304         return 0;
305 }
306
307 int AST_OPTIONAL_API_NAME(ast_smdi_mwi_set)(struct ast_smdi_interface *iface, const char *mailbox)
308 {
309         return smdi_toggle_mwi(iface, mailbox, 1);
310 }
311
312 int AST_OPTIONAL_API_NAME(ast_smdi_mwi_unset)(struct ast_smdi_interface *iface, const char *mailbox)
313 {
314         return smdi_toggle_mwi(iface, mailbox, 0);
315 }
316
317 enum smdi_message_type {
318         SMDI_MWI,
319         SMDI_MD,
320 };
321
322 static inline int lock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
323 {
324         switch (type) {
325         case SMDI_MWI:
326                 return ast_mutex_lock(&iface->mwi_q_lock);
327         case SMDI_MD:   
328                 return ast_mutex_lock(&iface->md_q_lock);
329         }
330         
331         return -1;
332 }
333
334 static inline int unlock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
335 {
336         switch (type) {
337         case SMDI_MWI:
338                 return ast_mutex_unlock(&iface->mwi_q_lock);
339         case SMDI_MD:
340                 return ast_mutex_unlock(&iface->md_q_lock);
341         }
342
343         return -1;
344 }
345
346 static inline void *unlink_from_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
347 {
348         switch (type) {
349         case SMDI_MWI:
350                 return ao2_callback(iface->mwi_q, OBJ_UNLINK, NULL, NULL);
351         case SMDI_MD:
352                 return ao2_callback(iface->md_q, OBJ_UNLINK, NULL, NULL);
353         }
354
355         return NULL;
356 }
357
358 static inline struct timeval msg_timestamp(void *msg, enum smdi_message_type type)
359 {
360         struct ast_smdi_md_message *md_msg = msg;
361         struct ast_smdi_mwi_message *mwi_msg = msg;
362
363         switch (type) {
364         case SMDI_MWI:
365                 return mwi_msg->timestamp;
366         case SMDI_MD:
367                 return md_msg->timestamp;
368         }
369
370         return ast_tv(0, 0);
371 }
372
373 static void purge_old_messages(struct ast_smdi_interface *iface, enum smdi_message_type type)
374 {
375         struct timeval now = ast_tvnow();
376         long elapsed = 0;
377         void *msg;
378         
379         lock_msg_q(iface, type);
380         msg = unlink_from_msg_q(iface, type);
381         unlock_msg_q(iface, type);
382
383         /* purge old messages */
384         while (msg) {
385                 elapsed = ast_tvdiff_ms(now, msg_timestamp(msg, type));
386
387                 if (elapsed > iface->msg_expiry) {
388                         /* found an expired message */
389                         ao2_ref(msg, -1);
390                         ast_log(LOG_NOTICE, "Purged expired message from %s SMDI %s message queue.  "
391                                 "Message was %ld milliseconds too old.\n",
392                                 iface->name, (type == SMDI_MD) ? "MD" : "MWI", 
393                                 elapsed - iface->msg_expiry);
394
395                         lock_msg_q(iface, type);
396                         msg = unlink_from_msg_q(iface, type);
397                         unlock_msg_q(iface, type);
398                 } else {
399                         /* good message, put it back and return */
400                         switch (type) {
401                         case SMDI_MD:
402                                 ast_smdi_md_message_push(iface, msg);
403                                 break;
404                         case SMDI_MWI:
405                                 ast_smdi_mwi_message_push(iface, msg);
406                                 break;
407                         }
408                         ao2_ref(msg, -1);
409                         break;
410                 }
411         }
412 }
413
414 static void *smdi_msg_pop(struct ast_smdi_interface *iface, enum smdi_message_type type)
415 {
416         void *msg;
417
418         purge_old_messages(iface, type);
419
420         lock_msg_q(iface, type);
421         msg = unlink_from_msg_q(iface, type);
422         unlock_msg_q(iface, type);
423
424         return msg;
425 }
426
427 enum {
428         OPT_SEARCH_TERMINAL = (1 << 0),
429         OPT_SEARCH_NUMBER   = (1 << 1),
430 };
431
432 static void *smdi_msg_find(struct ast_smdi_interface *iface,
433         enum smdi_message_type type, const char *search_key, struct ast_flags options)
434 {
435         void *msg = NULL;
436
437         purge_old_messages(iface, type);
438
439         switch (type) {
440         case SMDI_MD:
441                 if (ast_strlen_zero(search_key)) {
442                         /* No search key provided (the code from chan_dahdi does this).
443                          * Just pop the top message off of the queue. */
444
445                         msg = ao2_callback(iface->md_q, 0, NULL, NULL);
446                 } else if (ast_test_flag(&options, OPT_SEARCH_TERMINAL)) {
447                         /* Searching by the message desk terminal */
448                         struct ast_smdi_md_message md_msg = { .name = "" };
449                         strncpy(md_msg.mesg_desk_term, search_key, SMDI_MESG_DESK_TERM_LEN);
450                         msg = ao2_find(iface->md_q, &md_msg, OBJ_SEARCH_OBJECT);
451                 } else if (ast_test_flag(&options, OPT_SEARCH_NUMBER)) {
452                         /* Searching by the message desk number */
453                         struct ast_smdi_md_message md_msg = { .name = "" };
454                         strncpy(md_msg.mesg_desk_num, search_key, SMDI_MESG_DESK_NUM_LEN);
455                         msg = ao2_find(iface->md_q, &md_msg, OBJ_SEARCH_OBJECT);
456                 } else {
457                         /* Searching by the forwarding station */
458                         msg = ao2_find(iface->md_q, search_key, OBJ_SEARCH_KEY);
459                 }
460                 break;
461         case SMDI_MWI:
462                 if (ast_strlen_zero(search_key)) {
463                         /* No search key provided (the code from chan_dahdi does this).
464                          * Just pop the top message off of the queue. */
465
466                         msg = ao2_callback(iface->mwi_q, 0, NULL, NULL);
467                 } else {
468                         msg = ao2_find(iface->mwi_q, search_key, OBJ_SEARCH_KEY);
469                 }
470                 break;
471         }
472
473         return msg;
474 }
475
476 static void *smdi_message_wait(struct ast_smdi_interface *iface, int timeout, 
477         enum smdi_message_type type, const char *search_key, struct ast_flags options)
478 {
479         struct timeval start;
480         long diff = 0;
481         void *msg;
482         ast_cond_t *cond = NULL;
483         ast_mutex_t *lock = NULL;
484
485         switch (type) {
486         case SMDI_MWI:
487                 cond = &iface->mwi_q_cond;
488                 lock = &iface->mwi_q_lock;
489                 break;
490         case SMDI_MD:
491                 cond = &iface->md_q_cond;
492                 lock = &iface->md_q_lock;
493                 break;
494         }
495
496         start = ast_tvnow();
497
498         while (diff < timeout) {
499                 struct timespec ts = { 0, };
500                 struct timeval wait;
501
502                 lock_msg_q(iface, type);
503
504                 if ((msg = smdi_msg_find(iface, type, search_key, options))) {
505                         unlock_msg_q(iface, type);
506                         return msg;
507                 }
508
509                 wait = ast_tvadd(start, ast_tv(0, timeout));
510                 ts.tv_sec = wait.tv_sec;
511                 ts.tv_nsec = wait.tv_usec * 1000;
512
513                 /* If there were no messages in the queue, then go to sleep until one
514                  * arrives. */
515
516                 ast_cond_timedwait(cond, lock, &ts);
517
518                 if ((msg = smdi_msg_find(iface, type, search_key, options))) {
519                         unlock_msg_q(iface, type);
520                         return msg;
521                 }
522
523                 unlock_msg_q(iface, type);
524
525                 /* check timeout */
526                 diff = ast_tvdiff_ms(ast_tvnow(), start);
527         }
528
529         return NULL;
530 }
531
532 struct ast_smdi_md_message * AST_OPTIONAL_API_NAME(ast_smdi_md_message_pop)(struct ast_smdi_interface *iface)
533 {
534         return smdi_msg_pop(iface, SMDI_MD);
535 }
536
537 struct ast_smdi_md_message * AST_OPTIONAL_API_NAME(ast_smdi_md_message_wait)(struct ast_smdi_interface *iface, int timeout)
538 {
539         struct ast_flags options = { 0 };
540         return smdi_message_wait(iface, timeout, SMDI_MD, NULL, options);
541 }
542
543 struct ast_smdi_mwi_message * AST_OPTIONAL_API_NAME(ast_smdi_mwi_message_pop)(struct ast_smdi_interface *iface)
544 {
545         return smdi_msg_pop(iface, SMDI_MWI);
546 }
547
548 struct ast_smdi_mwi_message * AST_OPTIONAL_API_NAME(ast_smdi_mwi_message_wait)(struct ast_smdi_interface *iface, int timeout)
549 {
550         struct ast_flags options = { 0 };
551         return smdi_message_wait(iface, timeout, SMDI_MWI, NULL, options);
552 }
553
554 struct ast_smdi_mwi_message * AST_OPTIONAL_API_NAME(ast_smdi_mwi_message_wait_station)(struct ast_smdi_interface *iface, int timeout,
555         const char *station)
556 {
557         struct ast_flags options = { 0 };
558         return smdi_message_wait(iface, timeout, SMDI_MWI, station, options);
559 }
560
561 struct ast_smdi_interface * AST_OPTIONAL_API_NAME(ast_smdi_interface_find)(const char *iface_name)
562 {
563         struct ao2_container *c;
564         struct ast_smdi_interface *iface = NULL;
565
566         c = ao2_global_obj_ref(smdi_ifaces);
567         if (c) {
568                 iface = ao2_find(c, iface_name, OBJ_SEARCH_KEY);
569                 ao2_ref(c, -1);
570         }
571
572         return iface;
573 }
574
575 /*! 
576  * \internal
577  * \brief Read an SMDI message.
578  *
579  * \param iface_p the SMDI interface to read from.
580  *
581  * This function loops and reads from and SMDI interface.  It must be stopped
582  * using pthread_cancel().
583  */
584 static void *smdi_read(void *iface_p)
585 {
586         struct ast_smdi_interface *iface = iface_p;
587         struct ast_smdi_md_message *md_msg;
588         struct ast_smdi_mwi_message *mwi_msg;
589         char c = '\0';
590         char *cp = NULL;
591         int i;
592         int start = 0;
593
594         /* read an smdi message */
595         while ((c = fgetc(iface->file))) {
596
597                 /* check if this is the start of a message */
598                 if (!start) {
599                         if (c == 'M') {
600                                 ast_debug(1, "Read an 'M' to start an SMDI message\n");
601                                 start = 1;
602                         }
603                         continue;
604                 }
605
606                 if (c == 'D') { /* MD message */
607                         start = 0;
608
609                         ast_debug(1, "Read a 'D' ... it's an MD message.\n");
610
611                         if (!(md_msg = ast_calloc(1, sizeof(*md_msg)))) {
612                                 ao2_ref(iface, -1);
613                                 return NULL;
614                         }
615
616                         md_msg = ao2_alloc(sizeof(*md_msg), NULL);
617
618                         /* read the message desk number */
619                         for (i = 0; i < sizeof(md_msg->mesg_desk_num) - 1; i++) {
620                                 md_msg->mesg_desk_num[i] = fgetc(iface->file);
621                                 ast_debug(1, "Read a '%c'\n", md_msg->mesg_desk_num[i]);
622                         }
623
624                         md_msg->mesg_desk_num[sizeof(md_msg->mesg_desk_num) - 1] = '\0';
625
626                         ast_debug(1, "The message desk number is '%s'\n", md_msg->mesg_desk_num);
627
628                         /* read the message desk terminal number */
629                         for (i = 0; i < sizeof(md_msg->mesg_desk_term) - 1; i++) {
630                                 md_msg->mesg_desk_term[i] = fgetc(iface->file);
631                                 ast_debug(1, "Read a '%c'\n", md_msg->mesg_desk_term[i]);
632                         }
633
634                         md_msg->mesg_desk_term[sizeof(md_msg->mesg_desk_term) - 1] = '\0';
635
636                         ast_debug(1, "The message desk terminal is '%s'\n", md_msg->mesg_desk_term);
637
638                         /* read the message type */
639                         md_msg->type = fgetc(iface->file);
640
641                         ast_debug(1, "Message type is '%c'\n", md_msg->type);
642
643                         /* read the forwarding station number (may be blank) */
644                         cp = &md_msg->fwd_st[0];
645                         for (i = 0; i < sizeof(md_msg->fwd_st) - 1; i++) {
646                                 if ((c = fgetc(iface->file)) == ' ') {
647                                         *cp = '\0';
648                                         ast_debug(1, "Read a space, done looking for the forwarding station\n");
649                                         break;
650                                 }
651
652                                 /* store c in md_msg->fwd_st */
653                                 if (i >= iface->msdstrip) {
654                                         ast_debug(1, "Read a '%c' and stored it in the forwarding station buffer\n", c);
655                                         *cp++ = c;
656                                 } else {
657                                         ast_debug(1, "Read a '%c', but didn't store it in the fwd station buffer, because of the msdstrip setting (%d < %d)\n", c, i, iface->msdstrip);
658                                 }
659                         }
660
661                         /* make sure the value is null terminated, even if this truncates it */
662                         md_msg->fwd_st[sizeof(md_msg->fwd_st) - 1] = '\0';
663                         cp = NULL;
664
665                         ast_debug(1, "The forwarding station is '%s'\n", md_msg->fwd_st);
666
667                         /* Put the fwd_st in the name field so that we can use ao2_find to look
668                          * up a message on this field */
669                         ast_copy_string(md_msg->name, md_msg->fwd_st, sizeof(md_msg->name));
670
671                         /* read the calling station number (may be blank) */
672                         cp = &md_msg->calling_st[0];
673                         for (i = 0; i < sizeof(md_msg->calling_st) - 1; i++) {
674                                 if (!isdigit((c = fgetc(iface->file)))) {
675                                         *cp = '\0';
676                                         ast_debug(1, "Read a '%c', but didn't store it in the calling station buffer because it's not a digit\n", c);
677                                         if (c == ' ') {
678                                                 /* Don't break on a space.  We may read the space before the calling station
679                                                  * here if the forwarding station buffer filled up. */
680                                                 i--; /* We're still on the same character */
681                                                 continue;
682                                         }
683                                         break;
684                                 }
685
686                                 /* store c in md_msg->calling_st */
687                                 if (i >= iface->msdstrip) {
688                                         ast_debug(1, "Read a '%c' and stored it in the calling station buffer\n", c);
689                                         *cp++ = c;
690                                 } else {
691                                         ast_debug(1, "Read a '%c', but didn't store it in the calling station buffer, because of the msdstrip setting (%d < %d)\n", c, i, iface->msdstrip);
692                                 }
693                         }
694
695                         /* make sure the value is null terminated, even if this truncates it */
696                         md_msg->calling_st[sizeof(md_msg->calling_st) - 1] = '\0';
697                         cp = NULL;
698
699                         ast_debug(1, "The calling station is '%s'\n", md_msg->calling_st);
700
701                         /* add the message to the message queue */
702                         md_msg->timestamp = ast_tvnow();
703                         ast_smdi_md_message_push(iface, md_msg);
704                         ast_debug(1, "Received SMDI MD message on %s\n", iface->name);
705
706                         ao2_ref(md_msg, -1);
707
708                 } else if (c == 'W') { /* MWI message */
709                         start = 0;
710
711                         ast_debug(1, "Read a 'W', it's an MWI message. (No more debug coming for MWI messages)\n");
712
713                         if (!(mwi_msg = ast_calloc(1, sizeof(*mwi_msg)))) {
714                                 ao2_ref(iface, -1);
715                                 return NULL;
716                         }
717
718                         mwi_msg = ao2_alloc(sizeof(*mwi_msg), NULL);
719
720                         /* discard the 'I' (from 'MWI') */
721                         fgetc(iface->file);
722                         
723                         /* read the forwarding station number (may be blank) */
724                         cp = &mwi_msg->fwd_st[0];
725                         for (i = 0; i < sizeof(mwi_msg->fwd_st) - 1; i++) {
726                                 if ((c = fgetc(iface->file)) == ' ') {
727                                         *cp = '\0';
728                                         break;
729                                 }
730
731                                 /* store c in md_msg->fwd_st */
732                                 if (i >= iface->msdstrip)
733                                         *cp++ = c;
734                         }
735
736                         /* make sure the station number is null terminated, even if this will truncate it */
737                         mwi_msg->fwd_st[sizeof(mwi_msg->fwd_st) - 1] = '\0';
738                         cp = NULL;
739
740                         /* Put the fwd_st in the name field so that we can use ao2_find to look
741                          * up a message on this field */
742                         ast_copy_string(mwi_msg->name, mwi_msg->fwd_st, sizeof(mwi_msg->name));
743
744                         /* read the mwi failure cause */
745                         for (i = 0; i < sizeof(mwi_msg->cause) - 1; i++)
746                                 mwi_msg->cause[i] = fgetc(iface->file);
747
748                         mwi_msg->cause[sizeof(mwi_msg->cause) - 1] = '\0';
749
750                         /* add the message to the message queue */
751                         mwi_msg->timestamp = ast_tvnow();
752                         ast_smdi_mwi_message_push(iface, mwi_msg);
753                         ast_debug(1, "Received SMDI MWI message on %s\n", iface->name);
754
755                         ao2_ref(mwi_msg, -1);
756                 } else {
757                         ast_log(LOG_ERROR, "Unknown SMDI message type received on %s (M%c).\n", iface->name, c);
758                         start = 0;
759                 }
760         }
761
762         ast_log(LOG_ERROR, "Error reading from SMDI interface %s, stopping listener thread\n", iface->name);
763         ao2_ref(iface, -1);
764         return NULL;
765 }
766
767 static void destroy_mailbox_mapping(struct mailbox_mapping *mm)
768 {
769         ast_string_field_free_memory(mm);
770         ao2_ref(mm->iface, -1);
771         ast_free(mm);
772 }
773
774 static void destroy_all_mailbox_mappings(void)
775 {
776         struct mailbox_mapping *mm;
777
778         ast_mutex_lock(&mwi_monitor.lock);
779         while ((mm = AST_LIST_REMOVE_HEAD(&mwi_monitor.mailbox_mappings, entry)))
780                 destroy_mailbox_mapping(mm);
781         ast_mutex_unlock(&mwi_monitor.lock);
782 }
783
784 static void append_mailbox_mapping(struct ast_variable *var, struct ast_smdi_interface *iface)
785 {
786         struct mailbox_mapping *mm;
787         char *mailbox, *context;
788
789         if (!(mm = ast_calloc_with_stringfields(1, struct mailbox_mapping, 32)))
790                 return;
791
792         ast_string_field_set(mm, smdi, var->name);
793
794         context = ast_strdupa(var->value);
795         mailbox = strsep(&context, "@");
796         if (ast_strlen_zero(context))
797                 context = "default";
798
799         ast_string_field_set(mm, mailbox, mailbox);
800         ast_string_field_set(mm, context, context);
801
802         mm->iface = ao2_bump(iface);
803
804         ast_mutex_lock(&mwi_monitor.lock);
805         AST_LIST_INSERT_TAIL(&mwi_monitor.mailbox_mappings, mm, entry);
806         ast_mutex_unlock(&mwi_monitor.lock);
807 }
808
809 /*!
810  * \note Called with the mwi_monitor.lock locked
811  */
812 static void poll_mailbox(struct mailbox_mapping *mm)
813 {
814         char buf[1024];
815         unsigned int state;
816
817         snprintf(buf, sizeof(buf), "%s@%s", mm->mailbox, mm->context);
818
819         state = !!ast_app_has_voicemail(mm->mailbox, NULL);
820
821         if (state != mm->cur_state) {
822                 if (state)
823                         ast_smdi_mwi_set(mm->iface, mm->smdi);
824                 else
825                         ast_smdi_mwi_unset(mm->iface, mm->smdi);
826
827                 mm->cur_state = state;
828         }
829 }
830
831 static void *mwi_monitor_handler(void *data)
832 {
833         while (!mwi_monitor.stop) {
834                 struct timespec ts = { 0, };
835                 struct timeval polltime;
836                 struct mailbox_mapping *mm;
837
838                 ast_mutex_lock(&mwi_monitor.lock);
839
840                 mwi_monitor.last_poll = ast_tvnow();
841
842                 AST_LIST_TRAVERSE(&mwi_monitor.mailbox_mappings, mm, entry)
843                         poll_mailbox(mm);
844
845                 /* Sleep up to the configured polling interval.  Allow unload_module()
846                  * to signal us to wake up and exit. */
847                 polltime = ast_tvadd(mwi_monitor.last_poll, ast_tv(mwi_monitor.polling_interval, 0));
848                 ts.tv_sec = polltime.tv_sec;
849                 ts.tv_nsec = polltime.tv_usec * 1000;
850                 ast_cond_timedwait(&mwi_monitor.cond, &mwi_monitor.lock, &ts);
851
852                 ast_mutex_unlock(&mwi_monitor.lock);
853         }
854
855         return NULL;
856 }
857
858 static int smdi_mwi_q_cmp_fn(void *obj, void *data, int flags)
859 {
860         struct ast_smdi_mwi_message *msg = obj;
861         char *str = data;
862         return !strcmp(msg->name, str) ? CMP_MATCH | CMP_STOP : 0;
863 }
864
865 static int smdi_md_q_cmp_fn(void *obj, void *arg, int flags)
866 {
867         const struct ast_smdi_md_message *msg = obj;
868         const struct ast_smdi_md_message *search_msg = arg;
869         const char *search_key = arg;
870         int cmp = 0;
871
872         switch (flags & OBJ_SEARCH_MASK) {
873         case OBJ_SEARCH_OBJECT:
874                 if (!ast_strlen_zero(search_msg->mesg_desk_num)) {
875                         cmp = strcmp(msg->mesg_desk_num, search_msg->mesg_desk_num);
876                 }
877                 if (!ast_strlen_zero(search_msg->mesg_desk_term)) {
878                         cmp |= strcmp(msg->mesg_desk_term, search_msg->mesg_desk_term);
879                 }
880                 break;
881         case OBJ_SEARCH_KEY:
882                 cmp = strcmp(msg->name, search_key);
883                 break;
884         }
885
886         if (cmp) {
887                 return 0;
888         }
889
890         return CMP_MATCH;
891 }
892
893 static struct ast_smdi_interface *alloc_smdi_interface(void)
894 {
895         struct ast_smdi_interface *iface;
896
897         if (!(iface = ao2_alloc(sizeof(*iface), smdi_interface_destroy))) {
898                 return NULL;
899         }
900
901         iface->md_q = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, smdi_md_q_cmp_fn);
902         iface->mwi_q = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, smdi_mwi_q_cmp_fn);
903
904         ast_mutex_init(&iface->md_q_lock);
905         ast_cond_init(&iface->md_q_cond, NULL);
906
907         ast_mutex_init(&iface->mwi_q_lock);
908         ast_cond_init(&iface->mwi_q_cond, NULL);
909
910         return iface;
911 }
912
913 static int smdi_ifaces_cmp_fn(void *obj, void *data, int flags)
914 {
915         struct ast_smdi_interface *iface = obj;
916
917         char *str = data;
918         return !strcmp(iface->name, str) ? CMP_MATCH | CMP_STOP : 0;
919 }
920
921 /*!
922  * \internal
923  * \brief Load and reload SMDI configuration.
924  * \param reload this should be 1 if we are reloading and 0 if not.
925  *
926  * This function loads/reloads the SMDI configuration and starts and stops
927  * interfaces accordingly.
928  *
929  * \return zero on success, -1 on failure, and 1 if no smdi interfaces were started.
930  */
931 static int smdi_load(int reload)
932 {
933         struct ast_config *conf;
934         struct ast_variable *v;
935         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
936         int res = 0;
937         RAII_VAR(struct ao2_container *, new_ifaces, NULL, ao2_cleanup);
938         RAII_VAR(struct ao2_container *, old_ifaces, ao2_global_obj_ref(smdi_ifaces), ao2_cleanup);
939         struct ast_smdi_interface *mailbox_iface = NULL;
940
941         /* Config options */
942         speed_t baud_rate = B9600;     /* 9600 baud rate */
943         tcflag_t paritybit = PARENB;   /* even parity checking */
944         tcflag_t charsize = CS7;       /* seven bit characters */
945         int stopbits = 0;              /* One stop bit */
946         
947         int msdstrip = 0;              /* strip zero digits */
948         long msg_expiry = SMDI_MSG_EXPIRY_TIME;
949
950         if (!(conf = ast_config_load(config_file, config_flags)) || conf == CONFIG_STATUS_FILEINVALID) {
951                 if (reload)
952                         ast_log(LOG_NOTICE, "Unable to reload config %s: SMDI untouched\n", config_file);
953                 else
954                         ast_log(LOG_NOTICE, "Unable to load config %s: SMDI disabled\n", config_file);
955                 return 1;
956         } else if (conf == CONFIG_STATUS_FILEUNCHANGED)
957                 return 0;
958
959         new_ifaces = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, smdi_ifaces_cmp_fn);
960         for (v = ast_variable_browse(conf, "interfaces"); v; v = v->next) {
961                 RAII_VAR(struct ast_smdi_interface *, iface, NULL, ao2_cleanup);
962
963                 if (!strcasecmp(v->name, "baudrate")) {
964                         if (!strcasecmp(v->value, "9600"))
965                                 baud_rate = B9600;
966                         else if (!strcasecmp(v->value, "4800"))
967                                 baud_rate = B4800;
968                         else if (!strcasecmp(v->value, "2400"))
969                                 baud_rate = B2400;
970                         else if (!strcasecmp(v->value, "1200"))
971                                 baud_rate = B1200;
972                         else {
973                                 ast_log(LOG_NOTICE, "Invalid baud rate '%s' specified in %s (line %d), using default\n", v->value, config_file, v->lineno);
974                                 baud_rate = B9600;
975                         }
976                 } else if (!strcasecmp(v->name, "msdstrip")) {
977                         if (!sscanf(v->value, "%30d", &msdstrip)) {
978                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
979                                 msdstrip = 0;
980                         } else if (0 > msdstrip || msdstrip > 9) {
981                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
982                                 msdstrip = 0;
983                         }
984                 } else if (!strcasecmp(v->name, "msgexpirytime")) {
985                         if (!sscanf(v->value, "%30ld", &msg_expiry)) {
986                                 ast_log(LOG_NOTICE, "Invalid msgexpirytime value in %s (line %d), using default\n", config_file, v->lineno);
987                                 msg_expiry = SMDI_MSG_EXPIRY_TIME;
988                         }
989                 } else if (!strcasecmp(v->name, "paritybit")) {
990                         if (!strcasecmp(v->value, "even"))
991                                 paritybit = PARENB;
992                         else if (!strcasecmp(v->value, "odd"))
993                                 paritybit = PARENB | PARODD;
994                         else if (!strcasecmp(v->value, "none"))
995                                 paritybit = ~PARENB;
996                         else {
997                                 ast_log(LOG_NOTICE, "Invalid parity bit setting in %s (line %d), using default\n", config_file, v->lineno);
998                                 paritybit = PARENB;
999                         }
1000                 } else if (!strcasecmp(v->name, "charsize")) {
1001                         if (!strcasecmp(v->value, "7"))
1002                                 charsize = CS7;
1003                         else if (!strcasecmp(v->value, "8"))
1004                                 charsize = CS8;
1005                         else {
1006                                 ast_log(LOG_NOTICE, "Invalid character size setting in %s (line %d), using default\n", config_file, v->lineno);
1007                                 charsize = CS7;
1008                         }
1009                 } else if (!strcasecmp(v->name, "twostopbits")) {
1010                         stopbits = ast_true(v->name);
1011                 } else if (!strcasecmp(v->name, "smdiport")) {
1012                         if (reload) {
1013                                 /* we are reloading, check if we are already
1014                                  * monitoring this interface, if we are we do
1015                                  * not want to start it again.  This also has
1016                                  * the side effect of not updating different
1017                                  * setting for the serial port, but it should
1018                                  * be trivial to rewrite this section so that
1019                                  * options on the port are changed without
1020                                  * restarting the interface.  Or the interface
1021                                  * could be restarted with out emptying the
1022                                  * queue. */
1023                                 if ((iface = ao2_find(old_ifaces, v->value, OBJ_SEARCH_KEY))) {
1024                                         ast_log(LOG_NOTICE, "SMDI interface %s already running, not restarting\n", iface->name);
1025                                         ao2_link(new_ifaces, iface);
1026                                         continue;
1027                                 }
1028                         }
1029                         
1030                         if (!(iface = alloc_smdi_interface()))
1031                                 continue;
1032
1033                         ast_copy_string(iface->name, v->value, sizeof(iface->name));
1034
1035                         iface->thread = AST_PTHREADT_NULL;
1036
1037                         if (!(iface->file = fopen(iface->name, "r"))) {
1038                                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s)\n", iface->name, strerror(errno));
1039                                 continue;
1040                         }
1041
1042                         iface->fd = fileno(iface->file);
1043
1044                         /* Set the proper attributes for our serial port. */
1045
1046                         /* get the current attributes from the port */
1047                         if (tcgetattr(iface->fd, &iface->mode)) {
1048                                 ast_log(LOG_ERROR, "Error getting atributes of %s (%s)\n", iface->name, strerror(errno));
1049                                 continue;
1050                         }
1051
1052                         /* set the desired speed */
1053                         if (cfsetispeed(&iface->mode, baud_rate) || cfsetospeed(&iface->mode, baud_rate)) {
1054                                 ast_log(LOG_ERROR, "Error setting baud rate on %s (%s)\n", iface->name, strerror(errno));
1055                                 continue;
1056                         }
1057                         
1058                         /* set the stop bits */
1059                         if (stopbits)
1060                                 iface->mode.c_cflag = iface->mode.c_cflag | CSTOPB;   /* set two stop bits */
1061                         else
1062                                 iface->mode.c_cflag = iface->mode.c_cflag & ~CSTOPB;  /* set one stop bit */
1063                         
1064                         /* set the parity */
1065                         iface->mode.c_cflag = (iface->mode.c_cflag & ~PARENB & ~PARODD) | paritybit;
1066                         
1067                         /* set the character size */
1068                         iface->mode.c_cflag = (iface->mode.c_cflag & ~CSIZE) | charsize;
1069                         
1070                         /* commit the desired attributes */
1071                         if (tcsetattr(iface->fd, TCSAFLUSH, &iface->mode)) {
1072                                 ast_log(LOG_ERROR, "Error setting attributes on %s (%s)\n", iface->name, strerror(errno));
1073                                 continue;
1074                         }
1075
1076                         /* set the msdstrip */
1077                         iface->msdstrip = msdstrip;
1078
1079                         /* set the message expiry time */
1080                         iface->msg_expiry = msg_expiry;
1081
1082                         /* start the listener thread */
1083                         ast_verb(3, "Starting SMDI monitor thread for %s\n", iface->name);
1084                         if (ast_pthread_create_background(&iface->thread, NULL, smdi_read, iface)) {
1085                                 ast_log(LOG_ERROR, "Error starting SMDI monitor thread for %s\n", iface->name);
1086                                 continue;
1087                         }
1088
1089                         ao2_link(new_ifaces, iface);
1090                         ast_module_ref(ast_module_info->self);
1091                 } else {
1092                         ast_log(LOG_NOTICE, "Ignoring unknown option %s in %s\n", v->name, config_file);
1093                 }
1094         }
1095
1096         destroy_all_mailbox_mappings();
1097         mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
1098
1099         for (v = ast_variable_browse(conf, "mailboxes"); v; v = v->next) {
1100                 if (!strcasecmp(v->name, "smdiport")) {
1101                         ao2_cleanup(mailbox_iface);
1102
1103                         if (!(mailbox_iface = ao2_find(new_ifaces, v->value, OBJ_SEARCH_KEY))) {
1104                                 ast_log(LOG_NOTICE, "SMDI interface %s not found\n", v->value);
1105                                 continue;
1106                         }
1107                 } else if (!strcasecmp(v->name, "pollinginterval")) {
1108                         if (sscanf(v->value, "%30u", &mwi_monitor.polling_interval) != 1) {
1109                                 ast_log(LOG_ERROR, "Invalid value for pollinginterval: %s\n", v->value);
1110                                 mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
1111                         }
1112                 } else {
1113                         if (!mailbox_iface) {
1114                                 ast_log(LOG_ERROR, "Mailbox mapping ignored, no valid SMDI interface specified in mailboxes section\n");
1115                                 continue;
1116                         }
1117                         append_mailbox_mapping(v, mailbox_iface);
1118                 }
1119         }
1120         ao2_cleanup(mailbox_iface);
1121
1122         ast_config_destroy(conf);
1123
1124         ao2_global_obj_replace_unref(smdi_ifaces, new_ifaces);
1125
1126         if (!AST_LIST_EMPTY(&mwi_monitor.mailbox_mappings) && mwi_monitor.thread == AST_PTHREADT_NULL
1127                 && ast_pthread_create_background(&mwi_monitor.thread, NULL, mwi_monitor_handler, NULL)) {
1128                 ast_log(LOG_ERROR, "Failed to start MWI monitoring thread.  This module will not operate.\n");
1129                 return -1;
1130         }
1131
1132         if (ao2_container_count(new_ifaces)) {
1133                 res = 1;
1134         }
1135         
1136         return res;
1137 }
1138
1139 struct smdi_msg_datastore {
1140         unsigned int id;
1141         struct ast_smdi_interface *iface;
1142         struct ast_smdi_md_message *md_msg;
1143 };
1144
1145 static void smdi_msg_datastore_destroy(void *data)
1146 {
1147         struct smdi_msg_datastore *smd = data;
1148
1149         ao2_cleanup(smd->iface);
1150         ao2_cleanup(smd->md_msg);
1151
1152         ast_free(smd);
1153 }
1154
1155 static const struct ast_datastore_info smdi_msg_datastore_info = {
1156         .type = "SMDIMSG",
1157         .destroy = smdi_msg_datastore_destroy,
1158 };
1159
1160 static int smdi_msg_id;
1161
1162 /*! In milliseconds */
1163 #define SMDI_RETRIEVE_TIMEOUT_DEFAULT 3000
1164
1165 AST_APP_OPTIONS(smdi_msg_ret_options, BEGIN_OPTIONS
1166         AST_APP_OPTION('t', OPT_SEARCH_TERMINAL),
1167         AST_APP_OPTION('n', OPT_SEARCH_NUMBER),
1168 END_OPTIONS );
1169
1170 static int smdi_msg_retrieve_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
1171 {
1172         struct ast_module_user *u;
1173         AST_DECLARE_APP_ARGS(args,
1174                 AST_APP_ARG(port);
1175                 AST_APP_ARG(search_key);
1176                 AST_APP_ARG(timeout);
1177                 AST_APP_ARG(options);
1178         );
1179         struct ast_flags options = { 0 };
1180         unsigned int timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
1181         int res = -1;
1182         char *parse = NULL;
1183         struct smdi_msg_datastore *smd = NULL;
1184         struct ast_datastore *datastore = NULL;
1185         struct ast_smdi_interface *iface = NULL;
1186         struct ast_smdi_md_message *md_msg = NULL;
1187
1188         u = ast_module_user_add(chan);
1189
1190         if (ast_strlen_zero(data)) {
1191                 ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE requires an argument\n");
1192                 goto return_error;
1193         }
1194
1195         if (!chan) {
1196                 ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE must be used with a channel\n");
1197                 goto return_error;
1198         }
1199
1200         ast_autoservice_start(chan);
1201
1202         parse = ast_strdupa(data);
1203         AST_STANDARD_APP_ARGS(args, parse);
1204
1205         if (ast_strlen_zero(args.port) || ast_strlen_zero(args.search_key)) {
1206                 ast_log(LOG_ERROR, "Invalid arguments provided to SMDI_MSG_RETRIEVE\n");
1207                 goto return_error;
1208         }
1209
1210         if (!(iface = ast_smdi_interface_find(args.port))) {
1211                 ast_log(LOG_ERROR, "SMDI port '%s' not found\n", args.port);
1212                 goto return_error;
1213         }
1214
1215         if (!ast_strlen_zero(args.options)) {
1216                 ast_app_parse_options(smdi_msg_ret_options, &options, NULL, args.options);
1217         }
1218
1219         if (!ast_strlen_zero(args.timeout)) {
1220                 if (sscanf(args.timeout, "%30u", &timeout) != 1) {
1221                         ast_log(LOG_ERROR, "'%s' is not a valid timeout\n", args.timeout);
1222                         timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
1223                 }
1224         }
1225
1226         if (!(md_msg = smdi_message_wait(iface, timeout, SMDI_MD, args.search_key, options))) {
1227                 ast_log(LOG_WARNING, "No SMDI message retrieved for search key '%s' after "
1228                         "waiting %u ms.\n", args.search_key, timeout);
1229                 goto return_error;
1230         }
1231
1232         if (!(smd = ast_calloc(1, sizeof(*smd))))
1233                 goto return_error;
1234
1235         smd->iface = ao2_bump(iface);
1236         smd->md_msg = ao2_bump(md_msg);
1237         smd->id = ast_atomic_fetchadd_int((int *) &smdi_msg_id, 1);
1238         snprintf(buf, len, "%u", smd->id);
1239
1240         if (!(datastore = ast_datastore_alloc(&smdi_msg_datastore_info, buf)))
1241                 goto return_error;
1242
1243         datastore->data = smd;
1244
1245         ast_channel_lock(chan);
1246         ast_channel_datastore_add(chan, datastore);
1247         ast_channel_unlock(chan);
1248
1249         res = 0;
1250
1251 return_error:
1252         ao2_cleanup(iface);
1253         ao2_cleanup(md_msg);
1254
1255         if (smd && !datastore)
1256                 smdi_msg_datastore_destroy(smd);
1257
1258         if (parse)
1259                 ast_autoservice_stop(chan);
1260
1261         ast_module_user_remove(u);
1262
1263         return res;
1264 }
1265
1266 static int smdi_msg_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
1267 {
1268         struct ast_module_user *u;
1269         int res = -1;
1270         AST_DECLARE_APP_ARGS(args,
1271                 AST_APP_ARG(id);
1272                 AST_APP_ARG(component);
1273         );
1274         char *parse;
1275         struct ast_datastore *datastore = NULL;
1276         struct smdi_msg_datastore *smd = NULL;
1277
1278         u = ast_module_user_add(chan);
1279
1280         if (!chan) {
1281                 ast_log(LOG_ERROR, "SMDI_MSG can not be called without a channel\n");
1282                 goto return_error;
1283         }
1284
1285         if (ast_strlen_zero(data)) {
1286                 ast_log(LOG_WARNING, "SMDI_MSG requires an argument\n");
1287                 goto return_error;
1288         }
1289
1290         parse = ast_strdupa(data);
1291         AST_STANDARD_APP_ARGS(args, parse);
1292
1293         if (ast_strlen_zero(args.id)) {
1294                 ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
1295                 goto return_error;
1296         }
1297
1298         if (ast_strlen_zero(args.component)) {
1299                 ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
1300                 goto return_error;
1301         }
1302
1303         ast_channel_lock(chan);
1304         datastore = ast_channel_datastore_find(chan, &smdi_msg_datastore_info, args.id);
1305         ast_channel_unlock(chan);
1306         
1307         if (!datastore) {
1308                 ast_log(LOG_WARNING, "No SMDI message found for message ID '%s'\n", args.id);
1309                 goto return_error;
1310         }
1311
1312         smd = datastore->data;
1313
1314         if (!strcasecmp(args.component, "number")) {
1315                 ast_copy_string(buf, smd->md_msg->mesg_desk_num, len);
1316         } else if (!strcasecmp(args.component, "terminal")) {
1317                 ast_copy_string(buf, smd->md_msg->mesg_desk_term, len);
1318         } else if (!strcasecmp(args.component, "station")) {
1319                 ast_copy_string(buf, smd->md_msg->fwd_st, len);
1320         } else if (!strcasecmp(args.component, "callerid")) {
1321                 ast_copy_string(buf, smd->md_msg->calling_st, len);
1322         } else if (!strcasecmp(args.component, "type")) {
1323                 snprintf(buf, len, "%c", smd->md_msg->type);
1324         } else {
1325                 ast_log(LOG_ERROR, "'%s' is not a valid message component for SMDI_MSG\n",
1326                         args.component);
1327                 goto return_error;
1328         }
1329
1330         res = 0;
1331
1332 return_error:
1333         ast_module_user_remove(u);
1334
1335         return res;
1336 }
1337
1338 static struct ast_custom_function smdi_msg_retrieve_function = {
1339         .name = "SMDI_MSG_RETRIEVE",
1340         .read = smdi_msg_retrieve_read,
1341 };
1342
1343 static struct ast_custom_function smdi_msg_function = {
1344         .name = "SMDI_MSG",
1345         .read = smdi_msg_read,
1346 };
1347
1348 static int _unload_module(int fromload);
1349
1350 /*!
1351  * \brief Load the module
1352  *
1353  * Module loading including tests for configuration or dependencies.
1354  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
1355  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
1356  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the 
1357  * configuration file or other non-critical problem return 
1358  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
1359  */
1360 static int load_module(void)
1361 {
1362         int res;
1363         smdi_loaded = 1;
1364
1365         ast_mutex_init(&mwi_monitor.lock);
1366         ast_cond_init(&mwi_monitor.cond, NULL);
1367
1368         /* load the config and start the listener threads*/
1369         res = smdi_load(0);
1370         if (res < 0) {
1371                 _unload_module(1);
1372                 return AST_MODULE_LOAD_DECLINE;
1373         } else if (res == 1) {
1374                 _unload_module(1);
1375                 ast_log(LOG_NOTICE, "No SMDI interfaces are available to listen on, not starting SMDI listener.\n");
1376                 return AST_MODULE_LOAD_DECLINE;
1377         }
1378
1379         ast_custom_function_register(&smdi_msg_retrieve_function);
1380         ast_custom_function_register(&smdi_msg_function);
1381
1382         return AST_MODULE_LOAD_SUCCESS;
1383 }
1384
1385 static int _unload_module(int fromload)
1386 {
1387         if (!smdi_loaded) {
1388                 return 0;
1389         }
1390
1391         ao2_global_obj_release(smdi_ifaces);
1392
1393         destroy_all_mailbox_mappings();
1394
1395         ast_mutex_lock(&mwi_monitor.lock);
1396         mwi_monitor.stop = 1;
1397         ast_cond_signal(&mwi_monitor.cond);
1398         ast_mutex_unlock(&mwi_monitor.lock);
1399
1400         if (mwi_monitor.thread != AST_PTHREADT_NULL) {
1401                 pthread_join(mwi_monitor.thread, NULL);
1402         }
1403
1404         if (!fromload) {
1405                 ast_custom_function_unregister(&smdi_msg_retrieve_function);
1406                 ast_custom_function_unregister(&smdi_msg_function);
1407         }
1408
1409         smdi_loaded = 0;
1410         return 0;
1411 }
1412
1413 static int unload_module(void)
1414 {
1415         return _unload_module(0);
1416 }
1417
1418 static int reload(void)
1419 {
1420         int res;
1421
1422         res = smdi_load(1);
1423
1424         if (res < 0) {
1425                 return res;
1426         } else if (res == 1) {
1427                 ast_log(LOG_WARNING, "No SMDI interfaces were specified to listen on, not starting SDMI listener.\n");
1428                 return 0;
1429         } else
1430                 return 0;
1431 }
1432
1433 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Simplified Message Desk Interface (SMDI) Resource",
1434         .support_level = AST_MODULE_SUPPORT_CORE,
1435         .load = load_module,
1436         .unload = unload_module,
1437         .reload = reload,
1438         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
1439 );