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