home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume28 / yapp / part02 / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-29  |  12.9 KB  |  431 lines
  1. /* MISC.C */
  2. static    char sccsid[] = "@(#)misc.c 1.4 93/06/07 Copyright (c)1993 thalerd";
  3. #include <stdio.h>
  4. #include <sys/param.h>
  5. #include <time.h>
  6. #include <limits.h>
  7. #include <string.h>
  8. #ifndef NeXT
  9. #include <unistd.h>  /* for X_OK */
  10. #endif
  11. #include "config.h"
  12. #include "struct.h"
  13. #include "globals.h"
  14. #include "misc.h"
  15. #include "change.h"
  16. #include "help.h"
  17. #include "system.h"
  18. #include "macro.h"
  19. #include "range.h"
  20. #include "item.h"
  21. #include "sum.h"
  22. #include "sep.h"
  23. #include "files.h"
  24. #include "arch.h"
  25. #include "driver.h"  /* for open_pipe */
  26. #include "lib.h" /* for noquote() */
  27.  
  28. /* Misc. commands available at all modes */
  29. static dispatch_t misc_cmd[]={
  30.    "c_hange",   change,
  31.    "se_t",      change,
  32.    "?",         help,
  33.    "h_elp",     help,
  34.    "exp_lain",  help,
  35.    "al_ias",    define,
  36.    "def_ine",   define,
  37.    "una_lias",  define,
  38.    "und_efine", define,
  39.    "ec_ho",     echo,
  40.    "echoe",     echo,
  41.    "echon",     echo,
  42.    "echoen",    echo,
  43.    "echone",    echo,
  44.    "m_ail",     mail,
  45.    "t_ransmit", mail,
  46.    "sen_dmail", mail,
  47.    "d_isplay",  display,
  48.    "que_ry",    display,
  49.    "sh_ow",     display,
  50.    "t_est",     test,
  51.    "cd",        cd,
  52.    "chd_ir",    cd,
  53.    "uma_sk",    do_umask,
  54.    "cdate",     date,
  55.    "da_te",     date,
  56.    "clu_ster",  cluster, 
  57.    "cfdir",     set_cfdir,
  58.    "eval_uate", eval,
  59.    "source",    do_source,
  60. /* ex_it q_uit st_op good_bye log_off log_out h_elp exp_lain sy_stem unix al_ias
  61.  * def_ine una_lias und_efine ec_ho echoe echon echoen echone so_urce m_ail 
  62.  * t_ransmit sen_dmail chat write d_isplay que_ry p_articipants w_hoison 
  63.  * am_superuser resign chd_ir uma_sk sh_ell f_iles dir_ectory ty_pe e_dit 
  64.  * cdate da_te t_est clu_ster 
  65.  */
  66.    0, 0
  67. };
  68.  
  69. /******************************************************************************/
  70. /* DISPATCH CONTROL TO APPROPRIATE MISC. COMMAND FUNCTION                     */
  71. /******************************************************************************/
  72. char                         /* RETURNS: 0 to quit, 1 else */
  73. misc_cmd_dispatch(argc,argv) /* ARGUMENTS:                 */
  74. int    argc;                 /*    Number of arguments     */
  75. char **argv;                 /*    Argument list           */
  76. {
  77.    int i;
  78.  
  79.    for (i=0; misc_cmd[i].name; i++)
  80.       if (match(argv[0],misc_cmd[i].name))
  81.          return misc_cmd[i].func(argc,argv);
  82.  
  83.    /* Command dispatch */
  84.    if (match(argv[0],"q_uit")     
  85.     || match(argv[0],"st_op")
  86.     || match(argv[0],"ex_it")) {
  87.       status |= S_STOP;
  88.       return 0;
  89.    } else if (match(argv[0],"unix_cmd")) {
  90.       char buff[MAX_LINE_LENGTH],i;
  91.       if (argc<2) printf("syntax: unix_cmd \"command\"\n");
  92.       else {
  93.          /* implode(buff,argv," ",1); */
  94.          strcpy(buff,noquote(argv[1],0));
  95.          for (i=2; i<argc; i++) {
  96.             strcat(buff," ");
  97.             strcat(buff,noquote(argv[i],0));
  98.          }
  99. /* Undone at request of sno and jep
  100.          if (mode==M_SANE) printf("Conference rc cannot exec: %s\n",buff);
  101.          else              
  102. */
  103.          unix_cmd(buff);
  104.       }
  105.       /* if (argc==2) unix_cmd(argv[1]); */
  106.    } else if (argc) {
  107.       printf("Invalid command: %s\n",argv[0]);
  108.    }
  109.    return 1;
  110. }
  111.  
  112. /******************************************************************************/
  113. /* SET UMASK VALUE                                                            */
  114. /******************************************************************************/
  115. int                 /* RETURNS: (nothing)     */
  116. do_umask(argc,argv) /* ARGUMENTS:             */
  117. int    argc;        /*    Number of arguments */
  118. char **argv;        /*    Argument list       */
  119. {
  120.    int i;
  121.  
  122.    if (argc<2) {
  123.       umask(i=umask(0));
  124.       printf("%03o\n",i);
  125.    } else if (!isdigit(argv[1][0])) {
  126.       printf("UNK Bad umask \"%s\"specified (must be octal)\n",argv[1]);
  127.    } else {
  128.       sscanf(argv[1],"%o",&i);
  129.       umask(i);
  130.    }
  131.    return 1;
  132. }
  133.  
  134. /******************************************************************************/
  135. /* SEND MAIL TO ANOTHER USER                                                  */
  136. /******************************************************************************/
  137. int            /* RETURNS: (nothing)     */
  138. mail(argc,argv) /* ARGUMENTS:             */
  139. int    argc;    /*    Number of arguments */
  140. char **argv;    /*    Argument list       */
  141. {
  142.    char buff[MAX_LINE_LENGTH],buff2[MAX_LINE_LENGTH];
  143.  
  144.    if (argc<2) {
  145.       unix_cmd("mail");
  146.    } else if (flags & O_MAILTEXT) {
  147.       sprintf(buff,"mail %s",argv[1]);
  148.       unix_cmd(buff);
  149.    } else {
  150.       if (text_loop(0,1)) { /* dont clear buffer, for reply cmd */
  151.          strcpy(buff,argv[1]);
  152.          while (strlen(buff)) {
  153.             sprintf(buff2,"mail %s < %s/cf.buffer",buff,work);
  154.             unix_cmd(buff2);
  155.             printf("Mail sent to %s.\nMore recipients (or <return>)? ",buff);
  156.             ngets(buff, st_glob.inp);
  157.          }
  158.       }
  159.       sprintf(buff,"%s/cf.buffer",work);
  160.       rm(buff,SL_USER);
  161.    }
  162.    return 1;
  163. }
  164.  
  165. /******************************************************************************/
  166. /* CHANGE CURRENT WORKING DIRECTORY                                           */
  167. /******************************************************************************/
  168. int            /* RETURNS: (nothing)     */
  169. cd(argc,argv)  /* ARGUMENTS:             */
  170. int    argc;   /*    Number of arguments */
  171. char **argv;   /*    Argument list       */
  172. {
  173.    if (argc>2) {
  174.       printf("Bad parameters near \"%s\"\n",argv[2]);
  175.       return 2;
  176.    } else if (chdir((argc>1)?argv[1]:home))
  177.       error("cd'ing to ",argv[1]);
  178.    return 1;
  179. }
  180.  
  181. /******************************************************************************/
  182. /* ECHO ARGUMENTS TO OUTPUT                                                   */
  183. /******************************************************************************/
  184. int            /* RETURNS: (nothing)     */
  185. echo(argc,argv) /* ARGUMENTS:             */
  186. int    argc;    /*    Number of arguments */
  187. char **argv;    /*    Argument list       */
  188. {
  189.    short i;
  190.    FILE *fp;
  191.  
  192.    if (match(argv[0],"echoe") || match(argv[0],"echoen") 
  193.     || match(argv[0],"echone"))
  194.       fp = stderr;
  195.    else {
  196.       open_pipe();
  197.       fp = st_glob.outp;
  198.       if (!fp) fp = stdout;
  199.    }
  200.  
  201.    for (i=1; i<argc; i++) {
  202.       wfputs(argv[i],fp);
  203.       wfputc(' ',fp);
  204.    }
  205.    if (!strchr(argv[0],'n'))
  206.       wfputc('\n',fp);
  207.    return 1;
  208. }
  209.  
  210. /******************************************************************************/
  211. /* CHECK THE DATE                                                             */
  212. /******************************************************************************/
  213. int            /* RETURNS: (nothing)     */
  214. date(argc,argv) /* ARGUMENTS:             */
  215. int    argc;    /*    Number of arguments */
  216. char **argv;    /*    Argument list       */
  217. {
  218.    short i;
  219.    time_t t;
  220.  
  221.    i=0;
  222.    t = since(argc,argv,&i);
  223.    if (t<LONG_MAX) {
  224.       if (argv[0][0]=='c')
  225.          printf("%X\n",t); /* cdate command */
  226.       else
  227.          printf("\nDate is: %s\n",get_date(t,13));
  228.    }
  229.    return 1;
  230. }
  231.  
  232. /******************************************************************************/
  233. /* SOURCE A FILE OF COMMANDS                                                  */
  234. /******************************************************************************/
  235. int             /* RETURNS: (nothing)     */
  236. do_source(argc,argv) /* ARGUMENTS:             */
  237. int    argc;    /*    Number of arguments */
  238. char **argv;    /*    Argument list       */
  239. {
  240.    short i;
  241.    char  arg[10];
  242.  
  243.    if (argc<2) 
  244.       printf("usage: source filename [arg ...]\n");
  245.    else {
  246.       for (i=1; i<argc; i++) {
  247.          sprintf(arg,"arg%d",i-1);
  248.          def_macro(arg,DM_VAR,argv[i]);
  249.       }
  250.       
  251.       if (!source(argv[1],NIL))
  252.          printf("Cannot access %s\n",argv[1]);
  253.  
  254.       for (i=1; i<argc; i++) {
  255.          sprintf(arg,"arg%d",i-1);
  256.          undef_name(arg);
  257.       }
  258.    }
  259.    return 1;
  260. }
  261.  
  262. /******************************************************************************/
  263. /* TEST RANGES                                                                */
  264. /******************************************************************************/
  265. int             /* RETURNS: (nothing)     */
  266. test(argc,argv) /* ARGUMENTS:             */
  267. int    argc;    /*    Number of arguments */
  268. char **argv;    /*    Argument list       */
  269. {
  270.    int i;
  271.    char act[MAX_ITEMS];
  272.    short j,k=0,fl=0;
  273.  
  274.    rangeinit(&st_glob,act);
  275.    refresh_sum(0,confidx,sum,part,&st_glob);
  276.  
  277.    if (argc>1) /* Process argc */
  278.       range(argc,argv,&fl,act,sum,&st_glob,0);
  279.    if (!(fl & OF_RANGE)) {
  280.       printf("Error, no item specified! (try HELP RANGE)\n");
  281.       return 1;
  282.    }
  283.  
  284.    j = A_SKIP;
  285.    for (i=0; i<MAX_ITEMS; i++) {
  286.       if (act[i] == A_SKIP && j==A_COVER) printf("%d]",i);
  287.       if (act[i] == A_FORCE) printf("%s%d",(k++)?",":"",i+1);
  288.       if (act[i] == A_COVER && j!=A_COVER) printf("%s[%d-",(k++)?",":"",i+1);
  289.       j = act[i];
  290.    }
  291.    if (j==A_COVER) printf("%d]",i);
  292.    printf(".\n");
  293.    printf("newflag: %d\n",fl);
  294.    printf("since  date is %s",ctime(&(st_glob.since)));
  295.    printf("before date is %s",ctime(&(st_glob.before)));
  296.    if (st_glob.string[0]) printf("String is: %s\n",st_glob.string);
  297.    if (st_glob.author[0]) printf("Author is: %s\n",st_glob.author);
  298.  
  299.    return 1;
  300. }
  301.  
  302. int               /* RETURNS: (nothing)     */
  303. set_cfdir(argc,argv) /* ARGUMENTS:             */
  304. int    argc;      /*    Number of arguments */
  305. char **argv;      /*    Argument list       */
  306. {
  307.    char buff[MAX_LINE_LENGTH],cmd[MAX_LINE_LENGTH];
  308.  
  309.    printf("User name: ");
  310.    ngets(buff, st_glob.inp);
  311.    sprintf(cmd,"%s/%s",home,buff);
  312.    if (access(cmd,X_OK)) 
  313.       printf("No such directory.\n");
  314.    else
  315.       strcpy(work,cmd);
  316.    return 1;
  317. }
  318.  
  319. /* PROCESS A NEW SEP */
  320. int               /* RETURNS: (nothing)     */
  321. eval(argc,argv) /* ARGUMENTS:             */
  322. int    argc;      /*    Number of arguments */
  323. char **argv;      /*    Argument list       */
  324. {
  325.    int i;
  326.    char act[MAX_ITEMS],buff[MAX_LINE_LENGTH];
  327.    short      i_s,i_i, i_lastseen, shown=0, rfirst=0;
  328.    FILE      *fp;
  329.  
  330.    refresh_sum(0,confidx,sum,part,&st_glob);
  331.    for (i=0; i<MAX_ITEMS; i++) act[i]=0;
  332.    st_glob.string[0] ='\0';
  333.    st_glob.since     = st_glob.before = st_glob.r_first = 0;
  334.    st_glob.opt_flags = 0;
  335.  
  336.    if (argc>1) /* Process argc */
  337.       range(argc,argv,&st_glob.opt_flags,act,sum,&st_glob,0);
  338.    if (!st_glob.string[0]) {
  339.       printf("UNK usage: eval [range] \"string\"\n");
  340.       return 1;
  341.    } 
  342.  
  343.    open_pipe();
  344.    if (!(st_glob.opt_flags & OF_RANGE)) {
  345.  
  346.       if (mode==M_OK || mode==M_SANE || mode==M_SUPERSANE)
  347.          confsep(st_glob.string,confidx,&st_glob,part,0);
  348.       else if (mode==M_RFP)
  349.          itemsep(st_glob.string,0);
  350.       else
  351.          printf("UNK bad mode\n");
  352.  
  353.    } else {
  354.  
  355.       strcpy(buff,st_glob.string);
  356.  
  357.       if (mode==M_OK || mode==M_SANE || mode==M_SUPERSANE) {
  358.  
  359.          st_glob.string[0]='\0';
  360.          if (st_glob.opt_flags & OF_REVERSE) {
  361.             i_s = st_glob.i_last;
  362.             i_i = -1;
  363.          } else {
  364.             i_s = st_glob.i_first;
  365.             i_i = 1;
  366.          }
  367.  
  368.          /* Process items */
  369.          sepinit(IS_START); fp = NULL;
  370.          for (st_glob.i_current = i_s;
  371.                   st_glob.i_current >= st_glob.i_first
  372.                && st_glob.i_current <= st_glob.i_last
  373.                && !(status & S_INT);
  374.               st_glob.i_current += i_i) {
  375.             if (cover(st_glob.i_current,confidx,st_glob.opt_flags,
  376.              act[st_glob.i_current-1],sum, part, &st_glob)) {
  377.                st_glob.r_first = rfirst;
  378.                itemsep(buff,0);
  379.                shown++;
  380.             }
  381.          }
  382.          if (!shown && (st_glob.opt_flags & (OF_BRANDNEW|OF_NEWRESP)))
  383.             wputs("No new items matched.\n");
  384.  
  385.       } else if (mode==M_RFP) {
  386.          /* Open file */
  387.          sprintf(buff,"%s/_%d",conflist[confidx].location,st_glob.i_current);
  388.          if (!(fp=mopen(buff,O_R))) return 1;
  389.  
  390.          i_lastseen = st_glob.i_current-1;
  391.          if (st_glob.opt_flags & (OF_NEWRESP|OF_NORESPONSE))
  392.             st_glob.r_first = part[i_lastseen].nr;
  393.          else if (st_glob.since) {
  394.             st_glob.r_first=0;
  395.             while (st_glob.since > re[st_glob.r_first].date) {
  396.                st_glob.r_first++;
  397.                get_resp(fp,&(re[st_glob.r_first]),(short)GR_HEADER,st_glob.r_first);
  398.                if (st_glob.r_first>=sum[i_lastseen].nr) break;
  399.             }
  400.          }
  401.          st_glob.r_last = MAX_RESPONSES;
  402.          st_glob.r_max=sum[i_lastseen].nr-1;
  403.  
  404.          /* For each response */
  405.          for (st_glob.r_current = st_glob.r_first;
  406.               st_glob.r_current<= st_glob.r_last
  407.                && st_glob.r_current<=st_glob.r_max
  408.                && !(status & S_INT);
  409.               st_glob.r_current++) {
  410.             get_resp(fp,&(re[st_glob.r_current]),(short)GR_HEADER,st_glob.r_current);
  411.             itemsep(st_glob.string,0);
  412.          }
  413.  
  414.          mclose(fp);
  415.       } else
  416.          printf("UNK bad mode\n");
  417.    }
  418.    return 1;
  419. }
  420.  
  421. /* CHANGE CLUSTER */
  422. int               /* RETURNS: (nothing)     */
  423. cluster(argc,argv) /* ARGUMENTS:             */
  424. int    argc;      /*    Number of arguments */
  425. char **argv;      /*    Argument list       */
  426. {
  427.    leave(0,(char**)0);
  428.    open_cluster(argv[1],HELPDIR);
  429.    return 1;
  430. }
  431.