app_queue: Cleanup queue_ref / queue_unref routines.
[asterisk/asterisk.git] / apps / app_adsiprog.c
index e8ab878..cdc57aa 100644 (file)
  * \brief Program Asterisk ADSI Scripts into phone
  *
  * \author Mark Spencer <markster@digium.com>
- * 
+ *
  * \ingroup applications
  */
 
-#include "asterisk.h"
+/*! \li \ref app_adsiprog.c uses the configuration file \ref adsi.conf
+ * \addtogroup configuration_file Configuration Files
+ */
+
+/*!
+ * \page adsi.conf adsi.conf
+ * \verbinclude adsi.conf.sample
+ */
+
+/*** MODULEINFO
+       <depend>res_adsi</depend>
+       <support_level>deprecated</support_level>
+ ***/
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#include "asterisk.h"
 
-#include <sys/types.h>
 #include <netinet/in.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdlib.h>
 #include <ctype.h>
-#include <stdio.h>
-#include <errno.h>
 
+#include "asterisk/paths.h" /* use ast_config_AST_CONFIG_DIR */
 #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"
 
-static char *app = "ADSIProg";
-
-static char *synopsis = "Load Asterisk ADSI Scripts into phone";
+static const char app[] = "ADSIProg";
+
+/*** DOCUMENTATION
+       <application name="ADSIProg" language="en_US">
+               <synopsis>
+                       Load Asterisk ADSI Scripts into phone
+               </synopsis>
+               <syntax>
+                       <parameter name="script" required="false">
+                               <para>adsi script to use. If not given uses the default script <filename>asterisk.adsi</filename></para>
+                       </parameter>
+               </syntax>
+               <description>
+                       <para>This application programs an ADSI Phone with the given script</para>
+               </description>
+               <see-also>
+                       <ref type="application">GetCPEID</ref>
+                       <ref type="filename">adsi.conf</ref>
+               </see-also>
+       </application>
+ ***/
 
 /* #define DUMP_MESSAGES */
 
-static char *descrip =
-"  ADSIProg(script): This application programs an ADSI Phone with the given\n"
-"script. If nothing is specified, the default script (asterisk.adsi) is used.\n";
-
 struct adsi_event {
        int id;
-       char *name;
+       const char *name;
 };
 
