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