![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ifuncs.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 ifuncs.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: * ifuncs - functions used by inews.
16: */
17:
18: #ifdef SCCSID
19: static char *SccsId = "@(#)ifuncs.c 2.66 10/7/87";
20: #endif /* SCCSID */
21:
22: #include "iparams.h"
23:
24: extern long localize();
25:
26: /*LINTLIBRARY*/
27:
28: /*
29: * Transmit this article to all interested systems.
30: */
31:
32: #ifdef u370
33: static struct srec srec;
34: #endif /* u370 */
35:
36: static struct hbuf h, hh;
37:
38: #ifdef MULTICAST
39: #define MAXMCAST 20
40: #define MAXMCS 10
41:
42: struct multicast {
43: char mc_name[SBUFLEN]; /* "multi-cast" name */
44: short mc_syscnt;
45: char mc_tosys[MAXMCAST][SBUFLEN];
46: } mcast[MAXMCS];
47:
48: static int mccount;
49: #endif /* MULTICAST */
50:
51: long lseek();
52:
53: #ifndef DBM
54: char *histfile();
55: #endif /* !DBM */
56:
57: #ifdef VMS
58: /*
59: * For VMS/Eunice there are no links: article was moved to firstbufname
60: * before broadcast is reached. So we read it from there.
61: */
62: extern char firstbufname[];
63: #endif
64:
65: #ifndef GENERICPATH
66: /*ARGSUSED*/
67: #endif /* !GENERICPATH */
68: broadcast(is_rnews)
69: int is_rnews;
70: {
71: register char *hptr;
72: register char *sptr;
73: register FILE *fp;
74: #ifndef u370
75: struct srec srec;
76: #endif
77: char sentbuf[LBUFLEN];
78: int nsent = 0;
79: char *sentsys;
80: #ifdef GENERICPATH
81: int len;
82: #endif /* GENERICPATH */
83:
84: /* h is a local copy of the header we can scribble on */
85: #ifdef VMS
86: fp = xfopen (firstbufname, "r");
87: #else
88: fp = xfopen(ARTICLE, "r");
89: #endif
90: if (hread(&h, fp, TRUE) == NULL)
91: xerror("Cannot reread article");
92: (void) fclose(fp);
93:
94: (void) strcpy(sentbuf, h.ident);
95: (void) strcat(sentbuf, " sent to ");
96: sentsys = index(sentbuf, '\0');
97: nsent = 0;
98: /* break path into list of systems. */
99: hptr = h.path;
100: #ifdef GENERICPATH
101: if (!is_rnews &&
102: STRNCMP(PATHSYSNAME, h.path, (len = strlen(PATHSYSNAME))) == 0
103: && index(NETCHRS, h.path[len]))
104: (void) strcpy(h.path, &(h.path[len+1]));
105: #endif /* GENERICPATH */
106: sptr = hptr = h.path;
107: while ((hptr=strpbrk(hptr, NETCHRS)) != NULL) {
108: *hptr++ = '\0';
109: sptr = hptr;
110: }
111: *sptr = '\0';
112:
113: #ifdef MULTICAST
114: mccount = 0;
115: #endif /* MULTICAST */
116:
117: /* loop once per system. */
118: s_openr();
119: while (s_read(&srec)) {
120: char *dist = h.distribution;
121: if (STRNCMP(srec.s_name, LOCALPATHSYSNAME, SNLN) == 0)
122: continue;
123: if (sptr = srec.s_nosend) {
124: while (*sptr) {
125: while (*sptr && *sptr != ',')
126: sptr++;
127: if (*sptr == ',')
128: *sptr++ = '\0';
129: }
130: *++sptr = '\0';
131: }
132: hptr = h.path;
133: while (*hptr != '\0') {
134: if (STRNCMP(srec.s_name, hptr, SNLN) == 0)
135: goto contin;
136: if (sptr = srec.s_nosend) {
137: while (*sptr != '\0') {
138: if (STRNCMP(sptr, hptr, SNLN) == 0)
139: goto contin;
140: while (*sptr++)
141: ;
142: }
143: }
144: while (*hptr++ != '\0')
145: ;
146: }
147: if (!ngmatch(h.nbuf, srec.s_nbuf))
148: continue;
149: if (*dist == '\0')
150: dist = "world";
151: if (!ngmatch(dist, srec.s_nbuf) && !ngmatch(srec.s_nbuf, dist))
152: continue;
153:
154: if (nsent) {
155: hptr = sentsys;
156: while ((sptr = index(hptr, ',')) != NULL) {
157: *sptr = '\0';
158: if (STRCMP(hptr, srec.s_name) == 0) {
159: *sptr = ',';
160: goto contin;
161: }
162: *sptr++ = ',';
163: for (hptr = sptr; isspace(*hptr); hptr++)
164: ;
165: }
166: if (STRCMP(hptr, srec.s_name) == 0)
167: continue;
168: }
169: /* now we've found a system to send this article to */
170: #ifdef MULTICAST
171: if (index(srec.s_flags, 'M')) {
172: /* do a "multi-cast" transmit */
173: register struct multicast *m;
174:
175: if (strlen(srec.s_name) >= SBUFLEN ||
176: strlen(srec.s_xmit) >= SBUFLEN)
177: xerror("system name too long for multicast");
178: for (m = mcast; m < &mcast[mccount]; m++)
179: if (STRCMP(srec.s_xmit, m->mc_name) == 0)
180: break;
181: if (m >= &mcast[MAXMCS])
182: xerror("Too many multicasts");
183: if (m == &mcast[mccount]) {
184: mccount++;
185: m->mc_syscnt = 0;
186: strcpy(m->mc_name, srec.s_xmit);
187: }
188: if (m->mc_syscnt >= MAXMCAST)
189: xerror("Too many systems for multicast");
190: strcpy(m->mc_tosys[m->mc_syscnt++], srec.s_name);
191: } else {
192: register struct multicast *m;
193: register char **yptr;
194: char *sysptrs[MAXMCAST];
195: int mc;
196:
197: mc = 0;
198: for (m = mcast; m < &mcast[mccount]; m++)
199: if (STRCMP(m->mc_name, srec.s_name) == 0) {
200: yptr = sysptrs;
201: while (mc < m->mc_syscnt)
202: *yptr++ = m->mc_tosys[mc++];
203: break;
204: }
205: #ifdef VMS
206: if (!transmit(&srec, xfopen(firstbufname,"r"),
207: #else /* !VMS */
208: if (!transmit(&srec, xfopen(ARTICLE,"r"),
209: #endif /* !VMS */
210: (STRNCMP(h.nbuf, "to.", 3) != 0),
211: sysptrs, mc))
212: continue;
213: }
214: #else /* !MULTICAST */
215: #ifdef VMS
216: if (!transmit(&srec, xfopen(firstbufname, "r"),
217: #else /* !VMS */
218: if (!transmit(&srec, xfopen(ARTICLE, "r"),
219: #endif /* !VMS */
220: (STRNCMP(h.nbuf, "to.", 3) != 0),
221: (char **) NULL, FALSE))
222: continue;
223: #endif /* !MULTICAST */
224: if (nsent)
225: (void) strcat(sentbuf, ", ");
226: (void) strcat(sentbuf, srec.s_name);
227: nsent++;
228: contin:;
229: }
230: if (nsent)
231: log(sentbuf);
232: s_close();
233: }
234:
235: /*
236: * Transmit file to system.
237: */
238: #define PROC 0004
239: #ifndef MULTICAST
240: /* ARGSUSED */
241: #endif /* !MULTICAST */
242: transmit(sp, ifp, maynotify, sysnames, mc)
243: register struct srec *sp;
244: register FILE *ifp;
245: int maynotify;
246: char **sysnames;
247: int mc;
248: {
249: register FILE *ofp;
250: register int c;
251: register char *ptr;
252: char TRANS[BUFLEN];
253: char *argv[20];
254: register int pid;
255: extern char firstbufname[];
256:
257: /* A: afmt: the other machine runs an A news, so we xmit in A format */
258: int afmt = (index(sp->s_flags, 'A') != NULL);
259: /* B: use B format (this is the default - don't use this letter elsewise). */
260: /* F: append name to file */
261: int appfile = (index(sp->s_flags, 'F') != NULL);
262: /* L: local: don't send the article unless it was generated locally */
263: int local = ((ptr = index(sp->s_flags, 'L')) != NULL);
264: /* H: interpolate history line into command, use existing file */
265: int history = (index(sp->s_flags, 'H') != NULL);
266: /* m: moderated: only send if group is moderated */
267: int sendifmoderated = (index(sp->s_flags, 'm') != NULL);
268: /* u: unmoderated: only send if group is unmoderated */
269: int sendifunmoderated = (index(sp->s_flags, 'u') != NULL);
270: /* M: multi-cast: this is taken care of above, but don't reuse flag */
271: #ifdef MULTICAST
272: /* O: multi-cast only, don't send article if not multicast hosts */
273: int multisend = (index(sp->s_flags, 'O') != NULL);
274: #endif /* MULTICAST */
275: /* N: notify: don't send the article, just tell him we have it */
276: int notify = maynotify && (index(sp->s_flags, 'N') != NULL);
277: /* S: noshell: don't fork a shell to execute the xmit command */
278: int noshell = (index(sp->s_flags, 'S') != NULL);
279: /* U: useexist: use the -c option to uux to use the existing copy */
280: int useexist = (index(sp->s_flags, 'U') != NULL);
281: /* I: append messageid to file. implies F flag */
282: int appmsgid = maynotify && (index(sp->s_flags, 'I') != NULL);
283:
284: if (notify)
285: appfile = appmsgid = FALSE;
286:
287: if (local && mode == PROC) {
288: local = 0;
289: while (isdigit(*++ptr))
290: local = local * 10 + *ptr - '0';
291: for (ptr = h.path; *ptr != '\0' && local >= 0; local--)
292: while (*ptr++ != '\0')
293: ;
294: if (local < 0) {
295: (void) fclose(ifp);
296: return FALSE;
297: }
298: }
299:
300: /*
301: ** Do not transmit to system specified in -x flag.
302: */
303: if (not_here[0] && STRCMP(not_here, sp->s_name) == 0) {
304: (void) fclose(ifp);
305: return FALSE;
306: }
307:
308: #ifdef DEBUG
309: printf("Transmitting to '%s'\n", sp->s_name);
310: #endif /* DEBUG */
311:
312: #ifdef MULTICAST
313: if (multisend && mc == 0) {
314: (void) fclose(ifp);
315: return FALSE;
316: }
317: #endif /* MULTICAST */
318:
319: if ((sendifmoderated && is_mod[0] == '\0') ||
320: (sendifunmoderated && is_mod[0] != '\0')) {
321: fclose(ifp);
322: return FALSE;
323: }
324:
325: if (appmsgid || (!appfile && !useexist && !history)) {
326: if (!hread(&hh, ifp, TRUE)) {
327: logerr("Bad header, not transmitting %s re %s to %s",
328: hh.ident, hh.title, sp->s_name);
329: (void) fclose(ifp);
330: return FALSE;
331: }
332: if (hh.nbuf[0] == '\0') {
333: fprintf(stderr, "Article not subscribed to by %s\n", sp->s_name);
334: (void) fclose(ifp);
335: return FALSE;
336: }
337: (void) sprintf(TRANS, "%s/trXXXXXX", SPOOL);
338: }
339:
340: if (notify) {
341: char oldid[50];
342: (void) sprintf(hh.title, "ihave %s %s", hh.ident, PATHSYSNAME);
343: (void) strcpy(hh.ctlmsg, hh.title);
344: (void) strcpy(hh.numlines, "0");
345: (void) sprintf(hh.nbuf, "to.%s.ctl", sp->s_name);
346: (void) strcpy(oldid, hh.ident);
347: getident(&hh);
348: log("tell %s about %s, notif. id %s",
349: sp->s_name, oldid, hh.ident);
350: }
351:
352: if (appfile || appmsgid) {
353: if (firstbufname[0] == '\0') {
354: extern char histline[];
355: localize("junk");
356: savehist(histline);
357: xerror("No file name to xmit from");
358: }
359: if (sp->s_xmit[0] == '\0')
360: sprintf(sp->s_xmit, "%s/%s%s", BATCHDIR, sp->s_name,
361: appmsgid ? ".ihave" : "");
362: #ifdef LOGDIR
363: (void) sprintf(TRANS, "%s/%s/%s", logdir(HOME), BATCHDIR, sp->s_xmit);
364: ofp = fopen(TRANS, "a");
365: #else /* !LOGDIR */
366: ofp = fopen(sp->s_xmit, "a");
367: #endif /* !LOGDIR */
368: if (ofp == NULL)
369: xerror("Cannot append to %s", sp->s_xmit);
370: fprintf(ofp, "%s", appmsgid ? hh.ident : firstbufname);
371: #ifdef MULTICAST
372: while (--mc >= 0)
373: fprintf(ofp, " %s", *sysnames++);
374: #endif /* !MULTICAST */
375: putc('\n', ofp);
376: (void) fclose(ofp);
377: (void) fclose(ifp);
378: return TRUE;
379: }
380: else if (useexist) {
381: if (firstbufname[0] == '\0')
382: xerror("No file name to xmit from");
383: if (*sp->s_xmit == '\0')
384: #ifdef UXMIT
385: (void) sprintf(bfr, UXMIT, sp->s_name, firstbufname);
386: #else
387: xerror("UXMIT not defined for U flag");
388: #endif
389: else
390: #ifdef MULTICAST
391: makeargs(bfr, sp->s_xmit, firstbufname, sysnames, mc);
392: #else
393: (void) sprintf(bfr, sp->s_xmit, firstbufname);
394: #endif
395: (void) fclose(ifp);
396: } else if (history) {
397: extern char histline[];
398:
399: if (*sp->s_xmit == '\0')
400: xerror("no xmit command with H flag");
401: #ifdef MULTICAST
402: makeargs(bfr, sp->s_xmit, histline, sysnames, mc);
403: #else
404: (void) sprintf(bfr, sp->s_xmit, histline);
405: #endif
406: } else {
407: ofp = xfopen(mktemp(TRANS), "w");
408: if (afmt) {
409: #ifdef OLD
410: fprintf(ofp, "A%s\n%s\n%s!%s\n%s\n%s\n", oident(hh.ident), hh.nbuf, PATHSYSNAME,
411: hh.path, hh.subdate, hh.title);
412: #else /* !OLD */
413: logerr("Must have OLD defined to use A flag for xmit");
414: return FALSE;
415: #endif /* !OLD */
416: } else
417: hwrite(&hh, ofp);
418: if (!notify)
419: while ((c = getc(ifp)) != EOF)
420: putc(c, ofp);
421: if (ferror(ofp))
422: xerror("write failed on transmit");
423: (void) fclose(ifp);
424: (void) fclose(ofp);
425: if (*sp->s_xmit == '\0')
426: (void) sprintf(bfr, DFTXMIT, sp->s_name, TRANS);
427: else
428: #ifdef MULTICAST
429: makeargs(bfr, sp->s_xmit, TRANS, sysnames, mc);
430: #else /* !MULTICAST */
431: (void) sprintf(bfr, sp->s_xmit, TRANS);
432: #endif /* !MULTICAST */
433: }
434:
435: /* At this point, the command to be executed is in bfr. */
436: if (noshell) {
437: if (pid = vfork())
438: fwait(pid);
439: else {
440: (void) close(0);
441: (void) open(TRANS, 0);
442: ptr = bfr;
443: for (pid = 0; pid < 19; pid++) {
444: while (isspace(*ptr))
445: *ptr++ = 0;
446: argv[pid] = ptr;
447: while (!isspace(*++ptr) && *ptr)
448: ;
449: if (!*ptr)
450: break;
451: }
452: argv[++pid] = 0;
453: (void) setgid(gid);
454: (void) setuid(uid);
455: execvp(argv[0], argv);
456: xerror("Can't execv %s", argv[0]);
457: }
458: } else {
459: if (!history && sp->s_xmit[0] && !index(bfr, '<')) {
460: char newcmd[LBUFLEN];
461:
462: (void) sprintf(newcmd, "(%s) <%s", bfr,
463: useexist ? firstbufname : TRANS);
464: system(newcmd);
465: } else
466: system(bfr);
467: }
468: if (!appfile && !useexist && !history)
469: (void) unlink(TRANS);
470: (void) fclose(ifp);
471: return TRUE;
472: }
473:
474: #ifdef MULTICAST
475: makeargs(buf, cmd, arg2, sysargs, sac)
476: char *buf;
477: char *cmd;
478: char *arg2;
479: register char **sysargs;
480: int sac;
481: {
482: register char *p = cmd;
483: register char *q;
484: register ac = 0;
485: register char *b = buf;
486:
487: q = p;
488: do {
489: if (q = index(q, ' '))
490: *q = '\0';
491: if (index(p, '%')) {
492: switch (++ac) {
493: case 1:
494: while (--sac >= 0) {
495: sprintf(b, p, *sysargs++);
496: b = index(b, '\0');
497: }
498: break;
499: case 2:
500: sprintf(b, p, arg2);
501: b = index(b, '\0');
502: break;
503: default:
504: if (q)
505: *q = ' ';
506: xerror("badly formed command: %s", cmd);
507: }
508: } else {
509: strcpy(b, p);
510: b = index(b, '\0');
511: }
512: if (q) {
513: *q = ' ';
514: p = q;
515: while (isspace(*q))
516: q++;
517: }
518: } while (q != NULL);
519: }
520: #endif /* MULTICAST */
521:
522: /*
523: * Return TRUE if we have seen this file before, else FALSE.
524: */
525: history(hp)
526: struct hbuf *hp;
527: {
528: #ifdef DBM
529: datum lhs, rhs;
530: datum fetch();
531: #else /* !DBM */
532: register FILE *hfp;
533: register char *p;
534: #endif /* !DBM */
535: char lcident[BUFLEN];
536: extern char histline[];
537:
538: #ifdef DEBUG
539: fprintf(stderr,"history(%s)\n", hp->ident);
540: #endif /* DEBUG */
541: /*
542: * Make the article ID case insensitive.
543: */
544: (void) strcpy(lcident, hp->ident);
545: lcase(lcident);
546:
547: idlock(lcident);
548: #ifdef DBM
549: initdbm(ARTFILE);
550: lhs.dptr = lcident;
551: lhs.dsize = strlen(lhs.dptr) + 1;
552: rhs = fetch(lhs);
553: if (rhs.dptr) {
554: idunlock();
555: return(TRUE);
556: }
557: #else /* !DBM */
558: hfp = xfopen(histfile(lcident), "r");
559: while (fgets(bfr, BUFLEN, hfp) != NULL) {
560: p = index(bfr, '\t');
561: if (p == NULL)
562: p = index(bfr, '\n');
563: if (p != NULL) /* can happen if nulls in file */
564: *p = 0;
565: lcase(bfr);
566:
567: if (STRCMP(bfr, lcident) == 0) {
568: (void) fclose(hfp);
569: idunlock();
570: #ifdef DEBUG
571: fprintf(stderr,"history returns true\n");
572: #endif /* DEBUG */
573: return TRUE;
574: }
575: }
576: (void) fclose(hfp);
577: #endif /* !DBM */
578: histline[0] = '\0';
579: addhist(hp->ident);
580: addhist("\t");
581: #ifdef DEBUG
582: fprintf(stderr,"history returns false\n");
583: #endif
584: return FALSE;
585: }
586:
587: char histline[PATHLEN];
588:
589: addhist(msg)
590: char *msg;
591: {
592: (void) strcat(histline, msg);
593: }
594:
595: savehist(hline)
596: char *hline;
597: {
598: register FILE *hfp;
599: register char *p;
600: #ifdef DBM
601: long fpos;
602: #endif /* !DBM */
603:
604: #ifndef DBM
605: if (STRCMP((p = histfile(hline)), ARTFILE) != 0) {
606: /* If the history subfile is accessible */
607: if ((hfp = xfopen(p, "a")) != NULL ) { /* If we can append */
608: fprintf(hfp, "%s\n", hline); /* Append */
609: (void) fclose(hfp);
610: } else
611: logerr("Unable to append to %s: %s", p, errmsg(errno));
612: } else
613: #endif /* !DBM */
614: {
615: hfp = xfopen(ARTFILE, "a");
616: (void) fseek(hfp, 0L, 2); /* Unisoft 5.1 doesn't seek to EOF on 'a' */
617: #ifdef DBM
618: fpos = ftell(hfp);
619: #endif /* !DBM */
620: fprintf(hfp, "%s\n", hline);
621: (void) fclose(hfp);
622: }
623: #ifdef DBM
624: {
625: datum lhs, rhs;
626: /* We assume that history has already been called, calling dbminit. */
627: p = index(hline, '\t');
628: if (p)
629: *p = 0;
630: lcase(hline);
631: lhs.dptr = hline;
632: lhs.dsize = strlen(lhs.dptr) + 1;
633: rhs.dptr = (char *)&fpos;
634: rhs.dsize = sizeof fpos;
635: store(lhs, rhs);
636: }
637: #endif /* DBM */
638: idunlock();
639: }
640:
641: /*
642: * Save partial news.
643: */
644: /* ARGSUSED */
645: newssave(fd, dummy)
646: FILE *fd;
647: char *dummy;
648: {
649: register FILE *tofd, *fromfd;
650: char sfname[BUFLEN];
651: register int c;
652: time_t tim;
653:
654: if (fd == NULL)
655: fromfd = xfopen(INFILE, "r");
656: else
657: fromfd = fd;
658: (void) umask(savmask);
659: (void) setgid(gid);
660: (void) setuid(uid);
661:
662: (void) sprintf(sfname, "%s/%s", userhome, PARTIAL);
663: if ((tofd = fopen(sfname, "a")) == NULL)
664: xerror("Cannot save partial news in %s", sfname);
665: (void) time(&tim);
666: fprintf(tofd, "----- News saved at %s\n", arpadate(&tim));
667: while ((c = getc(fromfd)) != EOF)
668: putc(c, tofd);
669: (void) fclose(fromfd);
670: (void) fclose(tofd);
671: printf("News saved in %s\n", sfname);
672: xxit(1);
673: }
674:
675: /*
676: * Handle dates in header.
677: */
678:
679: dates(hp)
680: struct hbuf *hp;
681: {
682: time_t edt;
683:
684: if (*hp->subdate) {
685: if (cgtdate(hp->subdate) < 0) {
686: error("Cannot parse submittal date '%s'", hp->subdate);
687: }
688: } else {
689: (void) time(&edt);
690: (void) strcpy(hp->subdate, arpadate(&edt));
691: }
692: }
693:
694: #define LOCKSIZE 128
695: char lockname[LOCKSIZE];
696:
697: idlock(str)
698: char *str;
699: {
700: register int i;
701: register char *cp, *scp;
702: char tempname[LOCKSIZE];
703: time_t now;
704: struct stat sbuf;
705: extern int errno;
706: #ifdef VMS
707: int fd;
708: /* The name here is because of the peculiar properties of version numbers
709: * in Eunice. We eliminate any troublesome characters also.
710: */
711: (void) sprintf(lockname, "/tmp/%.10s.l.1", str);
712: for (cp = lockname; *cp; cp++)
713: if (*cp == '/' || *cp == '[' || *cp == ']') *cp = '.';
714: while ((fd = creat(lockname, 0444)) < 0) {
715: #else /* !VMS */
716: (void) strcpy(tempname, "/tmp/LTMP.XXXXXX");
717: (void) mktemp(tempname);
718: (void) strcpy(lockname, "/tmp/L");
719: i = strlen(lockname);
720: cp = &lockname[i];
721: scp = str - 1;
722: while (i++ < LOCKSIZE && *++scp != '\0')
723: if (*scp == '/') /* slash screws up the open */
724: *cp++ = '.';
725: else
726: *cp++ = *scp;
727: *cp = '\0';
728: #ifdef FOURTEENMAX
729: lockname[5 /* /tmp/ */ + 14] = '\0';
730: #endif
731: i = creat(tempname, 0666);
732: if (i < 0)
733: xerror("Cannot creat %s: errno %d", tempname, errno);
734: (void) close(i);
735: while (link(tempname, lockname)) {
736: #endif /* !VMS */
737: (void) time(&now);
738: if (stat(lockname, &sbuf) < 0)
739: xerror("Directory permission problem in /tmp");
740:
741: if (sbuf.st_mtime + 10*60 < now) {
742: (void) unlink(lockname);
743: logerr("Article %s locked up", str);
744: break;
745: }
746: log("waiting on lock for %s", lockname);
747: sleep((unsigned)60);
748: }
749: #ifdef VMS
750: (void) close(fd);
751: #endif
752: (void) unlink(tempname);
753: }
754:
755: idunlock()
756: {
757: (void) unlink(lockname);
758: }
759:
760: /*
761: * Put a unique name into header.ident.
762: */
763: getident(hp)
764: struct hbuf *hp;
765: {
766: long seqn;
767: register FILE *fp;
768: extern char *mydomain();
769:
770: lock();
771: fp = xfopen(SEQFILE, "r");
772: (void) fgets(bfr, BUFLEN, fp);
773: (void) fclose(fp);
774: seqn = atol(bfr) + 1;
775: /*
776: * For Eunice, this breaks if SEQFILE is not in Unix format.
777: */
778: fp = xfopen(SEQFILE, "r+w");
779: fprintf(fp, "%ld\n", seqn);
780: (void) fclose(fp);
781: unlock();
782: (void) sprintf(hp->ident, "<%ld@%s>", seqn, LOCALSYSNAME);
783: }
784:
785: /*
786: * Check that header.nbuf contains only valid newsgroup names;
787: * exit with error if not valid.
788: */
789: ngfcheck(isproc)
790: {
791: register FILE * f;
792: register char * cp;
793: register int i, j;
794: register int ngcount, okcount, havealiased;
795: register int pass;
796: char * ngs[sizeof header.nbuf / 2];
797: char uses[sizeof header.nbuf / 2];
798: char tbuf[sizeof header.nbuf];
799: char abuf[BUFLEN];
800:
801: havealiased = ngcount = 0;
802: is_mod[0] = '\0';
803: /*
804: ** Split header.nbuf into constituent newsgroups.
805: ** Zap "local" newsgroups of articles from remote sites.
806: */
807: cp = tbuf;
808: (void) strcpy(cp, header.nbuf);
809: for ( ; ; ) {
810: while (*cp == NGDELIM || *cp == ' ')
811: ++cp;
812: if (*cp == '\0')
813: break;
814: ngs[ngcount] = cp;
815: do {
816: ++cp;
817: } while (*cp != '\0' && *cp != NGDELIM && *cp != ' ');
818: if (*cp != '\0')
819: *cp++ = '\0';
820: /*
821: ** Check for local only distribution on incoming
822: ** newsgroups. This might occur if someone posted to
823: ** general,net.unix
824: */
825: if (isproc && index(ngs[ngcount], '.') == NULL &&
826: index(header.nbuf, '.') != NULL) {
827: logerr("Local group %s removed",
828: ngs[ngcount]);
829: continue;
830: }
831: uses[ngcount] = 1; /* it should go in "Newsgroups" line */
832: ++ngcount;
833: }
834: /*
835: ** Check groups against active file.
836: */
837: recheck:
838: okcount = 0;
839: rewind(actfp); clearerr(actfp);
840: while (okcount < ngcount && fgets(bfr, BUFLEN, actfp) == bfr) {
841: if ((cp = index(bfr, ' ')) == NULL)
842: continue; /* strange line in input! */
843: /* newsgroup 12345 12345 X */
844: /* cp + 01234567890123 */
845: if (!isproc && cp[13] == 'n')
846: continue; /* can't post to this group! */
847: *cp = '\0';
848: for (i = 0; i < ngcount; ++i)
849: if (uses[i] >= 1 && STRCMP(bfr, ngs[i]) == 0) {
850: uses[i] = 2; /* it should be localized too */
851: if (cp[13] == 'm')
852: strcpy(is_mod, bfr);
853: ++okcount;
854: }
855: }
856: #ifdef ALWAYSALIAS
857: okcount = 0;
858: #endif /* ALWAYSALIAS */
859: /*
860: ** Handle groups absent from active file.
861: */
862: if (havealiased == 0 && okcount < ngcount) {
863: /*
864: ** See if remaining groups are in our alias list.
865: */
866: f = xfopen(ALIASES, "r");
867: while (okcount < ngcount && fscanf(f, "%s %s%*[^\n]", abuf, bfr) == 2)
868: for (i = 0; i < ngcount; ++i) {
869: #ifndef ALWAYSALIAS
870: if (uses[i] == 2)
871: continue;
872: #endif /* ALWAYSALIAS */
873: if (STRCMP(ngs[i], abuf) != 0)
874: continue;
875: if (isproc)
876: cp = "Aliased newsgroup %s to %s";
877: else
878: cp = "Please change %s to %s";
879: logerr(cp, abuf, bfr);
880: ngs[i] = AllocCpy(bfr);
881: uses[i] = 2;
882: ++havealiased;
883: ++okcount;
884: }
885: (void) fclose(f);
886: for (i = 0; i < ngcount; ++i) {
887: if (uses[i] == 2)
888: continue;
889: if (isproc)
890: log("Unknown newsgroup %s not localized",
891: ngs[i]);
892: else
893: logerr("Unknown newsgroup %s", ngs[i]);
894: #ifdef ALWAYSALIAS
895: ++okcount; /* so we know to exit below */
896: }
897: if (!isproc && okcount > 0)
898: #else /* !ALWAYSALIAS */
899: }
900: if (!isproc)
901: #endif /* !ALWAYSALIAS */
902: newssave(infp, (char *) NULL);
903: /*
904: * Unfortunately, if you alias an unmoderated group to a
905: * moderated group, you must recheck the active file to see
906: * if the new group is moderated. Rude but necessary.
907: */
908: if (havealiased)
909: goto recheck;
910: }
911: /*
912: ** Zap duplicates.
913: */
914: for (i = 0; i < ngcount - 1; ++i) {
915: if (uses[i] == 0)
916: continue;
917: for (j = i + 1; j < ngcount; ++j) {
918: if (uses[j] == 0)
919: continue;
920: if (STRCMP(ngs[i], ngs[j]) != 0)
921: continue;
922: logerr("Duplicate %s removed", ngs[j]);
923: if (uses[i] < uses[j])
924: uses[i] = uses[j];
925: uses[j] = 0;
926: }
927: }
928: for (pass = 1; pass <= 2; ++pass) {
929: register int avail;
930:
931: if (pass == 1) {
932: /*
933: ** Rewrite header.nbuf.
934: */
935: cp = header.nbuf;
936: avail = sizeof header.nbuf;
937: } else {
938: /*
939: ** Fill in nbuf.
940: */
941: cp = nbuf;
942: avail = sizeof nbuf;
943: }
944: for (i = 0; i < ngcount; ++i) {
945: if (uses[i] < pass)
946: continue;
947: j = strlen(ngs[i]);
948: if (j + 2 > avail) {
949: logerr("Redone Newsgroups too long");
950: break;
951: }
952: (void) strcpy(cp, ngs[i]);
953: cp += j;
954: *cp++ = (pass == 1) ? NGDELIM : '\0';
955: avail -= (j + 1);
956: }
957: if (pass == 1) {
958: if (cp == header.nbuf)
959: *cp = '\0';
960: else *(cp - 1) = '\0';
961: } else *cp = '\0';
962: }
963: /*
964: ** Free aliases.
965: */
966: for (i = 0; i < ngcount; ++i)
967: if (ngs[i] < tbuf || ngs[i] > &tbuf[sizeof tbuf - 1])
968: free(ngs[i]);
969: return nbuf[0] == '\0';
970: }
971:
972: /*
973: * Figure out who posted the article (which is locally entered).
974: * The results are placed in the header structure hp.
975: */
976: gensender(hp, logname)
977: struct hbuf *hp;
978: char *logname;
979: {
980: register char *fn, *p;
981: char buf[BUFLEN];
982: char *fullname(), *getenv();
983: int fd, n;
984: extern char *mydomain();
985:
986: if ((fn = getenv("NAME")) == NULL) {
987: (void) sprintf(buf, "%s/%s", userhome, ".name");
988: if ((fd = open(buf, 0)) >= 0) {
989: n = read(fd, buf, sizeof buf);
990: (void) close(fd);
991: if (n > 0 && buf[0] >= 'A') {
992: for (p = fn = buf; *p; p++)
993: if (*p < ' ')
994: *p = '\0';
995: }
996: }
997: }
998:
999: if (fn == NULL)
1000: fn = fullname(logname);
1001:
1002: (void) sprintf(hp->path, "%s", logname);
1003: (void) sprintf(hp->from, "%s@%s (%s)", logname, FROMSYSNAME, fn);
1004: }
1005:
1006: /*
1007: * Trap interrupts.
1008: */
1009: onsig(n)
1010: int n;
1011: {
1012: static int numsigs = 0;
1013: /*
1014: * Most UNIX systems reset caught signals to SIG_DFL.
1015: * This bad design requires that the trap be set again here.
1016: * Unfortunately, if the signal recurs before the trap is set,
1017: * the program will die, possibly leaving the lock in place.
1018: */
1019: if (++numsigs > 100) {
1020: xerror("inews ran away looping on signal %d", n);
1021: }
1022: (void) signal(n, onsig);
1023: SigTrap = n;
1024: }
1025:
1026: /*
1027: * If the stdin begins with "#" the input is some kind of batch. if
1028: * the first line is:
1029: * #!cunbatch
1030: * or
1031: * #!c7unbatch
1032: * then fork off a pipe to do the either a
1033: * "compress -d"
1034: * or a
1035: * "decode | compress -d"
1036: * and check their output for more batch headers. They probably
1037: * contain a batch format that looks like this:
1038: * #! rnews 1234
1039: * article with 1234 chars
1040: * #! rnews 4321
1041: * article with 4321 chars
1042: * If so, then for each article, copy the indicated number of chars into
1043: * a temp file, fork a copy of ourselves, make its input the temp file,
1044: * and allow the copy to process the article. This avoids an exec of
1045: * rnews for each article.
1046: */
1047:
1048: checkbatch()
1049: {
1050: int c;
1051: char *cp;
1052:
1053: setbuf(infp, (char *)NULL);
1054: while ((c = getc(infp)) == '#') {
1055: /* some kind of batch, investigate further */
1056: int i;
1057: char cmd[BUFLEN];
1058: cmd[0] = c;
1059: fgets(cmd + 1, BUFLEN, infp);
1060: if (strncmp(cmd, "#! cunbatch", 11) == 0) {
1061: (void) sprintf(cmd, "%s/compress", LIB);
1062: input_pipe(cmd, "compress", "-d", (char *) 0);
1063: setbuf(infp, (char *)NULL);
1064: continue; /* look for the #! rnews */
1065: } else if (strncmp(cmd, "#! c7unbatch", 12) == 0) {
1066: (void) sprintf(cmd, "%s/decode | %s/compress -d",
1067: LIB, LIB);
1068: input_pipe("/bin/sh", "news-unpack", "-c", cmd);
1069: setbuf(infp, (char *)NULL);
1070: continue; /* look for the #! rnews */
1071: } else if (strncmp(cmd, "#! rnews ", 9) == 0 ||
1072: strncmp(cmd, "! rnews ", 8) == 0) {
1073: /* instead of execing unbatch do it ourselves */
1074: register int fd, rc, wc;
1075: int piped[2];
1076: register long size, asize;
1077: char *tfilename;
1078: int pid, wpid, exstat;
1079: #define CPBFSZ 8192
1080: char buf[CPBFSZ];
1081:
1082: tfilename = 0;
1083: cp = malloc((unsigned)BUFSIZ);
1084: if (cp != NULL)
1085: setbuf(infp, cp);
1086: do {
1087: while (STRNCMP(cmd, "#! rnews ", 9)) {
1088: fprintf(stderr, "out of sync, skipping %s\n", cmd);
1089: if (fgets(cmd, BUFLEN, infp) == NULL)
1090: exit(0);
1091: }
1092: asize = atol(cmd + 9);
1093: if (asize <= 0)
1094: xerror("checkbatch: bad batch count %ld", asize);
1095: fd = -1;
1096: size = asize;
1097: do {
1098: if (size > CPBFSZ)
1099: rc = CPBFSZ;
1100: else
1101: rc = size;
1102: rc = fread(buf, 1, rc, infp);
1103: if (rc <= 0)
1104: break;
1105: if (fd < 0) {
1106: if (rc == asize)
1107: break; /* fits in buffer */
1108: if (!tfilename)
1109: tfilename = mktemp("/tmp/unbnewsXXXXXX");
1110: if ((fd = creat(tfilename, 0666)) < 0) {
1111: fprintf(stderr, "rnews: creat of \"%s\" failed",
1112: tfilename);
1113: perror(" ");
1114: exit(1);
1115: }
1116: }
1117: wc = write(fd, buf, rc); /* write to temp file */
1118: if (wc != rc) {
1119: fprintf(stderr, "write of %d to \"%s\" returned %d",
1120: rc, tfilename, wc);
1121: perror(" ");
1122: exit(1);
1123: }
1124: size -= rc;
1125: } while (size > 0);
1126: if (fd >= 0)
1127: (void) close(fd);
1128:
1129: /*
1130: * If we got a truncated batch, don't process
1131: * the last article; it will probably be
1132: * received again.
1133: */
1134: if ((rc < asize) && (size > 0))
1135: break;
1136:
1137: /*
1138: * This differs from the old unbatcher in
1139: * that we don't exec rnews, mainly because
1140: * we ARE rnews. Instead we fork off a copy
1141: * of ourselves for each article and allow it
1142: * to process.
1143: */
1144: if (rc == asize) {
1145: /*
1146: * article fits in buffer, use a pipe
1147: * instead of a temporary file.
1148: */
1149: if (pipe(piped) != 0)
1150: xerror("checkbatch: pipe() failed");
1151: }
1152: while ((pid = fork()) == -1) {
1153: fprintf(stderr, "fork failed, waiting...\r\n");
1154: sleep(60);
1155: }
1156: if (pid == 0) {
1157: if (rc == asize) {
1158: /* article fits in buffer
1159: * make the output of the
1160: * pipe for STDIN
1161: */
1162: (void) fclose(infp);
1163: /* redundant but why not */
1164: (void) close(0);
1165: if ((i = dup(piped[0])) != 0)
1166: xerror("dup() returned %d, should be 0", i);
1167: (void) close(piped[0]);
1168: (void) close(piped[1]);
1169: infp = fdopen(0, "r");
1170: } else /* supstitute temp file as
1171: * input */
1172: freopen(tfilename, "r", infp);
1173: return; /* from checkbatch as if
1174: * normal article */
1175: }
1176: /* parent of fork */
1177: if (rc == asize) {
1178: /* article fits in buffer */
1179: wc = write(piped[1], buf, rc);
1180: if (wc != rc) {
1181: fprintf(stderr, "write of %d to pipe returned %d",
1182: rc, wc);
1183: perror("rnews: write");
1184: exit(1);
1185: }
1186: (void) close(piped[0]);
1187: (void) close(piped[1]);
1188: }
1189: while ((wpid = wait(&exstat)) >= 0 && wpid != pid);
1190: (void) unlink(tfilename);
1191: } while (fgets(cmd, BUFLEN, infp) != NULL);
1192: exit(0);/* all done */
1193:
1194: } else {
1195: docmd(cmd);
1196: xxit(0);
1197: }
1198: } /* while a batch */
1199: cp = malloc((unsigned)BUFSIZ);
1200: if (cp != NULL)
1201: setbuf(infp, cp);
1202: if (c != EOF)
1203: (void) ungetc(c, infp);
1204: clearerr(infp);
1205: }
1206:
1207: /*
1208: * The input requires some processing so fork and exec the indicated command
1209: * with its output piped to our input.
1210: */
1211: static
1212: input_pipe(cmd, arg0, arg1, arg2)
1213: char *cmd, *arg0, *arg1, *arg2;
1214: {
1215: int i, pid;
1216: int piped[2];
1217:
1218: if (pipe(piped) != 0) {
1219: perror("checkbatch: pipe() failed");
1220: exit(1);
1221: }
1222: fflush(stdout);
1223: while ((pid = vfork()) == -1) {
1224: perror("checkbatch: fork failed, waiting");
1225: sleep(60);
1226: }
1227: if (pid == 0) { /* child process */
1228: /*
1229: * setup a pipe such that the exec'ed process will read our
1230: * input file and write to the pipe
1231: */
1232: (void) close(1);
1233: if ((i = dup(piped[1])) != 1)
1234: xerror("dup() returned %d, should be 1", i);
1235: (void) close(piped[0]);
1236: (void) close(piped[1]);
1237: execl(cmd, arg0, arg1, arg2, (char *) 0);
1238: perror("checkbatch");
1239: xerror("Unable to exec %s to unpack news.", cmd);
1240: } else { /* parent process */
1241: /* make the output of the pipe for STDIN */
1242: (void) fclose(infp);
1243: (void) close(0);
1244: if ((i = dup(piped[0])) != 0)
1245: xerror("dup() returned %d, should be 0", i);
1246: (void) close(piped[0]);
1247: (void) close(piped[1]);
1248: /*
1249: * there should be a way to clear any buffered input and just
1250: * replace file descriptor 0 but I can't find a portable way.
1251: */
1252: infp = fdopen(0, "r");
1253: }
1254: }
1255:
1256: #define MAXARGS 32
1257:
1258: docmd(p)
1259: register char *p;
1260: {
1261: char *args[MAXARGS];
1262: register char **ap = args;
1263: char path[BUFSIZ];
1264: char *rindex(), *cp;
1265:
1266: while (*p && !isspace(*p)) /* skip leading #! crud */
1267: p++;
1268:
1269: while (isspace(*p))
1270: p++;
1271:
1272: while (*p != '\0') {
1273: *ap++ = p;
1274: if (ap >= &args[MAXARGS]) {
1275: logerr("inews: unbatch: Too many args to %s", args[0]);
1276: exit(2);
1277: }
1278: while (*p && !isspace(*p))
1279: p++;
1280: if (*p)
1281: *p++ = '\0';
1282: while (isspace(*p))
1283: p++;
1284: }
1285: *ap = (char *)0;
1286:
1287: if (ap == args) {
1288: logerr("inews: unbatch: no command to execute");
1289: exit(2);
1290: }
1291:
1292: /* strip off any leading pathname in case someone gets tricky */
1293: cp = rindex(args[0], '/');
1294: if (cp++ == NULL)
1295: cp = args[0];
1296:
1297: # ifdef HOME
1298: sprintf(path, "%s/%s/%s", logdir(HOME), LIBDIR, cp);
1299: # else /* !HOME */
1300: sprintf(path, "%s/%s", LIBDIR, cp);
1301: # endif /* HOME */
1302:
1303: /*
1304: * "path" is absolute, no searching is needed, we use
1305: * 'execvp' solely so that sh scripts will be handled
1306: */
1307: (void) execvp(path, args);
1308: perror(path);
1309: xxit(2);
1310: }
1311:
1312: /*
1313: * Exit and cleanup.
1314: */
1315: xxit(status)
1316: int status;
1317: {
1318: (void) unlink(INFILE);
1319: (void) unlink(ARTICLE);
1320: while (lockcount > 0)
1321: unlock();
1322: idunlock();
1323: exit(status);
1324: }
1325:
1326: rwaccess(fname)
1327: char *fname;
1328: {
1329: int fd;
1330:
1331: fd = open(fname, 2);
1332: if (fd < 0)
1333: return 0;
1334: (void) close(fd);
1335: return 1;
1336: }
1337:
1338: exists(fname)
1339: char *fname;
1340: {
1341: int fd;
1342:
1343: fd = open(fname, 0);
1344: if (fd < 0)
1345: return 0;
1346: (void) close(fd);
1347: return 1;
1348: }
1349:
1350: int lockcount = 0; /* no. of times we've called lock */
1351:
1352: #ifdef VMS
1353:
1354: #define SUBLOCK "/tmp/netnews.lck.1"
1355:
1356: /*
1357: * Newsystem locking.
1358: * These routines are different for VMS because we can not
1359: * effectively simulate links, and VMS supports multiple
1360: * version numbers of files
1361: */
1362: lock()
1363: {
1364: register int i;
1365: register int fd;
1366:
1367: if (lockcount++ == 0) {
1368: i = DEADTIME;
1369: while ((fd = creat(SUBLOCK, 0444)) < 0) {
1370: if (--i < 0) {
1371: (void) unlink(SUBLOCK);
1372: logerr("News system locked up");
1373: }
1374: if (i < -3)
1375: xerror("Unable to unlock news system");
1376: sleep((unsigned)1);
1377: }
1378: (void) close(fd);
1379: }
1380: }
1381:
1382: unlock()
1383: {
1384: if (--lockcount == 0)
1385: (void) unlink(SUBLOCK);
1386: }
1387:
1388: #else /* !VMS */
1389:
1390: /*
1391: * Newsystem locking.
1392: */
1393:
1394: #if defined(BSD4_2) || defined(LOCKF)
1395: #ifdef LOCKF
1396: #include <unistd.h>
1397: #else /* !LOCKF */
1398: #include <sys/file.h>
1399: #endif /* !LOCKF */
1400: static int LockFd = -1;
1401: lock()
1402: {
1403: LockFd = open(SUBFILE, 2);
1404: if (LockFd < 0)
1405: logerr("Can't open(\"%s\", 2) to lock", SUBFILE);
1406: /* This will sleep until the other program releases the lock */
1407: /* We may need to alarm out of this, but I don't think so */
1408: #ifdef LOCKF
1409: if (lockf(LockFd, F_LOCK, 0L) < 0)
1410: #else
1411: if (flock(LockFd, LOCK_EX) < 0)
1412: #endif
1413: xerror("Can't get lock on %s: %s", SUBFILE, errmsg(errno));
1414: }
1415:
1416: unlock()
1417: {
1418: (void) close(LockFd);
1419: }
1420: #else /* !BSD4_2 */
1421: lock()
1422: {
1423: register int i;
1424: extern int errno;
1425:
1426: if (lockcount++ == 0) {
1427: i = DEADTIME;
1428: while (link(SUBFILE, LOCKFILE)) {
1429: if (errno != EEXIST)
1430: break;
1431: if (--i < 0)
1432: xerror("News system locked up");
1433: sleep((unsigned)1);
1434: }
1435: }
1436: }
1437:
1438: unlock()
1439: {
1440: if (--lockcount == 0)
1441: (void) unlink(LOCKFILE);
1442: }
1443: #endif /* !BSD4_2 */
1444: #endif /* !VMS */
1445:
1446: /* VARARGS1 */
1447: error(message, arg1, arg2, arg3)
1448: char *message;
1449: long arg1, arg2, arg3;
1450: {
1451: char buffer[LBUFLEN];
1452:
1453: fflush(stdout);
1454: (void) sprintf(buffer, message, arg1, arg2, arg3);
1455: logerr(buffer);
1456: xxit(mode == PROC ? 0 : 1);
1457: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.