home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume28 / yapp / part04 / driver.c next >
Encoding:
C/C++ Source or Header  |  1994-05-29  |  24.5 KB  |  766 lines
  1. /* DRIVER.C */
  2. static    char sccsid[] = "@(#)driver.c 1.2 94/01/20 (c)1993 thalerd";
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <ctype.h>
  7. #ifndef NeXT
  8. #include <unistd.h>
  9. #endif
  10. #include <sys/types.h>
  11. #include <sys/file.h>
  12. #include <sys/stat.h>
  13. #include <signal.h>
  14. #include <pwd.h>
  15. #include "config.h"
  16. #include "struct.h"
  17. #include "driver.h"
  18. #include "xalloc.h"
  19. #include "lib.h"
  20. #include "macro.h"
  21. #include "joq.h"
  22. #include "rfp.h"
  23. #include "change.h"
  24. #include "item.h" /* needed by sep.h */
  25. #include "sep.h"
  26. #include "help.h"
  27. #include "conf.h"
  28. #include "system.h"
  29. #include "files.h"
  30. #include "sum.h"   /* for refresh_list */
  31. #include "edbuf.h" /* for text_cmd_dispatch */
  32. #include "misc.h"  /* for misc_cmd_dispatch */
  33.  
  34. /* GLOBAL VARS */
  35.  
  36. /* Status info */
  37. flag_t         flags =0;            /* user settable parameter flags */
  38. unsigned char  mode  =M_OK;         /* input mode (which prompt)     */
  39. flag_t         status=0;            /* system status flags           */
  40.  
  41. /* Conference info */
  42. short   current = -1;              /* current index to cflist       */
  43. short   confidx = -1;              /* current index to conflist     */
  44. short   defidx  = -1;
  45. short   joinidx = -1;              /* current index to conflist     */
  46. char    confname[MAX_LINE_LENGTH]; /* name of current conference    */
  47. char  **cflist = (char **)0;       /* User's conflist               */
  48. char  **fw;                        /* List of FW's for current conf */
  49. partentry_t part[MAX_ITEMS];       /* User participation info       */
  50.  
  51. /* System info */
  52. char    bbsdir[MAX_LINE_LENGTH];   /* Directory for bbs files       */
  53. char    helpdir[MAX_LINE_LENGTH];  /* Directory for help files      */
  54. assoc_t conflist[MAX_LIST_LENGTH]; /* System table of conferences   */
  55. short   maxconf=0;                 /* maximum index to conflist     */
  56. char    hostname[MAX_LINE_LENGTH]; /* System host name */
  57.  
  58. /* Info on the user */
  59. uid_t   uid;                       /* User's UID                    */
  60. char    login[L_cuserid];          /* User's login                  */
  61. char    home[MAX_LINE_LENGTH];     /* User's home directory         */
  62. char    work[MAX_LINE_LENGTH];     /* User's work directory         */
  63.  
  64. /* Item statistics */
  65. status_t   st_glob;                /* statistics on current conference */
  66. status_t   st_new;                 /* statistics on new conference to join */
  67. sumentry_t sum[MAX_ITEMS];         /* items in current conference      */
  68. response_t re[MAX_RESPONSES];      /* responses to current item        */
  69.  
  70. /* Variables global to this module only */
  71. static char cmdbuf[MAX_LINE_LENGTH];
  72.        char pipebuf[MAX_LINE_LENGTH];
  73.        char evalbuf[MAX_LINE_LENGTH];
  74. static char *options="dulosnj:";    /* Command-line options          */
  75. option_t option[]={                /* User-definable flags          */
  76. /*  name,       mask,        default, */
  77.    "debug",     O_DEBUG,     DEFAULT_OFF,
  78.    "buffer",    O_BUFFER,    DEFAULT_ON,
  79.    "default",   O_DEFAULT,   DEFAULT_ON,
  80.    "observe",   O_OBSERVE,   DEFAULT_OFF,
  81.    "st_rip",    O_STRIP,     DEFAULT_OFF,
  82.    "so_urce",   O_SOURCE,    DEFAULT_ON,
  83.    "f_orget",   O_FORGET,    DEFAULT_ON,
  84.    "sta_y",     O_STAY,      DEFAULT_OFF,
  85.    "dot",       O_DOT,       DEFAULT_ON,
  86.    "ed_always", O_EDALWAYS,  DEFAULT_OFF,
  87.    "me_too",    O_METOO,     DEFAULT_ON,
  88.    "nu_mbered", O_NUMBERED,  DEFAULT_OFF,
  89.    "d_ate",     O_DATE,      DEFAULT_OFF,
  90.    "u_id",      O_UID,       DEFAULT_OFF,
  91.    "ma_iltext", O_MAILTEXT,  DEFAULT_OFF,
  92.    "autosave",  O_AUTOSAVE,  DEFAULT_OFF,
  93.    "verbose",   O_VERBOSE,   DEFAULT_OFF,
  94.    "scr_ibbler",O_SCRIBBLER, DEFAULT_OFF,
  95.    "sig_niture",O_SIGNITURE, DEFAULT_OFF,
  96.    "readonly",  O_READONLY,  DEFAULT_OFF
  97. };
  98.  
  99. void
  100. open_pipe()
  101. {
  102.    char *pager,*p;
  103.  
  104.    /* Need to check if pager exists */
  105.    if (!(status & S_REDIRECT)) {
  106.       if (!pipebuf[0]) strcpy(pipebuf,expand("pager",DM_VAR));
  107.  
  108.       /* Compress it a bit */
  109.       pager=pipebuf;
  110.       while (*pager && *pager==' ') pager++; /* skip leading/trailing spaces */
  111.       for (p=pager+strlen(pager)-1; *p==' ' && p>=pager; p--) *p='\0'; 
  112.       if (*pager=='"') {
  113.          pager++;
  114.          if (p>=pager && *p=='"') { *p='\0'; p--; }
  115.       }
  116.       if (*pager=='\'') {
  117.          pager++;
  118.          if (p>=pager && *p=='\'') { *p='\0'; p--; }
  119.       }
  120.  
  121.       if (!(flags & O_BUFFER) 
  122.        || (pager[0] && (st_glob.outp =spopen(pager))==NULL))
  123.          pager[0]='\0';
  124.       if (!pager[0]) 
  125.          st_glob.outp =stdout;
  126.    }
  127. }
  128.  
  129. /******************************************************************************/
  130. /* PRINT PROMPT FOR AN INPUT MODE                                             */
  131. /******************************************************************************/
  132. void               /* RETURNS: (nothing) */
  133. print_prompt(mod)  /* ARGUMENTS:         */
  134. unsigned char mod; /*    Input mode      */
  135. { 
  136.    char *str;
  137.  
  138.    switch(mod & M_MASK) {
  139.    case M_OK :  /* In a conference or not? */
  140.                 str = (confidx<0) ? "noconfp" : "prompt";
  141.                 break;
  142.    case M_RFP:  str = (st_glob.c_status & (CS_OBSERVER|CS_NORESPONSE))?
  143.                  "obvprompt":"rfpprompt";
  144.                 break;
  145.    case M_TEXT: str="text";      break;
  146.    case M_JOQ:  str="joqprompt"; break;
  147.    case M_EDB:  str="edbprompt"; break;
  148.    }
  149.    if (flags & O_DEBUG) printf("!%s!\n",str);
  150.    confsep(str,confidx,&st_glob,part,1); /* expand seps & print */
  151. }
  152.  
  153. /******************************************************************************/
  154. /* COMMAND LOOP: PRINT PROMPT & GET RESPONSE                                  */
  155. /******************************************************************************/
  156. char             /* RETURNS: 0 on eof, 1 else   */
  157. get_command(def) /* ARGUMENTS:                  */
  158. char *def;       /*    Default command (if any) */
  159. {
  160.    char ok=1,inbuff[MAX_LINE_LENGTH],*inb;
  161.  
  162.    if (status & S_INT) status &= ~S_INT; /* Clear interrupt */
  163.    if (status & S_REDIRECT) spclose(st_glob.outp );
  164.    if (cmdbuf[0]) strcpy(inbuff,cmdbuf);
  165.    else {
  166.       print_prompt(mode);
  167.       if (mode==M_OK) status &= ~S_STOP;
  168.    }
  169.    if (cmdbuf[0] || (ok = (ngets(inbuff,st_glob.inp)!=NULL))) {
  170.  
  171.       /* Strip leading & trailing spaces */
  172.       for (inb=inbuff+strlen(inbuff)-1; inb>=inbuff && *inb==' '; inb--) *inb=0;
  173.       for (inb=inbuff; *inb==' '; inb++);
  174.  
  175.       if (!*inb) ok = command(def,0);
  176.       else       ok = command(inb,0);
  177.    }
  178.    return ok;
  179. }
  180.  
  181. /******************************************************************************/
  182. /* CLEAN UP MEMORY AND EXIT                                                   */
  183. /******************************************************************************/
  184. void        /* RETURNS: (nothing) */
  185. endbbs(ret) /* ARGUMENTS:         */
  186. int ret;    /*    Exit status     */
  187. {
  188.    int i;
  189.  
  190.    if (flags & O_DEBUG) printf("endbbs:\n");
  191.    if (confidx>=0) leave(0,(char**)0); /* leave current conference */
  192.  
  193.    /* Free up space, etc */
  194.    for (i=0; i<maxconf; i++) {
  195.       xfree(conflist[i].name);
  196.       xfree(conflist[i].location);
  197.    }
  198.    for (i=0; i<MAX_RESPONSES; i++) {
  199.       if (re[i].login)    { xfree(re[i].login);    re[i].login   =0; }
  200.       if (re[i].fullname) { xfree(re[i].fullname); re[i].fullname=0; }
  201. #ifdef NEWS
  202.       if (re[i].mid)      { xfree(re[i].mid);      re[i].mid     =0; }
  203. #endif
  204.    }
  205.     clear_cache();   /* throw out stat cache */
  206.    undefine(~0);    /* undefine all macros */
  207.    xfree(cflist);
  208.    mcheck();        /* verify that files are closed */
  209.    xcheck();        /* verify that memory is clean */
  210.    (void)exit(ret);
  211. }
  212.  
  213. void
  214. open_cluster(bdir,hdir)
  215. char *bdir, /*   BBSDIR  */
  216.      *hdir; /*   HELPDIR */
  217. {
  218.    short i;
  219.  
  220.    /* Free up space, etc */
  221.    for (i=0; i<maxconf; i++) {
  222.       xfree(conflist[i].name);
  223.       xfree(conflist[i].location);
  224.    }
  225.  
  226.    /* Read in /usr/bbs/conflist */
  227.    strcpy(bbsdir,bdir);
  228.    strcpy(helpdir,hdir);
  229.    if (!grab_list(bbsdir,"conflist",conflist,&maxconf)) 
  230.       endbbs(2);
  231.    for (i=1; i<maxconf; i++)
  232.       if (!strcmp(conflist[0].location,conflist[i].location)
  233.        ||   match(conflist[0].location,conflist[i].name)) defidx=i;
  234.    if (defidx<0) printf("Warning: bad default conference\n");
  235.  
  236.    /* Source system rc file */
  237.    mode = M_SUPERSANE;
  238.    source(bbsdir,"rc");
  239.    mode = M_OK;
  240. }
  241.  
  242. /******************************************************************************/
  243. /* PROCESS COMMAND LINE ARGUMENTS                                             */
  244. /******************************************************************************
  245. Function:    init
  246. Called by:   main
  247. Arguments:   
  248. Returns:    
  249. Calls:       source for .cfonce and system rc
  250.              grab_file to get .cflist and conflist
  251. Description: Sets up global variables, i.e. uid, login, envars,
  252.              workdir, processes rc file for system and for user
  253. ******************************************************************************/
  254. void            /* RETURNS: (nothing)                  */
  255. init(argc,argv) /* ARGUMENTS:                          */
  256. int    argc;    /*    Number of command-line arguments */
  257. char **argv;    /*    Command-line argument list       */
  258. {
  259.    short c,o,i;
  260.    struct passwd *pwd;
  261.    extern char *optarg;
  262.    extern int optind,opterr;
  263.    char **namestr,buff[MAX_LINE_LENGTH];
  264.    char mbox[MAX_LINE_LENGTH],*mail;
  265.    struct sigvec vec;
  266.  
  267.    /* Print identification */
  268.  
  269.    /* Start up interrupt handling *
  270.    for (c=1; c<=32; c++)
  271.       signal(c, handle_other);
  272.     * */
  273.    signal(SIGINT,  handle_int);
  274.    signal(SIGPIPE, handle_pipe);
  275.    /* *
  276.    signal(SIGINT,  handle_other);
  277.    signal(SIGPIPE, handle_other);
  278.     * */
  279.    sigvec(SIGINT,  NULL, &vec);
  280.    vec.sv_flags &= ~SV_INTERRUPT;
  281.    sigvec(SIGINT,  &vec, NULL);
  282.  
  283.    /* Initialize options */
  284.    for (o=0; o<sizeof(option)/sizeof(option_t); o++)
  285.       flags |= option[o].deflt * option[o].mask;
  286.  
  287.    /* Set up user variables */
  288.    cmdbuf[0] = pipebuf[0] = evalbuf[0] = '\0';
  289.    st_glob.c_status = 0;
  290. #ifdef NEWS
  291.     st_glob.c_article = 0;
  292. #endif
  293.    st_glob.inp = stdin;
  294.    uid = getuid();
  295.    if (!(pwd = getpwuid(uid))) {
  296.       error("reading ","user entry");
  297.       endbbs(2);
  298.    }
  299.    strcpy(login,   pwd->pw_name);
  300.    strcpy(st_glob.fullname,pwd->pw_gecos);
  301.    strcpy(home,    pwd->pw_dir);
  302.    if (access(home,X_OK)) {
  303.       error("accessing ",home);
  304.       endbbs(2);
  305.    }
  306.    sprintf(work,"%s/.cfdir",home);
  307.    if (access(work,X_OK)) strcpy(work,home);
  308.    strcpy(buff,work);
  309.    if (gethostname(hostname,MAX_LINE_LENGTH))
  310.       error("getting host name",NULL);
  311.  
  312.    /* Process command line options here */
  313.    if (!uid || uid==geteuid()) {
  314.       printf("login %s -- invoking bbs -%s\n",login,(uid)?"n":"no");
  315.       flags &= ~(O_SOURCE); /* for security */
  316.       if (!uid) 
  317.             flags |= O_OBSERVE|O_READONLY; 
  318.    }
  319.    confname[0]=0;
  320.    while ((c = getopt(argc, argv, options)) != -1) {
  321.       o = strchr(options,c)-options;
  322.       if (o>=0 && o<6) flags ^= (1<<o);
  323.       else if (c=='j') strcpy(confname,optarg);
  324.         if (c=='o')
  325.             flags ^= O_READONLY;  /* -o does observer AND readonly */
  326.    }
  327.    if (optind < argc) strcpy(confname,argv[argc-1]);
  328.  
  329.    /* Read in WORK/.cflist */
  330.    st_glob.listtime = 0;
  331.    refresh_list();
  332.    
  333.    for (i=0; i<MAX_RESPONSES; i++) {
  334.       re[i].fullname = re[i].login = NULL;
  335. #ifdef NEWS
  336.         re[i].mid = NULL;
  337.       re[i].article = 0;
  338. #endif
  339.    }
  340.  
  341.    /* Set up user customizations */
  342.    def_macro("today",DM_PARAM,"+0");
  343.    mail = getenv("MAIL");
  344.    if (!mail) {
  345.       sprintf(mbox,"%s/%s",MAILDIR,login);
  346.       mail = mbox;
  347.    }
  348.    def_macro("mailbox",DM_VAR,mail);
  349.    mail = getenv("SHELL");
  350.    if (mail) def_macro("shell",DM_VAR|DM_ENVAR,mail);
  351.    mail = getenv("EDITOR");
  352.    if (mail) def_macro("editor",DM_VAR|DM_ENVAR,mail);
  353.    mail = getenv("MESG");
  354.    if (mail) def_macro("mesg",DM_VAR|DM_ENVAR,mail);
  355.  
  356.    /* Read in /usr/bbs/conflist */
  357.    for (i=0; i<MAX_LIST_LENGTH; i++)
  358.       conflist[i].name = conflist[i].location = 0;
  359.    open_cluster(BBSDIR,HELPDIR);
  360.  
  361.    if (strcmp(work,buff)) { /* for cfdir command */
  362.       strcpy(buff,work);
  363.       refresh_list();
  364.    }
  365.  
  366.    /* Execute user's cfonce file */
  367.    source(work,".cfonce");
  368.    if (strcmp(work,buff))
  369.       source(work,".cfonce");
  370.  
  371.    /* Reset name */
  372.    namestr=explode(pwd->pw_gecos,expand("gecos",DM_VAR));
  373.    strcpy(st_glob.fullname,(xsizeof(namestr)>0)? namestr[0] : "Unknown");
  374.    xfree(namestr);
  375.  
  376.    /* Join initial conference */
  377.    if (flags & O_DEBUG)
  378.       printf("Default: %hd %s\n",defidx,conflist[defidx].name);
  379.    if (!(flags & O_DEFAULT) || defidx<0) {
  380.       current = -1;
  381.       st_glob.i_current = 0; /* No current item */
  382.    } else if (confname[0])
  383.       join(confname, 0);
  384.    else if (cflist && xsizeof(cflist))
  385.       join(cflist[current=0], 2); /* force join */
  386.    else {
  387.       join(compress(conflist[defidx].name), 2); /* force join */
  388.    }
  389. }
  390.  
  391. /******************************************************************************/
  392. /* PROCESS COMMAND LINE ARGUMENTS                                             */
  393. /******************************************************************************
  394. Function:    char source(char *dir, char *filename)
  395. Called by:   init
  396. Arguments:   File to source
  397. Returns:     
  398. Calls:       command for each statement
  399. Description: Executes commands in a file, does NOT grab_file since it
  400.              only needs 1-time sequential access.
  401. *******************************************************************************/
  402. char                 /* RETURNS: 0 on error, 1 else         */
  403. source(dir,filename) /* ARGUMENTS:                          */
  404. char *dir;           /*    Directory containing file        */
  405. char *filename;      /*    Filename of commands to execute  */
  406. {
  407.    FILE *fp;
  408.    char buff[MAX_LINE_LENGTH];
  409.  
  410.    if (filename)
  411.       sprintf(buff,"%s/%s",dir,filename);
  412.    else
  413.       strcpy(buff,dir);
  414.    if (flags & O_DEBUG) printf("source: %s\n",buff);
  415.    if ((fp=mopen(buff,O_R|O_SILENT))==NULL) return 0;
  416.    if (st_glob.inp != stdin) 
  417.       mclose(st_glob.inp);
  418.    st_glob.inp = stdin;
  419.    while (ngets(buff, fp)) {
  420.       if ((flags & O_VERBOSE) && mode==M_SANE)
  421.          printf("command: %s\n",buff);
  422.       st_glob.inp = fp;
  423.       command(buff,0);
  424.       st_glob.inp = stdin;
  425.    }
  426.    mclose(fp);
  427.    return 1;
  428. }
  429.             
  430. /******************************************************************************/
  431. /* PROCESS COMMAND LINE ARGUMENTS                                             */
  432. /******************************************************************************
  433. Function:    char command(char *command)
  434. Called by:   main
  435. Arguments:   command to process
  436. Returns:     0 if done, 1 else
  437. Calls:       join() for "join", "next" commands
  438.              leave() for "next", "quit" commands
  439. Description: For all command modes, this processes a user command.
  440.              Interrupts go back to here, without changing command mode.
  441. *******************************************************************************/
  442. char              /* RETURNS: Done flag                  */
  443. command(str,lvl)  /* ARGUMENTS:                          */
  444. char *str;        /*    Command to execute               */
  445. int   lvl;        /*    Recursion depth                  */
  446. {
  447.    int argc=0;    /*    Number of arguments */
  448.    unsigned short i;
  449.    char *argv[MAX_ARGS],cmddel,bufdel;
  450.    char *Sptr,*Eptr,state=1,ok;
  451.    char cmd[MAX_LINE_LENGTH],*cmd2;
  452.  
  453.    if (!str || !*str) return 1;
  454.    if (flags & O_DEBUG) printf("command: %s\n",str);
  455.    if (lvl > CMD_DEPTH) {
  456.       printf("UNK Too many expansions.\n");
  457.       return 0;
  458.    }
  459.  
  460.    /* Process shell escape */
  461.    if (str[0]=='!') {
  462. /* Undone at request of sno and jep
  463.       if (mode==M_SANE)
  464.          printf("Conference rc cannot exec: %s\n",str);
  465.       else {
  466. */
  467.          unix_cmd(str+1);
  468.          printf("!\n");
  469. /*    } */
  470.       return 1;
  471.  
  472.    /* And comments */
  473.    } else if (str[0]=='#') return 1;
  474.  
  475.    cmddel = expand("cmddel",DM_VAR)[0];
  476.    bufdel = expand("bufdel",DM_VAR)[0];
  477.  
  478.    /* Get arguments using a state machine for lexical analysis */
  479.    Sptr=str;
  480.    pipebuf[0]=cmdbuf[0]='\0';
  481.    while (state && argc<MAX_ARGS) {
  482.       switch(state) {
  483.       case 1: /* between words */
  484.               while (isspace(*Sptr)) Sptr++;
  485.               if      (*Sptr==cmddel)  { Sptr++;    state=0; }
  486.               else if (*Sptr==bufdel)  { Eptr= ++Sptr; state=6; }
  487.               else if (*Sptr=='|')  { Eptr= ++Sptr; state=7; }
  488.               else if (*Sptr=='>')  { Eptr=Sptr; state=9; }
  489.               else if (*Sptr=='\'') { Eptr= ++Sptr; state=4; }
  490.               else if (*Sptr=='`')  { Eptr= ++Sptr; state=8; }
  491. /*            else if (*Sptr=='\"') { Eptr= ++Sptr; state=3; } */
  492.               else if (*Sptr=='\"') { Eptr=Sptr; state=3; }
  493.               else if (*Sptr=='\\') { Eptr=Sptr; state=5; }
  494.               else if (*Sptr)       { Eptr=Sptr; state=2; }
  495.               else       state=0;
  496.               break;
  497.  
  498.       case 2: /* normal word */
  499.               while (*Eptr && !isspace(*Eptr)
  500.                && *Eptr!=cmddel && *Eptr!=bufdel 
  501.                && !strchr("|`'>\\\"",*Eptr)
  502.                && !(Eptr>Sptr && *(Eptr-1)=='=') /* '=' terminates word */
  503.                && (argc || *Sptr=='-' || isdigit(*Sptr) || !isdigit(*Eptr)))
  504.                  Eptr++;
  505.  
  506.               argv[argc]=(char*)xalloc(0,Eptr-Sptr+1);
  507.               strncpy(argv[argc],Sptr,Eptr-Sptr);
  508.               argv[argc++][Eptr-Sptr]=0;
  509.               Sptr = Eptr;
  510.  
  511.               if (argc==1) {
  512.                  cmd2=(char *)expand(argv[0],((mode & M_MASK)==M_RFP)? DM_RFP : DM_OK);
  513.                  if (cmd2) {
  514.                     sprintf(cmd,"%s%s",cmd2,Eptr);
  515.                     xfree(argv[argc=0]);
  516.                     Sptr = cmd;
  517.                  }
  518.               }
  519.  
  520.               state=1;
  521.               break;
  522.  
  523.       case 3: /* "stuff" */
  524.               do { 
  525.                  Eptr++; 
  526.               } while (*Eptr && (*Eptr!='\"' || *(Eptr-1)=='\\'));
  527. /*            argv[argc]=xalloc(0,Eptr-Sptr+1); */
  528.               argv[argc]=(char*)xalloc(0,Eptr-Sptr+2);
  529. /*            strncpy(argv[argc],Sptr,Eptr-Sptr); */
  530.               strncpy(argv[argc],Sptr,Eptr-Sptr+1);
  531. /*            argv[argc++][Eptr-Sptr]=0; */
  532.               argv[argc++][Eptr-Sptr+1]=0;
  533.  
  534.               if (*Eptr) Eptr++;
  535.               Sptr = Eptr;
  536.               state=1;
  537.               break;
  538.  
  539.       case 4: /* 'stuff' */
  540.               do { Eptr++; } while (*Eptr && *Eptr!='\'');
  541.               argv[argc]=(char*)xalloc(0,Eptr-Sptr+1);
  542.               strncpy(argv[argc],Sptr,Eptr-Sptr);
  543.               argv[argc++][Eptr-Sptr]=0;
  544.  
  545.               if (*Eptr) Eptr++;
  546.               Sptr = Eptr;
  547.               state=1;
  548.               break;
  549.  
  550.       case 5: /* \\ */
  551.               argv[argc]=(char*)xalloc(0,2);
  552.               strcpy(argv[argc++],"\\");
  553.               Sptr = Eptr+1;
  554.               state=1;
  555.               break;
  556.  
  557.       case 6: /* ,stuff */
  558.               do { Eptr++; } while (*Eptr && *Eptr!=cmddel);
  559.               strncpy(cmdbuf,Sptr,Eptr-Sptr);
  560.               cmdbuf[Eptr-Sptr]=0;
  561.               Sptr = Eptr;
  562.               state=1;
  563.               break;
  564.  
  565.       case 7: /* | stuff */
  566.               do { Eptr++; } while (*Eptr && *Eptr!=cmddel && *Eptr!=bufdel);
  567.               strncpy(pipebuf,Sptr,Eptr-Sptr);
  568.               pipebuf[Eptr-Sptr]=0;
  569.               Sptr = Eptr;
  570.               state=1;
  571.               break;
  572.  
  573.       case 8: /* `command` */
  574.               do { Eptr++; } while (*Eptr && *Eptr!='`');
  575.               strncpy(cmd,Sptr,Eptr-Sptr);
  576.               cmd[Eptr-Sptr]=0;
  577.  
  578.               status |=  S_EXECUTE;
  579.               evalbuf[0] = '\0';
  580.               command(cmd,lvl+1);
  581.               status &= ~S_EXECUTE;
  582.               argv[argc]=(char*)xalloc(0,strlen(evalbuf)+1);
  583.               strcpy(argv[argc++],evalbuf);
  584.  
  585.               if (*Eptr) Eptr++;
  586.               Sptr = Eptr;
  587.               state=1;
  588.               break;
  589.  
  590.       case 9: /* > file */
  591.               do { Eptr++; } while (*Eptr=='>');
  592.               do { Eptr++; } while (isspace(*Eptr));
  593.               do { 
  594.                  Eptr++; 
  595.               } while (*Eptr && *Eptr!=cmddel && *Eptr!=bufdel && *Eptr!=' ');
  596.               strcpy(pipebuf,"cat ");
  597.               strncat(pipebuf,Sptr,Eptr-Sptr);
  598.               pipebuf[4+Eptr-Sptr]=0;
  599.               Sptr = Eptr;
  600.               state=1;
  601.               break;
  602.       }
  603.    }
  604. /*
  605.    if (*Sptr) strcpy(cmdbuf,Sptr);
  606.    else       cmdbuf[0]='\0';
  607. */
  608.    if (argc) {
  609.    
  610.       /* Expand macros */
  611. #if 0
  612. /*
  613.       cmd2=(char *)expand(argv[0],((mode & M_MASK)==M_RFP)? DM_RFP : DM_OK);
  614. */
  615.       cmd2=0;
  616.       if (cmd2) {
  617.          xfree(argv[0]);
  618.          strcpy(cmd,cmd2);
  619. /* implode(cmd+strlen(cmd),argv," ",1); argv isn't malloc'ed */
  620.          for (i=1; i<argc; i++) {
  621.             strcat(cmd," ");
  622.             strcat(cmd,argv[i]);
  623.             xfree(argv[i]);
  624.          }
  625.          ok = command(cmd,lvl+1);
  626.       } else 
  627. #endif
  628.       {
  629.       
  630.          /* Execute command */
  631.          switch(mode & M_MASK) {
  632.          case M_OK:   ok=  ok_cmd_dispatch(argc,argv); break;
  633.          case M_JOQ:  ok= joq_cmd_dispatch(argc,argv); break;
  634.          case M_TEXT: ok=text_cmd_dispatch(argc,argv); break;
  635.          case M_RFP:  ok= rfp_cmd_dispatch(argc,argv); break;
  636.          case M_EDB:  ok= edb_cmd_dispatch(argc,argv); break;
  637.          default: printf("Unknown mode %d\n",mode); break;
  638.          }
  639.    
  640.          /* Free args */
  641.          for (i=0; i<argc; i++) xfree(argv[i]);
  642.       }
  643.    } else
  644.       ok=1; /* don't abort on null command */
  645.  
  646.    /* Do next ; cmd unless EOF or command says to halt (ok==2) */
  647.    if (ok==1 && *Sptr && !(status & S_STOP)) {
  648.       ok=command(Sptr,lvl+1); 
  649.    } 
  650. /* else if (*Sptr) status &= ~S_STOP; */
  651.    return ok;
  652. }
  653.  
  654. /* Commands available at the Ok: prompt only */
  655. static dispatch_t ok_cmd[]={
  656.    "i_tem",     do_read,
  657.    "r_ead",     do_read,
  658.    "pr_int",    do_read,
  659.    "e_nter",    enter,
  660.    "s_can",     do_read,
  661.    "b_rowse",   do_read,
  662.    /* j_oin */
  663.    "le_ave",    leave,
  664.    "n_ext",     do_next,
  665.    "che_ck",    check,
  666.    "rem_ember", remember,
  667.    "forget",    forget,
  668.    "unfor_get", remember,
  669.    "k_ill",     do_kill,
  670.    "freeze",    freeze,
  671.    "thaw",      freeze,
  672.    /* sync_hronous */
  673.    /* async_hronous */
  674.    "retire",    freeze,
  675.    "unretire",  freeze,
  676.    "f_ind",     do_find,
  677.    "l_ocate",   do_find,
  678.    "seen",      fixseen,
  679.    "fix_seen",  fixseen,
  680.    "re_spond",  respond,
  681.    /* lpr_int */
  682.    "li_nkfrom", linkfrom,
  683.    "abort",     leave,
  684. /* ex_it q_uit st_op good_bye log_off log_out h_elp exp_lain sy_stem unix al_ias
  685.  * def_ine una_lias und_efine ec_ho echoe echon echoen echone so_urce m_ail 
  686.  * t_ransmit sen_dmail chat write d_isplay que_ry */
  687.    "p_articipants", participants,
  688. /* w_hoison am_superuser */
  689.    "resign",    resign,
  690. /* chd_ir uma_sk sh_ell f_iles dir_ectory ty_pe e_dit cdate da_te t_est 
  691.  * clu_ster 
  692.  */
  693.    "ps_eudonym",respond,
  694.    "list",      check,
  695.    0, 0
  696. };
  697.  
  698. /******************************************************************************/
  699. /* DISPATCH CONTROL TO APPROPRIATE MISC. COMMAND FUNCTION                     */
  700. /******************************************************************************/
  701. char                       /* RETURNS: 0 to quit, 1 else */
  702. ok_cmd_dispatch(argc,argv) /* ARGUMENTS:                 */
  703. int    argc;               /*    Number of arguments     */
  704. char **argv;               /*    Argument list           */
  705. {
  706.    int i;
  707.  
  708.    for (i=0; ok_cmd[i].name; i++)
  709.       if (match(argv[0],ok_cmd[i].name))
  710.          return ok_cmd[i].func(argc,argv);
  711.  
  712.    /* Command dispatch */
  713.    if (match(argv[0],"j_oin"))    {
  714.       if (argc==2) join(argv[1],0); 
  715.       else if (confidx>=0) {
  716.          confsep("joinmsg",confidx,&st_glob,part,0); 
  717.       } else 
  718.          printf("Not in a conference!\n");
  719.    } else return misc_cmd_dispatch(argc,argv);
  720.    return 1;
  721. }
  722.  
  723. /******************************************************************************/
  724. /* PROCESS A GENERIC SIGNAL (if enabled)                                      */
  725. /******************************************************************************/
  726. void 
  727. handle_other(sig, code, scp, addr)
  728. int sig, code;
  729. /* struct sigcontext */ void *scp;
  730. char *addr;
  731. {
  732.    if (status & S_PIPE) printf("%d Pipe interrupt %d!\n",getpid(),sig);
  733.    else printf("%d Interrupt %d!\n",getpid(),sig);
  734.    status |= S_INT;
  735. }
  736.  
  737. /******************************************************************************/
  738. /* PROCESS A USER INTERRUPT SIGNAL                                            */
  739. /******************************************************************************/
  740. void         /* RETURNS: (nothing) */
  741. handle_int() /* ARGUMENTS: (none)  */
  742. {
  743.    struct sigvec vec;
  744.  
  745.    if (!(status & S_PIPE)) {
  746.       printf("Interrupt!\n");
  747.       status |= S_INT;
  748.    }
  749.    signal(SIGINT,  handle_int);
  750.    sigvec(SIGINT,  NULL, &vec);
  751.    vec.sv_flags |= SV_INTERRUPT;
  752.    sigvec(SIGINT,  &vec, NULL);
  753. }
  754.  
  755. /******************************************************************************/
  756. /* PROCESS AN INTERRUPT CAUSED BY A PIPE ABORTING                             */
  757. /******************************************************************************/
  758. void          /* RETURNS: (nothing) */
  759. handle_pipe() /* ARGUMENTS: (none)  */
  760. {
  761.    printf("Pipe interrupt?\n");
  762.    /* spclose(st_glob.outp );*/
  763.    signal(SIGPIPE, handle_pipe);
  764.    status |= S_INT;
  765. }
  766.