开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
script.c
资源名称：minicom-1.83.tar.gz　[点击查看]
上传用户：tianjinjs
上传日期：2007-01-05
资源大小：309k
文件大小：18k
源码类别：

Modem编程

开发平台：

Unix_Linux

script.c：源码内容
  1. /*
  2.  * Runscript    Run a login-or-something script.
  3.  * A basic like "programming language".
  4.  * This program also looks like a basic interpreter :
  5.  * a bit messy. (But hey, I'm no compiler writer :-))
  6.  *
  7.  * Version: 1.22
  8.  *
  9.  * Author: Miquel van Smoorenburg, miquels@drinkel.ow.nl
  10.  *
  11.  * Bugs: The "expect" routine is, unlike gosub, NOT reentrant !
  12.  *
  13.  * This file is part of the minicom communications package,
  14.  * Copyright 1991-1995 Miquel van Smoorenburg,
  15.  * 1997-1999 Jukka Lahtinen
  16.  *
  17.  * This program is free software; you can redistribute it and/or
  18.  * modify it under the terms of the GNU General Public License
  19.  * as published by the Free Software Foundation; either version
  20.  * 2 of the License, or (at your option) any later version.
  21.  *
  22.  * 10.07.98 jl  Added the log command
  23.  * 05.04.99 jl  The logfile name should also be passed as a parameter
  24.  */
  25. #include "port.h"
  26. #include "minicom.h"
  27. #include "intl.h"
  28.  
  29. #define OK 0
  30. #define ERR -1
  31. #define RETURN 1
  32. #define BREAK 2
  34. #ifndef lint
  35. char *Version = "@(#)runscript 1.23 31-May-1999 JL";
  36. #endif
  38. struct line {
  39.   char *line;
  40.   int labelcount;
  41.   int lineno;
  42.   struct line *next;
  43. };
  45. struct var {
  46.   char *name;
  47.   int value;
  48.   struct var *next;
  49. };
  51. #define LNULL ((struct line *)0)
  52. #define VNULL ((struct var  *)0)
  53. #ifndef CNULL
  54. #define CNULL ((char *)0)
  55. #endif
  58. /*
  59.  * Structure describing the script we are currently executing.
  60.  */
  61. struct env {
  62.   struct line *lines; /* Start of all lines */
  63.   struct var *vars; /* Start of all variables */
  64.   char *scriptname; /* Name of this script */
  65.   int verbose; /* Are we verbose? */
  66.   jmp_buf ebuf; /* For exit */
  67.   int exstat; /* For exit */
  68. };
  69.   
  70. struct env *curenv; /* Execution environment */  
  71. int gtimeout = 120; /* Global Timeout */
  72. int etimeout = 0; /* Timeout in expect routine */
  73. jmp_buf ejmp; /* To jump to if expect times out */
  74. int inexpect = 0; /* Are we in the expect routine */
  75. char *newline; /* What to print for 'n'. */
  76. char *s_login = "name"; /* User's login name */
  77. char *s_pass = "password"; /* User's password */
  78. struct line *thisline; /* Line to be executed */ 
  79. int laststatus = 0; /* Status of last command */
  80. char homedir[256]; /* Home directory */
  81. char logfname[PARS_VAL_LEN]; /* Name of logfile */
  83. static char inbuf[65]; /* Input buffer. */
  85. /* Forward declarations */
  86. int s_exec();
  87. int execscript();
  89. /*
  90.  * Print something formatted to stderr.
  91.  */
  92. /*VARARGS*/ 
  93. void s_error(fmt, a1, a2, a3, a4)
  94. char *fmt;
  95. char *a1, *a2, *a3, *a4;
  96. {
  97.   fprintf(stderr, fmt, a1, a2, a3, a4);
  98. }
  100. /*
  101.  * Walk through the environment, see if LOGIN and/or PASS are present.
  102.  * If so, delete them. (Someone using "ps" might see them!)
  103.  */
  104. void init_env()
  105. {
  106.   extern char **environ;
  107.   char **e;
  109.   for(e = environ; *e; e++) {
  110. if (!strncmp(*e, "LOGIN=", 6)) {
  111. s_login = (*e) + 6;
  112. *e = "LOGIN=";
  113. }
  114. if (!strncmp(*e, "PASS=", 5)) {
  115. s_pass = (*e) + 5;
  116. *e = "PASS=";
  117. }
  118.   }
  119. }
  122. /*
  123.  * Return an environment variable.
  124.  */
  125. char *mygetenv(env)
  126. char *env;
  127. {
  128.   if (!strcmp(env, "LOGIN")) return(s_login);
  129.   if (!strcmp(env, "PASS")) return(s_pass);
  130.   return(getenv(env));
  131. }
  133. /*
  134.  * Display a syntax error and exit.
  135.  */
  136. void syntaxerr(s)
  137. char *s;
  138. {
  139.   s_error(_("script "%s": syntax error in line %d %s%sn"),
  140.   curenv->scriptname, thisline->lineno, s, "r");
  141.   exit(1);
  142. }
  144. /*
  145.  * Skip all space
  146.  */
  147. void skipspace(s)
  148. char **s;
  149. {
  150.   while(**s == ' ' || **s == 't') (*s)++;
  151. }
  152.   
  153. /*
  154.  * Our clock. This gets called every second.
  155.  */
  156. /*ARGSUSED*/
  157. void myclock(dummy)
  158. int dummy;
  159. {
  160.   (void)dummy;
  161.   signal(SIGALRM, myclock);
  162.   alarm(1);
  164.   if (--gtimeout == 0) {
  165.    s_error(_("script "%s": global timeout%sn"),
  166. curenv->scriptname,"r");
  167.    exit(1);
  168.   }
  169.   if (inexpect && etimeout && --etimeout == 0) siglongjmp(ejmp, 1);
  170. }
  172. /*
  173.  * Read a word and advance pointer.
  174.  * Also processes quoting, variable substituting, and  escapes.
  175.  */
  176. char *getword(s)
  177. char **s;
  178. {
  179.   static char buf[81];
  180.   int len, f;
  181.   int idx = 0;
  182.   char *t = *s;
  183.   int sawesc = 0;
  184.   int sawq = 0;
  185.   char *env, envbuf[32];
  187.   if (**s == 0) return(CNULL);
  189.   for(len = 0; len < 81; len++) {
  190.    if (sawesc && t[len]) {
  191.    sawesc = 0;
  192.    if (t[len] <= '7' && t[len] >= '0') {
  193.    buf[idx] = 0;
  194.    for(f = 0; f < 4 && len < 81 && t[len] <= '7' &&
  195.        t[len] >= '0'; f++) 
  196.    buf[idx] = 8*buf[idx] + t[len++] - '0';
  197.    if (buf[idx] == 0) buf[idx] = '@';
  198.    idx++; len--;
  199.    continue;
  200.    }
  201.    switch(t[len]) {
  202.    case 'r':
  203.    buf[idx++] = 'r';
  204.    break;
  205.    case 'n':
  206.    buf[idx++] = 'n';
  207.    break;
  208.    case 'b':
  209.    buf[idx++] = 'b';
  210.    break;
  211. #ifndef _HPUX_SOURCE
  212.    case 'a':
  213.    buf[idx++] = 'a';
  214.    break;
  215. #endif
  216.    case 'f':
  217.    buf[idx++] = 'f';
  218.    break;
  219.    case 'c':
  220.    buf[idx++] = 255;
  221.    break;
  222.    default:
  223.    buf[idx++] = t[len];
  224.    break;
  225.    }
  226.    sawesc = 0;
  227.    continue;
  228.    }
  229.    if (t[len] == '\') {
  230.    sawesc = 1;
  231.    continue;
  232.    }
  233.    if (t[len] == '"') {
  234.    if (sawq == 1) {
  235.    sawq = 0;
  236.    len++;
  237.    break;
  238.    }
  239.    sawq = 1;
  240.    continue;
  241.    }
  242.    if (t[len] == '$' && t[len + 1] == '(') {
  243.    for(f = len; t[f] && t[f] != ')'; f++)
  244.    ;
  245.    if (t[f] == ')') {
  246.    strncpy(envbuf, &t[len + 2], f - len - 2);
  247.    envbuf[f - len - 2] = 0;
  248.    len = f;
  249.    env = mygetenv(envbuf);
  250.    if (env == CNULL) env = "";
  251.    while(*env) buf[idx++] = *env++;
  252.    continue;
  253.    }
  254.    }
  255.    if((!sawq && (t[len] == ' ' || t[len] == 't')) || t[len] == 0) break;
  256.    buf[idx++] = t[len];
  257.   }
  258.   buf[idx] = 0;
  259.   (*s) += len;
  260.   skipspace(s);
  261.   if (sawesc || sawq) syntaxerr(_("(word contains ESC or quote)"));
  262.   return(buf);
  263. }
  265. /*
  266.  * Save a string to memory. Strip trailing 'n'.
  267.  */
  268. char *strsave(s)
  269. char *s;
  270. {
  271.   char *t;
  272.   int len;
  274.   len = strlen(s);
  275.   if (len && s[len - 1] == 'n') s[--len] = 0;
  276.   if ((t = (char *)malloc(len + 1)) == (char *)0) return(t);
  277.   strcpy(t, s);
  278.   return(t);
  279. }
  281. /*
  282.  * Throw away all malloced memory.
  283.  */
  284. void freemem()
  285. {
  286.   struct line *l, *nextl;
  287.   struct var *v, *nextv;
  289.   for(l = curenv->lines; l; l = nextl) {
  290. nextl = l->next;
  291.    free((char *)l->line);
  292.    free((char *)l);
  293.   }
  294.   for(v = curenv->vars; v; v = nextv) {
  295. nextv = v->next;
  296.    free(v->name);
  297.    free((char *)v);
  298.   }
  299. }
  301. /*
  302.  * Read a script into memory.
  303.  */
  304. int readscript(s)
  305. char *s;
  306. {
  307.   FILE *fp;
  308.   struct line *tl, *prev = LNULL;
  309.   char *t;
  310.   char buf[81];
  311.   int no = 0;
  313.   if ((fp = fopen(s, "r")) == (FILE *)0) {
  314.    s_error(_("runscript: couldn't open %s%sn"), s, "r");
  315.    exit(1);
  316.   }
  317.   
  318.   /* Read all the lines into a linked list in memory. */
  319.   while((t = fgets(buf, 80, fp)) != CNULL) {
  320.    no++;
  321.    skipspace(&t);
  322.    if (*t == 'n') continue;
  323.    if (  ((tl = (struct line *)malloc(sizeof (struct line))) == LNULL) ||
  324.          ((tl->line = strsave(t)) == CNULL)) {
  325.    s_error(_("script %s: out of memory%sn"), s, "r");
  326.    exit(1);
  327.    }
  328.    if (prev)
  329.    prev->next = tl;
  330.    else
  331.    curenv->lines = tl;
  332.    tl->next = (struct line *)0;
  333.    tl->labelcount = 0;
  334.    tl->lineno = no;
  335.    prev = tl;
  336.   }
  337.   return(0);
  338. }
  340. /* Read one character, and store it in the buffer. */
  341. void readchar()
  342. {
  343.   char c;
  344.   int n;
  346.   while((n = read(0, &c, 1)) != 1)
  347.    if (errno != EINTR) break;
  348.   
  349.   if (n <= 0) return;
  351.   /* Shift character into the buffer. */
  352. #ifdef _SYSV
  353.   memcpy(inbuf, inbuf + 1, 63);
  354. #else
  355. #  ifdef _BSD43
  356.   bcopy(inbuf + 1, inbuf, 63);
  357. #  else
  358.   /* This is Posix, I believe. */
  359.   memmove(inbuf, inbuf + 1, 63);
  360. #  endif
  361. #endif
  362.   if (curenv->verbose) fputc(c, stderr);
  363.   inbuf[63] = c;
  364. }
  366. /* See if a string just came in. */
  367. int expfound(word)
  368. char *word;
  369. {
  370.   int len;
  372.   len = strlen(word);
  373.   if (len > 64) len = 64;
  375.   return(!strcmp(inbuf + 64 - len, word));
  376. }
  378. /*
  379.  * Send text to a file (stdout or stderr).
  380.  */
  381. int output(text, fp)
  382. char *text;
  383. FILE *fp;
  384. {
  385.   unsigned char *w;
  386.   int first = 1;
  387.   int donl = 1;
  389.   while((w = (unsigned char *)getword(&text)) != (unsigned char *)0) {
  390.    if (!first) fputc(' ', fp);
  391.    first = 0;
  392.    for(; *w; w++) {
  393.    if (*w == 255) {
  394.    donl = 0;
  395.    continue;
  396.    }
  397.    if (*w == 'n')
  398.    fputs(newline, fp);
  399.    else
  400.    fputc(*w, fp);
  401.    }
  402.   }
  403.   if (donl) fputs(newline, fp);
  404.   fflush(fp);
  405.   return(OK);
  406. }
  408. /*
  409.  * Find a variable in the list.
  410.  * If it is not there, create it.
  411.  */
  412. struct var *getvar(name, cr)
  413. char *name;
  414. int cr;
  415. {
  416.   struct var *v, *end = VNULL;
  417.   
  418.   for(v = curenv->vars; v; v = v->next) {
  419.    end = v;
  420.    if (!strcmp(v->name, name)) return(v);
  421.   }
  422.   if (!cr) {
  423.    s_error(_("script "%s" line %d: unknown variable "%s"%sn"),
  424.    curenv->scriptname, thisline->lineno, name, "r");
  425.    exit(1);
  426.   }
  427.   if ((v = (struct var *)malloc(sizeof(struct var))) == VNULL ||
  428.       (v->name = strsave(name)) == CNULL) {
  429.    s_error(_("script "%s": out of memory%sn"),
  430. curenv->scriptname, "r");
  431.    exit(1);
  432.   }
  433.   if (end)
  434. end->next = v;
  435.   else
  436.    curenv->vars = v;
  437.   v->next = VNULL;
  438.   v->value = 0;
  439.   return(v);
  440. }
  442. /*
  443.  * Read a number or variable.
  444.  */
  445. int getnum(text)
  446. char *text;
  447. {
  448.   int val;
  450.   if (!strcmp(text, "$?")) return(laststatus);
  451.   if ((val = atoi(text)) != 0 || *text == '0') return(val);
  452.   return(getvar(text, 0)->value);
  453. }
  455.   
  456. /*
  457.  * Get the lines following "expect" into memory.
  458.  */
  459. struct line **buildexpect()
  460. {
  461.   static struct line *seq[17];
  462.   int f;
  463.   char *w, *t;
  464.   
  465.   for(f = 0; f < 16; f++) {
  466.    if (thisline == LNULL) {
  467.    s_error(_("script "%s": unexpected end of file%sn"), 
  468.    curenv->scriptname, "r");
  469.    exit(1);
  470.    }
  471.    t = thisline->line;
  472.    w = getword(&t);
  473.    if (!strcmp(w, "}")) {
  474.    if (*t) syntaxerr(_("(garbage after })")); 
  475. seq[f] = NULL;
  476.    return(seq);
  477.    }
  478.    seq[f] = thisline;
  479.    thisline = thisline->next;
  480.   }
  481.   if (f == 16) syntaxerr(_("(too many arguments)"));
  482.   return(seq);
  483. }
  485. /*
  486.  * Our "expect" function.
  487.  */
  488. int expect(text)
  489. char *text;
  490. {
  491.   char *s, *w;
  492.   struct line **seq;
  493.   struct line oneline;
  494.   struct line *dflseq[2];
  495.   char *toact = "exit 1";
  496.   int found = 0, f, val, c;
  497.   char *action = CNULL;
  499.   if (inexpect) {
  500.     s_error(_("script "%s" line %d: nested expect%sn"),
  501.     curenv->scriptname, thisline->lineno, "r");
  502.     exit(1);
  503.   }
  504.   etimeout = 120;
  505.   inexpect = 1;
  507.   s = getword(&text);
  508.   if (!strcmp(s, "{")) {
  509.    if (*text) syntaxerr(_("(garbage after {)"));
  510.    thisline = thisline->next;
  511.    seq = buildexpect();
  512.   } else {
  513.   dflseq[1] = LNULL;
  514.   dflseq[0] = &oneline;
  515.   oneline.line = text;
  516.   oneline.next = LNULL;
  517. seq = dflseq;
  518.   }
  519.   /* Seek a timeout command */
  520.   for(f = 0; seq[f]; f++) {
  521.    if (!strncmp(seq[f]->line, "timeout", 7)) {
  522.    c = seq[f]->line[7];
  523.    if (c == 0 || (c != ' ' && c != 't')) continue;
  524.    s = seq[f]->line + 7;
  525.    seq[f] = LNULL;
  526.    skipspace(&s);
  527.    w = getword(&s);
  528.    if (w == CNULL) syntaxerr(_("(argument expected)"));
  529.    val = getnum(w);
  530.    if (val == 0) syntaxerr(_("(invalid argument)"));
  531.    etimeout = val;
  532.    skipspace(&s);
  533.    if (*s != 0) toact = s;
  534.    break;
  535. }
  536.   }
  537.   if (sigsetjmp(ejmp,1) != 0) {
  538.    f = s_exec(toact);
  539.    inexpect = 0;
  540.    return(f);
  541.   }
  543.   /* Allright. Now do the expect. */
  544.   c = OK;
  545.   while(!found) {
  546.    action = CNULL;
  547.    readchar();
  548.    for(f = 0; seq[f]; f++) {
  549.    s = seq[f]->line;
  550.    w = getword(&s);
  551.    if (expfound(w)) {
  552.    action = s;
  553.    found = 1;
  554.    break;
  555.    }
  556.    }
  557.    if (action != CNULL && *action) {
  558.    found = 0;
  559.    /* Maybe BREAK or RETURN */
  560.    if ((c = s_exec(action)) != OK) found = 1;
  561.    }
  562.   }
  563.   inexpect = 0;
  564.   etimeout = 0;
  565.   return(c);
  566. }
  568. /*
  569.  * Jump to a shell and run a command.
  570.  */
  571. int shell(text)
  572. char *text;
  573. {
  574.   laststatus = system(text);
  575.   return(OK);
  576. }
  578. /*
  579.  * Send output to stdout ( = modem)
  580.  */
  581. int dosend(text)
  582. char *text;
  583. {
  584. #ifdef __linux__
  585.   /* 200 ms delay. */
  586.   usleep(200000);
  587. #endif
  589.   /* Before we send anything, flush input buffer. */
  590.   m_flush(0);
  591.   memset(inbuf, 0, sizeof(inbuf));
  593.   newline = "r";
  594.   return(output(text, stdout));
  595. }
  597. /*
  598.  * Exit from the script, possibly with a value.
  599.  */
  600. int doexit(text)
  601. char *text;
  602. {
  603.   char *w;
  604.   int ret = 0;
  606.   w = getword(&text);
  607.   if (w != CNULL) ret = getnum(w);
  608.   curenv->exstat = ret;
  609.   longjmp(curenv->ebuf, 1);
  610.   return(0);
  611. }
  613. /*
  614.  * Goto a specific label.
  615.  */
  616. int dogoto(text)
  617. char *text;
  618. {
  619.   char *w;
  620.   struct line *l;
  621.   char buf[32];
  622.   int len;
  624.   w = getword(&text);
  625.   if (w == CNULL || *text) syntaxerr(_("(in goto/gosub label)"));
  626.   snprintf(buf, sizeof(buf), "%s:", w);
  627.   len = strlen(buf);
  628.   for(l = curenv->lines; l; l = l->next) if (!strncmp(l->line, buf, len)) break;
  629.   if (l == LNULL) {
  630.    s_error(_("script "%s" line %d: label "%s" not found%sn"),
  631.    curenv->scriptname, thisline->lineno, w, "r");
  632.    exit(1);
  633.   }
  634.   thisline = l;
  635.   /* We return break, to automatically break out of expect loops. */
  636.   return(BREAK);
  637. }
  639. /*
  640.  * Goto a subroutine.
  641.  */
  642. int dogosub(text)
  643. char *text;
  644. {
  645.   struct line *oldline;
  646.   int ret = OK;
  648.   oldline = thisline;
  649.   dogoto(text);
  650.   
  651.   while(ret != ERR) {
  652. if ((thisline = thisline->next) == LNULL) {
  653. s_error(_("script "%s": no return from gosub%sn"), 
  654. curenv->scriptname, "r");
  655. exit(1);
  656. }
  657. ret = s_exec(thisline->line);
  658. if (ret == RETURN) {
  659. ret = OK;
  660. thisline = oldline;
  661. break;
  662. }
  663.   }
  664.   return(ret);
  665. }
  667. /*
  668.  * Return from a subroutine.
  669.  */
  670. /*ARGSUSED*/
  671. int doreturn(text)
  672. char *text;
  673. {
  674.   (void)text;
  675.   return(RETURN);
  676. }
  678. /*
  679.  * Print text to stderr.
  680.  */
  681. int print(text)
  682. char *text;
  683. {
  684.   newline = "rn";
  686.   return(output(text, stderr));
  687. }
  689. /*
  690.  * Declare a variable (integer)
  691.  */
  692. int doset(text)
  693. char *text;
  694. {
  695.   char *w;
  696.   struct var *v;
  698.   w = getword(&text);
  699.   if (w == CNULL) syntaxerr(_("(missing var name)"));
  700.   v = getvar(w, 1);
  701.   if (*text) v->value = getnum(getword(&text));
  702.   return(OK);
  703. } 
  705. /*
  706.  * Lower the value of a variable.
  707.  */
  708. int dodec(text)
  709. char *text;
  710. {
  711.   char *w;
  712.   struct var *v;
  713.   
  714.   w = getword(&text);
  715.   if (w == CNULL)  syntaxerr(_("(expected variable)"));
  716.   v = getvar(w, 0);
  717.   v->value--;
  718.   return(OK);
  719. }
  721. /*
  722.  * Increase the value of a variable.
  723.  */
  724. int doinc(text)
  725. char *text;
  726. {
  727.   char *w;
  728.   struct var *v;
  729.   
  730.   w = getword(&text);
  731.   if (w == CNULL)  syntaxerr(_("(expected variable)"));
  732.   v = getvar(w, 0);
  733.   v->value++;
  734.   return(OK);
  735. }
  737. /*
  738.  * If syntax: if n1 [><=] n2 command.
  739.  */
  740. int doif(text)
  741. char *text;
  742. {
  743.   char *w;
  744.   int n1;
  745.   int n2;
  746.   char op;
  747.   
  748.   if ((w = getword(&text)) == CNULL) syntaxerr("(if)");
  749.   n1 = getnum(w);
  750.   if ((w = getword(&text)) == CNULL) syntaxerr("(if)");
  751.   if (strcmp(w, "!=") == 0)
  752. op = '!';
  753.   else {
  754. if (*w == 0 || w[1] != 0) syntaxerr("(if)");
  755. op = *w;
  756.   }
  757.   if ((w = getword(&text)) == CNULL) syntaxerr("(if)");
  758.   n2 = getnum(w);
  759.   if (!*text) syntaxerr(_("(expected command after if)"));
  760.   
  761.   if (op == '=') {
  762.    if (n1 != n2) return(OK);
  763.   } else if (op == '!') {
  764. if (n1 == n2) return(OK);
  765.   } else if (op == '>') {
  766.    if (n1 <= n2) return(OK);
  767.   } else if (op == '<') {
  768.    if (n1 >= n2) return(OK);
  769.   } else {
  770.    syntaxerr(_("(unknown operator)"));
  771.   }
  772.   return(s_exec(text));
  773. }
  775. /*
  776.  * Set the global timeout-time.
  777.  */
  778. int dotimeout(text)
  779. char *text;
  780. {
  781.   char *w;
  782.   int val;
  784.   w = getword(&text);
  785.   if(w == CNULL) syntaxerr(_("(argument expected)"));
  786.   if ((val = getnum(w)) == 0) syntaxerr(_("(invalid argument)"));
  787.   gtimeout = val;
  788.   return(OK);
  789. }
  791. /*
  792.  * Turn verbose on/off (= echo stdin to stderr)
  793.  */
  794. int doverbose(text)
  795. char *text;
  796. {
  797.   char *w;
  799.   curenv->verbose = 1;
  801.   if ((w = getword(&text)) != CNULL) {
  802. if (!strcmp(w, "on")) return(OK);
  803. if (!strcmp(w, "off")) {
  804. curenv->verbose = 0;
  805. return(OK);
  806. }
  807.   }
  808.   syntaxerr(_("(unexpected argument)"));
  809.   return(ERR);
  810. }
  812. /*
  813.  * Sleep for a certain number of seconds.
  814.  */
  815. int dosleep(text)
  816. char *text;
  817. {
  818.   int foo, tm;
  819.   
  820.   tm = getnum(text);
  821.   
  822.   foo = gtimeout - tm;
  823.   
  824.   /* The alarm goes off every second.. */
  825.   while(gtimeout != foo) pause();
  826.   return(OK);
  827. }
  829. /*
  830.  * Break out of an expect loop.
  831.  */
  832. int dobreak()
  833. {
  834.   if (!inexpect) {
  835.    s_error(_("script "%s" line %d: break outside of expect%sn"),
  836.    curenv->scriptname, thisline->lineno, "r");
  837.    exit(1);
  838.   }
  839.   return(BREAK);
  840. }
  842. /*
  843.  * Call another script!
  844.  */
  845. int docall(text)
  846. char *text;
  847. {
  848.   struct line *oldline;
  849.   struct env *oldenv;
  850.   int er;
  852.   if (*text == 0) syntaxerr(_("(argument expected)"));
  854.   if (inexpect) {
  855.    s_error(_("script "%s" line %d: call inside expect%sn"),
  856.    curenv->scriptname, "r");
  857.    exit(1);
  858.   }
  860.   oldline = thisline;
  861.   oldenv = curenv;
  862.   if ((er = execscript(text)) != 0) exit(er);
  863.   /* freemem(); */
  864.   thisline = oldline;
  865.   curenv = oldenv;
  866.   return(0);
  867. }
  869.   
  870. /* KEYWORDS */
  871. struct kw {
  872.   char *command;
  873.   int (*fn)();
  874. } keywords[] = {
  875.   { "expect", expect },
  876.   { "send", dosend },
  877.   { "!", shell },
  878.   { "goto", dogoto },
  879.   { "gosub", dogosub },
  880.   { "return", doreturn },
  881.   { "exit", doexit },
  882.   { "print", print },
  883.   { "set", doset },
  884.   { "inc", doinc },
  885.   { "dec", dodec },
  886.   { "if", doif },
  887.   { "timeout", dotimeout },
  888.   { "verbose", doverbose },
  889.   { "sleep", dosleep },
  890.   { "break", dobreak },
  891.   { "call", docall },
  892.   { "log", (int(*)())do_log },
  893.   { (char *)0, (int(*)())0 }
  894. };
  895.  
  896. /*
  897.  * Execute one line.
  898.  */
  899. int s_exec(text)
  900. char *text;
  901. {
  902.   char *w;
  903.   struct kw *k;
  905.   w = getword(&text);
  907.   /* If it is a label or a comment, skip it. */
  908.   if (w == CNULL || *w == '#' || w[strlen(w) - 1] == ':') return(OK);
  909.   
  910.   /* See which command it is. */
  911.   for(k = keywords; k->command; k++)
  912.    if (!strcmp(w, k->command)) break;
  914.   /* Command not found? */
  915.   if (k->command == (char *)NULL) {
  916. s_error(_("script "%s" line %d: unknown command "%s"%sn"),
  917.    curenv->scriptname, thisline->lineno, w, "r");
  918. exit(1);
  919.   }
  920.   return((*(k->fn))(text));
  921. }
  923. /*
  924.  * Run the script by continously executing "thisline".
  925.  */
  926. int execscript(s)
  927. char *s;
  928. {
  929.   int ret = OK;
  931.   curenv = (struct env *)malloc(sizeof(struct env));
  932.   curenv->lines = LNULL;
  933.   curenv->vars  = VNULL;
  934.   curenv->verbose = 1;
  935.   curenv->scriptname = s;
  937.   if (readscript(s) < 0) {
  938.    freemem();
  939. free(curenv);
  940.    return(ERR);
  941.   }
  942.   
  943.   signal(SIGALRM, myclock);
  944.   alarm(1);
  945.   if (setjmp(curenv->ebuf) == 0) {
  946. thisline = curenv->lines;
  947. while(thisline != LNULL && (ret = s_exec(thisline->line)) != ERR)
  948.    thisline = thisline->next;
  949.   } else
  950.    ret = curenv->exstat ? ERR : 0;
  951.   free(curenv);
  952.   return(ret);
  953. }
  955. int main(argc, argv)
  956. int argc;
  957. char **argv;
  958. {
  959.   char *s;
  960. #if 0 /* Shouldn't need this.. */
  961.   signal(SIGHUP, SIG_IGN);
  962. #endif
  964. #ifdef _I18N_
  965.   bindtextdomain("minicom", "/usr/share/locale");
  966.   textdomain("minicom");
  967. #endif
  969.   init_env();
  970.   memset(inbuf, 0, sizeof(inbuf));
  972.   if (argc < 2) {
  973.     s_error(_("Usage: runscript <scriptfile> [logfile [homedir]]%sn"),"r");
  974.     return(1);
  975.   }
  977.   if (argc > 2) {
  978.     strncpy(logfname, argv[2], sizeof(logfname));
  979.     if (argc > 3)
  980.       strncpy(homedir, argv[3], sizeof(homedir));
  981.     else if ((s = getenv("HOME")) != CNULL)
  982.       strncpy(homedir, s, sizeof(homedir));
  983.     else
  984.       homedir[0]=0;
  985.   }
  986.   else
  987.     logfname[0] = 0;
  989.   return(execscript(argv[1]) != OK);
  990. }