res/res_smdi.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Copyright (C) 2005-2008, Digium, Inc.
   5  *
   6  * Matthew A. Nicholson <mnicholson@digium.com>
   7  * Russell Bryant <russell@digium.com>
   8  *
   9  * See http://www.asterisk.org for more information about
  10  * the Asterisk project. Please do not directly contact
  11  * any of the maintainers of this project for assistance;
  12  * the project provides a web site, mailing lists and IRC
  13  * channels for your use.
  14  *
  15  * This program is free software, distributed under the terms of
  16  * the GNU General Public License Version 2. See the LICENSE file
  17  * at the top of the source tree.
  18  */
  19
  20 /*!
  21  * \file
  22  * \brief SMDI support for Asterisk.
  23  * \author Matthew A. Nicholson <mnicholson@digium.com>
  24  * \author Russell Bryant <russell@digium.com>
  25  *
  26  * Here is a useful mailing list post that describes SMDI protocol details:
  27  * \ref http://lists.digium.com/pipermail/asterisk-dev/2003-June/000884.html
  28  *
  29  * \todo This module currently has its own mailbox monitoring thread.  This should
  30  * be converted to MWI subscriptions and just let the optional global voicemail
  31  * polling thread handle it.
  32  */
  33
  34 #include "asterisk.h"
  35
  36 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  37
  38 #include <termios.h>
  39 #include <sys/time.h>
  40 #include <time.h>
  41 #include <ctype.h>
  42
  43 #include "asterisk/module.h"
  44 #include "asterisk/lock.h"
  45 #include "asterisk/utils.h"
  46 #include "asterisk/smdi.h"
  47 #include "asterisk/config.h"
  48 #include "asterisk/astobj.h"
  49 #include "asterisk/io.h"
  50 #include "asterisk/stringfields.h"
  51 #include "asterisk/linkedlists.h"
  52 #include "asterisk/app.h"
  53 #include "asterisk/pbx.h"
  54 #include "asterisk/channel.h"
  55
  56 /* Message expiry time in milliseconds */
  57 #define SMDI_MSG_EXPIRY_TIME    30000 /* 30 seconds */
  58
  59 static const char config_file[] = "smdi.conf";
  60
  61 /*! \brief SMDI message desk message queue. */
  62 struct ast_smdi_md_queue {
  63         ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_md_message);
  64 };
  65
  66 /*! \brief SMDI message waiting indicator message queue. */
  67 struct ast_smdi_mwi_queue {
  68         ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_mwi_message);
  69 };
  70
  71 struct ast_smdi_interface {
  72         ASTOBJ_COMPONENTS_FULL(struct ast_smdi_interface, SMDI_MAX_FILENAME_LEN, 1);
  73         struct ast_smdi_md_queue md_q;
  74         ast_mutex_t md_q_lock;
  75         ast_cond_t md_q_cond;
  76         struct ast_smdi_mwi_queue mwi_q;
  77         ast_mutex_t mwi_q_lock;
  78         ast_cond_t mwi_q_cond;
  79         FILE *file;
  80         int fd;
  81         pthread_t thread;
  82         struct termios mode;
  83         int msdstrip;
  84         long msg_expiry;
  85 };
  86
  87 /*! \brief SMDI interface container. */
  88 struct ast_smdi_interface_container {
  89         ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_interface);
  90 } smdi_ifaces;
  91
  92 /*! \brief A mapping between an SMDI mailbox ID and an Asterisk mailbox */
  93 struct mailbox_mapping {
  94         /*! This is the current state of the mailbox.  It is simply on or
  95          *  off to indicate if there are messages waiting or not. */
  96         unsigned int cur_state:1;
  97         /*! A Pointer to the appropriate SMDI interface */
  98         struct ast_smdi_interface *iface;
  99         AST_DECLARE_STRING_FIELDS(
 100                 /*! The Name of the mailbox for the SMDI link. */
 101                 AST_STRING_FIELD(smdi);
 102                 /*! The name of the mailbox on the Asterisk side */
 103                 AST_STRING_FIELD(mailbox);
 104                 /*! The name of the voicemail context in use */
 105                 AST_STRING_FIELD(context);
 106         );
 107         AST_LIST_ENTRY(mailbox_mapping) entry;
 108 };
 109
 110 /*! 10 seconds */
 111 #define DEFAULT_POLLING_INTERVAL 10
 112
 113 /*! \brief Data that gets used by the SMDI MWI monitoring thread */
 114 static struct {
 115         /*! The thread ID */
 116         pthread_t thread;
 117         ast_mutex_t lock;
 118         ast_cond_t cond;
 119         /*! A list of mailboxes that need to be monitored */
 120         AST_LIST_HEAD_NOLOCK(, mailbox_mapping) mailbox_mappings;
 121         /*! Polling Interval for checking mailbox status */
 122         unsigned int polling_interval;
 123         /*! Set to 1 to tell the polling thread to stop */
 124         unsigned int stop:1;
 125         /*! The time that the last poll began */
 126         struct timeval last_poll;
 127 } mwi_monitor = {
 128         .thread = AST_PTHREADT_NULL,
 129 };
 130
 131 static void ast_smdi_interface_destroy(struct ast_smdi_interface *iface)
 132 {
 133         if (iface->thread != AST_PTHREADT_NULL && iface->thread != AST_PTHREADT_STOP) {
 134                 pthread_cancel(iface->thread);
 135                 pthread_join(iface->thread, NULL);
 136         }
 137
 138         iface->thread = AST_PTHREADT_STOP;
 139
 140         if (iface->file)
 141                 fclose(iface->file);
 142
 143         ASTOBJ_CONTAINER_DESTROYALL(&iface->md_q, ast_smdi_md_message_destroy);
 144         ASTOBJ_CONTAINER_DESTROYALL(&iface->mwi_q, ast_smdi_mwi_message_destroy);
 145         ASTOBJ_CONTAINER_DESTROY(&iface->md_q);
 146         ASTOBJ_CONTAINER_DESTROY(&iface->mwi_q);
 147
 148         ast_mutex_destroy(&iface->md_q_lock);
 149         ast_cond_destroy(&iface->md_q_cond);
 150
 151         ast_mutex_destroy(&iface->mwi_q_lock);
 152         ast_cond_destroy(&iface->mwi_q_cond);
 153
 154         free(iface);
 155
 156         ast_module_unref(ast_module_info->self);
 157 }
 158
 159 void ast_smdi_interface_unref(struct ast_smdi_interface *iface)
 160 {
 161         ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 162 }
 163
 164 /*!
 165  * \internal
 166  * \brief Push an SMDI message to the back of an interface's message queue.
 167  * \param iface a pointer to the interface to use.
 168  * \param md_msg a pointer to the message to use.
 169  */
 170 static void ast_smdi_md_message_push(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
 171 {
 172         ast_mutex_lock(&iface->md_q_lock);
 173         ASTOBJ_CONTAINER_LINK_END(&iface->md_q, md_msg);
 174         ast_cond_broadcast(&iface->md_q_cond);
 175         ast_mutex_unlock(&iface->md_q_lock);
 176 }
 177
 178 /*!
 179  * \internal
 180  * \brief Push an SMDI message to the back of an interface's message queue.
 181  * \param iface a pointer to the interface to use.
 182  * \param mwi_msg a pointer to the message to use.
 183  */
 184 static void ast_smdi_mwi_message_push(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
 185 {
 186         ast_mutex_lock(&iface->mwi_q_lock);
 187         ASTOBJ_CONTAINER_LINK_END(&iface->mwi_q, mwi_msg);
 188         ast_cond_broadcast(&iface->mwi_q_cond);
 189         ast_mutex_unlock(&iface->mwi_q_lock);
 190 }
 191
 192 static int smdi_toggle_mwi(struct ast_smdi_interface *iface, const char *mailbox, int on)
 193 {
 194         FILE *file;
 195         int i;
 196
 197         if (!(file = fopen(iface->name, "w"))) {
 198                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s) for writing\n", iface->name, strerror(errno));
 199                 return 1;
 200         }
 201
 202         ASTOBJ_WRLOCK(iface);
 203
 204         fprintf(file, "%s:MWI ", on ? "OP" : "RMV");
 205
 206         for (i = 0; i < iface->msdstrip; i++)
 207                 fprintf(file, "0");
 208
 209         fprintf(file, "%s!\x04", mailbox);
 210
 211         fclose(file);
 212
 213         ASTOBJ_UNLOCK(iface);
 214         ast_debug(1, "Sent MWI set message for %s on %s\n", mailbox, iface->name);
 215
 216         return 0;
 217 }
 218
 219 int ast_smdi_mwi_set(struct ast_smdi_interface *iface, const char *mailbox)
 220 {
 221         return smdi_toggle_mwi(iface, mailbox, 1);
 222 }
 223
 224 int ast_smdi_mwi_unset(struct ast_smdi_interface *iface, const char *mailbox)
 225 {
 226         return smdi_toggle_mwi(iface, mailbox, 0);
 227 }
 228
 229 void ast_smdi_md_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
 230 {
 231         ast_mutex_lock(&iface->md_q_lock);
 232         ASTOBJ_CONTAINER_LINK_START(&iface->md_q, md_msg);
 233         ast_cond_broadcast(&iface->md_q_cond);
 234         ast_mutex_unlock(&iface->md_q_lock);
 235 }
 236
 237 void ast_smdi_mwi_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
 238 {
 239         ast_mutex_lock(&iface->mwi_q_lock);
 240         ASTOBJ_CONTAINER_LINK_START(&iface->mwi_q, mwi_msg);
 241         ast_cond_broadcast(&iface->mwi_q_cond);
 242         ast_mutex_unlock(&iface->mwi_q_lock);
 243 }
 244
 245 enum smdi_message_type {
 246         SMDI_MWI,
 247         SMDI_MD,
 248 };
 249
 250 static inline int lock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
 251 {
 252         switch (type) {
 253         case SMDI_MWI:
 254                 return ast_mutex_lock(&iface->mwi_q_lock);
 255         case SMDI_MD:
 256                 return ast_mutex_lock(&iface->md_q_lock);
 257         }
 258
 259         return -1;
 260 }
 261
 262 static inline int unlock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
 263 {
 264         switch (type) {
 265         case SMDI_MWI:
 266                 return ast_mutex_unlock(&iface->mwi_q_lock);
 267         case SMDI_MD:
 268                 return ast_mutex_unlock(&iface->md_q_lock);
 269         }
 270
 271         return -1;
 272 }
 273
 274 static inline void *unlink_from_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
 275 {
 276         switch (type) {
 277         case SMDI_MWI:
 278                 return ASTOBJ_CONTAINER_UNLINK_START(&iface->mwi_q);
 279         case SMDI_MD:
 280                 return ASTOBJ_CONTAINER_UNLINK_START(&iface->md_q);
 281         }
 282         return NULL;
 283 }
 284
 285 static inline struct timeval msg_timestamp(void *msg, enum smdi_message_type type)
 286 {
 287         struct ast_smdi_md_message *md_msg = msg;
 288         struct ast_smdi_mwi_message *mwi_msg = msg;
 289
 290         switch (type) {
 291         case SMDI_MWI:
 292                 return mwi_msg->timestamp;
 293         case SMDI_MD:
 294                 return md_msg->timestamp;
 295         }
 296
 297         return ast_tv(0, 0);
 298 }
 299
 300 static inline void unref_msg(void *msg, enum smdi_message_type type)
 301 {
 302         struct ast_smdi_md_message *md_msg = msg;
 303         struct ast_smdi_mwi_message *mwi_msg = msg;
 304
 305         switch (type) {
 306         case SMDI_MWI:
 307                 ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
 308         case SMDI_MD:
 309                 ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
 310         }
 311 }
 312
 313 static void purge_old_messages(struct ast_smdi_interface *iface, enum smdi_message_type type)
 314 {
 315         struct timeval now = ast_tvnow();
 316         long elapsed = 0;
 317         void *msg;
 318
 319         lock_msg_q(iface, type);
 320         msg = unlink_from_msg_q(iface, type);
 321         unlock_msg_q(iface, type);
 322
 323         /* purge old messages */
 324         while (msg) {
 325                 elapsed = ast_tvdiff_ms(now, msg_timestamp(msg, type));
 326
 327                 if (elapsed > iface->msg_expiry) {
 328                         /* found an expired message */
 329                         unref_msg(msg, type);
 330                         ast_log(LOG_NOTICE, "Purged expired message from %s SMDI %s message queue.  "
 331                                 "Message was %ld milliseconds too old.\n",
 332                                 iface->name, (type == SMDI_MD) ? "MD" : "MWI",
 333                                 elapsed - iface->msg_expiry);
 334
 335                         lock_msg_q(iface, type);
 336                         msg = unlink_from_msg_q(iface, type);
 337                         unlock_msg_q(iface, type);
 338                 } else {
 339                         /* good message, put it back and return */
 340                         switch (type) {
 341                         case SMDI_MD:
 342                                 ast_smdi_md_message_push(iface, msg);
 343                                 break;
 344                         case SMDI_MWI:
 345                                 ast_smdi_mwi_message_push(iface, msg);
 346                                 break;
 347                         }
 348                         unref_msg(msg, type);
 349                         break;
 350                 }
 351         }
 352 }
 353
 354 static void *smdi_msg_pop(struct ast_smdi_interface *iface, enum smdi_message_type type)
 355 {
 356         void *msg;
 357
 358         purge_old_messages(iface, type);
 359
 360         lock_msg_q(iface, type);
 361         msg = unlink_from_msg_q(iface, type);
 362         unlock_msg_q(iface, type);
 363
 364         return msg;
 365 }
 366
 367 enum {
 368         OPT_SEARCH_TERMINAL = (1 << 0),
 369         OPT_SEARCH_NUMBER   = (1 << 1),
 370 };
 371
 372 static void *smdi_msg_find(struct ast_smdi_interface *iface,
 373         enum smdi_message_type type, const char *search_key, struct ast_flags options)
 374 {
 375         void *msg = NULL;
 376
 377         purge_old_messages(iface, type);
 378
 379         switch (type) {
 380         case SMDI_MD:
 381                 if (ast_test_flag(&options, OPT_SEARCH_TERMINAL)) {
 382                         struct ast_smdi_md_message *md_msg = NULL;
 383
 384                         /* Searching by the message desk terminal */
 385
 386                         ASTOBJ_CONTAINER_TRAVERSE(&iface->md_q, !md_msg, do {
 387                                 if (!strcasecmp(iterator->mesg_desk_term, search_key))
 388                                         md_msg = ASTOBJ_REF(iterator);
 389                         } while (0); );
 390
 391                         msg = md_msg;
 392                 } else if (ast_test_flag(&options, OPT_SEARCH_NUMBER)) {
 393                         struct ast_smdi_md_message *md_msg = NULL;
 394
 395                         /* Searching by the message desk number */
 396
 397                         ASTOBJ_CONTAINER_TRAVERSE(&iface->md_q, !md_msg, do {
 398                                 if (!strcasecmp(iterator->mesg_desk_num, search_key))
 399                                         md_msg = ASTOBJ_REF(iterator);
 400                         } while (0); );
 401
 402                         msg = md_msg;
 403                 } else {
 404                         /* Searching by the forwarding station */
 405                         msg = ASTOBJ_CONTAINER_FIND(&iface->md_q, search_key);
 406                 }
 407                 break;
 408         case SMDI_MWI:
 409                 msg = ASTOBJ_CONTAINER_FIND(&iface->mwi_q, search_key);
 410                 break;
 411         }
 412
 413         return msg;
 414 }
 415
 416 static void *smdi_message_wait(struct ast_smdi_interface *iface, int timeout,
 417         enum smdi_message_type type, const char *search_key, struct ast_flags options)
 418 {
 419         struct timeval start;
 420         long diff = 0;
 421         void *msg;
 422         ast_cond_t *cond = NULL;
 423         ast_mutex_t *lock = NULL;
 424
 425         switch (type) {
 426         case SMDI_MWI:
 427                 cond = &iface->mwi_q_cond;
 428                 lock = &iface->mwi_q_lock;
 429                 break;
 430         case SMDI_MD:
 431                 cond = &iface->md_q_cond;
 432                 lock = &iface->md_q_lock;
 433                 break;
 434         }
 435
 436         start = ast_tvnow();
 437
 438         while (diff < timeout) {
 439                 struct timespec ts = { 0, };
 440                 struct timeval tv;
 441
 442                 lock_msg_q(iface, type);
 443
 444                 if ((msg = smdi_msg_find(iface, type, search_key, options))) {
 445                         unlock_msg_q(iface, type);
 446                         return msg;
 447                 }
 448
 449                 tv = ast_tvadd(start, ast_tv(0, timeout));
 450                 ts.tv_sec = tv.tv_sec;
 451                 ts.tv_nsec = tv.tv_usec * 1000;
 452
 453                 /* If there were no messages in the queue, then go to sleep until one
 454                  * arrives. */
 455
 456                 ast_cond_timedwait(cond, lock, &ts);
 457
 458                 if ((msg = smdi_msg_find(iface, type, search_key, options))) {
 459                         unlock_msg_q(iface, type);
 460                         return msg;
 461                 }
 462
 463                 unlock_msg_q(iface, type);
 464
 465                 /* check timeout */
 466                 diff = ast_tvdiff_ms(ast_tvnow(), start);
 467         }
 468
 469         return NULL;
 470 }
 471
 472 struct ast_smdi_md_message *ast_smdi_md_message_pop(struct ast_smdi_interface *iface)
 473 {
 474         return smdi_msg_pop(iface, SMDI_MD);
 475 }
 476
 477 struct ast_smdi_md_message *ast_smdi_md_message_wait(struct ast_smdi_interface *iface, int timeout)
 478 {
 479         struct ast_flags options = { 0 };
 480         return smdi_message_wait(iface, timeout, SMDI_MD, NULL, options);
 481 }
 482
 483 struct ast_smdi_mwi_message *ast_smdi_mwi_message_pop(struct ast_smdi_interface *iface)
 484 {
 485         return smdi_msg_pop(iface, SMDI_MWI);
 486 }
 487
 488 struct ast_smdi_mwi_message *ast_smdi_mwi_message_wait(struct ast_smdi_interface *iface, int timeout)
 489 {
 490         struct ast_flags options = { 0 };
 491         return smdi_message_wait(iface, timeout, SMDI_MWI, NULL, options);
 492 }
 493
 494 struct ast_smdi_mwi_message *ast_smdi_mwi_message_wait_station(struct ast_smdi_interface *iface, int timeout,
 495         const char *station)
 496 {
 497         struct ast_flags options = { 0 };
 498         return smdi_message_wait(iface, timeout, SMDI_MWI, station, options);
 499 }
 500
 501 struct ast_smdi_interface *ast_smdi_interface_find(const char *iface_name)
 502 {
 503         return (ASTOBJ_CONTAINER_FIND(&smdi_ifaces, iface_name));
 504 }
 505
 506 /*!
 507  * \internal
 508  * \brief Read an SMDI message.
 509  *
 510  * \param iface_p the SMDI interface to read from.
 511  *
 512  * This function loops and reads from and SMDI interface.  It must be stopped
 513  * using pthread_cancel().
 514  */
 515 static void *smdi_read(void *iface_p)
 516 {
 517         struct ast_smdi_interface *iface = iface_p;
 518         struct ast_smdi_md_message *md_msg;
 519         struct ast_smdi_mwi_message *mwi_msg;
 520         char c = '\0';
 521         char *cp = NULL;
 522         int i;
 523         int start = 0;
 524
 525         /* read an smdi message */
 526         while ((c = fgetc(iface->file))) {
 527
 528                 /* check if this is the start of a message */
 529                 if (!start) {
 530                         if (c == 'M') {
 531                                 ast_log(LOG_DEBUG, "Read an 'M' to start an SMDI message\n");
 532                                 start = 1;
 533                         }
 534                         continue;
 535                 }
 536
 537                 if (c == 'D') { /* MD message */
 538                         start = 0;
 539
 540                         ast_log(LOG_DEBUG, "Read a 'D' ... it's an MD message.\n");
 541
 542                         if (!(md_msg = ast_calloc(1, sizeof(*md_msg)))) {
 543                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 544                                 return NULL;
 545                         }
 546
 547                         ASTOBJ_INIT(md_msg);
 548
 549                         /* read the message desk number */
 550                         for (i = 0; i < sizeof(md_msg->mesg_desk_num) - 1; i++) {
 551                                 md_msg->mesg_desk_num[i] = fgetc(iface->file);
 552                                 ast_log(LOG_DEBUG, "Read a '%c'\n", md_msg->mesg_desk_num[i]);
 553                         }
 554
 555                         md_msg->mesg_desk_num[sizeof(md_msg->mesg_desk_num) - 1] = '\0';
 556
 557                         ast_log(LOG_DEBUG, "The message desk number is '%s'\n", md_msg->mesg_desk_num);
 558
 559                         /* read the message desk terminal number */
 560                         for (i = 0; i < sizeof(md_msg->mesg_desk_term) - 1; i++) {
 561                                 md_msg->mesg_desk_term[i] = fgetc(iface->file);
 562                                 ast_log(LOG_DEBUG, "Read a '%c'\n", md_msg->mesg_desk_term[i]);
 563                         }
 564
 565                         md_msg->mesg_desk_term[sizeof(md_msg->mesg_desk_term) - 1] = '\0';
 566
 567                         ast_log(LOG_DEBUG, "The message desk terminal is '%s'\n", md_msg->mesg_desk_term);
 568
 569                         /* read the message type */
 570                         md_msg->type = fgetc(iface->file);
 571
 572                         ast_log(LOG_DEBUG, "Message type is '%c'\n", md_msg->type);
 573
 574                         /* read the forwarding station number (may be blank) */
 575                         cp = &md_msg->fwd_st[0];
 576                         for (i = 0; i < sizeof(md_msg->fwd_st) - 1; i++) {
 577                                 if ((c = fgetc(iface->file)) == ' ') {
 578                                         *cp = '\0';
 579                                         ast_log(LOG_DEBUG, "Read a space, done looking for the forwarding station\n");
 580                                         break;
 581                                 }
 582
 583                                 /* store c in md_msg->fwd_st */
 584                                 if (i >= iface->msdstrip) {
 585                                         ast_log(LOG_DEBUG, "Read a '%c' and stored it in the forwarding station buffer\n", c);
 586                                         *cp++ = c;
 587                                 } else {
 588                                         ast_log(LOG_DEBUG, "Read a '%c', but didn't store it in the fwd station buffer, because of the msdstrip setting (%d < %d)\n", c, i, iface->msdstrip);
 589                                 }
 590                         }
 591
 592                         /* make sure the value is null terminated, even if this truncates it */
 593                         md_msg->fwd_st[sizeof(md_msg->fwd_st) - 1] = '\0';
 594                         cp = NULL;
 595
 596                         ast_log(LOG_DEBUG, "The forwarding station is '%s'\n", md_msg->fwd_st);
 597
 598                         /* Put the fwd_st in the name field so that we can use ASTOBJ_FIND to look
 599                          * up a message on this field */
 600                         ast_copy_string(md_msg->name, md_msg->fwd_st, sizeof(md_msg->name));
 601
 602                         /* read the calling station number (may be blank) */
 603                         cp = &md_msg->calling_st[0];
 604                         for (i = 0; i < sizeof(md_msg->calling_st) - 1; i++) {
 605                                 if (!isdigit((c = fgetc(iface->file)))) {
 606                                         *cp = '\0';
 607                                         ast_log(LOG_DEBUG, "Read a '%c', but didn't store it in the calling station buffer because it's not a digit\n", c);
 608                                         if (c == ' ') {
 609                                                 /* Don't break on a space.  We may read the space before the calling station
 610                                                  * here if the forwarding station buffer filled up. */
 611                                                 i--; /* We're still on the same character */
 612                                                 continue;
 613                                         }
 614                                         break;
 615                                 }
 616
 617                                 /* store c in md_msg->calling_st */
 618                                 if (i >= iface->msdstrip) {
 619                                         ast_log(LOG_DEBUG, "Read a '%c' and stored it in the calling station buffer\n", c);
 620                                         *cp++ = c;
 621                                 } else {
 622                                         ast_log(LOG_DEBUG, "Read a '%c', but didn't store it in the calling station buffer, because of the msdstrip setting (%d < %d)\n", c, i, iface->msdstrip);
 623                                 }
 624                         }
 625
 626                         /* make sure the value is null terminated, even if this truncates it */
 627                         md_msg->calling_st[sizeof(md_msg->calling_st) - 1] = '\0';
 628                         cp = NULL;
 629
 630                         ast_log(LOG_DEBUG, "The calling station is '%s'\n", md_msg->calling_st);
 631
 632                         /* add the message to the message queue */
 633                         md_msg->timestamp = ast_tvnow();
 634                         ast_smdi_md_message_push(iface, md_msg);
 635                         ast_log(LOG_DEBUG, "Recieved SMDI MD message on %s\n", iface->name);
 636
 637                         ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
 638
 639                 } else if (c == 'W') { /* MWI message */
 640                         start = 0;
 641
 642                         ast_log(LOG_DEBUG, "Read a 'W', it's an MWI message. (No more debug coming for MWI messages)\n");
 643
 644                         if (!(mwi_msg = ast_calloc(1, sizeof(*mwi_msg)))) {
 645                                 ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
 646                                 return NULL;
 647                         }
 648
 649                         ASTOBJ_INIT(mwi_msg);
 650
 651                         /* discard the 'I' (from 'MWI') */
 652                         fgetc(iface->file);
 653
 654                         /* read the forwarding station number (may be blank) */
 655                         cp = &mwi_msg->fwd_st[0];
 656                         for (i = 0; i < sizeof(mwi_msg->fwd_st) - 1; i++) {
 657                                 if ((c = fgetc(iface->file)) == ' ') {
 658                                         *cp = '\0';
 659                                         break;
 660                                 }
 661
 662                                 /* store c in md_msg->fwd_st */
 663                                 if (i >= iface->msdstrip)
 664                                         *cp++ = c;
 665                         }
 666
 667                         /* make sure the station number is null terminated, even if this will truncate it */
 668                         mwi_msg->fwd_st[sizeof(mwi_msg->fwd_st) - 1] = '\0';
 669                         cp = NULL;
 670
 671                         /* Put the fwd_st in the name field so that we can use ASTOBJ_FIND to look
 672                          * up a message on this field */
 673                         ast_copy_string(mwi_msg->name, mwi_msg->fwd_st, sizeof(mwi_msg->name));
 674
 675                         /* read the mwi failure cause */
 676                         for (i = 0; i < sizeof(mwi_msg->cause) - 1; i++)
 677                                 mwi_msg->cause[i] = fgetc(iface->file);
 678
 679                         mwi_msg->cause[sizeof(mwi_msg->cause) - 1] = '\0';
 680
 681                         /* add the message to the message queue */
 682                         mwi_msg->timestamp = ast_tvnow();
 683                         ast_smdi_mwi_message_push(iface, mwi_msg);
 684                         ast_log(LOG_DEBUG, "Recieved SMDI MWI message on %s\n", iface->name);
 685
 686                         ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
 687                 } else {
 688                         ast_log(LOG_ERROR, "Unknown SMDI message type recieved on %s (M%c).\n", iface->name, c);
 689                         start = 0;
 690                 }
 691         }
 692
 693         ast_log(LOG_ERROR, "Error reading from SMDI interface %s, stopping listener thread\n", iface->name);
 694         ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
 695         return NULL;
 696 }
 697
 698 void ast_smdi_md_message_destroy(struct ast_smdi_md_message *msg)
 699 {
 700         ast_free(msg);
 701 }
 702
 703 void ast_smdi_mwi_message_destroy(struct ast_smdi_mwi_message *msg)
 704 {
 705         ast_free(msg);
 706 }
 707
 708 static void destroy_mailbox_mapping(struct mailbox_mapping *mm)
 709 {
 710         ast_string_field_free_memory(mm);
 711         ASTOBJ_UNREF(mm->iface, ast_smdi_interface_destroy);
 712         free(mm);
 713 }
 714
 715 static void destroy_all_mailbox_mappings(void)
 716 {
 717         struct mailbox_mapping *mm;
 718
 719         ast_mutex_lock(&mwi_monitor.lock);
 720         while ((mm = AST_LIST_REMOVE_HEAD(&mwi_monitor.mailbox_mappings, entry)))
 721                 destroy_mailbox_mapping(mm);
 722         ast_mutex_unlock(&mwi_monitor.lock);
 723 }
 724
 725 static void append_mailbox_mapping(struct ast_variable *var, struct ast_smdi_interface *iface)
 726 {
 727         struct mailbox_mapping *mm;
 728         char *mailbox, *context;
 729
 730         if (!(mm = ast_calloc(1, sizeof(*mm))))
 731                 return;
 732
 733         if (ast_string_field_init(mm, 32)) {
 734                 free(mm);
 735                 return;
 736         }
 737
 738         ast_string_field_set(mm, smdi, var->name);
 739
 740         context = ast_strdupa(var->value);
 741         mailbox = strsep(&context, "@");
 742         if (ast_strlen_zero(context))
 743                 context = "default";
 744
 745         ast_string_field_set(mm, mailbox, mailbox);
 746         ast_string_field_set(mm, context, context);
 747
 748         mm->iface = ASTOBJ_REF(iface);
 749
 750         ast_mutex_lock(&mwi_monitor.lock);
 751         AST_LIST_INSERT_TAIL(&mwi_monitor.mailbox_mappings, mm, entry);
 752         ast_mutex_unlock(&mwi_monitor.lock);
 753 }
 754
 755 /*!
 756  * \note Called with the mwi_monitor.lock locked
 757  */
 758 static void poll_mailbox(struct mailbox_mapping *mm)
 759 {
 760         char buf[1024];
 761         unsigned int state;
 762
 763         snprintf(buf, sizeof(buf), "%s@%s", mm->mailbox, mm->context);
 764
 765         state = !!ast_app_has_voicemail(mm->mailbox, NULL);
 766
 767         if (state != mm->cur_state) {
 768                 if (state)
 769                         ast_smdi_mwi_set(mm->iface, mm->smdi);
 770                 else
 771                         ast_smdi_mwi_unset(mm->iface, mm->smdi);
 772
 773                 mm->cur_state = state;
 774         }
 775 }
 776
 777 static void *mwi_monitor_handler(void *data)
 778 {
 779         while (!mwi_monitor.stop) {
 780                 struct timespec ts = { 0, };
 781                 struct timeval tv;
 782                 struct mailbox_mapping *mm;
 783
 784                 ast_mutex_lock(&mwi_monitor.lock);
 785
 786                 mwi_monitor.last_poll = ast_tvnow();
 787
 788                 AST_LIST_TRAVERSE(&mwi_monitor.mailbox_mappings, mm, entry)
 789                         poll_mailbox(mm);
 790
 791                 /* Sleep up to the configured polling interval.  Allow unload_module()
 792                  * to signal us to wake up and exit. */
 793                 tv = ast_tvadd(mwi_monitor.last_poll, ast_tv(mwi_monitor.polling_interval, 0));
 794                 ts.tv_sec = tv.tv_sec;
 795                 ts.tv_nsec = tv.tv_usec * 1000;
 796                 ast_cond_timedwait(&mwi_monitor.cond, &mwi_monitor.lock, &ts);
 797
 798                 ast_mutex_unlock(&mwi_monitor.lock);
 799         }
 800
 801         return NULL;
 802 }
 803
 804 static struct ast_smdi_interface *alloc_smdi_interface(void)
 805 {
 806         struct ast_smdi_interface *iface;
 807
 808         if (!(iface = ast_calloc(1, sizeof(*iface))))
 809                 return NULL;
 810
 811         ASTOBJ_INIT(iface);
 812         ASTOBJ_CONTAINER_INIT(&iface->md_q);
 813         ASTOBJ_CONTAINER_INIT(&iface->mwi_q);
 814
 815         ast_mutex_init(&iface->md_q_lock);
 816         ast_cond_init(&iface->md_q_cond, NULL);
 817
 818         ast_mutex_init(&iface->mwi_q_lock);
 819         ast_cond_init(&iface->mwi_q_cond, NULL);
 820
 821         return iface;
 822 }
 823
 824 /*!
 825  * \internal
 826  * \brief Load and reload SMDI configuration.
 827  * \param reload this should be 1 if we are reloading and 0 if not.
 828  *
 829  * This function loads/reloads the SMDI configuration and starts and stops
 830  * interfaces accordingly.
 831  *
 832  * \return zero on success, -1 on failure, and 1 if no smdi interfaces were started.
 833  */
 834 static int smdi_load(int reload)
 835 {
 836         struct ast_config *conf;
 837         struct ast_variable *v;
 838         struct ast_smdi_interface *iface = NULL;
 839         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
 840         int res = 0;
 841
 842         /* Config options */
 843         speed_t baud_rate = B9600;     /* 9600 baud rate */
 844         tcflag_t paritybit = PARENB;   /* even parity checking */
 845         tcflag_t charsize = CS7;       /* seven bit characters */
 846         int stopbits = 0;              /* One stop bit */
 847
 848         int msdstrip = 0;              /* strip zero digits */
 849         long msg_expiry = SMDI_MSG_EXPIRY_TIME;
 850
 851         if (!(conf = ast_config_load(config_file, config_flags))) {
 852                 if (reload)
 853                         ast_log(LOG_NOTICE, "Unable to reload config %s: SMDI untouched\n", config_file);
 854                 else
 855                         ast_log(LOG_NOTICE, "Unable to load config %s: SMDI disabled\n", config_file);
 856                 return 1;
 857         } else if (conf == CONFIG_STATUS_FILEUNCHANGED)
 858                 return 0;
 859
 860         /* Mark all interfaces that we are listening on.  We will unmark them
 861          * as we find them in the config file, this way we know any interfaces
 862          * still marked after we have finished parsing the config file should
 863          * be stopped.
 864          */
 865         if (reload)
 866                 ASTOBJ_CONTAINER_MARKALL(&smdi_ifaces);
 867
 868         for (v = ast_variable_browse(conf, "interfaces"); v; v = v->next) {
 869                 if (!strcasecmp(v->name, "baudrate")) {
 870                         if (!strcasecmp(v->value, "9600"))
 871                                 baud_rate = B9600;
 872                         else if (!strcasecmp(v->value, "4800"))
 873                                 baud_rate = B4800;
 874                         else if (!strcasecmp(v->value, "2400"))
 875                                 baud_rate = B2400;
 876                         else if (!strcasecmp(v->value, "1200"))
 877                                 baud_rate = B1200;
 878                         else {
 879                                 ast_log(LOG_NOTICE, "Invalid baud rate '%s' specified in %s (line %d), using default\n", v->value, config_file, v->lineno);
 880                                 baud_rate = B9600;
 881                         }
 882                 } else if (!strcasecmp(v->name, "msdstrip")) {
 883                         if (!sscanf(v->value, "%d", &msdstrip)) {
 884                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
 885                                 msdstrip = 0;
 886                         } else if (0 > msdstrip || msdstrip > 9) {
 887                                 ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
 888                                 msdstrip = 0;
 889                         }
 890                 } else if (!strcasecmp(v->name, "msgexpirytime")) {
 891                         if (!sscanf(v->value, "%ld", &msg_expiry)) {
 892                                 ast_log(LOG_NOTICE, "Invalid msgexpirytime value in %s (line %d), using default\n", config_file, v->lineno);
 893                                 msg_expiry = SMDI_MSG_EXPIRY_TIME;
 894                         }
 895                 } else if (!strcasecmp(v->name, "paritybit")) {
 896                         if (!strcasecmp(v->value, "even"))
 897                                 paritybit = PARENB;
 898                         else if (!strcasecmp(v->value, "odd"))
 899                                 paritybit = PARENB | PARODD;
 900                         else if (!strcasecmp(v->value, "none"))
 901                                 paritybit = ~PARENB;
 902                         else {
 903                                 ast_log(LOG_NOTICE, "Invalid parity bit setting in %s (line %d), using default\n", config_file, v->lineno);
 904                                 paritybit = PARENB;
 905                         }
 906                 } else if (!strcasecmp(v->name, "charsize")) {
 907                         if (!strcasecmp(v->value, "7"))
 908                                 charsize = CS7;
 909                         else if (!strcasecmp(v->value, "8"))
 910                                 charsize = CS8;
 911                         else {
 912                                 ast_log(LOG_NOTICE, "Invalid character size setting in %s (line %d), using default\n", config_file, v->lineno);
 913                                 charsize = CS7;
 914                         }
 915                 } else if (!strcasecmp(v->name, "twostopbits")) {
 916                         stopbits = ast_true(v->name);
 917                 } else if (!strcasecmp(v->name, "smdiport")) {
 918                         if (reload) {
 919                                 /* we are reloading, check if we are already
 920                                  * monitoring this interface, if we are we do
 921                                  * not want to start it again.  This also has
 922                                  * the side effect of not updating different
 923                                  * setting for the serial port, but it should
 924                                  * be trivial to rewrite this section so that
 925                                  * options on the port are changed without
 926                                  * restarting the interface.  Or the interface
 927                                  * could be restarted with out emptying the
 928                                  * queue. */
 929                                 if ((iface = ASTOBJ_CONTAINER_FIND(&smdi_ifaces, v->value))) {
 930                                         ast_log(LOG_NOTICE, "SMDI interface %s already running, not restarting\n", iface->name);
 931                                         ASTOBJ_UNMARK(iface);
 932                                         ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 933                                         continue;
 934                                 }
 935                         }
 936
 937                         if (!(iface = alloc_smdi_interface()))
 938                                 continue;
 939
 940                         ast_copy_string(iface->name, v->value, sizeof(iface->name));
 941
 942                         iface->thread = AST_PTHREADT_NULL;
 943
 944                         if (!(iface->file = fopen(iface->name, "r"))) {
 945                                 ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s)\n", iface->name, strerror(errno));
 946                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 947                                 continue;
 948                         }
 949
 950                         iface->fd = fileno(iface->file);
 951
 952                         /* Set the proper attributes for our serial port. */
 953
 954                         /* get the current attributes from the port */
 955                         if (tcgetattr(iface->fd, &iface->mode)) {
 956                                 ast_log(LOG_ERROR, "Error getting atributes of %s (%s)\n", iface->name, strerror(errno));
 957                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 958                                 continue;
 959                         }
 960
 961                         /* set the desired speed */
 962                         if (cfsetispeed(&iface->mode, baud_rate) || cfsetospeed(&iface->mode, baud_rate)) {
 963                                 ast_log(LOG_ERROR, "Error setting baud rate on %s (%s)\n", iface->name, strerror(errno));
 964                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 965                                 continue;
 966                         }
 967
 968                         /* set the stop bits */
 969                         if (stopbits)
 970                                 iface->mode.c_cflag = iface->mode.c_cflag | CSTOPB;   /* set two stop bits */
 971                         else
 972                                 iface->mode.c_cflag = iface->mode.c_cflag & ~CSTOPB;  /* set one stop bit */
 973
 974                         /* set the parity */
 975                         iface->mode.c_cflag = (iface->mode.c_cflag & ~PARENB & ~PARODD) | paritybit;
 976
 977                         /* set the character size */
 978                         iface->mode.c_cflag = (iface->mode.c_cflag & ~CSIZE) | charsize;
 979
 980                         /* commit the desired attributes */
 981                         if (tcsetattr(iface->fd, TCSAFLUSH, &iface->mode)) {
 982                                 ast_log(LOG_ERROR, "Error setting attributes on %s (%s)\n", iface->name, strerror(errno));
 983                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 984                                 continue;
 985                         }
 986
 987                         /* set the msdstrip */
 988                         iface->msdstrip = msdstrip;
 989
 990                         /* set the message expiry time */
 991                         iface->msg_expiry = msg_expiry;
 992
 993                         /* start the listener thread */
 994                         ast_verb(3, "Starting SMDI monitor thread for %s\n", iface->name);
 995                         if (ast_pthread_create_background(&iface->thread, NULL, smdi_read, iface)) {
 996                                 ast_log(LOG_ERROR, "Error starting SMDI monitor thread for %s\n", iface->name);
 997                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
 998                                 continue;
 999                         }
1000
1001                         ASTOBJ_CONTAINER_LINK(&smdi_ifaces, iface);
1002                         ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
1003                         ast_module_ref(ast_module_info->self);
1004                 } else {
1005                         ast_log(LOG_NOTICE, "Ignoring unknown option %s in %s\n", v->name, config_file);
1006                 }
1007         }
1008
1009         destroy_all_mailbox_mappings();
1010         mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
1011
1012         iface = NULL;
1013
1014         for (v = ast_variable_browse(conf, "mailboxes"); v; v = v->next) {
1015                 if (!strcasecmp(v->name, "smdiport")) {
1016                         if (iface)
1017                                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
1018
1019                         if (!(iface = ASTOBJ_CONTAINER_FIND(&smdi_ifaces, v->value))) {
1020                                 ast_log(LOG_NOTICE, "SMDI interface %s not found\n", iface->name);
1021                                 continue;
1022                         }
1023                 } else if (!strcasecmp(v->name, "pollinginterval")) {
1024                         if (sscanf(v->value, "%u", &mwi_monitor.polling_interval) != 1) {
1025                                 ast_log(LOG_ERROR, "Invalid value for pollinginterval: %s\n", v->value);
1026                                 mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
1027                         }
1028                 } else {
1029                         if (!iface) {
1030                                 ast_log(LOG_ERROR, "Mailbox mapping ignored, no valid SMDI interface specified in mailboxes section\n");
1031                                 continue;
1032                         }
1033                         append_mailbox_mapping(v, iface);
1034                 }
1035         }
1036
1037         if (iface)
1038                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
1039
1040         ast_config_destroy(conf);
1041
1042         if (!AST_LIST_EMPTY(&mwi_monitor.mailbox_mappings) && mwi_monitor.thread == AST_PTHREADT_NULL
1043                 && ast_pthread_create_background(&mwi_monitor.thread, NULL, mwi_monitor_handler, NULL)) {
1044                 ast_log(LOG_ERROR, "Failed to start MWI monitoring thread.  This module will not operate.\n");
1045                 return AST_MODULE_LOAD_FAILURE;
1046         }
1047
1048         /* Prune any interfaces we should no longer monitor. */
1049         if (reload)
1050                 ASTOBJ_CONTAINER_PRUNE_MARKED(&smdi_ifaces, ast_smdi_interface_destroy);
1051
1052         ASTOBJ_CONTAINER_RDLOCK(&smdi_ifaces);
1053         /* TODO: this is bad, we need an ASTOBJ method for this! */
1054         if (!smdi_ifaces.head)
1055                 res = 1;
1056         ASTOBJ_CONTAINER_UNLOCK(&smdi_ifaces);
1057
1058         return res;
1059 }
1060
1061 struct smdi_msg_datastore {
1062         unsigned int id;
1063         struct ast_smdi_interface *iface;
1064         struct ast_smdi_md_message *md_msg;
1065 };
1066
1067 static void smdi_msg_datastore_destroy(void *data)
1068 {
1069         struct smdi_msg_datastore *smd = data;
1070
1071         if (smd->iface)
1072                 ASTOBJ_UNREF(smd->iface, ast_smdi_interface_destroy);
1073
1074         if (smd->md_msg)
1075                 ASTOBJ_UNREF(smd->md_msg, ast_smdi_md_message_destroy);
1076
1077         free(smd);
1078 }
1079
1080 static const struct ast_datastore_info smdi_msg_datastore_info = {
1081         .type = "SMDIMSG",
1082         .destroy = smdi_msg_datastore_destroy,
1083 };
1084
1085 static int smdi_msg_id;
1086
1087 /*! In milliseconds */
1088 #define SMDI_RETRIEVE_TIMEOUT_DEFAULT 3000
1089
1090 AST_APP_OPTIONS(smdi_msg_ret_options, BEGIN_OPTIONS
1091         AST_APP_OPTION('t', OPT_SEARCH_TERMINAL),
1092         AST_APP_OPTION('n', OPT_SEARCH_NUMBER),
1093 END_OPTIONS );
1094
1095 static int smdi_msg_retrieve_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
1096 {
1097         struct ast_module_user *u;
1098         AST_DECLARE_APP_ARGS(args,
1099                 AST_APP_ARG(port);
1100                 AST_APP_ARG(search_key);
1101                 AST_APP_ARG(timeout);
1102                 AST_APP_ARG(options);
1103         );
1104         struct ast_flags options = { 0 };
1105         unsigned int timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
1106         int res = -1;
1107         char *parse = NULL;
1108         struct smdi_msg_datastore *smd = NULL;
1109         struct ast_datastore *datastore = NULL;
1110         struct ast_smdi_interface *iface = NULL;
1111         struct ast_smdi_md_message *md_msg = NULL;
1112
1113         u = ast_module_user_add(chan);
1114
1115         if (ast_strlen_zero(data)) {
1116                 ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE requires an argument\n");
1117                 goto return_error;
1118         }
1119
1120         if (!chan) {
1121                 ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE must be used with a channel\n");
1122                 goto return_error;
1123         }
1124
1125         ast_autoservice_start(chan);
1126
1127         parse = ast_strdupa(data);
1128         AST_STANDARD_APP_ARGS(args, parse);
1129
1130         if (ast_strlen_zero(args.port) || ast_strlen_zero(args.search_key)) {
1131                 ast_log(LOG_ERROR, "Invalid arguments provided to SMDI_MSG_RETRIEVE\n");
1132                 goto return_error;
1133         }
1134
1135         if (!(iface = ast_smdi_interface_find(args.port))) {
1136                 ast_log(LOG_ERROR, "SMDI port '%s' not found\n", args.port);
1137                 goto return_error;
1138         }
1139
1140         if (!ast_strlen_zero(args.options)) {
1141                 ast_app_parse_options(smdi_msg_ret_options, &options, NULL, args.options);
1142         }
1143
1144         if (!ast_strlen_zero(args.timeout)) {
1145                 if (sscanf(args.timeout, "%u", &timeout) != 1) {
1146                         ast_log(LOG_ERROR, "'%s' is not a valid timeout\n", args.timeout);
1147                         timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
1148                 }
1149         }
1150
1151         if (!(md_msg = smdi_message_wait(iface, timeout, SMDI_MD, args.search_key, options))) {
1152                 ast_log(LOG_WARNING, "No SMDI message retrieved for search key '%s' after "
1153                         "waiting %u ms.\n", args.search_key, timeout);
1154                 goto return_error;
1155         }
1156
1157         if (!(smd = ast_calloc(1, sizeof(*smd))))
1158                 goto return_error;
1159
1160         smd->iface = ASTOBJ_REF(iface);
1161         smd->md_msg = ASTOBJ_REF(md_msg);
1162         smd->id = ast_atomic_fetchadd_int((int *) &smdi_msg_id, 1);
1163         snprintf(buf, len, "%u", smd->id);
1164
1165         if (!(datastore = ast_channel_datastore_alloc(&smdi_msg_datastore_info, buf)))
1166                 goto return_error;
1167
1168         datastore->data = smd;
1169
1170         ast_channel_lock(chan);
1171         ast_channel_datastore_add(chan, datastore);
1172         ast_channel_unlock(chan);
1173
1174         res = 0;
1175
1176 return_error:
1177         if (iface)
1178                 ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
1179
1180         if (md_msg)
1181                 ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
1182
1183         if (smd && !datastore)
1184                 smdi_msg_datastore_destroy(smd);
1185
1186         if (parse)
1187                 ast_autoservice_stop(chan);
1188
1189         ast_module_user_remove(u);
1190
1191         return res;
1192 }
1193
1194 static int smdi_msg_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
1195 {
1196         struct ast_module_user *u;
1197         int res = -1;
1198         AST_DECLARE_APP_ARGS(args,
1199                 AST_APP_ARG(id);
1200                 AST_APP_ARG(component);
1201         );
1202         char *parse;
1203         struct ast_datastore *datastore = NULL;
1204         struct smdi_msg_datastore *smd = NULL;
1205
1206         u = ast_module_user_add(chan);
1207
1208         if (!chan) {
1209                 ast_log(LOG_ERROR, "SMDI_MSG can not be called without a channel\n");
1210                 goto return_error;
1211         }
1212
1213         if (ast_strlen_zero(data)) {
1214                 ast_log(LOG_WARNING, "SMDI_MSG requires an argument\n");
1215                 goto return_error;
1216         }
1217
1218         parse = ast_strdupa(data);
1219         AST_STANDARD_APP_ARGS(args, parse);
1220
1221         if (ast_strlen_zero(args.id)) {
1222                 ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
1223                 goto return_error;
1224         }
1225
1226         if (ast_strlen_zero(args.component)) {
1227                 ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
1228                 goto return_error;
1229         }
1230
1231         ast_channel_lock(chan);
1232         datastore = ast_channel_datastore_find(chan, &smdi_msg_datastore_info, args.id);
1233         ast_channel_unlock(chan);
1234
1235         if (!datastore) {
1236                 ast_log(LOG_WARNING, "No SMDI message found for message ID '%s'\n", args.id);
1237                 goto return_error;
1238         }
1239
1240         smd = datastore->data;
1241
1242         if (!strcasecmp(args.component, "number")) {
1243                 ast_copy_string(buf, smd->md_msg->mesg_desk_num, len);
1244         } else if (!strcasecmp(args.component, "terminal")) {
1245                 ast_copy_string(buf, smd->md_msg->mesg_desk_term, len);
1246         } else if (!strcasecmp(args.component, "station")) {
1247                 ast_copy_string(buf, smd->md_msg->fwd_st, len);
1248         } else if (!strcasecmp(args.component, "callerid")) {
1249                 ast_copy_string(buf, smd->md_msg->calling_st, len);
1250         } else if (!strcasecmp(args.component, "type")) {
1251                 snprintf(buf, len, "%c", smd->md_msg->type);
1252         } else {
1253                 ast_log(LOG_ERROR, "'%s' is not a valid message component for SMDI_MSG\n",
1254                         args.component);
1255                 goto return_error;
1256         }
1257
1258         res = 0;
1259
1260 return_error:
1261         ast_module_user_remove(u);
1262
1263         return 0;
1264 }
1265
1266 static struct ast_custom_function smdi_msg_retrieve_function = {
1267         .name = "SMDI_MSG_RETRIEVE",
1268         .synopsis = "Retrieve an SMDI message.",
1269         .syntax = "SMDI_MSG_RETRIEVE(<smdi port>,<search key>[,timeout[,options]])",
1270         .desc =
1271         "   This function is used to retrieve an incoming SMDI message.  It returns\n"
1272         "an ID which can be used with the SMDI_MSG() function to access details of\n"
1273         "the message.  Note that this is a destructive function in the sense that\n"
1274         "once an SMDI message is retrieved using this function, it is no longer in\n"
1275         "the global SMDI message queue, and can not be accessed by any other Asterisk\n"
1276         "channels.  The timeout for this function is optional, and the default is\n"
1277         "3 seconds.  When providing a timeout, it should be in milliseconds.\n"
1278         "   The default search is done on the forwarding station ID.  However, if\n"
1279         "you set one of the search key options in the options field, you can change\n"
1280         "this behavior.\n"
1281         "   Options:\n"
1282         "     t - Instead of searching on the forwarding station, search on the message\n"
1283         "         desk terminal.\n"
1284         "     n - Instead of searching on the forwarding station, search on the message\n"
1285         "         desk number.\n"
1286         "",
1287         .read = smdi_msg_retrieve_read,
1288 };
1289
1290 static struct ast_custom_function smdi_msg_function = {
1291         .name = "SMDI_MSG",
1292         .synopsis = "Retrieve details about an SMDI message.",
1293         .syntax = "SMDI_MSG(<message_id>,<component>)",
1294         .desc =
1295         "   This function is used to access details of an SMDI message that was\n"
1296         "pulled from the incoming SMDI message queue using the SMDI_MSG_RETRIEVE()\n"
1297         "function.\n"
1298         "   Valid message components are:\n"
1299         "      number   - The message desk number\n"
1300         "      terminal - The message desk terminal\n"
1301         "      station  - The forwarding station\n"
1302         "      callerid - The callerID of the calling party that was forwarded\n"
1303         "      type     - The call type.  The value here is the exact character\n"
1304         "                 that came in on the SMDI link.  Typically, example values\n"
1305         "                 are: D - Direct Calls, A - Forward All Calls,\n"
1306         "                      B - Forward Busy Calls, N - Forward No Answer Calls\n"
1307         "",
1308         .read = smdi_msg_read,
1309 };
1310
1311 static int load_module(void)
1312 {
1313         int res;
1314
1315         /* initialize our containers */
1316         memset(&smdi_ifaces, 0, sizeof(smdi_ifaces));
1317         ASTOBJ_CONTAINER_INIT(&smdi_ifaces);
1318
1319         ast_mutex_init(&mwi_monitor.lock);
1320         ast_cond_init(&mwi_monitor.cond, NULL);
1321
1322         ast_custom_function_register(&smdi_msg_retrieve_function);
1323         ast_custom_function_register(&smdi_msg_function);
1324
1325         /* load the config and start the listener threads*/
1326         res = smdi_load(0);
1327         if (res < 0) {
1328                 return res;
1329         } else if (res == 1) {
1330                 ast_log(LOG_NOTICE, "No SMDI interfaces are available to listen on, not starting SMDI listener.\n");
1331                 return AST_MODULE_LOAD_DECLINE;
1332         }
1333
1334         return AST_MODULE_LOAD_SUCCESS;
1335 }
1336
1337 static int unload_module(void)
1338 {
1339         /* this destructor stops any running smdi_read threads */
1340         ASTOBJ_CONTAINER_DESTROYALL(&smdi_ifaces, ast_smdi_interface_destroy);
1341         ASTOBJ_CONTAINER_DESTROY(&smdi_ifaces);
1342
1343         destroy_all_mailbox_mappings();
1344
1345         ast_mutex_lock(&mwi_monitor.lock);
1346         mwi_monitor.stop = 1;
1347         ast_cond_signal(&mwi_monitor.cond);
1348         ast_mutex_unlock(&mwi_monitor.lock);
1349
1350         if (mwi_monitor.thread != AST_PTHREADT_NULL) {
1351                 pthread_join(mwi_monitor.thread, NULL);
1352         }
1353
1354         ast_custom_function_unregister(&smdi_msg_retrieve_function);
1355         ast_custom_function_unregister(&smdi_msg_function);
1356
1357         return 0;
1358 }
1359
1360 static int reload(void)
1361 {
1362         int res;
1363
1364         res = smdi_load(1);
1365
1366         if (res < 0) {
1367                 return res;
1368         } else if (res == 1) {
1369                 ast_log(LOG_WARNING, "No SMDI interfaces were specified to listen on, not starting SDMI listener.\n");
1370                 return 0;
1371         } else
1372                 return 0;
1373 }
1374
1375 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Simplified Message Desk Interface (SMDI) Resource",
1376                 .load = load_module,
1377                 .unload = unload_module,
1378                 .reload = reload,
1379                );