home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume7 / 2.11news / patch05 < prev    next >
Text File  |  1987-03-10  |  45KB  |  1,709 lines
  1. Path: mirror!adelie!necntc!husc6!seismo!rick
  2. From: rick@seismo.CSS.GOV (Rick Adams)
  3. Newsgroups: news.software.b
  4. Subject: patch #5 for 2.11 news src
  5. Message-ID: <43143@beno.seismo.CSS.GOV>
  6. Date: 10 Mar 87 20:58:51 GMT
  7. Sender: rick@seismo.CSS.GOV
  8. Organization: Center for Seismic Studies, Arlington, VA
  9. Lines: 1698
  10.  
  11. Description:
  12.     This is patch #5 for news 2.11 source. It addresses the following
  13.     problems:
  14.  
  15.     The locking seems to work completely now. Various obscure
  16.     interactions have all been fixed.
  17.     Mail sent to moderators no longer contains the suggested news header.
  18.     If HIDDENNET is defined, you can now use your local hostname instead
  19.     of the HIDDENNET name in the sys file.
  20.     The senduuname control message has been removed. It wasn't used
  21.     anymore and many people felt it was a security hole.
  22.     ihave/sendme now works with multicasting.
  23.     expire -R will just rebuild the dbm history files without actually
  24.     expiring anything.
  25.     If LIBDIR/localdomain is present, it is used instead of MYDOMAIN.
  26.     "unbatch" has been moved into rnews to avoid execing a separate process.
  27.     Processing batches of news is much faster (but still not fast). This
  28.     is done by recognizing that the parent process IS rnews (since
  29.     the unbatcher was moved into it), so it only need fork and not exec.
  30.  
  31. Fix:
  32.     cd to the src directory and apply the following patch
  33.  
  34. Index: patchlevel.h
  35. Prereq: 4
  36. *** .d/patchlevel.h    Tue Feb 24 17:55:57 1987
  37. --- patchlevel.h    Tue Mar 10 15:06:47 1987
  38. ***************
  39. *** 1,3 ****
  40. ! #define    PATCHLEVEL    4
  41.   
  42. ! #define NEWS_VERSION   "B 2.11 2/22/87"
  43. --- 1,3 ----
  44. ! #define    PATCHLEVEL    5
  45.   
  46. ! #define NEWS_VERSION   "B 2.11 3/10/87"
  47.  
  48. Index: inews.c
  49. Prereq: 2.74
  50. *** .d/inews.c    Tue Feb 24 17:55:56 1987
  51. --- inews.c    Tue Mar 10 15:06:14 1987
  52. ***************
  53. *** 17,27 ****
  54.    */
  55.   
  56.   #ifdef SCCSID
  57. ! static char    *SccsId = "@(#)inews.c    2.74    2/22/87";
  58.   #endif /* SCCSID */
  59.   
  60.   #include "iparams.h"
  61.   
  62.   #ifdef BSD4_2
  63.   # include <sys/dir.h>
  64.   # include <sys/file.h>
  65. --- 17,31 ----
  66.    */
  67.   
  68.   #ifdef SCCSID
  69. ! static char    *SccsId = "@(#)inews.c    2.76    3/10/87";
  70.   #endif /* SCCSID */
  71.   
  72.   #include "iparams.h"
  73.   
  74. + # ifdef LOCKF
  75. + # include <unistd.h>
  76. + # endif /* LOCKF */
  77. + 
  78.   #ifdef BSD4_2
  79.   # include <sys/dir.h>
  80.   # include <sys/file.h>
  81. ***************
  82. *** 30,38 ****
  83.   # ifdef USG
  84.   # include <fcntl.h>
  85.   # endif /* USG */
  86. - # ifdef LOCKF
  87. - # include <unistd.h>
  88. - # endif /* LOCKF */
  89.   #endif /* !BSD4_2 */
  90.   /* local defines for inews */
  91.   
  92. --- 34,39 ----
  93. ***************
  94. *** 86,91 ****
  95. --- 87,93 ----
  96.   };
  97.   
  98.   FILE *mailhdr();
  99. + extern char *mydomain();
  100.   extern int errno;
  101.   
  102.   struct timeb Now;
  103. ***************
  104. *** 126,138 ****
  105.       if (!ptr)
  106.           ptr = *argv - 1;
  107.       actfp = xfopen(ACTIVE, "r+");
  108. - #ifdef BSD4_2
  109. -     if (flock(fileno(actfp), LOCK_SH|LOCK_NB) < 0 && errno == EWOULDBLOCK)
  110. - #else    /* !BSD4_2 */
  111.   #ifdef    LOCKF
  112.       if (lockf(fileno(actfp), F_TLOCK, 0) < 0 &&
  113.           (errno == EAGAIN || errno == EACCES))
  114.   #else    /* !LOCKF */
  115.       sprintf(bfr, "%s.lock", ACTIVE);
  116.       if (LINK(ACTIVE,bfr) < 0 && errno == EEXIST)
  117.   #endif /* V7 */
  118. --- 128,140 ----
  119.       if (!ptr)
  120.           ptr = *argv - 1;
  121.       actfp = xfopen(ACTIVE, "r+");
  122.   #ifdef    LOCKF
  123.       if (lockf(fileno(actfp), F_TLOCK, 0) < 0 &&
  124.           (errno == EAGAIN || errno == EACCES))
  125.   #else    /* !LOCKF */
  126. + #ifdef BSD4_2
  127. +     if (flock(fileno(actfp), LOCK_SH|LOCK_NB) < 0 && errno == EWOULDBLOCK)
  128. + #else    /* !BSD4_2 */
  129.       sprintf(bfr, "%s.lock", ACTIVE);
  130.       if (LINK(ACTIVE,bfr) < 0 && errno == EEXIST)
  131.   #endif /* V7 */
  132. ***************
  133. *** 148,162 ****
  134.   
  135.   #endif /* SPOOLNEWS */
  136.       }
  137. ! #ifdef BSD4_2
  138. !     flock(fileno(actfp), LOCK_UN);
  139. ! #else    /* !BSD4_2 */
  140.   #ifdef    LOCKF
  141. !     lockf(fileno(actfp), F_ULOCK, 0);
  142.   #else    /* !LOCKF */
  143. !     UNLINK(bfr);
  144. ! #endif /* V7 */
  145.   #endif    /* !BSD4_2 */
  146.       if (argc > 1 && !strcmp(*(argv+1), "-U")) {
  147.           if (spool_news > 1) /* can't unspool while things are locked */
  148.               xxit(0);
  149. --- 150,170 ----
  150.   
  151.   #endif /* SPOOLNEWS */
  152.       }
  153. !     if (spool_news != 2) {
  154. !         /* only unlock if we locked */
  155.   #ifdef    LOCKF
  156. !         lockf(fileno(actfp), F_ULOCK, 0);
  157.   #else    /* !LOCKF */
  158. ! #ifdef     BSD4_2
  159. !         flock(fileno(actfp), LOCK_UN);
  160. ! #else    /* !BSD4_2 */
  161. !         UNLINK(bfr);
  162. ! #endif     /* V7 */
  163.   #endif    /* !BSD4_2 */
  164. +     } else {    /* expire is running */
  165. +         if (argc > 1 && !strcmp(*(argv+1), "-S"))
  166. +             exit(42);    /* inform rnews -U by exit status */
  167. +     }
  168.       if (argc > 1 && !strcmp(*(argv+1), "-U")) {
  169.           if (spool_news > 1) /* can't unspool while things are locked */
  170.               xxit(0);
  171. ***************
  172. *** 357,368 ****
  173.               }
  174.               if (!Mflag && !strpbrk(forgedname, "@ (<"))
  175.                   (void) sprintf(header.from,"%s@%s%s",
  176. !                     forgedname, FULLSYSNAME, MYDOMAIN);
  177.               else
  178.                   (void) strncpy(header.from, forgedname, BUFLEN);
  179.   
  180.               (void) sprintf(header.sender, "%s@%s%s",
  181. !                 username, FULLSYSNAME, MYDOMAIN);
  182.           } else {
  183.               gensender(&header, username);
  184.           }
  185. --- 365,376 ----
  186.               }
  187.               if (!Mflag && !strpbrk(forgedname, "@ (<"))
  188.                   (void) sprintf(header.from,"%s@%s%s",
  189. !                     forgedname, FULLSYSNAME, mydomain());
  190.               else
  191.                   (void) strncpy(header.from, forgedname, BUFLEN);
  192.   
  193.               (void) sprintf(header.sender, "%s@%s%s",
  194. !                 username, FULLSYSNAME, mydomain());
  195.           } else {
  196.               gensender(&header, username);
  197.           }
  198. ***************
  199. *** 407,413 ****
  200.           (void) signal(SIGQUIT, SIG_IGN);
  201.           header.ident[0] = '\0';
  202.           if (hread(&header, infp, TRUE) == NULL)
  203. !             error("Inbound news is garbled");
  204.           input();
  205.       }
  206.       /* always check history */
  207. --- 415,421 ----
  208.           (void) signal(SIGQUIT, SIG_IGN);
  209.           header.ident[0] = '\0';
  210.           if (hread(&header, infp, TRUE) == NULL)
  211. !             xerror("%s: Inbound news is garbled", filename);
  212.           input();
  213.       }
  214.       /* always check history */
  215. ***************
  216. *** 470,475 ****
  217. --- 478,484 ----
  218.       if (!rwaccess(f)) {
  219.           mfd = mailhdr((struct hbuf *)NULL, exists(f) ? "Unwritable files!" : "Missing files!");
  220.           if (mfd != NULL) {
  221. +             putc('\n', mfd);
  222.   #ifdef HIDDENNET
  223.               fprintf(mfd, "System: %s.%s\n\nThere was a problem with %s!!\n", LOCALSYSNAME, FULLSYSNAME, f);
  224.   #else /* !HIDDENNET */
  225. ***************
  226. *** 498,503 ****
  227. --- 507,513 ----
  228.       if (eaccess(dir, 07) != 0) {
  229.           mfd = mailhdr((struct hbuf *)NULL, exists(dir) ? "Unwritable diretories!" : "Missing directories!");
  230.           if (mfd != NULL) {
  231. +             putc('\n', mfd);
  232.   #ifdef HIDDENNET
  233.               fprintf(mfd, "System: %s.%s\n\nThere was a problem with %s!!\n", LOCALSYSNAME, FULLSYSNAME, dir);
  234.   #else /* !HIDDENNET */
  235. ***************
  236. *** 566,574 ****
  237.       register FILE *sp;
  238.       register struct tm *tp;
  239.       time_t t;
  240. !     char buf[BUFLEN];
  241.       extern struct tm *gmtime();
  242.   
  243.       (void) time(&t);
  244.       tp = gmtime(&t);
  245.       /* This file name "has to" be unique  (right?) */
  246. --- 576,596 ----
  247.       register FILE *sp;
  248.       register struct tm *tp;
  249.       time_t t;
  250. !     char buf[BUFLEN], *mktemp();
  251.       extern struct tm *gmtime();
  252.   
  253. +     sp = xfopen(mktemp(INFILE), "w");
  254. +     if (batchcmd != NULL)
  255. +         fprintf(sp, "%s\n", batchcmd);
  256. +     else
  257. +         if (not_here[0] != '\0')
  258. +             fprintf(sp, "#! inews -x %s -p\n", not_here);
  259. +     if (dolhwrite)
  260. +         lhwrite(&header, sp);
  261. +     while ((c = getc(infp)) != EOF)
  262. +         putc(c, sp);
  263. +     fclose(sp);
  264. + 
  265.       (void) time(&t);
  266.       tp = gmtime(&t);
  267.       /* This file name "has to" be unique  (right?) */
  268. ***************
  269. *** 585,592 ****
  270.           SPOOL,
  271.           tp->tm_year, tp->tm_mon+1, tp->tm_mday,
  272.           tp->tm_hour, tp->tm_min, getpid());
  273. !     sp = fopen(buf, "w");
  274. !     if (sp == NULL) {
  275.           char dbuf[BUFLEN];
  276.   #ifdef VMS
  277.           sprintf(dbuf, "%s/+rnews", SPOOL);
  278. --- 607,613 ----
  279.           SPOOL,
  280.           tp->tm_year, tp->tm_mon+1, tp->tm_mday,
  281.           tp->tm_hour, tp->tm_min, getpid());
  282. !     if (LINK(INFILE, buf) < 0) {
  283.           char dbuf[BUFLEN];
  284.   #ifdef VMS
  285.           sprintf(dbuf, "%s/+rnews", SPOOL);
  286. ***************
  287. *** 595,612 ****
  288.   #endif /* !VMS */
  289.           if (mkdir(dbuf, 0777&~N_UMASK) < 0)
  290.               xerror("Cannot mkdir %s: %s", dbuf, errmsg(errno));
  291. !         sp = xfopen(buf, "w");
  292.       }
  293. !     if (batchcmd != NULL)
  294. !         fprintf(sp, "%s\n", batchcmd);
  295. !     else
  296. !         if (not_here[0] != '\0')
  297. !             fprintf(sp, "#! inews -x %s -p\n", not_here);
  298. !     if (dolhwrite)
  299. !         lhwrite(&header, sp);
  300. !     while ((c = getc(infp)) != EOF)
  301. !         putc(c, sp);
  302. !     fclose(sp);
  303.       xxit(0);
  304.       /* NOTREACHED */
  305.   }
  306. --- 616,626 ----
  307.   #endif /* !VMS */
  308.           if (mkdir(dbuf, 0777&~N_UMASK) < 0)
  309.               xerror("Cannot mkdir %s: %s", dbuf, errmsg(errno));
  310. !         if (LINK(INFILE, buf) < 0) 
  311. !             xerror("Cannot link(%s,%s): %s", INFILE, buf,
  312. !                 errmsg(errno));
  313.       }
  314. !     (void) UNLINK(INFILE);
  315.       xxit(0);
  316.       /* NOTREACHED */
  317.   }
  318. ***************
  319. *** 638,644 ****
  320.   
  321.       if (header.approved[0] == '\0')
  322.           (void) sprintf(header.approved, "%s@%s%s",
  323. !                 username, FULLSYSNAME, MYDOMAIN);
  324.       (void) sprintf(bfr, "%s/inews -n %s.ctl -c newgroup %s -d %s -a \"%s\"",
  325.           LIB, header.nbuf, header.ctlmsg, header.distribution,
  326.           header.approved);
  327. --- 652,658 ----
  328.   
  329.       if (header.approved[0] == '\0')
  330.           (void) sprintf(header.approved, "%s@%s%s",
  331. !                 username, FULLSYSNAME, mydomain());
  332.       (void) sprintf(bfr, "%s/inews -n %s.ctl -c newgroup %s -d %s -a \"%s\"",
  333.           LIB, header.nbuf, header.ctlmsg, header.distribution,
  334.           header.approved);
  335. ***************
  336. *** 839,847 ****
  337.       if (is_mod[0] != '\0'     /* one of the groups is moderated */
  338.           && header.approved[0] == '\0') { /* and unapproved */
  339.           struct hbuf mhdr;
  340. !         FILE *mfd;
  341.           register char *p;
  342. !         char modadd[BUFLEN];
  343.   #ifdef DONTFOWARD
  344.           if(mode == PROC) {
  345.               logerr("Unapproved article in moderated group %s",
  346. --- 853,861 ----
  347.       if (is_mod[0] != '\0'     /* one of the groups is moderated */
  348.           && header.approved[0] == '\0') { /* and unapproved */
  349.           struct hbuf mhdr;
  350. !         FILE *mfd, *mhopen();
  351.           register char *p;
  352. !         char modadd[BUFLEN], *replyname();
  353.   #ifdef DONTFOWARD
  354.           if(mode == PROC) {
  355.               logerr("Unapproved article in moderated group %s",
  356. ***************
  357. *** 871,882 ****
  358.           while (*++p)
  359.               if (*p == '.')
  360.                   *p = '-';
  361. -         sprintf(bfr, "Submission for %s", is_mod);
  362.           sprintf(mhdr.path, modadd, is_mod);
  363. !         mfd = mailhdr(&mhdr, bfr);
  364.           if (mfd == NULL)
  365.               xerror("Can't send mail to %s", mhdr.path);
  366.           lhwrite(&header, mfd);
  367.           while ((c = getc(infp)) != EOF)
  368.               putc(c, mfd);
  369.           mclose(mfd);
  370. --- 885,897 ----
  371.           while (*++p)
  372.               if (*p == '.')
  373.                   *p = '-';
  374.           sprintf(mhdr.path, modadd, is_mod);
  375. !         mfd = mhopen(&mhdr);
  376.           if (mfd == NULL)
  377.               xerror("Can't send mail to %s", mhdr.path);
  378. +         fprintf(mfd, "To: %s\n", replyname(mhdr.path));
  379.           lhwrite(&header, mfd);
  380. +         putc('\n', mfd);
  381.           while ((c = getc(infp)) != EOF)
  382.               putc(c, mfd);
  383.           mclose(mfd);
  384. ***************
  385. *** 891,901 ****
  386.       }
  387.   
  388.       if (is_ctl) {
  389. !         exitcode = control(&header);
  390.           if (localize("control") && exitcode != 0)
  391.               savehist(histline);
  392.       } else {
  393.           if (s_find(&srec, FULLSYSNAME) == FALSE) {
  394.               logerr("Cannot find my name '%s' in %s", FULLSYSNAME, SUBFILE);
  395.               srec = dummy_srec;
  396.           }
  397. --- 906,920 ----
  398.       }
  399.   
  400.       if (is_ctl) {
  401. !         exitcode = control(&header, mode == PROC);
  402.           if (localize("control") && exitcode != 0)
  403.               savehist(histline);
  404.       } else {
  405. + #ifdef HIDDENNET
  406. +         if (s_find(&srec, LOCALSYSNAME) == FALSE) {
  407. + #else /* !HIDDENNET */
  408.           if (s_find(&srec, FULLSYSNAME) == FALSE) {
  409. + #endif /* !HIDDENNET */
  410.               logerr("Cannot find my name '%s' in %s", FULLSYSNAME, SUBFILE);
  411.               srec = dummy_srec;
  412.           }
  413. ***************
  414. *** 1193,1212 ****
  415.       register struct direct *dir;
  416.       register int foundsome;
  417.       int pid, status, ret;
  418.   #ifdef VMS
  419. !     sprintf(bfr, "%s/+rnews", SPOOL);
  420.   #else /* !VMS */
  421. !     sprintf(bfr, "%s/.rnews", SPOOL);
  422.   #endif /* !VMS */
  423.   
  424. !     if (chdir(bfr) < 0)
  425. !         xerror("chdir(%s):%s", bfr, errmsg(errno));
  426.   
  427.       do {
  428.           foundsome = 0;
  429. -         dirp = opendir(".");
  430. -         if (dirp == NULL)    /* Boy are things screwed up */
  431. -             xerror("opendir can't open .:%s", errmsg(errno));
  432.   
  433.           while ((dir=readdir(dirp)) != NULL) {
  434.               if (dir->d_name[0] == '.')
  435. --- 1212,1253 ----
  436.       register struct direct *dir;
  437.       register int foundsome;
  438.       int pid, status, ret;
  439. +     char spbuf[BUFLEN];
  440.   #ifdef VMS
  441. !     sprintf(spbuf, "%s/+rnews", SPOOL);
  442.   #else /* !VMS */
  443. !     sprintf(spbuf, "%s/.rnews", SPOOL);
  444.   #endif /* !VMS */
  445.   
  446. !     if (chdir(spbuf) < 0)
  447. !         xerror("chdir(%s):%s", spbuf, errmsg(errno));
  448.   
  449. +     dirp = opendir(".");
  450. +     if (dirp == NULL)    /* Boy are things screwed up */
  451. +         xerror("opendir can't open .:%s", errmsg(errno));
  452. + #ifdef    LOCKF
  453. +     if (lockf(dirp->dd_fd, F_TLOCK, 0) < 0 &&
  454. +         (errno == EAGAIN || errno == EACCES)) {
  455. + #else    /* !LOCKF */
  456. + #ifdef BSD4_2
  457. +     if (flock(dirp->dd_fd, LOCK_EX|LOCK_NB) < 0 &&
  458. +         errno == EWOULDBLOCK) {
  459. + #else    /* V7 */
  460. +     strcat(spbuf, ".lock");
  461. +     sprintf(bfr, "%s.tmp", spbuf);
  462. +     (void) close(creat(bfr, 0666));
  463. +     if (LINK(bfr, spbuf) < 0) {
  464. +         (void) UNLINK(bfr);
  465. +         if (errno != EEXIST)
  466. +             xerror("Can't lock %s: %s", spbuf, errmsg(errno));
  467. +         else
  468. + #endif /* V7 */
  469. + #endif    /* !LOCKF */
  470. +         xxit(3); /* another rnews -U is running */
  471. +     }
  472. + 
  473.       do {
  474.           foundsome = 0;
  475.   
  476.           while ((dir=readdir(dirp)) != NULL) {
  477.               if (dir->d_name[0] == '.')
  478. ***************
  479. *** 1222,1227 ****
  480. --- 1263,1273 ----
  481.               while ((ret=wait(&status)) != pid && ret != -1)
  482.                   /* continue */;
  483.   
  484. +             if (((status>>8)&0177) == 42) {
  485. +                 /* expire has started up, shutdown rnews -U */
  486. +                 break;
  487. +             }
  488. + 
  489.               if (status != 0) {
  490.                   sprintf(bfr, "../%s", dir->d_name);
  491.                   (void) LINK(dir->d_name, bfr);
  492. ***************
  493. *** 1231,1238 ****
  494.               (void) unlink(dir->d_name);
  495.               foundsome++;
  496.           }
  497. !         closedir(dirp);
  498.       } while (foundsome); /* keep rereading the directory until it's empty */
  499.   
  500.       xxit(0);
  501.   }
  502. --- 1277,1286 ----
  503.               (void) unlink(dir->d_name);
  504.               foundsome++;
  505.           }
  506. !         rewinddir(dirp);
  507.       } while (foundsome); /* keep rereading the directory until it's empty */
  508. +     closedir(dirp);
  509. +     (void) UNLINK(spbuf);
  510.   
  511.       xxit(0);
  512.   }
  513.  
  514. Index: control.c
  515. Prereq: 2.51
  516. *** .d/control.c    Tue Feb 24 17:55:44 1987
  517. --- control.c    Mon Mar  9 22:59:58 1987
  518. ***************
  519. *** 19,25 ****
  520.    */
  521.   
  522.   #ifdef SCCSID
  523. ! static char    *SccsId = "@(#)control.c    2.51    2/22/87";
  524.   #endif /* SCCSID */
  525.   
  526.   #include "iparams.h"
  527. --- 19,25 ----
  528.    */
  529.   
  530.   #ifdef SCCSID
  531. ! static char    *SccsId = "@(#)control.c    2.52    3/9/87";
  532.   #endif /* SCCSID */
  533.   
  534.   #include "iparams.h"
  535. ***************
  536. *** 55,66 ****
  537.    *        to listed address.
  538.    */
  539.   
  540. ! control(h)
  541.   struct hbuf *h;
  542.   {
  543.       register char *ctlmsgtext;
  544.       register struct msgtype *mp;
  545.   
  546.       if (strncmp(h->title, "cmsg ", 5) == 0) {
  547.           register char *cp1, *cp2;
  548.           cp1 = h->title;
  549. --- 55,70 ----
  550.    *        to listed address.
  551.    */
  552.   
  553. ! static int is_proc;
  554. ! 
  555. ! control(h, isproc)
  556.   struct hbuf *h;
  557. + int isproc;
  558.   {
  559.       register char *ctlmsgtext;
  560.       register struct msgtype *mp;
  561.   
  562. +     is_proc = isproc;
  563.       if (strncmp(h->title, "cmsg ", 5) == 0) {
  564.           register char *cp1, *cp2;
  565.           cp1 = h->title;
  566. ***************
  567. *** 161,166 ****
  568. --- 165,171 ----
  569.       register int    i;
  570.       char        list[sizeof header.title];
  571.       extern char *    findhist();
  572. +     extern char *    mydomain();
  573.   
  574.       if (argc < 2)
  575.           error("ihave: Too few arguments.");
  576. ***************
  577. *** 210,216 ****
  578.       (void) sprintf(header.title, "sendme%s %s", list, FULLSYSNAME);
  579.       (void) strcpy(header.ctlmsg, header.title);
  580.       getident(&header);
  581. !     (void) sprintf(header.from, "%s@%s%s", "usenet", FULLSYSNAME, MYDOMAIN);
  582.       (void) strcpy(header.path, NEWSUSR);
  583.       header.subdate[0] = header.expdate[0] = '\0';
  584.       dates(&header);
  585. --- 215,221 ----
  586.       (void) sprintf(header.title, "sendme%s %s", list, FULLSYSNAME);
  587.       (void) strcpy(header.ctlmsg, header.title);
  588.       getident(&header);
  589. !     (void) sprintf(header.from, "%s@%s%s", "usenet", FULLSYSNAME, mydomain());
  590.       (void) strcpy(header.path, NEWSUSR);
  591.       header.subdate[0] = header.expdate[0] = '\0';
  592.       dates(&header);
  593. ***************
  594. *** 238,243 ****
  595. --- 243,252 ----
  596.    * The other system wants me to send out article <artid>.
  597.    * Give it to them with no fuss.
  598.    */
  599. + #ifdef MULTICAST
  600. + static int    c_mc;
  601. + static char **    c_sysnames;
  602. + #endif /* MULTICAST */
  603.   c_sendme(argc, argv)
  604.   register char **argv;
  605.   {
  606. ***************
  607. *** 249,254 ****
  608. --- 258,275 ----
  609.           return 0;
  610.       if (s_find(&srec, argv[argc - 1]) != TRUE)
  611.           error("sendme: Can't find sys record for %s", argv[argc - 1]);
  612. + #ifdef MULTICAST
  613. +     c_mc = index(srec.s_flags, 'M') != 0;
  614. +     if (c_mc) {
  615. +         struct srec    trec;
  616. + 
  617. +         c_sysnames = &argv[argc - 1];
  618. +         if (s_find(&trec, srec.s_xmit) != TRUE)
  619. +             error("sendme: Can't find sys record for %s for %s",
  620. +                 srec.s_xmit, argv[argc - 1]);
  621. +         srec = trec;
  622. +     } else    c_sysnames = NULL;
  623. + #endif /* MULTICAST */
  624.       /* Send the articles. */
  625.       if (argc == 2) {
  626.           register FILE *    fp;
  627. ***************
  628. *** 284,290 ****
  629. --- 305,315 ----
  630.       cp = findfname(id);
  631.       if (cp == NULL) {
  632.           logerr("System %s wants unavailable article %s.",
  633. + #ifdef MULTICAST
  634. +             (c_mc ? c_sysnames[0] : sp->s_name), id);
  635. + #else /* !MULTICAST */
  636.               sp->s_name, id);
  637. + #endif /* !MULTICAST */
  638.           return;
  639.       }
  640.       cp = dirname(cp);
  641. ***************
  642. *** 295,301 ****
  643.       }
  644.       (void) strcpy(savedbufname, firstbufname);
  645.       (void) strcpy(firstbufname, cp);
  646. !     transmit(sp, fp, FALSE, (char **) NULL, FALSE);
  647.       /* transmit closes fp */
  648.       (void) strcpy(firstbufname, savedbufname);
  649.   }
  650. --- 320,330 ----
  651.       }
  652.       (void) strcpy(savedbufname, firstbufname);
  653.       (void) strcpy(firstbufname, cp);
  654. ! #ifdef MULTICAST
  655. !     transmit(sp, fp, FALSE, c_sysnames, c_mc);
  656. ! #else /* !MULTICAST */
  657. !     transmit(sp, fp, FALSE, (char **) NULL, 0);
  658. ! #endif /* !MULTICAST */
  659.       /* transmit closes fp */
  660.       (void) strcpy(firstbufname, savedbufname);
  661.   }
  662. ***************
  663. *** 389,396 ****
  664.                       fprintf(fd,
  665.   "%s\nhas requested that %s be changed from %smoderated to %smoderated\n",
  666.                           header.path, argv[1], 
  667. !                         *p=='y' ? "un" : "",
  668. !                         *p=='y' ? "" : "un");
  669.   #ifdef ORGDISTRIB
  670.                       fprintf(fd,
  671.   "You can accomplish this by re-creating the newsgroup with a distribution\n");
  672. --- 418,425 ----
  673.                       fprintf(fd,
  674.   "%s\nhas requested that %s be changed from %smoderated to %smoderated\n",
  675.                           header.path, argv[1], 
  676. !                         *p=='y' ? "" : "un",
  677. !                         *p=='y' ? "un" : "");
  678.   #ifdef ORGDISTRIB
  679.                       fprintf(fd,
  680.   "You can accomplish this by re-creating the newsgroup with a distribution\n");
  681. ***************
  682. *** 595,601 ****
  683.              argv[1], tm->tm_mon+1, tm->tm_mday, tm->tm_year, tm->tm_hour,
  684.              tm->tm_min);
  685.           savehist(bfr);
  686. !         return 1;
  687.       }
  688.   
  689.       q = index(line, '\t');
  690. --- 624,630 ----
  691.              argv[1], tm->tm_mon+1, tm->tm_mday, tm->tm_year, tm->tm_hour,
  692.              tm->tm_min);
  693.           savehist(bfr);
  694. !         return is_proc ? 0 : 1;
  695.       }
  696.   
  697.       q = index(line, '\t');
  698. ***************
  699. *** 603,614 ****
  700.       if (p == NULL || *++p == '\0' || *p == '\n') {
  701.           *q = '\0';
  702.           log("Expired article %s", line);
  703. !         return 1;
  704.       }
  705.       if (strcmp(p, "cancelled") == 0) {
  706.           *q = '\0';
  707.           log("Already Cancelled %s", line);
  708. !         return 1;
  709.       } else
  710.           log("Cancelling %s", line);
  711.       if ((uid == ROOTID||uid == 0) && strcmp(header.distribution, "local") == 0)
  712. --- 632,643 ----
  713.       if (p == NULL || *++p == '\0' || *p == '\n') {
  714.           *q = '\0';
  715.           log("Expired article %s", line);
  716. !         return is_proc ? 0 : 1;
  717.       }
  718.       if (strcmp(p, "cancelled") == 0) {
  719.           *q = '\0';
  720.           log("Already Cancelled %s", line);
  721. !         return is_proc ? 0 : 1;
  722.       } else
  723.           log("Cancelling %s", line);
  724.       if ((uid == ROOTID||uid == 0) && strcmp(header.distribution, "local") == 0)
  725. ***************
  726. *** 696,750 ****
  727.   }
  728.   
  729.   /*
  730. -  * senduuname    (no arguments)
  731. -  *
  732. -  * Run the "uuname" command and send it back to the person who submitted
  733. -  * the article.  The purpose of this control message is for attempting to
  734. -  * make a uucp net map.
  735. -  *
  736. -  * POLICY: If you view this information as not public (because you have
  737. -  * a connection you consider secret, or know a site that considers itself
  738. -  * secret) you can feel free to change this code in whatever way is
  739. -  * appropriate, so long as it sends some response back to the sender.  If
  740. -  * you don't run uucp, this code does not make sense, and so an error
  741. -  * message (or garbage, such as "research") will be mailed back.
  742. -  *
  743. -  * If you wish to add or remove sites from the output of uuname, you
  744. -  * may wish to use the euuname.sh shell script here.
  745. -  */
  746. - /* ARGSUSED */
  747. - c_senduuname(argc, argv)
  748. - char **argv;
  749. - {
  750. -     char buf[256];
  751. -     FILE *fd, *u;
  752. -     int c;
  753. - 
  754. - #ifdef NOTIFY
  755. -     fd = mailhdr((struct hbuf *)NULL, "uuname control message");
  756. -     fprintf(fd, "%s requested your uuname output\n", header.path);
  757. -     (void) mclose(fd);
  758. - #endif /* NOTIFY */
  759. -     fd = mailhdr(&header, "response to your senduuname request");
  760. - #ifdef UUPROG
  761. -     if (UUPROG[0] == '/')
  762. -         (void) strcpy(buf, UUPROG);
  763. -     else
  764. -         (void) sprintf(buf, "%s/%s", LIB, UUPROG);
  765. - #else
  766. -     (void) strcpy(buf, "uuname");
  767. - #endif
  768. -     u = popen(buf, "r");
  769. -     if (fd != NULL && u != NULL) {
  770. -         while ((c=getc(u)) != EOF)
  771. -             putc(c, fd);
  772. -         (void) pclose(u);
  773. -         (void) mclose(fd);
  774. -     }
  775. -     return 0;
  776. - }
  777. - 
  778. - /*
  779.    * Send the version number to the right person.
  780.    */
  781.   /* ARGSUSED */
  782. --- 725,730 ----
  783. ***************
  784. *** 923,928 ****
  785. --- 903,909 ----
  786.       FILE *fp;
  787.       time_t now;
  788.       char *to = "usenet";
  789. +     extern char *mydomain();
  790.   
  791.   #ifdef NOTIFY
  792.       if (TELLME && *TELLME)
  793. ***************
  794. *** 936,942 ****
  795.           fprintf(fp, "Date: %s\n", arpadate(&now));
  796.   #ifdef MMDF
  797.           fprintf(fp, "From: The News System <usenet@%s%s>\n",
  798. !                 FULLSYSNAME, MYDOMAIN);
  799.   #endif /* MMDF */
  800.           fprintf(fp, "To: %s\n", to);
  801.           fprintf(fp, "Subject: %s\n", subject);
  802. --- 917,923 ----
  803.           fprintf(fp, "Date: %s\n", arpadate(&now));
  804.   #ifdef MMDF
  805.           fprintf(fp, "From: The News System <usenet@%s%s>\n",
  806. !                 FULLSYSNAME, mydomain());
  807.   #endif /* MMDF */
  808.           fprintf(fp, "To: %s\n", to);
  809.           fprintf(fp, "Subject: %s\n", subject);
  810. ***************
  811. *** 943,953 ****
  812.   #ifdef HIDDENNET
  813.           if (strcmp(LOCALSYSNAME, FULLSYSNAME))
  814.               fprintf(fp, "Responding-System: %s.%s%s\n\n",
  815. !                 LOCALSYSNAME, FULLSYSNAME, MYDOMAIN);
  816.           else
  817.   #endif /* !HIDDENNET */
  818.               fprintf(fp, "Responding-System: %s%s\n\n",
  819. !                 FULLSYSNAME, MYDOMAIN);
  820.       }
  821.       return fp;
  822.   }
  823. --- 924,934 ----
  824.   #ifdef HIDDENNET
  825.           if (strcmp(LOCALSYSNAME, FULLSYSNAME))
  826.               fprintf(fp, "Responding-System: %s.%s%s\n\n",
  827. !                 LOCALSYSNAME, FULLSYSNAME, mydomain());
  828.           else
  829.   #endif /* !HIDDENNET */
  830.               fprintf(fp, "Responding-System: %s%s\n\n",
  831. !                 FULLSYSNAME, mydomain());
  832.       }
  833.       return fp;
  834.   }
  835. ***************
  836. *** 1009,1016 ****
  837.       } else if (strcmp(msg, "rmgroup") == 0) {
  838.           suser();
  839.       } else if (strcmp(msg, "sendsys") == 0) {
  840. -         suser();
  841. -     } else if (strcmp(msg, "senduuname") == 0) {
  842.           suser();
  843.       } else if (strcmp(msg, "checkgroups") == 0) {
  844.           suser();
  845. --- 990,995 ----
  846.  
  847. Index: expire.c
  848. Prereq: 2.50
  849. *** .d/expire.c    Tue Feb 24 17:55:47 1987
  850. --- expire.c    Mon Mar  9 22:59:59 1987
  851. ***************
  852. *** 17,23 ****
  853.    */
  854.   
  855.   #ifdef SCCSID
  856. ! static char    *SccsId = "@(#)expire.c    2.50    2/22/87";
  857.   #endif /* SCCSID */
  858.   
  859.   #include "params.h"
  860. --- 17,23 ----
  861.    */
  862.   
  863.   #ifdef SCCSID
  864. ! static char    *SccsId = "@(#)expire.c    2.51    3/9/87";
  865.   #endif /* SCCSID */
  866.   
  867.   #include "params.h"
  868. ***************
  869. *** 230,235 ****
  870. --- 230,244 ----
  871.               dorebuild++;
  872.               nohistory++;
  873.               break;
  874. +         case 'R':    /* just rebuild the dbm files */
  875. + #ifdef DBM
  876. +             rebuilddbm();
  877. +             xxit(0);
  878. + #else /* !DBM */
  879. +             fprintf(stderr, "You have not compiled expire with DBM, so -R is meaningless\n");
  880. +             xxit(1);
  881. + #endif /* !DBM */
  882. + 
  883.           case 'p':    /* use posting date to expire */
  884.               usepost++;
  885.               break;
  886. ***************
  887. *** 1171,1177 ****
  888.           (void) mkdir(fn, 0755);
  889.       (void) sprintf(fn, "%s.d", ARTFILE);
  890.       if (verbose)
  891. !         printf("Rebuilding history subfile directory %d.\n", fn);
  892.       if (access(fn,0) != 0)
  893.           (void) mkdir(fn, 0755);
  894.       for (i = 0; i < 10; i++) {
  895. --- 1180,1186 ----
  896.           (void) mkdir(fn, 0755);
  897.       (void) sprintf(fn, "%s.d", ARTFILE);
  898.       if (verbose)
  899. !         printf("Rebuilding history subfile directory %s.\n", fn);
  900.       if (access(fn,0) != 0)
  901.           (void) mkdir(fn, 0755);
  902.       for (i = 0; i < 10; i++) {
  903.  
  904. Index: header.c
  905. Prereq: 2.46
  906. *** .d/header.c    Wed Dec 17 18:23:40 1986
  907. --- header.c    Mon Mar  9 22:59:59 1987
  908. ***************
  909. *** 16,22 ****
  910.    */
  911.   
  912.   #ifdef SCCSID
  913. ! static char    *SccsId = "@(#)header.c    2.46    12/17/86";
  914.   #endif /* SCCSID */
  915.   
  916.   #include <stdio.h>
  917. --- 16,22 ----
  918.    */
  919.   
  920.   #ifdef SCCSID
  921. ! static char    *SccsId = "@(#)header.c    2.47    3/9/87";
  922.   #endif /* SCCSID */
  923.   
  924.   #include <stdio.h>
  925. ***************
  926. *** 284,289 ****
  927. --- 284,290 ----
  928.       char *at, *dot;
  929.       char pathbuf[PATHLEN];
  930.       char fullname[BUFLEN];
  931. +     extern char *mydomain();
  932.   
  933.       tp = tailpath(hp);
  934.       user = rindex(tp, '!');
  935. ***************
  936. *** 314,320 ****
  937.       tp = index(host, '@');
  938.       if (tp != NULL)
  939.           *tp = 0;
  940. !     (void) sprintf(hp->from, "%s@%s%s", user, host, MYDOMAIN);
  941.   
  942.       skin(pathbuf, fullname, hp->path);    /* remove RFC822-style comments */
  943.       if (fullname[0] != '\0') {
  944. --- 315,321 ----
  945.       tp = index(host, '@');
  946.       if (tp != NULL)
  947.           *tp = 0;
  948. !     (void) sprintf(hp->from, "%s@%s%s", user, host, mydomain());
  949.   
  950.       skin(pathbuf, fullname, hp->path);    /* remove RFC822-style comments */
  951.       if (fullname[0] != '\0') {
  952.  
  953. Index: pathinit.c
  954. Prereq: 1.19
  955. *** .d/pathinit.c    Wed Dec 17 18:23:22 1986
  956. --- pathinit.c    Mon Mar  9 23:00:02 1987
  957. ***************
  958. *** 34,40 ****
  959.    */
  960.   
  961.   #ifdef SCCSID
  962. ! static char    *SccsId = "@(#)pathinit.c    1.19    12/16/86";
  963.   #endif /* SCCSID */
  964.   
  965.   #if defined(INEW) || defined(EXP)
  966. --- 34,40 ----
  967.    */
  968.   
  969.   #ifdef SCCSID
  970. ! static char    *SccsId = "@(#)pathinit.c    1.20    3/9/87";
  971.   #endif /* SCCSID */
  972.   
  973.   #if defined(INEW) || defined(EXP)
  974. ***************
  975. *** 57,63 ****
  976.   char *LOCKFILE, *SEQFILE, *ARTICLE, *INFILE, *TELLME;
  977.   
  978.   int c_cancel(), c_newgroup(), c_ihave(), c_sendme(), c_rmgroup(),
  979. !     c_sendsys(), c_senduuname(), c_version(), c_checkgroups(), c_unimp();
  980.   
  981.   struct msgtype msgtype[] = {
  982.       "cancel", NULL, c_cancel,
  983. --- 57,63 ----
  984.   char *LOCKFILE, *SEQFILE, *ARTICLE, *INFILE, *TELLME;
  985.   
  986.   int c_cancel(), c_newgroup(), c_ihave(), c_sendme(), c_rmgroup(),
  987. !     c_sendsys(), c_version(), c_checkgroups(), c_unimp();
  988.   
  989.   struct msgtype msgtype[] = {
  990.       "cancel", NULL, c_cancel,
  991. ***************
  992. *** 67,73 ****
  993.       "sendbad", NULL, c_sendme,
  994.       "rmgroup", NULL, c_rmgroup,
  995.       "sendsys", NULL, c_sendsys,
  996. -     "senduuname", NULL, c_senduuname,
  997.       "version", NULL, c_version,
  998.       "checkgroups", NULL, c_checkgroups,
  999.       "delsub", NULL, c_unimp,
  1000. --- 67,72 ----
  1001.  
  1002. Index: uname.c
  1003. Prereq: 2.13
  1004. *** .d/uname.c    Wed Dec 17 18:23:29 1986
  1005. --- uname.c    Mon Mar  9 23:00:02 1987
  1006. ***************
  1007. *** 21,27 ****
  1008.    */
  1009.   
  1010.   #ifdef SCCSID
  1011. ! static char    *SccsId = "@(#)uname.c    2.13    12/16/86";
  1012.   #endif /* SCCSID */
  1013.   
  1014.   #include "params.h"
  1015. --- 21,27 ----
  1016.    */
  1017.   
  1018.   #ifdef SCCSID
  1019. ! static char    *SccsId = "@(#)uname.c    2.14    3/9/87";
  1020.   #endif /* SCCSID */
  1021.   
  1022.   #include "params.h"
  1023. ***************
  1024. *** 35,42 ****
  1025.   struct utsname *uptr;
  1026.   {
  1027.       char *cp;
  1028.       gethostname(uptr->nodename, sizeof (uptr->nodename));
  1029. !     cp = MYDOMAIN;    /* Gould compiler can't handle ""[0] */
  1030.       if (*cp == '\0') /* get domain name from hostname */
  1031.           return;
  1032.       cp = index(uptr->nodename, '.');
  1033. --- 35,43 ----
  1034.   struct utsname *uptr;
  1035.   {
  1036.       char *cp;
  1037. +     extern char *mydomain();
  1038.       gethostname(uptr->nodename, sizeof (uptr->nodename));
  1039. !     cp = mydomain();
  1040.       if (*cp == '\0') /* get domain name from hostname */
  1041.           return;
  1042.       cp = index(uptr->nodename, '.');
  1043. ***************
  1044. *** 96,98 ****
  1045. --- 97,157 ----
  1046.       }
  1047.   }
  1048.   #endif
  1049. + 
  1050. + 
  1051. + /*
  1052. +  * At sites where the are many mail domains within the support area of a single
  1053. +  * news administrator, it is much nicer to be able to read the local domain of
  1054. +  * a machine from a file.  What we do here is:
  1055. +  * 1)    Check for the presence of a LIBDIR/localdomain file.  If it doesn't 
  1056. +  *     exist,assume that MYDOMAIN should be used instead.
  1057. +  * 2)    If it does exist, we make the following assumptions:
  1058. +  *    a)  If it is empty, has only comments, or only blank lines; we assume
  1059. +  *        the domain is desired to be a zero length string ( ie "").  (this
  1060. +  *        implies that the domain name is contained in the hostname.)
  1061. +  *    b)  If it is not empty, we assume the first line not beginning with a
  1062. +  *        '#', blank/tab, or newline is the desired domain name.
  1063. +  *        A like '.UUCP' or '.TEK.COM' should be used.  We could insure that
  1064. +  *        the line begin with a '.' to be a valid domain name, but I don't 
  1065. +  *        think it is necessary to put that restriction on it.
  1066. +  */
  1067. + char *
  1068. + mydomain()
  1069. + {
  1070. +     static char *md = NULL;
  1071. +     register char *cp;
  1072. +     FILE *fp = NULL;
  1073. +     char fbuf[BUFLEN];
  1074. +     extern char *malloc(), *strcpy(), *index();
  1075. + 
  1076. +     if(md)    /* we've been here before, so just return what we found */
  1077. +         return(md);
  1078. + 
  1079. +     (void) sprintf(fbuf,"%s/localdomain", LIBDIR);
  1080. +     if ( (fp = fopen(fbuf,"r")) == NULL) {
  1081. +         md = MYDOMAIN;    /* No localdomain file, use MYDOMAIN instead */
  1082. +     } else {
  1083. +         while(fgets(fbuf, sizeof(fbuf), fp) ) {
  1084. +             if( *fbuf == '\n' || *fbuf == '#' 
  1085. +                 || *fbuf == ' ' || *fbuf == '\t')
  1086. +                 continue;
  1087. +     
  1088. +             if( cp = index(fbuf, '\n') )
  1089. +                 *cp = '\0';
  1090. +     
  1091. +             if ( (md = malloc(strlen(fbuf) + 1)) == NULL)
  1092. +                 md = MYDOMAIN;    /* punt here */
  1093. +             else
  1094. +                 (void)strcpy(md, fbuf);
  1095. +             break;
  1096. +         }
  1097. +     }
  1098. + 
  1099. +     if(fp)
  1100. +         (void)fclose(fp);
  1101. + 
  1102. +     if( md == NULL)
  1103. +         md = "";
  1104. +     
  1105. +     return(md);
  1106. + }
  1107.  
  1108. Index: ndir.c
  1109. Prereq: 1.9
  1110. *** .d/ndir.c    Wed Dec 17 18:23:21 1986
  1111. --- ndir.c    Mon Mar  9 23:00:01 1987
  1112. ***************
  1113. *** 1,10 ****
  1114.   #include "defs.h"
  1115. ! #if !defined(BSD4_2) && !defined(BSD4_1C)
  1116.   #include <sys/param.h>
  1117.   #include "ndir.h"
  1118.   
  1119.   #ifdef SCCSID
  1120. ! static char    *SccsId = "@(#)ndir.c    1.9    12/16/86";
  1121.   #endif /* SCCSID */
  1122.   
  1123.   /*
  1124. --- 1,10 ----
  1125.   #include "defs.h"
  1126. ! #if !defined(BSD4_2) && !defined(BSD4_1C) && !defined(HP9K5)
  1127.   #include <sys/param.h>
  1128.   #include "ndir.h"
  1129.   
  1130.   #ifdef SCCSID
  1131. ! static char    *SccsId = "@(#)ndir.c    1.10    3/9/87";
  1132.   #endif /* SCCSID */
  1133.   
  1134.   /*
  1135. ***************
  1136. *** 48,67 ****
  1137.   #else /* V7 file system */
  1138.   #define    ODIRSIZ    14
  1139.   
  1140. - #if HP9K5
  1141. - /* HP 9000/500 has a weird directory format */
  1142. - struct olddirect {
  1143. -     char    od_name[DIRSIZ+2];    /* filename */
  1144. -     short    od_object_type;
  1145. -     short    od_file_code;
  1146. -     short    od_ino;         /* inode */
  1147. - };
  1148. - #else /* normal V7 */
  1149.   struct    olddirect {
  1150.       short    od_ino;
  1151.       char    od_name[ODIRSIZ];
  1152.   };
  1153. - #endif /* V7 */
  1154.   #endif /* !pyr */
  1155.   
  1156.   /*
  1157. --- 48,57 ----
  1158. ***************
  1159. *** 110,113 ****
  1160.       dirp->dd_loc = 0;
  1161.       free((char *)dirp);
  1162.   }
  1163. ! #endif /* !BSD4_2 && !BSD4_1C */
  1164. --- 100,140 ----
  1165.       dirp->dd_loc = 0;
  1166.       free((char *)dirp);
  1167.   }
  1168. ! 
  1169. ! /*
  1170. !  * seek to an entry in a directory.
  1171. !  * Only values returned by "telldir" should be passed to seekdir.
  1172. !  */
  1173. ! void
  1174. ! seekdir(dirp, loc)
  1175. ! register DIR *dirp;
  1176. ! long loc;
  1177. ! {
  1178. !     long curloc, base, offset;
  1179. !     struct direct *dp;
  1180. !     extern long lseek();
  1181. ! 
  1182. !     curloc = telldir(dirp);
  1183. !     if (loc == curloc)
  1184. !         return;
  1185. !     base = loc & ~(DIRBLKSIZ - 1);
  1186. !     offset = loc & (DIRBLKSIZ - 1);
  1187. !     (void) lseek(dirp->dd_fd, base, 0);
  1188. !     dirp->dd_loc = 0;
  1189. !     while (dirp->dd_loc < offset) {
  1190. !         dp = readdir(dirp);
  1191. !         if (dp == NULL)
  1192. !             return;
  1193. !     }
  1194. ! }
  1195. ! 
  1196. ! /*
  1197. !  * return a pointer into a directory
  1198. !  */
  1199. ! long
  1200. ! telldir(dirp)
  1201. ! DIR *dirp;
  1202. ! {
  1203. !     return lseek(dirp->dd_fd, 0L, 1) - dirp->dd_size + dirp->dd_loc;
  1204. ! }
  1205. ! #endif /* !BSD4_2 && !BSD4_1C && !HP9K5 */
  1206.  
  1207. Index: ndir.h
  1208. Prereq: 1.4
  1209. *** .d/ndir.h    Thu Oct 30 16:12:09 1986
  1210. --- ndir.h    Mon Mar  9 23:00:01 1987
  1211. ***************
  1212. *** 1,4 ****
  1213. ! /* @(#)ndir.h    1.4    4/16/85 */
  1214.   #ifndef DEV_BSIZE
  1215.   #define    DEV_BSIZE    512
  1216.   #endif
  1217. --- 1,8 ----
  1218. ! /* @(#)ndir.h    1.6    3/9/87    */
  1219. ! #if defined(HP9K5)
  1220. ! /* He should have included it instead of this, but prevent confusion */
  1221. ! #include <sys/ndir.h>
  1222. ! #else /* other */
  1223.   #ifndef DEV_BSIZE
  1224.   #define    DEV_BSIZE    512
  1225.   #endif
  1226. ***************
  1227. *** 40,42 ****
  1228. --- 44,49 ----
  1229.   extern    DIR *opendir();
  1230.   extern    struct direct *readdir();
  1231.   extern    void closedir();
  1232. + 
  1233. + #define rewinddir(dirp)    seekdir((dirp), (long)0)
  1234. + #endif /* other */
  1235.  
  1236. Index: ifuncs.c
  1237. Prereq: 2.60
  1238. *** .d/ifuncs.c    Tue Feb 24 17:55:52 1987
  1239. --- ifuncs.c    Mon Mar  9 23:00:00 1987
  1240. ***************
  1241. *** 16,22 ****
  1242.    */
  1243.   
  1244.   #ifdef SCCSID
  1245. ! static char    *SccsId = "@(#)ifuncs.c    2.60    2/22/87";
  1246.   #endif /* SCCSID */
  1247.   
  1248.   #include "iparams.h"
  1249. --- 16,22 ----
  1250.    */
  1251.   
  1252.   #ifdef SCCSID
  1253. ! static char    *SccsId = "@(#)ifuncs.c    2.61    3/9/87";
  1254.   #endif /* SCCSID */
  1255.   
  1256.   #include "iparams.h"
  1257. ***************
  1258. *** 712,719 ****
  1259.       extern int errno;
  1260.   #ifdef    VMS
  1261.       int fd;
  1262. ! 
  1263. !     (void) sprintf(lockname, "/tmp/%s.l.1", str);
  1264.       while ((fd = creat(lockname, 0444)) < 0) {
  1265.   #else /* !VMS */
  1266.       (void) strcpy(tempname, "/tmp/LTMP.XXXXXX");
  1267. --- 712,723 ----
  1268.       extern int errno;
  1269.   #ifdef    VMS
  1270.       int fd;
  1271. ! /* The name here is because of the peculiar properties of version numbers
  1272. !  * in Eunice.  We eliminate any troublesome characters also.
  1273. !  */
  1274. !     (void) sprintf(lockname, "/tmp/%.10s.l.1", str);
  1275. !     for (cp = lockname; *cp; cp++)
  1276. !         if (*cp == '/' || *cp == '[' || *cp == ']') *cp = '.';
  1277.       while ((fd = creat(lockname, 0444)) < 0) {
  1278.   #else /* !VMS */
  1279.       (void) strcpy(tempname, "/tmp/LTMP.XXXXXX");
  1280. ***************
  1281. *** 768,773 ****
  1282. --- 772,778 ----
  1283.   {
  1284.       long seqn;
  1285.       register FILE *fp;
  1286. +     extern char *mydomain();
  1287.   
  1288.       lock();
  1289.       fp = xfopen(SEQFILE, "r");
  1290. ***************
  1291. *** 784,793 ****
  1292.   #ifdef HIDDENNET
  1293.       if (strcmp(LOCALSYSNAME, FULLSYSNAME))
  1294.           (void) sprintf(hp->ident, "<%ld@%s.%s%s>", seqn, LOCALSYSNAME, FULLSYSNAME,
  1295. !         MYDOMAIN);
  1296.       else
  1297.   #endif /* !HIDDENNET */
  1298. !     (void) sprintf(hp->ident, "<%ld@%s%s>", seqn, FULLSYSNAME, MYDOMAIN);
  1299.   }
  1300.   
  1301.   /*
  1302. --- 789,798 ----
  1303.   #ifdef HIDDENNET
  1304.       if (strcmp(LOCALSYSNAME, FULLSYSNAME))
  1305.           (void) sprintf(hp->ident, "<%ld@%s.%s%s>", seqn, LOCALSYSNAME, FULLSYSNAME,
  1306. !         mydomain());
  1307.       else
  1308.   #endif /* !HIDDENNET */
  1309. !     (void) sprintf(hp->ident, "<%ld@%s%s>", seqn, FULLSYSNAME, mydomain());
  1310.   }
  1311.   
  1312.   /*
  1313. ***************
  1314. *** 989,994 ****
  1315. --- 994,1000 ----
  1316.       char buf[BUFLEN];
  1317.       char *fullname(), *getenv();
  1318.       int fd, n;
  1319. +     extern char *mydomain();
  1320.   
  1321.       if ((fn = getenv("NAME")) == NULL) {
  1322.           (void) sprintf(buf, "%s/%s", userhome, ".name");
  1323. ***************
  1324. *** 1007,1013 ****
  1325.           fn = fullname(logname);
  1326.   
  1327.       (void) sprintf(hp->path, "%s", logname);
  1328. !     (void) sprintf(hp->from, "%s@%s%s (%s)", logname, FULLSYSNAME, MYDOMAIN, fn);
  1329.   }
  1330.   
  1331.   /*
  1332. --- 1013,1019 ----
  1333.           fn = fullname(logname);
  1334.   
  1335.       (void) sprintf(hp->path, "%s", logname);
  1336. !     (void) sprintf(hp->from, "%s@%s%s (%s)", logname, FULLSYSNAME, mydomain(), fn);
  1337.   }
  1338.   
  1339.   /*
  1340. ***************
  1341. *** 1032,1104 ****
  1342.   
  1343.   #ifdef BATCH
  1344.   /*
  1345. !  * If the stdin begins with "#", we assume we have been fed a batched
  1346. !  * shell script which looks like this:
  1347.    *    #! rnews 1234
  1348.    *    article with 1234 chars
  1349.    *    #! rnews 4321
  1350.    *    article with 4321 chars
  1351. !  *
  1352. !  * In this case we just exec the unbatcher and let it unpack and call us back.
  1353. !  *
  1354. !  * Note that there is a potential security hole here.  If the batcher is
  1355. !  * /bin/sh, someone could ship you arbitrary stuff to run as shell commands.
  1356. !  * The main protection you have is that the effective uid will be news, not
  1357. !  * uucp and not the super user.  (That, plus the fact that BATCH is set to
  1358. !  * "unbatch" as the system is distributed.)  If you want to run a batched link
  1359. !  * and you are security conscious, do not use /bin/sh as the unbatcher.
  1360. !  * the thing to do is to change BATCH in your localize.sh file from /bin/sh
  1361. !  * to some restricted shell which can only run rnews.
  1362.    */
  1363.   checkbatch()
  1364.   {
  1365.       int c;
  1366.   
  1367. !     c = getc(infp);
  1368.       if (c != EOF)
  1369.           (void) ungetc(c, infp);
  1370.       clearerr(infp);
  1371. !     if (c == '#') {
  1372. !         char cmd[BUFLEN], unbatcher[BUFLEN], arg1[BUFLEN], arg2[BUFLEN];
  1373. !         register char *cp;
  1374. !         int n;
  1375.   
  1376. !         reset_infp();
  1377.           /*
  1378. !          * For efficiency, try and recognize the most common
  1379. !          * forms of batching and exec them directly
  1380.            */
  1381. !         n = read(0, cmd, BUFLEN-1);
  1382. !         if (n <= 0)    /* Can't happen */
  1383. !             xerror("can't read stdin to unbatch");
  1384. !         cmd[n] = '\0';
  1385. !         cp = index(cmd, '\n');
  1386. !         if (cp)
  1387. !             *cp = '\0';
  1388. !         /* now put stdin at the "right" place for the exec */
  1389. !         (void) lseek(0,1L+(long)(cp - cmd), 0);
  1390. !         if( strncmp(cmd, "#! cunbatch", 11) == 0) {
  1391. !             (void) strcpy(unbatcher, "/bin/sh");
  1392. !             (void) strcpy(arg1, "-c");
  1393. !             (void) sprintf(arg2, "%s/compress -d | %s/%s",
  1394. !                 LIB, LIB, BATCH);
  1395. !         } else if (strncmp(cmd, "#! c7unbatch", 12) == 0) {
  1396. !             (void) strcpy(unbatcher, "/bin/sh");
  1397. !             (void) strcpy(arg1, "-c");
  1398. !             (void) sprintf(arg2,
  1399. !                 "%s/decode | %s/compress -d | %s/%s",
  1400. !                 LIB, LIB, LIB, BATCH);
  1401. !         } else {
  1402. !             (void) lseek(0, 0L, 0);
  1403. !             (void) sprintf(unbatcher, "%s/%s", LIB, BATCH);
  1404. !             arg1[0] = '\0';
  1405. !             arg2[0] = '\0';
  1406. !         }
  1407. !         execl(unbatcher, "news-unpack", arg1, arg2, (char *)0);
  1408. !         xerror("Unable to exec %s to unpack news.", unbatcher);
  1409.       }
  1410.   }
  1411.   
  1412.   /*
  1413.    * We've already done a read on stdin, and we want to seek back to the
  1414.    * beginning.  We want the real file descriptor (beyond buffers) to
  1415. --- 1038,1330 ----
  1416.   
  1417.   #ifdef BATCH
  1418.   /*
  1419. !  * If the stdin begins with "#" the input is some kind of batch.  if
  1420. !  * the first line is:
  1421. !  *    #!cunbatch
  1422. !  * or
  1423. !  *    #!c7unbatch
  1424. !  * then fork off a pipe to do the either a
  1425. !  *    "compress -d"
  1426. !  * or a
  1427. !  *    "decode | compress -d"
  1428. !  * and check their output for more batch headers.  They probably
  1429. !  * contain a batch format that looks like this:
  1430.    *    #! rnews 1234
  1431.    *    article with 1234 chars
  1432.    *    #! rnews 4321
  1433.    *    article with 4321 chars
  1434. !  * If so, then for each article, copy the indicated number of chars into
  1435. !  * a temp file, fork a copy of ourselves, make its input the temp file,
  1436. !  * and allow the copy to process the article.  This avoids an exec of
  1437. !  * rnews for each article.
  1438.    */
  1439. + 
  1440.   checkbatch()
  1441.   {
  1442.       int c;
  1443.   
  1444. !     while ((c = getc(infp)) == '#') {
  1445. !         /* some kind of batch, investigate further */
  1446. !         int i;
  1447. !         char cmd[BUFLEN];
  1448. !         cmd[0] = c;
  1449. !         fgets(cmd + 1, BUFLEN, infp);
  1450. !         if (strncmp(cmd, "#! cunbatch", 11) == 0) {
  1451. !             reset_infp();
  1452. !             i = strlen(cmd);
  1453. !             (void) lseek(0, (long) i, 0);    /* position STDIN for
  1454. !                              * exec */
  1455. !             (void) sprintf(cmd, "%s/compress", LIB);
  1456. !             input_pipe(cmd, "compress", "-d", (char *) 0);
  1457. !             continue;    /* look for the #! rnews */
  1458. !         } else if (strncmp(cmd, "#! c7unbatch", 12) == 0) {
  1459. !             reset_infp();
  1460. !             i = strlen(cmd);
  1461. !             (void) lseek(0, (long) i, 0);    /* position STDIN for
  1462. !                              * exec */
  1463. !             (void) sprintf(cmd, "%s/decode | %s/compress -d", LIB, LIB);
  1464. !             input_pipe("/bin/sh", "news-unpack", "-c", cmd);
  1465. !             continue;    /* look for the #! rnews */
  1466. !         } else if (strncmp(cmd, "#! rnews", 8) == 0) {
  1467. !             /* instead of execing unbatch do it ourselves */
  1468. !             register int fd, rc, wc;
  1469. !             int piped[2];
  1470. !             register long size, asize;
  1471. !             char *filename;
  1472. !             int pid, wpid, exstat;
  1473. !             char *mktemp();
  1474. !             long atol();
  1475. ! #define CPBFSZ 8192
  1476. !             char buf[CPBFSZ];
  1477. ! 
  1478. !             filename = 0;
  1479. !             do {
  1480. !                 while (strncmp(cmd, "#! rnews ", 9)) {
  1481. !                     fprintf(stderr, "out of sync, skipping %s\n", cmd);
  1482. !                     if (fgets(cmd, BUFLEN, infp) == NULL)
  1483. !                         exit(0);
  1484. !                 }
  1485. !                 asize = atol(cmd + 9);
  1486. !                 if (asize <= 0)
  1487. !                     xerror("checkbatch: bad batch count %ld", asize);
  1488. !                 fd = -1;
  1489. !                 size = asize;
  1490. !                 do {
  1491. !                     if (size > CPBFSZ)
  1492. !                         rc = CPBFSZ;
  1493. !                     else
  1494. !                         rc = size;
  1495. !                     rc = fread(buf, 1, rc, infp);
  1496. !                     if (rc <= 0)
  1497. !                         break;
  1498. !                     if (fd < 0) {
  1499. !                         if (rc == asize)
  1500. !                             break;    /* fits in buffer */
  1501. !                         if (!filename)
  1502. !                             filename = mktemp("/tmp/unbnewsXXXXXX");
  1503. !                         if ((fd = creat(filename, 0666)) < 0) {
  1504. !                             fprintf(stderr, "rnews: creat of \"%s\" failed",
  1505. !                                 filename);
  1506. !                             perror(" ");
  1507. !                             exit(1);
  1508. !                         }
  1509. !                     }
  1510. !                     wc = write(fd, buf, rc);    /* write to temp file */
  1511. !                     if (wc != rc) {
  1512. !                         fprintf(stderr, "write of %d to \"%s\" returned %d",
  1513. !                             rc, filename, wc);
  1514. !                         perror(" ");
  1515. !                         exit(1);
  1516. !                     }
  1517. !                     size -= rc;
  1518. !                 } while (size > 0);
  1519. !                 if (fd >= 0)
  1520. !                     (void) close(fd);
  1521. ! 
  1522. !                 /*
  1523. !                  * If we got a truncated batch, don't process
  1524. !                  * the last article; it will probably be
  1525. !                  * received again. 
  1526. !                  */
  1527. !                 if ((rc < asize) && (size > 0))
  1528. !                     break;
  1529. ! 
  1530. !                 /*
  1531. !                  * This differs from the old unbatcher in
  1532. !                  * that we don't exec rnews, mainly because
  1533. !                  * we ARE rnews.  Instead we fork off a copy
  1534. !                  * of ourselves for each article and allow it
  1535. !                  * to process. 
  1536. !                  */
  1537. !                 if (rc == asize) {
  1538. !                     /*
  1539. !                      * article fits in buffer, use a pipe
  1540. !                      * instead of a temporary file. 
  1541. !                      */
  1542. !                     if (pipe(piped) != 0) {
  1543. !                         perror("checkbatch: pipe() failed");
  1544. !                         exit(1);
  1545. !                     }
  1546. !                 }
  1547. !                 while ((pid = fork()) == -1) {
  1548. !                     fprintf(stderr, "fork failed, waiting...\r\n");
  1549. !                     sleep(60);
  1550. !                 }
  1551. !                 if (pid == 0) {
  1552. !                     if (rc == asize) {
  1553. !                         /* article fits in buffer
  1554. !                          * make the output of the
  1555. !                          * pipe for STDIN 
  1556. !                          */
  1557. !                         (void) fclose(infp);
  1558. !                         /* redundant but why not */
  1559. !                         (void) close(0);
  1560. !                         if ((i = dup(piped[0])) != 0)
  1561. !                             xerror("dup() returned %d, should be 0", i);
  1562. !                         (void) close(piped[0]);
  1563. !                         (void) close(piped[1]);
  1564. !                         infp = fdopen(0, "r");
  1565. !                     } else    /* supstitute temp file as
  1566. !                          * input */
  1567. !                         freopen(filename, "r", infp);
  1568. !                     return;    /* from checkbatch as if
  1569. !                          * normal article */
  1570. !                 }
  1571. !                 /* parent of fork */
  1572. !                 if (rc == asize) {
  1573. !                     /* article fits in buffer */
  1574. !                     wc = write(piped[1], buf, rc);
  1575. !                     if (wc != rc) {
  1576. !                         fprintf(stderr, "write of %d to pipe returned %d",
  1577. !                             rc, wc);
  1578. !                         perror("rnews: write");
  1579. !                         exit(1);
  1580. !                     }
  1581. !                     (void) close(piped[0]);
  1582. !                     (void) close(piped[1]);
  1583. !                 }
  1584. !                 while ((wpid = wait(&exstat)) >= 0 && wpid != pid);
  1585. !             } while (fgets(cmd, BUFLEN, infp) != NULL);
  1586. !             (void) unlink(filename);
  1587. !             exit(0);/* all done */
  1588. ! 
  1589. !         } else {
  1590. !             reset_infp();
  1591. !             i = strlen(cmd);
  1592. !             (void) lseek(0, (long)i, 0);
  1593. !             docmd(cmd);
  1594. !             xxit(0);
  1595. !         }
  1596. !     }            /* while a batch */
  1597.       if (c != EOF)
  1598.           (void) ungetc(c, infp);
  1599.       clearerr(infp);
  1600. ! }
  1601.   
  1602. ! /*
  1603. !  * The input requires some processing so fork and exec the indicated command
  1604. !  * with its output piped to our input. 
  1605. !  */
  1606. ! static 
  1607. ! input_pipe(cmd, arg0, arg1, arg2)
  1608. ! char *cmd, *arg0, *arg1, *arg2;
  1609. ! {
  1610. !     int i, pid;
  1611. !     int piped[2];
  1612. ! 
  1613. !     if (pipe(piped) != 0) {
  1614. !         perror("checkbatch: pipe() failed");
  1615. !         exit(1);
  1616. !     }
  1617. !     fflush(stdout);
  1618. !     while ((pid = fork()) == -1) {
  1619. !         perror("checkbatch: fork failed, waiting");
  1620. !         sleep(60);
  1621. !     }
  1622. !     if (pid == 0) {        /* child process */
  1623.           /*
  1624. !          * setup a pipe such that the exec'ed process will read our
  1625. !          * input file and write to the pipe 
  1626.            */
  1627. !         (void) close(1);
  1628. !         if ((i = dup(piped[1])) != 1)
  1629. !             xerror("dup() returned %d, should be 1", i);
  1630. !         (void) close(piped[0]);
  1631. !         (void) close(piped[1]);
  1632. !         execl(cmd, arg0, arg1, arg2, (char *) 0);
  1633. !         perror("checkbatch");
  1634. !         xerror("Unable to exec %s to unpack news.", cmd);
  1635. !     } else {        /* parent process */
  1636. !         /* make the output of the pipe for STDIN */
  1637. !         (void) fclose(infp);
  1638. !         (void) close(0);
  1639. !         if ((i = dup(piped[0])) != 0)
  1640. !             xerror("dup() returned %d, should be 0", i);
  1641. !         (void) close(piped[0]);
  1642. !         (void) close(piped[1]);
  1643. !         /*
  1644. !          * there should be a way to clear any buffered input and just
  1645. !          * replace file descriptor 0 but I can't find a portable way. 
  1646. !          */
  1647. !         infp = fdopen(0, "r");
  1648.       }
  1649.   }
  1650.   
  1651. + #define MAXARGS 32
  1652. + 
  1653. + docmd(p)
  1654. + register char *p;
  1655. + {
  1656. +     char *args[MAXARGS];
  1657. +     register char **ap = args;
  1658. +     char path[BUFSIZ];
  1659. +     char *rindex(), *cp;
  1660. + 
  1661. +     while (*p && !isspace(*p))        /* skip leading #! crud */
  1662. +         p++;
  1663. + 
  1664. +     while (isspace(*p))
  1665. +         p++;
  1666. + 
  1667. +     while (*p != '\0') {
  1668. +         *ap++ = p;
  1669. +         if (ap >= &args[MAXARGS]) {
  1670. +             logerr("inews: unbatch: Too many args to %s", args[0]);
  1671. +             exit(2);
  1672. +         }
  1673. +         while (*p && !isspace(*p))
  1674. +             p++;
  1675. +         if (*p)
  1676. +             *p++ = '\0';
  1677. +         while (isspace(*p))
  1678. +             p++;
  1679. +     }
  1680. +     *ap = (char *)0;
  1681. + 
  1682. +     if (ap == args) {
  1683. +         logerr("inews: unbatch: no command to execute");
  1684. +         exit(2);
  1685. +     }
  1686. + 
  1687. +     /* strip off any leading pathname in case someone gets tricky */
  1688. +     cp = rindex(args[0], '/');
  1689. +     if (cp++ == NULL)
  1690. +         cp = args[0];
  1691. + 
  1692. + # ifdef HOME
  1693. +     sprintf(path, "%s/%s/%s", logdir(HOME), LIBDIR, cp);
  1694. + # else /* !HOME */
  1695. +     sprintf(path, "%s/%s", LIBDIR, cp);
  1696. + # endif /* HOME */
  1697. + 
  1698. +     /*
  1699. +      * "path" is absolute, no searching is needed,  we use
  1700. +      * 'execvp' solely so that sh scripts will be handled
  1701. +      */
  1702. +     (void) execvp(path, args);
  1703. +     perror(path);
  1704. +     xxit(2);
  1705. + }
  1706.   /*
  1707.    * We've already done a read on stdin, and we want to seek back to the
  1708.    * beginning.  We want the real file descriptor (beyond buffers) to
  1709.