res/res_smdi.c

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