res_smdi.c File Reference

SMDI support for Asterisk. More...

#include "asterisk.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/io.h"
#include "asterisk/stringfields.h"
#include "asterisk/linkedlists.h"
#include "asterisk/app.h"
#include "asterisk/mwi.h"
#include "asterisk/pbx.h"
#include "asterisk/channel.h"

Include dependency graph for res_smdi.c:

Go to the source code of this file.

Data Structures
struct	ast_smdi_interface
struct	mailbox_mapping
	A mapping between an SMDI mailbox ID and an Asterisk mailbox. More...
struct	smdi_msg_datastore

Macros
#define	AST_API_MODULE
#define	DEFAULT_POLLING_INTERVAL   10
#define	SMDI_MSG_EXPIRY_TIME   30000 /* 30 seconds */
#define	SMDI_RETRIEVE_TIMEOUT_DEFAULT   3000

Enumerations
enum	{ OPT_SEARCH_TERMINAL = (1 << 0) , OPT_SEARCH_NUMBER = (1 << 1) }
enum	smdi_message_type { SMDI_MWI , SMDI_MD }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static struct ast_smdi_interface *	alloc_smdi_interface (void)
static	AO2_GLOBAL_OBJ_STATIC (smdi_ifaces)
static void	append_mailbox_mapping (struct ast_variable *var, struct ast_smdi_interface *iface)
struct ast_module *	AST_MODULE_SELF_SYM (void)
struct ast_smdi_interface *AST_OPTIONAL_API_NAME()	ast_smdi_interface_find (const char *iface_name)
	Find an SMDI interface with the specified name. More...
struct ast_smdi_md_message *AST_OPTIONAL_API_NAME()	ast_smdi_md_message_pop (struct ast_smdi_interface *iface)
	Get the next SMDI message from the queue. More...
static void	ast_smdi_md_message_push (struct ast_smdi_interface *iface, struct ast_smdi_md_message *md_msg)
struct ast_smdi_md_message *AST_OPTIONAL_API_NAME()	ast_smdi_md_message_wait (struct ast_smdi_interface *iface, int timeout)
	Get the next SMDI message from the queue. More...
struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME()	ast_smdi_mwi_message_pop (struct ast_smdi_interface *iface)
	Get the next SMDI message from the queue. More...
static void	ast_smdi_mwi_message_push (struct ast_smdi_interface *iface, struct ast_smdi_mwi_message *mwi_msg)
struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME()	ast_smdi_mwi_message_wait (struct ast_smdi_interface *iface, int timeout)
	Get the next SMDI message from the queue. More...
struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME()	ast_smdi_mwi_message_wait_station (struct ast_smdi_interface *iface, int timeout, const char *station)
int AST_OPTIONAL_API_NAME()	ast_smdi_mwi_set (struct ast_smdi_interface *iface, const char *mailbox)
	Set the MWI indicator for a mailbox. More...
int AST_OPTIONAL_API_NAME()	ast_smdi_mwi_unset (struct ast_smdi_interface *iface, const char *mailbox)
	Unset the MWI indicator for a mailbox. More...
static void	destroy_all_mailbox_mappings (void)
static void	destroy_mailbox_mapping (struct mailbox_mapping *mm)
static int	load_module (void)
	Load the module. More...
static int	lock_msg_q (struct ast_smdi_interface *iface, enum smdi_message_type type)
static struct timeval	msg_timestamp (void *msg, enum smdi_message_type type)
static void *	mwi_monitor_handler (void *data)
static void	poll_mailbox (struct mailbox_mapping *mm)
static void	purge_old_messages (struct ast_smdi_interface *iface, enum smdi_message_type type)
static int	reload (void)
static int	smdi_ifaces_cmp_fn (void *obj, void *data, int flags)
static void	smdi_interface_destroy (void *obj)
static int	smdi_load (int reload)
static int	smdi_md_q_cmp_fn (void *obj, void *arg, int flags)
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)
static void	smdi_msg_datastore_destroy (void *data)
static void *	smdi_msg_find (struct ast_smdi_interface *iface, enum smdi_message_type type, const char *search_key, struct ast_flags options)
static void *	smdi_msg_pop (struct ast_smdi_interface *iface, enum smdi_message_type type)
static int	smdi_msg_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	smdi_msg_retrieve_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	smdi_mwi_q_cmp_fn (void *obj, void *data, int flags)
static void *	smdi_read (void *iface_p)
static int	smdi_toggle_mwi (struct ast_smdi_interface *iface, const char *mailbox, int on)
static void *	unlink_from_msg_q (struct ast_smdi_interface *iface, enum smdi_message_type type)
static int	unload_module (void)
static int	unlock_msg_q (struct ast_smdi_interface *iface, enum smdi_message_type type)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Simplified Message Desk Interface (SMDI) Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DEPEND, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char	config_file [] = "smdi.conf"
struct {
ast_cond_t   cond
struct timeval   last_poll
ast_mutex_t   lock
struct {
struct mailbox_mapping *   first
struct mailbox_mapping *   last
}   mailbox_mappings
unsigned int   polling_interval
unsigned int   stop:1
pthread_t   thread
}	mwi_monitor
	Data that gets used by the SMDI MWI monitoring thread. More...
static const struct ast_datastore_info	smdi_msg_datastore_info
static struct ast_custom_function	smdi_msg_function
static int	smdi_msg_id
static const struct ast_app_option	smdi_msg_ret_options [128] = { [ 't' ] = { .flag = OPT_SEARCH_TERMINAL }, [ 'n' ] = { .flag = OPT_SEARCH_NUMBER }, }
static struct ast_custom_function	smdi_msg_retrieve_function

Detailed Description

SMDI support for Asterisk.

Author

Matthew A. Nicholson mnich.nosp@m.olso.nosp@m.n@dig.nosp@m.ium..nosp@m.com

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Here is a useful mailing list post that describes SMDI protocol details: http://lists.digium.com/pipermail/asterisk-dev/2003-June/000884.html

Todo:

This module currently has its own mailbox monitoring thread. This should be converted to MWI subscriptions and just let the optional global voicemail polling thread handle it.

Definition in file res_smdi.c.

Macro Definition Documentation

AST_API_MODULE

#define AST_API_MODULE

Definition at line 57 of file res_smdi.c.

DEFAULT_POLLING_INTERVAL

#define DEFAULT_POLLING_INTERVAL   10

10 seconds

Definition at line 210 of file res_smdi.c.

SMDI_MSG_EXPIRY_TIME

#define SMDI_MSG_EXPIRY_TIME   30000 /* 30 seconds */

Definition at line 69 of file res_smdi.c.

SMDI_RETRIEVE_TIMEOUT_DEFAULT

#define SMDI_RETRIEVE_TIMEOUT_DEFAULT   3000

