![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inews.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / news / src|
Return to inews.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / news / src |
1.1 root 1: /*
2: * This software is Copyright (c) 1986 by Rick Adams.
3: *
4: * Permission is hereby granted to copy, reproduce, redistribute or
5: * otherwise use this software as long as: there is no monetary
6: * profit gained specifically from the use or reproduction or this
7: * software, it is not sold, rented, traded or otherwise marketed, and
8: * this copyright notice is included prominently in any copy
9: * made.
10: *
11: * The author make no claims as to the fitness or correctness of
12: * this software for any use whatsoever, and it is provided as is.
13: * Any use of this software is at the user's own risk.
14: *
15: * inews - insert, receive, and transmit news articles.
16: *
17: */
18:
19: #ifdef SCCSID
20: static char *SccsId = "@(#)inews.c 2.82 10/15/87";
21: #endif /* SCCSID */
22:
23: #include "iparams.h"
24:
25: # ifdef LOCKF
26: # include <unistd.h>
27: # include <fcntl.h>
28:
29: # if defined(F_RDLCK) && defined(F_SETLK)
30: struct flock news_lock;
31: # endif /* F_RDLCK && F_SETLK */
32: # endif /* LOCKF */
33:
34: #ifdef BSD4_2
35: # include <sys/file.h>
36: #else /* !BSD4_2 */
37: # if defined(USG) && !defined(LOCKF)
38: # include <fcntl.h>
39: # endif /* USG */
40: #endif /* !BSD4_2 */
41: /* local defines for inews */
42:
43: #define OPTION 0 /* pick up an option string */
44: #define STRING 1 /* pick up a string of arguments */
45:
46: #define UNKNOWN 0001 /* possible modes for news program */
47: #define UNPROC 0002 /* Unprocessed input */
48: #define PROC 0004 /* Processed input */
49: #define CONTROL 0010 /* Control Message */
50: #define CREATENG 0020 /* Create a new newsgroup */
51:
52: #define DONT_SPOOL 0
53: #define DO_SPOOL 1
54: #define EXPIRE_RUNNING 2
55: int spool_news = DONT_SPOOL;
56:
57: extern char histline[];
58: char forgedname[NAMELEN]; /* A user specified -f option. */
59: /* Fake sys line in case they forget their own system */
60: struct srec dummy_srec = { "MEMEME", "", "all", "", "" };
61:
62: char *Progname = "inews"; /* used by xerror to identify failing program */
63:
64: struct { /* options table. */
65: char optlet; /* option character. */
66: char filchar; /* if to pickup string, fill character. */
67: int flag; /* TRUE if have seen this opt. */
68: int oldmode; /* OR of legal input modes. */
69: int newmode; /* output mode. */
70: char *buf; /* string buffer */
71: } *optpt, options[] = { /*
72: optlet filchar flag oldmode newmode buf */
73: 't', ' ', FALSE, UNPROC, UNKNOWN, header.title,
74: 'n', NGDELIM, FALSE, UNPROC, UNKNOWN, header.nbuf,
75: 'd', '\0', FALSE, UNPROC, UNKNOWN, header.distribution,
76: 'e', ' ', FALSE, UNPROC, UNKNOWN, header.expdate,
77: 'p', '\0', FALSE, UNKNOWN|PROC, PROC, filename,
78: 'f', '\0', FALSE, UNPROC, UNKNOWN, forgedname,
79: 'F', ' ', FALSE, UNPROC, UNKNOWN, header.followid,
80: 'c', ' ', FALSE, UNKNOWN,UNKNOWN, header.ctlmsg,
81: 'C', ' ', FALSE, UNKNOWN,CREATENG, header.ctlmsg,
82: #define hflag options[9].flag
83: 'h', '\0', FALSE, UNPROC, UNKNOWN, filename,
84: #define oflag options[10].flag
85: 'o', '\0', FALSE, UNPROC, UNKNOWN, header.organization,
86: #define Mflag options[11].flag
87: 'M', '\0', FALSE, UNPROC, UNKNOWN, filename,
88: 'a', '\0', FALSE, UNPROC, UNKNOWN, header.approved,
89: 'U', '\0', FALSE, PROC, PROC, filename,
90: #define Sflag options[14].flag
91: 'S', '\0', FALSE, UNKNOWN|PROC, UNPROC, filename,
92: 'x', '\0', FALSE, UNPROC, UNKNOWN, not_here,
93: 'r', '\0', FALSE, UNPROC, UNKNOWN, header.replyto,
94: '\0', '\0', 0, 0, 0, (char *)NULL
95: };
96:
97: FILE *mailhdr();
98: extern int errno;
99:
100: struct timeb Now;
101:
102: /*
103: * Authors:
104: * Matt Glickman [email protected]
105: * Mark Horton [email protected]
106: * Stephen Daniels [email protected]
107: * Tom Truscott [email protected]
108: * Rick Adams [email protected]
109: * IHCC version adapted by:
110: * Larry Marek [email protected]
111: */
112: main(argc, argv)
113: int argc;
114: register char **argv;
115: {
116: int state; /* which type of argument to pick up */
117: int tlen, len; /* temps for string processing routine */
118: register char *ptr; /* pointer to rest of buffer */
119: int filchar; /* fill character (state = STRING) */
120: char *user = NULL, *home = NULL; /* environment temps */
121: struct passwd *pw; /* struct for pw lookup */
122: struct group *gp; /* struct for group lookup */
123: register int i;
124: FILE *mfd; /* mail file file-descriptor */
125:
126: /* uuxqt doesn't close all its files */
127: for (i = 3; !close(i); i++)
128: ;
129: /* set up defaults and initialize. */
130: mode = UNKNOWN;
131: infp = stdin;
132: pathinit();
133: savmask = umask(N_UMASK); /* set up mask */
134: ptr = rindex(*argv, '/');
135: if (!ptr)
136: ptr = *argv - 1;
137: actfp = xfopen(ACTIVE, "r+");
138: #ifdef LOCKF
139: # if defined(F_RDLCK) && defined(F_SETLK)
140: news_lock.l_type = F_RDLCK;
141: if (fcntl(fileno(actfp), F_SETLK, &news_lock) < 0) {
142: # else /* !F_RDLCK */
143: if (lockf(fileno(actfp), F_TLOCK, 0L) < 0) {
144: # endif /* !F_RDLCK */
145: if (errno != EAGAIN && errno != EACCES)
146: #else /* !LOCKF */
147: #ifdef BSD4_2
148: if (flock(fileno(actfp), LOCK_SH|LOCK_NB) < 0) {
149: if (errno != EWOULDBLOCK)
150: #else /* !BSD4_2 */
151: sprintf(bfr, "%s.lock", ACTIVE);
152: if (LINK(ACTIVE, bfr) < 0) {
153: if (errno != EEXIST)
154: #endif /* V7 */
155: #endif /* !BSD4_2 */
156: xerror("Can't lock %s: %s", ACTIVE, errmsg(errno));
157: spool_news = EXPIRE_RUNNING;
158: } else {
159: #ifdef SPOOLNEWS
160: if (argc > 1 && !strcmp(*(argv+1), "-S")) {
161: argc--;
162: argv++;
163: Sflag = 1;
164: } else
165: spool_news = DO_SPOOL;
166:
167: #endif /* SPOOLNEWS */
168: }
169: if (spool_news != EXPIRE_RUNNING) {
170: /* only unlock if we locked */
171: #ifdef LOCKF
172: (void) lockf(fileno(actfp), F_ULOCK, 0L);
173: #else /* !LOCKF */
174: #ifdef BSD4_2
175: (void) flock(fileno(actfp), LOCK_UN);
176: #else /* !BSD4_2 */
177: (void) UNLINK(bfr);
178: #endif /* V7 */
179: #endif /* !BSD4_2 */
180: } else { /* expire is running */
181: if (argc > 1 && !strcmp(*(argv+1), "-S"))
182: exit(42); /* inform rnews -U by exit status */
183: }
184: if (argc > 1 && !strcmp(*(argv+1), "-U")) {
185: /* can't unspool while things are locked */
186: if (spool_news == EXPIRE_RUNNING)
187: xxit(0);
188: dounspool();
189: /* NOT REACHED */
190: }
191:
192: if (!STRNCMP(ptr+1, "rnews", 5)) {
193: mode = PROC;
194: if (spool_news != DONT_SPOOL) {
195: dospool((char *)NULL, FALSE);
196: /* NOT REACHED */
197: }
198: #ifdef NICENESS
199: if (nice(0) < NICENESS)
200: (void) nice(NICENESS);
201: #endif /* NICENESS */
202: } else {
203: /* it's not rnews, so it must be inews */
204: if (argc < 2)
205: goto usage;
206: #ifndef SPOOLINEWS
207: if (spool_news == DO_SPOOL)
208: spool_news = DONT_SPOOL;
209: #endif /* SPOOLINEWS */
210: }
211:
212: state = OPTION;
213: header.title[0] = header.nbuf[0] = filename[0] = '\0';
214:
215: /* check for existence of special files */
216: #ifdef DBM
217: chkfile(ARTFILE);
218: #else
219: chkdir(ARTFILE);
220: #endif /* DBM */
221: chkfile(ACTIVE);
222: SigTrap = FALSE; /* true if a signal has been caught */
223: if (mode != PROC) {
224: (void) signal(SIGHUP, onsig);
225: (void) signal(SIGINT, onsig);
226: }
227: /*
228: * Catch "filesize exceeded" signals on 4.2BSD systems
229: * - the history files may exceed this limit.
230: */
231: #ifdef SIGXFSZ
232: (void) signal(SIGXFSZ, SIG_IGN);
233: #endif /* SIGXFSZ */
234: uid = getuid();
235: gid = getgid();
236: duid = geteuid();
237: dgid = getegid();
238: (void) ftime(&Now);
239: if (uid == 0 && duid == 0) {
240: /*
241: * Must go through with this kludge since
242: * some systems do not honor the setuid bit
243: * when root invokes a setuid program.
244: */
245: if ((pw = getpwnam(NEWSUSR)) == NULL)
246: xerror("Cannot get NEWSU pw entry");
247:
248: duid = pw->pw_uid;
249: if ((gp = getgrnam(NEWSGRP)) == NULL)
250: xerror("Cannot get NEWSG gr entry");
251: dgid = gp->gr_gid;
252: (void) setgid(dgid);
253: (void) setuid(duid);
254: }
255:
256: #ifndef DOGETUSER
257: /*
258: * Force the use of 'getuser()' to prevent forgery of articles
259: * by just changing $LOGNAME
260: */
261: if (isatty(fileno(stderr))) {
262: if ((user = getenv("USER")) == NULL)
263: user = getenv("LOGNAME");
264: if ((home = getenv("HOME")) == NULL)
265: home = getenv("LOGDIR");
266: }
267: #endif /* !DOGETUSER */
268: if (user == NULL || home == NULL)
269: getuser();
270: else {
271: if (STRCMP(username, "Unknown") == 0 || username[0] == 0) {
272: username = AllocCpy(user);
273: }
274: userhome = AllocCpy(home);
275: }
276: getuser();
277:
278: /* loop once per arg. */
279:
280: ++argv; /* skip first arg, which is prog name. */
281:
282: while (--argc) {
283: if (state == OPTION) {
284: if (**argv != '-') {
285: xerror("Bad option string \"%s\"", *argv);
286: }
287: while (*++*argv != '\0') {
288: for (optpt = options; optpt->optlet != '\0'; ++optpt) {
289: if (optpt->optlet == **argv)
290: goto found;
291: }
292: /* unknown option letter */
293: usage:
294: fprintf(stderr, "usage: inews -t title");
295: fprintf(stderr, " [ -n newsgroups ]");
296: fprintf(stderr, " [ -e expiration date ]\n");
297: fprintf(stderr, "\t[ -f sender]\n\n");
298: xxit(1);
299:
300: found:;
301: if (optpt->flag == TRUE || (mode != UNKNOWN &&
302: (mode&optpt->oldmode) == 0)) {
303: xerror("Bad %c option", **argv);
304: }
305: if (mode == UNKNOWN)
306: mode = optpt->newmode;
307: filchar = optpt->filchar;
308: optpt->flag = TRUE;
309: state = STRING;
310: ptr = optpt->buf;
311: len = BUFLEN;
312: }
313:
314: argv++; /* done with this option arg. */
315:
316: } else {
317:
318: /*
319: * Pick up a piece of a string and put it into
320: * the appropriate buffer.
321: */
322: if (**argv == '-') {
323: state = OPTION;
324: argc++; /* uncount this arg. */
325: continue;
326: }
327:
328: if ((tlen = strlen(*argv)) >= len)
329: xerror("Argument string too long");
330: (void) strcpy(ptr, *argv++);
331: ptr += tlen;
332: if (*(ptr-1) != filchar)
333: *ptr++ = filchar;
334: len -= tlen + 1;
335: *ptr = '\0';
336: }
337: }
338:
339: /*
340: * ALL of the command line has now been processed. (!)
341: */
342:
343: if (*filename) {
344: infp = freopen(filename, "r", stdin);
345: if (infp == NULL)
346: xerror("freopen(%s): %s", filename, errmsg(errno));
347: } else
348: infp = stdin;
349:
350: tty = isatty(fileno(infp));
351:
352: if (mode == CREATENG)
353: createng();
354:
355: if (header.ctlmsg[0] != '\0' && header.title[0] == '\0')
356: (void) strcpy(header.title, header.ctlmsg);
357:
358: if (*header.nbuf) {
359: lcase(header.nbuf);
360: ptr = index(header.nbuf, '\0');
361: if (ptr[-1] == NGDELIM)
362: *--ptr = '\0';
363: }
364: (void) nstrip(header.title);
365: (void) nstrip(header.expdate);
366: (void) nstrip(header.followid);
367: if (mode != PROC) {
368: if (hflag) {
369: header.path[0] = '\0';
370: (void) hread(&header, infp, FALSE);
371: /* there are certain fields we won't let him specify. */
372: if (header.from[0]) {
373: (void) fixfrom(&header);
374: if (Sflag && !Mflag && !header.approved[0] &
375: !header.sender[0]) {
376: register char *p;
377: strcpy(bfr, header.from);
378: p = strpbrk(bfr, "@ !");
379: if (p)
380: *p = '\0';
381: if ((pw = getpwnam(bfr)) != NULL) {
382: uid = pw->pw_uid;
383: gid = pw->pw_gid;
384: username = AllocCpy(bfr);
385: }
386: } else {
387: (void) strcpy(forgedname, header.from);
388: header.from[0] = '\0';
389: }
390: }
391: if (!header.approved[0])
392: Mflag = FALSE;
393: header.sender[0] = '\0';
394: if (header.subdate[0] && cgtdate(header.subdate) < 0)
395: header.subdate[0] = '\0';
396: }
397:
398: if (header.ident[0] == '\0')
399: getident(&header);
400:
401: if (forgedname[0]) {
402: register char *p1;
403: if (Mflag)
404: sprintf(header.path, "%s!%s",
405: PATHSYSNAME, username);
406: else if (!header.path[0]) {
407: (void) strcpy(header.path, forgedname);
408:
409: if ((p1 = strpbrk(header.path, " (<")) != NULL)
410: *p1 = '\0';
411: }
412: if (!Mflag && !strpbrk(forgedname, "@ (<"))
413: (void) sprintf(header.from,"%s@%s",
414: forgedname, FROMSYSNAME);
415: else
416: (void) strncpy(header.from, forgedname, BUFLEN);
417:
418: (void) sprintf(header.sender, "%s@%s",
419: username, FROMSYSNAME);
420: } else {
421: gensender(&header, username);
422: }
423: #ifdef MYORG
424: if (header.organization[0] == '\0' && !Mflag &&
425: header.sender[0] == '\0') {
426: strncpy(header.organization, MYORG, BUFLEN);
427: if (STRNCMP(header.organization, "Frobozz", 7) == 0)
428: header.organization[0] = '\0';
429: if (ptr = getenv("ORGANIZATION"))
430: strncpy(header.organization, ptr, BUFLEN);
431: /*
432: * Note that the organization can also be turned off by
433: * setting it to the null string, either in MYORG or
434: * $ORGANIZATION in the environment.
435: */
436: if (header.organization[0] == '/') {
437: mfd = fopen(header.organization, "r");
438: if (mfd) {
439: (void) fgets(header.organization, sizeof header.organization, mfd);
440: (void) fclose(mfd);
441: } else {
442: logerr("Couldn't open %s",
443: header.organization);
444: header.organization[0] = '\0';
445: }
446: ptr = index(header.organization, '\n');
447: if (ptr)
448: *ptr = '\0';
449: }
450: }
451: #endif /* MYORG */
452: }
453:
454: /* Authorize newsgroups. */
455: if (mode == PROC) {
456: checkbatch();
457: (void) signal(SIGHUP, SIG_IGN);
458: (void) signal(SIGINT, SIG_IGN);
459: (void) signal(SIGQUIT, SIG_IGN);
460: header.ident[0] = '\0';
461: if (hread(&header, infp, TRUE) == NULL)
462: xerror("%s: Inbound news is garbled", filename);
463: input(bfr[0] != '\n');
464: }
465: /* always check history */
466:
467: if (history(&header)) {
468: log("Duplicate article %s rejected. Path: %s",
469: header.ident, header.path);
470: xxit(0);
471: }
472:
473: /* Easy way to make control messages, since all.all.ctl is unblessed */
474: if (mode != PROC && PREFIX(header.title, "cmsg ") && header.ctlmsg[0] == 0)
475: (void) strcpy(header.ctlmsg, &header.title[5]);
476: is_ctl = mode != CREATENG &&
477: (ngmatch(header.nbuf, "all.all.ctl,") || header.ctlmsg[0]);
478: #ifdef DEBUG
479: fprintf(stderr,"is_ctl set to %d\n", is_ctl);
480: #endif
481:
482: if (mode != CREATENG) {
483: if (!*header.title)
484: error("No title, ng %s from %s", header.nbuf,
485: header.from);
486: if (!*header.nbuf)
487: (void) strcpy(header.nbuf, DFLTNG);
488: }
489:
490: if (mode <= UNPROC) {
491: #ifdef FASCIST
492: if (uid && uid != ROOTID && fascist(username, header.nbuf))
493: xerror("User %s is not authorized to post to newsgroup %s",
494: username, header.nbuf);
495: #endif /* FASCIST */
496: ctlcheck();
497: }
498:
499: if (mode == CREATENG)
500: createng();
501:
502: /* Determine input. */
503: if (mode != PROC)
504: input(FALSE);
505: if (header.intnumlines == 0 && !is_ctl)
506: error("%s rejected: no text lines", header.ident);
507:
508: dates(&header);
509:
510: /* Do the actual insertion. */
511: insert();
512: /* NOTREACHED */
513: }
514:
515: /* check for existence of file */
516: static chkfile(f)
517: char *f;
518: {
519: FILE *mfd; /* mail file file-descriptor */
520: char cbuf[BUFLEN]; /* command buffer */
521:
522: if (rwaccess(f))
523: return; /* everything is ok */
524: mfd = mailhdr((struct hbuf *)NULL,
525: exists(f) ? "Unwritable files!" : "Missing files!");
526: if (mfd == NULL)
527: return;
528: putc('\n', mfd);
529: fprintf(mfd, "System: %s\n\nThere was a problem with %s!!\n",
530: LOCALSYSNAME, f);
531: (void) sprintf(cbuf, "touch %s;chmod 666 %s", f, f);
532: (void) system(cbuf);
533: if (rwaccess(f))
534: fprintf(mfd, "The problem has been taken care of.\n");
535: else
536: fprintf(mfd, "Corrective action failed - check suid bits.\n");
537: (void) mclose(mfd);
538: }
539:
540: #ifndef DBM
541: /* check for existence of directory */
542: static chkdir(d)
543: char *d;
544: {
545: FILE *mfd; /* mail file file-descriptor */
546: char dir[BUFLEN]; /* holds directory name */
547:
548: sprintf(dir, "%s.d", d);
549: if (eaccess(dir, 07) == 0)
550: return; /* everything is ok */
551: mfd = mailhdr((struct hbuf *)NULL,
552: exists(dir) ? "Unwritable directories" : "Missing directories");
553: if (mfd == NULL)
554: return;
555: putc('\n', mfd);
556: fprintf(mfd, "System: %s\n\nThere was a problem with %s!\n",
557: LOCALSYSNAME, dir);
558: (void) mkdir(dir, 0775);
559: if (eaccess(dir, 07) == 0)
560: fprintf(mfd, "The problem has been taken care of.\n");
561: else
562: fprintf(mfd, "Corrective action failed - check suid bits.\n");
563: (void) mclose(mfd);
564: }
565:
566: /*
567: * This version of access checks against effective uid and effective gid
568: */
569: eaccess(name, mode)
570: register char *name;
571: register int mode;
572: {
573: struct stat statb;
574: int euserid = geteuid();
575: int egroupid = getegid();
576:
577: if (stat(name, &statb) == 0) {
578: if (euserid == 0) {
579: if ((statb.st_mode&S_IFMT) != S_IFREG || mode != 1)
580: return 0;
581: /* root needs execute permission for someone */
582: mode = (S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6));
583: }
584: else if (euserid == statb.st_uid)
585: mode <<= 6;
586: else if (egroupid == statb.st_gid)
587: mode <<= 3;
588: #ifdef BSD4_2
589: /* in BSD4_2 you can be in several groups */
590: else {
591: int groups[NGROUPS];
592: register int n;
593: n = getgroups(NGROUPS,groups);
594: while(--n >= 0) {
595: if(groups[n] == statb.st_gid) {
596: mode <<= 3;
597: break;
598: }
599: }
600: }
601: #endif /* BSD4_2 */
602:
603: if (statb.st_mode & mode)
604: return 0;
605: }
606: return -1;
607: }
608: #endif /* DBM */
609:
610: dospool(batchcmd, dolhwrite)
611: char *batchcmd;
612: int dolhwrite;
613: {
614: register int c;
615: register FILE *sp;
616: register struct tm *tp;
617: time_t t;
618: char buf[BUFLEN], sfile[BUFLEN];
619: extern struct tm *gmtime();
620:
621: (void) sprintf(sfile, "%s/.spXXXXXX", SPOOL);
622: sp = xfopen(mktemp(sfile), "w");
623: if (batchcmd != NULL) {
624: if (not_here[0] != '\0')
625: fprintf(sp, "%s -x %s\n", batchcmd, not_here);
626: else
627: fprintf(sp, "%s\n", batchcmd);
628: } else
629: if (not_here[0] != '\0')
630: fprintf(sp, "#! inews -x %s -p\n", not_here);
631: if (dolhwrite)
632: lhwrite(&header, sp);
633: while ((c = getc(infp)) != EOF)
634: putc(c, sp);
635: fclose(sp);
636:
637: (void) time(&t);
638: tp = gmtime(&t);
639: /* This file name "has to" be unique (right?) */
640: #ifdef USG
641: (void) sprintf(buf, "%s/.rnews/%2.2d%2.2d%2.2d%2.2d%2.2d%x",
642: #else
643: #ifdef VMS
644: /* Eunice doesn't like dots in directory names */
645: (void) sprintf(buf, "%s/+rnews/%02d%02d%02d%02d%02d%x",
646: #else /* V7 */
647: (void) sprintf(buf, "%s/.rnews/%02d%02d%02d%02d%02d%x",
648: #endif /* V7 */
649: #endif /* VMS */
650: SPOOL,
651: tp->tm_year, tp->tm_mon+1, tp->tm_mday,
652: tp->tm_hour, tp->tm_min, getpid());
653:
654: #ifdef IHCC
655: log("Spooling %s into %s", header.ident, (rindex(buf,'/') + 1));
656: #endif /* IHCC */
657:
658: if (LINK(sfile, buf) < 0) {
659: char dbuf[BUFLEN];
660: #ifdef VMS
661: sprintf(dbuf, "%s/+rnews", SPOOL);
662: #else /* !VMS */
663: sprintf(dbuf, "%s/.rnews", SPOOL);
664: #endif /* !VMS */
665: if (mkdir(dbuf, 0777&~N_UMASK) < 0)
666: xerror("Cannot mkdir %s: %s", dbuf, errmsg(errno));
667: if (LINK(sfile, buf) < 0)
668: xerror("Cannot link(%s,%s): %s", sfile, buf,
669: errmsg(errno));
670: }
671: (void) UNLINK(sfile);
672: xxit(0);
673: /* NOTREACHED */
674: }
675:
676: /*
677: * Create a newsgroup
678: */
679: createng()
680: {
681: register char *cp;
682:
683: /*
684: * Only certain users are allowed to create newsgroups
685: */
686: if (uid != ROOTID && uid != duid && uid) {
687: logerr("Please contact one of the local netnews people");
688: xerror("to create group \"%s\" for you", header.ctlmsg);
689: }
690: if (header.distribution[0] == '\0')
691: #ifdef ORGDISTRIB
692: strcpy(header.distribution, ORGDISTRIB);
693: #else /* !ORGDISTRIB */
694: strcpy(header.distribution, "local");
695: #endif /* !ORGDISTRIB */
696:
697: (void) strcpy(header.nbuf, header.ctlmsg);
698: if ((cp=index(header.nbuf, ' ')) != NULL)
699: *cp = '\0';
700:
701: if (header.approved[0] == '\0')
702: (void) sprintf(header.approved, "%s@%s",
703: username, FROMSYSNAME);
704: (void) sprintf(bfr, "%s/inews -n %s.ctl -c newgroup %s -d %s -a \"%s\"",
705: LIB, header.nbuf, header.ctlmsg, header.distribution,
706: header.approved);
707: if (tty) {
708: printf("Please type in a paragraph describing the new newsgroup.\n");
709: printf("End with control D as usual.\n");
710: }
711: printf("%s\n", bfr);
712: (void) fflush(stdout);
713: (void) system(bfr);
714: exit(0);
715: /*NOTREACHED*/
716: }
717:
718: char firstbufname[BUFLEN];
719: /*
720: * Link ARTICLE into dir for ngname and update active file.
721: */
722: long
723: localize(ngname)
724: char *ngname;
725: {
726: char afline[BUFLEN];
727: long ngsize;
728: long fpos;
729: int e;
730: char *cp;
731:
732: lock();
733: (void) rewind(actfp); clearerr(actfp);
734:
735: for(;;) {
736: fpos = ftell(actfp);
737: if (fgets(afline, sizeof afline, actfp) == NULL) {
738: unlock();
739: logerr("Can't find \"%s\" in active file", ngname);
740: return FALSE; /* No such newsgroup locally */
741: }
742: if (PREFIX(afline, ngname)) {
743: (void) sscanf(afline, "%s %ld", bfr, &ngsize);
744: if (STRCMP(bfr, ngname) == 0) {
745: if (ngsize < 0 || ngsize > 99998) {
746: logerr("found bad ngsize %ld ng %s, setting to 1", ngsize, bfr);
747: ngsize = 1;
748: }
749: break;
750: }
751: }
752: }
753: for (;;) {
754: cp = dirname(ngname);
755:
756: (void) sprintf(bfr, "%s/%ld", cp, ngsize+1);
757: #ifdef VMS
758: /*
759: * The effect of this code is to store the article in the first
760: * newsgroup's directory and to put symbolic links elsewhere.
761: * If this is the first group, firstbufname is not yet filled
762: * in. It should be portable to other link-less systems.
763: * epimass!jbuck
764: */
765: if (firstbufname[0]) {
766: if (vmslink(firstbufname, bfr) == 0)
767: break;
768: } else if (rename(ARTICLE, bfr) == 0)
769: break;
770: #else /* !VMS */
771: if (link(ARTICLE, bfr) == 0)
772: break;
773: #endif /* !VMS */
774: if (!exists(cp))
775: mknewsg(cp, ngname);
776: #ifdef VMS
777: if (firstbufname[0]) {
778: if (vmslink(firstbufname, bfr) == 0)
779: break;
780: } else if (rename(ARTICLE, bfr) == 0)
781: break;
782: #else /* !VMS */
783: if (link(ARTICLE, bfr) == 0)
784: break;
785: #endif /* !VMS */
786: e = errno; /* keep log from clobbering it */
787: log("Cannot install article as %s: %s", bfr, errmsg(errno));
788: if (e != EEXIST) {
789: logerr("Link into %s failed (%s); check dir permissions.",
790: bfr, errmsg(e));
791: unlock();
792: return FALSE;
793: }
794: ngsize++;
795: }
796:
797: /*
798: * This works around a bug in the 4.1bsd stdio
799: * on fseeks to non even offsets in r+w files
800: */
801: if (fpos&1)
802: (void) rewind(actfp);
803:
804: (void) fseek(actfp, fpos, 0);
805: /*
806: * Has to be same size as old because of %05d.
807: * This will overflow with 99999 articles.
808: */
809: fprintf(actfp, "%s %05ld", ngname, ngsize+1);
810: #if defined(USG) || defined(MG1)
811: /*
812: * U G L Y K L U D G E
813: * This utter piece of tripe is the only way I know of to get
814: * around the fact that ATT BROKE standard IO in System 5.2.
815: * Basically, you can't open a file for "r+" and then try and
816: * write to it. This works on all "real" USGUnix systems, It will
817: * probably break on some obscure look alike that doesnt use the
818: * real ATT stdio.h
819: * Don't blame me, blame ATT. stdio should have already done the
820: * following line for us, but it doesn't
821: * also broken in WCW MG-1 42nix 2.0
822: */
823: actfp->_flag |= _IOWRT;
824: #endif /* USG */
825: (void) fflush(actfp);
826: if (ferror(actfp))
827: xerror("Active file write failed");
828: unlock();
829: if (firstbufname[0] == '\0')
830: (void) strcpy(firstbufname, bfr);
831: (void) sprintf(bfr, "%s/%ld ", ngname, ngsize+1);
832: addhist(bfr);
833: return ngsize+1;
834: }
835:
836: /*
837: * Localize for each newsgroup and broadcast.
838: */
839: insert()
840: {
841: register char *ptr;
842: register FILE *tfp;
843: register int c;
844: struct srec srec; /* struct for sys file lookup */
845: struct tm *tm, *gmtime();
846: int is_invalid = FALSE;
847: int exitcode = 0;
848: long now;
849: #ifdef DOXREFS
850: register char *nextref = header.xref;
851: #endif /* DOXREFS */
852:
853: /* Clean up Newsgroups: line */
854: if (!is_ctl && mode != CREATENG)
855: is_invalid = ngfcheck(mode == PROC);
856:
857: (void) time(&now);
858: tm = gmtime(&now);
859: if (header.expdate[0])
860: addhist(" ");
861: #ifdef USG
862: sprintf(bfr,"%2.2d/%2.2d/%d %2.2d:%2.2d\t",
863: #else /* !USG */
864: sprintf(bfr,"%02d/%02d/%d %02d:%02d\t",
865: #endif /* !USG */
866: tm->tm_mon+1, tm->tm_mday, tm->tm_year,tm->tm_hour, tm->tm_min);
867: addhist(bfr);
868: log("%s %s ng %s subj '%s' from %s", spool_news != DONT_SPOOL
869: ? "queued" : (mode==PROC ? "received" : "posted"),
870: header.ident, header.nbuf, header.title, header.from);
871:
872: /* Write article to temp file. */
873: tfp = xfopen(mktemp(ARTICLE), "w");
874:
875: if (is_invalid) {
876: logerr("No valid newsgroups found, moved to junk");
877: if (localize("junk"))
878: savehist(histline);
879: exitcode = 1;
880: goto writeout;
881: }
882:
883: #ifdef ZAPNOTES
884: if (STRNCMP(header.title, "Re: Orphaned Response", 21) == 0) {
885: logerr("Orphaned Response, moved to junk");
886: if (localize("junk"))
887: savehist(histline);
888: exitcode = 1;
889: goto writeout;
890: }
891: #endif /* ZAPNOTES */
892:
893: if (time((time_t *)0) > (cgtdate(header.subdate) + HISTEXP) ){
894: logerr("Article too old, moved to junk");
895: if (localize("junk"))
896: savehist(histline);
897: exitcode = 1;
898: goto writeout;
899: }
900:
901: if (is_mod[0] != '\0' /* one of the groups is moderated */
902: && header.approved[0] == '\0') { /* and unapproved */
903: struct hbuf mhdr;
904: FILE *mfd, *mhopen();
905: register char *p;
906: char modadd[BUFLEN], *replyname();
907: #ifdef DONTFOWARD
908: if(mode == PROC) {
909: logerr("Unapproved article in moderated group %s",
910: is_mod);
911: if (localize("junk"))
912: savehist(histline);
913: goto writeout;
914: }
915: #endif /* DONTFORWARD */
916: fprintf(stderr,"%s is moderated and may not be posted to",
917: is_mod);
918: fprintf(stderr," directly.\nYour article is being mailed to");
919: fprintf(stderr," the moderator who will post it for you.\n");
920: /* Let's find a path to the backbone */
921: sprintf(bfr, "%s/mailpaths", LIB);
922: mfd = xfopen(bfr, "r");
923: do {
924: if (fscanf(mfd, "%s %s", bfr, modadd) != 2)
925: xerror("Can't find backbone in %s/mailpaths",
926: LIB);
927: } while (STRCMP(bfr, "backbone") != 0 && !ngmatch(is_mod, bfr));
928: (void) fclose(mfd);
929: /* fake a header for mailhdr */
930: mhdr.from[0] = '\0';
931: mhdr.replyto[0] = '\0';
932: p = is_mod;
933: while (*++p)
934: if (*p == '.')
935: *p = '-';
936: sprintf(mhdr.path, modadd, is_mod);
937: mfd = mhopen(&mhdr);
938: if (mfd == NULL)
939: xerror("Can't send mail to %s", mhdr.path);
940: fprintf(mfd, "To: %s\n", replyname(&mhdr));
941: lhwrite(&header, mfd);
942: putc('\n', mfd);
943: while ((c = getc(infp)) != EOF)
944: putc(c, mfd);
945: mclose(mfd);
946: log("Article mailed to %s", mhdr.path);
947: xxit(0);
948: }
949:
950: if (mode != PROC && spool_news != DONT_SPOOL) {
951: if (spool_news != EXPIRE_RUNNING
952: && ngmatch(header.nbuf,"to.all.ctl"))
953: spool_news = DONT_SPOOL;
954: if (spool_news != DONT_SPOOL) {
955: fprintf(stderr,
956: "Your article has been spooled for later processing.\n");
957: dospool("#! inews -S -h", TRUE);
958: /* NOT REACHED */
959: }
960: }
961:
962: if (is_ctl) {
963: exitcode = control(&header);
964: if (localize("control") && exitcode != 0)
965: savehist(histline);
966: } else {
967: if (s_find(&srec, LOCALPATHSYSNAME) == FALSE) {
968: logerr("Cannot find my name '%s' in %s",
969: LOCALPATHSYSNAME, SUBFILE);
970: srec = dummy_srec;
971: }
972: #ifdef DOXREFS
973: (void) strncpy(nextref, PATHSYSNAME, BUFLEN);
974: #endif /* DOXREFS */
975: for (ptr = nbuf; *ptr;) {
976: if (ngmatch(ptr,srec.s_nbuf) || index(ptr,'.') == NULL){
977: #ifdef DOXREFS
978: while (*nextref++)
979: ;
980: (void) sprintf(--nextref, " %s:%ld", ptr, localize(ptr));
981: #else /* !DOXREFS */
982: (void) localize(ptr);
983: #endif /* !DOXREFS */
984: }
985: while (*ptr++)
986: ;
987: }
988: if (firstbufname[0] == '\0') {
989: logerr("Newsgroups in active, but not sys");
990: (void) localize("junk");
991: }
992: }
993: #ifdef DOXREFS
994: if (index(header.nbuf, NGDELIM) == NULL)
995: header.xref[0] = '\0';
996: #endif /* DOXREFS */
997:
998: writeout:
999: /* Part 1 of kludge to get around article truncation problem */
1000: if ( (c=getc(infp)) != EOF) {
1001: ungetc(c, infp);
1002: if (c == ' ' || c == '\t') {
1003: header.intnumlines++;
1004: (void) sprintf(header.numlines, "%d",
1005: header.intnumlines);
1006: }
1007: }
1008: /* End of part 1 */
1009: if (header.expdate[0] != '\0' && mode != PROC) {
1010: /* Make sure it's fully qualified */
1011: long t = cgtdate(header.expdate);
1012: strcpy(header.expdate, arpadate(&t));
1013: }
1014:
1015: lhwrite(&header, tfp);
1016: if ((c = getc(infp)) != EOF) {
1017: /* Part 2 of kludge to get around article truncation problem */
1018: if (c == ' ' || c == '\t' )
1019: putc('\n', tfp);
1020: /* End of part 2 */
1021: ungetc(c, infp);
1022: while (fgets(bfr, BUFLEN, infp) != NULL)
1023: fputs(bfr, tfp);
1024: if (bfr[strlen(bfr)-1] != '\n')
1025: putc('\n',tfp);
1026: }
1027: if (ferror(tfp))
1028: xerror("Write failed for temp file");
1029: (void) fclose(tfp);
1030: (void) fclose(infp);
1031: if(exitcode == 0) {
1032: /* article has passed all the checks, so work in background */
1033: if (mode != PROC) {
1034: int pid;
1035: if ((pid=fork()) < 0)
1036: xerror("Can't fork");
1037: else if (pid > 0)
1038: _exit(0);
1039: }
1040: #ifdef SIGTTOU
1041: (void) signal(SIGTTOU, SIG_IGN);
1042: #endif /* SIGTTOU */
1043: savehist(histline);
1044: if (header.supersedes[0] != '\0') {
1045: char *av[2];
1046:
1047: av[0] = "cancel";
1048: av[1] = header.supersedes;
1049: c_cancel(2, av);
1050: }
1051: broadcast(mode==PROC);
1052: }
1053: xxit((mode == PROC && filename[0] == '\0') ? 0 :
1054: (exitcode < 0 ? 0 : exitcode));
1055: }
1056:
1057: input(usegunk)
1058: {
1059: register char *cp;
1060: register int c;
1061: register int empty = TRUE;
1062: FILE *tmpfp;
1063: int consec_newlines = 0;
1064: int linecount = 0;
1065: int linserted = 0;
1066:
1067: tmpfp = xfopen(mktemp(INFILE), "w");
1068: for ( ; ; ) {
1069: if (SigTrap)
1070: break;
1071: if (usegunk)
1072: usegunk = FALSE;
1073: else if (fgets(bfr, BUFLEN, infp) != bfr)
1074: break;
1075: if (mode == PROC) { /* zap trailing empty lines */
1076: #ifdef ZAPNOTES
1077: if (empty && bfr[0] == '#' && bfr[2] == ':'
1078: && header.nf_id[0] == '\0'
1079: && header.nf_from[0] == '\0' ) {
1080: (void) strcpy(header.nf_id, bfr);
1081: (void) nstrip(header.nf_id);
1082: (void) fgets(bfr, BUFLEN, infp);
1083: (void) strcpy(header.nf_from, bfr);
1084: (void) nstrip(header.nf_from);
1085: (void) fgets(bfr, BUFLEN, infp);
1086:
1087: if (header.numlines[0]) {
1088: header.intnumlines -= 2;
1089: (void) sprintf(header.numlines, "%d", header.intnumlines);
1090: }
1091:
1092: /* Strip trailing " - (nf)" */
1093: if ((cp = rindex(header.title, '-')) != NULL
1094: && !strcmp(--cp, " - (nf)"))
1095: *cp = '\0';
1096: log("Stripped notes header on %s", header.ident);
1097: continue;
1098: }
1099: #endif /* ZAPNOTES */
1100: if (bfr[0] == '\n' ||
1101: /* Bandage for older versions of inews */
1102: bfr[1] == '\n' && !isascii(bfr[0])) {
1103: consec_newlines++; /* count it, in case */
1104: continue; /* but don't write it*/
1105: }
1106: /* foo! a non-empty line. write out all saved lines. */
1107: while (consec_newlines > 0) {
1108: putc('\n', tmpfp);
1109: consec_newlines--;
1110: linecount++;
1111: }
1112: }
1113: if (mode != PROC && tty && STRCMP(bfr, ".\n") == 0)
1114: break;
1115: for (cp = bfr; c = toascii(*cp); cp++) {
1116: if (isprint(c) || isspace(c) || c == '\b')
1117: putc(c, tmpfp);
1118: if (c == '\n')
1119: linecount++;
1120: }
1121: if (bfr[0] == '>')
1122: linserted++;
1123: if (bfr[0] == '<') /* kludge to allow diff's to be posted */
1124: linserted--;
1125: empty = FALSE;
1126: }
1127: if (*filename)
1128: (void) fclose(infp);
1129: if (mode != PROC &&
1130: linecount > LNCNT && linserted > (linecount-linserted))
1131: error("Article rejected: %s included more text than new text",
1132: username);
1133:
1134: if (mode != PROC && !is_ctl && header.sender[0] == '\0' && !Sflag) {
1135: int siglines = 0;
1136: char sbuf[BUFLEN];
1137: (void) sprintf(bfr, "%s/%s", userhome, ".signature");
1138: if (access(bfr, 4) == 0) {
1139: if ((infp = fopen(bfr, "r")) == NULL) {
1140: (void) fprintf(stderr,
1141: "inews: \"%s\" left off (must be readable by \"inews\" owner)\n", bfr);
1142: goto finish;
1143: }
1144:
1145: while (fgets(sbuf, sizeof sbuf, infp) != NULL)
1146: if (++siglines > 4)
1147: break;
1148: if (siglines > 4)
1149: fprintf(stderr,".signature not included (> 4 lines)\n");
1150: else {
1151: rewind(infp);
1152: fprintf(tmpfp, "-- \n"); /* To separate */
1153: linecount++;
1154: while ((c = getc(infp)) != EOF) {
1155: putc(c, tmpfp);
1156: if (c == '\n')
1157: linecount++;
1158: }
1159: }
1160: (void) fclose(infp);
1161: }
1162: }
1163:
1164: finish:
1165: if (ferror(tmpfp))
1166: xerror("write failed to temp file");
1167: (void) fclose(tmpfp);
1168: if (SigTrap) {
1169: if (tty)
1170: fprintf(stderr, "Interrupt\n");
1171: if (tty && !empty)
1172: fwait(fsubr(newssave, (char *) NULL, (char *) NULL));
1173: if (!tty)
1174: log("Blown away by an interrupt %d", SigTrap);
1175: xxit(1);
1176: }
1177: if (tty)
1178: fprintf(stderr, "EOT\n");
1179: fflush(stdout);
1180: infp = fopen(INFILE, "r");
1181: if (header.numlines[0]) {
1182: /*
1183: * Check line count if there's already one attached to
1184: * the article. Could make this a fatal error -
1185: * throwing it away if it got chopped, in hopes that
1186: * another copy will come in later with a correct
1187: * line count. But that seems a bit much for now.
1188: */
1189: if (linecount != header.intnumlines) {
1190: if (linecount == 0)
1191: error("%s rejected. linecount expected %d, got 0", header.ident, header.intnumlines);
1192: if (linecount > header.intnumlines ||
1193: linecount+consec_newlines < header.intnumlines)
1194: log("linecount expected %d, got %d", header.intnumlines, linecount+consec_newlines);
1195: }
1196: /* adjust count for blank lines we stripped off */
1197: if (consec_newlines) {
1198: header.intnumlines -= consec_newlines;
1199: if (header.intnumlines < 0 )
1200: header.intnumlines = 0; /* paranoia */
1201: (void) sprintf(header.numlines, "%d", header.intnumlines);
1202: }
1203:
1204: } else {
1205: /* Attach a line count to the article. */
1206: header.intnumlines = linecount;
1207: (void) sprintf(header.numlines, "%d", linecount);
1208: }
1209: }
1210:
1211: /*
1212: * Make the directory for a new newsgroup. ngname should be the
1213: * full pathname of the directory. Do the other stuff too.
1214: * The various games with setuid and chown are to try to make sure
1215: * the directory is owned by NEWSUSR and NEWSGRP, which is tough to
1216: * do if you aren't root. This will work on a UCB system (which allows
1217: * setuid(geteuid()) or a USG system (which allows you to give away files
1218: * you own with chown), otherwise you have to change your kernel to allow
1219: * one of these things or run with your dirs 777 so that it doesn't matter
1220: * who owns them.
1221: */
1222: mknewsg(fulldir, ngname)
1223: char *fulldir;
1224: char *ngname;
1225: {
1226: #ifdef USG
1227: register char *p;
1228: char parent[200];
1229: char sysbuf[200];
1230: struct stat sbuf;
1231: #endif /* USG */
1232:
1233: if (ngname == NULL || !isalpha(ngname[0]))
1234: xerror("Tried to make illegal newsgroup %s", ngname);
1235:
1236: #ifdef USG
1237: /*
1238: * If the parent is 755 the setuid(getuid)
1239: * will fail, and since mkdir is suid, and our real uid is random,
1240: * the mkdir will fail. So we have to temporarily chmod it to 777.
1241: */
1242: (void) strcpy(parent, fulldir);
1243: while (p = rindex(parent, '/')) {
1244: *p = '\0';
1245: if (stat(parent, &sbuf) == 0) {
1246: (void) chmod(parent, 0777);
1247: break;
1248: }
1249: }
1250: #endif /* USG */
1251:
1252: /* Create the directory */
1253: mkparents(fulldir);
1254: if (mkdir(fulldir, 0777) < 0)
1255: xerror("Cannot mkdir %s: %s", fulldir, errmsg(errno));
1256:
1257: #ifdef USG
1258: /*
1259: * Give away the directories we just created which were assigned
1260: * our real uid.
1261: */
1262: (void) setuid(uid);
1263: (void) chown(fulldir, duid, dgid);
1264:
1265: (void) strcpy(sysbuf, fulldir);
1266: while (p = rindex(sysbuf, '/')) {
1267: *p = '\0';
1268: /* stop when get to last known good parent */
1269: if (strcmp(sysbuf, parent) == 0)
1270: break;
1271: (void) chown(sysbuf, duid, dgid);
1272: }
1273: (void) setuid(duid);
1274: (void) chmod(parent, (int)sbuf.st_mode); /* put it back */
1275: #endif /* USG */
1276:
1277: log("make newsgroup %s in dir %s", ngname, fulldir);
1278: }
1279:
1280: /*
1281: * If any parent directories of this dir don't exist, create them.
1282: */
1283: mkparents(dname)
1284: char *dname;
1285: {
1286: char buf[200];
1287: register char *p;
1288:
1289: (void) strcpy(buf, dname);
1290: p = rindex(buf, '/');
1291: if (p)
1292: *p = '\0';
1293: if (exists(buf))
1294: return;
1295: mkparents(buf);
1296: if (mkdir(buf, 0777) < 0)
1297: xerror("Can not mkdir %s: %s", buf, errmsg(errno));
1298: }
1299:
1300: dounspool()
1301: {
1302: register DIR *dirp;
1303: register struct direct *dir;
1304: register int foundsome;
1305: int pid, status, ret;
1306: char spbuf[BUFLEN];
1307: #ifdef LOCKF
1308: FILE* LockFd;
1309: #endif /* LOCKF */
1310: #ifdef VMS
1311: sprintf(spbuf, "%s/+rnews", SPOOL);
1312: #else /* !VMS */
1313: sprintf(spbuf, "%s/.rnews", SPOOL);
1314: #endif /* !VMS */
1315:
1316: if (chdir(spbuf) < 0)
1317: xerror("chdir(%s):%s", spbuf, errmsg(errno));
1318:
1319: dirp = opendir(".");
1320: if (dirp == NULL) /* Boy are things screwed up */
1321: xerror("opendir can't open .:%s", errmsg(errno));
1322: #ifdef LOCKF
1323: LockFd = xfopen(SEQFILE, "r+w");
1324: if (lockf(fileno(LockFd), F_TLOCK, 0L) < 0) {
1325: if (errno != EAGAIN && errno != EACCES)
1326: #else /* !LOCKF */
1327: #ifdef BSD4_2
1328: if (flock(dirp->dd_fd, LOCK_EX|LOCK_NB) < 0) {
1329: if (errno != EWOULDBLOCK)
1330: #else /* V7 */
1331: strcat(spbuf, ".lock");
1332: sprintf(bfr, "%s.tmp", spbuf);
1333: (void) close(creat(bfr, 0666));
1334: ret = LINK(bfr, spbuf);
1335: status = errno;
1336: (void) UNLINK(bfr);
1337: errno = status;
1338: if (ret < 0) {
1339: if (errno != EEXIST)
1340: #endif /* V7 */
1341: #endif /* !LOCKF */
1342: xerror("Can't lock %s: %s", spbuf, errmsg(errno));
1343: xxit(3); /* another rnews -U is running */
1344: }
1345:
1346: do {
1347: foundsome = 0;
1348:
1349: while ((dir=readdir(dirp)) != NULL) {
1350: if (dir->d_name[0] == '.')
1351: continue;
1352:
1353: #ifdef IHCC
1354: log("Unspooling from %s", dir->d_name);
1355: #endif /* IHCC */
1356:
1357: if ((pid=vfork()) == -1)
1358: xerror("Can't fork: %s", errmsg(errno));
1359: if (pid == 0) {
1360: #ifdef LOGDIR
1361: char bufr[BUFSIZ];
1362: sprintf(bufr, "%s/%s", logdir(HOME), RNEWS);
1363: execl(bufr, "rnews", "-S", "-p", dir->d_name,
1364: (char *) NULL);
1365: #else /* !LOGDIR */
1366: execl(RNEWS, "rnews", "-S", "-p", dir->d_name,
1367: (char *) NULL);
1368: #endif /* !LOGDIR */
1369: _exit(1);
1370: }
1371:
1372: while ((ret=wait(&status)) != pid && ret != -1)
1373: /* continue */;
1374:
1375: if (((status>>8)&0177) == 42) {
1376: /* expire has started up, shutdown rnews -U */
1377: break;
1378: }
1379:
1380: if (status != 0) {
1381: sprintf(bfr, "../%s", dir->d_name);
1382: (void) LINK(dir->d_name, bfr);
1383: logerr("rnews failed, status %ld. Batch saved in %s/%s",
1384: (long)status, SPOOL, dir->d_name);
1385: }
1386: (void) unlink(dir->d_name);
1387: foundsome++;
1388: }
1389: rewinddir(dirp);
1390: } while (foundsome); /* keep rereading the directory until it's empty */
1391: #ifndef LOCKF
1392: #ifndef BSD4_2
1393: (void) UNLINK(spbuf);
1394: #endif
1395: #endif
1396:
1397: xxit(0);
1398: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.