Sat Nov 1 06:28:38 2008

Asterisk developer's documentation

---

res_smdi.c

Go to the documentation of this file.

/*
 * Asterisk -- A telephony toolkit for Linux.
 *
 * Copyright (C) 2005-2008, Digium, Inc.
 *
 * Matthew A. Nicholson <mnicholson@digium.com>
 * Russell Bryant <russell@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*!
 * \file
 * \brief SMDI support for Asterisk.
 * \author Matthew A. Nicholson <mnicholson@digium.com>
 * \author Russell Bryant <russell@digium.com>
 *
 * Here is a useful mailing list post that describes SMDI protocol details:
 * \ref http://lists.digium.com/pipermail/asterisk-dev/2003-June/000884.html
 */

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 146799 $")

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <termios.h>
#include <sys/time.h>
#include <time.h>
#include <ctype.h>

#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/smdi.h"
#include "asterisk/config.h"
#include "asterisk/astobj.h"
#include "asterisk/io.h"
#include "asterisk/logger.h"
#include "asterisk/utils.h"
#include "asterisk/options.h"
#include "asterisk/stringfields.h"
#include "asterisk/linkedlists.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"

/* Message expiry time in milliseconds */
#define SMDI_MSG_EXPIRY_TIME  30000 /* 30 seconds */

static const char config_file[] = "smdi.conf";

/*! \brief SMDI message desk message queue. */
struct ast_smdi_md_queue {
   ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_md_message);
};

/*! \brief SMDI message waiting indicator message queue. */
struct ast_smdi_mwi_queue {
   ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_mwi_message);
};

struct ast_smdi_interface {
   ASTOBJ_COMPONENTS_FULL(struct ast_smdi_interface, SMDI_MAX_FILENAME_LEN, 1);
   struct ast_smdi_md_queue md_q;
   ast_mutex_t md_q_lock;
   ast_cond_t md_q_cond;
   struct ast_smdi_mwi_queue mwi_q;
   ast_mutex_t mwi_q_lock;
   ast_cond_t mwi_q_cond;
   FILE *file;
   int fd;
   pthread_t thread;
   struct termios mode;
   int msdstrip;
   long msg_expiry;
};

/*! \brief SMDI interface container. */
struct ast_smdi_interface_container {
   ASTOBJ_CONTAINER_COMPONENTS(struct ast_smdi_interface);
} smdi_ifaces;

/*! \brief A mapping between an SMDI mailbox ID and an Asterisk mailbox */
struct mailbox_mapping {
   /*! This is the current state of the mailbox.  It is simply on or
    *  off to indicate if there are messages waiting or not. */
   unsigned int cur_state:1;
   /*! A Pointer to the appropriate SMDI interface */
   struct ast_smdi_interface *iface;
   AST_DECLARE_STRING_FIELDS(
      /*! The Name of the mailbox for the SMDI link. */
      AST_STRING_FIELD(smdi);
      /*! The name of the mailbox on the Asterisk side */
      AST_STRING_FIELD(mailbox);
      /*! The name of the voicemail context in use */
      AST_STRING_FIELD(context);
   );
   AST_LIST_ENTRY(mailbox_mapping) entry;
};

/*! 10 seconds */
#define DEFAULT_POLLING_INTERVAL 10

/*! \brief Data that gets used by the SMDI MWI monitoring thread */
static struct {
   /*! The thread ID */
   pthread_t thread;
   ast_mutex_t lock;
   ast_cond_t cond;
   /*! A list of mailboxes that need to be monitored */
   AST_LIST_HEAD_NOLOCK(, mailbox_mapping) mailbox_mappings;
   /*! Polling Interval for checking mailbox status */
   unsigned int polling_interval;
   /*! Set to 1 to tell the polling thread to stop */
   unsigned int stop:1;
   /*! The time that the last poll began */
   struct timeval last_poll;
} mwi_monitor = {
   .thread = AST_PTHREADT_NULL,
};

