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