app_directed_pickup.c File Reference

Directed Call Pickup Support. More...

#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/pickup.h"
#include "asterisk/manager.h"
#include "asterisk/callerid.h"

Include dependency graph for app_directed_pickup.c:

Go to the source code of this file.

Data Structures
struct	pickup_by_name_args

Macros
#define	PICKUPMARK   "PICKUPMARK"

Enumerations
enum	OPT_PICKUPCHAN_FLAGS { OPT_PICKUPCHAN_PARTIAL = (1 << 0) }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_channel *	find_by_channel (struct ast_channel *chan, const char *channame)
	Helper Function to walk through ALL channels checking NAME and STATE.
static int	find_by_mark (void *obj, void *arg, void *data, int flags)
static int	find_by_name (void *obj, void *arg, void *data, int flags)
static struct ast_channel *	find_by_part (struct ast_channel *chan, const char *part)
static int	find_by_uniqueid (void *obj, void *arg, void *data, int flags)
static int	load_module (void)
static int	pickup_by_channel (struct ast_channel *chan, const char *name)
	Attempt to pick up named channel.
static int	pickup_by_exten (struct ast_channel *chan, const char *exten, const char *context)
static int	pickup_by_group (struct ast_channel *chan)
static int	pickup_by_mark (struct ast_channel *chan, const char *mark)
static int	pickup_by_part (struct ast_channel *chan, const char *part)
static int	pickup_exec (struct ast_channel *chan, const char *data)
static int	pickupchan_exec (struct ast_channel *chan, const char *data)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Directed Call Pickup Application" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const char	app [] = "Pickup"
static const char	app2 [] = "PickupChan"
static const struct ast_module_info *	ast_module_info = &__mod_info
static const struct ast_app_option	pickupchan_opts [128] = { [ 'p' ] = { .flag = OPT_PICKUPCHAN_PARTIAL }, }

Detailed Description

Directed Call Pickup Support.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Gary Cook

Definition in file app_directed_pickup.c.

Macro Definition Documentation

PICKUPMARK

#define PICKUPMARK   "PICKUPMARK"

Definition at line 48 of file app_directed_pickup.c.

Enumeration Type Documentation

OPT_PICKUPCHAN_FLAGS

enum OPT_PICKUPCHAN_FLAGS

Enumerator
OPT_PICKUPCHAN_PARTIAL