static void ast_smdi_interface_destroy(struct ast_smdi_interface *iface)
{
   if (iface->thread != AST_PTHREADT_NULL && iface->thread != AST_PTHREADT_STOP) {
      pthread_cancel(iface->thread);
      pthread_join(iface->thread, NULL);
   }
   
   iface->thread = AST_PTHREADT_STOP;
   
   if (iface->file) 
      fclose(iface->file);
   
   ASTOBJ_CONTAINER_DESTROYALL(&iface->md_q, ast_smdi_md_message_destroy);
   ASTOBJ_CONTAINER_DESTROYALL(&iface->mwi_q, ast_smdi_mwi_message_destroy);
   ASTOBJ_CONTAINER_DESTROY(&iface->md_q);
   ASTOBJ_CONTAINER_DESTROY(&iface->mwi_q);

   ast_mutex_destroy(&iface->md_q_lock);
   ast_cond_destroy(&iface->md_q_cond);

   ast_mutex_destroy(&iface->mwi_q_lock);
   ast_cond_destroy(&iface->mwi_q_cond);

   free(iface);

   ast_module_unref(ast_module_info->self);
}

void ast_smdi_interface_unref(struct ast_smdi_interface *iface)
{
   ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
}

/*! 
 * \internal
 * \brief Push an SMDI message to the back of an interface's message queue.
 * \param iface a pointer to the interface to use.
 * \param md_msg a pointer to the message to use.
 */
