Wed Aug 20 06:37:21 2008

Asterisk developer's documentation

---

app_adsiprog.c File Reference

Program Asterisk ADSI Scripts into phone. More...

#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <errno.h>
#include "asterisk.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/adsi.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"

Include dependency graph for app_adsiprog.c:

Go to the source code of this file.

Data Structures
struct	adsi_display
struct	adsi_event
struct	adsi_flag
struct	adsi_key_cmd
struct	adsi_script
struct	adsi_soft_key
struct	adsi_state
struct	adsi_subscript
Defines
#define	ARG_NUMBER   (1 << 1)
#define	ARG_STRING   (1 << 0)
#define	MAX_MAIN_LEN   1600
#define	MAX_RET_CODE   20
#define	MAX_SUB_LEN   255
#define	STATE_INIF   3
#define	STATE_INKEY   1
#define	STATE_INSUB   2
#define	STATE_NORMAL   0
Functions
static int	adsi_exec (struct ast_channel *chan, void *data)
static int	adsi_process (struct adsi_script *state, char *buf, char *script, int lineno)
static int	adsi_prog (struct ast_channel *chan, char *script)
static int	clearcbone (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static int	cleardisplay (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static int	clearflag (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	cleartimer (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static struct adsi_script *	compile_script (char *script)
char *	description (void)
	Provides a description of the module.
static int	digitcollect (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static int	digitdirect (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static char *	get_token (char **buf, char *script, int lineno)
static struct adsi_display *	getdisplaybyname (struct adsi_script *state, char *name, char *script, int lineno, int create)
static int	geteventbyname (char *name)
static struct adsi_flag *	getflagbyname (struct adsi_script *state, char *name, char *script, int lineno, int create)
static int	getjustifybyname (char *name)
static struct adsi_soft_key *	getkeybyname (struct adsi_script *state, char *name, char *script, int lineno)
static struct adsi_state *	getstatebyname (struct adsi_script *state, char *name, char *script, int lineno, int create)
static struct adsi_subscript *	getsubbyname (struct adsi_script *state, char *name, char *script, int lineno)
static int	goto_line (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	goto_line_rel (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
char *	key ()
	Returns the ASTERISK_GPL_KEY.
int	load_module (void)
	Initialize the module.
static int	onevent (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	process_opcode (struct adsi_subscript *sub, char *code, char *args, struct adsi_script *state, char *script, int lineno)
static int	process_returncode (struct adsi_soft_key *key, char *code, char *args, struct adsi_script *state, char *script, int lineno)
static int	process_token (void *out, char *src, int maxlen, int argtype)
static int	send_delay (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	send_dtmf (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	set_state (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static int	setflag (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	showdisplay (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	showkeys (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
static int	starttimer (char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
static int	subscript (char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
int	unload_module (void)
	Cleanup all module structures, sockets, etc.
int	usecount (void)
	Provides a usecount.
Variables
static char *	app = "ADSIProg"
static char *	descrip
static struct adsi_event	events []
static struct adsi_event	justify []
static struct adsi_key_cmd	kcmds []
	LOCAL_USER_DECL
static struct adsi_key_cmd	opcmds []
	STANDARD_LOCAL_USER
static char *	synopsis = "Load Asterisk ADSI Scripts into phone"
static char *	tdesc = "Asterisk ADSI Programming Application"
static char *	validdtmf = "123456789*0#ABCD"

---

Detailed Description

Program Asterisk ADSI Scripts into phone.

Definition in file app_adsiprog.c.

---

Define Documentation

#define ARG_NUMBER   (1 << 1)

Definition at line 114 of file app_adsiprog.c.

Referenced by adsi_process(), goto_line(), goto_line_rel(), process_token(), send_delay(), set_state(), showdisplay(), and starttimer().

#define ARG_STRING   (1 << 0)

Definition at line 113 of file app_adsiprog.c.

Referenced by adsi_process(), clearflag(), onevent(), process_token(), send_dtmf(), setflag(), showdisplay(), showkeys(), and subscript().

#define MAX_MAIN_LEN   1600

Definition at line 111 of file app_adsiprog.c.

Referenced by process_opcode().

#define MAX_RET_CODE   20

Definition at line 109 of file app_adsiprog.c.

Referenced by process_returncode().

#define MAX_SUB_LEN   255

Definition at line 110 of file app_adsiprog.c.

Referenced by process_opcode().

#define STATE_INIF   3

Definition at line 107 of file app_adsiprog.c.

Referenced by adsi_process().

#define STATE_INKEY   1

Definition at line 105 of file app_adsiprog.c.

Referenced by adsi_process(), and compile_script().

#define STATE_INSUB   2

Definition at line 106 of file app_adsiprog.c.

Referenced by adsi_process(), and compile_script().

#define STATE_NORMAL   0

Definition at line 104 of file app_adsiprog.c.

Referenced by adsi_process(), and compile_script().

---

Function Documentation

static int adsi_exec	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Definition at line 1551 of file app_adsiprog.c.

References adsi_available(), adsi_prog(), ast_strlen_zero(), ast_verbose(), localuser::chan, LOCAL_USER_ADD, LOCAL_USER_REMOVE, option_verbose, and VERBOSE_PREFIX_3.

Referenced by load_module().

{
   int res=0;
   struct localuser *u;

   LOCAL_USER_ADD(u);
   
   if (ast_strlen_zero(data))
      data = "asterisk.adsi";
   
   if (!adsi_available(chan)) {
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "ADSI Unavailable on CPE.  Not bothering to try.\n");
   } else {
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "ADSI Available on CPE.  Attempting Upload.\n");
      res = adsi_prog(chan, data);
   }

   LOCAL_USER_REMOVE(u);
   
   return res;
}

static int adsi_process	(	struct adsi_script *	state,
		char *	buf,
		char *	script,
		int	lineno
	)			[static]

Definition at line 963 of file app_adsiprog.c.

References ARG_NUMBER, ARG_STRING, ast_log(), adsi_display::data, adsi_subscript::data, adsi_display::datalen, adsi_subscript::datalen, adsi_subscript::defined, adsi_soft_key::defined, adsi_script::desc, adsi_script::fdn, get_token(), getdisplaybyname(), geteventbyname(), getflagbyname(), getjustifybyname(), getkeybyname(), getstatebyname(), getsubbyname(), adsi_display::id, adsi_subscript::id, adsi_soft_key::id, adsi_subscript::ifdata, adsi_subscript::ifinscount, adsi_soft_key::initlen, adsi_subscript::inscount, adsi_script::key, LOG_WARNING, process_opcode(), process_returncode(), process_token(), adsi_soft_key::retstr, adsi_soft_key::retstrlen, adsi_script::sec, adsi_script::state, STATE_INIF, STATE_INKEY, STATE_INSUB, STATE_NORMAL, adsi_script::sub, and adsi_script::ver.

Referenced by compile_script().

{
   char *keyword;
   char *args;
   char vname[256];
   char tmp[80];
   char tmp2[80];
   int lrci;
   int wi;
   int event;
   struct adsi_display *disp;
   struct adsi_subscript *newsub;
   /* Find the first keyword */
   keyword = get_token(&buf, script, lineno);
   if (!keyword) 
      return 0;
   switch(state->state) {
   case STATE_NORMAL:
      if (!strcasecmp(keyword, "DESCRIPTION")) {
         args = get_token(&buf, script, lineno);
         if (args) {
            if (process_token(state->desc, args, sizeof(state->desc) - 1, ARG_STRING))
               ast_log(LOG_WARNING, "'%s' is not a valid token for DESCRIPTION at line %d of %s\n", args, lineno, script);
         } else
            ast_log(LOG_WARNING, "Missing argument for DESCRIPTION at line %d of %s\n", lineno, script);
      } else if (!strcasecmp(keyword, "VERSION")) {
         args = get_token(&buf, script, lineno);
         if (args) {
            if (process_token(&state->ver, args, sizeof(state->ver) - 1, ARG_NUMBER))
               ast_log(LOG_WARNING, "'%s' is not a valid token for VERSION at line %d of %s\n", args, lineno, script);
         } else
            ast_log(LOG_WARNING, "Missing argument for VERSION at line %d of %s\n", lineno, script);
      } else if (!strcasecmp(keyword, "SECURITY")) {
         args = get_token(&buf, script, lineno);
         if (args) {
            if (process_token(state->sec, args, sizeof(state->sec) - 1, ARG_STRING | ARG_NUMBER))
               ast_log(LOG_WARNING, "'%s' is not a valid token for SECURITY at line %d of %s\n", args, lineno, script);
         } else
            ast_log(LOG_WARNING, "Missing argument for SECURITY at line %d of %s\n", lineno, script);
      } else if (!strcasecmp(keyword, "FDN")) {
         args = get_token(&buf, script, lineno);
         if (args) {
            if (process_token(state->fdn, args, sizeof(state->fdn) - 1, ARG_STRING | ARG_NUMBER))
               ast_log(LOG_WARNING, "'%s' is not a valid token for FDN at line %d of %s\n", args, lineno, script);
         } else
            ast_log(LOG_WARNING, "Missing argument for FDN at line %d of %s\n", lineno, script);
      } else if (!strcasecmp(keyword, "KEY")) {
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "KEY definition missing name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(vname, args, sizeof(vname) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a KEY name at line %d of %s\n", args, lineno, script);
            break;
         }
         state->key = getkeybyname(state, vname, script, lineno);
         if (!state->key) {
            ast_log(LOG_WARNING, "Out of key space at line %d of %s\n", lineno, script);
            break;
         }
         if (state->key->defined) {
            ast_log(LOG_WARNING, "Cannot redefine key '%s' at line %d of %s\n", vname, lineno, script);
            break;
         }
         args = get_token(&buf, script, lineno);
         if (!args || strcasecmp(args, "IS")) {
            ast_log(LOG_WARNING, "Expecting 'IS', but got '%s' at line %d of %s\n", args ? args : "<nothing>", lineno, script);
            break;
         }
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "KEY definition missing short name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(tmp, args, sizeof(tmp) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a KEY short name at line %d of %s\n", args, lineno, script);
            break;
         }
         args = get_token(&buf, script, lineno);
         if (args) {
            if (strcasecmp(args, "OR")) {
               ast_log(LOG_WARNING, "Expecting 'OR' but got '%s' instead at line %d of %s\n", args, lineno, script);
               break;
            }
            args = get_token(&buf, script, lineno);
            if (!args) {
               ast_log(LOG_WARNING, "KEY definition missing optional long name at line %d of %s\n", lineno, script);
               break;
            }
            if (process_token(tmp2, args, sizeof(tmp2) - 1, ARG_STRING)) {
               ast_log(LOG_WARNING, "'%s' is not a valid token for a KEY long name at line %d of %s\n", args, lineno, script);
               break;
            }
         } else {
            ast_copy_string(tmp2, tmp, sizeof(tmp2));
         }
         if (strlen(tmp2) > 18) {
            ast_log(LOG_WARNING, "Truncating full name to 18 characters at line %d of %s\n", lineno, script);
            tmp2[18] = '\0';
         }
         if (strlen(tmp) > 7) {
            ast_log(LOG_WARNING, "Truncating short name to 7 bytes at line %d of %s\n", lineno, script);
            tmp[7] = '\0';
         }
         /* Setup initial stuff */
         state->key->retstr[0] = 128;
         /* 1 has the length */
         state->key->retstr[2] = state->key->id;
         /* Put the Full name in */
         memcpy(state->key->retstr + 3, tmp2, strlen(tmp2));
         /* Update length */
         state->key->retstrlen = strlen(tmp2) + 3;
         /* Put trailing 0xff */
         state->key->retstr[state->key->retstrlen++] = 0xff;
         /* Put the short name */
         memcpy(state->key->retstr + state->key->retstrlen, tmp, strlen(tmp));
         /* Update length */
         state->key->retstrlen += strlen(tmp);
         /* Put trailing 0xff */
         state->key->retstr[state->key->retstrlen++] = 0xff;
         /* Record initial length */
         state->key->initlen = state->key->retstrlen;
         state->state = STATE_INKEY;
      } else if (!strcasecmp(keyword, "SUB")) {
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "SUB definition missing name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(vname, args, sizeof(vname) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a KEY name at line %d of %s\n", args, lineno, script);
            break;
         }
         state->sub = getsubbyname(state, vname, script, lineno);
         if (!state->sub) {
            ast_log(LOG_WARNING, "Out of subroutine space at line %d of %s\n", lineno, script);
            break;
         }
         if (state->sub->defined) {
            ast_log(LOG_WARNING, "Cannot redefine subroutine '%s' at line %d of %s\n", vname, lineno, script);
            break;
         }
         /* Setup sub */
         state->sub->data[0] = 130;
         /* 1 is the length */
         state->sub->data[2] = 0x0; /* Clear extensibility bit */
         state->sub->datalen = 3;
         if (state->sub->id) {
            /* If this isn't the main subroutine, make a subroutine label for it */
            state->sub->data[3] = 9;
            state->sub->data[4] = state->sub->id;
            /* 5 is length */
            state->sub->data[6] = 0xff;
            state->sub->datalen = 7;
         }
         args = get_token(&buf, script, lineno);
         if (!args || strcasecmp(args, "IS")) {
            ast_log(LOG_WARNING, "Expecting 'IS', but got '%s' at line %d of %s\n", args ? args : "<nothing>", lineno, script);
            break;
         }
         state->state = STATE_INSUB;
      } else if (!strcasecmp(keyword, "STATE")) {
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "STATE definition missing name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(vname, args, sizeof(vname) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a STATE name at line %d of %s\n", args, lineno, script);
            break;
         }
         if (getstatebyname(state, vname, script, lineno, 0)) {
            ast_log(LOG_WARNING, "State '%s' is already defined at line %d of %s\n", vname, lineno, script);
            break;
         }
         getstatebyname(state, vname, script, lineno, 1);
      } else if (!strcasecmp(keyword, "FLAG")) {
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "FLAG definition missing name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(vname, args, sizeof(vname) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a FLAG name at line %d of %s\n", args, lineno, script);
            break;
         }
         if (getflagbyname(state, vname, script, lineno, 0)) {
            ast_log(LOG_WARNING, "Flag '%s' is already defined\n", vname);
            break;
         }
         getflagbyname(state, vname, script, lineno, 1);
      } else if (!strcasecmp(keyword, "DISPLAY")) {
         lrci = 0;
         wi = 0;
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "SUB definition missing name at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(vname, args, sizeof(vname) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "'%s' is not a valid token for a KEY name at line %d of %s\n", args, lineno, script);
            break;
         }
         if (getdisplaybyname(state, vname, script, lineno, 0)) {
            ast_log(LOG_WARNING, "State '%s' is already defined\n", vname);
            break;
         }
         disp = getdisplaybyname(state, vname, script, lineno, 1);
         if (!disp)
            break;
         args = get_token(&buf, script, lineno);
         if (!args || strcasecmp(args, "IS")) {
            ast_log(LOG_WARNING, "Missing 'IS' at line %d of %s\n", lineno, script);
            break;
         }
         args = get_token(&buf, script, lineno);
         if (!args) {
            ast_log(LOG_WARNING, "Missing Column 1 text at line %d of %s\n", lineno, script);
            break;
         }
         if (process_token(tmp, args, sizeof(tmp) - 1, ARG_STRING)) {
            ast_log(LOG_WARNING, "Token '%s' is not valid column 1 text at line %d of %s\n", args, lineno, script);
            break;
         }
         if (strlen(tmp) > 20) {
            ast_log(LOG_WARNING, "Truncating column one to 20 characters at line %d of %s\n", lineno, script);
            tmp[20] = '\0';
         }
         memcpy(disp->data + 5, tmp, strlen(tmp));
         disp->datalen = strlen(tmp) + 5;
         disp->data[disp->datalen++] = 0xff;

         args = get_token(&buf, script, lineno);
         if (args && !process_token(tmp, args, sizeof(tmp) - 1, ARG_STRING)) {
            /* Got a column two */
            if (strlen(tmp) > 20) {
               ast_log(LOG_WARNING, "Truncating column two to 20 characters at line %d of %s\n", lineno, script);
               tmp[20] = '\0';
            }
            memcpy(disp->data + disp->datalen, tmp, strlen(tmp));
            disp->datalen += strlen(tmp);
            args = get_token(&buf, script, lineno);
         }
         while(args) {
            if (!strcasecmp(args, "JUSTIFY")) {
               args = get_token(&buf, script, lineno);
               if (!args) {
                  ast_log(LOG_WARNING, "Qualifier 'JUSTIFY' requires an argument at line %d of %s\n", lineno, script);
                  break;
               }
               lrci = getjustifybyname(args);
               if (lrci < 0) {
                  ast_log(LOG_WARNING, "'%s' is not a valid justification at line %d of %s\n", args, lineno, script);
                  break;
               }
            } else if (!strcasecmp(args, "WRAP")) {
               wi = 0x80;
            } else {
               ast_log(LOG_WARNING, "'%s' is not a known qualifier at line %d of %s\n", args, lineno, script);
               break;
            }
            args = get_token(&buf, script, lineno);
         }
         if (args) {
            /* Something bad happened */
            break;
         }
         disp->data[0] = 129;
         disp->data[1] = disp->datalen - 2;
         disp->data[2] = ((lrci & 0x3) << 6) | disp->id;
         disp->data[3] = wi;
         disp->data[4] = 0xff;
      } else {
         ast_log(LOG_WARNING, "Invalid or Unknown keyword '%s' in PROGRAM\n", keyword);
      }
      break;
   case STATE_INKEY:
      if (process_returncode(state->key, keyword, buf, state, script, lineno)) {
         if (!strcasecmp(keyword, "ENDKEY")) {
            /* Return to normal operation and increment current key */
            state->state = STATE_NORMAL;
            state->key->defined = 1;
            state->key->retstr[1] = state->key->retstrlen - 2;
            state->key = NULL;
         } else {
            ast_log(LOG_WARNING, "Invalid or Unknown keyword '%s' in SOFTKEY definition at line %d of %s\n", keyword, lineno, script);
         }
      }
      break;
   case STATE_INIF:
      if (process_opcode(state->sub, keyword, buf, state, script, lineno)) {
         if (!strcasecmp(keyword, "ENDIF")) {
            /* Return to normal SUB operation and increment current key */
            state->state = STATE_INSUB;
            state->sub->defined = 1;
            /* Store the proper number of instructions */
            state->sub->ifdata[2] = state->sub->ifinscount;
         } else if (!strcasecmp(keyword, "GOTO")) {
            args = get_token(&buf, script, lineno);
            if (!args) {
               ast_log(LOG_WARNING, "GOTO clause missing Subscript name at line %d of %s\n", lineno, script);
               break;
            }
            if (process_token(tmp, args, sizeof(tmp) - 1, ARG_STRING)) {
               ast_log(LOG_WARNING, "'%s' is not a valid subscript name token at line %d of %s\n", args, lineno, script);
               break;
            }
            newsub = getsubbyname(state, tmp, script, lineno);
            if (!newsub) 
               break;
            /* Somehow you use GOTO to go to another place */
            state->sub->data[state->sub->datalen++] = 0x8;
            state->sub->data[state->sub->datalen++] = state->sub->ifdata[1];
            state->sub->data[state->sub->datalen++] = newsub->id;
            /* Terminate */
            state->sub->data[state->sub->datalen++] = 0xff;
            /* Increment counters */
            state->sub->inscount++;
            state->sub->ifinscount++;
         } else {
            ast_log(LOG_WARNING, "Invalid or Unknown keyword '%s' in IF clause at line %d of %s\n", keyword, lineno, script);
         }
      } else
         state->sub->ifinscount++;
      break;
   case STATE_INSUB:
      if (process_opcode(state->sub, keyword, buf, state, script, lineno)) {
         if (!strcasecmp(keyword, "ENDSUB")) {
            /* Return to normal operation and increment current key */
            state->state = STATE_NORMAL;
            state->sub->defined = 1;
            /* Store the proper length */
            state->sub->data[1] = state->sub->datalen - 2;
            if (state->sub->id) {
               /* if this isn't main, store number of instructions, too */
               state->sub->data[5] = state->sub->inscount;
            }
            state->sub = NULL;
         } else if (!strcasecmp(keyword, "IFEVENT")) {
            args = get_token(&buf, script, lineno);
            if (!args) {
               ast_log(LOG_WARNING, "IFEVENT clause missing Event name at line %d of %s\n", lineno, script);
               break;
            }
            event = geteventbyname(args);
            if (event < 1) {
               ast_log(LOG_WARNING, "'%s' is not a valid event\n", args);
               break;
            }
            args = get_token(&buf, script, lineno);
            if (!args || strcasecmp(args, "THEN")) {
               ast_log(LOG_WARNING, "IFEVENT clause missing 'THEN' at line %d of %s\n", lineno, script);
               break;
            }
            state->sub->ifinscount = 0;
            state->sub->ifdata = state->sub->data + 
                  state->sub->datalen;
            /* Reserve header and insert op codes */
            state->sub->ifdata[0] = 0x1;
            state->sub->ifdata[1] = event;
            /* 2 is for the number of instructions */
            state->sub->ifdata[3] = 0xff;
            state->sub->datalen += 4;
            /* Update Subscript instruction count */
            state->sub->inscount++;
            state->state = STATE_INIF;
         } else {
            ast_log(LOG_WARNING, "Invalid or Unknown keyword '%s' in SUB definition at line %d of %s\n", keyword, lineno, script);
         }
      }
      break;
   default:
      ast_log(LOG_WARNING, "Can't process keyword '%s' in weird state %d\n", keyword, state->state);
   }
   return 0;
}

static int adsi_prog	(	struct ast_channel *	chan,
		char *	script
	)			[static]

Definition at line 1436 of file app_adsiprog.c.

References adsi_begin_download(), adsi_load_session(), ADSI_MSG_DOWNLOAD, adsi_transmit_message(), ast_log(), ast_verbose(), compile_script(), adsi_script::desc, adsi_script::fdn, free, adsi_script::keys, LOG_NOTICE, LOG_WARNING, ast_channel::name, adsi_script::numkeys, option_verbose, adsi_soft_key::retstr, adsi_soft_key::retstrlen, adsi_script::sec, adsi_script::ver, VERBOSE_PREFIX_3, and adsi_soft_key::vname.

Referenced by adsi_exec().

{
   struct adsi_script *scr;
   int x;
   unsigned char buf[1024];
   int bytes;
   scr = compile_script(script);
   if (!scr) 
      return -1;

   /* Start an empty ADSI Session */
   if (adsi_load_session(chan, NULL, 0, 1) < 1) 
      return -1;

   /* Now begin the download attempt */
   if (adsi_begin_download(chan, scr->desc, scr->fdn, scr->sec, scr->ver)) {
      /* User rejected us for some reason */
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "User rejected download attempt\n");
      ast_log(LOG_NOTICE, "User rejected download on channel %s\n", chan->name);
      free(scr);
      return -1;
   }

   bytes = 0;
   /* Start with key definitions */
   for (x=0;x<scr->numkeys;x++) {
      if (bytes + scr->keys[x].retstrlen > 253) {
         /* Send what we've collected so far */
         if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
            ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
            return -1;
         }
         bytes =0;
      }
      memcpy(buf + bytes, scr->keys[x].retstr, scr->keys[x].retstrlen);
      bytes += scr->keys[x].retstrlen;
#ifdef DUMP_MESSAGES
      dump_message("Key", scr->keys[x].vname, scr->keys[x].retstr, scr->keys[x].retstrlen);
#endif
   }
   if (bytes) {
      if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
         ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
         return -1;
      }
   }

   bytes = 0;
   /* Continue with the display messages */
   for (x=0;x<scr->numdisplays;x++) {
      if (bytes + scr->displays[x].datalen > 253) {
         /* Send what we've collected so far */
         if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
            ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
            return -1;
         }
         bytes =0;
      }
      memcpy(buf + bytes, scr->displays[x].data, scr->displays[x].datalen);
      bytes += scr->displays[x].datalen;
#ifdef DUMP_MESSAGES
      dump_message("Display", scr->displays[x].vname, scr->displays[x].data, scr->displays[x].datalen);
#endif
   }
   if (bytes) {
      if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
         ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
         return -1;
      }
   }

   bytes = 0;
   /* Send subroutines */
   for (x=0;x<scr->numsubs;x++) {
      if (bytes + scr->subs[x].datalen > 253) {
         /* Send what we've collected so far */
         if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
            ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
            return -1;
         }
         bytes =0;
      }
      memcpy(buf + bytes, scr->subs[x].data, scr->subs[x].datalen);
      bytes += scr->subs[x].datalen;
#ifdef DUMP_MESSAGES
      dump_message("Sub", scr->subs[x].vname, scr->subs[x].data, scr->subs[x].datalen);
#endif
   }
   if (bytes) {
      if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
         ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
         return -1;
      }
   }


   bytes = 0;
   bytes += adsi_display(buf, ADSI_INFO_PAGE, 1, ADSI_JUST_LEFT, 0, "Download complete.", "");
   bytes += adsi_set_line(buf, ADSI_INFO_PAGE, 1);
   if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY) < 0)
      return -1;
   if (adsi_end_download(chan)) {
      /* Download failed for some reason */
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Download attempt failed\n");
      ast_log(LOG_NOTICE, "Download failed on %s\n", chan->name);
      free(scr);
      return -1;
   }
   free(scr);
   adsi_unload_session(chan);
   return 0;
}

static int clearcbone	(	char *	buf,
		char *	name,