src/cmd/cmdCmd.c

Go to the documentation of this file.

#include "cmdInt.h"

static char rcsid[] UNUSED = "$Id: cmdCmd.c,v 1.16 2005/04/16 04:23:02 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Stucture declarations                                                     */
/*---------------------------------------------------------------------------*/

typedef struct CommandDescrStruct {
  char *name;
  PFI command_fp;
  int changes_hmgr;
} CommandDescr_t;


/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/
Hrc_Manager_t *cmdBackupHmgr;
avl_tree *cmdCommandTable;

static char visShellChar = '!';      /* can be reset using the "set shell_char" */

static int autoexec;            /* indicates currently in autoexec */
static jmp_buf env;


/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static int com_dispatch(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int apply_alias(Hrc_Manager_t ** hmgr, int * argcp, char *** argvp, int * loop);
static void variableInterpolation(int *argc, char ***argv);
static char * variableInterpolationRecur(char *str);
static char * split_line(char * command, int * argc, char *** argv);
static int check_shell_escape(char * p, int * status);
static void sigterm(int sig);

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/

void
Cmd_CommandAdd(
  char * name,
  PFI  funcFp,
  int  changes)
{
  char *key, *value;
  CommandDescr_t *descr;
  int status;

  key = name;
  if (avl_delete(cmdCommandTable, &key, &value)) {
    /* delete existing definition for this command */
    (void) fprintf
      (vis_stderr, "** cmd warning: redefining '%s'\n", name);
    CmdCommandFree(value);
  }

  descr = ALLOC(CommandDescr_t, 1);
  descr->name = util_strsav(name);
  descr->command_fp = funcFp;
  descr->changes_hmgr = changes;
  status = avl_insert(cmdCommandTable, descr->name, (char *) descr);
  assert(!status);  /* error here in SIS version, TRS, 8/4/95 */
}


int
Cmd_CommandExecute(
  Hrc_Manager_t ** hmgr,
  char * command)
{
  int status, argc;
  int loop;
  char *commandp, **argv;

  (void) signal(SIGINT, SIG_IGN);
  commandp = command;
  do {
    if (check_shell_escape(commandp, &status)) {
      break;
    }
    
    commandp = split_line(commandp, &argc, &argv);
    loop = 0;
    status = apply_alias(hmgr, &argc, &argv, &loop);
    if (status == 0) {

      variableInterpolation(&argc, &argv);

      status = com_dispatch(hmgr, argc, argv);
    }
    CmdFreeArgv(argc, argv);
  } while (status == 0 && *commandp != '\0');
  return status;
}



/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/


void
CmdCommandFree(
  char * value)
{
  CommandDescr_t *command = (CommandDescr_t *) value;

  FREE(command->name);          /* same as key */
  FREE(command);
}


/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/

static int
com_dispatch(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int status;
  char *value;
  CommandDescr_t *descr;

  if (argc == 0) {              /* empty command */
    return 0;
  }

  if (! avl_lookup(cmdCommandTable, argv[0], &value)) {
    (void) fprintf(vis_stderr, "** cmd error: unknown command '%s'\n", argv[0]);
    return 1;
  }

  descr = (CommandDescr_t *) value;
  if (setjmp(env)) {
#if 0
    /* FIX (Tom) need hmgr_dup and network_dup to use this functionality */
    /* return from control-c -- restore the hmgr */
    if (descr->changes_hmgr) {
      *hmgr = cmdBackupHmgr;
      cmdBackupHmgr = NIL(Hrc_Manager_t);
    }
#endif
    return 1;
  }

  
#if 0
  /* FIX (Tom) need hmgr_dup and network_dup to use this functionality */
  if (descr->changes_hmgr) {
    if (cmdBackupHmgr != NIL(Hrc_Manager_t)) {
      Hrc_ManagerFree(cmdBackupHmgr);
    }
    cmdBackupHmgr = hmgr_dup(*hmgr);
  }
#endif
  
  (void) signal(SIGINT, sigterm);
  status = (*descr->command_fp)(hmgr, argc, argv);

  /* automatic execution of arbitrary command after each command */
  /* usually this is a passive command ... */
  if (status == 0 && ! autoexec) {
    if (avl_lookup(cmdFlagTable, "autoexec", &value)) {
      autoexec = 1;
      status = Cmd_CommandExecute(hmgr, value);
      autoexec = 0;
    }
  }

  (void) signal(SIGINT, SIG_IGN);
  return status;
}


static int
apply_alias(
  Hrc_Manager_t ** hmgr,
  int * argcp,
  char *** argvp,
  int * loop)
{
  int i, argc, stopit, added, offset, did_subst, subst, status, newc, j;
  char *arg, **argv, **newv;
  CmdAliasDescr_t *alias;

  argc = *argcp;
  argv = *argvp;
  stopit = 0;
  for(; *loop < 20; (*loop)++) {
    if (argc == 0) {
      return 0;
    }
    if (stopit != 0 || avl_lookup(cmdAliasTable, argv[0], &alias) == 0) {
      return 0;
    }
    if (strcmp(argv[0], alias->argv[0]) == 0) {
      stopit = 1;
    }
    FREE(argv[0]);
    added = alias->argc - 1;

    /* shift all the arguments to the right */
    if (added != 0) {
      argv = REALLOC(char *, argv, argc + added);
      for (i = argc - 1; i >= 1; i--) {
        argv[i + added] = argv[i];
      }
      for (i = 1; i <= added; i++) {
        argv[i] = NIL(char);
      }
      argc += added;
    }
    subst = 0;
    for (i = 0, offset = 0; i < alias->argc; i++, offset++) {
      arg = CmdHistorySubstitution(alias->argv[i], &did_subst);
      if (arg == NIL(char)) {
        *argcp = argc;
        *argvp = argv;
        return(1);
      }
      if (did_subst != 0) {
        subst = 1;
      }
      status = 0;
      do {
        arg = split_line(arg, &newc, &newv);
        /*
         * If there's a complete `;' terminated command in `arg',
         * when split_line() returns arg[0] != '\0'.
         */
        if (arg[0] == '\0') {   /* just a bunch of words */
          break;
        }
        status = apply_alias(hmgr, &newc, &newv, loop);
        if (status == 0) {
          status = com_dispatch(hmgr, newc, newv);
        }
        CmdFreeArgv(newc, newv);
      } while (status == 0);
      if (status != 0) {
        *argcp = argc;
        *argvp = argv;
        return(1);
      }
      added = newc - 1;
      if (added != 0) {
        argv = REALLOC(char *, argv, argc + added);
        for (j = argc - 1; j > offset; j--) {
          argv[j + added] = argv[j];
        }
        argc += added;
      }
      for (j = 0; j <= added; j++) {
        argv[j + offset] = newv[j];
      }
      FREE(newv);
      offset += added;
    }
    if (subst == 1) {
      for (i = offset; i < argc; i++) {
        FREE(argv[i]);
      }
      argc = offset;
    }
    *argcp = argc;
    *argvp = argv;
  }

  (void) fprintf(vis_stderr, "** cmd error: alias loop\n");
  return 1;
}


static void
variableInterpolation(int *ori_argc, char ***ori_argv)
{
  int i;          /* to iterate through the arguments */
  char *newStr;   /* string returned by the expanded value */
  char dollar;    /* character to store reference to the variable, now '$' */
  int argc;
  char **argv;
  int index;
  int null_string_flag;

  argc = *ori_argc;
  argv = *ori_argv;

  dollar = '$';
  null_string_flag = 0;

  /* step through all argvs */
  for (i = 0; i < argc; i++) {
    if (strchr((char *)argv[i], (int)dollar) != NULL) {
      /* expanded string returned by the procedure */
      newStr = variableInterpolationRecur(argv[i]);
      if(!strcmp(newStr, " ")) {
        FREE(argv[i]);
        /* replace old value with new */
        argv[i] = 0;
        null_string_flag = 1;
      }
      else {
        FREE(argv[i]);
        /* replace old value with new */
        argv[i] = newStr;
      }
    }
  } /* end of iterating through all arguments */

  if(null_string_flag) {
    *ori_argv = ALLOC(char *, argc);
    index = 0;
    for (i = 0; i < argc; i++) {
      if(argv[i] == 0) {
        (*ori_argc)--;
        continue;
      }
      (*ori_argv)[index++] = argv[i];
    }
    FREE(argv);
  }

  return;
}/* end of variable interpolation */


static char *
variableInterpolationRecur(char *str)
{
  int i;               /* iterators */
  int findEndDollar;   /* flag to denote that a $ has been found. So
                        * search till end of variable
                        */
  int endDollarIndex;  /* index in the current string of the end of the
                        * variable
                        */
  int dollarIndex;     /* index in the current string of the dollar sign */  
  int singleQuote;     /* flag that symbolizes that a quote is started */ 
  int doubleQuote;     /* flag that symbolizes that a quote is started */
  char *value;         /* value of the variable that is returned by the table */
  char *subStr;        /* string to store the variable */
  int curStrIndex;     /* index to step through the current string */
  int subLen;          /* length of the variable */
  int index;           /* variable use to step through the various strings */
  char *curStr;        /* current string which may change as substitutions
                        * take place
                        */
  char *newCurStr;     /* new string pieced together with the expanded value */
  char c;              /* current character in the string */

  int freeNewValue;    /* new value of string returned by recursion needs
                        * to be freed.
                        */
  char dollar;         /* character that stores the dollar sign */
  int lastPos;         /* position of the last character of the variable
                        * in the string.
                        */
  int envVar;           /* flag to say that the variable is not found in
                         * the table, hence may be an environment variable
                         */

  dollar = '$';
  curStrIndex = 0;
  subLen = 0;
  findEndDollar = 0;
  singleQuote = 0;
  doubleQuote = 0;
  dollarIndex = -1;
  endDollarIndex = -1;
  /* make a local copy since the string may change */
  curStr = ALLOC(char, strlen(str)+1);
  curStr = strncpy(curStr, str, strlen(str)+1);
  /* search through the end of string including te \0 character to detect
   * end of variable, if required.
   */
  while (curStrIndex <= (int) strlen(curStr)) {
    /* current character */
    c = curStr[curStrIndex];
    /* redundant here since split_line already strips out the quotes */
    if ((c == '\"') || (c == '\'')) {
      /* also termination charactrers for $ */
      /* set flags for quote found */
      singleQuote = !singleQuote;
      doubleQuote = !doubleQuote;
      /* also a variable termination */
      if (findEndDollar) {
        findEndDollar = 0;
        endDollarIndex = curStrIndex;
      }
    }
    /* detect a $ if not within quotes */
    if ((c == '$') && (!singleQuote) && (!doubleQuote)) {
      if (findEndDollar == 1) {
        error_append("Cannot have nested $ signs, not found termination\n");
        break;
      }
      /* note the beginning of the dollar position */
      dollarIndex = curStrIndex;
      /* start quest for end of dollar */
      findEndDollar = 1;
      endDollarIndex = -1;
    }
    /* termination characters are \0, :, / when not within quotes.
     * Although, some of these may never be encountered
     * since this is called after split_line and apply_alias
     * Termination characters except '\0' are ignored within quotes
     */
    if ((findEndDollar) &&
        ((c == '\0') ||
         ((!singleQuote) && (!doubleQuote) &&
          ((c == ':') || (c == '/'))))) {
      /*     if (((c == '\n') || (c == '\t') || (isspace(c)) ||
        (c == ':') || (c == ';') || (c == '\0') ||
        (c == '#') || (c == '/')) && (findEndDollar)) { */
        findEndDollar = 0;
        endDollarIndex = curStrIndex;
    } /* end of find termination characters */

    /* found the interpolation variable and its end*/
    if (!findEndDollar && (endDollarIndex != -1)) {
      /* found an interpolation variable */
      subLen = 0;
      freeNewValue = 0;
      envVar = 0;
      subStr = NULL;
      if (endDollarIndex > (dollarIndex +1)) {
        /* if not empty string */
        subStr = ALLOC(char, endDollarIndex - dollarIndex);
        /* copy the variable into another string */
        for ( i = 0; i <  endDollarIndex - dollarIndex - 1; i++) {
          subStr[i] = curStr[dollarIndex+1+i];
        }
        subStr[i] = '\0';
        /* quiet if of the form var$:iable or var$foo:iable and
         * $foo not in flag table
         */
        if (avl_lookup(cmdFlagTable, subStr, (char **)&value) != 0) {
          /* found the variable in the alias table */
          if (strchr((char *)value, (int)dollar) != NULL) {
            /* if more $s in the value */
            value = variableInterpolationRecur(value);
            subLen = strlen(value);
            /* to be freed later since variableInterpolationRecur
             * returns a new string to be freed later.
             */
            freeNewValue = 1;

          }  else {
          /* if no dollars in the value, substitute the return value
           * in the string
           */
            subLen = strlen(value);
          }
        } else { 
          /* if the variable is not found, it might be an
           * environment variable and so keep it. This might be
           * a hazard for bogus variables but that is upto the user.
           */
          value = subStr;
          /* for environment variable keep the $ sign */
          subLen = strlen(value) +1;
          envVar = 1;
        }

      } /* end of interpolation variable not trivial */
      /* prefix + strlen(substituted value) + suffix */
      newCurStr = ALLOC(char, dollarIndex + 
                              subLen +
                              strlen(curStr) - endDollarIndex + 1);
                        
      
      
      /* copy prefix */
      newCurStr = strncpy(newCurStr, curStr, dollarIndex);
      i = dollarIndex;
      if (subLen) {
        /* copy substituted value */
        if (envVar) {
          /* if it is an environment variable, keep the $ sign */
          newCurStr[i++] = '$';
        }
        index = 0;
        while (value[index] != '\0') {
          newCurStr[i++] = value[index++];
        }
        if (freeNewValue) {
          FREE(value);
        }
      }
      /* freed here cos value might be subStr in one case */
      if (subStr != NULL) {
        FREE(subStr);
      }
      /* copy suffix */
      index = endDollarIndex;
      /* figure out where to start the next search */
      lastPos = i;
      while (curStr[index] != '\0') {
        newCurStr[i++] = curStr[index++];
      }
      newCurStr[i] = '\0';
      FREE(curStr);
      curStr = newCurStr;
      /* reset counter for further search. Due to recursive calling of this
       * function eventually, the value that is substituted will not have a $
       */
      curStrIndex = lastPos;
      dollarIndex = -1;
      endDollarIndex = -1;
      /* end of found a variable */   
    } else { /* if a variable is not found, keep going */
      curStrIndex++;
    }
  } /* end of stepping through the string */
  return(curStr);
} /* end of variableInterpolationRecur */



static char *
split_line(
  char * command,
  int * argc,
  char *** argv)
{
  register char *p, *start, c;
  register int i, j;
  register char *new_arg;
  array_t *argv_array;
  int single_quote, double_quote;

  argv_array = array_alloc(char *, 5);

  p = command;
  for(;;) {
    /* skip leading white space */
    while (isspace((int)(*p))) {
      p++;
    }

    /* skip until end of this token */
    single_quote = double_quote = 0;
    for(start = p; (c = *p) != '\0'; p++) {
      if (c == ';' || c == '#' || isspace((int)c)) {
        if (! single_quote && ! double_quote) {
          break;
        }
      }
      if (c == '\'') {
        single_quote = ! single_quote;
      }
      if (c == '"') {
        double_quote = ! double_quote;
      }
    }
    if (single_quote || double_quote) {
      (void) fprintf(vis_stderr, "** cmd warning: ignoring unbalanced quote ...\n");
    }
    if (start == p) break;

    new_arg = ALLOC(char, p - start + 1);
    j = 0;
    for(i = 0; i < p - start; i++) {
      c = start[i];
      if ((c != '\'') && (c != '\"')) {
        new_arg[j++] = isspace((int)c) ? ' ' : start[i];
      }
    }
    new_arg[j] = '\0';
    array_insert_last(char *, argv_array, new_arg);
  }

  *argc = array_n(argv_array);
  *argv = array_data(char *, argv_array);
  array_free(argv_array);
  if (*p == ';') {
    p++;
  }
  else if (*p == '#') {
    for(; *p != 0; p++) ;               /* skip to end of line */
  }
  return p;
}    


static int
check_shell_escape(
  char * p,
  int * status)
{
    char *value;
    while (isspace((int)(*p))) {
        p++;
    }
    if ((value = Cmd_FlagReadByName("shell_char")) != NIL(char)){
        visShellChar = *value;
    }
    if (*p == visShellChar) {
        *status = system(p+1);
        return 1;
    }
    return 0;
}

static void
sigterm(int sig)
{
    (void) signal(SIGINT, SIG_IGN);     /* ignore further ctl-c */
    (void)fprintf(vis_stderr, "\n");
    (void)fprintf(vis_stderr,
                  "** cmd warning : data may be corrupted due to CTRL-c.\n");
    (void)fprintf(vis_stderr,
                  "                 It may cause abnormal termination.\n");
    longjmp(env, 1);
}