static void ast_smdi_md_message_push(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
{
   ast_mutex_lock(&iface->md_q_lock);
   ASTOBJ_CONTAINER_LINK_END(&iface->md_q, md_msg);
   ast_cond_broadcast(&iface->md_q_cond);
   ast_mutex_unlock(&iface->md_q_lock);
}

/*!
 * \internal
 * \brief Push an SMDI message to the back of an interface's message queue.
 * \param iface a pointer to the interface to use.
 * \param mwi_msg a pointer to the message to use.
 */
static void ast_smdi_mwi_message_push(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
{
   ast_mutex_lock(&iface->mwi_q_lock);
   ASTOBJ_CONTAINER_LINK_END(&iface->mwi_q, mwi_msg);
   ast_cond_broadcast(&iface->mwi_q_cond);
   ast_mutex_unlock(&iface->mwi_q_lock);
}

static int smdi_toggle_mwi(struct ast_smdi_interface *iface, const char *mailbox, int on)
{
   FILE *file;
   int i;
   
   if (!(file = fopen(iface->name, "w"))) {
      ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s) for writing\n", iface->name, strerror(errno));
      return 1;
   }  

   ASTOBJ_WRLOCK(iface);

   fprintf(file, "%s:MWI ", on ? "OP" : "RMV");

   for (i = 0; i < iface->msdstrip; i++)
      fprintf(file, "0");

   fprintf(file, "%s!\x04", mailbox);

   fclose(file);

   ASTOBJ_UNLOCK(iface);

   ast_log(LOG_DEBUG, "Sent MWI %s message for %s on %s\n", on ? "set" : "unset", 
      mailbox, iface->name);

   return 0;
}

int ast_smdi_mwi_set(struct ast_smdi_interface *iface, const char *mailbox)
{
   return smdi_toggle_mwi(iface, mailbox, 1);
}

int ast_smdi_mwi_unset(struct ast_smdi_interface *iface, const char *mailbox)
{
   return smdi_toggle_mwi(iface, mailbox, 0);
}

void ast_smdi_md_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
{
   ast_mutex_lock(&iface->md_q_lock);
   ASTOBJ_CONTAINER_LINK_START(&iface->md_q, md_msg);
   ast_cond_broadcast(&iface->md_q_cond);
   ast_mutex_unlock(&iface->md_q_lock);
}

void ast_smdi_mwi_message_putback(struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
{
   ast_mutex_lock(&iface->mwi_q_lock);
   ASTOBJ_CONTAINER_LINK_START(&iface->mwi_q, mwi_msg);
   ast_cond_broadcast(&iface->mwi_q_cond);
   ast_mutex_unlock(&iface->mwi_q_lock);
}

enum smdi_message_type {
   SMDI_MWI,
   SMDI_MD,
};

static inline int lock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
{
   switch (type) {
   case SMDI_MWI:
      return ast_mutex_lock(&iface->mwi_q_lock);
   case SMDI_MD:  
      return ast_mutex_lock(&iface->md_q_lock);
   }
   
   return -1;
}

static inline int unlock_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
{
   switch (type) {
   case SMDI_MWI:
      return ast_mutex_unlock(&iface->mwi_q_lock);
   case SMDI_MD:
      return ast_mutex_unlock(&iface->md_q_lock);
   }

   return -1;
}

static inline void *unlink_from_msg_q(struct ast_smdi_interface *iface, enum smdi_message_type type)
{
   switch (type) {
   case SMDI_MWI:
      return ASTOBJ_CONTAINER_UNLINK_START(&iface->mwi_q);
   case SMDI_MD:
      return ASTOBJ_CONTAINER_UNLINK_START(&iface->md_q);
   }

   return NULL;
}

static inline struct timeval msg_timestamp(void *msg, enum smdi_message_type type)
{
   struct ast_smdi_md_message *md_msg = msg;
   struct ast_smdi_mwi_message *mwi_msg = msg;

   switch (type) {
   case SMDI_MWI:
      return mwi_msg->timestamp;
   case SMDI_MD:
      return md_msg->timestamp;
   }

   return ast_tv(0, 0);
}

static inline void unref_msg(void *msg, enum smdi_message_type type)
{
   struct ast_smdi_md_message *md_msg = msg;
   struct ast_smdi_mwi_message *mwi_msg = msg;

   switch (type) {
   case SMDI_MWI:
      ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
   case SMDI_MD:
      ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);
   }
}

static void purge_old_messages(struct ast_smdi_interface *iface, enum smdi_message_type type)
{
   struct timeval now;
   long elapsed = 0;
   void *msg;
   
   lock_msg_q(iface, type);
   msg = unlink_from_msg_q(iface, type);
   unlock_msg_q(iface, type);

   /* purge old messages */
   now = ast_tvnow();
   while (msg) {
      elapsed = ast_tvdiff_ms(now, msg_timestamp(msg, type));

      if (elapsed > iface->msg_expiry) {
         /* found an expired message */
         unref_msg(msg, type);
         ast_log(LOG_NOTICE, "Purged expired message from %s SMDI %s message queue.  "
            "Message was %ld milliseconds too old.\n",
            iface->name, (type == SMDI_MD) ? "MD" : "MWI", 
            elapsed - iface->msg_expiry);

         lock_msg_q(iface, type);
         msg = unlink_from_msg_q(iface, type);
         unlock_msg_q(iface, type);
      } else {
         /* good message, put it back and return */
         switch (type) {
         case SMDI_MD:
            ast_smdi_md_message_push(iface, msg);
            break;
         case SMDI_MWI:
            ast_smdi_mwi_message_push(iface, msg);
            break;
         }
         unref_msg(msg, type);
         break;
      }
   }
}

static void *smdi_msg_pop(struct ast_smdi_interface *iface, enum smdi_message_type type)
{
   void *msg;

   purge_old_messages(iface, type);

   lock_msg_q(iface, type);
   msg = unlink_from_msg_q(iface, type);
   unlock_msg_q(iface, type);

   return msg;
}

enum {
   OPT_SEARCH_TERMINAL = (1 << 0),
   OPT_SEARCH_NUMBER   = (1 << 1),
};

static void *smdi_msg_find(struct ast_smdi_interface *iface,
   enum smdi_message_type type, const char *search_key, struct ast_flags options)
{
   void *msg = NULL;

   purge_old_messages(iface, type);

   switch (type) {
   case SMDI_MD:
      if (ast_test_flag(&options, OPT_SEARCH_TERMINAL)) {
         struct ast_smdi_md_message *md_msg = NULL;

         /* Searching by the message desk terminal */

         ASTOBJ_CONTAINER_TRAVERSE(&iface->md_q, !md_msg, do {
            if (!strcasecmp(iterator->mesg_desk_term, search_key))
               md_msg = ASTOBJ_REF(iterator);
         } while (0); );

         msg = md_msg;
      } else if (ast_test_flag(&options, OPT_SEARCH_NUMBER)) {
         struct ast_smdi_md_message *md_msg = NULL;

         /* Searching by the message desk number */

         ASTOBJ_CONTAINER_TRAVERSE(&iface->md_q, !md_msg, do {
            if (!strcasecmp(iterator->mesg_desk_num, search_key))
               md_msg = ASTOBJ_REF(iterator);
         } while (0); );

         msg = md_msg;
      } else {
         /* Searching by the forwarding station */
         msg = ASTOBJ_CONTAINER_FIND(&iface->md_q, search_key);
      }
      break;
   case SMDI_MWI:
      msg = ASTOBJ_CONTAINER_FIND(&iface->mwi_q, search_key);
      break;
   }

   return msg;
}

static void *smdi_message_wait(struct ast_smdi_interface *iface, int timeout, 
   enum smdi_message_type type, const char *search_key, struct ast_flags options)
{
   struct timeval start;
   long diff = 0;
   void *msg;
   ast_cond_t *cond = NULL;
   ast_mutex_t *lock = NULL;

   switch (type) {
   case SMDI_MWI:
      cond = &iface->mwi_q_cond;
      lock = &iface->mwi_q_lock;
      break;
   case SMDI_MD:
      cond = &iface->md_q_cond;
      lock = &iface->md_q_lock;
      break;
   }

   start = ast_tvnow();
   while (diff < timeout) {
      struct timespec ts = { 0, };
      struct timeval tv;

      lock_msg_q(iface, type);

      if ((msg = smdi_msg_find(iface, type, search_key, options))) {
         unlock_msg_q(iface, type);
         return msg;
      }

      tv = ast_tvadd(start, ast_tv(0, timeout));
      ts.tv_sec = tv.tv_sec;
      ts.tv_nsec = tv.tv_usec * 1000;

      /* If there were no messages in the queue, then go to sleep until one
       * arrives. */

      ast_cond_timedwait(cond, lock, &ts);

      if ((msg = smdi_msg_find(iface, type, search_key, options))) {
         unlock_msg_q(iface, type);
         return msg;
      }

      unlock_msg_q(iface, type);

      /* check timeout */
      diff = ast_tvdiff_ms(ast_tvnow(), start);
   }

   return NULL;
}

struct ast_smdi_md_message *ast_smdi_md_message_pop(struct ast_smdi_interface *iface)
{
   return smdi_msg_pop(iface, SMDI_MD);
}

struct ast_smdi_md_message *ast_smdi_md_message_wait(struct ast_smdi_interface *iface, int timeout)
{
   struct ast_flags options = { 0 };
   return smdi_message_wait(iface, timeout, SMDI_MD, NULL, options);
}

struct ast_smdi_mwi_message *ast_smdi_mwi_message_pop(struct ast_smdi_interface *iface)
{
   return smdi_msg_pop(iface, SMDI_MWI);
}

struct ast_smdi_mwi_message *ast_smdi_mwi_message_wait(struct ast_smdi_interface *iface, int timeout)
{
   struct ast_flags options = { 0 };
   return smdi_message_wait(iface, timeout, SMDI_MWI, NULL, options);
}

struct ast_smdi_mwi_message *ast_smdi_mwi_message_wait_station(struct ast_smdi_interface *iface, int timeout,
   const char *station)
{
   struct ast_flags options = { 0 };
   return smdi_message_wait(iface, timeout, SMDI_MWI, station, options);
}

struct ast_smdi_interface *ast_smdi_interface_find(const char *iface_name)
{
   return (ASTOBJ_CONTAINER_FIND(&smdi_ifaces, iface_name));
}

/*! 
 * \internal
 * \brief Read an SMDI message.
 *
 * \param iface_p the SMDI interface to read from.
 *
 * This function loops and reads from and SMDI interface.  It must be stopped
 * using pthread_cancel().
 */
static void *smdi_read(void *iface_p)
{
   struct ast_smdi_interface *iface = iface_p;
   struct ast_smdi_md_message *md_msg;
   struct ast_smdi_mwi_message *mwi_msg;
   char c = '\0';
   char *cp = NULL;
   int i;
   int start = 0;
      
   /* read an smdi message */
   while ((c = fgetc(iface->file))) {

      /* check if this is the start of a message */
      if (!start) {
         if (c == 'M') {
            ast_log(LOG_DEBUG, "Read an 'M' to start an SMDI message\n");
            start = 1;
         }
         continue;
      }
      
      if (c == 'D') { /* MD message */
         start = 0;

         ast_log(LOG_DEBUG, "Read a 'D' ... it's an MD message.\n");

         if (!(md_msg = ast_calloc(1, sizeof(*md_msg)))) {
            ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
            return NULL;
         }
         
         ASTOBJ_INIT(md_msg);

         /* read the message desk number */
         for (i = 0; i < sizeof(md_msg->mesg_desk_num) - 1; i++) {
            md_msg->mesg_desk_num[i] = fgetc(iface->file);
            ast_log(LOG_DEBUG, "Read a '%c'\n", md_msg->mesg_desk_num[i]);
         }

         md_msg->mesg_desk_num[sizeof(md_msg->mesg_desk_num) - 1] = '\0';
         
         ast_log(LOG_DEBUG, "The message desk number is '%s'\n", md_msg->mesg_desk_num);

         /* read the message desk terminal number */
         for (i = 0; i < sizeof(md_msg->mesg_desk_term) - 1; i++) {
            md_msg->mesg_desk_term[i] = fgetc(iface->file);
            ast_log(LOG_DEBUG, "Read a '%c'\n", md_msg->mesg_desk_term[i]);
         }

         md_msg->mesg_desk_term[sizeof(md_msg->mesg_desk_term) - 1] = '\0';

         ast_log(LOG_DEBUG, "The message desk terminal is '%s'\n", md_msg->mesg_desk_term);

         /* read the message type */
         md_msg->type = fgetc(iface->file);
       
         ast_log(LOG_DEBUG, "Message type is '%c'\n", md_msg->type);

         /* read the forwarding station number (may be blank) */
         cp = &md_msg->fwd_st[0];
         for (i = 0; i < sizeof(md_msg->fwd_st) - 1; i++) {
            if ((c = fgetc(iface->file)) == ' ') {
               *cp = '\0';
               ast_log(LOG_DEBUG, "Read a space, done looking for the forwarding station\n");
               break;
            }

            /* store c in md_msg->fwd_st */
            if (i >= iface->msdstrip) {
               ast_log(LOG_DEBUG, "Read a '%c' and stored it in the forwarding station buffer\n", c);
               *cp++ = c;
            } else {
               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);
            }
         }

         /* make sure the value is null terminated, even if this truncates it */
         md_msg->fwd_st[sizeof(md_msg->fwd_st) - 1] = '\0';
         cp = NULL;

         ast_log(LOG_DEBUG, "The forwarding station is '%s'\n", md_msg->fwd_st);

         /* Put the fwd_st in the name field so that we can use ASTOBJ_FIND to look
          * up a message on this field */
         ast_copy_string(md_msg->name, md_msg->fwd_st, sizeof(md_msg->name));

         /* read the calling station number (may be blank) */
         cp = &md_msg->calling_st[0];
         for (i = 0; i < sizeof(md_msg->calling_st) - 1; i++) {
            if (!isdigit((c = fgetc(iface->file)))) {
               *cp = '\0';
               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);
               if (c == ' ') {
                  /* Don't break on a space.  We may read the space before the calling station
                   * here if the forwarding station buffer filled up. */
                  i--; /* We're still on the same character */
                  continue;
               }
               break;
            }

            /* store c in md_msg->calling_st */
            if (i >= iface->msdstrip) {
               ast_log(LOG_DEBUG, "Read a '%c' and stored it in the calling station buffer\n", c);
               *cp++ = c;
            } else {
               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);
            }
         }

         /* make sure the value is null terminated, even if this truncates it */
         md_msg->calling_st[sizeof(md_msg->calling_st) - 1] = '\0';
         cp = NULL;

         ast_log(LOG_DEBUG, "The calling station is '%s'\n", md_msg->calling_st);

         /* add the message to the message queue */
         md_msg->timestamp = ast_tvnow();
         ast_smdi_md_message_push(iface, md_msg);
         ast_log(LOG_DEBUG, "Recieved SMDI MD message on %s\n", iface->name);
         
         ASTOBJ_UNREF(md_msg, ast_smdi_md_message_destroy);

      } else if (c == 'W') { /* MWI message */
         start = 0;

         ast_log(LOG_DEBUG, "Read a 'W', it's an MWI message. (No more debug coming for MWI messages)\n");

         if (!(mwi_msg = ast_calloc(1, sizeof(*mwi_msg)))) {
            ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
            return NULL;
         }

         ASTOBJ_INIT(mwi_msg);

         /* discard the 'I' (from 'MWI') */
         fgetc(iface->file);
         
         /* read the forwarding station number (may be blank) */
         cp = &mwi_msg->fwd_st[0];
         for (i = 0; i < sizeof(mwi_msg->fwd_st) - 1; i++) {
            if ((c = fgetc(iface->file)) == ' ') {
               *cp = '\0';
               break;
            }

            /* store c in md_msg->fwd_st */
            if (i >= iface->msdstrip)
               *cp++ = c;
         }

         /* make sure the station number is null terminated, even if this will truncate it */
         mwi_msg->fwd_st[sizeof(mwi_msg->fwd_st) - 1] = '\0';
         cp = NULL;
         
         /* Put the fwd_st in the name field so that we can use ASTOBJ_FIND to look
          * up a message on this field */
         ast_copy_string(mwi_msg->name, mwi_msg->fwd_st, sizeof(mwi_msg->name));

         /* read the mwi failure cause */
         for (i = 0; i < sizeof(mwi_msg->cause) - 1; i++)
            mwi_msg->cause[i] = fgetc(iface->file);

         mwi_msg->cause[sizeof(mwi_msg->cause) - 1] = '\0';

         /* add the message to the message queue */
         mwi_msg->timestamp = ast_tvnow();
         ast_smdi_mwi_message_push(iface, mwi_msg);
         ast_log(LOG_DEBUG, "Recieved SMDI MWI message on %s\n", iface->name);
         
         ASTOBJ_UNREF(mwi_msg, ast_smdi_mwi_message_destroy);
      } else {
         ast_log(LOG_ERROR, "Unknown SMDI message type recieved on %s (M%c).\n", iface->name, c);
         start = 0;
      }
   }

   ast_log(LOG_ERROR, "Error reading from SMDI interface %s, stopping listener thread\n", iface->name);
   ASTOBJ_UNREF(iface,ast_smdi_interface_destroy);
   return NULL;
}

