path: root/main/common/if.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 *
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * if.c:
 *
 * This file started off as the file for the "if" command in the monitor,
 * and has since grown into the file that contains the commands that only
 * make sense if they are used in scripts; hence, a prerequisite to these
 * commands is that TFS is included in the build.
 * It also contains the script runner portion of TFS.  The name of this
 * file should have been changed to tfsscript.c!
 *
 * if:
 * Supports the monitor's ability to do conditional branching within
 * scripts executed through TFS.
 *
 * goto:
 * Tag based jumping in a script.
 *
 * item:
 * A simple way to process a list (similar to KSH's 'for' construct).
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "genlib.h"
#include "stddefs.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "ether.h"
#include "cli.h"
#include <ctype.h>

#if INCLUDE_TFSSCRIPT

/* Subroutine variables:
 * The definition of MAXGOSUBDEPTH (15) determines the maximum number
 * of subroutines that can be nested within any one script invocation.
 * ReturnToTellTbl[]
 *  Used by script runner to keep track of the location in the file that
 *  the subroutine is supposed to return to.
 * ReturnToDepth
 *  The current subroutine nesting depth of the script runner.
 */
#define MAXGOSUBDEPTH   15
static int  ReturnToDepth;
static long ReturnToTellTbl[MAXGOSUBDEPTH+1];
static int  CurrentScriptfdTbl[TFS_MAXOPEN+1];

/* ScriptIsRunning:
 * Non-zero if a script is active, else zero.
 */
static int  ScriptIsRunning;

/* ScriptGotoTag:
 * Points to the string that is the most recent target of
 * a goto or gosub command.
 */
static char *ScriptGotoTag;

/* ScriptExitFlag:
 * If non-zero, then the script must exit.
 * The 'exit' command sets this flag based on options provided to exit.
 */
int ScriptExitFlag;

/* ExecuteAfterNext:
 * If the ScriptExitFlag has the EXECUTE_AFTER_EXIT flag set, then the content
 * of this array is assumed to be the file that is to be executed
 * automatically after the exit of the current script.
 */
char    ExecuteAfterExit[TFSNAMESIZE+1];

/*****************************************************************************/

/* If:
 *  A simple test/action statement.
 *  Currently, the only action supported is "goto tag".
 *  Syntax:
 *      if ARG1 compar ARG2 {action} [else action]
 *      if -t TEST {action} [else action]
 */
char *IfHelp[] = {
    "Conditional branching",
    "-[t:v] [{arg1} {compar} {arg2}] {action} [else action]",
#if INCLUDE_VERBOSEHELP
    " Options:",
    " -t{test} see below",
    " -v       verbose mode (print TRUE or FALSE result)",
    " Notes:",
    " * Numerical/logical/string compare:",
    "   seq sec sne sin gt lt le ge eq ne and or xor",
    " * Action:",
    "   goto tag | gosub tag | exit | return",
    " * Other tests (-t args):",
    "   gc, ngc, iscmp {filename}",
#endif
    0,
};

int
If(int argc, char *argv[])
{
    int     opt, arg, true, if_else, offset, verbose;
    void (*iffunc)(char *), (*elsefunc)(char *);
    long    var1, var2;
    char    *testtype, *arg1, *arg2, *iftag, *elsetag;

    verbose = 0;
    testtype = 0;
    while((opt=getopt(argc,argv,"vt:")) != -1) {
        switch(opt) {
        case 'v':
            verbose = 1;
            break;
        case 't':
            testtype = optarg;
            break;
        default:
            return(CMD_PARAM_ERROR);
        }
    }

    elsetag = 0;
    elsefunc = 0;
    offset = true = if_else = 0;

    /* First see if there is an 'else' present... */
    for(arg=optind; arg<argc; arg++) {
        if(!strcmp(argv[arg],"else")) {
            if_else = 1;
            break;
        }
    }

    if(if_else) {
        elsetag = argv[argc-1];
        if(!strcmp(argv[argc-1],"exit")) {
            offset = 2;
            elsefunc = exitscript;
        } else if(!strcmp(argv[argc-1],"return")) {
            offset = 2;
            elsefunc = gosubret;
        } else if(!strcmp(argv[argc-2],"goto")) {
            offset = 3;
            elsefunc = gototag;
        } else if(!strcmp(argv[argc-2],"gosub")) {
            offset = 3;
            elsefunc = gosubtag;
        } else {
            return(CMD_PARAM_ERROR);
        }
    }

    iftag = argv[argc-offset-1];
    if(!strcmp(argv[argc-offset-1],"exit")) {
        iffunc = exitscript;
    } else if(!strcmp(argv[argc-offset-1],"return")) {
        iffunc = gosubret;
    } else if(!strcmp(argv[argc-offset-2],"goto")) {
        iffunc = gototag;
    } else if(!strcmp(argv[argc-offset-2],"gosub")) {
        iffunc = gosubtag;
    } else {
        return(CMD_PARAM_ERROR);
    }

    if(testtype) {
        if(!strcmp(testtype,"gc")) {
            if(gotachar()) {
                true=1;
            }
        } else if(!strcmp(testtype,"ngc")) {
            if(!gotachar()) {
                true=1;
            }
        } else {
            return(CMD_PARAM_ERROR);
        }
    } else {
        arg1 = argv[optind];
        testtype = argv[optind+1];
        arg2 = argv[optind+2];

        var1 = strtoul(arg1,(char **)0,0);
        var2 = strtoul(arg2,(char **)0,0);

        if(!strcmp(testtype,"gt")) {
            if(var1 > var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"lt")) {
            if(var1 < var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"le")) {
            if(var1 <= var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"ge")) {
            if(var1 >= var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"eq")) {
            if(var1 == var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"ne")) {
            if(var1 != var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"and")) {
            if(var1 & var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"xor")) {
            if(var1 ^ var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"or")) {
            if(var1 | var2) {
                true = 1;
            }
        } else if(!strcmp(testtype,"sec")) {
            if(!strcasecmp(arg1,arg2)) {
                true = 1;
            }
        } else if(!strcmp(testtype,"seq")) {
            if(!strcmp(arg1,arg2)) {
                true = 1;
            }
        } else if(!strcmp(testtype,"sin")) {
            if(strstr(arg2,arg1)) {
                true = 1;
            }
        } else if(!strcmp(testtype,"sne")) {
            if(strcmp(arg1,arg2)) {
                true = 1;
            }
        } else {
            return(CMD_PARAM_ERROR);
        }
    }

    /* If the true flag is set, call the 'if' function.
     * If the true flag is clear, and "else" was found on the command
     * line, then call the 'else' function...
     */
    if(true) {
        if(verbose) {
            printf("TRUE\n");
        }
        iffunc(iftag);
    } else {
        if(verbose) {
            printf("FALSE\n");
        }
        if(if_else) {
            elsefunc(elsetag);
        }
    }

    return(CMD_SUCCESS);
}

int
InAScript(void)
{
    if(ScriptIsRunning) {
        return(1);
    } else {
        printf("Invalid from outside a script\n");
        return(0);
    }
}

void
exitscript(char *ignored)
{
    if(InAScript()) {
        ScriptExitFlag = EXIT_SCRIPT;
    }
}


char *ExitHelp[] = {
    "Exit currently running script",
    "-[ae:r]",
#if INCLUDE_VERBOSEHELP
    "Options:",
    " -a       exit all scripts (if nested)",
    " -e {exe} automatically execute 'exe' after exit",
    " -r       remove script after exit",
#endif
    0,
};

int
Exit(int argc, char *argv[])
{
    int opt;
    ScriptExitFlag = EXIT_SCRIPT;

    while((opt=getopt(argc,argv,"ae:r")) != -1) {
        switch(opt) {
        case 'a':
            ScriptExitFlag |= EXIT_ALL_SCRIPTS;
            break;
        case 'e':
            if(strlen(optarg) >= sizeof(ExecuteAfterExit)) {
                return(CMD_PARAM_ERROR);
            }
            ScriptExitFlag |= EXECUTE_AFTER_EXIT;
            strcpy(ExecuteAfterExit,optarg);
            break;
        case 'r':
            ScriptExitFlag |= REMOVE_SCRIPT;
            break;
        }
    }
    return(CMD_SUCCESS);
}

char *GotoHelp[] = {
    "Branch to file tag",
    "{tagname}",
    0,
};

int
Goto(int argc, char *argv[])
{
    if(argc != 2) {
        return(CMD_PARAM_ERROR);
    }
    gototag(argv[1]);
    return(CMD_SUCCESS);
}


char *GosubHelp[] = {
    "Call a subroutine",
    "{tagname}",
    0,
};

int
Gosub(int argc, char *argv[])
{
    if(argc != 2) {
        return(CMD_PARAM_ERROR);
    }
    gosubtag(argv[1]);
    return(CMD_SUCCESS);
}

char *ReturnHelp[] = {
    "Return from subroutine",
    "",
    0,
};

int
Return(int argc, char *argv[])
{
    if(argc != 1) {
        return(CMD_PARAM_ERROR);
    }
    gosubret(0);
    return(CMD_SUCCESS);
}

/* Item:
 *  This is a simple replacement for the KSH "for" construct...
 *  It allows the user to build a list of strings and retrieve one at a time.
 *  Basically, the items can be thought of as a table.  The value of idx
 *  (starting with 1) is used to index into the list of items and place
 *  that item in the shell variable "var".
 *  Syntax:
 *      item {idx} {var} {item1} {item2} {item3} ....
 */
char *ItemHelp[] = {
    "Extract an item from a list",
    "{idx} {stor_var} [item1] [item2] ...",
#if INCLUDE_VERBOSEHELP
    "Note: idx=1 retrieves item1",
#endif
    0,
};

int
Item(int argc, char *argv[])
{
    int idx;
    char *varname;

    if(argc < 3) {
        return(CMD_PARAM_ERROR);
    }

    idx = atoi(argv[1]);
    varname = argv[2];

    if((idx < 1) || (idx > (argc-3))) {
        setenv(varname,0);
        return(CMD_SUCCESS);
    }

    idx += 2;
    setenv(varname,argv[idx]);
    return(CMD_SUCCESS);
}

/* Read():
 *  Simple interactive shell variable entry.
 *  Syntax:
 *  read [options] [var1] [var2] [...]
 *  Options:
 *      -twww   timeout after 'www' milliseconds (approximate) of
 *              waiting for input.
 *
 */

char *ReadHelp[] = {
    "Interactive shellvar entry",
#if INCLUDE_VERBOSEHELP
    "-[fnp:t:T:] [var1] [var2] ... ",
    " -f      flush console input",
    " -n      no echo during read",
    " -p ***  prefill string",
    " -t ###  msec timeout per char",
    " -T ###  msec timeout cumulative",
    "Notes:",
    "  This command waits for console input terminated by ENTER.",
    "  Input tokens are whitespace delimited.",
    "Examples:",
    " * read name                    # wait forever",
    "   If user responds with ENTER, shell var 'name' is cleared;",
    "   else it is loaded with the first input token.",
    " * read -t2000 name             # timeout after 2 seconds",
    "   If timeout, shell var 'name' is untouched; else if timeout",
    "   doesn't occur, but user only types ENTER 'var' is cleared;",
    "   else 'var' will contain token.",
#endif
    0,
};

int
Read(int argc,char *argv[])
{
    int     i, reached_eol, opt, waitfor, noecho;
    char    *prefill, buf[64], *space, *bp;

    prefill = 0;
    waitfor = noecho = 0;
    while((opt=getopt(argc,argv,"fnp:t:T:")) != -1) {
        switch(opt) {
        case 'f':
            flush_console_in();
            return(CMD_SUCCESS);
        case 'n':
            noecho = 1;
            break;
        case 'p':
            prefill = optarg;
            break;
        case 't':
            waitfor = strtol(optarg,(char **)0,0);
            break;
        case 'T':
            waitfor = strtol(optarg,(char **)0,0);
            waitfor = -waitfor;
            break;
        default:
            return(CMD_PARAM_ERROR);
        }
    }

#if INCLUDE_MONCMD
    /* Since this command blocks waiting for user input on the console,
     * check to see if we are running under the context of MONCMD, and,
     * if yes, return CMD_FAILURE to avoid a lockup...
     */
    if(IPMonCmdActive) {
        printf("Invalid under moncmd context.\n");
        return(CMD_FAILURE);
    }
#endif

    /* If -t, then restart the timeout for each character.
     * If -T, then the timeout accumulates over all characters.
     * If a timeout does occur, then do nothing to the shell variables
     * that may be specified as arguments.  This allows the script
     * writer to distinguish between a timeout, and an empty line...
     * Timeout has no affect, empty line will NULL out the variable.
     */
    if(getfullline(buf,sizeof(buf)-1,0,waitfor,prefill,noecho?0:1) == -1) {
        return(CMD_SUCCESS);
    }

    /* If there were no args after the option, then there is no need to
     * consider populating a shell variable, so just return here.
     */
    if(argc == optind) {
        return(CMD_SUCCESS);
    }

    bp = buf;
    reached_eol = 0;
    for(i=optind; i<argc; i++) {
        space=strpbrk(bp," \t");
        if(space) {
            *space = 0;
            setenv(argv[i],bp);
            bp = space+1;
        } else {
            if((reached_eol) || (*bp == 0)) {
                setenv(argv[i],0);
            } else {
                setenv(argv[i],bp);
                reached_eol = 1;
            }
        }
    }
    return(CMD_SUCCESS);
}

int
currentScriptfd(void)
{
    return(CurrentScriptfdTbl[ScriptIsRunning]);
}

/* gototag():
 *  Used with tfsscript to allow a command to adjust the pointer into the
 *  script that is currently being executed.  It simply populates the
 *  "ScriptGotoTag" pointer with the tag that should be branched to next.
 */
void
gototag(char *tag)
{
    if(InAScript()) {
        if(ScriptGotoTag) {
            free(ScriptGotoTag);
        }
        ScriptGotoTag = malloc(strlen(tag)+8);
        sprintf(ScriptGotoTag,"# %s",tag);
    }
}

/* gosubtag():
 *  Similar in basic use to gototag(), except that we keep a copy of the
 *  current position in the active script file so that it can be returned
 *  to later.
 */
void
gosubtag(char *tag)
{
    if(InAScript()) {
        if(ReturnToDepth >= MAXGOSUBDEPTH) {
            printf("Max return-to depth reached\n");
            return;
        }
        ReturnToTellTbl[ReturnToDepth++] = tfstell(currentScriptfd());
        gototag(tag);
    }
}

void
gosubret(char *ignored)
{
    int offset, err;

    if(InAScript()) {
        err = 0;

        if(ReturnToDepth <= 0) {
            printf("Nothing to return to\n");
            err = 1;
        } else {
            ReturnToDepth--;
            offset = tfsseek(currentScriptfd(),
                             ReturnToTellTbl[ReturnToDepth],TFS_BEGIN);
            if(offset <= 0) {
                err = 1;
                printf("return error: %s\n",tfserrmsg(offset));
            }
        }
        if(err) {
            printf("Possible gosub/return imbalance.\n");
        }
    }
}

/* tfsscript():
 *  Treat the file as a list of commands that should be executed
 *  as monitor commands.  Step through each line and execute it.
 *  The tfsDocommand() function pointer is used so that the application
 *  can assign a different command interpreter to the script capbilities
 *  of the monitor.  To really take advantage of this, the command interpreter
 *  that is reassigned, should allow monitor commands to run if the command
 *  does not exist in the application's command list.
 *
 *  Scripts can call other scripts that call other scripts (etc...) and
 *  that works fine because tfsscript() will just use more stack space but
 *  it eventually returns through the same function call tree.  A script can
 *  also call a COFF, ELF or AOUT file and expect it to return as long as
 *  the executable returns through the same point into which it was started
 *  (the entrypoint).  If the executable uses mon_appexit() to terminate,
 *  then the calling script will not regain control.
 */

int
tfsscript(TFILE *fp,int verbose)
{
    char    lcpy[CMDLINESIZE], *sv;
    int     tfd, lnsize, lno, verbosity, ignoreerror, cmdstat;

    tfd = tfsopen(fp->name,TFS_RDONLY,0);
    if(tfd < 0) {
        return(tfd);
    }

    lno = 0;

    /* If ScriptIsRunning is zero, then we know that this is the top-level
     * script, so we can initialize state here...
     */
    if(ScriptIsRunning == 0) {
        ReturnToDepth = 0;
    }

    CurrentScriptfdTbl[++ScriptIsRunning] = tfd;

    while(1) {
        lno++;
        lnsize = tfsgetline(tfd,lcpy,CMDLINESIZE);
        if(lnsize == 0) {   /* end of file? */
            break;
        }
        if(lnsize < 0) {
            printf("tfsscript(): %s\n",tfserrmsg(lnsize));
            break;
        }
        if((lcpy[0] == '\r') || (lcpy[0] == '\n')) { /* empty line? */
            continue;
        }

        lcpy[lnsize-1] = 0;         /* Remove the newline */

        /* Just in case the goto tag was set outside a script, */
        /* clear it now. */
        if(ScriptGotoTag) {
            free(ScriptGotoTag);
            ScriptGotoTag = (char *)0;
        }

        ScriptExitFlag = 0;

        /* Execute the command line.
         * If the shell variable "SCRIPTVERBOSE" is set, then enable
         * verbosity for this command; else use what was passed in
         * the parameter list of the function.  Note that the variable
         * is tested for each command so that verbosity can be enabled
         * or disabled within a script.
         * If the command returns a status that indicates that there was
         * some parameter error, then exit the script.
         */
        sv = getenv("SCRIPTVERBOSE");
        if(sv) {
            verbosity = atoi(sv);
        } else {
            verbosity = verbose;
        }

        if((lcpy[0] == '-') || (getenv("SCRIPT_IGNORE_ERROR"))) {
            ignoreerror = 1;
        } else {
            ignoreerror = 0;
        }

        if(verbosity) {
            printf("[%02d]: %s\n",lno,lcpy);
        }

        cmdstat = tfsDocommand(lcpy[0] == '-' ? lcpy+1 : lcpy, 0);

        if(cmdstat != CMD_SUCCESS) {
            setenv("CMDSTAT","FAIL");
            if(ignoreerror == 0) {
                printf("Terminating script '%s' at line %d\n",
                       TFS_NAME(fp),lno);
                ScriptExitFlag = EXIT_SCRIPT;
                break;
            }
        } else {
            setenv("CMDSTAT","PASS");
        }

        /* Check for exit flag.  If set, then in addition to terminating the
         * script, clear the return depth here so that the "missing return"
         * warning  is not printed.  This is done because there is likely
         * to be a subroutine with an exit in it and this should not
         * cause a warning.
         */
        if(ScriptExitFlag) {
            ReturnToDepth = 0;
            break;
        }

        /* If ScriptGotoTag is set, then attempt to reposition the line
         * pointer to the line that contains the tag.
         */
        if(ScriptGotoTag) {
            int     tlen;

            tlen = strlen(ScriptGotoTag);
            lno = 0;
            tfsseek(tfd,0,TFS_BEGIN);
            while(1) {
                lnsize = tfsgetline(tfd,lcpy,CMDLINESIZE);
                if(lnsize == 0) {
                    printf("Tag '%s' not found\n",ScriptGotoTag+2);
                    free(ScriptGotoTag);
                    ScriptGotoTag = (char *)0;
                    tfsclose(tfd,0);
                    return(TFS_OKAY);
                }
                lno++;
                if(!strncmp(lcpy,ScriptGotoTag,tlen) &&
                        (isspace(lcpy[tlen]) || (lcpy[tlen] == ':'))) {
                    free(ScriptGotoTag);
                    ScriptGotoTag = (char *)0;
                    break;
                }
            }
        }
        /* After each line, poll ethernet interface. */
        pollethernet();
    }
    tfsclose(tfd,0);
    if(ScriptExitFlag & REMOVE_SCRIPT) {
        tfsunlink(fp->name);
    }
    if(ScriptIsRunning > 0) {
        ScriptIsRunning--;
        if((ScriptIsRunning == 0) && (ReturnToDepth != 0)) {
            printf("Error: script is done, but return-to-depth != 0\n");
            printf("(possible gosub/return imbalance)\n");
        }
    } else  {
        printf("Script run-depth error\n");
    }

    /* If the EXECUTE_AFTER_EXIT flag is set (by exit -e), then automatically
     * start up the file specified in ExecuteAfterExit[]...
     */
    if(ScriptExitFlag & EXECUTE_AFTER_EXIT) {
        char    *argv[2];

        argv[0] = ExecuteAfterExit;
        argv[1] = 0;
        ScriptExitFlag = 0;
        tfsrun(argv,0);
    }

    /* Upon completion of a script, clear the ScriptExitFlag variable so
     * that it is not accidentally applied to another script that may have
     * called this script.
     */
    if((ScriptExitFlag & EXIT_ALL_SCRIPTS) != EXIT_ALL_SCRIPTS) {
        ScriptExitFlag = 0;
    }
    return(TFS_OKAY);
}

/* tfsscriptname():
 * Return the currently running script name; else return an empty string.
 */
char *
tfsscriptname(void)
{
    struct  tfsdat *slot;

    if(ScriptIsRunning) {
        slot = &tfsSlots[CurrentScriptfdTbl[ScriptIsRunning]];
        if(slot->offset != (ulong)-1) {
            return(slot->hdr.name);
        }
    }
    return("");
}

#else   /* INCLUDE_TFSSCRIPT */

int
tfsscript(TFILE *fp,int verbose)
{
    return(TFSERR_NOTAVAILABLE);
}

char *
tfsscriptname(void)
{
    return(0);
}

#endif