In milliseconds

Definition at line 1201 of file res_smdi.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
OPT_SEARCH_TERMINAL
OPT_SEARCH_NUMBER

Definition at line 435 of file res_smdi.c.

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

smdi_message_type

enum smdi_message_type

Enumerator
SMDI_MWI
SMDI_MD

Definition at line 325 of file res_smdi.c.

                       {
    SMDI_MWI,
    SMDI_MD,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1458 of file res_smdi.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1458 of file res_smdi.c.

alloc_smdi_interface()

static struct ast_smdi_interface * alloc_smdi_interface ( void  )

static

Definition at line 920 of file res_smdi.c.

{
    struct ast_smdi_interface *iface;
 
    if (!(iface = ao2_alloc(sizeof(*iface), smdi_interface_destroy))) {
        return NULL;
    }
 
    iface->md_q = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, smdi_md_q_cmp_fn);
    iface->mwi_q = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, smdi_mwi_q_cmp_fn);
 
    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;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_container_alloc_list, ast_cond_init, ast_mutex_init, ast_smdi_interface::md_q, ast_smdi_interface::md_q_cond, ast_smdi_interface::md_q_lock, ast_smdi_interface::mwi_q, ast_smdi_interface::mwi_q_cond, ast_smdi_interface::mwi_q_lock, NULL, smdi_interface_destroy(), smdi_md_q_cmp_fn(), and smdi_mwi_q_cmp_fn().

Referenced by smdi_load().

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( smdi_ifaces  )

static

append_mailbox_mapping()

static void append_mailbox_mapping ( struct ast_variable *  var, struct ast_smdi_interface *  iface  )

static

Definition at line 811 of file res_smdi.c.

{
    struct mailbox_mapping *mm;
    char *mailbox, *context;
 
    if (!(mm = ast_calloc_with_stringfields(1, struct mailbox_mapping, 32)))
        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 = ao2_bump(iface);
 
    ast_mutex_lock(&mwi_monitor.lock);
    AST_LIST_INSERT_TAIL(&mwi_monitor.mailbox_mappings, mm, entry);
    ast_mutex_unlock(&mwi_monitor.lock);
}

References ao2_bump, ast_calloc_with_stringfields, AST_LIST_INSERT_TAIL, ast_mutex_lock, ast_mutex_unlock, ast_strdupa, ast_string_field_set, ast_strlen_zero(), voicemailpwcheck::context, mailbox_mapping::entry, mailbox_mapping::iface, voicemailpwcheck::mailbox, mwi_monitor, mailbox_mapping::smdi, strsep(), and var.

Referenced by smdi_load().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1458 of file res_smdi.c.

ast_smdi_interface_find()

struct ast_smdi_interface *AST_OPTIONAL_API_NAME() ast_smdi_interface_find

(

const char *

iface_name

)

Find an SMDI interface with the specified name.

Parameters

iface_name

the name/port of the interface to search for.

Returns

an ao2 reference to the interface located or NULL if none was found.

Definition at line 569 of file res_smdi.c.

{
    struct ao2_container *c;
    struct ast_smdi_interface *iface = NULL;
 
    c = ao2_global_obj_ref(smdi_ifaces);
    if (c) {
        iface = ao2_find(c, iface_name, OBJ_SEARCH_KEY);
        ao2_ref(c, -1);
    }
 
    return iface;
}

References ao2_find, ao2_global_obj_ref, ao2_ref, c, NULL, and OBJ_SEARCH_KEY.

Referenced by actual_load_config(), mkintf(), and smdi_msg_retrieve_read().

ast_smdi_md_message_pop()

struct ast_smdi_md_message *AST_OPTIONAL_API_NAME() ast_smdi_md_message_pop

(

struct ast_smdi_interface *

iface

)

Get the next SMDI message from the queue.

Parameters

iface

a pointer to the interface to use.

This function pulls the first unexpired message from the SMDI message queue on the specified interface. It will purge all expired SMDI messages before returning.

Returns

the next SMDI message, or NULL if there were no pending messages.

Definition at line 540 of file res_smdi.c.

{
    return smdi_msg_pop(iface, SMDI_MD);
}

References SMDI_MD, and smdi_msg_pop().

ast_smdi_md_message_push()

static void ast_smdi_md_message_push ( struct ast_smdi_interface *  iface, struct ast_smdi_md_message *  md_msg  )

static

Definition at line 266 of file res_smdi.c.

{
    ast_mutex_lock(&iface->md_q_lock);
    ao2_link(iface->md_q, md_msg);
    ast_cond_broadcast(&iface->md_q_cond);
    ast_mutex_unlock(&iface->md_q_lock);
}

References ao2_link, ast_cond_broadcast, ast_mutex_lock, ast_mutex_unlock, ast_smdi_interface::md_q, ast_smdi_interface::md_q_cond, and ast_smdi_interface::md_q_lock.

Referenced by purge_old_messages(), and smdi_read().

ast_smdi_md_message_wait()

struct ast_smdi_md_message *AST_OPTIONAL_API_NAME() ast_smdi_md_message_wait	(	struct ast_smdi_interface *	iface,
		int	timeout
	)

Get the next SMDI message from the queue.

Parameters

iface	a pointer to the interface to use.
timeout	the time to wait before returning in milliseconds.

This function pulls a message from the SMDI message queue on the specified interface. If no message is available this function will wait the specified amount of time before returning.

Returns

the next SMDI message, or NULL if there were no pending messages and the timeout has expired.

Definition at line 545 of file res_smdi.c.

{
    struct ast_flags options = { 0 };
    return smdi_message_wait(iface, timeout, SMDI_MD, NULL, options);
}

References NULL, options, SMDI_MD, and smdi_message_wait().

Referenced by __analog_ss_thread(), and analog_ss_thread().

ast_smdi_mwi_message_pop()

struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME() ast_smdi_mwi_message_pop

(

struct ast_smdi_interface *

iface

)

Get the next SMDI message from the queue.

Parameters

iface

a pointer to the interface to use.

This function pulls the first unexpired message from the SMDI message queue on the specified interface. It will purge all expired SMDI messages before returning.

Returns

the next SMDI message, or NULL if there were no pending messages.

Definition at line 551 of file res_smdi.c.

{
    return smdi_msg_pop(iface, SMDI_MWI);
}

References smdi_msg_pop(), and SMDI_MWI.

ast_smdi_mwi_message_push()

static void ast_smdi_mwi_message_push ( struct ast_smdi_interface *  iface, struct ast_smdi_mwi_message *  mwi_msg  )

static

Definition at line 280 of file res_smdi.c.

{
    ast_mutex_lock(&iface->mwi_q_lock);
    ao2_link(iface->mwi_q, mwi_msg);
    ast_cond_broadcast(&iface->mwi_q_cond);
    ast_mutex_unlock(&iface->mwi_q_lock);
}

