remove a duplicate include
[asterisk/asterisk.git] / res / res_smdi.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Copyright (C) 2005-2006, Digium, Inc.
5  *
6  * Matthew A. Nicholson <mnicholson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief SMDI support for Asterisk.
22  * \author Matthew A. Nicholson <mnicholson@digium.com>
23  */
24
25 #include "asterisk.h"
26
27 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <termios.h>
33 #include <sys/time.h>
34 #include <time.h>
35 #include <ctype.h>
36
37 #include "asterisk/module.h"
38 #include "asterisk/lock.h"
39 #include "asterisk/utils.h"
40 #include "asterisk/smdi.h"
41 #include "asterisk/config.h"
42 #include "asterisk/astobj.h"
43 #include "asterisk/io.h"
44 #include "asterisk/logger.h"
45 #include "asterisk/options.h"
46
47 /* Message expiry time in milliseconds */
48 #define SMDI_MSG_EXPIRY_TIME    30000 /* 30 seconds */
49
50 static const char config_file[] = "smdi.conf";
51
52 static void ast_smdi_md_message_push(struct ast_smdi_interface *iface, struct ast_smdi_md_message *msg);
53 static void ast_smdi_mwi_message_push(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *msg);
54
55 static void *smdi_read(void *iface_p);
56 static int smdi_load(int reload);
57
58 struct module_symbols *me;      /* initialized in load_module() */
59
60 /*! \brief SMDI interface container. */
61 struct ast_smdi_interface_container {
62         ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_interface);
63 } smdi_ifaces;
64
65 /*! 
66  * \internal
67  * \brief Push an SMDI message to the back of an interface's message queue.
68  * \param iface a pointer to the interface to use.
69  * \param md_msg a pointer to the message to use.
70  */
71 static void ast_smdi_md_message_push(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
72 {
73         ASTOBJ_CONTAINER_LINK_END(&iface->md_q, md_msg);
74 }
75
76 /*!
77  * \internal
78  * \brief Push an SMDI message to the back of an interface's message queue.
79  * \param iface a pointer to the interface to use.
80  * \param mwi_msg a pointer to the message to use.
81  */
82 static void ast_smdi_mwi_message_push(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
83 {
84         ASTOBJ_CONTAINER_LINK_END(&iface->mwi_q, mwi_msg);
85 }
86
87 /*!
88  * \brief Set the MWI indicator for a mailbox.
89  * \param iface the interface to use.
90  * \param mailbox the mailbox to use.
91  */
92 int ast_smdi_mwi_set(struct ast_smdi_interface *iface, const char *mailbox)
93 {
94         FILE *file;
95         int i;
96         
97         file = fopen(iface->name, "w");
98         if(!file) {
99                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s) for writing\n", iface->name, strerror(errno));
100                 return 1;
101         }       
102
103         ASTOBJ_WRLOCK(iface);
104
105         fprintf(file, "OP:MWI ");
106
107         for(i = 0; i < iface->msdstrip; i++)
108            fprintf(file, "0");
109
110         fprintf(file, "%s!\x04", mailbox);
111         fclose(file);
112
113         ASTOBJ_UNLOCK(iface);
114         if (option_debug)
115                 ast_log(LOG_DEBUG, "Sent MWI set message for %s on %s\n", mailbox, iface->name);
116         return 0;
117 }
118
119 /*! 
120  * \brief Unset the MWI indicator for a mailbox.
121  * \param iface the interface to use.
122  * \param mailbox the mailbox to use.
123  */
124 int ast_smdi_mwi_unset(struct ast_smdi_interface *iface, const char *mailbox)
125 {
126         FILE *file;
127         int i;
128         
129         file = fopen(iface->name, "w");
130         if(!file) {
131                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s) for writing\n", iface->name, strerror(errno));
132                 return 1;
133         }       
134
135         ASTOBJ_WRLOCK(iface);
136
137         fprintf(file, "RMV:MWI ");
138
139         for(i = 0; i < iface->msdstrip; i++)
140            fprintf(file, "0");
141
142         fprintf(file, "%s!\x04", mailbox);
143         fclose(file);
144
145         ASTOBJ_UNLOCK(iface);
146         if (option_debug)
147                 ast_log(LOG_DEBUG, "Sent MWI unset message for %s on %s\n", mailbox, iface->name);
148         return 0;
149 }
150
151 /*!
152  * \brief Put an SMDI message back in the front of the queue.
153  * \param iface a pointer to the interface to use.
154  * \param md_msg a pointer to the message to use.
155  *
156  * This function puts a message back in the front of the specified queue.  It
157  * should be used if a message was popped but is not going to be processed for
158  * some reason, and the message needs to be returned to the queue.
159  */
160 void ast_smdi_md_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
161 {
162         ASTOBJ_CONTAINER_LINK_START(&iface->md_q, md_msg);
163 }
164
165 /*!
166  * \brief Put an SMDI message back in the front of the queue.
167  * \param iface a pointer to the interface to use.
168  * \param mwi_msg a pointer to the message to use.
169  *
170  * This function puts a message back in the front of the specified queue.  It
171  * should be used if a message was popped but is not going to be processed for
172  * some reason, and the message needs to be returned to the queue.
173  */
174 void ast_smdi_mwi_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
175 {
176         ASTOBJ_CONTAINER_LINK_START(&iface->mwi_q, mwi_msg);
177 }
178
179 /*! 
180  * \brief Get the next SMDI message from the queue.
181  * \param iface a pointer to the interface to use.
182  *
183  * This function pulls the first unexpired message from the SMDI message queue
184  * on the specified interface.  It will purge all expired SMDI messages before
185  * returning.
186  *
187  * \return the next SMDI message, or NULL if there were no pending messages.
188  */
189 struct ast_smdi_md_message *ast_smdi_md_message_pop(struct ast_smdi_interface *iface)
190 {
191         struct ast_smdi_md_message *md_msg = ASTOBJ_CONTAINER_UNLINK_START(&iface->md_q);
192         struct timeval now;
193         long elapsed = 0;
194
195         /* purge old messages */
196         now = ast_tvnow();
197         while (md_msg) {
198                 elapsed = ast_tvdiff_ms(now, md_msg->timestamp);
199
200                 if (elapsed > iface->msg_expiry) {
201                         /* found an expired message */
202                         ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
203                         ast_log(LOG_NOTICE, "Purged expired message from %s SMDI MD message queue.  Message was %ld milliseconds too old.\n",
204                                 iface->name, elapsed - iface->msg_expiry);
205                         md_msg = ASTOBJ_CONTAINER_UNLINK_START(&iface->md_q);
206                 }
207                 else {
208                         /* good message, return it */
209                         break;
210                 }
211         }
212
213         return md_msg;
214 }
215
216 /*!
217  * \brief Get the next SMDI message from the queue.
218  * \param iface a pointer to the interface to use.
219  * \param timeout the time to wait before returning in milliseconds.
220  *
221  * This function pulls a message from the SMDI message queue on the specified
222  * interface.  If no message is available this function will wait the specified
223  * amount of time before returning.
224  *
225  * \return the next SMDI message, or NULL if there were no pending messages and
226  * the timeout has expired.
227  */
228 extern struct ast_smdi_md_message *ast_smdi_md_message_wait(struct ast_smdi_interface *iface, int timeout)
229 {
230         struct timeval start;
231         long diff = 0;
232         struct ast_smdi_md_message *msg;
233
234         start = ast_tvnow();
235         while (diff < timeout) {
236
237                 if ((msg = ast_smdi_md_message_pop(iface)))
238                         return msg;
239
240                 /* check timeout */
241                 diff = ast_tvdiff_ms(ast_tvnow(), start);
242         }
243
244         return (ast_smdi_md_message_pop(iface));
245 }
246
247 /*!
248  * \brief Get the next SMDI message from the queue.
249  * \param iface a pointer to the interface to use.
250  *
251  * This function pulls the first unexpired message from the SMDI message queue
252  * on the specified interface.  It will purge all expired SMDI messages before
253  * returning.
254  *
255  * \return the next SMDI message, or NULL if there were no pending messages.
256  */
257 extern struct ast_smdi_mwi_message *ast_smdi_mwi_message_pop(struct ast_smdi_interface *iface)
258 {
259         struct ast_smdi_mwi_message *mwi_msg = ASTOBJ_CONTAINER_UNLINK_START(&iface->mwi_q);
260         struct timeval now;
261         long elapsed = 0;
262
263         /* purge old messages */
264         now = ast_tvnow();
265         while (mwi_msg) {
266                 elapsed = ast_tvdiff_ms(now, mwi_msg->timestamp);
267
268                 if (elapsed > iface->msg_expiry) {
269                         /* found an expired message */
270                         ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
271                         ast_log(LOG_NOTICE, "Purged expired message from %s SMDI MWI message queue.  Message was %ld milliseconds too old.\n",
272                                 iface->name, elapsed - iface->msg_expiry);
273                         mwi_msg = ASTOBJ_CONTAINER_UNLINK_START(&iface->mwi_q);
274                 }
275                 else {
276                         /* good message, return it */
277                         break;
278                 }
279         }
280
281         return mwi_msg;
282 }
283
284 /*!
285  * \brief Get the next SMDI message from the queue.
286  * \param iface a pointer to the interface to use.
287  * \param timeout the time to wait before returning in milliseconds.
288  *
289  * This function pulls a message from the SMDI message queue on the specified
290  * interface.  If no message is available this function will wait the specified
291  * amount of time before returning.
292  *
293  * \return the next SMDI message, or NULL if there were no pending messages and
294  * the timeout has expired.
295  */
296 extern struct ast_smdi_mwi_message *ast_smdi_mwi_message_wait(struct ast_smdi_interface *iface, int timeout)
297 {
298         struct timeval start;
299         long diff = 0;
300         struct ast_smdi_mwi_message *msg;
301
302         start = ast_tvnow();
303         while (diff < timeout) {
304
305                 if ((msg = ast_smdi_mwi_message_pop(iface)))
306                         return msg;
307
308                 /* check timeout */
309                 diff = ast_tvdiff_ms(ast_tvnow(), start);
310         }
311
312         return (ast_smdi_mwi_message_pop(iface));
313 }
314
315 /*!
316  * \brief Find an SMDI interface with the specified name.
317  * \param iface_name the name/port of the interface to search for.
318  *
319  * \return a pointer to the interface located or NULL if none was found.  This
320  * actually returns an ASTOBJ reference and should be released using
321  * #ASTOBJ_UNREF(iface, ast_smdi_interface_destroy).
322  */
323 extern struct ast_smdi_interface *ast_smdi_interface_find(const char *iface_name)
324 {
325         return (ASTOBJ_CONTAINER_FIND(&smdi_ifaces, iface_name));
326 }
327
328 /*! \brief Read an SMDI message.
329  *
330  * \param iface_p the SMDI interface to read from.
331  *
332  * This function loops and reads from and SMDI interface.  It must be stopped
333  * using pthread_cancel().
334  */
335 static void *smdi_read(void *iface_p)
336 {
337         struct ast_smdi_interface *iface = iface_p;
338         struct ast_smdi_md_message *md_msg;
339         struct ast_smdi_mwi_message *mwi_msg;
340         char c = '\0';
341         char *cp = NULL;
342         int i;
343         int start = 0;
344                 
345         /* read an smdi message */
346         while ((c = fgetc(iface->file))) {
347
348                 /* check if this is the start of a message */
349                 if (!start) {
350                         if (c == 'M')
351                                 start = 1;
352                 }
353                 else { /* Determine if this is a MD or MWI message */
354                         if(c == 'D') { /* MD message */
355                                 start = 0;
356
357                                 if (!(md_msg = ast_calloc(1, sizeof(*md_msg)))) {
358                                         ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
359                                         return NULL;
360                                 }
361                                 
362                                 ASTOBJ_INIT(md_msg);
363
364                                 /* read the message desk number */
365                                 for(i = 0; i < SMDI_MESG_DESK_NUM_LEN; i++)
366                                         md_msg->mesg_desk_num[i] = fgetc(iface->file);
367
368                                 md_msg->mesg_desk_num[SMDI_MESG_DESK_NUM_LEN] = '\0';
369
370                                 /* read the message desk terminal number */
371                                 for(i = 0; i < SMDI_MESG_DESK_TERM_LEN; i++)
372                                         md_msg->mesg_desk_term[i] = fgetc(iface->file);
373
374                                 md_msg->mesg_desk_term[SMDI_MESG_DESK_TERM_LEN] = '\0';
375
376                                 /* read the message type */
377                                 md_msg->type = fgetc(iface->file);
378                            
379                                 /* read the forwarding station number (may be blank) */
380                                 cp = &md_msg->fwd_st[0];
381                                 for (i = 0; i < SMDI_MAX_STATION_NUM_LEN + 1; i++) {
382                                         if((c = fgetc(iface->file)) == ' ') {
383                                                 *cp = '\0';
384                                                 break;
385                                         }
386
387                                         /* store c in md_msg->fwd_st */
388                                         if( i >= iface->msdstrip)
389                                                 *cp++ = c;
390                                 }
391
392                                 /* make sure the value is null terminated, even if this truncates it */
393                                 md_msg->fwd_st[SMDI_MAX_STATION_NUM_LEN] = '\0';
394                                 cp = NULL;
395                                 
396                                 /* read the calling station number (may be blank) */
397                                 cp = &md_msg->calling_st[0];
398                                 for (i = 0; i < SMDI_MAX_STATION_NUM_LEN + 1; i++) {
399                                         if (!isdigit((c = fgetc(iface->file)))) {
400                                                 *cp = '\0';
401                                                 break;
402                                         }
403
404                                         /* store c in md_msg->calling_st */
405                                         if (i >= iface->msdstrip)
406                                                 *cp++ = c;
407                                 }
408
409                                 /* make sure the value is null terminated, even if this truncates it */
410                                 md_msg->calling_st[SMDI_MAX_STATION_NUM_LEN] = '\0';
411                                 cp = NULL;
412
413                                 /* add the message to the message queue */
414                                 md_msg->timestamp = ast_tvnow();
415                                 ast_smdi_md_message_push(iface, md_msg);
416                                 if (option_debug)
417                                         ast_log(LOG_DEBUG, "Recieved SMDI MD message on %s\n", iface->name);
418                                 
419                                 ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
420
421                         } else if(c == 'W') { /* MWI message */
422                                 start = 0;
423
424                                 if (!(mwi_msg = ast_calloc(1, sizeof(*mwi_msg)))) {
425                                         ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
426                                         return NULL;
427                                 }
428
429                                 ASTOBJ_INIT(mwi_msg);
430
431                                 /* discard the 'I' (from 'MWI') */
432                                 fgetc(iface->file);
433                                 
434                                 /* read the forwarding station number (may be blank) */
435                                 cp = &mwi_msg->fwd_st[0];
436                                 for (i = 0; i < SMDI_MAX_STATION_NUM_LEN + 1; i++) {
437                                         if ((c = fgetc(iface->file)) == ' ') {
438                                                 *cp = '\0';
439                                                 break;
440                                         }
441
442                                         /* store c in md_msg->fwd_st */
443                                         if (i >= iface->msdstrip)
444                                                 *cp++ = c;
445                                 }
446
447                                 /* make sure the station number is null terminated, even if this will truncate it */
448                                 mwi_msg->fwd_st[SMDI_MAX_STATION_NUM_LEN] = '\0';
449                                 cp = NULL;
450                                 
451                                 /* read the mwi failure cause */
452                                 for (i = 0; i < SMDI_MWI_FAIL_CAUSE_LEN; i++)
453                                         mwi_msg->cause[i] = fgetc(iface->file);
454
455                                 mwi_msg->cause[SMDI_MWI_FAIL_CAUSE_LEN] = '\0';
456
457                                 /* add the message to the message queue */
458                                 mwi_msg->timestamp = ast_tvnow();
459                                 ast_smdi_mwi_message_push(iface, mwi_msg);
460                                 if (option_debug)
461                                         ast_log(LOG_DEBUG, "Recieved SMDI MWI message on %s\n", iface->name);
462                                 
463                                 ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
464                         } else {
465                                 ast_log(LOG_ERROR, "Unknown SMDI message type recieved on %s (M%c).\n", iface->name, c);
466                                 start = 0;
467                         }
468                 }
469         }
470
471         ast_log(LOG_ERROR, "Error reading from SMDI interface %s, stopping listener thread\n", iface->name);
472         ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
473         return NULL;
474 }
475
476 /*! \brief ast_smdi_md_message destructor. */
477 void ast_smdi_md_message_destroy(struct ast_smdi_md_message *msg)
478 {
479         free(msg);
480 }
481
482 /*! \brief ast_smdi_mwi_message destructor. */
483 void ast_smdi_mwi_message_destroy(struct ast_smdi_mwi_message *msg)
484 {
485         free(msg);
486 }
487
488 /*! \brief ast_smdi_interface destructor. */
489 void ast_smdi_interface_destroy(struct ast_smdi_interface *iface)
490 {
491         if (iface->thread != AST_PTHREADT_NULL && iface->thread != AST_PTHREADT_STOP) {
492                 pthread_cancel(iface->thread);
493                 pthread_join(iface->thread, NULL);
494         }
495         
496         iface->thread = AST_PTHREADT_STOP;
497         
498         if(iface->file) 
499                 fclose(iface->file);
500         
501         ASTOBJ_CONTAINER_DESTROYALL(&iface->md_q, ast_smdi_md_message_destroy);
502         ASTOBJ_CONTAINER_DESTROYALL(&iface->mwi_q, ast_smdi_mwi_message_destroy);
503         ASTOBJ_CONTAINER_DESTROY(&iface->md_q);
504         ASTOBJ_CONTAINER_DESTROY(&iface->mwi_q);
505         free(iface);
506
507         ast_module_unref(ast_module_info->self);
508 }
509
510 /*!
511  * \internal
512  * \brief Load and reload SMDI configuration.
513  * \param reload this should be 1 if we are reloading and 0 if not.
514  *
515  * This function loads/reloads the SMDI configuration and starts and stops
516  * interfaces accordingly.
517  *
518  * \return zero on success, -1 on failure, and 1 if no smdi interfaces were started.
519  */
520 static int smdi_load(int reload)
521 {
522         struct ast_config *conf;
523         struct ast_variable *v;
524         struct ast_smdi_interface *iface = NULL;
525         int res = 0;
526
527         /* Config options */
528         speed_t baud_rate = B9600;     /* 9600 baud rate */
529         tcflag_t paritybit = PARENB;   /* even parity checking */
530         tcflag_t charsize = CS7;       /* seven bit characters */
531         int stopbits = 0;              /* One stop bit */
532         
533         int msdstrip = 0;              /* strip zero digits */
534         long msg_expiry = SMDI_MSG_EXPIRY_TIME;
535         
536         conf = ast_config_load(config_file);
537
538         if (!conf) {
539                 if (reload)
540                         ast_log(LOG_NOTICE, "Unable to reload config %s: SMDI untouched\n", config_file);
541                 else
542                         ast_log(LOG_NOTICE, "Unable to load config %s: SMDI disabled\n", config_file);
543                 return 1;
544         }
545
546         /* Mark all interfaces that we are listening on.  We will unmark them
547          * as we find them in the config file, this way we know any interfaces
548          * still marked after we have finished parsing the config file should
549          * be stopped.
550          */
551         if (reload)
552                 ASTOBJ_CONTAINER_MARKALL(&smdi_ifaces);
553
554         for (v = ast_variable_browse(conf, "interfaces"); v; v = v->next) {
555                 if (!strcasecmp(v->name, "baudrate")) {
556                         if (!strcasecmp(v->value, "9600"))
557                                 baud_rate = B9600;
558                         else if(!strcasecmp(v->value, "4800"))
559                                 baud_rate = B4800;
560                         else if(!strcasecmp(v->value, "2400"))
561                                 baud_rate = B2400;
562                         else if(!strcasecmp(v->value, "1200"))
563                                 baud_rate = B1200;
564                         else {
565                                 ast_log(LOG_NOTICE, "Invalid baud rate '%s' specified in %s (line %d), using default\n", v->value, config_file, v->lineno);
566                                 baud_rate = B9600;
567                         }
568                 } else if (!strcasecmp(v->name, "msdstrip")) {
569                         if (!sscanf(v->value, "%d", &msdstrip)) {
570                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
571                                 msdstrip = 0;
572                         } else if (0 > msdstrip || msdstrip > 9) {
573                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
574                                 msdstrip = 0;
575                         }
576                 } else if (!strcasecmp(v->name, "msgexpirytime")) {
577                         if (!sscanf(v->value, "%ld", &msg_expiry)) {
578                                 ast_log(LOG_NOTICE, "Invalid msgexpirytime value in %s (line %d), using default\n", config_file, v->lineno);
579                                 msg_expiry = SMDI_MSG_EXPIRY_TIME;
580                         }
581                 } else if (!strcasecmp(v->name, "paritybit")) {
582                         if (!strcasecmp(v->value, "even"))
583                                 paritybit = PARENB;
584                         else if (!strcasecmp(v->value, "odd"))
585                                 paritybit = PARENB | PARODD;
586                         else if (!strcasecmp(v->value, "none"))
587                                 paritybit = ~PARENB;
588                         else {
589                                 ast_log(LOG_NOTICE, "Invalid parity bit setting in %s (line %d), using default\n", config_file, v->lineno);
590                                 paritybit = PARENB;
591                         }
592                 } else if (!strcasecmp(v->name, "charsize")) {
593                         if (!strcasecmp(v->value, "7"))
594                                 charsize = CS7;
595                         else if (!strcasecmp(v->value, "8"))
596                                 charsize = CS8;
597                         else {
598                                 ast_log(LOG_NOTICE, "Invalid character size setting in %s (line %d), using default\n", config_file, v->lineno);
599                                 charsize = CS7;
600                         }
601                 } else if (!strcasecmp(v->name, "twostopbits")) {
602                         stopbits = ast_true(v->name);
603                 } else if (!strcasecmp(v->name, "smdiport")) {
604                         if (reload) {
605                                 /* we are reloading, check if we are already
606                                  * monitoring this interface, if we are we do
607                                  * not want to start it again.  This also has
608                                  * the side effect of not updating different
609                                  * setting for the serial port, but it should
610                                  * be trivial to rewrite this section so that
611                                  * options on the port are changed without
612                                  * restarting the interface.  Or the interface
613                                  * could be restarted with out emptying the
614                                  * queue. */
615                                 if ((iface = ASTOBJ_CONTAINER_FIND(&smdi_ifaces, v->value))) {
616                                         ast_log(LOG_NOTICE, "SMDI interface %s already running, not restarting\n", iface->name);
617                                         ASTOBJ_UNMARK(iface);
618                                         ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
619                                         continue;
620                                 }
621                         }
622                                                         
623                         if (!(iface = ast_calloc(1, sizeof(*iface))))
624                                 continue;
625
626                         ASTOBJ_INIT(iface);
627                         ASTOBJ_CONTAINER_INIT(&iface->md_q);
628                         ASTOBJ_CONTAINER_INIT(&iface->mwi_q);
629
630                         ast_copy_string(iface->name, v->value, sizeof(iface->name));
631
632                         if (!(iface->file = fopen(iface->name, "r"))) {
633                                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s)\n", iface->name, strerror(errno));
634                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
635                                 continue;
636                         }
637
638                         iface->fd = fileno(iface->file);
639
640                         /* Set the proper attributes for our serial port. */
641
642                         /* get the current attributes from the port */
643                         if (tcgetattr(iface->fd, &iface->mode)) {
644                                 ast_log(LOG_ERROR, "Error getting atributes of %s (%s)\n", iface->name, strerror(errno));
645                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
646                                 continue;
647                         }
648
649                         /* set the desired speed */
650                         if (cfsetispeed(&iface->mode, baud_rate) || cfsetospeed(&iface->mode, baud_rate)) {
651                                 ast_log(LOG_ERROR, "Error setting baud rate on %s (%s)\n", iface->name, strerror(errno));
652                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
653                                 continue;
654                         }
655                         
656                         /* set the stop bits */
657                         if (stopbits)
658                            iface->mode.c_cflag = iface->mode.c_cflag | CSTOPB;   /* set two stop bits */
659                         else
660                            iface->mode.c_cflag = iface->mode.c_cflag & ~CSTOPB;  /* set one stop bit */
661
662                         /* set the parity */
663                         iface->mode.c_cflag = (iface->mode.c_cflag & ~PARENB & ~PARODD) | paritybit;
664
665                         /* set the character size */
666                         iface->mode.c_cflag = (iface->mode.c_cflag & ~CSIZE) | charsize;
667                         
668                         /* commit the desired attributes */
669                         if (tcsetattr(iface->fd, TCSAFLUSH, &iface->mode)) {
670                                 ast_log(LOG_ERROR, "Error setting attributes on %s (%s)\n", iface->name, strerror(errno));
671                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
672                                 continue;
673                         }
674
675                         /* set the msdstrip */
676                         iface->msdstrip = msdstrip;
677
678                         /* set the message expiry time */
679                         iface->msg_expiry = msg_expiry;
680
681                         /* start the listner thread */
682                         if (option_verbose > 2)
683                                 ast_verbose(VERBOSE_PREFIX_3 "Starting SMDI monitor thread for %s\n", iface->name);
684                         if (ast_pthread_create_background(&iface->thread, NULL, smdi_read, iface)) {
685                                 ast_log(LOG_ERROR, "Error starting SMDI monitor thread for %s\n", iface->name);
686                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
687                                 continue;
688                         }
689
690                         ASTOBJ_CONTAINER_LINK(&smdi_ifaces, iface);
691                         ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
692                         ast_module_ref(ast_module_info->self);
693                 } else {
694                         ast_log(LOG_NOTICE, "Ignoring unknown option %s in %s\n", v->name, config_file);
695                 }
696         }
697         ast_config_destroy(conf);
698
699         /* Prune any interfaces we should no longer monitor. */
700         if (reload)
701                 ASTOBJ_CONTAINER_PRUNE_MARKED(&smdi_ifaces, ast_smdi_interface_destroy);
702         
703         ASTOBJ_CONTAINER_RDLOCK(&smdi_ifaces);
704         /* TODO: this is bad, we need an ASTOBJ method for this! */
705         if (!smdi_ifaces.head)
706                 res = 1;
707         ASTOBJ_CONTAINER_UNLOCK(&smdi_ifaces);
708                         
709         return res;
710 }
711
712 static int load_module(void)
713 {
714         int res;
715
716         /* initialize our containers */
717         memset(&smdi_ifaces, 0, sizeof(smdi_ifaces));
718         ASTOBJ_CONTAINER_INIT(&smdi_ifaces);
719
720         /* load the config and start the listener threads*/
721         res = smdi_load(0);
722         if (res < 0) {
723                 return res;
724         } else if (res == 1) {
725                 ast_log(LOG_WARNING, "No SMDI interfaces are available to listen on, not starting SDMI listener.\n");
726                 return AST_MODULE_LOAD_DECLINE;;
727         } else
728                 return 0;
729 }
730
731 static int unload_module(void)
732 {
733         /* this destructor stops any running smdi_read threads */
734         ASTOBJ_CONTAINER_DESTROYALL(&smdi_ifaces, ast_smdi_interface_destroy);
735         ASTOBJ_CONTAINER_DESTROY(&smdi_ifaces);
736
737         return 0;
738 }
739
740 static int reload(void)
741 {
742         int res;
743
744         res = smdi_load(1);
745
746         if (res < 0) {
747                 return res;
748         } else if (res == 1) {
749                 ast_log(LOG_WARNING, "No SMDI interfaces were specified to listen on, not starting SDMI listener.\n");
750                 return 0;
751         } else
752                 return 0;
753 }
754
755 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Simplified Message Desk Interface (SMDI) Resource",
756                 .load = load_module,
757                 .unload = unload_module,
758                 .reload = reload,
759                );