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