References ao2_link, ast_cond_broadcast, ast_mutex_lock, ast_mutex_unlock, ast_smdi_interface::mwi_q, ast_smdi_interface::mwi_q_cond, and ast_smdi_interface::mwi_q_lock.

Referenced by purge_old_messages(), and smdi_read().

ast_smdi_mwi_message_wait()

struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME() ast_smdi_mwi_message_wait	(	struct ast_smdi_interface *	iface,
		int	timeout
	)

Get the next SMDI message from the queue.

Parameters

iface	a pointer to the interface to use.
timeout	the time to wait before returning in milliseconds.

This function pulls a message from the SMDI message queue on the specified interface. If no message is available this function will wait the specified amount of time before returning.

Returns

the next SMDI message, or NULL if there were no pending messages and the timeout has expired.

Definition at line 556 of file res_smdi.c.

{
    struct ast_flags options = { 0 };
    return smdi_message_wait(iface, timeout, SMDI_MWI, NULL, options);
}

References NULL, options, smdi_message_wait(), and SMDI_MWI.

ast_smdi_mwi_message_wait_station()

struct ast_smdi_mwi_message *AST_OPTIONAL_API_NAME() ast_smdi_mwi_message_wait_station	(	struct ast_smdi_interface *	iface,
		int	timeout,
		const char *	station
	)

Definition at line 562 of file res_smdi.c.

{
    struct ast_flags options = { 0 };
    return smdi_message_wait(iface, timeout, SMDI_MWI, station, options);
}

References options, smdi_message_wait(), and SMDI_MWI.

Referenced by run_externnotify().

ast_smdi_mwi_set()

int AST_OPTIONAL_API_NAME() ast_smdi_mwi_set	(	struct ast_smdi_interface *	iface,
		const char *	mailbox
	)

Set the MWI indicator for a mailbox.

Parameters

iface	the interface to use.
mailbox	the mailbox to use.

Definition at line 315 of file res_smdi.c.

{
    return smdi_toggle_mwi(iface, mailbox, 1);
}

References voicemailpwcheck::mailbox, and smdi_toggle_mwi().

Referenced by poll_mailbox(), and run_externnotify().

ast_smdi_mwi_unset()

int AST_OPTIONAL_API_NAME() ast_smdi_mwi_unset	(	struct ast_smdi_interface *	iface,
		const char *	mailbox
	)

Unset the MWI indicator for a mailbox.

Parameters

iface	the interface to use.
mailbox	the mailbox to use.

Definition at line 320 of file res_smdi.c.

{
    return smdi_toggle_mwi(iface, mailbox, 0);
}

References voicemailpwcheck::mailbox, and smdi_toggle_mwi().

Referenced by poll_mailbox(), and run_externnotify().

destroy_all_mailbox_mappings()

static void destroy_all_mailbox_mappings ( void  )

static

Definition at line 801 of file res_smdi.c.

{
    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);
}

References AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, destroy_mailbox_mapping(), mailbox_mapping::entry, and mwi_monitor.

Referenced by smdi_load(), and unload_module().

destroy_mailbox_mapping()

static void destroy_mailbox_mapping ( struct mailbox_mapping *  mm )

static

Definition at line 794 of file res_smdi.c.

{
    ast_string_field_free_memory(mm);
    ao2_ref(mm->iface, -1);
    ast_free(mm);
}

References ao2_ref, ast_free, ast_string_field_free_memory, and mailbox_mapping::iface.

Referenced by destroy_all_mailbox_mappings().

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 1417 of file res_smdi.c.

{
    int res;
 
    ast_mutex_init(&mwi_monitor.lock);
    ast_cond_init(&mwi_monitor.cond, NULL);
 
    /* load the config and start the listener threads*/
    res = smdi_load(0);
    if (res < 0) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    } else if (res == 1) {
        ast_log(LOG_NOTICE, "No SMDI interfaces are available to listen on, not starting SMDI listener.\n");
    }
 
    ast_custom_function_register(&smdi_msg_retrieve_function);
    ast_custom_function_register(&smdi_msg_function);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_cond_init, ast_custom_function_register, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_mutex_init, LOG_NOTICE, mwi_monitor, NULL, smdi_load(), smdi_msg_function, smdi_msg_retrieve_function, and unload_module().

lock_msg_q()

static int lock_msg_q ( struct ast_smdi_interface *  iface, enum smdi_message_type  type  )

inlinestatic

Definition at line 330 of file res_smdi.c.

{
    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;
}

References ast_mutex_lock, ast_smdi_interface::md_q_lock, ast_smdi_interface::mwi_q_lock, SMDI_MD, SMDI_MWI, and type.

Referenced by purge_old_messages(), smdi_message_wait(), and smdi_msg_pop().

msg_timestamp()

static struct timeval msg_timestamp ( void *  msg, enum smdi_message_type  type  )

inlinestatic

Definition at line 366 of file res_smdi.c.

{
    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);
}

References ast_tv(), SMDI_MD, SMDI_MWI, ast_smdi_mwi_message::timestamp, ast_smdi_md_message::timestamp, and type.

Referenced by ari_websocket_send_event(), and purge_old_messages().

mwi_monitor_handler()

static void * mwi_monitor_handler ( void *  data )

static

Definition at line 858 of file res_smdi.c.

{
    while (!mwi_monitor.stop) {
        struct timespec ts = { 0, };
        struct timeval polltime;
        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. */
        polltime = ast_tvadd(mwi_monitor.last_poll, ast_tv(mwi_monitor.polling_interval, 0));
        ts.tv_sec = polltime.tv_sec;
        ts.tv_nsec = polltime.tv_usec * 1000;
        ast_cond_timedwait(&mwi_monitor.cond, &mwi_monitor.lock, &ts);
 
        ast_mutex_unlock(&mwi_monitor.lock);
    }
 
    return NULL;
}

References ast_cond_timedwait, AST_LIST_TRAVERSE, ast_mutex_lock, ast_mutex_unlock, ast_tv(), ast_tvadd(), ast_tvnow(), mailbox_mapping::entry, mwi_monitor, NULL, and poll_mailbox().

Referenced by smdi_load().

poll_mailbox()

static void poll_mailbox ( struct mailbox_mapping *  mm )

static

Note

Called with the mwi_monitor.lock locked

Definition at line 839 of file res_smdi.c.

{
    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;
    }
}

References ast_app_has_voicemail(), ast_smdi_mwi_set(), ast_smdi_mwi_unset(), buf, mailbox_mapping::context, mailbox_mapping::cur_state, mailbox_mapping::iface, mailbox_mapping::mailbox, NULL, mailbox_mapping::smdi, and state.

Referenced by mwi_monitor_handler().

