home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / UUCPbb_2_1_src.lzh / UUCPBB21 / newsutils.c < prev    next >
Text File  |  1994-09-25  |  7KB  |  262 lines
  1. /*  newsutils.c    Routines used manipulate the newsgroup active file.
  2.     Copyright (C) 1990, 1993  Rick Adams and Bob Billson
  3.  
  4.     This file is part of the OS-9 UUCP package, UUCPbb.
  5.  
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.     The author of UUCPbb, Bob Billson, can be contacted at:
  21.     bob@kc2wz.bubble.org  or  uunet!kc2wz!bob  or  by snail mail:
  22.     21 Bates Way, Westfield, NJ 07090
  23. */
  24.  
  25. #include "uucp.h"
  26. #include <modes.h>
  27. #include <signal.h>
  28.  
  29. #define NAP  5                      /* seconds to sleep if active file busy */
  30.  
  31. EXTERN QQ int ngroups;
  32. EXTERN QQ int debuglvl;
  33. EXTERN struct active groups[];
  34. EXTERN QQ FILE *log;
  35. EXTERN char sender[];
  36.  
  37. static int activepath;                 /* only accessible within this file */
  38.  
  39.  
  40. /* init in-core newsgroups list from active file */
  41.  
  42. int readactive (mode, showmsg)
  43. int mode, showmsg;
  44. {
  45.      register char *words[3];
  46.      FILE *file;
  47.      char c, *p, buff[128];
  48.      char *cantopen = "readactive: cannot open active file";
  49.  
  50.      int firstpass = TRUE;
  51.  
  52.      /* open the active file in non-sharable mode, read-write.
  53.  
  54.         if active file was already opened by some other user, such as rnews,
  55.         wait until it is closed or user the decides to cancel sending the
  56.         article.  Between waits take a brief nap. */
  57.  
  58.      for (;;)
  59.           if ((activepath = open (NGROUPS, mode)) != ERROR)
  60.                break;
  61.           else
  62.                if (errno == 253)
  63.                  {
  64.                     if (showmsg)
  65.                       {
  66.                          if (firstpass)
  67.                            {
  68.                               fputs ("\nrnews: active file in use...wait or hit 'c' to cancel...",
  69.                                      stdout);
  70.  
  71.                               fflush (stdout);
  72.                               firstpass = FALSE;
  73.                            }
  74.  
  75.                          if (timeout (1) != TIMEDOUT)
  76.                            {
  77.                                read (0, &c, 1);
  78.  
  79.                                if (tolower (c) == 'c')
  80.                                  {
  81.                                     putchar ('\n');
  82.                                     return (FALSE);
  83.                                  }
  84.                            }
  85.                       }
  86.                     sleep (NAP);                   /* take a short snooze */
  87.                  }
  88.                else
  89.                  {
  90.                     logerror (cantopen);
  91.                     return (FALSE);
  92.                  }
  93.  
  94.      /* now turn the path # into a file descriptor for read */
  95.      ngroups = 0;
  96.  
  97.      if ((file = fdopen (activepath, "r")) == NULL)
  98.        {
  99.           logerror (cantopen);
  100.           return (FALSE);
  101.        }
  102.  
  103.      /* Read in the newsgroup name, lowest and highest message number in
  104.         the group. */
  105.  
  106.      p = buff;
  107.      while (mfgets (p, sizeof (buff), file) != NULL)
  108.        {
  109.           int linecount = 0;
  110.  
  111.           ++linecount;
  112.  
  113.           if (ISCOMMENT (*p) == TRUE)
  114.                continue;
  115.  
  116.           if (getargs (words, buff, 3) != 3)
  117.             {
  118.                char tmp[40];
  119.  
  120.                sprintf (tmp, "readactive: error in active file, line: %d",
  121.                              linecount);
  122.                logerror (tmp);
  123.                return (FALSE);
  124.             }
  125.  
  126.           /* Newsgroup name */
  127.           strcpy (groups[ngroups].newsgroup, *words);
  128.  
  129.           /* Lowest msg in group */
  130.           groups[ngroups].index = atoi (words[1]);
  131.  
  132.           /* Highest msg in group */
  133.           groups[ngroups].seq = atoi (words[2]);
  134.  
  135.           if (groups[ngroups].index <= 1)
  136.                groups[ngroups].index = 1;
  137.  
  138.           if (debuglvl > 0)
  139.                fprintf (log, "%s %s Newsgroup: %s  lowest: #%d  highest: #%d\n",
  140.                              sender, gtime(), groups[ngroups].newsgroup,
  141.                              groups[ngroups].index, groups[ngroups].seq);
  142.  
  143.           /* previously end of loop wouldn't detect when you exceeded
  144.              MAXNEWGROUPS, fixed!  --TK  */
  145.  
  146.           if (ngroups++ == MAXNEWSGROUPS)
  147.                break;
  148.        }
  149.      /* Leave file, thus, activepath open for updactive() */
  150.      return (TRUE);
  151. }
  152.  
  153.  
  154.  
  155. /* Release (unlock) active file if we won't update it */
  156.  
  157. int closeactive()
  158. {
  159.      close (activepath);
  160. }
  161.  
  162.  
  163.  
  164. /* Update active file */
  165.  
  166. int updactive()
  167. {
  168.      FILE *file;
  169.      register int  curgroup;
  170.  
  171.      if ((file = fdopen (activepath, "w")) == NULL)
  172.        {
  173.           logerror ("updactive: can't open active file for output");
  174.           return (FALSE);
  175.        }
  176.  
  177.      rewind (file);
  178.      for (curgroup = 0; curgroup < ngroups; curgroup++)
  179.           fprintf (file, "%s %d %d\n",
  180.                          groups[curgroup].newsgroup,
  181.                          groups[curgroup].index,
  182.                          groups[curgroup].seq);
  183.  
  184.      /* make sure all I/O has flushed before: */
  185.      /* chop off any junk at the end */
  186.      fflush (file);
  187.      _ss_size (activepath, ftell (file));
  188.  
  189.      /* closes readactive as well */
  190.      fclose (file);
  191.      return (TRUE);
  192. }
  193.  
  194.  
  195.  
  196. /* Find the group "group" in the in-core table, return its index.  If not
  197.    found, create if "makenew" otherwise return "-1".  */
  198.  
  199. int findgroup (group, makenew)
  200. char *group;
  201. int  makenew;
  202. {
  203.      register int curgroup;
  204.  
  205.      for (curgroup = 0; curgroup < ngroups; curgroup++)
  206.           if (strcmp (group, groups[curgroup].newsgroup) == 0)
  207.                break;
  208.  
  209.      /* If not found, return appropriate pointer */
  210.      if (curgroup == ngroups)
  211.           if (makenew)
  212.             {
  213.                strcpy (groups[ngroups].newsgroup, group);
  214.                groups[ngroups].index = groups[ngroups].seq = 0;
  215.                ngroups++;
  216.             }
  217.           else
  218.                return (-1);
  219.  
  220.      return (curgroup);
  221. }
  222.  
  223.  
  224.  
  225. /* Timeout will sleep for 'secs' seconds or until there's input ready
  226.    Return:  TIMEDOUT  - if we timed out
  227.             FALSE     - if data is waiting  */
  228.  
  229. int timeout (secs)
  230. int secs;
  231. {
  232.      register int i;
  233.      int count;
  234.  
  235.      /* if input waiting, return */
  236.      if (_gs_rdy (1) > 0)
  237.           return (FALSE);
  238.  
  239.      /* count *= 4 because we wake up 4 times / second */
  240.      count = secs << 2;
  241.      for (i = 0; i < count; i++)
  242.        {
  243.           if (_gs_rdy (1) > 0)
  244.                return (FALSE);
  245.           else
  246.             {
  247.                _ss_ssig (1, SIGWAKE);
  248.                tsleep (PORTSLEEP);
  249.                _ss_rel (1);
  250.             }
  251.        }
  252.      return (TIMEDOUT);
  253. }
  254.  
  255.  
  256.  
  257. static logerror (msg)
  258. char *msg;
  259. {
  260.      fprintf (log, "%s %s %s\n", sender, gtime(), msg);
  261. }
  262.