home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / tass.lzh / misc.c < prev    next >
Text File  |  1993-01-24  |  11KB  |  535 lines
  1.  
  2. #include       <stdio.h>
  3. #include       <signal.h>
  4. #include       <pwd.h>
  5. #ifndef                OSK
  6. #include       <sys/types.h>
  7. #include       <sys/stat.h>
  8. #else          /* OSK */
  9. #include       <types.h>
  10. #include       <stat.h>
  11. #endif         /* OSK */
  12. #include       "tass.h"
  13.  
  14. extern char *rindex ();
  15.  
  16. char active_file[LEN];
  17. #ifdef OSK
  18. char spooldir[LEN];
  19. #endif /* OSK */
  20. char homedir[LEN];
  21. char userid[LEN];
  22. char delgroups[LEN];
  23. char newsrc[LEN];
  24. char newnewsrc[LEN];
  25. char indexdir[LEN];
  26. char my_org[LEN];              /* organization */
  27. #ifdef INCSTR
  28. char *incstr;
  29. #endif /* INCSTR */
  30.  
  31. /*
  32.  *  Which base note (an index into base[]) does a respnum
  33.  *  (an index into arts[]) corresponsd to?
  34.  *
  35.  *  In other words, base[] points to an entry in arts[] which is
  36.  *  the head of a thread, linked with arts[].thread.  For any q: arts[q],
  37.  *  find i such that base[i]->arts[n]->arts[o]->...->arts[q]
  38.  */
  39.  
  40. which_base(n)
  41. int n;
  42. {
  43.        int i, j;
  44.  
  45.        for (i = 0; i < top_base; i++)
  46.                for (j = base[i]; j >= 0; j = arts[j].thread)
  47.                        if (j == n)
  48.                                return i;
  49.  
  50.        fprintf(stderr, "can't find base article\n");
  51.        return 0;
  52. }
  53.  
  54.  
  55. /*
  56.  *  Find how deep in a thread a response is.  Start counting at zero
  57.  */
  58.  
  59. which_resp(n)
  60. int n;
  61. {
  62.        int i, j;
  63.        int num = 0;
  64.  
  65.        i = which_base(n);
  66.  
  67.        for (j = base[i]; j != -1; j = arts[j].thread)
  68.                if (j == n)
  69.                        break;
  70.                else
  71.                        num++;
  72.  
  73.        return num;
  74. }
  75.  
  76.  
  77. /*
  78.  *  Given an index into base[], find the number of responses for
  79.  *  that basenote
  80.  */
  81.  
  82. nresp(n)
  83. int n;
  84. {
  85.        int i;
  86.        int oldi = -3;
  87.        int sum = 0;
  88.  
  89.        assert(n < top_base);
  90.  
  91.        for (i = base[n]; i != -1; i = arts[i].thread) {
  92.                assert(i != -2);
  93.                assert(i != oldi);
  94.                oldi = i;
  95.                sum++;
  96.        }
  97.  
  98.        return sum - 1;
  99. }
  100.  
  101.  
  102. asfail(file, line, cond)
  103. char   *file;
  104. int    line;
  105. char   *cond;
  106. {
  107.        fprintf(stderr, "tass: assertion failure: %s (%d): %s\n",
  108.                                                        file, line, cond);
  109.        exit(1);
  110. }
  111.  
  112.  
  113. /*
  114.  *  Make regular expressions pleasant for the masses:  glob them
  115.  */
  116.  
  117. glob_name(group, grp)
  118. char *group;
  119. char *grp;
  120. {
  121. char *p, *q;
  122.  
  123. /*
  124.  *  Prefix the .'s in the group name so they won't be interpreted
  125.  *  as regular expression commands.  Change 'all' into '*'
  126.  */
  127.  
  128.        p = group;
  129.        q = grp;
  130.  
  131.        if (strncmp(p, "all", 3) == 0 && (p[3] == '.' || p[3] == '\0')) {
  132.                *q++ = '.';
  133.                *q++ = '*';
  134.                p = &p[3];
  135.        }
  136.        while (*p != '\0') {
  137.                if (*p == '.') {
  138.                        *q++ = '\\';
  139.                        *q++ = '.';
  140.                        p++;
  141.  
  142.                        if (strncmp(p, "all", 3) == 0 &&
  143.                                (p[3] == '.' || p[3] == '\0')) {
  144.                                        *q++ = '.';
  145.                                        *q++ = '*';
  146.                                        p = &p[3];
  147.                                }
  148.                } else if (*p == '*') {
  149.                        *q++ = '.';
  150.                        *q++ = '*';
  151.                        p++;
  152.                } else
  153.                        *q++ = *p++;
  154.        }
  155.        *q = '\0';
  156. }
  157.  
  158.  
  159. /*
  160.  * init_selfinfo
  161.  *   Deterimines users home directory, userid, and a path
  162.  *   for an rc file in the home directory
  163.  */
  164.  
  165. init_selfinfo()
  166. {
  167.        struct passwd *myentry;
  168.        extern struct passwd *getpwuid();
  169.        struct stat sb;
  170.        char nam[LEN];
  171.        char *p;
  172.        extern char *getenv();
  173.        FILE *fp;
  174.  
  175. #ifndef        OSK
  176.        myentry = getpwuid(getuid());
  177. #else  /* OSK */
  178.        setpwent ();
  179. #ifdef USE_UID
  180.        myentry = getpwuid(real_uid () & 0xffff);
  181. #else  /* USE_UID */
  182.        myentry = getpwuid(getuid () & 0xffff);
  183. #endif /* USE_UID */
  184.        endpwent ();
  185. #endif /* OSK */
  186.        strcpy(userid, myentry->pw_name);
  187.        strcpy(homedir, myentry->pw_dir);
  188.  
  189.        sprintf(newsrc, "%s/.newsrc", homedir);
  190.        sprintf(newnewsrc, "%s/.newnewsrc", homedir);
  191.        sprintf(delgroups, "%s/.delgroups", homedir);
  192.        sprintf(indexdir, "%s/.tindex", homedir);
  193. #ifndef        OSK
  194.        sprintf(active_file, "%s/active", LIBDIR);
  195. #else  /* OSK */
  196.        if (!info_str ("MNEWS.LIB", active_file, LEN - 20))
  197.                strcpy (active_file, LIBDIR);
  198.        strcat (active_file, "/Active");
  199.        if (!info_str ("MNEWS.DIR", spooldir, LEN))
  200.                strcpy (spooldir, SPOOLDIR);
  201. #endif /* OSK */
  202. #ifdef INCSTR
  203.        if (!(incstr = getenv ("INCSTR")))
  204.                incstr = "> ";
  205. #endif /* INCSTR */
  206.  
  207.        if (stat(active_file, &sb) >= 0)
  208.                goto got_active;
  209.  
  210. #ifndef        OSK
  211. /*
  212.  *  I hate forgetting to define LIBDIR correctly.  Guess a
  213.  *  couple of likely places if it's not where LIBDIR says it is.
  214.  */
  215.  
  216.        strcpy(active_file, "/usr/lib/news/active");
  217.        if (stat(active_file, &sb) >= 0)
  218.                goto got_active;
  219.  
  220.        strcpy(active_file, "/usr/local/lib/news/active");
  221.        if (stat(active_file, &sb) >= 0)
  222.                goto got_active;
  223.  
  224.        strcpy(active_file, "/usr/public/lib/news/active");
  225.        if (stat(active_file, &sb) >= 0)
  226.                goto got_active;
  227.  
  228. /*
  229.  *  Oh well.  Revert to what LIBDIR says it is to produce a
  230.  *  useful error message when read_active() fails later.
  231.  */
  232.  
  233.        sprintf(active_file, "%s/active", LIBDIR);
  234. #endif /* OSK */
  235.  
  236. got_active:
  237.  
  238.        *my_org = '\0';
  239.        p = getenv("ORGANIZATION");
  240.        if (p != NULL) {
  241.                strcpy(my_org, p);
  242.                goto got_org;
  243.        }
  244.  
  245. #ifndef        OSK
  246.        sprintf(nam, "%s/organization", LIBDIR);
  247.        fp = fopen(nam, "r");
  248.  
  249.        if (fp == NULL) {
  250.                sprintf(nam, "/usr/lib/news/organization");
  251.                fp = fopen(nam, "r");
  252.        }
  253.  
  254.        if (fp == NULL) {
  255.                sprintf(nam, "/usr/local/lib/news/organization");
  256.                fp = fopen(nam, "r");
  257.        }
  258.  
  259.        if (fp == NULL) {
  260.                sprintf(nam, "/usr/public/lib/news/organization");
  261.                fp = fopen(nam, "r");
  262.        }
  263.  
  264.        if (fp == NULL) {
  265.                sprintf(nam, "/etc/organization");
  266.                fp = fopen(nam, "r");
  267.        }
  268.  
  269.        if (fp != NULL) {
  270.                if (fgets(my_org, LEN, fp) != NULL) {
  271.                        for (p = my_org; *p && *p != '\n'; p++) ;
  272.                        *p = '\0';
  273.                }
  274.                fclose(fp);
  275.        }
  276. #endif /* OSK */
  277.  
  278. got_org:;
  279.  
  280. }
  281.  
  282.  
  283. char *
  284. my_malloc(size)
  285. unsigned size;
  286. {
  287.        char *p;
  288.        extern char *malloc();
  289.  
  290.        p = malloc(size);
  291.        if (p == NULL) {
  292.                fprintf(stderr, "tass: out of memory\n");
  293.                exit(1);
  294.        }
  295.        return p;
  296. }
  297.  
  298.  
  299. char *
  300. my_realloc(p, size)
  301. char *p;
  302. unsigned size;
  303. {
  304.        extern char *malloc();
  305.        extern char *realloc();
  306.  
  307.        if (p == NULL)
  308.                p = malloc(size);
  309.        else
  310.                p = realloc(p, size);
  311.  
  312.        if (p == NULL) {
  313.                fprintf(stderr, "tass: out of memory\n");
  314.                exit(1);
  315.        }
  316.        return p;
  317. }
  318.  
  319.  
  320. char *
  321. str_save(s)
  322. char *s;
  323. {
  324. char *p;
  325.  
  326.        assert(s != NULL);
  327.        
  328.        p = my_malloc(strlen(s) + 1);
  329.        strcpy(p, s);
  330.  
  331.        return(p);
  332. }
  333.  
  334.  
  335. copy_fp(a, b, prefix)
  336. FILE *a;
  337. FILE *b;
  338. char *prefix;
  339. {
  340.        char buf[8192];
  341.  
  342.        while (fgets(buf, 8192, a) != NULL) {
  343. #ifdef MNEWS
  344.                conv_charset (buf, strlen (buf));
  345. #endif /* MNEWS */
  346.                fprintf(b, "%s%s", prefix, buf);
  347.        }
  348. }
  349.  
  350.  
  351. char *
  352. get_val(env, def)
  353. char *env;             /* Environment variable we're looking for       */
  354. char *def;             /* Default value if no environ value found      */
  355. {
  356.        extern char *getenv();
  357.        char *ptr;
  358.  
  359.        if ((ptr = getenv(env)) != NULL)
  360.                return(ptr);
  361.        else
  362.                return(def);
  363. }
  364.  
  365.  
  366. invoke_editor(nam, line)
  367. char *nam;
  368. int line;
  369. {
  370.        char buf[200];
  371.        static int first = TRUE;
  372.        static char editor[200];
  373.        static int type = -1;
  374.        char *ptr;
  375.  
  376.        if (first) {
  377. #ifndef        OSK
  378.                strcpy(editor, get_val("EDITOR", "/usr/bin/vi"));
  379. #else  /* OSK */
  380.                strcpy(editor, get_val("EDITOR", "me"));
  381. #endif /* OSK */
  382.                if (ptr = rindex (editor, '/'))
  383.                        ++ptr;
  384.                else
  385.                        ptr = editor;
  386.                if (!strncmp (ptr, "vi", 2))
  387.                        type = 0;
  388.                else if ((!strncmp (ptr, "me", 2)) || (!strncmp (ptr, "emacs")))
  389.                        type = 1;
  390.                first = FALSE;
  391.        }
  392.  
  393.        ++line;
  394.        switch (type) {
  395.                case -1:
  396.                default:
  397.                        sprintf(buf, "%s %s", editor, nam);
  398.                        break;
  399.                case 0:
  400.                        sprintf (buf, "%s +%d %s", editor, line, nam);
  401.                        break;
  402.                case 1:
  403.                        sprintf (buf, "%s -g=%d %s", editor, line, nam);
  404.                        break;
  405.        }
  406.        printf("\r%s", buf);
  407.        CleartoEOLN ();
  408.        return invoke_cmd(buf);
  409. }
  410.  
  411.  
  412. invoke_cmd(nam)
  413. char *nam;
  414. {
  415.        int ret;
  416. #ifdef SIGTSTP
  417.        void (*susp)();
  418. #endif
  419.  
  420.        Raw(FALSE);
  421. #ifdef USE_UID
  422.        setuid(real_uid);
  423.        setgid(real_gid);
  424. #endif /* USE_UID */
  425.  
  426. #ifndef        OSK
  427. #ifdef SIGTSTP
  428.        susp = signal(SIGTSTP, SIG_DFL);
  429. #endif
  430.  
  431.        ret = system(nam);
  432.  
  433. #ifdef SIGTSTP
  434.        signal(SIGTSTP, susp);
  435. #endif
  436. #else  /* OSK */
  437.        ret = system (nam);
  438. #endif /* OSK */
  439.  
  440. #ifdef USE_UID
  441.        setuid(tass_uid);
  442.        setgid(tass_gid);
  443. #endif /* USE_UID */
  444.        Raw(TRUE);
  445.  
  446.        return ret == 0;
  447. }
  448.  
  449.  
  450. shell_escape() {
  451.        char shell[LEN];
  452.        char *p;
  453. #ifdef SIGTSTP
  454.        void (*susp)();
  455. #endif
  456.  
  457.        if (!parse_string("!", shell))
  458.                strcpy(shell, get_val("SHELL", "/bin/sh"));
  459.  
  460.        for (p = shell; *p && (*p == ' ' || *p == '\t'); p++) ;
  461.  
  462.        if (!*p)
  463.                strcpy(shell, get_val("SHELL", "/bin/sh"));
  464.        
  465.        Raw(FALSE);
  466.  
  467. #ifdef USE_UID
  468.        setuid(real_uid);
  469.        setgid(real_gid);
  470. #endif /* USE_UID */
  471.  
  472.        fputs("\r\012", stdout);
  473.  
  474. #ifndef        OSK
  475. #ifdef SIGTSTP
  476.        susp = signal(SIGTSTP, SIG_DFL);
  477. #endif
  478.  
  479.        system(p);
  480.  
  481. #ifdef SIGTSTP
  482.        signal(SIGTSTP, susp);
  483. #endif
  484. #else  /* OSK */
  485.        system (p);
  486. #endif /* OSK */
  487.  
  488. #ifdef USE_UID
  489.        setuid(tass_uid);
  490.        setgid(tass_gid);
  491. #endif /* USE_UID */
  492.  
  493.        Raw(TRUE);
  494.  
  495.        continue_prompt();
  496.        mail_setup();
  497. }
  498.  
  499.  
  500. /*
  501.  *  Find the next unread response in this group 
  502.  */
  503.  
  504. next_unread(n)
  505. int n;
  506. {
  507.  
  508.        while (n >= 0) {
  509.                if (arts[n].unread == 1)
  510.                        return n;
  511.                n = next_response(n);
  512.        }
  513.  
  514.        return -1;
  515. }
  516.  
  517.  
  518. /*
  519.  *  Find the previous unread response in this thread
  520.  */
  521.  
  522. prev_unread(n)
  523. int n;
  524. {
  525.  
  526.        while (n >= 0) {
  527.                if (arts[n].unread == 1)
  528.                        return n;
  529.                n = prev_response(n);
  530.        }
  531.  
  532.        return -1;
  533. }
  534.  
  535.