purge_old_messages()

static void purge_old_messages ( struct ast_smdi_interface *  iface, enum smdi_message_type  type  )

static

Definition at line 381 of file res_smdi.c.

{
    struct timeval now = ast_tvnow();
    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 */
    while (msg) {
        elapsed = ast_tvdiff_ms(now, msg_timestamp(msg, type));
 
        if (elapsed > iface->msg_expiry) {
            /* found an expired message */
            ao2_ref(msg, -1);
            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;
            }
            ao2_ref(msg, -1);
            break;
        }
    }
}

References ao2_ref, ast_log, ast_smdi_md_message_push(), ast_smdi_mwi_message_push(), ast_tvdiff_ms(), ast_tvnow(), lock_msg_q(), LOG_NOTICE, ast_smdi_interface::msg_expiry, msg_timestamp(), ast_smdi_interface::name, SMDI_MD, SMDI_MWI, type, unlink_from_msg_q(), and unlock_msg_q().

Referenced by smdi_msg_find(), and smdi_msg_pop().

reload()

static int reload ( void  )

static

Definition at line 1439 of file res_smdi.c.

{
    int res;
 
    res = smdi_load(1);
    if (res < 0) {
        return res;
    } else if (res == 1) {
        ast_log(LOG_WARNING, "No SMDI interfaces were specified to listen on, not starting SDMI listener.\n");
    }
    return 0;
}

References ast_log, LOG_WARNING, and smdi_load().

Referenced by smdi_load().

smdi_ifaces_cmp_fn()

static int smdi_ifaces_cmp_fn ( void *  obj, void *  data, int  flags  )

static

Definition at line 940 of file res_smdi.c.

{
    struct ast_smdi_interface *iface = obj;
 
    char *str = data;
    return !strcmp(iface->name, str) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, ast_smdi_interface::name, and str.

Referenced by smdi_load().

smdi_interface_destroy()

static void smdi_interface_destroy ( void *  obj )

static

Definition at line 230 of file res_smdi.c.

{
    struct ast_smdi_interface *iface = obj;
    int mod_unref_defer = 0;
 
    if (iface->thread != AST_PTHREADT_NULL && iface->thread != AST_PTHREADT_STOP) {
        pthread_cancel(iface->thread);
        pthread_join(iface->thread, NULL);
        mod_unref_defer = 1;
    }
 
    iface->thread = AST_PTHREADT_STOP;
 
    if (iface->file) {
        fclose(iface->file);
    }
 
    ao2_cleanup(iface->md_q);
    ast_mutex_destroy(&iface->md_q_lock);
    ast_cond_destroy(&iface->md_q_cond);
 
    ao2_cleanup(iface->mwi_q);
    ast_mutex_destroy(&iface->mwi_q_lock);
    ast_cond_destroy(&iface->mwi_q_cond);
 
    if (mod_unref_defer) {
        ast_module_unref(ast_module_info->self);
    }
}

References ao2_cleanup, ast_cond_destroy, ast_module_unref, ast_mutex_destroy, AST_PTHREADT_NULL, AST_PTHREADT_STOP, ast_smdi_interface::file, ast_smdi_interface::md_q, ast_smdi_interface::md_q_cond, ast_smdi_interface::md_q_lock, ast_smdi_interface::mwi_q, ast_smdi_interface::mwi_q_cond, ast_smdi_interface::mwi_q_lock, NULL, ast_module_info::self, and ast_smdi_interface::thread.

Referenced by alloc_smdi_interface().

smdi_load()

static int smdi_load ( int  reload )

static

Definition at line 958 of file res_smdi.c.

{
    struct ast_config *conf;
    struct ast_variable *v;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    int res = 0;
    RAII_VAR(struct ao2_container *, new_ifaces, NULL, ao2_cleanup);
    RAII_VAR(struct ao2_container *, old_ifaces, ao2_global_obj_ref(smdi_ifaces), ao2_cleanup);
    struct ast_smdi_interface *mailbox_iface = NULL;
 
    /* 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;
 
    if (!(conf = ast_config_load(config_file, config_flags)) || conf == CONFIG_STATUS_FILEINVALID) {
        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;
    } else if (conf == CONFIG_STATUS_FILEUNCHANGED)
        return 0;
 
    new_ifaces = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, smdi_ifaces_cmp_fn);
    if (!new_ifaces) {
        ast_config_destroy(conf);
        return -1;
    }
 
    for (v = ast_variable_browse(conf, "interfaces"); v; v = v->next) {
        RAII_VAR(struct ast_smdi_interface *, iface, NULL, ao2_cleanup);
 
        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, "%30d", &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, "%30ld", &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 && old_ifaces) {
                /* 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 = ao2_find(old_ifaces, v->value, OBJ_SEARCH_KEY))) {
                    ast_log(LOG_NOTICE, "SMDI interface %s already running, not restarting\n", iface->name);
                    ao2_link(new_ifaces, iface);
                    continue;
                }
            }
 
            if (!(iface = alloc_smdi_interface()))
                continue;
 
            ast_copy_string(iface->name, v->value, sizeof(iface->name));
 
            iface->thread = AST_PTHREADT_NULL;
 
            if (!(iface->file = fopen(iface->name, "r"))) {
                ast_log(LOG_ERROR, "Error opening SMDI interface %s (%s)\n", iface->name, strerror(errno));
                continue;
            }
 
            iface->fd = fileno(iface->file);
 
            /* Set the proper attributes for our serial port. */
 
            /* get the current attributes from the port */
            if (tcgetattr(iface->fd, &iface->mode)) {
                ast_log(LOG_ERROR, "Error getting attributes of %s (%s)\n", iface->name, strerror(errno));
                continue;
            }
 
            /* set the desired speed */
            if (cfsetispeed(&iface->mode, baud_rate) || cfsetospeed(&iface->mode, baud_rate)) {
                ast_log(LOG_ERROR, "Error setting baud rate on %s (%s)\n", iface->name, strerror(errno));
                continue;
            }
 
            /* set the stop bits */
            if (stopbits)
                iface->mode.c_cflag = iface->mode.c_cflag | CSTOPB;   /* set two stop bits */
            else
                iface->mode.c_cflag = iface->mode.c_cflag & ~CSTOPB;  /* set one stop bit */
 
            /* set the parity */
            iface->mode.c_cflag = (iface->mode.c_cflag & ~PARENB & ~PARODD) | paritybit;
 
            /* set the character size */
            iface->mode.c_cflag = (iface->mode.c_cflag & ~CSIZE) | charsize;
 
            /* commit the desired attributes */
            if (tcsetattr(iface->fd, TCSAFLUSH, &iface->mode)) {
                ast_log(LOG_ERROR, "Error setting attributes on %s (%s)\n", iface->name, strerror(errno));
                continue;
            }
 
            /* set the msdstrip */
            iface->msdstrip = msdstrip;
 
            /* set the message expiry time */
            iface->msg_expiry = msg_expiry;
 
            /*
             * start the listener thread
             *
             * The listener thread does not actually hold a ref to iface.  When all
             * external refs go away, the destructor will stop the listener thread
             * before actually destroying the iface object.
             */
            ast_verb(3, "Starting SMDI monitor thread for %s\n", iface->name);
            if (ast_pthread_create_background(&iface->thread, NULL, smdi_read, iface)) {
                ast_log(LOG_ERROR, "Error starting SMDI monitor thread for %s\n", iface->name);
                continue;
            }
 
            ao2_link(new_ifaces, iface);
            ast_module_ref(ast_module_info->self);
        } else {
            ast_log(LOG_NOTICE, "Ignoring unknown option %s in %s\n", v->name, config_file);
        }
    }
 
    destroy_all_mailbox_mappings();
    mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
 
    for (v = ast_variable_browse(conf, "mailboxes"); v; v = v->next) {
        if (!strcasecmp(v->name, "smdiport")) {
            ao2_cleanup(mailbox_iface);
 
            if (!(mailbox_iface = ao2_find(new_ifaces, v->value, OBJ_SEARCH_KEY))) {
                ast_log(LOG_NOTICE, "SMDI interface %s not found\n", v->value);
                continue;
            }
        } else if (!strcasecmp(v->name, "pollinginterval")) {
            if (sscanf(v->value, "%30u", &mwi_monitor.polling_interval) != 1) {
                ast_log(LOG_ERROR, "Invalid value for pollinginterval: %s\n", v->value);
                mwi_monitor.polling_interval = DEFAULT_POLLING_INTERVAL;
            }
        } else {
            if (!mailbox_iface) {
                ast_log(LOG_ERROR, "Mailbox mapping ignored, no valid SMDI interface specified in mailboxes section\n");
                continue;
            }
            append_mailbox_mapping(v, mailbox_iface);
        }
    }
    ao2_cleanup(mailbox_iface);
 
    ast_config_destroy(conf);
 
    ao2_global_obj_replace_unref(smdi_ifaces, new_ifaces);
 
    if (!AST_LIST_EMPTY(&mwi_monitor.mailbox_mappings) && mwi_monitor.thread == AST_PTHREADT_NULL
        && ast_pthread_create_background(&mwi_monitor.thread, NULL, mwi_monitor_handler, NULL)) {
        ast_log(LOG_ERROR, "Failed to start MWI monitoring thread.  This module will not operate.\n");
        return -1;
    }
 
    if (!ao2_container_count(new_ifaces)) {
        res = 1;
    }
 
    return res;
}

