home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / languages / tcl / expect / expect-4.7 / exp_inter.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-06  |  48.9 KB  |  1,940 lines
  1. /* interact (using select) - give user keyboard control
  2.  
  3. Written by: Don Libes, NIST, 2/6/90
  4.  
  5. Design and implementation of this program was paid for by U.S. tax
  6. dollars.  Therefore it is public domain.  However, the author and NIST
  7. would appreciate credit if this program or parts of it are used.
  8.  
  9. $Revision: 1.2 $
  10. $Date: 1993/03/03 00:21:20 $
  11.  
  12. */
  13.  
  14. #include "exp_conf.h"
  15. #include <stdio.h>
  16. #include <sys/types.h>
  17. #include <sys/time.h>
  18. #include <ctype.h>
  19.  
  20. #include "tcl.h"
  21. #include "string.h"
  22.  
  23. #include "exp_tty.h"
  24. #include "exp_rename.h"
  25. #include "exp_global.h"
  26. #include "exp_command.h"
  27. #include "exp_log.h"
  28.  
  29. #include "regexp.h"
  30. #include "exp_regexp.h"
  31.  
  32. extern int errno;
  33.  
  34. #define new(x)    (x *)malloc(sizeof(x))
  35.  
  36. struct action {
  37.     char *statement;
  38.     int fast;        /* if true, skip tty mode changing */
  39.     int update;        /* if true, check implicit spawn_id */
  40.     struct action *next;    /* chain only for later for freeing */
  41. };
  42.  
  43. struct keymap {
  44.     char *keys;    /* original pattern provided by user */
  45.     regexp *re;
  46.     int case_sensitive;
  47.     int echo;    /* if keystrokes should be echoed */
  48.     int writethru;    /* if keystrokes should go through to process */
  49.     struct action action;
  50.     struct keymap *next;
  51. };
  52.  
  53. struct output {
  54.     int spawn_id;
  55.     struct f *f;
  56.     struct action *action_eof;
  57.     struct output *next;
  58. };
  59.  
  60. struct input {
  61.     int spawn_id;
  62.     struct f *f;
  63.     struct output *output;
  64.     struct action *action_eof;
  65.     struct action *action_timeout;
  66.     struct keymap *keymap;
  67.     int timeout_nominal;        /* timeout nominal */
  68.     int timeout_remaining;        /* timeout remaining */
  69.     struct input *next;
  70. };
  71.  
  72. /* record any use of implicit spawn_id here in the event that it */
  73. /* needs updating */
  74. struct update {
  75.     int *spawn_id;
  76.     struct update *next;
  77. };
  78.  
  79. static void free_input();
  80. static void free_keymap();
  81. static void free_output();
  82. static void free_action();
  83. static void free_update();
  84. static struct action *new_action();
  85. static struct output *new_output();
  86. static struct input *new_input();
  87. static struct update *new_update();
  88. static int inter_eval();
  89.  
  90. /* special pattern that signifies the expect interpreter itself */
  91. #define INTERPRETER_ACTION    "interpreter"
  92.  
  93. char update_error_string[] = "malloc failed: -update";
  94.  
  95. /* NB: FOLLOWING DESCRIPTION HAS NOT BEEN REVISED SINCE ADDITION OF REGEXP */
  96. /* This function accepts user keystrokes and returns one of the above values */
  97. /* describing whether the keystrokes match a key sequence, and could or */
  98. /* can't if more characters arrive */
  99. /* The function assigns a matching keymap if there is a match or can-match */
  100.  
  101. /* The basic idea of how this works is it does a smart sequential search. */
  102. /* It is optimized (if you can call it that) towards a small number of */
  103. /* key mappings, but still works well for large maps, since no function */
  104. /* calls are made, and we stop as soon as there is a single-char mismatch, */
  105. /* and go on to the next one.  A hash table or compiled DFA probably would */
  106. /* not buy very much here for most maps. */
  107.  
  108. static
  109. int
  110. in_keymap(string,stringlen,keymap,km_match,match_length,skip)
  111. char *string;
  112. int stringlen;
  113. struct keymap *keymap;        /* linked list of keymaps */
  114. struct keymap **km_match;    /* keymap that matches or can match */
  115. int *match_length;        /* # of chars that matched */
  116. int *skip;            /* # of chars to skip */
  117. {
  118.     struct keymap *km;
  119.     char *ks;        /* string from a keymap */
  120.     char *start_search;    /* where in the string to start searching */
  121.     char *string_end;
  122.  
  123.     /* assert (*km == 0) */
  124.  
  125.     /* a shortcut that should help master output which typically */
  126.     /* is lengthy and has no key maps.  Otherwise it would mindlessly */
  127.     /* iterate on each character anyway. */
  128.     if (!keymap) {
  129.         *skip = stringlen;
  130.         return(EXP_CANTMATCH);
  131.     }
  132.  
  133.     string_end = string + stringlen;
  134.  
  135.     /* Mark beginning of line for ^ . */
  136.     regbol = string;
  137.  
  138. /* skip over nulls - Pascal Meheut, pascal@cnam.cnam.fr 18-May-1993 */
  139. /*    for (start_search = string;*start_search;start_search++) {*/
  140.     for (start_search = string;start_search<string_end;start_search++) {
  141.     if (*km_match) break; /* if we've already found a CAN_MATCH */
  142.             /* don't bother starting search from positions */
  143.             /* further along the string */
  144.  
  145.     for (km=keymap;km;km=km->next) {
  146.         char *s;    /* current character being examined */
  147.  
  148.         if (!km->re) {
  149.         /* fixed string */
  150.         for (s = start_search,ks = km->keys ;;s++,ks++) {
  151.             /* if we hit the end of this map, must've matched! */
  152.             if (*ks == 0) {
  153.                 *skip = start_search-string;
  154.                 *match_length = s-start_search;
  155.                 *km_match = km;
  156.                 return(EXP_MATCH);
  157.             }
  158.  
  159.             /* if we ran out of user-supplied characters, and */
  160.             /* still haven't matched, it might match if the user */
  161.             /* supplies more characters next time */
  162.             if (s == string_end) {
  163.                 /* skip to next key entry, but remember */
  164.                 /* possibility that this entry might match */
  165.                 if (!*km_match) *km_match = km;
  166.                 break;
  167.             }
  168.             /* skip to next key entry, if characters don't match */
  169.             if ((*s & 0x7f) != *ks) break;
  170.         }
  171.         } else {
  172.         /* regexp */
  173.         int r;    /* regtry status */
  174.         regexp *prog = km->re;
  175.  
  176.         /* if anchored, but we're not at beginning, skip pattern */
  177.         if (prog->reganch) {
  178.             if (string != start_search) continue;
  179.         }
  180.  
  181.         /* known starting char - quick test 'fore lotta work */
  182.         if (prog->regstart) {
  183.             if ((*start_search & 0x7f) != prog->regstart) break;
  184.         }
  185.         r = regtry(prog,start_search,match_length);
  186.         if (r == EXP_MATCH) {
  187.             *km_match = km;
  188.             *skip = start_search-string;
  189.             return(EXP_MATCH);
  190.         }
  191.         if (r == EXP_CANMATCH) {
  192.             if (!*km_match) *km_match = km;
  193.         }
  194.         }
  195.     }
  196.     }
  197.  
  198.     if (*km_match) {
  199.         /* report a can-match */
  200.         *skip = (start_search-string)-1;
  201.         *match_length = stringlen - *skip;
  202.         return(EXP_CANMATCH);
  203.     }
  204.  
  205.     *skip = start_search-string;
  206.     return(EXP_CANTMATCH);
  207. }
  208.  
  209. #ifdef SIMPLE_EVENT
  210.  
  211. #ifndef WEXITSTATUS
  212. #define WEXITSTATUS(stat) (((*((int *) &(stat))) >> 8) & 0xff)
  213. #endif
  214.  
  215. #include <setjmp.h>
  216. #include "exp_main.h"        /* need exp_exit */
  217.  
  218. static jmp_buf env;        /* for interruptable read() */
  219. static int reading;        /* while we are reading */
  220.                 /* really, while "env" is valid */
  221. static int deferred_interrupt = FALSE;    /* if signal is received, but not */
  222.                 /* in i_read record this here, so it will */
  223.                 /* be handled next time through i_read */
  224.  
  225. void sigchld_handler()
  226. {
  227.     if (reading) longjmp(env,1);
  228.  
  229.     deferred_interrupt = TRUE;
  230. }
  231.  
  232. #define EXP_CHILD_EOF -100
  233.  
  234. /* interruptable read */
  235. static int
  236. i_read(fd,buffer,length)
  237. int fd;
  238. char *buffer;
  239. int length;
  240. {
  241.     int cc = EXP_CHILD_EOF;
  242.  
  243.     if (deferred_interrupt) return(cc);
  244.  
  245.     if (0 == setjmp(env)) {
  246.         reading = TRUE;
  247.         cc = read(fd,buffer,length);
  248.     }
  249.     reading = FALSE;
  250.     return(cc);
  251. }
  252.  
  253. /* exit status for the child process created by cmdInteract */
  254. #define CHILD_DIED        -2
  255. #define SPAWNED_PROCESS_DIED    -3
  256.  
  257. static void
  258. clean_up_after_child(interp,master)
  259. Tcl_Interp *interp;
  260. int master;
  261. {
  262. /* should really be recoded using the common wait code in command.c */
  263.     int status;
  264.     int pid;
  265.     int i;
  266.     extern int fd_max;
  267.  
  268.     pid = wait(&status);    /* for slave */
  269.     for (i=0;i<=fd_max;i++) {
  270.         if (fs[i].pid == pid) {
  271.             fs[i].flags |= FD_SYSWAITED;
  272.             fs[i].wait = status;
  273.         }
  274.     }
  275.     pid = wait(&status);    /* for child */
  276.     for (i=0;i<=fd_max;i++) {
  277.         if (fs[i].pid == pid) {
  278.             fs[i].flags |= FD_SYSWAITED;
  279.             fs[i].wait = status;
  280.         }
  281.     }
  282.  
  283.     deferred_interrupt = FALSE;
  284.     exp_close(interp,master);
  285.     master = -1;
  286. }
  287. #endif /*SIMPLE_EVENT*/
  288.             
  289. #define finish(x)    { status = x; goto done; }
  290.  
  291. /*ARGSUSED*/
  292. int
  293. cmdInteract(clientData, interp, argc, argv)
  294. ClientData clientData;
  295. Tcl_Interp *interp;
  296. int argc;
  297. char **argv;
  298. {
  299. #ifdef SIMPLE_EVENT
  300.     int pid;
  301. #endif /*SIMPLE_EVENT*/
  302.  
  303.     /*declarations*/
  304.     int input_count;    /* count of struct input descriptors */
  305.     extern int fd_max;
  306.     struct input **fd_to_input;    /* map from fd's to "struct input"s */
  307.     int *fd_list;
  308.     struct keymap *km;    /* ptr for above while parsing */
  309.      extern char *tclRegexpError;    /* declared in tclInt.h */
  310.     extern int exp_dev_tty;
  311.     int master = EXP_SPAWN_ID_BAD;
  312.     int spawn_id_referenced = FALSE;    /* if spawn_id is implicitly */
  313.                         /* referenced */
  314.  
  315.     int all_fast = FALSE;    /* by default, turn off -f */
  316.     int next_fast = FALSE;    /* if we've seen a single -f */
  317.     int next_update = FALSE;/* if we've seen a single -update */
  318.     int next_re = FALSE;    /* if we've seen a single -re */
  319.     int next_writethru = FALSE;/*if macros should also go to proc output */
  320.     int next_echo = FALSE;    /* if macros should be echoed */
  321. /*    int next_case_sensitive = TRUE;*/
  322.     char **oldargv = 0;    /* save original argv here if we split it */
  323.     int status = TCL_OK;    /* final return value */
  324.     int i;            /* trusty temp */
  325.  
  326.     int timeout_simple = TRUE;    /* if no or global timeout */
  327.  
  328.     int tty_changed = FALSE;/* true if we had to change tty modes for */
  329.                 /* interact to work (i.e., to raw, noecho) */
  330.     int was_raw;
  331.     int was_echo;
  332.     exp_tty tty_old;
  333.  
  334.     int replace_user_by_process = EXP_SPAWN_ID_BAD; /* for -u flag */
  335.  
  336.     struct input *input_user;
  337.     struct input *input_default;
  338. #define input_base input_user
  339.     struct input *inp;    /* overused ptr to struct input */
  340.     struct output *outp;    /* overused ptr to struct output */
  341.  
  342.     int dash_input_count = 0; /* # of "-input"s seen */
  343.     int dash_output_count = 0; /* # of "-output"s seen */
  344.     int arbitrary_timeout;
  345.     int default_timeout;
  346.     struct action action_timeout;    /* common to all */
  347.     struct action action_eof;    /* common to all */
  348.     struct action **action_eof_ptr;    /* allow -input/ouput to */
  349.         /* leave their eof-action assignable by a later */
  350.         /* -eof */
  351.     struct action *action_base = 0;
  352.     struct update *update_base = 0;
  353.  
  354.     struct keymap **end_km;
  355.  
  356.     int key;
  357.  
  358.     if ((argc == 2) && exp_one_arg_braced(argv[1])) {
  359.         return(exp_eval_with_one_arg(clientData,interp,argc,argv));
  360.     } else if ((argc == 3) && streq(argv[1],"-brace")) {
  361.         char *new_argv[2];
  362.         new_argv[0] = argv[0];
  363.         new_argv[1] = argv[2];
  364.         return(exp_eval_with_one_arg(clientData,interp,argc,new_argv));
  365.     }
  366.  
  367.     argv++;
  368.     argc--;
  369.  
  370.     default_timeout = EXP_TIME_INFINITY;
  371.     arbitrary_timeout = EXP_TIME_INFINITY;    /* if user specifies */
  372.         /* a bunch of timeouts with EXP_TIME_INFINITY, this will be */
  373.         /* left around for us to find. */
  374.  
  375.     if (!(input_user = new_input(interp))) return(TCL_ERROR);
  376.     input_user->spawn_id = 0;    /* stdin by default */
  377.     input_user->output = 0;
  378.     input_user->action_eof = &action_eof;
  379.     input_user->timeout_nominal = EXP_TIME_INFINITY;
  380.     input_user->action_timeout = 0;
  381.     input_user->keymap = 0;
  382.     end_km = &input_user->keymap;
  383.     inp = input_user;
  384.     action_eof_ptr = &input_user->action_eof;
  385.  
  386.     if (!(input_default = new_input(interp))) return(TCL_ERROR);
  387.     input_default->spawn_id = EXP_SPAWN_ID_BAD;    /* fix later */
  388.     input_default->output = 0;
  389.     input_default->action_eof = &action_eof;
  390.     input_default->timeout_nominal = EXP_TIME_INFINITY;
  391.     input_default->action_timeout = 0;
  392.     input_default->keymap = 0;
  393.     input_default->next = 0;        /* no one else */
  394.     input_user->next = input_default;
  395.  
  396.     input_count = 2;
  397.  
  398.     action_eof.statement = "return";
  399.     action_eof.fast = TRUE;
  400.     action_timeout.fast = TRUE;
  401.  
  402.     for (;argc>0;argc--,argv++) {
  403.         if (streq(*argv,"--")) {
  404.             /* prevent other arguments from being matched */
  405.             argc--;argv++;
  406.  
  407.             /* this is the only one of these if's that doesn't */
  408.             /* have a "continue" */
  409.         } else if (streq(*argv,"-input")) {
  410.             dash_input_count++;
  411.             if (dash_input_count == 2) {
  412.                 inp = input_default;
  413.             } else if (dash_input_count > 2) {
  414.                 struct input *previous_input = inp;
  415.                 if (!(inp = new_input(interp)))
  416.                     return(TCL_ERROR);
  417.                 previous_input->next = inp;
  418.                 input_count++;
  419.             }
  420.             inp->output = 0;
  421.             inp->action_eof = &action_eof;
  422.             action_eof_ptr = &inp->action_eof;
  423.             inp->timeout_nominal = default_timeout;
  424.             inp->action_timeout = &action_timeout;
  425.             inp->keymap = 0;
  426.             end_km = &inp->keymap;
  427.             inp->next = 0;
  428.             argc--;argv++;
  429.             if (argc < 1) {
  430.                 exp_error(interp,"-input needs argument");
  431.                 return(TCL_ERROR);
  432.             }
  433.             inp->spawn_id = atoi(*argv);
  434.             continue;
  435.         } else if (streq(*argv,"-output")) {
  436.             struct output *tmp;
  437.  
  438.             dash_output_count++;
  439.  
  440.             /* imply a "-input" */
  441.             if (dash_input_count == 0) dash_input_count = 1;
  442.  
  443.             if (!(outp = new_output(interp))) return(TCL_ERROR);
  444.  
  445.             /* link new output in front of others */
  446.             tmp = inp->output;
  447.             inp->output = outp;
  448.             outp->next = tmp;
  449.  
  450.             argc--;argv++;
  451.             if (argc < 1) {
  452.                 exp_error(interp,"-output needs argument");
  453.                 return(TCL_ERROR);
  454.             }
  455.             /* accept Tcl file handles, too */
  456.             /* the following expression looks stupid but we */
  457.             /* really have to verify that at least four chars */
  458.             /* exist before we bop on over to the 5th one so */
  459.             /* we might as well verify them while we're at it */
  460.             if ((argv[0][0] == 'f') && (argv[0][1] == 'i')
  461.                 && (argv[0][2] == 'l') && (argv[0][3] == 'e')) {
  462.                 outp->spawn_id = atoi(*argv + 4);
  463.             } else     outp->spawn_id = atoi(*argv);
  464.             outp->action_eof = &action_eof;
  465.             action_eof_ptr = &outp->action_eof;
  466.             continue;
  467.         } else if (streq(*argv,"-u")) {    /* treat process as user */
  468.             argc--;argv++;
  469.             if (argc < 1) {
  470.                 exp_error(interp,"-u needs argument");
  471.                 return(TCL_ERROR);
  472.             }
  473.             replace_user_by_process = atoi(*argv);
  474.  
  475.             /* imply a "-input" */
  476.             if (dash_input_count == 0) dash_input_count = 1;
  477.  
  478.             continue;
  479.         } else if (streq(*argv,"-o")) {    /* apply following patterns */
  480.                         /* to opposite side of */
  481.                         /* interaction */
  482.             end_km = &input_default->keymap;
  483.  
  484.             /* imply two "-input" */
  485.             if (dash_input_count < 2) {
  486.                 dash_input_count = 2;
  487.                 inp = input_default;
  488.                 action_eof_ptr = &inp->action_eof;
  489.             }
  490.  
  491.             continue;
  492.         } else if (streq(*argv,"-i")) { /* substitute master */
  493.             argc--;argv++;
  494.             master = atoi(*argv);
  495.             /* will be used later on */
  496.  
  497.             /* imply two "-input" */
  498.             if (dash_input_count < 2) {
  499.                 dash_input_count = 2;
  500.                 inp = input_default;
  501.                 action_eof_ptr = &inp->action_eof;
  502.             }
  503.             continue;
  504. /*        } else if (streq(*argv,"-nocase")) {*/
  505. /*            next_case_sensitive = FALSE;*/
  506. /*            continue;*/
  507.         } else if (streq(*argv,"-re")) {
  508.             if (argc < 1) {
  509.                 exp_error(interp,"-re needs pattern");
  510.                 return(TCL_ERROR);
  511.             }
  512.             next_re = TRUE;
  513.             continue;
  514.         } else if (streq(*argv,"-echo")) {
  515.             next_echo = TRUE;
  516.             continue;
  517.         } else if (streq(*argv,"-flush")) {
  518.             next_writethru = TRUE;
  519.             continue;
  520.         } else if (streq(*argv,"-f")) {
  521.             if (argc < 1) {
  522.                 exp_error(interp,"-f needs pattern");
  523.                 return(TCL_ERROR);
  524.             }
  525.             next_fast = TRUE;
  526.             continue;
  527.         } else if (streq(*argv,"-F")) {
  528.             all_fast = TRUE;
  529.             continue;
  530.         } else if (streq(*argv,"-update")) {
  531.             next_update = TRUE;
  532.             continue;
  533.         } else if (streq(*argv,"-eof")) {
  534.             struct action *action;
  535.  
  536.             argc--;argv++;
  537.  
  538.             /* if -eof comes before "-input", then applies */
  539.             /* to all descriptors, else just the current one */
  540.             if (dash_input_count > 0 || dash_output_count > 0) {
  541.                 *action_eof_ptr = action =
  542.                     new_action(&action_base);
  543.                 if (!action) {
  544.                     exp_error(interp,"malloc failed: -action");
  545.                     return(TCL_ERROR);
  546.                 }
  547.             } else {
  548.                 action = &action_eof;
  549.             }
  550.             action->statement = *argv;
  551.             if (all_fast || next_fast) {
  552.                 action->fast = TRUE;
  553.                 next_fast = FALSE;
  554.             }
  555.             if (next_update) {
  556.                 action->update = TRUE;
  557.                 next_update = FALSE;
  558.             }
  559.             continue;
  560.         } else if (streq(*argv,"-timeout")) {
  561.             int t;
  562.             struct action *action;
  563.  
  564.             argc--;argv++;
  565.             if (argc < 1) {
  566.                 exp_error(interp,"-timeout needs time");
  567.                 return(TCL_ERROR);
  568.             }
  569.  
  570.             t = atoi(*argv);
  571.             argc--;argv++;
  572.             if (t != -1)
  573.                 arbitrary_timeout = t;
  574.             /* we need an arbitrary timeout to start */
  575.             /* search for lowest one later */
  576.  
  577.  
  578.             /* if -timeout comes before "-input", then applies */
  579.             /* to all descriptors, else just the current one */
  580.             if (dash_input_count > 0) {
  581.                 timeout_simple = FALSE;
  582.                 action = inp->action_timeout;
  583.                 inp->timeout_nominal = t;
  584.             } else {
  585.                 action = &action_timeout;
  586.                 default_timeout = t;
  587.             }
  588.             action->statement = *argv;
  589.             action->fast = (all_fast || next_fast);
  590.             next_fast = FALSE;
  591.             action->update = next_update;
  592.             next_update = FALSE;
  593.             continue;
  594.         }
  595.  
  596.         /*
  597.          * pick up the pattern
  598.          */
  599.  
  600.         km = new(struct keymap);
  601.         if (!km) {
  602.             exp_error(interp,"malloc failed (struct keymap)");
  603.             return(TCL_ERROR);
  604.         }
  605.  
  606.         /* so that we can match in order user specified */
  607.         /* link to end of keymap list */
  608.         *end_km = km;
  609.         km->next = 0;
  610.         end_km = &km->next;
  611.  
  612.         km->echo = next_echo;
  613.         km->writethru = next_writethru;
  614.         km->action.fast = (all_fast || next_fast);
  615.         km->action.update = next_update;
  616. /*        km->case_sensitive = next_case_sensitive;*/
  617.  
  618.         next_echo = next_writethru = next_fast = FALSE;
  619.         next_update = FALSE;
  620. /*        next_case_sensitive = TRUE;*/
  621.  
  622.         km->keys = *argv;
  623.  
  624.         if (next_re) {
  625.             if (0 == (km->re = regcomp(*argv))) {
  626.                 exp_error(interp,"bad regular expression: %s",
  627.                     tclRegexpError);
  628.                 return(TCL_ERROR);
  629.             }
  630.         } else {
  631.             km->re = 0;
  632.         }
  633.         argc--;argv++;
  634.  
  635.         km->action.statement = *argv;
  636.         debuglog("defining key %s, action %s\r\n",
  637.          km->keys,
  638.          km->action.statement?(dprintify(km->action.statement))
  639.                    :INTERPRETER_ACTION);
  640.  
  641.         /* imply a "-input" */
  642.         if (dash_input_count == 0) dash_input_count = 1;
  643.     }
  644.  
  645.     /* if the user has not supplied either "-output" for the */
  646.     /* default two "-input"s, fix them up here */
  647.  
  648.     if (!input_user->output) {
  649.         struct update *u;
  650.  
  651.         struct output *o = new_output(interp);
  652.  
  653.         if (!o) return(TCL_ERROR);
  654.         if (master == EXP_SPAWN_ID_BAD) {
  655.             if (0 == exp_update_master(interp,&master,1,1)) {
  656.                 return(TCL_ERROR);
  657.             }
  658.             spawn_id_referenced = TRUE;
  659.         }
  660.          o->spawn_id = master;
  661.         o->next = 0;    /* no one else */
  662.         o->action_eof = &action_eof;
  663.         input_user->output = o;
  664.  
  665.         if (spawn_id_referenced) {
  666.             u = new_update(&update_base,&input_user->output->spawn_id);
  667.             if (!u) {
  668.                 exp_error(interp,update_error_string);
  669.                 return(TCL_ERROR);
  670.             }
  671.         }
  672.     }
  673.  
  674.     if (!input_default->output) {
  675.         struct output *o = new_output(interp);
  676.  
  677.         if (!o) return(TCL_ERROR);
  678.          o->spawn_id = 1;    /* stdout by default */
  679.         o->next = 0;    /* no one else */
  680.         o->action_eof = &action_eof;
  681.         input_default->output = o;
  682.     }
  683.  
  684.     /* if user has given "-u" flag, substitute process for user */
  685.     /* in first two -inputs */
  686.     if (replace_user_by_process != EXP_SPAWN_ID_BAD) {
  687.         input_user->spawn_id =           replace_user_by_process;
  688.         input_default->output->spawn_id = replace_user_by_process;
  689.     }
  690.  
  691.     if (input_default->spawn_id == EXP_SPAWN_ID_BAD) {
  692.         struct update *u;
  693.  
  694.         if ((master == EXP_SPAWN_ID_BAD) || spawn_id_referenced) {
  695.             if (master == EXP_SPAWN_ID_BAD) {
  696.                 if (0 == exp_update_master(interp,&master,1,1)) {
  697.                     return(TCL_ERROR);
  698.                 }
  699.                 /* don't bother updating spawn_id_referenced */
  700.                 /* after this point since no longer used */
  701.             }
  702.             u = new_update(&update_base,&input_default->spawn_id);
  703.             if (!u) {
  704.                 exp_error(interp,update_error_string);
  705.                 return(TCL_ERROR);
  706.             }
  707.         }
  708.         input_default->spawn_id = master;
  709.     }
  710.  
  711.     if (input_user->spawn_id == input_default->spawn_id) {
  712.         exp_error(interp,"cannot interact with self - set spawn_id to a spawned process");
  713.         return(TCL_ERROR);
  714.     }
  715.  
  716.  
  717. /* if we are running this using /dev/tty */
  718. #define realtty(x)    ((x == 1) || (x == exp_dev_tty && exp_dev_tty != -1))
  719. #define REALTTY ((input_user->spawn_id == 0) || \
  720.          (input_user->spawn_id == exp_dev_tty && exp_dev_tty != -1))
  721.  
  722.     if (REALTTY) {
  723.         tty_changed = tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);
  724.     }
  725.  
  726.     /* build args for ready() */
  727.     fd_list = (int *)malloc(input_count * sizeof(int));
  728.  
  729.     fd_to_input = (struct input **)malloc((fd_max+1) * sizeof(struct input *));
  730.     /* at this point, we can now "goto done"; doing so earlier will */
  731.     /* screw up memory allocator */
  732.  
  733.     for (inp = input_base,i=0;inp;inp=inp->next,i++) {
  734.         /* validate all the input descriptors */
  735.         if (!(inp->f = exp_fd2f(interp,inp->spawn_id,1,1,"interact")))
  736.             finish(TCL_ERROR);
  737.  
  738.         /* build map to translate from spawn_id to struct input */
  739.         fd_to_input[inp->spawn_id] = inp;
  740.  
  741.         /* build input to ready() */
  742.         fd_list[i] = inp->spawn_id;
  743.  
  744.         /* start timers */
  745.         inp->timeout_remaining = inp->timeout_nominal;
  746.     }
  747.  
  748.     key = expect_key++;
  749.  
  750. #ifndef SIMPLE_EVENT
  751.     /* loop waiting (in event handler) for input */
  752.     for (;;) {
  753.         int te;    /* result of Tcl_Eval */
  754.         struct f *u;
  755.         int rc;    /* return code from ready.  This is further */
  756.             /* refined by matcher. */
  757.         int cc;    /* chars count from read() */
  758.         int m;    /* master */
  759.         struct action *action = 0;
  760.         time_t previous_time;
  761.         time_t current_time;
  762.         int match_length, skip;
  763.         int change;    /* if action requires cooked mode */
  764.         int attempt_match = TRUE;
  765.         struct input *soonest_input;
  766.         int print;        /* # of chars to print */
  767.         int oldprinted;        /* old version of u->printed */
  768.  
  769.         int timeout;    /* current as opposed to default_timeout */
  770.  
  771.         /* calculate how long to wait */
  772.         /* by finding shortest remaining timeout */
  773.         if (timeout_simple) {
  774.             timeout = default_timeout;
  775.         } else {
  776.             timeout = arbitrary_timeout;
  777.  
  778.             for (inp=input_base;inp;inp=inp->next) {
  779.                 if ((inp->timeout_remaining != EXP_TIME_INFINITY) &&
  780.                     (inp->timeout_remaining < timeout))
  781.                     soonest_input = inp;
  782.                     timeout = inp->timeout_remaining;
  783.             }
  784.  
  785.             time(&previous_time);
  786.             /* timestamp here rather than simply saving old */
  787.             /* current time (after ready()) to account for */
  788.             /* possibility of slow actions */
  789.  
  790.             /* timeout can actually be EXP_TIME_INFINITY here if user */
  791.             /* explicitly supplied it in a few cases (or */
  792.             /* the count-down code is broken) */
  793.         }
  794.  
  795.         rc = exp_get_next_event(interp,fd_list,input_count,&m,timeout,key);
  796.         if (rc == EXP_TCLERROR)
  797.             return(TCL_ERROR);
  798.  
  799.         if (rc == EXP_TIMEOUT) {
  800.             if (timeout_simple) {
  801.                 action = &action_timeout;
  802.                 goto got_action;
  803.             } else {
  804.                 action = soonest_input->action_timeout;
  805.             }
  806.         }
  807.         if (!timeout_simple) {
  808.             int time_diff;
  809.  
  810.             time(¤t_time);
  811.             time_diff = current_time - previous_time;
  812.  
  813.             /* update all timers */
  814.             for (inp=input_base;inp;inp=inp->next) {
  815.                 if (inp->timeout_remaining != EXP_TIME_INFINITY) {
  816.                     inp->timeout_remaining -= time_diff;
  817.                     if (inp->timeout_remaining < 0)
  818.                         inp->timeout_remaining = 0;
  819.                 }
  820.             }
  821.         }
  822.  
  823.         /* at this point, we have some kind of event which can be */
  824.         /* immediately processed - i.e. something that doesn't block */
  825.  
  826.         /* figure out who we are */
  827.         inp = fd_to_input[m];
  828.         u = inp->f;
  829.  
  830.         /* reset timer */
  831.         inp->timeout_remaining = inp->timeout_nominal;
  832.  
  833.         switch (rc) {
  834.         case EXP_DATA_NEW:
  835.             cc = read(m,    u->buffer + u->size,
  836.                     u->msize - u->size);
  837.             if (cc > 0) {
  838.                 fs[m].key = key;
  839.                 u->size += cc;
  840.                 u->buffer[u->size] = '\0';
  841.  
  842.                 /* strip parity if requested */
  843.                 if (u->parity == 0) {
  844.                     /* do it from end backwards */
  845.                     char *p = u->buffer + u->size - 1;
  846.                     int count = cc;
  847.                     while (count--) {
  848.                         *p-- &= 0x7f;
  849.                     }
  850.                 }
  851.  
  852.                 /* avoid another function call if possible */
  853.                 if (debugfile || is_debugging) {
  854.                     debuglog("spawn id %d sent {%s}\r\n",m,
  855.                         exp_printify(u->buffer + u->size - cc));
  856.                 }
  857.                 break;
  858.             }
  859.             /*FALLTHRU*/
  860.  
  861.             /* Most systems have read() return 0, allowing */
  862.             /* control to fall thru and into this code.  On some */
  863.             /* systems (currently HP and new SGI), read() does */
  864.             /* see eof, and it must be detected earlier.  Then */
  865.             /* control jumps directly to this EXP_EOF label. */
  866.         case EXP_EOF:
  867.             action = inp->action_eof;
  868.             attempt_match = FALSE;
  869.             skip = u->size;
  870.             rc = EXP_EOF;
  871.             debuglog("interact: received eof from spawn_id %d\r\n",m);
  872.             exp_close(interp,m);
  873.             break;
  874.         case EXP_DATA_OLD:
  875.             cc = 0;
  876.             break;
  877.         case EXP_TIMEOUT:
  878.             action = inp->action_timeout;
  879.             attempt_match = FALSE;
  880.             skip = u->size;
  881.             break;
  882.         }
  883.  
  884.         km = 0;
  885.  
  886.         if (attempt_match) {
  887.             rc = in_keymap(u->buffer,u->size,inp->keymap,
  888.                 &km,&match_length,&skip);
  889.         } else {
  890.             attempt_match = TRUE;
  891.         }
  892.  
  893.         /* put regexp result in variables */
  894.         if (km && km->re) {
  895. #define INTER_OUT "interact_out"
  896. #define out(i,val)  debuglog("expect: set %s(%s) {%s}\r\n",INTER_OUT,i, \
  897.                         dprintify(val)); \
  898.             if (!Tcl_SetVar2(interp,INTER_OUT,i,val,0)) \
  899.                 {status = TCL_ERROR; goto done;}
  900.  
  901.             char name[20], value[20];
  902.             regexp *re = km->re;
  903.             char match_char;/* place to hold char temporarily */
  904.                     /* uprooted by a NULL */
  905.  
  906.             for (i=0;i<NSUBEXP;i++) {
  907.                 int offset;
  908.  
  909.                 if (re->startp[i] == 0) break;
  910.  
  911.                 /* start index */
  912.                 sprintf(name,"%d,start",i);
  913.                 offset = re->startp[i]-u->buffer;
  914.                 sprintf(value,"%d",offset);
  915.                 out(name,value);
  916.  
  917.                 /* end index */
  918.                 sprintf(name,"%d,end",i);
  919.                 sprintf(value,"%d",re->endp[i]-u->buffer-1);
  920.                 out(name,value);
  921.  
  922.                 /* string itself */
  923.                 sprintf(name,"%d,string",i);
  924.                 /* temporarily null-terminate in */
  925.                 /* middle */
  926.                 match_char = *re->endp[i];
  927.                 *re->endp[i] = 0;
  928.                 out(name,re->startp[i]);
  929.                 *re->endp[i] = match_char;
  930.             }
  931.         }
  932.  
  933.         /* dispose of chars that should be skipped */
  934.         
  935.         /* skip is chars not involved in match */
  936.         /* print is with chars involved in match */
  937.  
  938.         if (km && km->writethru) {
  939.             print = skip + match_length;
  940.         } else print = skip;
  941.  
  942.         /* figure out if we should echo any chars */
  943.         if (km && km->echo) {
  944.             int seen;    /* either printed or echoed */
  945.  
  946.             /* echo to stdout rather than stdin */
  947.             if (m == 0) m = 1;
  948.  
  949.             /* write is unlikely to fail, since we just read */
  950.             /* from same descriptor */
  951.             seen = u->printed + u->echoed;
  952.             if (skip >= seen) {
  953.                 write(m,u->buffer+skip,match_length);
  954.             } else if ((match_length + skip - seen) > 0) {
  955.                 write(m,u->buffer+seen,match_length+skip-seen);
  956.             }
  957.             u->echoed = match_length + skip - u->printed;
  958.         }
  959.  
  960.         oldprinted = u->printed;
  961.  
  962.         /* If expect has left characters in buffer, it has */
  963.         /* already echoed them to the screen, thus we must */
  964.         /* prevent them being rewritten.  Unfortunately this */
  965.         /* gives the possibility of matching chars that have */
  966.         /* already been output, but we do so since the user */
  967.         /* could have avoided it by flushing the output */
  968.         /* buffers directly. */
  969.         if (print > u->printed) {    /* usual case */
  970.             int wc;    /* return code from write() */
  971.             for (outp = inp->output;outp;outp=outp->next) {
  972.  
  973.                 /* send to logfile if open */
  974.                 /* and user is seeing it */
  975.                 if (logfile && realtty(outp->spawn_id)) {
  976.                     fwrite(u->buffer+u->printed,1,
  977.                            print - u->printed,logfile);
  978.                 }
  979.  
  980.                 /* send to each output descriptor */
  981.                 wc = write(outp->spawn_id,u->buffer+u->printed,
  982.                     print - u->printed);
  983.                 if (wc <= 0) {
  984.                     debuglog("interact: write on spawn id %d failed (errno = %d)\r\n",outp->spawn_id,errno);
  985.                     action = outp->action_eof;
  986.                     change = !(action && action->fast);
  987.  
  988.                     if (change && tty_changed)
  989.                         tty_set(interp,&tty_old,was_raw,was_echo);
  990.                     te = inter_eval(interp,action,fd_to_input,fd_list,
  991.                         update_base,input_base);
  992.  
  993.                     if (change && REALTTY) tty_changed =
  994.                        tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);
  995.                     switch (te) {
  996.                     case TCL_BREAK:
  997.                     case TCL_CONTINUE:
  998.                         finish(te);
  999.                     case TCL_RETURN_TCL:
  1000.                         finish(TCL_RETURN);
  1001.                     case TCL_RETURN:
  1002.                         finish(TCL_OK);
  1003.                     case TCL_OK:
  1004.                         /* god knows what the user might */
  1005.                         /* have done to us in the way of */
  1006.                         /* closed fds, so .... */
  1007.                         action = 0;    /* reset action */
  1008.                         continue;
  1009.                     default:
  1010.                         finish(TCL_ERROR);
  1011.                     }
  1012.                 }
  1013.             }
  1014.             u->printed = print;
  1015.         }
  1016.  
  1017.         /* u->printed is now accurate with respect to the buffer */
  1018.         /* However, we're about to shift the old data out of the */
  1019.         /* buffer.  Thus, u->size, printed, and echoed must be */
  1020.         /* updated */
  1021.  
  1022.         /* first update size based on skip information */
  1023.         /* then set skip to the total amount skipped */
  1024.  
  1025.         if (rc == EXP_MATCH) {
  1026.             action = &km->action;
  1027.  
  1028.             skip += match_length;
  1029.             u->size -= skip;
  1030.  
  1031.             if (u->size)
  1032.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1033.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1034.         } else {
  1035.             if (skip) {
  1036.                 u->size -= skip;
  1037.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1038.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1039.             }
  1040.         }
  1041.  
  1042.         /* as long as buffer is still around, null terminate it */
  1043.         if (rc != EXP_EOF) {
  1044.             u->buffer[u->size] = '\0';
  1045.             u->lower [u->size] = '\0';
  1046.         }
  1047.         /* now update printed based on total amount skipped */
  1048.  
  1049.         u->printed -= skip;
  1050.         /* if more skipped than printed (i.e., keymap encountered) */
  1051.         /* for printed positive */
  1052.         if (u->printed < 0) u->printed = 0;
  1053.  
  1054.         /* if we are in the middle of a match, force the next event */
  1055.         /* to wait for more data to arrive */
  1056.         u->force_read = (rc == EXP_CANMATCH);
  1057.  
  1058.         /* finally reset echoed if necessary */
  1059.         if (rc != EXP_CANMATCH) {
  1060.             if (skip >= oldprinted + u->echoed) u->echoed = 0;
  1061.         }
  1062.  
  1063.         if (action) {
  1064. got_action:
  1065.             change = !(action && action->fast);
  1066.  
  1067.             if (change && tty_changed)
  1068.                 tty_set(interp,&tty_old,was_raw,was_echo);
  1069.  
  1070.             te = inter_eval(interp,action,fd_to_input,fd_list,
  1071.                         update_base,input_base);
  1072.  
  1073.             if (change && REALTTY) tty_changed =
  1074.                tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);
  1075.             switch (te) {
  1076.             case TCL_BREAK:
  1077.             case TCL_CONTINUE:
  1078.                 finish(te);
  1079.             case TCL_RETURN_TCL:
  1080.                 finish(TCL_RETURN);
  1081.             case TCL_RETURN:
  1082.                 finish(TCL_OK);
  1083.             case TCL_OK:
  1084.                 /* god knows what the user might */
  1085.                 /* have done to us in the way of */
  1086.                 /* closed fds, so .... */
  1087.                 action = 0;    /* reset action */
  1088.                 continue;
  1089.             default:
  1090.                 finish(TCL_ERROR);
  1091.             }
  1092.         }
  1093.     }
  1094.  
  1095. #else /* SIMPLE_EVENT */
  1096. /*    deferred_interrupt = FALSE;*/
  1097. {
  1098.         int te;    /* result of Tcl_Eval */
  1099.         struct f *u;
  1100.         int rc;    /* return code from ready.  This is further */
  1101.             /* refined by matcher. */
  1102.         int cc;    /* chars count from read() */
  1103.         int m;    /* master */
  1104.         struct action *action = 0;
  1105.         time_t previous_time;
  1106.         time_t current_time;
  1107.         int match_length, skip;
  1108.         int change;    /* if action requires cooked mode */
  1109.         int attempt_match = TRUE;
  1110.         struct input *soonest_input;
  1111.         int print;        /* # of chars to print */
  1112.         int oldprinted;        /* old version of u->printed */
  1113.  
  1114.         int timeout;    /* current as opposed to default_timeout */
  1115.  
  1116.     if (-1 == (pid = fork())) {
  1117.         exp_error("fork: %s",sys_errlist[errno]);
  1118.         finish(TCL_ERROR);
  1119.     }
  1120.     if (pid == 0) { /* child - send process output to user */
  1121.         exp_close(interp,0);
  1122.  
  1123.         m = fd_list[1];    /* get 2nd fd */
  1124.         input_count = 1;
  1125.  
  1126.         while (1) {
  1127.  
  1128.         /* calculate how long to wait */
  1129.         /* by finding shortest remaining timeout */
  1130.         if (timeout_simple) {
  1131.             timeout = default_timeout;
  1132.         } else {
  1133.             timeout = arbitrary_timeout;
  1134.  
  1135.             for (inp=input_base;inp;inp=inp->next) {
  1136.                 if ((inp->timeout_remaining != EXP_TIME_INFINITY) &&
  1137.                     (inp->timeout_remaining < timeout))
  1138.                     soonest_input = inp;
  1139.                     timeout = inp->timeout_remaining;
  1140.             }
  1141.  
  1142.             time(&previous_time);
  1143.             /* timestamp here rather than simply saving old */
  1144.             /* current time (after ready()) to account for */
  1145.             /* possibility of slow actions */
  1146.  
  1147.             /* timeout can actually be EXP_TIME_INFINITY here if user */
  1148.             /* explicitly supplied it in a few cases (or */
  1149.             /* the count-down code is broken) */
  1150.         }
  1151.  
  1152.         /* +1 so we can look at the "other" file descriptor */
  1153.         rc = exp_get_next_event(interp,fd_list+1,input_count,&m,timeout,key);
  1154.         if (!timeout_simple) {
  1155.             int time_diff;
  1156.  
  1157.             time(¤t_time);
  1158.             time_diff = current_time - previous_time;
  1159.  
  1160.             /* update all timers */
  1161.             for (inp=input_base;inp;inp=inp->next) {
  1162.                 if (inp->timeout_remaining != EXP_TIME_INFINITY) {
  1163.                     inp->timeout_remaining -= time_diff;
  1164.                     if (inp->timeout_remaining < 0)
  1165.                         inp->timeout_remaining = 0;
  1166.                 }
  1167.             }
  1168.         }
  1169.  
  1170.         /* at this point, we have some kind of event which can be */
  1171.         /* immediately processed - i.e. something that doesn't block */
  1172.  
  1173.         /* figure out who we are */
  1174.         inp = fd_to_input[m];
  1175.         u = inp->f;
  1176.  
  1177.         switch (rc) {
  1178.         case EXP_DATA_NEW:
  1179.             cc = read(m,    u->buffer + u->size,
  1180.                     u->msize - u->size);
  1181.             if (cc > 0) {
  1182.                 fs[m].key = key;
  1183.                 u->size += cc;
  1184.                 u->buffer[u->size] = '\0';
  1185.  
  1186.                 /* strip parity if requested */
  1187.                 if (u->parity == 0) {
  1188.                     /* do it from end backwards */
  1189.                     char *p = u->buffer + u->size - 1;
  1190.                     int count = cc;
  1191.                     while (count--) {
  1192.                         *p-- &= 0x7f;
  1193.                     }
  1194.                 }
  1195.  
  1196.                 /* avoid another function call if possible */
  1197.                 if (debugfile || is_debugging) {
  1198.                     debuglog("spawn id %d sent {%s}\r\n",m,
  1199.                         exp_printify(u->buffer + u->size - cc));
  1200.                 }
  1201.                 break;
  1202.             }
  1203.             /*FALLTHRU*/
  1204.  
  1205.             /* Most systems have read() return 0, allowing */
  1206.             /* control to fall thru and into this code.  On some */
  1207.             /* systems (currently HP and new SGI), read() does */
  1208.             /* see eof, and it must be detected earlier.  Then */
  1209.             /* control jumps directly to this EXP_EOF label. */
  1210.         case EXP_EOF:
  1211.             action = inp->action_eof;
  1212.             attempt_match = FALSE;
  1213.             skip = u->size;
  1214.             rc = EXP_EOF;
  1215.             debuglog("interact: child received eof from spawn_id %d\r\n",m);
  1216.             exp_close(interp,m);
  1217.             break;
  1218.         case EXP_DATA_OLD:
  1219.             cc = 0;
  1220.             break;
  1221.         }
  1222.  
  1223.         km = 0;
  1224.  
  1225.         if (attempt_match) {
  1226.             rc = in_keymap(u->buffer,u->size,inp->keymap,
  1227.                 &km,&match_length,&skip);
  1228.         } else {
  1229.             attempt_match = TRUE;
  1230.         }
  1231.  
  1232.         /* put regexp result in variables */
  1233.         if (km && km->re) {
  1234. #define INTER_OUT "interact_out"
  1235. #define out(i,val)  debuglog("expect: set %s(%s) {%s}\r\n",INTER_OUT,i, \
  1236.                         dprintify(val)); \
  1237.             if (!Tcl_SetVar2(interp,INTER_OUT,i,val,0)) \
  1238.                 {status = TCL_ERROR; goto done;}
  1239.  
  1240.             char name[20], value[20];
  1241.             regexp *re = km->re;
  1242.             char match_char;/* place to hold char temporarily */
  1243.                     /* uprooted by a NULL */
  1244.  
  1245.             for (i=0;i<NSUBEXP;i++) {
  1246.                 int offset;
  1247.  
  1248.                 if (re->startp[i] == 0) break;
  1249.  
  1250.                 /* start index */
  1251.                 sprintf(name,"%d,start",i);
  1252.                 offset = re->startp[i]-u->buffer;
  1253.                 sprintf(value,"%d",offset);
  1254.                 out(name,value);
  1255.  
  1256.                 /* end index */
  1257.                 sprintf(name,"%d,end",i);
  1258.                 sprintf(value,"%d",re->endp[i]-u->buffer-1);
  1259.                 out(name,value);
  1260.  
  1261.                 /* string itself */
  1262.                 sprintf(name,"%d,string",i);
  1263.                 /* temporarily null-terminate in */
  1264.                 /* middle */
  1265.                 match_char = *re->endp[i];
  1266.                 *re->endp[i] = 0;
  1267.                 out(name,re->startp[i]);
  1268.                 *re->endp[i] = match_char;
  1269.             }
  1270.         }
  1271.  
  1272.         /* dispose of chars that should be skipped */
  1273.         
  1274.         /* skip is chars not involved in match */
  1275.         /* print is with chars involved in match */
  1276.  
  1277.         if (km && km->writethru) {
  1278.             print = skip + match_length;
  1279.         } else print = skip;
  1280.  
  1281.         /* figure out if we should echo any chars */
  1282.         if (km && km->echo) {
  1283.             int seen;    /* either printed or echoed */
  1284.  
  1285.             /* echo to stdout rather than stdin */
  1286.             if (m == 0) m = 1;
  1287.  
  1288.             /* write is unlikely to fail, since we just read */
  1289.             /* from same descriptor */
  1290.             seen = u->printed + u->echoed;
  1291.             if (skip >= seen) {
  1292.                 write(m,u->buffer+skip,match_length);
  1293.             } else if ((match_length + skip - seen) > 0) {
  1294.                 write(m,u->buffer+seen,match_length+skip-seen);
  1295.             }
  1296.             u->echoed = match_length + skip - u->printed;
  1297.         }
  1298.  
  1299.         oldprinted = u->printed;
  1300.  
  1301.         /* If expect has left characters in buffer, it has */
  1302.         /* already echoed them to the screen, thus we must */
  1303.         /* prevent them being rewritten.  Unfortunately this */
  1304.         /* gives the possibility of matching chars that have */
  1305.         /* already been output, but we do so since the user */
  1306.         /* could have avoided it by flushing the output */
  1307.         /* buffers directly. */
  1308.  
  1309.         if (print > u->printed) {    /* usual case */
  1310.             int wc;    /* return code from write() */
  1311.             for (outp = inp->output;outp;outp=outp->next) {
  1312.  
  1313.                 /* send to logfile if open */
  1314.                 /* and user is seeing it */
  1315.                 if (logfile && realtty(outp->spawn_id)) {
  1316.                     fwrite(u->buffer+u->printed,1,
  1317.                            print - u->printed,logfile);
  1318.                 }
  1319.  
  1320.                 /* send to each output descriptor */
  1321.                 wc = write(outp->spawn_id,u->buffer+u->printed,
  1322.                     print - u->printed);
  1323.                 if (wc <= 0) {
  1324.                     debuglog("interact: write on spawn id %d failed (errno = %d)\r\n",outp->spawn_id,errno);
  1325.                     action = outp->action_eof;
  1326.  
  1327.                     te = inter_eval(interp,action,fd_to_input,fd_list,
  1328.                         update_base,input_base);
  1329.  
  1330.                     switch (te) {
  1331.                     case TCL_BREAK:
  1332.                     case TCL_CONTINUE:
  1333.                         finish(te);
  1334.                     case TCL_RETURN_TCL:
  1335.                         finish(TCL_RETURN);
  1336.                     case TCL_RETURN:
  1337.                         finish(TCL_OK);
  1338.                     case TCL_OK:
  1339.                         if (eof) finish(TCL_OK);
  1340.  
  1341.                         /* god knows what the user might */
  1342.                         /* have done to us in the way of */
  1343.                         /* closed fds, so .... */
  1344.                         action = 0;    /* reset action */
  1345.                         continue;
  1346.                     default:
  1347.                         finish(TCL_ERROR);
  1348.                     }
  1349.                 }
  1350.             }
  1351.             u->printed = print;
  1352.         }
  1353.  
  1354.         /* u->printed is now accurate with respect to the buffer */
  1355.         /* However, we're about to shift the old data out of the */
  1356.         /* buffer.  Thus, u->size, printed, and echoed must be */
  1357.         /* updated */
  1358.  
  1359.         /* first update size based on skip information */
  1360.         /* then set skip to the total amount skipped */
  1361.  
  1362.         if (rc == EXP_MATCH) {
  1363.             action = &km->action;
  1364.  
  1365.             skip += match_length;
  1366.             u->size -= skip;
  1367.  
  1368.             if (u->size)
  1369.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1370.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1371.         } else {
  1372.             if (skip) {
  1373.                 u->size -= skip;
  1374.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1375.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1376.             }
  1377.         }
  1378.  
  1379.         /* as long as buffer is still around, null terminate it */
  1380.         if (rc != EXP_EOF) {
  1381.             u->buffer[u->size] = '\0';
  1382.             u->lower [u->size] = '\0';
  1383.         }
  1384.         /* now update printed based on total amount skipped */
  1385.  
  1386.         u->printed -= skip;
  1387.         /* if more skipped than printed (i.e., keymap encountered) */
  1388.         /* for printed positive */
  1389.         if (u->printed < 0) u->printed = 0;
  1390.  
  1391.         /* if we are in the middle of a match, force the next event */
  1392.         /* to wait for more data to arrive */
  1393.         u->force_read = (rc == EXP_CANMATCH);
  1394.  
  1395.         /* finally reset echoed if necessary */
  1396.         if (rc != EXP_CANMATCH) {
  1397.             if (skip >= oldprinted + u->echoed) u->echoed = 0;
  1398.         }
  1399.  
  1400.         if (action) {
  1401. got_action_2:
  1402.             te = inter_eval(interp,action,fd_to_input,fd_list,
  1403.                         update_base,input_base);
  1404.             switch (te) {
  1405.             case TCL_BREAK:
  1406.             case TCL_CONTINUE:
  1407.                 finish(te);
  1408.             case TCL_RETURN_TCL:
  1409.                 finish(TCL_RETURN);
  1410.             case TCL_RETURN:
  1411.                 finish(TCL_OK);
  1412.             case TCL_OK:
  1413.                 if (eof) finish(TCL_OK);
  1414.  
  1415.                 /* god knows what the user might */
  1416.                 /* have done to us in the way of */
  1417.                 /* closed fds, so .... */
  1418.                 action = 0;    /* reset action */
  1419.                 continue;
  1420.             default:
  1421.                 finish(TCL_ERROR);
  1422.             }
  1423.         }
  1424.         }
  1425.     } else { /* parent - send user keystrokes to process */
  1426. #include <signal.h>
  1427.  
  1428.         debuglog("fork = %d\r\n",pid);
  1429. #ifdef SIGCHLD
  1430.         signal(SIGCHLD,sigchld_handler);
  1431. #else
  1432.         signal(SIGCLD,sigchld_handler);
  1433. #endif
  1434. /*    restart:*/
  1435. /*        tty_changed = tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);*/
  1436.  
  1437.         m = fd_list[0];    /* get 1st fd */
  1438.         input_count = 1;
  1439.  
  1440.         while (1) {
  1441.         /* calculate how long to wait */
  1442.         /* by finding shortest remaining timeout */
  1443.         if (timeout_simple) {
  1444.             timeout = default_timeout;
  1445.         } else {
  1446.             timeout = arbitrary_timeout;
  1447.  
  1448.             for (inp=input_base;inp;inp=inp->next) {
  1449.                 if ((inp->timeout_remaining != EXP_TIME_INFINITY) &&
  1450.                     (inp->timeout_remaining < timeout))
  1451.                     soonest_input = inp;
  1452.                     timeout = inp->timeout_remaining;
  1453.             }
  1454.  
  1455.             time(&previous_time);
  1456.             /* timestamp here rather than simply saving old */
  1457.             /* current time (after ready()) to account for */
  1458.             /* possibility of slow actions */
  1459.  
  1460.             /* timeout can actually be EXP_TIME_INFINITY here if user */
  1461.             /* explicitly supplied it in a few cases (or */
  1462.             /* the count-down code is broken) */
  1463.         }
  1464.  
  1465.         rc = exp_get_next_event(interp,fd_list,input_count,&m,timeout,key);
  1466.         if (!timeout_simple) {
  1467.             int time_diff;
  1468.  
  1469.             time(¤t_time);
  1470.             time_diff = current_time - previous_time;
  1471.  
  1472.             /* update all timers */
  1473.             for (inp=input_base;inp;inp=inp->next) {
  1474.                 if (inp->timeout_remaining != EXP_TIME_INFINITY) {
  1475.                     inp->timeout_remaining -= time_diff;
  1476.                     if (inp->timeout_remaining < 0)
  1477.                         inp->timeout_remaining = 0;
  1478.                 }
  1479.             }
  1480.         }
  1481.  
  1482.         /* at this point, we have some kind of event which can be */
  1483.         /* immediately processed - i.e. something that doesn't block */
  1484.  
  1485.         /* figure out who we are */
  1486.         inp = fd_to_input[m];
  1487.         u = inp->f;
  1488.  
  1489.         switch (rc) {
  1490.         case EXP_DATA_NEW:
  1491.             cc = i_read(m,    u->buffer + u->size,
  1492.                     u->msize - u->size);
  1493.             if (cc > 0) {
  1494.                 fs[m].key = key;
  1495.                 u->size += cc;
  1496.                 u->buffer[u->size] = '\0';
  1497.  
  1498.                 /* strip parity if requested */
  1499.                 if (u->parity == 0) {
  1500.                     /* do it from end backwards */
  1501.                     char *p = u->buffer + u->size - 1;
  1502.                     int count = cc;
  1503.                     while (count--) {
  1504.                         *p-- &= 0x7f;
  1505.                     }
  1506.                 }
  1507.  
  1508.                 /* avoid another function call if possible */
  1509.                 if (debugfile || is_debugging) {
  1510.                     debuglog("spawn id %d sent {%s}\r\n",m,
  1511.                         exp_printify(u->buffer + u->size - cc));
  1512.                 }
  1513.                 break;
  1514.             } else if (cc == EXP_CHILD_EOF) {
  1515.                 /* user could potentially have two outputs in which */
  1516.                 /* case we might be looking at the wrong one, but */
  1517.                 /* the likelihood of this is nil */
  1518.                 action = inp->output->action_eof;
  1519.                 attempt_match = FALSE;
  1520.                 skip = u->size;
  1521.                 rc = EXP_EOF;
  1522.                 debuglog("interact: process died/eof\r\n");
  1523.                 clean_up_after_child(interp,fd_list[1]);
  1524.                 break;
  1525.             }
  1526.             /*FALLTHRU*/
  1527.  
  1528.             /* Most systems have read() return 0, allowing */
  1529.             /* control to fall thru and into this code.  On some */
  1530.             /* systems (currently HP and new SGI), read() does */
  1531.             /* see eof, and it must be detected earlier.  Then */
  1532.             /* control jumps directly to this EXP_EOF label. */
  1533.         case EXP_EOF:
  1534.             action = inp->action_eof;
  1535.             attempt_match = FALSE;
  1536.             skip = u->size;
  1537.             rc = EXP_EOF;
  1538.             debuglog("user sent EOF or disappeared\n\n");
  1539.             break;
  1540.         case EXP_DATA_OLD:
  1541.             cc = 0;
  1542.             break;
  1543.         }
  1544.  
  1545.         km = 0;
  1546.  
  1547.         if (attempt_match) {
  1548.             rc = in_keymap(u->buffer,u->size,inp->keymap,
  1549.                 &km,&match_length,&skip);
  1550.         } else {
  1551.             attempt_match = TRUE;
  1552.         }
  1553.  
  1554.         /* put regexp result in variables */
  1555.         if (km && km->re) {
  1556. #define INTER_OUT "interact_out"
  1557. #define out(i,val)  debuglog("expect: set %s(%s) {%s}\r\n",INTER_OUT,i, \
  1558.                         dprintify(val)); \
  1559.             if (!Tcl_SetVar2(interp,INTER_OUT,i,val,0)) \
  1560.                 {status = TCL_ERROR; goto done;}
  1561.  
  1562.             char name[20], value[20];
  1563.             regexp *re = km->re;
  1564.             char match_char;/* place to hold char temporarily */
  1565.                     /* uprooted by a NULL */
  1566.  
  1567.             for (i=0;i<NSUBEXP;i++) {
  1568.                 int offset;
  1569.  
  1570.                 if (re->startp[i] == 0) break;
  1571.  
  1572.                 /* start index */
  1573.                 sprintf(name,"%d,start",i);
  1574.                 offset = re->startp[i]-u->buffer;
  1575.                 sprintf(value,"%d",offset);
  1576.                 out(name,value);
  1577.  
  1578.                 /* end index */
  1579.                 sprintf(name,"%d,end",i);
  1580.                 sprintf(value,"%d",re->endp[i]-u->buffer-1);
  1581.                 out(name,value);
  1582.  
  1583.                 /* string itself */
  1584.                 sprintf(name,"%d,string",i);
  1585.                 /* temporarily null-terminate in */
  1586.                 /* middle */
  1587.                 match_char = *re->endp[i];
  1588.                 *re->endp[i] = 0;
  1589.                 out(name,re->startp[i]);
  1590.                 *re->endp[i] = match_char;
  1591.             }
  1592.         }
  1593.  
  1594.         /* dispose of chars that should be skipped */
  1595.         
  1596.         /* skip is chars not involved in match */
  1597.         /* print is with chars involved in match */
  1598.  
  1599.         if (km && km->writethru) {
  1600.             print = skip + match_length;
  1601.         } else print = skip;
  1602.  
  1603.         /* figure out if we should echo any chars */
  1604.         if (km && km->echo) {
  1605.             int seen;    /* either printed or echoed */
  1606.  
  1607.             /* echo to stdout rather than stdin */
  1608.             if (m == 0) m = 1;
  1609.  
  1610.             /* write is unlikely to fail, since we just read */
  1611.             /* from same descriptor */
  1612.             seen = u->printed + u->echoed;
  1613.             if (skip >= seen) {
  1614.                 write(m,u->buffer+skip,match_length);
  1615.             } else if ((match_length + skip - seen) > 0) {
  1616.                 write(m,u->buffer+seen,match_length+skip-seen);
  1617.             }
  1618.             u->echoed = match_length + skip - u->printed;
  1619.         }
  1620.  
  1621.         oldprinted = u->printed;
  1622.  
  1623.         /* If expect has left characters in buffer, it has */
  1624.         /* already echoed them to the screen, thus we must */
  1625.         /* prevent them being rewritten.  Unfortunately this */
  1626.         /* gives the possibility of matching chars that have */
  1627.         /* already been output, but we do so since the user */
  1628.         /* could have avoided it by flushing the output */
  1629.         /* buffers directly. */
  1630.         if (print > u->printed) {    /* usual case */
  1631.             int wc;    /* return code from write() */
  1632.             for (outp = inp->output;outp;outp=outp->next) {
  1633.  
  1634.                 /* send to logfile if open */
  1635.                 /* and user is seeing it */
  1636.                 if (logfile && realtty(outp->spawn_id)) {
  1637.                     fwrite(u->buffer+u->printed,1,
  1638.                            print - u->printed,logfile);
  1639.                 }
  1640.  
  1641.                 /* send to each output descriptor */
  1642.                 wc = write(outp->spawn_id,u->buffer+u->printed,
  1643.                     print - u->printed);
  1644.                 if (wc <= 0) {
  1645.                     debuglog("interact: write on spawn id %d failed (errno = %d)\r\n",outp->spawn_id,errno);
  1646.                     clean_up_after_child(interp,outp->spawn_id);
  1647.  
  1648.                     action = outp->action_eof;
  1649.                     change = !(action && action->fast);
  1650.  
  1651.                     if (change && tty_changed)
  1652.                         tty_set(interp,&tty_old,was_raw,was_echo);
  1653.                     te = inter_eval(interp,action,fd_to_input,fd_list,
  1654.                         update_base,input_base);
  1655.  
  1656.                     if (change && REALTTY) tty_changed =
  1657.                        tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);
  1658.                     switch (te) {
  1659.                     case TCL_BREAK:
  1660.                     case TCL_CONTINUE:
  1661.                         finish(te);
  1662.                     case TCL_RETURN_TCL:
  1663.                         finish(TCL_RETURN);
  1664.                     case TCL_RETURN:
  1665.                         finish(TCL_OK);
  1666.                     case TCL_OK:
  1667.                         /* god knows what the user might */
  1668.                         /* have done to us in the way of */
  1669.                         /* closed fds, so .... */
  1670.                         action = 0;    /* reset action */
  1671.                         continue;
  1672.                     default:
  1673.                         finish(TCL_ERROR);
  1674.                     }
  1675.                 }
  1676.             }
  1677.             u->printed = print;
  1678.         }
  1679.  
  1680.         /* u->printed is now accurate with respect to the buffer */
  1681.         /* However, we're about to shift the old data out of the */
  1682.         /* buffer.  Thus, u->size, printed, and echoed must be */
  1683.         /* updated */
  1684.  
  1685.         /* first update size based on skip information */
  1686.         /* then set skip to the total amount skipped */
  1687.  
  1688.         if (rc == EXP_MATCH) {
  1689.             action = &km->action;
  1690.  
  1691.             skip += match_length;
  1692.             u->size -= skip;
  1693.  
  1694.             if (u->size)
  1695.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1696.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1697.         } else {
  1698.             if (skip) {
  1699.                 u->size -= skip;
  1700.                 memcpy(u->buffer, u->buffer + skip, u->size);
  1701.                 exp_lowmemcpy(u->lower,u->buffer+ skip, u->size);
  1702.             }
  1703.         }
  1704.  
  1705.         /* as long as buffer is still around, null terminate it */
  1706.         if (rc != EXP_EOF) {
  1707.             u->buffer[u->size] = '\0';
  1708.             u->lower [u->size] = '\0';
  1709.         }
  1710.         /* now update printed based on total amount skipped */
  1711.  
  1712.         u->printed -= skip;
  1713.         /* if more skipped than printed (i.e., keymap encountered) */
  1714.         /* for printed positive */
  1715.         if (u->printed < 0) u->printed = 0;
  1716.  
  1717.         /* if we are in the middle of a match, force the next event */
  1718.         /* to wait for more data to arrive */
  1719.         u->force_read = (rc == EXP_CANMATCH);
  1720.  
  1721.         /* finally reset echoed if necessary */
  1722.         if (rc != EXP_CANMATCH) {
  1723.             if (skip >= oldprinted + u->echoed) u->echoed = 0;
  1724.         }
  1725.  
  1726.         if (action) {
  1727. got_action_3:
  1728.             change = !(action && action->fast);
  1729.  
  1730.             if (change && tty_changed)
  1731.                 tty_set(interp,&tty_old,was_raw,was_echo);
  1732.  
  1733.             te = inter_eval(interp,action,fd_to_input,fd_list,
  1734.                         update_base,input_base);
  1735.  
  1736.             if (change && REALTTY) tty_changed =
  1737.                tty_raw_noecho(interp,&tty_old,&was_raw,&was_echo);
  1738.             switch (te) {
  1739.             case TCL_BREAK:
  1740.             case TCL_CONTINUE:
  1741.                 finish(te);
  1742.             case TCL_RETURN_TCL:
  1743.                 finish(TCL_RETURN);
  1744.             case TCL_RETURN:
  1745.                 finish(TCL_OK);
  1746.             case TCL_OK:
  1747.                 /* god knows what the user might */
  1748.                 /* have done to us in the way of */
  1749.                 /* closed fds, so .... */
  1750.                 action = 0;    /* reset action */
  1751.                 continue;
  1752.             default:
  1753.                 finish(TCL_ERROR);
  1754.             }
  1755.         }
  1756.         }
  1757.     }
  1758. }
  1759. #endif /* SIMPLE_EVENT */
  1760.  
  1761.  done:
  1762. #ifdef SIMPLE_EVENT
  1763.     /* force child to exit upon eof from master */
  1764.     if (pid == 0) {
  1765.         exit(SPAWNED_PROCESS_DIED);
  1766.     }
  1767. #endif /* SIMPLE_EVENT */
  1768.  
  1769.  
  1770.  
  1771.     if (tty_changed) tty_set(interp,&tty_old,was_raw,was_echo);
  1772.     if (oldargv) free((char *)argv);
  1773.     free((char *)fd_list);
  1774.     free((char *)fd_to_input);
  1775.     free_input(input_base);
  1776.     free_action(action_base);
  1777.     free_update(update_base);
  1778.  
  1779.     return(status);
  1780. }
  1781.  
  1782. /* version of Tcl_Eval for interact */ 
  1783. static int
  1784. inter_eval(interp,action,fd_to_input,fd_list,update,input_base)
  1785. Tcl_Interp *interp;
  1786. struct action *action;
  1787. struct input **fd_to_input;
  1788. int *fd_list;
  1789. struct update *update;
  1790. struct input *input_base;
  1791. {
  1792.     struct input *inp;
  1793.     int master;
  1794.     int te;
  1795.     int i;
  1796.  
  1797.     if (action->statement) {
  1798.         te = Tcl_Eval(interp,action->statement,0,(char **)0);
  1799.     } else {
  1800.         nflog("\r\n",1);
  1801.         te = exp_interpreter(interp);
  1802.     }
  1803.  
  1804.     /* don't validate if we're exiting anyway */
  1805.     if (te != TCL_OK) return(te);
  1806.  
  1807.     if (action->update) {
  1808.         if (0 == exp_update_master(interp,&master,1,0)) {
  1809.             return(TCL_ERROR);
  1810.         }
  1811.         for (;update;update = update->next) {
  1812.             *update->spawn_id = master;
  1813.         }
  1814.     }
  1815.     /* revalidate all input descriptors */
  1816.     for (inp = input_base,i=0;inp;inp=inp->next,i++) {
  1817.         /* have to "adjust", just in case spawn id hasn't had a */
  1818.         /* buffer sized yet */
  1819.  
  1820.         if (!(inp->f = exp_fd2f(interp,inp->spawn_id,1,1,"interact")))
  1821.             return(TCL_ERROR);
  1822.  
  1823.         /* build map to translate from spawn_id to struct input */
  1824.         fd_to_input[inp->spawn_id] = inp;
  1825.  
  1826.         /* build input to ready() */
  1827.         fd_list[i] = inp->spawn_id;
  1828.     }
  1829.  
  1830.     return te;
  1831. }
  1832.  
  1833. static void
  1834. free_keymap(km)
  1835. struct keymap *km;
  1836. {
  1837.     if (km == 0) return;
  1838.     free_keymap(km->next);
  1839.  
  1840.     free((char *)km);
  1841. }
  1842.  
  1843. static void
  1844. free_action(a)
  1845. struct action *a;
  1846. {
  1847.     struct action *next;
  1848.  
  1849.     while (a) {
  1850.         next = a->next;
  1851.         free((char *)a);
  1852.         a = next;
  1853.     }
  1854. }
  1855.  
  1856. static void
  1857. free_input(i)
  1858. struct input *i;
  1859. {
  1860.     if (i == 0) return;
  1861.     free_input(i->next);
  1862.  
  1863.     free_output(i->output);
  1864.     free_keymap(i->keymap);
  1865.     free((char *)i);
  1866. }
  1867.  
  1868. static struct action *
  1869. new_action(base)
  1870. struct action **base;
  1871. {
  1872.     struct action *o = new(struct action);
  1873.     if (!o) return 0;
  1874.  
  1875.     /* stick new action into beginning of list of all actions */
  1876.     o->next = *base;
  1877.     *base = o;
  1878.  
  1879.     return o;
  1880. }
  1881.  
  1882. static struct update *
  1883. new_update(base,fd_ptr)
  1884. struct update **base;
  1885. int *fd_ptr;
  1886. {
  1887.     struct update *u = new(struct update);
  1888.     if (!u) return 0;        
  1889.  
  1890.     /* stick new update into beginning of list of all updates */
  1891.     u->next = *base;
  1892.     *base = u;
  1893.  
  1894.     u->spawn_id = fd_ptr;
  1895.  
  1896.     return u;
  1897. }
  1898.  
  1899. static void
  1900. free_update(u)
  1901. struct update *u;
  1902. {
  1903.     struct update *next;
  1904.  
  1905.     while (u) {
  1906.         next = u->next;
  1907.         free((char *)u);
  1908.         u = next;
  1909.     }
  1910. }
  1911.  
  1912. static struct output *
  1913. new_output(interp)
  1914. Tcl_Interp *interp;
  1915. {
  1916.     struct output *o = new(struct output);
  1917.  
  1918.     if (!o) exp_error(interp,"malloc failed: -output");
  1919.     return o;
  1920. }
  1921.  
  1922. static struct input *
  1923. new_input(interp)
  1924. Tcl_Interp *interp;
  1925. {
  1926.     struct input *i = new(struct input);
  1927.     if (!i) exp_error(interp,"malloc failed: -input");
  1928.     return i;
  1929. }
  1930.  
  1931. static void
  1932. free_output(o)
  1933. struct output *o;
  1934. {
  1935.     if (o == 0) return;
  1936.     free_output(o->next);
  1937.  
  1938.     free((char *)o);
  1939. }
  1940.