Sun Aug 6 15:03:58 2006

Asterisk developer's documentation


Main Page | Modules | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

app_page.c File Reference

page() - Paging application More...

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "asterisk.h"
#include "asterisk/options.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/file.h"
#include "asterisk/app.h"
#include "asterisk/chanvars.h"

Include dependency graph for app_page.c:

Go to the source code of this file.

Enumerations

enum  { PAGE_DUPLEX = (1 << 0), PAGE_QUIET = (1 << 1) }

Functions

 AST_APP_OPTIONS (page_opts,{AST_APP_OPTION('d', PAGE_DUPLEX), AST_APP_OPTION('q', PAGE_QUIET),})
char * description (void)
 Provides a description of the module.
char * key ()
 Returns the ASTERISK_GPL_KEY.
static void launch_page (struct ast_channel *chan, const char *meetmeopts, const char *tech, const char *resource)
int load_module (void)
 Initialize the module.
static int page_exec (struct ast_channel *chan, void *data)
static void * page_thread (void *data)
int unload_module (void)
 Cleanup all module structures, sockets, etc.
int usecount (void)
 Provides a usecount.

Variables

static const char * app_page = "Page"
 LOCAL_USER_DECL
static const char * page_descrip
enum { ... }  page_opt_flags
static const char * page_synopsis = "Pages phones"
 STANDARD_LOCAL_USER
static const char * tdesc = "Page Multiple Phones"


Detailed Description

page() - Paging application

Definition in file app_page.c.


Enumeration Type Documentation

anonymous enum
 

Enumeration values:
PAGE_DUPLEX 
PAGE_QUIET 

Definition at line 65 of file app_page.c.

00065      {
00066    PAGE_DUPLEX = (1 << 0),
00067    PAGE_QUIET = (1 << 1),
00068 } page_opt_flags;


Function Documentation

AST_APP_OPTIONS page_opts   ) 
 

char* description void   ) 
 

Provides a description of the module.

Returns:
a short description of your module

Definition at line 228 of file app_page.c.

References tdesc.

00229 {
00230    return (char *) tdesc;
00231 }

char* key void   ) 
 

Returns the ASTERISK_GPL_KEY.

This returns the ASTERISK_GPL_KEY, signifiying that you agree to the terms of the GPL stated in the ASTERISK_GPL_KEY. Your module will not load if it does not return the EXACT message:

 char *key(void) {
         return ASTERISK_GPL_KEY;
 }

Returns:
ASTERISK_GPL_KEY

Definition at line 242 of file app_page.c.

References ASTERISK_GPL_KEY.

00243 {
00244    return ASTERISK_GPL_KEY;
00245 }

static void launch_page struct ast_channel chan,
const char *  meetmeopts,
const char *  tech,
const char *  resource
[static]
 

Definition at line 93 of file app_page.c.

References AST_LIST_TRAVERSE, ast_log(), ast_pthread_create, ast_var_full_name(), ast_var_value(), ast_variable_new(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, free, LOG_WARNING, malloc, page_thread(), t, and ast_channel::varshead.

Referenced by page_exec().

00094 {
00095    struct calloutdata *cd;
00096    const char *varname;
00097    struct ast_variable *lastvar = NULL;
00098    struct ast_var_t *varptr;
00099    pthread_t t;
00100    pthread_attr_t attr;
00101    cd = malloc(sizeof(struct calloutdata));
00102    if (cd) {
00103       memset(cd, 0, sizeof(struct calloutdata));
00104       ast_copy_string(cd->cidnum, chan->cid.cid_num ? chan->cid.cid_num : "", sizeof(cd->cidnum));
00105       ast_copy_string(cd->cidname, chan->cid.cid_name ? chan->cid.cid_name : "", sizeof(cd->cidname));
00106       ast_copy_string(cd->tech, tech, sizeof(cd->tech));
00107       ast_copy_string(cd->resource, resource, sizeof(cd->resource));
00108       ast_copy_string(cd->meetmeopts, meetmeopts, sizeof(cd->meetmeopts));
00109 
00110       AST_LIST_TRAVERSE(&chan->varshead, varptr, entries) {
00111          if (!(varname = ast_var_full_name(varptr)))
00112             continue;
00113          if (varname[0] == '_') {
00114             struct ast_variable *newvar = NULL;
00115 
00116             if (varname[1] == '_') {
00117                newvar = ast_variable_new(varname, ast_var_value(varptr));
00118             } else {
00119                newvar = ast_variable_new(&varname[1], ast_var_value(varptr));
00120             }
00121 
00122             if (newvar) {
00123                if (lastvar)
00124                   lastvar->next = newvar;
00125                else
00126                   cd->variables = newvar;
00127                lastvar = newvar;
00128             }
00129          }
00130       }
00131 
00132       pthread_attr_init(&attr);
00133       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
00134       if (ast_pthread_create(&t, &attr, page_thread, cd)) {
00135          ast_log(LOG_WARNING, "Unable to create paging thread: %s\n", strerror(errno));
00136          free(cd);
00137       }
00138    }
00139 }

int load_module void   ) 
 

Initialize the module.

Initialize the Agents module. This function is being called by Asterisk when loading the module. Among other thing it registers applications, cli commands and reads the cofiguration file.

Returns:
int Always 0.

Definition at line 223 of file app_page.c.

References app_page, ast_register_application(), page_descrip, page_exec(), and page_synopsis.

static int page_exec struct ast_channel chan,
void *  data
[static]
 

Definition at line 141 of file app_page.c.