References alloc_smdi_interface(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_list, ao2_container_count(), ao2_find, ao2_global_obj_ref, ao2_global_obj_replace_unref, ao2_link, append_mailbox_mapping(), ast_config_destroy(), ast_config_load, ast_copy_string(), AST_LIST_EMPTY, ast_log, ast_module_ref, ast_pthread_create_background, AST_PTHREADT_NULL, ast_true(), ast_variable_browse(), ast_verb, config_file, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_POLLING_INTERVAL, destroy_all_mailbox_mappings(), errno, ast_smdi_interface::fd, ast_smdi_interface::file, ast_variable::lineno, LOG_ERROR, LOG_NOTICE, ast_smdi_interface::mode, ast_smdi_interface::msdstrip, ast_smdi_interface::msg_expiry, mwi_monitor, mwi_monitor_handler(), ast_variable::name, ast_smdi_interface::name, ast_variable::next, NULL, OBJ_SEARCH_KEY, RAII_VAR, reload(), ast_module_info::self, smdi_ifaces_cmp_fn(), SMDI_MSG_EXPIRY_TIME, smdi_read(), ast_smdi_interface::thread, and ast_variable::value.

Referenced by load_module(), and reload().

smdi_md_q_cmp_fn()

static int smdi_md_q_cmp_fn ( void *  obj, void *  arg, int  flags  )

static

Definition at line 892 of file res_smdi.c.

{
    const struct ast_smdi_md_message *msg = obj;
    const struct ast_smdi_md_message *search_msg = arg;
    const char *search_key = arg;
    int cmp = 0;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        if (!ast_strlen_zero(search_msg->mesg_desk_num)) {
            cmp = strcmp(msg->mesg_desk_num, search_msg->mesg_desk_num);
        }
        if (!ast_strlen_zero(search_msg->mesg_desk_term)) {
            cmp |= strcmp(msg->mesg_desk_term, search_msg->mesg_desk_term);
        }
        break;
    case OBJ_SEARCH_KEY:
        cmp = strcmp(msg->name, search_key);
        break;
    }
 
    if (cmp) {
        return 0;
    }
 
    return CMP_MATCH;
}

References ast_strlen_zero(), CMP_MATCH, ast_smdi_md_message::mesg_desk_num, ast_smdi_md_message::mesg_desk_term, ast_smdi_md_message::name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by alloc_smdi_interface().

smdi_message_wait()

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  )

static

Definition at line 484 of file res_smdi.c.

{
    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 wait;
 
        lock_msg_q(iface, type);
 
        if ((msg = smdi_msg_find(iface, type, search_key, options))) {
            unlock_msg_q(iface, type);
            return msg;
        }
 
        wait = ast_tvadd(start, ast_tv(0, timeout));
        ts.tv_sec = wait.tv_sec;
        ts.tv_nsec = wait.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;
}

References ast_cond_timedwait, ast_tv(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), cond, lock, lock_msg_q(), ast_smdi_interface::md_q_cond, ast_smdi_interface::md_q_lock, ast_smdi_interface::mwi_q_cond, ast_smdi_interface::mwi_q_lock, NULL, options, SMDI_MD, smdi_msg_find(), SMDI_MWI, type, and unlock_msg_q().

Referenced by ast_smdi_md_message_wait(), ast_smdi_mwi_message_wait(), ast_smdi_mwi_message_wait_station(), and smdi_msg_retrieve_read().

smdi_msg_datastore_destroy()

static void smdi_msg_datastore_destroy ( void *  data )

static

Definition at line 1183 of file res_smdi.c.

{
    struct smdi_msg_datastore *smd = data;
 
    ao2_cleanup(smd->iface);
    ao2_cleanup(smd->md_msg);
 
    ast_free(smd);
}

References ao2_cleanup, ast_free, smdi_msg_datastore::iface, and smdi_msg_datastore::md_msg.

Referenced by smdi_msg_retrieve_read().

smdi_msg_find()

static void * smdi_msg_find ( struct ast_smdi_interface *  iface, enum smdi_message_type  type, const char *  search_key, struct ast_flags  options  )

static