-static struct adsi_event events[] = {
+static const struct adsi_event events[] = {
        { 1, "CALLERID" },
        { 2, "VMWI" },
        { 3, "NEARANSWER" },
@@ -91,32 +109,32 @@ static struct adsi_event events[] = {
        { 24, "CPEID" },
 };
 
-static struct adsi_event justify[] = {
+static const struct adsi_event justify[] = {
        { 0, "CENTER" },
        { 1, "RIGHT" },
        { 2, "LEFT" },
        { 3, "INDENT" },
 };
 
-#define STATE_NORMAL           0
-#define STATE_INKEY            1
-#define STATE_INSUB            2
-#define STATE_INIF             3
+#define STATE_NORMAL 0
+#define STATE_INKEY  1
+#define STATE_INSUB  2
+#define STATE_INIF   3
 
-#define MAX_RET_CODE           20
-#define MAX_SUB_LEN            255
-#define MAX_MAIN_LEN           1600
+#define MAX_RET_CODE 20
+#define MAX_SUB_LEN  255
+#define MAX_MAIN_LEN 1600
 
-#define ARG_STRING             (1 << 0)
-#define ARG_NUMBER             (1 << 1)
+#define ARG_STRING (1 << 0)
+#define ARG_NUMBER (1 << 1)
 
 struct adsi_soft_key {
-       char vname[40];         /* Which "variable" is associated with it */
-       int retstrlen;          /* Length of return string */
-       int initlen;            /* initial length */
+       char vname[40];  /* Which "variable" is associated with it */
+       int retstrlen;   /* Length of return string */
+       int initlen;     /* initial length */
        int id;
        int defined;
-       char retstr[80];        /* Return string data */
+       char retstr[80]; /* Return string data */
 };
 
 struct adsi_subscript {
@@ -191,7 +209,7 @@ static int process_token(void *out, char *src, int maxlen, int argtype)
                if (!(argtype & ARG_NUMBER))
                        return -1;
                /* Octal value */
-               if (sscanf(src, "%o", (int *)out) != 1)
+               if (sscanf(src, "%30o", (unsigned *)out) != 1)
                        return -1;
                if (argtype & ARG_STRING) {
                        /* Convert */
@@ -201,7 +219,7 @@ static int process_token(void *out, char *src, int maxlen, int argtype)
                if (!(argtype & ARG_NUMBER))
                        return -1;
                /* Hex value */
-               if (sscanf(src + 2, "%x", (unsigned int *)out) != 1)
+               if (sscanf(src + 2, "%30x", (unsigned int *)out) != 1)
                        return -1;
                if (argtype & ARG_STRING) {
                        /* Convert */
@@ -211,7 +229,7 @@ static int process_token(void *out, char *src, int maxlen, int argtype)
                if (!(argtype & ARG_NUMBER))
                        return -1;
                /* Hex value */
-               if (sscanf(src, "%d", (int *)out) != 1)
+               if (sscanf(src, "%30d", (int *)out) != 1)
                        return -1;
                if (argtype & ARG_STRING) {
                        /* Convert */
@@ -222,11 +240,11 @@ static int process_token(void *out, char *src, int maxlen, int argtype)
        return 0;
 }
 
-static char *get_token(char **buf, char *script, int lineno)
+static char *get_token(char **buf, const char *script, int lineno)
 {
-       char *tmp = *buf;
-       char *keyword;
+       char *tmp = *buf, *keyword;
        int quoted = 0;
+
        /* Advance past any white space */
        while(*tmp && (*tmp < 33))
                tmp++;
@@ -254,22 +272,24 @@ static char *get_token(char **buf, char *script, int lineno)
 
 static char *validdtmf = "123456789*0#ABCD";
 
-static int send_dtmf(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, const char *script, int lineno)
 {
-       char dtmfstr[80];
-       char *a;
-       int bytes=0;
-       a = get_token(&args, script, lineno);
-       if (!a) {
+       char dtmfstr[80], *a;
+       int bytes = 0;
+
+       if (!(a = get_token(&args, script, lineno))) {
                ast_log(LOG_WARNING, "Expecting something to send for SENDDTMF at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(dtmfstr, a, sizeof(dtmfstr) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid token for SENDDTMF at line %d of %s\n", lineno, script);
                return 0;
        }
+
        a = dtmfstr;
-       while(*a) {
+
+       while (*a) {
                if (strchr(validdtmf, *a)) {
                        *buf = *a;
                        buf++;
@@ -278,326 +298,378 @@ static int send_dtmf(char *buf, char *name, int id, char *args, struct adsi_scri
                        ast_log(LOG_WARNING, "'%c' is not a valid DTMF tone at line %d of %s\n", *a, lineno, script);
                a++;
        }
+
        return bytes;
 }
 
-static int goto_line(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int goto_line(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *page;
-       char *gline;
+       char *page = get_token(&args, script, lineno);
+       char *gline = get_token(&args, script, lineno);
        int line;
        unsigned char cmd;
-       page = get_token(&args, script, lineno);
-       gline = get_token(&args, script, lineno);
+
        if (!page || !gline) {
                ast_log(LOG_WARNING, "Expecting page and line number for GOTOLINE at line %d of %s\n", lineno, script);
                return 0;
        }
-       if (!strcasecmp(page, "INFO")) {
+
+       if (!strcasecmp(page, "INFO"))
                cmd = 0;
-       } else if (!strcasecmp(page, "COMM")) {
+       else if (!strcasecmp(page, "COMM"))
                cmd = 0x80;
-       } else {
-               ast_log(LOG_WARNING, "Expecting either 'INFO' or 'COMM' page, got got '%s' at line %d of %s\n", page, lineno, script);
+       else {
+               ast_log(LOG_WARNING, "Expecting either 'INFO' or 'COMM' page, got '%s' at line %d of %s\n", page, lineno, script);
                return 0;
        }
+
        if (process_token(&line, gline, sizeof(line), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid line number '%s' at line %d of %s\n", gline, lineno, script);
                return 0;
        }
+
        cmd |= line;
        buf[0] = 0x8b;
        buf[1] = cmd;
+
        return 2;
 }
 
-static int goto_line_rel(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, const char *script, int lineno)
 {
-       char *dir;
-       char *gline;
+       char *dir = get_token(&args, script, lineno);
+       char *gline = get_token(&args, script, lineno);
        int line;
        unsigned char cmd;
-       dir = get_token(&args, script, lineno);
-       gline = get_token(&args, script, lineno);
+
        if (!dir || !gline) {
                ast_log(LOG_WARNING, "Expecting direction and number of lines for GOTOLINEREL at line %d of %s\n", lineno, script);
                return 0;
        }
-       if (!strcasecmp(dir, "UP")) {
+
+       if (!strcasecmp(dir, "UP"))
                cmd = 0;
-       } else if (!strcasecmp(dir, "DOWN")) {
+       else if (!strcasecmp(dir, "DOWN"))
                cmd = 0x20;
-       } else {
+       else {
                ast_log(LOG_WARNING, "Expecting either 'UP' or 'DOWN' direction, got '%s' at line %d of %s\n", dir, lineno, script);
                return 0;
        }
+
        if (process_token(&line, gline, sizeof(line), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid line number '%s' at line %d of %s\n", gline, lineno, script);
                return 0;
        }
+
        cmd |= line;
        buf[0] = 0x8c;
        buf[1] = cmd;
+
        return 2;
 }
 
-static int send_delay(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int send_delay(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *gtime;
+       char *gtime = get_token(&args, script, lineno);
        int ms;
-       gtime = get_token(&args, script, lineno);
+
        if (!gtime) {
                ast_log(LOG_WARNING, "Expecting number of milliseconds to wait at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(&ms, gtime, sizeof(ms), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid delay milliseconds '%s' at line %d of %s\n", gtime, lineno, script);
                return 0;
        }
+
        buf[0] = 0x90;
+
        if (id == 11)
                buf[1] = ms / 100;
        else
                buf[1] = ms / 10;
+
        return 2;
 }
 
-static int set_state(char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
+static int set_state(char *buf, char *name, int id, char *args, struct adsi_script *istate, const char *script, int lineno)
 {
-       char *gstate;
+       char *gstate = get_token(&args, script, lineno);
        int state;
-       gstate = get_token(&args, script, lineno);
+
        if (!gstate) {
                ast_log(LOG_WARNING, "Expecting state number at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(&state, gstate, sizeof(state), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid state number '%s' at line %d of %s\n", gstate, lineno, script);
                return 0;
        }
+
        buf[0] = id;
        buf[1] = state;
+
        return 2;
 }
 
-static int cleartimer(char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
+static int cleartimer(char *buf, char *name, int id, char *args, struct adsi_script *istate, const char *script, int lineno)
 {
-       char *tok;
-       tok = get_token(&args, script, lineno);
-       if (tok) 
+       char *tok = get_token(&args, script, lineno);
+
+       if (tok)
                ast_log(LOG_WARNING, "Clearing timer requires no arguments ('%s') at line %d of %s\n", tok, lineno, script);
 
        buf[0] = id;
+
        /* For some reason the clear code is different slightly */
        if (id == 7)
                buf[1] = 0x10;
        else
                buf[1] = 0x00;
+
        return 2;
 }
 
-static struct adsi_flag *getflagbyname(struct adsi_script *state, char *name, char *script, int lineno, int create)
+static struct adsi_flag *getflagbyname(struct adsi_script *state, char *name, const char *script, int lineno, int create)
 {
        int x;
-       for (x=0;x<state->numflags;x++) 
-               if (!strcasecmp(state->flags[x].vname, name)) 
+
+       for (x = 0; x < state->numflags; x++) {
+               if (!strcasecmp(state->flags[x].vname, name))
                        return &state->flags[x];
+       }
+
        /* Return now if we're not allowed to create */
        if (!create)
                return NULL;
+
        if (state->numflags > 6) {
                ast_log(LOG_WARNING, "No more flag space at line %d of %s\n", lineno, script);
                return NULL;
        }
+
        ast_copy_string(state->flags[state->numflags].vname, name, sizeof(state->flags[state->numflags].vname));
        state->flags[state->numflags].id = state->numflags + 1;
        state->numflags++;
+
        return &state->flags[state->numflags-1];
 }
 
-static int setflag(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int setflag(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *tok;
+       char *tok = get_token(&args, script, lineno);
        char sname[80];
        struct adsi_flag *flag;
-       tok = get_token(&args, script, lineno);
+
        if (!tok) {
                ast_log(LOG_WARNING, "Setting flag requires a flag number at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(sname, tok, sizeof(sname) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid flag '%s' at line %d of %s\n", tok, lineno, script);
                return 0;
        }
-       flag = getflagbyname(state, sname, script, lineno, 0);
-       if (!flag) {
+
+       if (!(flag = getflagbyname(state, sname, script, lineno, 0))) {
                ast_log(LOG_WARNING, "Flag '%s' is undeclared at line %d of %s\n", sname, lineno, script);
                return 0;
        }
+
        buf[0] = id;
        buf[1] = ((flag->id & 0x7) << 4) | 1;
+
        return 2;
 }
 
-static int clearflag(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int clearflag(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *tok;
+       char *tok = get_token(&args, script, lineno);
        struct adsi_flag *flag;
        char sname[80];
-       tok = get_token(&args, script, lineno);
+
        if (!tok) {
                ast_log(LOG_WARNING, "Clearing flag requires a flag number at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(sname, tok, sizeof(sname) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid flag '%s' at line %d of %s\n", tok, lineno, script);
                return 0;
        }
-       flag = getflagbyname(state, sname, script, lineno, 0);
-       if (!flag) {
+
+       if (!(flag = getflagbyname(state, sname, script, lineno, 0))) {
                ast_log(LOG_WARNING, "Flag '%s' is undeclared at line %d of %s\n", sname, lineno, script);
                return 0;
        }
+
        buf[0] = id;
        buf[1] = ((flag->id & 0x7) << 4);
+
        return 2;
 }
 
-static int starttimer(char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
+static int starttimer(char *buf, char *name, int id, char *args, struct adsi_script *istate, const char *script, int lineno)
 {
-       char *tok;
+       char *tok = get_token(&args, script, lineno);
        int secs;
-       tok = get_token(&args, script, lineno);
+
        if (!tok) {
                ast_log(LOG_WARNING, "Missing number of seconds at line %d of %s\n", lineno, script);
                return 0;
        }
+
        if (process_token(&secs, tok, sizeof(secs), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid number of seconds '%s' at line %d of %s\n", tok, lineno, script);
                return 0;
        }
+
        buf[0] = id;
        buf[1] = 0x1;
        buf[2] = secs;
+
        return 3;
 }
 
 static int geteventbyname(char *name)
 {
        int x;
-       for (x=0;x<sizeof(events) / sizeof(events[0]); x++) {
+
+       for (x = 0; x < ARRAY_LEN(events); x++) {
                if (!strcasecmp(events[x].name, name))
                        return events[x].id;
        }
+
        return 0;
 }
 
 static int getjustifybyname(char *name)
 {
        int x;
-       for (x=0;x<sizeof(justify) / sizeof(justify[0]); x++) {
+
+       for (x = 0; x < ARRAY_LEN(justify); x++) {
                if (!strcasecmp(justify[x].name, name))
                        return justify[x].id;
        }
+
        return -1;
 }
 
-static struct adsi_soft_key *getkeybyname(struct adsi_script *state, char *name, char *script, int lineno)
+static struct adsi_soft_key *getkeybyname(struct adsi_script *state, char *name, const char *script, int lineno)
 {
        int x;
-       for (x=0;x<state->numkeys;x++) 
-               if (!strcasecmp(state->keys[x].vname, name)) 
+
+       for (x = 0; x < state->numkeys; x++) {
+               if (!strcasecmp(state->keys[x].vname, name))
                        return &state->keys[x];
+       }
+
        if (state->numkeys > 61) {
                ast_log(LOG_WARNING, "No more key space at line %d of %s\n", lineno, script);
                return NULL;
        }
+
        ast_copy_string(state->keys[state->numkeys].vname, name, sizeof(state->keys[state->numkeys].vname));
        state->keys[state->numkeys].id = state->numkeys + 2;
        state->numkeys++;
+
        return &state->keys[state->numkeys-1];
 }
 
-static struct adsi_subscript *getsubbyname(struct adsi_script *state, char *name, char *script, int lineno)
+static struct adsi_subscript *getsubbyname(struct adsi_script *state, char *name, const char *script, int lineno)
 {
        int x;
-       for (x=0;x<state->numsubs;x++) 
-               if (!strcasecmp(state->subs[x].vname, name)) 
+
+       for (x = 0; x < state->numsubs; x++) {
+               if (!strcasecmp(state->subs[x].vname, name))
                        return &state->subs[x];
+       }
+
        if (state->numsubs > 127) {
                ast_log(LOG_WARNING, "No more subscript space at line %d of %s\n", lineno, script);
                return NULL;
        }
+
        ast_copy_string(state->subs[state->numsubs].vname, name, sizeof(state->subs[state->numsubs].vname));
        state->subs[state->numsubs].id = state->numsubs;
        state->numsubs++;
+
        return &state->subs[state->numsubs-1];
 }
 
-static struct adsi_state *getstatebyname(struct adsi_script *state, char *name, char *script, int lineno, int create)
+static struct adsi_state *getstatebyname(struct adsi_script *state, char *name, const char *script, int lineno, int create)
 {
        int x;
-       for (x=0;x<state->numstates;x++) 
-               if (!strcasecmp(state->states[x].vname, name)) 
+
+       for (x = 0; x <state->numstates; x++) {
+               if (!strcasecmp(state->states[x].vname, name))
                        return &state->states[x];
+       }
+
        /* Return now if we're not allowed to create */
        if (!create)
                return NULL;
+
        if (state->numstates > 253) {
                ast_log(LOG_WARNING, "No more state space at line %d of %s\n", lineno, script);
                return NULL;
        }
+
        ast_copy_string(state->states[state->numstates].vname, name, sizeof(state->states[state->numstates].vname));
        state->states[state->numstates].id = state->numstates + 1;
        state->numstates++;
+
        return &state->states[state->numstates-1];
 }
 
-static struct adsi_display *getdisplaybyname(struct adsi_script *state, char *name, char *script, int lineno, int create)
+static struct adsi_display *getdisplaybyname(struct adsi_script *state, char *name, const char *script, int lineno, int create)
 {
        int x;
-       for (x=0;x<state->numdisplays;x++) 
-               if (!strcasecmp(state->displays[x].vname, name)) 
+
+       for (x = 0; x < state->numdisplays; x++) {
+               if (!strcasecmp(state->displays[x].vname, name))
                        return &state->displays[x];
+       }
+
        /* Return now if we're not allowed to create */
        if (!create)
                return NULL;
+
        if (state->numdisplays > 61) {
                ast_log(LOG_WARNING, "No more display space at line %d of %s\n", lineno, script);
                return NULL;
        }
+
        ast_copy_string(state->displays[state->numdisplays].vname, name, sizeof(state->displays[state->numdisplays].vname));
        state->displays[state->numdisplays].id = state->numdisplays + 1;
        state->numdisplays++;
+
        return &state->displays[state->numdisplays-1];
 }
 
-static int showkeys(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, const char *script, int lineno)
 {
-       char *tok;
-       char newkey[80];
-       int bytes;
+       char *tok, newkey[80];
+       int bytes, x, flagid = 0;
        unsigned char keyid[6];
-       int x;
-       int flagid=0;
        struct adsi_soft_key *key;
        struct adsi_flag *flag;
 
-       for (x=0;x<7;x++) {
+       for (x = 0; x < 7; x++) {
                /* Up to 6 key arguments */
-               tok = get_token(&args, script, lineno);
-               if (!tok)
+               if (!(tok = get_token(&args, script, lineno)))
                        break;
                if (!strcasecmp(tok, "UNLESS")) {
                        /* Check for trailing UNLESS flag */
-                       tok = get_token(&args, script, lineno);
-                       if (!tok) {
+                       if (!(tok = get_token(&args, script, lineno)))
                                ast_log(LOG_WARNING, "Missing argument for UNLESS clause at line %d of %s\n", lineno, script);
-                       } else if (process_token(newkey, tok, sizeof(newkey) - 1, ARG_STRING)) {
+                       else if (process_token(newkey, tok, sizeof(newkey) - 1, ARG_STRING))
                                ast_log(LOG_WARNING, "Invalid flag name '%s' at line %d of %s\n", tok, lineno, script);
-                       } else if (!(flag = getflagbyname(state, newkey, script, lineno, 0))) {
+                       else if (!(flag = getflagbyname(state, newkey, script, lineno, 0)))
                                ast_log(LOG_WARNING, "Flag '%s' is undeclared at line %d of %s\n", newkey, lineno, script);
-                       } else
+                       else
                                flagid = flag->id;
                        if ((tok = get_token(&args, script, lineno)))
                                ast_log(LOG_WARNING, "Extra arguments after UNLESS clause: '%s' at line %d of %s\n", tok, lineno, script);
@@ -608,83 +680,78 @@ static int showkeys(char *buf, char *name, int id, char *args, struct adsi_scrip
                        break;
                }
                if (process_token(newkey, tok, sizeof(newkey) - 1, ARG_STRING)) {
-                       ast_log(LOG_WARNING, "Invalid token for key name: %s\n", tok);  
+                       ast_log(LOG_WARNING, "Invalid token for key name: %s\n", tok);
                        continue;
                }
-                                  
-               key = getkeybyname(state, newkey, script, lineno);
-               if (!key)
+
+               if (!(key = getkeybyname(state, newkey, script, lineno)))
                        break;
                keyid[x] = key->id;
        }
        buf[0] = id;
        buf[1] = (flagid & 0x7) << 3 | (x & 0x7);
-       for (bytes=0;bytes<x;bytes++) {
+       for (bytes = 0; bytes < x; bytes++)
                buf[bytes + 2] = keyid[bytes];
-       }
+
        return 2 + x;
 }
 
-static int showdisplay(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, const char *script, int lineno)
 {
-       char *tok;
-       char dispname[80];
-       int line=0;
-       int flag=0;
-       int cmd = 3;
+       char *tok, dispname[80];
+       int line = 0, flag = 0, cmd = 3;
        struct adsi_display *disp;
 
        /* Get display */
-       tok = get_token(&args, script, lineno);
-       if (!tok || process_token(dispname, tok, sizeof(dispname) - 1, ARG_STRING)) {
+       if (!(tok = get_token(&args, script, lineno)) || process_token(dispname, tok, sizeof(dispname) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid display name: %s at line %d of %s\n", tok ? tok : "<nothing>", lineno, script);
                return 0;
        }
-       disp = getdisplaybyname(state, dispname, script, lineno, 0);
-       if (!disp) {
+
+       if (!(disp = getdisplaybyname(state, dispname, script, lineno, 0))) {
                ast_log(LOG_WARNING, "Display '%s' is undefined at line %d of %s\n", dispname, lineno, script);
                return 0;
        }
 
-       tok = get_token(&args, script, lineno);
-       if (!tok || strcasecmp(tok, "AT")) {
+       if (!(tok = get_token(&args, script, lineno)) || strcasecmp(tok, "AT")) {
                ast_log(LOG_WARNING, "Missing token 'AT' at line %d of %s\n", lineno, script);
                return 0;
        }
+
        /* Get line number */
-       tok = get_token(&args, script, lineno);
-       if (!tok || process_token(&line, tok, sizeof(line), ARG_NUMBER)) {
+       if (!(tok = get_token(&args, script, lineno)) || process_token(&line, tok, sizeof(line), ARG_NUMBER)) {
                ast_log(LOG_WARNING, "Invalid line: '%s' at line %d of %s\n", tok ? tok : "<nothing>", lineno, script);
                return 0;
        }
-       tok = get_token(&args, script, lineno);
-       if (tok && !strcasecmp(tok, "NOUPDATE")) {
+
+       if ((tok = get_token(&args, script, lineno)) && !strcasecmp(tok, "NOUPDATE")) {
                cmd = 1;
                tok = get_token(&args, script, lineno);
        }
+
        if (tok && !strcasecmp(tok, "UNLESS")) {
                /* Check for trailing UNLESS flag */
-               tok = get_token(&args, script, lineno);
-               if (!tok) {
+               if (!(tok = get_token(&args, script, lineno)))
                        ast_log(LOG_WARNING, "Missing argument for UNLESS clause at line %d of %s\n", lineno, script);
-               } else if (process_token(&flag, tok, sizeof(flag), ARG_NUMBER)) {
+               else if (process_token(&flag, tok, sizeof(flag), ARG_NUMBER))
                        ast_log(LOG_WARNING, "Invalid flag number '%s' at line %d of %s\n", tok, lineno, script);
-               }
+
                if ((tok = get_token(&args, script, lineno)))
                        ast_log(LOG_WARNING, "Extra arguments after UNLESS clause: '%s' at line %d of %s\n", tok, lineno, script);
        }
-                                  
+
        buf[0] = id;
-       buf[1] = (cmd << 6) | (disp->id & 0x3f); 
+       buf[1] = (cmd << 6) | (disp->id & 0x3f);
        buf[2] = ((line & 0x1f) << 3) | (flag & 0x7);
+
        return 3;
 }
 
-static int cleardisplay(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, const char *script, int lineno)
 {
-       char *tok;
-       tok = get_token(&args, script, lineno);
-       if (tok) 
+       char *tok = get_token(&args, script, lineno);
+
+       if (tok)
                ast_log(LOG_WARNING, "Clearing display requires no arguments ('%s') at line %d of %s\n", tok, lineno, script);
 
        buf[0] = id;
@@ -692,11 +759,11 @@ static int cleardisplay(char *buf, char *name, int id, char *args, struct adsi_s
        return 2;
 }
 
-static int digitdirect(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, const char *script, int lineno)
 {
-       char *tok;
-       tok = get_token(&args, script, lineno);
-       if (tok) 
+       char *tok = get_token(&args, script, lineno);
+
+       if (tok)
                ast_log(LOG_WARNING, "Digitdirect requires no arguments ('%s') at line %d of %s\n", tok, lineno, script);
 
        buf[0] = id;
@@ -704,10 +771,10 @@ static int digitdirect(char *buf, char *name, int id, char *args, struct adsi_sc
        return 2;
 }
 
-static int clearcbone(char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
+static int clearcbone(char *buf, char *name, int id, char *args, struct adsi_script *istate, const char *script, int lineno)
 {
-       char *tok;
-       tok = get_token(&args, script, lineno);
+       char *tok = get_token(&args, script, lineno);
+
        if (tok)
                ast_log(LOG_WARNING, "CLEARCB1 requires no arguments ('%s') at line %d of %s\n", tok, lineno, script);
 
@@ -716,11 +783,11 @@ static int clearcbone(char *buf, char *name, int id, char *args, struct adsi_scr
        return 2;
 }
 
-static int digitcollect(char *buf, char *name, int id, char *args, struct adsi_script *istate, char *script, int lineno)
+static int digitcollect(char *buf, char *name, int id, char *args, struct adsi_script *istate, const char *script, int lineno)
 {
-       char *tok;
-       tok = get_token(&args, script, lineno);
-       if (tok) 
+       char *tok = get_token(&args, script, lineno);
+
+       if (tok)
                ast_log(LOG_WARNING, "Digitcollect requires no arguments ('%s') at line %d of %s\n", tok, lineno, script);
 
        buf[0] = id;
@@ -728,52 +795,50 @@ static int digitcollect(char *buf, char *name, int id, char *args, struct adsi_s
        return 2;
 }
 
-static int subscript(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int subscript(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *tok;
-       char subscript[80];
+       char *tok = get_token(&args, script, lineno);
+       char subscr[80];
        struct adsi_subscript *sub;
-       tok = get_token(&args, script, lineno);
+
        if (!tok) {
                ast_log(LOG_WARNING, "Missing subscript to call at line %d of %s\n", lineno, script);
                return 0;
        }
-       if (process_token(subscript, tok, sizeof(subscript) - 1, ARG_STRING)) {
+
+       if (process_token(subscr, tok, sizeof(subscr) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid number of seconds '%s' at line %d of %s\n", tok, lineno, script);
                return 0;
        }
-       sub = getsubbyname(state, subscript, script, lineno);
-       if (!sub) 
+
+       if (!(sub = getsubbyname(state, subscr, script, lineno)))
                return 0;
+
        buf[0] = 0x9d;
        buf[1] = sub->id;
+
        return 2;
 }
 
-static int onevent(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno)
+static int onevent(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno)
 {
-       char *tok;
-       char subscript[80];
-       char sname[80];
-       int sawin=0;
-       int event;
-       int snums[8];
-       int scnt = 0;
-       int x;
+       char *tok = get_token(&args, script, lineno);
+       char subscr[80], sname[80];
+       int sawin = 0, event, snums[8], scnt = 0, x;
        struct adsi_subscript *sub;
-       tok = get_token(&args, script, lineno);
+
        if (!tok) {
                ast_log(LOG_WARNING, "Missing event for 'ONEVENT' at line %d of %s\n", lineno, script);
                return 0;
        }
-       event = geteventbyname(tok);
-       if (event < 1) {
+
+       if ((event = geteventbyname(tok)) < 1) {
                ast_log(LOG_WARNING, "'%s' is not a valid event name, at line %d of %s\n", args, lineno, script);
                return 0;
        }
+
        tok = get_token(&args, script, lineno);
-       while ((!sawin && !strcasecmp(tok, "IN")) ||
-              (sawin && !strcasecmp(tok, "OR"))) {
+       while ((!sawin && !strcasecmp(tok, "IN")) || (sawin && !strcasecmp(tok, "OR"))) {
                sawin = 1;
                if (scnt > 7) {
                        ast_log(LOG_WARNING, "No more than 8 states may be specified for inclusion at line %d of %s\n", lineno, script);
@@ -785,39 +850,36 @@ static int onevent(char *buf, char *name, int id, char *args, struct adsi_script
                        ast_log(LOG_WARNING, "'%s' is not a valid state name at line %d of %s\n", tok, lineno, script);
                        return 0;
                }
-               if ((snums[scnt] = getstatebyname(state, sname, script, lineno, 0) < 0)) {
+               if ((snums[scnt] = getstatebyname(state, sname, script, lineno, 0) == NULL)) {
                        ast_log(LOG_WARNING, "State '%s' not declared at line %d of %s\n", sname, lineno, script);
                        return 0;
                }
                scnt++;
-               tok = get_token(&args, script, lineno);
-               if (!tok)
+               if (!(tok = get_token(&args, script, lineno)))
                        break;
        }
        if (!tok || strcasecmp(tok, "GOTO")) {
                if (!tok)
                        tok = "<nothing>";
-               if (sawin) 
+               if (sawin)
                        ast_log(LOG_WARNING, "Got '%s' while looking for 'GOTO' or 'OR' at line %d of %s\n", tok, lineno, script);
                else
                        ast_log(LOG_WARNING, "Got '%s' while looking for 'GOTO' or 'IN' at line %d of %s\n", tok, lineno, script);
        }
-       tok = get_token(&args, script, lineno);
-       if (!tok) {
+       if (!(tok = get_token(&args, script, lineno))) {
                ast_log(LOG_WARNING, "Missing subscript to call at line %d of %s\n", lineno, script);
                return 0;
        }
-       if (process_token(subscript, tok, sizeof(subscript) - 1, ARG_STRING)) {
+       if (process_token(subscr, tok, sizeof(subscr) - 1, ARG_STRING)) {
                ast_log(LOG_WARNING, "Invalid subscript '%s' at line %d of %s\n", tok, lineno, script);
                return 0;
        }
-       sub = getsubbyname(state, subscript, script, lineno);
-       if (!sub) 
+       if (!(sub = getsubbyname(state, subscr, script, lineno)))
                return 0;
        buf[0] = 8;
        buf[1] = event;
        buf[2] = sub->id | 0x80;
-       for (x=0;x<scnt;x++)
+       for (x = 0; x < scnt; x++)
                buf[3 + x] = snums[x];
        return 3 + scnt;
 }
@@ -825,10 +887,10 @@ static int onevent(char *buf, char *name, int id, char *args, struct adsi_script
 struct adsi_key_cmd {
        char *name;
        int id;
-       int (*add_args)(char *buf, char *name, int id, char *args, struct adsi_script *state, char *script, int lineno);
+       int (*add_args)(char *buf, char *name, int id, char *args, struct adsi_script *state, const char *script, int lineno);
 };
 
-static struct adsi_key_cmd kcmds[] = {
+static const struct adsi_key_cmd kcmds[] = {
        { "SENDDTMF", 0, send_dtmf },
        /* Encoded DTMF would go here */
        { "ONHOOK", 0x81 },
@@ -870,8 +932,8 @@ static struct adsi_key_cmd kcmds[] = {
        { "EXIT", 0xa0 },
 };
 
-static struct adsi_key_cmd opcmds[] = {
-       
+static const struct adsi_key_cmd opcmds[] = {
+
        /* 1 - Branch on event -- handled specially */
        { "SHOWKEYS", 2, showkeys },
        /* Display Control */
@@ -890,27 +952,27 @@ static struct adsi_key_cmd opcmds[] = {
 };
 
 
-static int process_returncode(struct adsi_soft_key *key, 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, const char *script, int lineno)
 {
-       int x;
+       int x, res;
        char *unused;
-       int res;
-       for (x=0;x<sizeof(kcmds) / sizeof(kcmds[0]);x++) {
+
+       for (x = 0; x < ARRAY_LEN(kcmds); x++) {
                if ((kcmds[x].id > -1) && !strcasecmp(kcmds[x].name, code)) {
                        if (kcmds[x].add_args) {
                                res = kcmds[x].add_args(key->retstr + key->retstrlen,
                                                code, kcmds[x].id, args, state, script, lineno);
-                               if ((key->retstrlen + res - key->initlen) <= MAX_RET_CODE) 
+                               if ((key->retstrlen + res - key->initlen) <= MAX_RET_CODE)
                                        key->retstrlen += res;
-                               else 
+                               else
                                        ast_log(LOG_WARNING, "No space for '%s' code in key '%s' at line %d of %s\n", kcmds[x].name, key->vname, lineno, script);
                        } else {
-                               if ((unused = get_token(&args, script, lineno))) 
+                               if ((unused = get_token(&args, script, lineno)))
                                        ast_log(LOG_WARNING, "'%s' takes no arguments at line %d of %s (token is '%s')\n", kcmds[x].name, lineno, script, unused);
                                if ((key->retstrlen + 1 - key->initlen) <= MAX_RET_CODE) {
                                        key->retstr[key->retstrlen] = kcmds[x].id;
                                        key->retstrlen++;
-                               } else 
+                               } else
                                        ast_log(LOG_WARNING, "No space for '%s' code in key '%s' at line %d of %s\n", kcmds[x].name, key->vname, lineno, script);
                        }
                        return 0;
@@ -919,25 +981,24 @@ static int process_returncode(struct adsi_soft_key *key, char *code, char *args,
        return -1;
 }
 
-static int process_opcode(struct adsi_subscript *sub, char *code, 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, const char *script, int lineno)
 {
-       int x;
+       int x, res, max = sub->id ? MAX_SUB_LEN : MAX_MAIN_LEN;
        char *unused;
-       int res;
-       int max = sub->id ? MAX_SUB_LEN : MAX_MAIN_LEN;
-       for (x=0;x<sizeof(opcmds) / sizeof(opcmds[0]);x++) {
+
+       for (x = 0; x < ARRAY_LEN(opcmds); x++) {
                if ((opcmds[x].id > -1) && !strcasecmp(opcmds[x].name, code)) {
                        if (opcmds[x].add_args) {
                                res = opcmds[x].add_args(sub->data + sub->datalen,
                                                code, opcmds[x].id, args, state, script, lineno);
-                               if ((sub->datalen + res + 1) <= max) 
+                               if ((sub->datalen + res + 1) <= max)
                                        sub->datalen += res;
                                else {
                                        ast_log(LOG_WARNING, "No space for '%s' code in subscript '%s' at line %d of %s\n", opcmds[x].name, sub->vname, lineno, script);
                                        return -1;
                                }
                        } else {
-                               if ((unused = get_token(&args, script, lineno))) 
+                               if ((unused = get_token(&args, script, lineno)))
                                        ast_log(LOG_WARNING, "'%s' takes no arguments at line %d of %s (token is '%s')\n", opcmds[x].name, lineno, script, unused);
                                if ((sub->datalen + 2) <= max) {
                                        sub->data[sub->datalen] = opcmds[x].id;
@@ -957,55 +1018,45 @@ static int process_opcode(struct adsi_subscript *sub, char *code, char *args, st
        return -1;
 }
 
-static int adsi_process(struct adsi_script *state, char *buf, char *script, int lineno)
+static int adsi_process(struct adsi_script *state, char *buf, const char *script, int lineno)
 {
-       char *keyword;
-       char *args;
-       char vname[256];
-       char tmp[80];
-       char tmp2[80];
-       int lrci;
-       int wi;
-       int event;
+       char *keyword = get_token(&buf, script, lineno);
+       char *args, vname[256], tmp[80], tmp2[80];
+       int lrci, wi, event;
        struct adsi_display *disp;
        struct adsi_subscript *newsub;
-       /* Find the first keyword */
-       keyword = get_token(&buf, script, lineno);
-       if (!keyword) 
+
+       if (!keyword)
                return 0;
+
        switch(state->state) {
        case STATE_NORMAL:
                if (!strcasecmp(keyword, "DESCRIPTION")) {
-                       args = get_token(&buf, script, lineno);
-                       if (args) {
+                       if ((args = get_token(&buf, script, lineno))) {
                                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 ((args = get_token(&buf, script, lineno))) {
                                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 ((args = get_token(&buf, script, lineno))) {
                                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 ((args = get_token(&buf, script, lineno))) {
                                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) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "KEY definition missing name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1013,8 +1064,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                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) {
+                       if (!(state->key = getkeybyname(state, vname, script, lineno))) {
                                ast_log(LOG_WARNING, "Out of key space at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1022,13 +1072,11 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                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")) {
+                       if (!(args = get_token(&buf, script, lineno)) || 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) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "KEY definition missing short name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1036,14 +1084,12 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                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 ((args = get_token(&buf, script, lineno))) {
                                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) {
+                               if (!(args = get_token(&buf, script, lineno))) {
                                        ast_log(LOG_WARNING, "KEY definition missing optional long name at line %d of %s\n", lineno, script);
                                        break;
                                }
@@ -1063,7 +1109,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                tmp[7] = '\0';
                        }
                        /* Setup initial stuff */
-                       state->key->retstr[0] = 128;
+                       state->key->retstr[0] = 0x80;
                        /* 1 has the length */
                        state->key->retstr[2] = state->key->id;
                        /* Put the Full name in */
@@ -1082,8 +1128,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                        state->key->initlen = state->key->retstrlen;
                        state->state = STATE_INKEY;
                } else if (!strcasecmp(keyword, "SUB")) {
-                       args = get_token(&buf, script, lineno);
-                       if (!args) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "SUB definition missing name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1091,8 +1136,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                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) {
+                       if (!(state->sub = getsubbyname(state, vname, script, lineno))) {
                                ast_log(LOG_WARNING, "Out of subroutine space at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1101,7 +1145,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                break;
                        }
                        /* Setup sub */
-                       state->sub->data[0] = 130;
+                       state->sub->data[0] = 0x82;
                        /* 1 is the length */
                        state->sub->data[2] = 0x0; /* Clear extensibility bit */
                        state->sub->datalen = 3;
@@ -1113,15 +1157,13 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                state->sub->data[6] = 0xff;
                                state->sub->datalen = 7;
                        }
-                       args = get_token(&buf, script, lineno);
-                       if (!args || strcasecmp(args, "IS")) {
+                       if (!(args = get_token(&buf, script, lineno)) || 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) {
+               } else if (!strcasecmp(keyword, "STATE")) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "STATE definition missing name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1134,9 +1176,8 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                break;
                        }
                        getstatebyname(state, vname, script, lineno, 1);
-               } else if (!strcasecmp(keyword, "FLAG")) {
-                       args = get_token(&buf, script, lineno);
-                       if (!args) {
+               } else if (!strcasecmp(keyword, "FLAG")) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "FLAG definition missing name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1152,8 +1193,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                } else if (!strcasecmp(keyword, "DISPLAY")) {
                        lrci = 0;
                        wi = 0;
-                       args = get_token(&buf, script, lineno);
-                       if (!args) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "SUB definition missing name at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1165,16 +1205,13 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                ast_log(LOG_WARNING, "State '%s' is already defined\n", vname);
                                break;
                        }
-                       disp = getdisplaybyname(state, vname, script, lineno, 1);
-                       if (!disp)
+                       if (!(disp = getdisplaybyname(state, vname, script, lineno, 1)))
                                break;
-                       args = get_token(&buf, script, lineno);
-                       if (!args || strcasecmp(args, "IS")) {
+                       if (!(args = get_token(&buf, script, lineno)) || 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) {
+                       if (!(args = get_token(&buf, script, lineno))) {
                                ast_log(LOG_WARNING, "Missing Column 1 text at line %d of %s\n", lineno, script);
                                break;
                        }
@@ -1201,7 +1238,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                disp->datalen += strlen(tmp);
                                args = get_token(&buf, script, lineno);
                        }
-                       while(args) {
+                       while (args) {
                                if (!strcasecmp(args, "JUSTIFY")) {
                                        args = get_token(&buf, script, lineno);
                                        if (!args) {
@@ -1225,7 +1262,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                /* Something bad happened */
                                break;
                        }
-                       disp->data[0] = 129;
+                       disp->data[0] = 0x81;
                        disp->data[1] = disp->datalen - 2;
                        disp->data[2] = ((lrci & 0x3) << 6) | disp->id;
                        disp->data[3] = wi;
@@ -1256,8 +1293,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                /* 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) {
+                               if (!(args = get_token(&buf, script, lineno))) {
                                        ast_log(LOG_WARNING, "GOTO clause missing Subscript name at line %d of %s\n", lineno, script);
                                        break;
                                }
@@ -1265,8 +1301,7 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                        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) 
+                               if (!(newsub = getsubbyname(state, tmp, script, lineno)))
                                        break;
                                /* Somehow you use GOTO to go to another place */
                                state->sub->data[state->sub->datalen++] = 0x8;
@@ -1297,24 +1332,20 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
                                }
                                state->sub = NULL;
                        } else if (!strcasecmp(keyword, "IFEVENT")) {
-                               args = get_token(&buf, script, lineno);
-                               if (!args) {
+                               if (!(args = get_token(&buf, script, lineno))) {
                                        ast_log(LOG_WARNING, "IFEVENT clause missing Event name at line %d of %s\n", lineno, script);
                                        break;
                                }
-                               event = geteventbyname(args);
-                               if (event < 1) {
+                               if ((event = geteventbyname(args)) < 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")) {
+                               if (!(args = get_token(&buf, script, lineno)) || 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;
+                               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;
@@ -1335,39 +1366,40 @@ static int adsi_process(struct adsi_script *state, char *buf, char *script, int
        return 0;
 }
 
-static struct adsi_script *compile_script(char *script)
+static struct adsi_script *compile_script(const char *script)
 {
        FILE *f;
-       char fn[256];
-       char buf[256];
-       char *c;
-       int lineno=0;
-       int x, err;
+       char fn[256], buf[256], *c;
+       int lineno = 0, x, err;
        struct adsi_script *scr;
+
        if (script[0] == '/')
                ast_copy_string(fn, script, sizeof(fn));
        else
-               snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, script);
-       f = fopen(fn, "r");
-       if (!f) {
+               snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, script);
+
+       if (!(f = fopen(fn, "r"))) {
                ast_log(LOG_WARNING, "Can't open file '%s'\n", fn);
                return NULL;
        }
+
        if (!(scr = ast_calloc(1, sizeof(*scr)))) {
                fclose(f);
                return NULL;
        }
+
        /* Create "main" as first subroutine */
        getsubbyname(scr, "main", NULL, 0);
-       while(!feof(f)) {
-               fgets(buf, sizeof(buf), f);
+       while (!feof(f)) {
+               if (!fgets(buf, sizeof(buf), f)) {
+                       continue;
+               }
                if (!feof(f)) {
                        lineno++;
                        /* Trim off trailing return */
                        buf[strlen(buf) - 1] = '\0';
-                       c = strchr(buf, ';');
                        /* Strip comments */
-                       if (c)
+                       if ((c = strchr(buf, ';')))
                                *c = '\0';
                        if (!ast_strlen_zero(buf))
                                adsi_process(scr, buf, script, lineno);
@@ -1380,17 +1412,17 @@ static struct adsi_script *compile_script(char *script)
                break;
        case STATE_INSUB:
                ast_log(LOG_WARNING, "Missing ENDSUB at end of file %s\n", script);
-               free(scr);
+               ast_free(scr);
                return NULL;
        case STATE_INKEY:
                ast_log(LOG_WARNING, "Missing ENDKEY at end of file %s\n", script);
-               free(scr);
+               ast_free(scr);
                return NULL;
        }
        err = 0;
 
        /* Resolve all keys and record their lengths */
-       for (x=0;x<scr->numkeys;x++) {
+       for (x = 0; x < scr->numkeys; x++) {
                if (!scr->keys[x].defined) {
                        ast_log(LOG_WARNING, "Key '%s' referenced but never defined in file %s\n", scr->keys[x].vname, fn);
                        err++;
@@ -1398,7 +1430,7 @@ static struct adsi_script *compile_script(char *script)
        }
 
        /* Resolve all subs */
-       for (x=0;x<scr->numsubs;x++) {
+       for (x = 0; x < scr->numsubs; x++) {
                if (!scr->subs[x].defined) {
                        ast_log(LOG_WARNING, "Subscript '%s' referenced but never defined in file %s\n", scr->subs[x].vname, fn);
                        err++;
@@ -1410,7 +1442,7 @@ static struct adsi_script *compile_script(char *script)
        }
 
        if (err) {
-               free(scr);
+               ast_free(scr);
                return NULL;
        }
        return scr;
@@ -1421,42 +1453,40 @@ static void dump_message(char *type, char *vname, unsigned char *buf, int buflen
 {
        int x;
        printf("%s %s: [ ", type, vname);
-       for (x=0;x<buflen;x++)
-               printf("%02x ", buf[x]);
+       for (x = 0; x < buflen; x++)
+               printf("%02hhx ", buf[x]);
        printf("]\n");
 }
 #endif
 
-static int adsi_prog(struct ast_channel *chan, char *script)
+static int adsi_prog(struct ast_channel *chan, const char *script)
 {
        struct adsi_script *scr;
-       int x;
+       int x, bytes;
        unsigned char buf[1024];
-       int bytes;
-       scr = compile_script(script);
-       if (!scr) 
+
+       if (!(scr = compile_script(script)))
                return -1;
 
        /* Start an empty ADSI Session */
-       if (adsi_load_session(chan, NULL, 0, 1) < 1) 
+       if (ast_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)) {
+       if (ast_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);
+               ast_verb(3, "User rejected download attempt\n");
+               ast_log(LOG_NOTICE, "User rejected download on channel %s\n", ast_channel_name(chan));
+               ast_free(scr);
                return -1;
        }
 
        bytes = 0;
        /* Start with key definitions */
-       for (x=0;x<scr->numkeys;x++) {
+       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)) {
+                       if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
                                ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
                                return -1;
                        }
@@ -1469,7 +1499,7 @@ static int adsi_prog(struct ast_channel *chan, char *script)
 #endif
        }
        if (bytes) {
-               if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
+               if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
                        ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
                        return -1;
                }
@@ -1477,10 +1507,10 @@ static int adsi_prog(struct ast_channel *chan, char *script)
 
        bytes = 0;
        /* Continue with the display messages */
-       for (x=0;x<scr->numdisplays;x++) {
+       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)) {
+                       if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
                                ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
                                return -1;
                        }
@@ -1493,7 +1523,7 @@ static int adsi_prog(struct ast_channel *chan, char *script)
 #endif
        }
        if (bytes) {
-               if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
+               if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
                        ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
                        return -1;
                }
@@ -1501,10 +1531,10 @@ static int adsi_prog(struct ast_channel *chan, char *script)
 
        bytes = 0;
        /* Send subroutines */
-       for (x=0;x<scr->numsubs;x++) {
+       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)) {
+                       if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
                                ast_log(LOG_WARNING, "Unable to send chunk ending at %d\n", x);
                                return -1;
                        }
@@ -1517,81 +1547,71 @@ static int adsi_prog(struct ast_channel *chan, char *script)
 #endif
        }
        if (bytes) {
-               if (adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DOWNLOAD)) {
+               if (ast_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)
+       bytes += ast_adsi_display(buf, ADSI_INFO_PAGE, 1, ADSI_JUST_LEFT, 0, "Download complete.", "");
+       bytes += ast_adsi_set_line(buf, ADSI_INFO_PAGE, 1);
+       if (ast_adsi_transmit_message(chan, buf, bytes, ADSI_MSG_DISPLAY) < 0)
                return -1;
-       if (adsi_end_download(chan)) {
+       if (ast_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);
+               ast_verb(3, "Download attempt failed\n");
+               ast_log(LOG_NOTICE, "Download failed on %s\n", ast_channel_name(chan));
+               ast_free(scr);
                return -1;
        }
-       free(scr);
-       adsi_unload_session(chan);
+       ast_free(scr);
+       ast_adsi_unload_session(chan);
        return 0;
 }
 
-static int adsi_exec(struct ast_channel *chan, void *data)
+static int adsi_exec(struct ast_channel *chan, const char *data)
 {
-       int res=0;
-       struct localuser *u;
+       int res = 0;
 
-       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");
+
+       if (!ast_adsi_available(chan)) {
+               ast_verb(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");
+               ast_verb(3, "ADSI Available on CPE.  Attempting Upload.\n");
                res = adsi_prog(chan, data);
        }
 
-       LOCAL_USER_REMOVE(u);
-       
        return res;
 }
 
-static int unload_module(void *mod)
+static int unload_module(void)
 {
-       int res;
-
-       STANDARD_HANGUP_LOCALUSERS;
-
-       res = ast_unregister_application(app);  
-       
-
-       return res;
-}
-
-static int load_module(void *mod)
-{
-       __mod_desc = mod;
-       return ast_register_application(app, adsi_exec, synopsis, descrip);
+       return ast_unregister_application(app);
 }
 
-static const char *description(void)
-{
-       return "Asterisk ADSI Programming Application";
-}
-
-static const char *key(void)
+/*!
+ * \brief 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.
+ */
+static int load_module(void)
 {
-       return ASTERISK_GPL_KEY;
+       if (ast_register_application_xml(app, adsi_exec))
+               return AST_MODULE_LOAD_DECLINE;
+       return AST_MODULE_LOAD_SUCCESS;
 }
 
-STD_MOD(MOD_1, NULL, NULL, NULL);
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk ADSI Programming Application",
+       .support_level = AST_MODULE_SUPPORT_DEPRECATED,
+       .load = load_module,
+       .unload = unload_module,
+       .requires = "res_adsi",
+);