void ast_smdi_md_message_destroy(struct ast_smdi_md_message *msg)
{
   free(msg);
}

void ast_smdi_mwi_message_destroy(struct ast_smdi_mwi_message *msg)
{
   free(msg);
}

static void destroy_mailbox_mapping(struct mailbox_mapping *mm)
{
   ast_string_field_free_memory(mm);
   ASTOBJ_UNREF(mm->iface, ast_smdi_interface_destroy);
   free(mm);
}

static void destroy_all_mailbox_mappings(void)
{
   struct mailbox_mapping *mm;

   ast_mutex_lock(&mwi_monitor.lock);
   while ((mm = AST_LIST_REMOVE_HEAD(&mwi_monitor.mailbox_mappings, entry)))
      destroy_mailbox_mapping(mm);
   ast_mutex_unlock(&mwi_monitor.lock);
}

static void append_mailbox_mapping(struct ast_variable *var, struct ast_smdi_interface *iface)
{
   struct mailbox_mapping *mm;
   char *mailbox, *context;

   if (!(mm = ast_calloc(1, sizeof(*mm))))
      return;
   
   if (ast_string_field_init(mm, 32)) {
      free(mm);
      return;
   }

   ast_string_field_set(mm, smdi, var->name);

   context = ast_strdupa(var->value);
   mailbox = strsep(&context, "@");
   if (ast_strlen_zero(context))
      context = "default";

   ast_string_field_set(mm, mailbox, mailbox);
   ast_string_field_set(mm, context, context);

   mm->iface = ASTOBJ_REF(iface);

   ast_mutex_lock(&mwi_monitor.lock);
   AST_LIST_INSERT_TAIL(&mwi_monitor.mailbox_mappings, mm, entry);
   ast_mutex_unlock(&mwi_monitor.lock);
}

