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