Definition at line 440 of file res_smdi.c.

{
    void *msg = NULL;
 
    purge_old_messages(iface, type);
 
    switch (type) {
    case SMDI_MD:
        if (ast_strlen_zero(search_key)) {
            /* No search key provided (the code from chan_dahdi does this).
             * Just pop the top message off of the queue. */
 
            msg = ao2_callback(iface->md_q, 0, NULL, NULL);
        } else if (ast_test_flag(&options, OPT_SEARCH_TERMINAL)) {
            /* Searching by the message desk terminal */
            struct ast_smdi_md_message md_msg = { .name = "" };
            strncpy(md_msg.mesg_desk_term, search_key, SMDI_MESG_DESK_TERM_LEN);
            msg = ao2_find(iface->md_q, &md_msg, OBJ_SEARCH_OBJECT);
        } else if (ast_test_flag(&options, OPT_SEARCH_NUMBER)) {
            /* Searching by the message desk number */
            struct ast_smdi_md_message md_msg = { .name = "" };
            strncpy(md_msg.mesg_desk_num, search_key, SMDI_MESG_DESK_NUM_LEN);
            msg = ao2_find(iface->md_q, &md_msg, OBJ_SEARCH_OBJECT);
        } else {
            /* Searching by the forwarding station */
            msg = ao2_find(iface->md_q, search_key, OBJ_SEARCH_KEY);
        }
        break;
    case SMDI_MWI:
        if (ast_strlen_zero(search_key)) {
            /* No search key provided (the code from chan_dahdi does this).
             * Just pop the top message off of the queue. */
 
            msg = ao2_callback(iface->mwi_q, 0, NULL, NULL);
        } else {
            msg = ao2_find(iface->mwi_q, search_key, OBJ_SEARCH_KEY);
        }
        break;
    }
 
    return msg;
}

References ao2_callback, ao2_find, ast_strlen_zero(), ast_test_flag, ast_smdi_interface::md_q, ast_smdi_md_message::mesg_desk_num, ast_smdi_md_message::mesg_desk_term, ast_smdi_interface::mwi_q, ast_smdi_md_message::name, NULL, OBJ_SEARCH_KEY, OBJ_SEARCH_OBJECT, OPT_SEARCH_NUMBER, OPT_SEARCH_TERMINAL, options, purge_old_messages(), SMDI_MD, SMDI_MESG_DESK_NUM_LEN, SMDI_MESG_DESK_TERM_LEN, SMDI_MWI, and type.

Referenced by smdi_message_wait().

smdi_msg_pop()

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

static

Definition at line 422 of file res_smdi.c.

{
    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;
}

References lock_msg_q(), purge_old_messages(), type, unlink_from_msg_q(), and unlock_msg_q().

Referenced by ast_smdi_md_message_pop(), and ast_smdi_mwi_message_pop().

smdi_msg_read()

static int smdi_msg_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 1304 of file res_smdi.c.

{
    struct ast_module_user *u;
    int res = -1;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(id);
        AST_APP_ARG(component);
    );
    char *parse;
    struct ast_datastore *datastore = NULL;
    struct smdi_msg_datastore *smd = NULL;
 
    u = ast_module_user_add(chan);
 
    if (!chan) {
        ast_log(LOG_ERROR, "SMDI_MSG can not be called without a channel\n");
        goto return_error;
    }
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "SMDI_MSG requires an argument\n");
        goto return_error;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.id)) {
        ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
        goto return_error;
    }
 
    if (ast_strlen_zero(args.component)) {
        ast_log(LOG_WARNING, "ID must be supplied to SMDI_MSG\n");
        goto return_error;
    }
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &smdi_msg_datastore_info, args.id);
    ast_channel_unlock(chan);
 
    if (!datastore) {
        ast_log(LOG_WARNING, "No SMDI message found for message ID '%s'\n", args.id);
        goto return_error;
    }
 
    smd = datastore->data;
 
    if (!strcasecmp(args.component, "number")) {
        ast_copy_string(buf, smd->md_msg->mesg_desk_num, len);
    } else if (!strcasecmp(args.component, "terminal")) {
        ast_copy_string(buf, smd->md_msg->mesg_desk_term, len);
    } else if (!strcasecmp(args.component, "station")) {
        ast_copy_string(buf, smd->md_msg->fwd_st, len);
    } else if (!strcasecmp(args.component, "callerid")) {
        ast_copy_string(buf, smd->md_msg->calling_st, len);
    } else if (!strcasecmp(args.component, "type")) {
        snprintf(buf, len, "%c", smd->md_msg->type);
    } else {
        ast_log(LOG_ERROR, "'%s' is not a valid message component for SMDI_MSG\n",
            args.component);
        goto return_error;
    }
 
    res = 0;
 
return_error:
    ast_module_user_remove(u);
 
    return res;
}

References args, AST_APP_ARG, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_log, ast_module_user_add, ast_module_user_remove, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), buf, ast_smdi_md_message::calling_st, ast_datastore::data, ast_smdi_md_message::fwd_st, len(), LOG_ERROR, LOG_WARNING, smdi_msg_datastore::md_msg, ast_smdi_md_message::mesg_desk_num, ast_smdi_md_message::mesg_desk_term, NULL, smdi_msg_datastore_info, and ast_smdi_md_message::type.

smdi_msg_retrieve_read()

static int smdi_msg_retrieve_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 1208 of file res_smdi.c.

{
    struct ast_module_user *u;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(port);
        AST_APP_ARG(search_key);
        AST_APP_ARG(timeout);
        AST_APP_ARG(options);
    );
    struct ast_flags options = { 0 };
    unsigned int timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
    int res = -1;
    char *parse = NULL;
    struct smdi_msg_datastore *smd = NULL;
    struct ast_datastore *datastore = NULL;
    struct ast_smdi_interface *iface = NULL;
    struct ast_smdi_md_message *md_msg = NULL;
 
    u = ast_module_user_add(chan);
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE requires an argument\n");
        goto return_error;
    }
 
    if (!chan) {
        ast_log(LOG_ERROR, "SMDI_MSG_RETRIEVE must be used with a channel\n");
        goto return_error;
    }
 
    ast_autoservice_start(chan);
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.port) || ast_strlen_zero(args.search_key)) {
        ast_log(LOG_ERROR, "Invalid arguments provided to SMDI_MSG_RETRIEVE\n");
        goto return_error;
    }
 
    if (!(iface = ast_smdi_interface_find(args.port))) {
        ast_log(LOG_ERROR, "SMDI port '%s' not found\n", args.port);
        goto return_error;
    }
 
    if (!ast_strlen_zero(args.options)) {
        ast_app_parse_options(smdi_msg_ret_options, &options, NULL, args.options);
    }
 
    if (!ast_strlen_zero(args.timeout)) {
        if (sscanf(args.timeout, "%30u", &timeout) != 1) {
            ast_log(LOG_ERROR, "'%s' is not a valid timeout\n", args.timeout);
            timeout = SMDI_RETRIEVE_TIMEOUT_DEFAULT;
        }
    }
 
    if (!(md_msg = smdi_message_wait(iface, timeout, SMDI_MD, args.search_key, options))) {
        ast_log(LOG_WARNING, "No SMDI message retrieved for search key '%s' after "
            "waiting %u ms.\n", args.search_key, timeout);
        goto return_error;
    }
 
    if (!(smd = ast_calloc(1, sizeof(*smd))))
        goto return_error;
 
    smd->iface = ao2_bump(iface);
    smd->md_msg = ao2_bump(md_msg);
    smd->id = ast_atomic_fetchadd_int((int *) &smdi_msg_id, 1);
    snprintf(buf, len, "%u", smd->id);
 
    if (!(datastore = ast_datastore_alloc(&smdi_msg_datastore_info, buf)))
        goto return_error;
 
    datastore->data = smd;
 
    ast_channel_lock(chan);
    ast_channel_datastore_add(chan, datastore);
    ast_channel_unlock(chan);
 
    res = 0;
 