Definition at line 417 of file app_directed_pickup.c.

                          {
    OPT_PICKUPCHAN_PARTIAL =   (1 << 0),    /* Channel name is a partial name. */
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 498 of file app_directed_pickup.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 498 of file app_directed_pickup.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 498 of file app_directed_pickup.c.

find_by_channel()

static struct ast_channel * find_by_channel ( struct ast_channel *  chan, const char *  channame  )

static

Helper Function to walk through ALL channels checking NAME and STATE.

Definition at line 186 of file app_directed_pickup.c.

{
    struct ast_channel *target;
    char *chkchan;
    struct pickup_by_name_args pickup_args;
 
    pickup_args.chan = chan;
 
    if (strchr(channame, '-')) {
        /*
         * Use the given channel name string as-is.  This allows a full channel
         * name with a typical sequence number to be used as well as still
         * allowing the odd partial channel name that has a '-' in it to still
         * work, i.e. Local/bob@en-phone.
         */
        pickup_args.len = strlen(channame);
        pickup_args.name = channame;
    } else {
        /*
         * Append a '-' for the comparison so we check the channel name less
         * a sequence number, i.e Find SIP/bob- and not SIP/bobby.
         */
        pickup_args.len = strlen(channame) + 1;
        chkchan = ast_alloca(pickup_args.len + 1);
        strcpy(chkchan, channame);/* Safe */
        strcat(chkchan, "-");
        pickup_args.name = chkchan;
    }
    target = ast_channel_callback(find_by_name, NULL, &pickup_args, 0);
    if (target) {
        return target;
    }
 
    /* Now try a search for uniqueid. */
    pickup_args.name = channame;
    pickup_args.len = 0;
    return ast_channel_callback(find_by_uniqueid, NULL, &pickup_args, 0);
}

References ast_alloca, ast_channel_callback(), pickup_by_name_args::chan, find_by_name(), find_by_uniqueid(), pickup_by_name_args::len, pickup_by_name_args::name, and NULL.

Referenced by pickup_by_channel().

find_by_mark()

static int find_by_mark ( void *  obj, void *  arg, void *  data, int  flags  )

static

< Potential pickup target

Definition at line 274 of file app_directed_pickup.c.

{
    struct ast_channel *target = obj;/*!< Potential pickup target */
    struct ast_channel *chan = arg;
    const char *mark = data;
    const char *tmp;
 
    if (chan == target) {
        /* The channel attempting to pickup a call cannot pickup itself. */
        return 0;
    }
 
    ast_channel_lock(target);
    tmp = pbx_builtin_getvar_helper(target, PICKUPMARK);
    if (tmp && !strcasecmp(tmp, mark) && ast_can_pickup(target)) {
        /* Return with the channel still locked on purpose */
        return CMP_MATCH | CMP_STOP;
    }
    ast_channel_unlock(target);
 
    return 0;
}

References ast_can_pickup(), ast_channel_lock, ast_channel_unlock, CMP_MATCH, CMP_STOP, ast_channel::data, pbx_builtin_getvar_helper(), and PICKUPMARK.

Referenced by pickup_by_mark().

find_by_name()

static int find_by_name ( void *  obj, void *  arg, void *  data, int  flags  )

static

< Potential pickup target

Definition at line 143 of file app_directed_pickup.c.

{
    struct ast_channel *target = obj;/*!< Potential pickup target */
    struct pickup_by_name_args *args = data;
 
    if (args->chan == target) {
        /* The channel attempting to pickup a call cannot pickup itself. */
        return 0;
    }
 
    ast_channel_lock(target);
    if (!strncasecmp(ast_channel_name(target), args->name, args->len)
        && ast_can_pickup(target)) {
        /* Return with the channel still locked on purpose */
        return CMP_MATCH | CMP_STOP;
    }
    ast_channel_unlock(target);
 
    return 0;
}

References args, ast_can_pickup(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, CMP_MATCH, and CMP_STOP.

Referenced by find_by_channel(), and find_by_part().

find_by_part()

static struct ast_channel * find_by_part ( struct ast_channel *  chan, const char *  part  )

static

Definition at line 379 of file app_directed_pickup.c.

{
    struct ast_channel *target;
    struct pickup_by_name_args pickup_args;
 
    pickup_args.chan = chan;
 
    /* Try a partial channel name search. */
    pickup_args.name = part;
    pickup_args.len = strlen(part);
    target = ast_channel_callback(find_by_name, NULL, &pickup_args, 0);
    if (target) {
        return target;
    }
 
    /* Now try a search for uniqueid. */
    pickup_args.name = part;
    pickup_args.len = 0;
    return ast_channel_callback(find_by_uniqueid, NULL, &pickup_args, 0);
}

References ast_channel_callback(), pickup_by_name_args::chan, find_by_name(), find_by_uniqueid(), pickup_by_name_args::len, pickup_by_name_args::name, and NULL.

Referenced by pickup_by_part().

find_by_uniqueid()

static int find_by_uniqueid ( void *  obj, void *  arg, void *  data, int  flags  )

static

< Potential pickup target

Definition at line 164 of file app_directed_pickup.c.

{
    struct ast_channel *target = obj;/*!< Potential pickup target */
    struct pickup_by_name_args *args = data;
 
    if (args->chan == target) {
        /* The channel attempting to pickup a call cannot pickup itself. */
        return 0;
    }
 
    ast_channel_lock(target);
    if (!strcasecmp(ast_channel_uniqueid(target), args->name)
        && ast_can_pickup(target)) {
        /* Return with the channel still locked on purpose */
        return CMP_MATCH | CMP_STOP;
    }
    ast_channel_unlock(target);
 
    return 0;
}

References args, ast_can_pickup(), ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, CMP_MATCH, and CMP_STOP.

Referenced by find_by_channel(), and find_by_part().

load_module()

static int load_module ( void  )

static

Definition at line 488 of file app_directed_pickup.c.

{
    int res;
 
    res = ast_register_application_xml(app, pickup_exec);
    res |= ast_register_application_xml(app2, pickupchan_exec);
 
    return res;
}

References app, app2, ast_register_application_xml, pickup_exec(), and pickupchan_exec().

pickup_by_channel()

static int pickup_by_channel ( struct ast_channel *  chan, const char *  name  )

static

Attempt to pick up named channel.

< Potential pickup target

Definition at line 226 of file app_directed_pickup.c.

{
    int res = -1;
    struct ast_channel *target;/*!< Potential pickup target */
 
    /* The found channel is already locked. */
    target = find_by_channel(chan, name);
    if (target) {
        res = ast_do_pickup(chan, target);
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    return res;
}

References ast_channel_unlock, ast_channel_unref, ast_do_pickup(), find_by_channel(), and name.

Referenced by pickupchan_exec().

pickup_by_exten()

static int pickup_by_exten ( struct ast_channel *  chan, const char *  exten, const char *  context  )

static

< Potential pickup target

Definition at line 243 of file app_directed_pickup.c.

{
    struct ast_channel *target = NULL;/*!< Potential pickup target */
    struct ast_channel_iterator *iter;
    int res = -1;
 
    if (!(iter = ast_channel_iterator_by_exten_new(exten, context))) {
        return -1;
    }
 
    while ((target = ast_channel_iterator_next(iter))) {
        ast_channel_lock(target);
        if ((chan != target) && ast_can_pickup(target)) {
            ast_log(LOG_NOTICE, "%s pickup by %s\n", ast_channel_name(target), ast_channel_name(chan));
            break;
        }
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    ast_channel_iterator_destroy(iter);
 
    if (target) {
        res = ast_do_pickup(chan, target);
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    return res;
}

References ast_can_pickup(), ast_channel_iterator_by_exten_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_do_pickup(), ast_log, LOG_NOTICE, and NULL.

Referenced by pickup_exec().

pickup_by_group()

static int pickup_by_group ( struct ast_channel *  chan )

static

< Potential pickup target

Definition at line 314 of file app_directed_pickup.c.

{
    struct ast_channel *target;/*!< Potential pickup target */
    int res = -1;
 
    /* The found channel is already locked. */
    target = ast_pickup_find_by_group(chan);
    if (target) {
        ast_log(LOG_NOTICE, "pickup %s attempt by %s\n", ast_channel_name(target), ast_channel_name(chan));
        res = ast_do_pickup(chan, target);
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    return res;
}

References ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_do_pickup(), ast_log, ast_pickup_find_by_group(), and LOG_NOTICE.

Referenced by pickup_exec().

pickup_by_mark()

static int pickup_by_mark ( struct ast_channel *  chan, const char *  mark  )

static

< Potential pickup target

Definition at line 298 of file app_directed_pickup.c.

{
    struct ast_channel *target;/*!< Potential pickup target */
    int res = -1;
 
    /* The found channel is already locked. */
    target = ast_channel_callback(find_by_mark, chan, (char *) mark, 0);
    if (target) {
        res = ast_do_pickup(chan, target);
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    return res;
}

References ast_channel_callback(), ast_channel_unlock, ast_channel_unref, ast_do_pickup(), and find_by_mark().

Referenced by pickup_exec().

pickup_by_part()

static int pickup_by_part ( struct ast_channel *  chan, const char *  part  )

static

< Potential pickup target

Definition at line 401 of file app_directed_pickup.c.

{
    struct ast_channel *target;/*!< Potential pickup target */
    int res = -1;
 
    /* The found channel is already locked. */
    target = find_by_part(chan, part);
    if (target) {
        res = ast_do_pickup(chan, target);
        ast_channel_unlock(target);
        target = ast_channel_unref(target);
    }
 
    return res;
}

References ast_channel_unlock, ast_channel_unref, ast_do_pickup(), and find_by_part().

Referenced by pickupchan_exec().

pickup_exec()

static int pickup_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 332 of file app_directed_pickup.c.

{
    char *parse;
    char *exten;
    char *context;
 
    if (ast_strlen_zero(data)) {
        return pickup_by_group(chan) ? 0 : -1;
    }
 
    /* Parse extension (and context if there) */
    parse = ast_strdupa(data);
    for (;;) {
        if (ast_strlen_zero(parse)) {
            break;
        }
        exten = strsep(&parse, "&");
        if (ast_strlen_zero(exten)) {
            continue;
        }
 
        context = strchr(exten, '@');
        if (context) {
            *context++ = '\0';
        }
        if (!ast_strlen_zero(context) && !strcasecmp(context, PICKUPMARK)) {
            if (!pickup_by_mark(chan, exten)) {
                /* Pickup successful.  Stop the dialplan this channel is a zombie. */
                return -1;
            }
        } else {
            if (ast_strlen_zero(context)) {
                context = (char *) ast_channel_context(chan);
            }
            if (!pickup_by_exten(chan, exten, context)) {
                /* Pickup successful.  Stop the dialplan this channel is a zombie. */
                return -1;
            }
        }
        ast_log(LOG_NOTICE, "No target channel found for %s@%s.\n", exten, context);
    }
 
    /* Pickup failed.  Keep going in the dialplan. */
    return 0;
}

References ast_channel_context(), ast_log, ast_strdupa, ast_strlen_zero(), ast_channel::context, ast_channel::data, ast_channel::exten, LOG_NOTICE, pickup_by_exten(), pickup_by_group(), pickup_by_mark(), PICKUPMARK, and strsep().

Referenced by load_module().

pickupchan_exec()

static int pickupchan_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 426 of file app_directed_pickup.c.

{
    char *pickup = NULL;
    char *parse = ast_strdupa(data);
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(channel);
        AST_APP_ARG(options);
        AST_APP_ARG(other); /* Any remining unused arguments */
    );
    struct ast_flags opts;
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.channel)) {
        ast_log(LOG_WARNING, "PickupChan requires an argument (channel)!\n");
        /* Pickup failed.  Keep going in the dialplan. */
        return 0;
    }
    if (ast_app_parse_options(pickupchan_opts, &opts, NULL, args.options)) {
        /*
         * General invalid option syntax.
         * Pickup failed.  Keep going in the dialplan.
         */
        return 0;
    }
 
    /* Parse channel */
    for (;;) {
        if (ast_strlen_zero(args.channel)) {
            break;
        }
        pickup = strsep(&args.channel, "&");
        if (ast_strlen_zero(pickup)) {
            continue;
        }
 
        if (ast_test_flag(&opts, OPT_PICKUPCHAN_PARTIAL)) {
            if (!pickup_by_part(chan, pickup)) {
                /* Pickup successful.  Stop the dialplan this channel is a zombie. */
                return -1;
            }
        } else if (!pickup_by_channel(chan, pickup)) {
            /* Pickup successful.  Stop the dialplan this channel is a zombie. */
            return -1;
        }
        ast_log(LOG_NOTICE, "No target channel found for %s.\n", pickup);
    }
 
    /* Pickup failed.  Keep going in the dialplan. */
    return 0;
}

References args, AST_APP_ARG, ast_app_parse_options(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_channel::data, LOG_NOTICE, LOG_WARNING, NULL, OPT_PICKUPCHAN_PARTIAL, options, pickup_by_channel(), pickup_by_part(), pickupchan_opts, and strsep().

Referenced by load_module().

unload_module()

static int unload_module ( void  )

static

Definition at line 478 of file app_directed_pickup.c.

{
    int res;
 
    res = ast_unregister_application(app);
    res |= ast_unregister_application(app2);
 
    return res;
}

References app, app2, and ast_unregister_application().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Directed Call Pickup Application" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 498 of file app_directed_pickup.c.

app

const char app[] = "Pickup"

static

Definition at line 131 of file app_directed_pickup.c.

Referenced by load_module(), and unload_module().

app2

const char app2[] = "PickupChan"

static

Definition at line 132 of file app_directed_pickup.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 498 of file app_directed_pickup.c.

pickupchan_opts

const struct ast_app_option pickupchan_opts[128] = { [ 'p' ] = { .flag = OPT_PICKUPCHAN_PARTIAL }, }

static

Definition at line 423 of file app_directed_pickup.c.

Referenced by pickupchan_exec().