/*!
 * \note Called with the mwi_monitor.lock locked
 */
static void poll_mailbox(struct mailbox_mapping *mm)
{
   char buf[1024];
   unsigned int state;

   snprintf(buf, sizeof(buf), "%s@%s", mm->mailbox, mm->context);

   state = !!ast_app_has_voicemail(mm->mailbox, NULL);

   if (state != mm->cur_state) {
      if (state)
         ast_smdi_mwi_set(mm->iface, mm->smdi);
      else
         ast_smdi_mwi_unset(mm->iface, mm->smdi);

      mm->cur_state = state;
   }
}

static void *mwi_monitor_handler(void *data)
{
   while (!mwi_monitor.stop) {
      struct timespec ts = { 0, };
      struct timeval tv;
      struct mailbox_mapping *mm;

      ast_mutex_lock(&mwi_monitor.lock);

      mwi_monitor.last_poll = ast_tvnow();

      AST_LIST_TRAVERSE(&mwi_monitor.mailbox_mappings, mm, entry)
         poll_mailbox(mm);

      /* Sleep up to the configured polling interval.  Allow unload_module()
       * to signal us to wake up and exit. */
      tv = ast_tvadd(mwi_monitor.last_poll, ast_tv(mwi_monitor.polling_interval, 0));
      ts.tv_sec = tv.tv_sec;
      ts.tv_nsec = tv.tv_usec * 1000;
      ast_cond_timedwait(&mwi_monitor.cond, &mwi_monitor.lock, &ts);

      ast_mutex_unlock(&mwi_monitor.lock);
   }

   return NULL;
}