return_error:
    ao2_cleanup(iface);
    ao2_cleanup(md_msg);
 
    if (smd && !datastore)
        smdi_msg_datastore_destroy(smd);
 
    if (parse)
        ast_autoservice_stop(chan);
 
    ast_module_user_remove(u);
 
    return res;
}

References ao2_bump, ao2_cleanup, args, AST_APP_ARG, ast_app_parse_options(), ast_atomic_fetchadd_int(), ast_autoservice_start(), ast_autoservice_stop(), ast_calloc, ast_channel_datastore_add(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, AST_DECLARE_APP_ARGS, ast_log, ast_module_user_add, ast_module_user_remove, ast_smdi_interface_find(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), buf, ast_datastore::data, smdi_msg_datastore::id, smdi_msg_datastore::iface, len(), LOG_ERROR, LOG_WARNING, smdi_msg_datastore::md_msg, NULL, options, SMDI_MD, smdi_message_wait(), smdi_msg_datastore_destroy(), smdi_msg_datastore_info, smdi_msg_id, smdi_msg_ret_options, and SMDI_RETRIEVE_TIMEOUT_DEFAULT.

smdi_mwi_q_cmp_fn()

static int smdi_mwi_q_cmp_fn ( void *  obj, void *  data, int  flags  )

static

Definition at line 885 of file res_smdi.c.

{
    struct ast_smdi_mwi_message *msg = obj;
    char *str = data;
    return !strcmp(msg->name, str) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, ast_smdi_mwi_message::name, and str.

Referenced by alloc_smdi_interface().

smdi_read()

static void * smdi_read ( void *  iface_p )

static

Definition at line 592 of file res_smdi.c.

{
    struct ast_smdi_interface *iface = iface_p;
    struct ast_smdi_md_message *md_msg;
    struct ast_smdi_mwi_message *mwi_msg;
    char *cp = NULL;
    int i, c;
    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_debug(1, "Read an 'M' to start an SMDI message\n");
                start = 1;
            }
            continue;
        }
 
        if (c == 'D') { /* MD message */
            start = 0;
 
            ast_debug(1, "Read a 'D' ... it's an MD message.\n");
 
            md_msg = ao2_alloc(sizeof(*md_msg), NULL);
            if (!md_msg) {
                return NULL;
            }
 
            /* read the message desk number */
            for (i = 0; i < sizeof(md_msg->mesg_desk_num) - 1; i++) {
                c = fgetc(iface->file);
                if (c == EOF) {
                    ast_log(LOG_ERROR, "Unexpected EOF while reading MD message\n");
                    ao2_ref(md_msg, -1);
                    return NULL;
                }
                md_msg->mesg_desk_num[i] = (char) c;
                ast_debug(1, "Read a '%c'\n", md_msg->mesg_desk_num[i]);
            }
 
            md_msg->mesg_desk_num[sizeof(md_msg->mesg_desk_num) - 1] = '\0';
 
            ast_debug(1, "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++) {
                c = fgetc(iface->file);
                if (c == EOF) {
                    ast_log(LOG_ERROR, "Unexpected EOF while reading SMDI message\n");
                    ao2_ref(md_msg, -1);
                    return NULL;
                }
                md_msg->mesg_desk_term[i] = (char) c;
                ast_debug(1, "Read a '%c'\n", md_msg->mesg_desk_term[i]);
            }
 
            md_msg->mesg_desk_term[sizeof(md_msg->mesg_desk_term) - 1] = '\0';
 
            ast_debug(1, "The message desk terminal is '%s'\n", md_msg->mesg_desk_term);
 
            /* read the message type */
            c = fgetc(iface->file);
            if (c == EOF) {
                ast_log(LOG_ERROR, "Unexpected EOF while reading SMDI message\n");
                ao2_ref(md_msg, -1);
                return NULL;
            }
            md_msg->type = (char) c;
 
            ast_debug(1, "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_debug(1, "Read a space, done looking for the forwarding station\n");
                    break;
                }
 
                /* store c in md_msg->fwd_st */
                if (i >= iface->msdstrip) {
                    ast_debug(1, "Read a '%c' and stored it in the forwarding station buffer\n", c);
                    *cp++ = c;
                } else {
                    ast_debug(1, "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_debug(1, "The forwarding station is '%s'\n", md_msg->fwd_st);
 
            /* Put the fwd_st in the name field so that we can use ao2_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_debug(1, "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_debug(1, "Read a '%c' and stored it in the calling station buffer\n", c);
                    *cp++ = c;
                } else {
                    ast_debug(1, "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_debug(1, "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_debug(1, "Received SMDI MD message on %s\n", iface->name);
 
            ao2_ref(md_msg, -1);
 
        } else if (c == 'W') { /* MWI message */
            start = 0;
 
            ast_debug(1, "Read a 'W', it's an MWI message. (No more debug coming for MWI messages)\n");
 
            mwi_msg = ao2_alloc(sizeof(*mwi_msg), NULL);
            if (!mwi_msg) {
                return NULL;
            }
 
            /* 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 ao2_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++) {
                c = fgetc(iface->file);
                if (c == EOF) {
                    ast_log(LOG_ERROR, "Unexpected EOF while reading MWI message\n");
                    ao2_ref(mwi_msg, -1);
                    return NULL;
                }
                mwi_msg->cause[i] = (char) c;
            }
 
            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_debug(1, "Received SMDI MWI message on %s\n", iface->name);
 
            ao2_ref(mwi_msg, -1);
        } else {
            ast_log(LOG_ERROR, "Unknown SMDI message type received 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);
    return NULL;
}

References ao2_alloc, ao2_ref, ast_copy_string(), ast_debug, ast_log, ast_smdi_md_message_push(), ast_smdi_mwi_message_push(), ast_tvnow(), c, ast_smdi_md_message::calling_st, ast_smdi_mwi_message::cause, ast_smdi_interface::file, ast_smdi_mwi_message::fwd_st, ast_smdi_md_message::fwd_st, LOG_ERROR, ast_smdi_md_message::mesg_desk_num, ast_smdi_md_message::mesg_desk_term, ast_smdi_interface::msdstrip, ast_smdi_interface::name, ast_smdi_mwi_message::name, ast_smdi_md_message::name, NULL, ast_smdi_mwi_message::timestamp, ast_smdi_md_message::timestamp, and ast_smdi_md_message::type.

Referenced by smdi_load().

smdi_toggle_mwi()

static int smdi_toggle_mwi ( struct ast_smdi_interface *  iface, const char *  mailbox, int  on  )

static

Definition at line 288 of file res_smdi.c.

{
    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;
    }
 
    ao2_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);
 
    ao2_unlock(iface);
    ast_debug(1, "Sent MWI set message for %s on %s\n", mailbox, iface->name);
 
    return 0;
}

References ao2_unlock, ao2_wrlock, ast_debug, ast_log, errno, make_ari_stubs::file, LOG_ERROR, voicemailpwcheck::mailbox, ast_smdi_interface::msdstrip, and ast_smdi_interface::name.

Referenced by ast_smdi_mwi_set(), and ast_smdi_mwi_unset().

unlink_from_msg_q()

static void * unlink_from_msg_q ( struct ast_smdi_interface *  iface, enum smdi_message_type  type  )

inlinestatic

Definition at line 354 of file res_smdi.c.

{
    switch (type) {
    case SMDI_MWI:
        return ao2_callback(iface->mwi_q, OBJ_UNLINK, NULL, NULL);
    case SMDI_MD:
        return ao2_callback(iface->md_q, OBJ_UNLINK, NULL, NULL);
    }
 
    return NULL;
}

References ao2_callback, ast_smdi_interface::md_q, ast_smdi_interface::mwi_q, NULL, OBJ_UNLINK, SMDI_MD, SMDI_MWI, and type.

Referenced by purge_old_messages(), and smdi_msg_pop().

unload_module()

static int unload_module ( void  )

static

Definition at line 1386 of file res_smdi.c.

{
    ao2_global_obj_release(smdi_ifaces);
 
    destroy_all_mailbox_mappings();
 
    ast_mutex_lock(&mwi_monitor.lock);
    mwi_monitor.stop = 1;
    ast_cond_signal(&mwi_monitor.cond);
    ast_mutex_unlock(&mwi_monitor.lock);
 
    if (mwi_monitor.thread != AST_PTHREADT_NULL) {
        pthread_join(mwi_monitor.thread, NULL);
    }
 
    ast_custom_function_unregister(&smdi_msg_retrieve_function);
    ast_custom_function_unregister(&smdi_msg_function);
 
    return 0;
}

References ao2_global_obj_release, ast_cond_signal, ast_custom_function_unregister(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, destroy_all_mailbox_mappings(), mwi_monitor, NULL, smdi_msg_function, and smdi_msg_retrieve_function.

Referenced by load_module().

unlock_msg_q()

static int unlock_msg_q ( struct ast_smdi_interface *  iface, enum smdi_message_type  type  )

inlinestatic

Definition at line 342 of file res_smdi.c.

{
    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;
}

References ast_mutex_unlock, ast_smdi_interface::md_q_lock, ast_smdi_interface::mwi_q_lock, SMDI_MD, SMDI_MWI, and type.

Referenced by purge_old_messages(), smdi_message_wait(), and smdi_msg_pop().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Simplified Message Desk Interface (SMDI) Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DEPEND, }

static

Definition at line 1458 of file res_smdi.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1458 of file res_smdi.c.

cond

ast_cond_t cond

Definition at line 217 of file res_smdi.c.

Referenced by smdi_message_wait().

config_file

const char config_file[] = "smdi.conf"

static

Definition at line 171 of file res_smdi.c.

Referenced by smdi_load().

first

struct mailbox_mapping* first

Definition at line 219 of file res_smdi.c.

last

struct mailbox_mapping* last

Definition at line 219 of file res_smdi.c.

last_poll

struct timeval last_poll

The time that the last poll began

Definition at line 225 of file res_smdi.c.

lock

ast_mutex_t lock

Definition at line 216 of file res_smdi.c.

Referenced by smdi_message_wait().

struct { ... } mailbox_mappings

A list of mailboxes that need to be monitored

struct { ... } mwi_monitor

Initial value:

= {
    .thread = AST_PTHREADT_NULL,
}

Data that gets used by the SMDI MWI monitoring thread.

Referenced by append_mailbox_mapping(), destroy_all_mailbox_mappings(), load_module(), mwi_monitor_handler(), smdi_load(), and unload_module().

polling_interval

unsigned int polling_interval

Polling Interval for checking mailbox status

Definition at line 221 of file res_smdi.c.

smdi_msg_datastore_info

const struct ast_datastore_info smdi_msg_datastore_info

static

Initial value:

= {
    .type = "SMDIMSG",
    .destroy = smdi_msg_datastore_destroy,
}

Definition at line 1193 of file res_smdi.c.

Referenced by smdi_msg_read(), and smdi_msg_retrieve_read().

smdi_msg_function

struct ast_custom_function smdi_msg_function

static

Initial value:

= {
    .name = "SMDI_MSG",
    .read = smdi_msg_read,
}

Definition at line 1381 of file res_smdi.c.

Referenced by load_module(), and unload_module().

smdi_msg_id

int smdi_msg_id

static

Definition at line 1198 of file res_smdi.c.

Referenced by smdi_msg_retrieve_read().

smdi_msg_ret_options

const struct ast_app_option smdi_msg_ret_options[128] = { [ 't' ] = { .flag = OPT_SEARCH_TERMINAL }, [ 'n' ] = { .flag = OPT_SEARCH_NUMBER }, }

static

Definition at line 1206 of file res_smdi.c.

Referenced by smdi_msg_retrieve_read().

smdi_msg_retrieve_function

struct ast_custom_function smdi_msg_retrieve_function

static

Initial value:

= {
    .name = "SMDI_MSG_RETRIEVE",
    .read = smdi_msg_retrieve_read,
}

Definition at line 1376 of file res_smdi.c.

Referenced by load_module(), and unload_module().

stop

unsigned int stop

Set to 1 to tell the polling thread to stop

Definition at line 223 of file res_smdi.c.

thread

pthread_t thread

The thread ID

Definition at line 215 of file res_smdi.c.