References app, ast_app_parse_options(), AST_CHANNEL_NAME, ast_log(), ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_test_flag, ast_waitstream(), ast_channel::language, launch_page(), LOCAL_USER_ADD, LOCAL_USER_REMOVE, LOG_ERROR, LOG_WARNING, ast_channel::name, PAGE_DUPLEX, PAGE_QUIET, pbx_exec(), pbx_findapp(), and strsep().

Referenced by load_module().

00142 {
00143    struct localuser *u;
00144    char *options;
00145    char *tech, *resource;
00146    char meetmeopts[80];
00147    struct ast_flags flags = { 0 };
00148    unsigned int confid = rand();
00149    struct ast_app *app;
00150    char *tmp;
00151    int res=0;
00152    char originator[AST_CHANNEL_NAME];
00153 
00154    if (ast_strlen_zero(data)) {
00155       ast_log(LOG_WARNING, "This application requires at least one argument (destination(s) to page)\n");
00156       return -1;
00157    }
00158 
00159    LOCAL_USER_ADD(u);
00160 
00161    if (!(app = pbx_findapp("MeetMe"))) {
00162       ast_log(LOG_WARNING, "There is no MeetMe application available!\n");
00163       LOCAL_USER_REMOVE(u);
00164       return -1;
00165    };
00166 
00167    options = ast_strdupa(data);
00168    if (!options) {
00169       ast_log(LOG_ERROR, "Out of memory\n");
00170       LOCAL_USER_REMOVE(u);
00171       return -1;
00172    }
00173 
00174    ast_copy_string(originator, chan->name, sizeof(originator));
00175    if ((tmp = strchr(originator, '-')))
00176       *tmp = '\0';
00177 
00178    tmp = strsep(&options, "|");
00179    if (options)
00180       ast_app_parse_options(page_opts, &flags, NULL, options);
00181 
00182    snprintf(meetmeopts, sizeof(meetmeopts), "%ud|%sqxdw", confid, ast_test_flag(&flags, PAGE_DUPLEX) ? "" : "m");
00183 
00184    while ((tech = strsep(&tmp, "&"))) {
00185       /* don't call the originating device */
00186       if (!strcasecmp(tech, originator))
00187          continue;
00188 
00189       if ((resource = strchr(tech, '/'))) {
00190          *resource++ = '\0';
00191          launch_page(chan, meetmeopts, tech, resource);
00192       } else {
00193          ast_log(LOG_WARNING, "Incomplete destination '%s' supplied.\n", tech);
00194       }
00195    }
00196 
00197    if (!ast_test_flag(&flags, PAGE_QUIET)) {
00198       res = ast_streamfile(chan, "beep", chan->language);
00199       if (!res)
00200          res = ast_waitstream(chan, "");
00201    }
00202    if (!res) {
00203       snprintf(meetmeopts, sizeof(meetmeopts), "%ud|A%sqxd", confid, ast_test_flag(&flags, PAGE_DUPLEX) ? "" : "t");
00204       pbx_exec(chan, app, meetmeopts, 1);
00205    }
00206 
00207    LOCAL_USER_REMOVE(u);
00208 
00209    return -1;
00210 }

static void* page_thread void *  data  )  [static]
 

Definition at line 84 of file app_page.c.

References AST_FORMAT_SLINEAR, ast_pbx_outgoing_app(), calloutdata::cidname, calloutdata::cidnum, free, calloutdata::meetmeopts, calloutdata::resource, calloutdata::tech, and calloutdata::variables.

Referenced by launch_page().

00085 {
00086    struct calloutdata *cd = data;
00087    ast_pbx_outgoing_app(cd->tech, AST_FORMAT_SLINEAR, cd->resource, 30000,
00088       "MeetMe", cd->meetmeopts, NULL, 0, cd->cidnum, cd->cidname, cd->variables, NULL, NULL);
00089    free(cd);
00090    return NULL;
00091 }

int unload_module void   ) 
 

Cleanup all module structures, sockets, etc.

This is called at exit. Any registrations and memory allocations need to be unregistered and free'd here. Nothing else will do these for you (until exit).

Returns:
Zero on success, or non-zero on error.

Definition at line 212 of file app_page.c.

References app_page, ast_unregister_application(), and STANDARD_HANGUP_LOCALUSERS.

00213 {
00214    int res;
00215 
00216    res =  ast_unregister_application(app_page);
00217 
00218    STANDARD_HANGUP_LOCALUSERS;
00219 
00220    return res;
00221 }

int usecount void   ) 
 

Provides a usecount.

This function will be called by various parts of asterisk. Basically, all it has to do is to return a usecount when called. You will need to maintain your usecount within the module somewhere. The usecount should be how many channels provided by this module are in use.

Returns:
The module's usecount.

Definition at line 233 of file app_page.c.

References STANDARD_USECOUNT.

00234 {
00235    int res;
00236 
00237    STANDARD_USECOUNT(res);
00238 
00239    return res;
00240 }


Variable Documentation

const char* app_page = "Page" [static]
 

Definition at line 48 of file app_page.c.

Referenced by load_module(), and unload_module().

LOCAL_USER_DECL
 

Definition at line 63 of file app_page.c.

const char* page_descrip [static]
 

Definition at line 52 of file app_page.c.

Referenced by load_module().

enum { ... } page_opt_flags
 

const char* page_synopsis = "Pages phones" [static]
 

Definition at line 50 of file app_page.c.

Referenced by load_module().

STANDARD_LOCAL_USER
 

Definition at line 61 of file app_page.c.

const char* tdesc = "Page Multiple Phones" [static]
 

Definition at line 46 of file app_page.c.


Generated on Sun Aug 6 15:03:59 2006 for Asterisk - the Open Source PBX by  doxygen 1.4.2