static struct ast_smdi_interface *alloc_smdi_interface(void)
{
   struct ast_smdi_interface *iface;

   if (!(iface = ast_calloc(1, sizeof(*iface))))
      return NULL;

   ASTOBJ_INIT(iface);
   ASTOBJ_CONTAINER_INIT(&iface->md_q);
   ASTOBJ_CONTAINER_INIT(&iface->mwi_q);

   ast_mutex_init(&iface->md_q_lock);
   ast_cond_init(&iface->md_q_cond, NULL);

   ast_mutex_init(&iface->mwi_q_lock);
   ast_cond_init(&iface->mwi_q_cond, NULL);

   return iface;
}

/*!
 * \internal
 * \brief Load and reload SMDI configuration.
 * \param reload this should be 1 if we are reloading and 0 if not.
 *
 * This function loads/reloads the SMDI configuration and starts and stops
 * interfaces accordingly.
 *
 * \return zero on success, -1 on failure, and 1 if no smdi interfaces were started.
 */
static int smdi_load(int reload)
{
   struct ast_config *conf;
   struct ast_variable *v;
   struct ast_smdi_interface *iface = NULL;
   int res = 0;

   /* Config options */
   speed_t baud_rate = B9600;     /* 9600 baud rate */
   tcflag_t paritybit = PARENB;   /* even parity checking */
   tcflag_t charsize = CS7;       /* seven bit characters */
   int stopbits = 0;              /* One stop bit */
   
   int msdstrip = 0;              /* strip zero digits */
   long msg_expiry = SMDI_MSG_EXPIRY_TIME;
   
   conf = ast_config_load(config_file);

   if (!conf) {
      if (reload)
         ast_log(LOG_NOTICE, "Unable to reload config %s: SMDI untouched\n", config_file);
      else
         ast_log(LOG_NOTICE, "Unable to load config %s: SMDI disabled\n", config_file);
      return 1;
   }

   /* Mark all interfaces that we are listening on.  We will unmark them
    * as we find them in the config file, this way we know any interfaces
    * still marked after we have finished parsing the config file should
    * be stopped.
    */
   if (reload)
      ASTOBJ_CONTAINER_MARKALL(&smdi_ifaces);

   for (v = ast_variable_browse(conf, "interfaces"); v; v = v->next) {
      if (!strcasecmp(v->name, "baudrate")) {
         if (!strcasecmp(v->value, "9600"))
            baud_rate = B9600;
         else if (!strcasecmp(v->value, "4800"))
            baud_rate = B4800;
         else if (!strcasecmp(v->value, "2400"))
            baud_rate = B2400;
         else if (!strcasecmp(v->value, "1200"))
            baud_rate = B1200;
         else {
            ast_log(LOG_NOTICE, "Invalid baud rate '%s' specified in %s (line %d), using default\n", v->value, config_file, v->lineno);
            baud_rate = B9600;
         }
      } else if (!strcasecmp(v->name, "msdstrip")) {
         if (!sscanf(v->value, "%d", &msdstrip)) {
            ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
            msdstrip = 0;
         } else if (0 > msdstrip || msdstrip > 9) {
            ast_log(LOG_NOTICE, "Invalid msdstrip value in %s (line %d), using default\n", config_file, v->lineno);
            msdstrip = 0;
         }
      } else if (!strcasecmp(v->name, "msgexpirytime")) {
         if (!sscanf(v->value, "%ld", &msg_expiry)) {
            ast_log(LOG_NOTICE, "Invalid msgexpirytime value in %s (line %d), using default\n", config_file, v->lineno);
            msg_expiry = SMDI_MSG_EXPIRY_TIME;
         }
      } else if (!strcasecmp(v->name, "paritybit")) {
         if (!strcasecmp(v->value, "even"))
            paritybit = PARENB;
         else if (!strcasecmp(v->value, "odd"))
            paritybit = PARENB | PARODD;
         else if (!strcasecmp(v->value, "none"))
            paritybit = ~PARENB;
         else {
            ast_log(LOG_NOTICE, "Invalid parity bit setting in %s (line %d), using default\n", config_file, v->lineno);
            paritybit = PARENB;
         }
      } else if (!strcasecmp(v->name, "charsize")) {
         if (!strcasecmp(v->value, "7"))
            charsize = CS7;
         else if (!strcasecmp(v->value, "8"))
            charsize = CS8;
         else {
            ast_log(LOG_NOTICE, "Invalid character size setting in %s (line %d), using default\n", config_file, v->lineno);
            charsize = CS7;
         }
      } else if (!strcasecmp(v->name, "twostopbits")) {
         stopbits = ast_true(v->name);
      } else if (!strcasecmp(v->name, "smdiport")) {
         if (reload) {
            /* we are reloading, check if we are already
             * monitoring this interface, if we are we do
             * not want to start it again.  This also has
             * the side effect of not updating different
             * setting for the serial port, but it should
             * be trivial to rewrite this section so that
             * options on the port are changed without
             * restarting the interface.  Or the interface
             * could be restarted with out emptying the
             * queue. */
            if ((iface = ASTOBJ_CONTAINER_FIND(&smdi_ifaces, v->value))) {
               ast_log(LOG_NOTICE, "SMDI interface %s already running, not restarting\n", iface->name);
               ASTOBJ_UNMARK(iface);
               ASTOBJ_UNREF(iface, ast_smdi_interface_destroy);
               continue;