![[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] / 43BSD / contrib / news / src|
Return to ifuncs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / 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.51 3/19/86";
20: #endif /* SCCSID */
21:
22: #include "iparams.h"
23: #include <errno.h>
24: #include <ctype.h>
25:
26: /*LINTLIBRARY*/
27:
28: #define AFSIZ 4000 /* size of text in the active file for initial malloc */
29:
30: /*
31: * Transmit this article to all interested systems.
32: */
33:
34: #ifdef u370
35: static struct srec srec;
36: #endif /* u370 */
37:
38: static struct hbuf h, hh;
39:
40: #ifdef MULTICAST
41: #define MAXMCAST 20
42: #define MAXMCS 10
43:
44: struct multicast {
45: char mc_name[SBUFLEN]; /* "multi-cast" name */
46: short mc_syscnt;
47: char mc_tosys[MAXMCAST][SBUFLEN];
48: } mcast[MAXMCS];
49:
50: static int mccount;
51: #endif /* MULTICAST */
52:
53: #ifndef DBM
54: char *histfile();
55: #endif /* !DBM */
56:
57: broadcast()
58: {
59: register char *hptr;
60: register char *sptr;
61: register FILE *fp;
62: #ifndef u370
63: struct srec srec;
64: #endif
65: char sentbuf[LBUFLEN];
66: int nsent = 0;
67: char *sentsys;
68:
69: /* h is a local copy of the header we can scribble on */
70: fp = xfopen(ARTICLE, "r");
71: if (hread(&h, fp, TRUE) == NULL)
72: xerror("Cannot reread article");
73: (void) fclose(fp);
74:
75: (void) strcpy(sentbuf, h.ident);
76: (void) strcat(sentbuf, " sent to ");
77: sentsys = index(sentbuf, 0);
78: nsent = 0;
79: /* break path into list of systems. */
80: sptr = hptr = h.path;
81: while ((hptr=strpbrk(hptr, NETCHRS)) != NULL) {
82: *hptr++ = '\0';
83: sptr = hptr;
84: }
85: *sptr = '\0';
86:
87: #ifdef MULTICAST
88: mccount = 0;
89: #endif /* MULTICAST */
90:
91: /* loop once per system. */
92: s_openr();
93: while (s_read(&srec)) {
94: #ifdef HIDDENNET
95: if (strncmp(srec.s_name, LOCALSYSNAME, SNLN) == 0)
96: continue;
97: #endif /* HIDDENNET */
98: if (strncmp(srec.s_name, FULLSYSNAME, SNLN) == 0)
99: continue;
100: if (sptr = srec.s_nosend) {
101: while (*sptr) {
102: while (*sptr && *sptr != ',')
103: sptr++;
104: if (*sptr == ',')
105: *sptr++ = '\0';
106: }
107: *++sptr = '\0';
108: }
109: hptr = h.path;
110: while (*hptr != '\0') {
111: if (strncmp(srec.s_name, hptr, SNLN) == 0)
112: goto contin;
113: if (sptr = srec.s_nosend) {
114: while (*sptr != '\0') {
115: if (strncmp(sptr, hptr, SNLN) == 0)
116: goto contin;
117: while (*sptr++)
118: ;
119: }
120: }
121: while (*hptr++ != '\0')
122: ;
123: }
124: if (!ngmatch(h.nbuf, srec.s_nbuf))
125: continue;
126: if (h.distribution[0] != '\0' &&
127: !ngmatch(h.distribution, srec.s_nbuf) &&
128: !ngmatch(srec.s_nbuf, h.distribution))
129: continue;
130: if (nsent) {
131: hptr = sentsys;
132: while ((sptr = index(hptr, ',')) != NULL) {
133: *sptr = '\0';
134: if (strcmp(hptr, srec.s_name) == 0) {
135: *sptr = ',';
136: goto contin;
137: }
138: *sptr++ = ',';
139: for (hptr = sptr; isspace(*hptr); hptr++)
140: ;
141: }
142: if (strcmp(hptr, srec.s_name) == 0)
143: continue;
144: }
145: /* now we've found a system to send this article to */
146: #ifdef MULTICAST
147: if (index(srec.s_flags, 'M')) {
148: /* do a "multi-cast" transmit */
149: register struct multicast *m;
150:
151: if (strlen(srec.s_name) >= SBUFLEN ||
152: strlen(srec.s_xmit) >= SBUFLEN)
153: xerror("system name too long for multicast");
154: for (m = mcast; m < &mcast[mccount]; m++)
155: if (strcmp(srec.s_xmit, m->mc_name) == 0)
156: break;
157: if (m >= &mcast[MAXMCS])
158: xerror("Too many multicasts");
159: if (m == &mcast[mccount]) {
160: mccount++;
161: m->mc_syscnt = 0;
162: strcpy(m->mc_name, srec.s_xmit);
163: }
164: if (m->mc_syscnt >= MAXMCAST)
165: xerror("Too many systems for multicast");
166: strcpy(m->mc_tosys[m->mc_syscnt++], srec.s_name);
167: } else {
168: register struct multicast *m;
169: register char **yptr;
170: char *sysptrs[MAXMCAST];
171: int mc;
172:
173: mc = 0;
174: for (m = mcast; m < &mcast[mccount]; m++)
175: if (strcmp(m->mc_name, srec.s_name) == 0) {
176: yptr = sysptrs;
177: while (mc < m->mc_syscnt)
178: *yptr++ = m->mc_tosys[mc++];
179: break;
180: }
181: if (!transmit(&srec,xfopen(ARTICLE,"r"),1,sysptrs,mc))
182: continue;
183: }
184: #else /* !MULTICAST */
185: if (!transmit(&srec, xfopen(ARTICLE, "r"), 1, (char **)0, 0))
186: continue;
187: #endif /* !MULTICAST */
188: if (nsent)
189: (void) strcat(sentbuf, ", ");
190: (void) strcat(sentbuf, srec.s_name);
191: nsent++;
192: contin:;
193: }
194: if (nsent)
195: log(sentbuf);
196: s_close();
197: }
198:
199: /*
200: * Transmit file to system.
201: */
202: #define PROC 0004
203: #ifndef MULTICAST
204: /* ARGSUSED */
205: #endif /* !MULTICAST */
206: transmit(sp, ifp, maynotify, sysnames, mc)
207: register struct srec *sp;
208: register FILE *ifp;
209: int maynotify;
210: char **sysnames;
211: int mc;
212: {
213: register FILE *ofp;
214: register int c;
215: register char *ptr;
216: char TRANS[BUFLEN];
217: char *argv[20];
218: register int pid;
219: extern char firstbufname[];
220:
221: /* A: afmt: the other machine runs an A news, so we xmit in A format */
222: int afmt = (index(sp->s_flags, 'A') != NULL);
223: /* B: use B format (this is the default - don't use this letter elsewise). */
224: /* F: append name to file */
225: int appfile = (index(sp->s_flags, 'F') != NULL);
226: /* L: local: don't send the article unless it was generated locally */
227: int local = ((ptr = index(sp->s_flags, 'L')) != NULL);
228: /* H: interpolate history line into command, use existing file */
229: int history = (index(sp->s_flags, 'H') != NULL);
230: /* M: multi-cast: this is taken care of above, but don't reuse flag */
231: #ifdef MULTICAST
232: /* O: multi-cast only, don't send article if not multicast hosts */
233: int multisend = (index(sp->s_flags, 'O') != NULL);
234: #endif /* MULTICAST */
235: /* N: notify: don't send the article, just tell him we have it */
236: int notify = maynotify && (index(sp->s_flags, 'N') != NULL);
237: /* S: noshell: don't fork a shell to execute the xmit command */
238: int noshell = (index(sp->s_flags, 'S') != NULL);
239: /* U: useexist: use the -c option to uux to use the existing copy */
240: int useexist = (index(sp->s_flags, 'U') != NULL);
241:
242: if (local && mode == PROC) {
243: local = 0;
244: while (isdigit(*++ptr))
245: local = local * 10 + *ptr - '0';
246: for (ptr = h.path; *ptr != '\0' && local >= 0; local--)
247: while (*ptr++ != '\0')
248: ;
249: if (local < 0) {
250: (void) fclose(ifp);
251: return FALSE;
252: }
253: }
254:
255: #ifdef DEBUG
256: printf("Transmitting to '%s'\n", sp->s_name);
257: #endif /* DEBUG */
258:
259: #ifdef MULTICAST
260: if (multisend && mc == 0) {
261: (void) fclose(ifp);
262: return FALSE;
263: }
264: #endif /* MULTICAST */
265:
266: if (!appfile && !useexist && !history) {
267: if (!hread(&hh, ifp, TRUE)) {
268: logerr("Bad header, not transmitting %s re %s to %s",
269: hh.ident, hh.title, sp->s_name);
270: (void) fclose(ifp);
271: return FALSE;
272: }
273: if (hh.nbuf[0] == '\0') {
274: fprintf(stderr, "Article not subscribed to by %s\n", sp->s_name);
275: (void) fclose(ifp);
276: return FALSE;
277: }
278: (void) sprintf(TRANS, "%s/trXXXXXX", SPOOL);
279: }
280:
281: if (notify) {
282: char oldid[50];
283: (void) sprintf(hh.title, "ihave %s %s", hh.ident, FULLSYSNAME);
284: (void) sprintf(hh.nbuf, "to.%s.ctl", sp->s_name);
285: (void) strcpy(oldid, hh.ident);
286: getident(&hh);
287: log("tell %s about %s, notif. id %s",
288: sp->s_name, oldid, hh.ident);
289: }
290:
291: if (appfile) {
292: if (firstbufname[0] == '\0') {
293: extern char histline[];
294: localize("junk");
295: savehist(histline);
296: xerror("No file name to xmit from");
297: }
298: if (sp->s_xmit[0] == '\0')
299: sprintf(sp->s_xmit, "%s/%s", BATCHDIR, sp->s_name);
300: #ifdef IHCC
301: (void) sprintf(TRANS, "%s/%s/%s", logdir(HOME), BATCHDIR, sp->s_xmit);
302: ofp = fopen(TRANS, "a");
303: #else /* !IHCC */
304: ofp = fopen(sp->s_xmit, "a");
305: #endif /* !IHCC */
306: if (ofp == NULL)
307: xerror("Cannot append to %s", sp->s_xmit);
308: #ifdef MULTICAST
309: fprintf(ofp, "%s", firstbufname);
310: while (--mc >= 0)
311: fprintf(ofp, " %s", *sysnames++);
312: fprintf(ofp, "\n");
313: #else /* !MULTICAST */
314: fprintf(ofp, "%s\n", firstbufname);
315: #endif /* !MULTICAST */
316: (void) fclose(ofp);
317: (void) fclose(ifp);
318: return TRUE;
319: }
320: else if (useexist) {
321: if (firstbufname[0] == '\0')
322: xerror("No file name to xmit from");
323: if (*sp->s_xmit == '\0')
324: #ifdef UXMIT
325: (void) sprintf(bfr, UXMIT, sp->s_name, firstbufname);
326: #else
327: xerror("UXMIT not defined for U flag");
328: #endif
329: else
330: #ifdef MULTICAST
331: makeargs(bfr, sp->s_xmit, firstbufname, sysnames, mc);
332: #else
333: (void) sprintf(bfr, sp->s_xmit, firstbufname);
334: #endif
335: (void) fclose(ifp);
336: } else if (history) {
337: extern char histline[];
338:
339: if (*sp->s_xmit == '\0')
340: xerror("no xmit command with H flag");
341: #ifdef MULTICAST
342: makeargs(bfr, sp->s_xmit, histline, sysnames, mc);
343: #else
344: (void) sprintf(bfr, sp->s_xmit, histline);
345: #endif
346: } else {
347: ofp = xfopen(mktemp(TRANS), "w");
348: if (afmt) {
349: #ifdef OLD
350: fprintf(ofp, "A%s\n%s\n%s!%s\n%s\n%s\n", oident(hh.ident), hh.nbuf, FULLSYSNAME,
351: hh.path, hh.subdate, hh.title);
352: #else /* !OLD */
353: logerr("Must have OLD defined to use A flag for xmit");
354: return FALSE;
355: #endif /* !OLD */
356: } else
357: hwrite(&hh, ofp);
358: if (!notify)
359: while ((c = getc(ifp)) != EOF)
360: putc(c, ofp);
361: if (ferror(ofp))
362: xerror("write failed on transmit");
363: (void) fclose(ifp);
364: (void) fclose(ofp);
365: if (*sp->s_xmit == '\0')
366: (void) sprintf(bfr, DFTXMIT, sp->s_name, TRANS);
367: else
368: #ifdef MULTICAST
369: makeargs(bfr, sp->s_xmit, TRANS, sysnames, mc);
370: #else /* !MULTICAST */
371: (void) sprintf(bfr, sp->s_xmit, TRANS);
372: #endif /* !MULTICAST */
373: }
374:
375: /* At this point, the command to be executed is in bfr. */
376: if (noshell) {
377: if (pid = fork())
378: fwait(pid);
379: else {
380: (void) close(0);
381: (void) open(TRANS, 0);
382: ptr = bfr;
383: for (pid = 0; pid < 19; pid++) {
384: while (isspace(*ptr))
385: *ptr++ = 0;
386: argv[pid] = ptr;
387: while (!isspace(*++ptr) && *ptr)
388: ;
389: if (!*ptr)
390: break;
391: }
392: argv[++pid] = 0;
393: (void) setgid(gid);
394: (void) setuid(uid);
395: execv(argv[0], argv);
396: xerror("Can't execv %s", argv[0]);
397: }
398: } else {
399: if (!history && sp->s_xmit[0] && !index(bfr, '<')) {
400: char newcmd[LBUFLEN];
401:
402: (void) sprintf(newcmd, "(%s) <%s", bfr,
403: useexist ? firstbufname : TRANS);
404: system(newcmd);
405: } else
406: system(bfr);
407: }
408: if (!appfile && !useexist && !history)
409: (void) unlink(TRANS);
410: (void) fclose(ifp);
411: return TRUE;
412: }
413:
414: #ifdef MULTICAST
415: makeargs(buf, cmd, arg2, sysargs, sac)
416: char *buf;
417: char *cmd;
418: char *arg2;
419: register char **sysargs;
420: int sac;
421: {
422: register char *p = cmd;
423: register char *q;
424: register ac = 0;
425: register char *b = buf;
426:
427: q = p;
428: do {
429: if (q = index(q, ' '))
430: *q = '\0';
431: if (index(p, '%')) {
432: switch (++ac) {
433: case 1:
434: while (--sac >= 0) {
435: sprintf(b, p, *sysargs++);
436: b = index(b, '\0');
437: }
438: break;
439: case 2:
440: sprintf(b, p, arg2);
441: b = index(b, '\0');
442: break;
443: default:
444: if (q)
445: *q = ' ';
446: xerror("badly formed command: %s", cmd);
447: }
448: } else {
449: strcpy(b, p);
450: b = index(b, '\0');
451: }
452: if (q) {
453: *q = ' ';
454: p = q;
455: while (isspace(*q))
456: q++;
457: }
458: } while (q != NULL);
459: }
460: #endif /* MULTICAST */
461:
462: typedef struct {
463: char *dptr;
464: int dsize;
465: } datum;
466:
467: /*
468: * Return TRUE if we have seen this file before, else FALSE.
469: */
470: history(hp)
471: struct hbuf *hp;
472: {
473: #ifdef DBM
474: datum lhs, rhs;
475: datum fetch();
476: #else /* !DBM */
477: register FILE *hfp;
478: register char *p;
479: #endif /* !DBM */
480: char lcident[BUFLEN];
481: extern char histline[];
482:
483: #ifdef DEBUG
484: fprintf(stderr,"history(%s)\n", hp->ident);
485: #endif /* DEBUG */
486: /*
487: * Make the article ID case insensitive.
488: */
489: (void) strcpy(lcident, hp->ident);
490: lcase(lcident);
491:
492: idlock(lcident);
493: #ifdef DBM
494: initdbm(ARTFILE);
495: lhs.dptr = lcident;
496: lhs.dsize = strlen(lhs.dptr) + 1;
497: rhs = fetch(lhs);
498: if (rhs.dptr)
499: return(TRUE);
500: #else /* !DBM */
501: hfp = xfopen(histfile(lcident), "r");
502: while (fgets(bfr, BUFLEN, hfp) != NULL) {
503: p = index(bfr, '\t');
504: if (p == NULL)
505: p = index(bfr, '\n');
506: if (p != NULL) /* can happen if nulls in file */
507: *p = 0;
508: lcase(bfr);
509:
510: if (strcmp(bfr, lcident) == 0) {
511: (void) fclose(hfp);
512: idunlock();
513: #ifdef DEBUG
514: fprintf(stderr,"history returns true\n");
515: #endif /* DEBUG */
516: return TRUE;
517: }
518: }
519: (void) fclose(hfp);
520: #endif /* !DBM */
521: histline[0] = '\0';
522: addhist(hp->ident);
523: addhist("\t");
524: #ifdef DEBUG
525: fprintf(stderr,"history returns false\n");
526: #endif
527: return FALSE;
528: }
529:
530: char histline[PATHLEN];
531:
532: addhist(msg)
533: char *msg;
534: {
535: (void) strcat(histline, msg);
536: }
537:
538: savehist(hline)
539: char *hline;
540: {
541: register FILE *hfp;
542: datum lhs, rhs;
543: long fpos;
544: register char *p;
545:
546: hfp = xfopen(ARTFILE, "a");
547: fpos = ftell(hfp);
548: fprintf(hfp, "%s\n", hline);
549: (void) fclose(hfp);
550: #ifdef DBM
551: /* We assume that history has already been called, calling dbminit. */
552: p = index(hline, '\t');
553: if (p)
554: *p = 0;
555: lcase(hline);
556: lhs.dptr = hline;
557: lhs.dsize = strlen(lhs.dptr) + 1;
558: rhs.dptr = (char *)&fpos;
559: rhs.dsize = sizeof fpos;
560: store(lhs, rhs);
561: #else /* !DBM */
562: /* also append to proper history subfile */
563: hfp = xfopen(histfile(hline), "a");
564: fprintf(hfp, "%s\n", hline);
565: (void) fclose(hfp);
566: #endif /* !DBM */
567: idunlock();
568: }
569:
570: /*
571: * Save partial news.
572: */
573: /* ARGSUSED */
574: newssave(fd, dummy)
575: FILE *fd;
576: char *dummy;
577: {
578: register FILE *tofd, *fromfd;
579: char sfname[BUFLEN];
580: register int c;
581: time_t tim;
582:
583: if (fd == NULL)
584: fromfd = xfopen(INFILE, "r");
585: else
586: fromfd = fd;
587: (void) umask(savmask);
588: (void) setgid(gid);
589: (void) setuid(uid);
590:
591: (void) sprintf(sfname, "%s/%s", userhome, PARTIAL);
592: if ((tofd = fopen(sfname, "a")) == NULL)
593: xerror("Cannot save partial news in %s", sfname);
594: (void) time(&tim);
595: fprintf(tofd, "----- News saved at %s\n", arpadate(&tim));
596: while ((c = getc(fromfd)) != EOF)
597: putc(c, tofd);
598: (void) fclose(fromfd);
599: (void) fclose(tofd);
600: printf("News saved in %s\n", sfname);
601: xxit(1);
602: }
603:
604: /*
605: * Handle dates in header.
606: */
607:
608: dates(hp)
609: struct hbuf *hp;
610: {
611: time_t edt;
612:
613: if (*hp->subdate) {
614: if (cgtdate(hp->subdate) < 0) {
615: xerror("Cannot parse submittal date '%s'", hp->subdate);
616: }
617: } else {
618: (void) time(&edt);
619: (void) strcpy(hp->subdate, arpadate(&edt));
620: }
621: }
622:
623: char lockname[80];
624: idlock(str)
625: char *str;
626: {
627: register int i;
628: char tempname[80];
629: time_t now;
630: struct stat sbuf;
631: extern int errno;
632: #ifdef VMS
633: int fd;
634:
635: (void) sprintf(lockname, "/tmp/%s.l.1", str);
636: if ((fd = creat(lockname, 0444)) < 0) {
637: #else /* !VMS */
638: (void) strcpy(tempname, "/tmp/LTMP.XXXXXX");
639: (void) mktemp(tempname);
640: (void) sprintf(lockname, "/tmp/L%s", str);
641: #ifdef FOURTEENMAX
642: lockname[5 /* /tmp/ */ + 14] = '\0';
643: #endif
644: i = creat(tempname, 0666);
645: if (i < 0)
646: xerror("Cannot creat %s: errno %d", tempname, errno);
647: (void) close(i);
648: while (link(tempname, lockname)) {
649: #endif /* !VMS */
650: (void) time(&now);
651: i = stat(lockname, &sbuf);
652: if (i < 0) {
653: xerror("Directory permission problem in /tmp");
654: }
655: if (sbuf.st_mtime + 10*60 < now) {
656: (void) unlink(lockname);
657: logerr("Article %s locked up", str);
658: break;
659: }
660: log("waiting on lock for %s", lockname);
661: sleep((unsigned)60);
662: }
663: #ifdef VMS
664: (void) close(fd);
665: #endif
666: (void) unlink(tempname);
667: }
668:
669: idunlock()
670: {
671: (void) unlink(lockname);
672: }
673:
674: /*
675: * Put a unique name into header.ident.
676: */
677: getident(hp)
678: struct hbuf *hp;
679: {
680: long seqn;
681: register FILE *fp;
682:
683: lock();
684: fp = xfopen(SEQFILE, "r");
685: (void) fgets(bfr, BUFLEN, fp);
686: (void) fclose(fp);
687: seqn = atol(bfr) + 1;
688: #ifdef VMS
689: (void) unlink(SEQFILE);
690: #endif /* VMS */
691: fp = xfopen(SEQFILE, "r+w");
692: fprintf(fp, "%ld\n", seqn);
693: (void) fclose(fp);
694: unlock();
695: #ifdef HIDDENNET
696: if (strcmp(LOCALSYSNAME, FULLSYSNAME))
697: (void) sprintf(hp->ident, "<%ld@%s.%s%s>", seqn, LOCALSYSNAME, FULLSYSNAME,
698: MYDOMAIN);
699: else
700: #endif /* !HIDDENNET */
701: (void) sprintf(hp->ident, "<%ld@%s%s>", seqn, FULLSYSNAME, MYDOMAIN);
702: }
703:
704: /*
705: * Check that header.nbuf contains only valid newsgroup names;
706: * exit with error if not valid.
707: *
708: */
709: ngfcheck(isproc)
710: int isproc;
711: {
712: register char *s1, *s2;
713: register FILE *f;
714: register char *os1;
715: int ngroups = 1;
716: unsigned int ngsize = AFSIZ;
717: char tbuf[BUFLEN], *ngcheck;
718:
719: f = xfopen(ACTIVE, "r");
720: ngcheck = malloc(ngsize);
721: if (ngcheck == NULL)
722: xerror("Can't malloc the active file");
723: s1 = ngcheck;
724: while (fgets(bfr, BUFLEN, f) != NULL) {
725: os1 = s1;
726: for(s2 = bfr; *s2 != '\0' && *s2 != ' ';) {
727: if (s1 >= &ngcheck[ngsize-2]) {
728: unsigned int offs = s1 - ngcheck;
729: ngsize += LBUFLEN;
730: ngcheck = realloc(ngcheck, ngsize);
731: if (ngcheck == NULL)
732: xerror("Can't realloc active file");
733: s1 = ngcheck + offs;
734: }
735: *s1++ = *s2++;
736: }
737: *s1++ = '\0';
738: if (isproc) /* don't check to see if can post to this group */
739: continue;
740: while (*s2++ != '\0' && *s2 != ' ')
741: ; /* skip max article number */
742: while (*s2++ != '\0' && *s2 != ' ')
743: ; /* skip min article number */
744: if (*s2++ != '\0' && *s2 == 'n')
745: s1 = os1; /* can't post to this group */
746: }
747: *s1++ = '\0';
748: *s1 = '\0';
749: (void) fclose(f);
750:
751: s1 = header.nbuf;
752: s2 = nbuf;
753: while (*s1 == NGDELIM || *s1 == ' ')
754: s1++; /* skip leading junk */
755: do {
756: /* there shouldn't be blanks, but give the jerk a break */
757: if (*s1 == NGDELIM || *s1 == ' ') {
758: *s2++ = '\0';
759: while (*++s1 == NGDELIM || *s1 == ' ')
760: ; /* remove extra commas */
761: if (*s1 != '\0')
762: ngroups++;
763: } else
764: *s2++ = *s1++;
765: } while (*s1 != '\0');
766: if (s2[-1] == NGDELIM) /* strip trailing commas */
767: s2--;
768: *s2 = '\0';
769:
770: s1 = nbuf;
771: while (*s1 != '\0') { /* for each newsgroup in header */
772: s2 = ngcheck;
773: while (*s2 != '\0') { /* for each newsgroup in active file */
774: if (strcmp(s1, s2) == 0)
775: break;
776: while (*s2++ != '\0')
777: ;
778: }
779: if (*s2 == '\0') { /* not found. remove it */
780: if (!isproc) {
781: logerr("Invalid news group '%s'", s1);
782: newssave(stdin, (char *)NULL);
783: }
784: /* See if it's in our alias list */
785: f = xfopen(ALIASES,"r");
786: while (fscanf(f,"%s %s", tbuf, bfr) == 2
787: && strcmp(s1, tbuf))
788: ;
789: (void) fclose(f);
790: if (strcmp(s1, tbuf) == 0) {
791: logerr("Aliased newsgroup '%s' to '%s'", s1, bfr);
792: os1 = s1;
793: s1 = nbuf;
794: s2 = tbuf;
795: while (s1 < os1) /* copy left part */
796: *s2++ = *s1++;
797: s1 = bfr;
798: while (*s1 != '\0') /* copy alias */
799: *s2++ = *s1++;
800: *s2++ = '\0';
801: s1 = os1;
802: os1 = nbuf + (s2 - tbuf);
803: while (*s1++ != '\0') /* skip old group */
804: ;
805: /* copy right part */
806: tbufcpy(s2, s1);
807: /* copy back to original buffer */
808: tbufcpy(nbuf, tbuf);
809: s1 = os1;
810: } else {
811: logerr("Unknown newsgroup '%s' removed", s1);
812: s2 = s1;
813: while (*s2++ != '\0') /* skip the bad one */
814: ;
815: tbufcpy(s1, s2);
816: }
817: } else { /* It's in our active file */
818: os1 = s1;
819: while (*s1++ != '\0')
820: ;
821: /* check for local only distribution on incoming
822: newsgroups. This might occur if someone posted to
823: general,net.unix */
824: if(isproc && ngroups > 1 && index(os1, '.') == NULL
825: && index(header.nbuf, '.') != NULL) {
826: logerr("Local group '%s' removed", os1);
827: tbufcpy(os1, s1);
828: s1 = os1;
829: }
830: }
831: }
832: /* remove any duplicates */
833: os1 = s1 = nbuf;
834: for(;;) {
835: if (*s1++ == '\0') {
836: if (*s1 == '\0')
837: break;
838: s2 = s1;
839: while (*s2 != '\0') {
840: if (strcmp(os1, s2) == 0) {
841: logerr("Duplicate '%s' removed",os1);
842: os1 = s2;
843: while (*s2++ != '\0') /* skip it */
844: ;
845: tbufcpy(os1, s2);
846: } else
847: while (*s2++ != '\0')
848: ;
849: }
850: os1 = s1;
851: s1[-1] = '\0';
852: }
853: }
854: if (nbuf[0] != '\0') {
855: s1 = header.nbuf;
856: s2 = nbuf;
857: do {
858: while (*s2 != '\0')
859: *s1++ = *s2++;
860: *s1++ = NGDELIM;
861: } while (*++s2 != '\0');
862: *--s1 = '\0';
863: (void) free(ngcheck);
864: return FALSE;
865: }
866: (void) free(ngcheck);
867: return TRUE;
868: }
869:
870: tbufcpy(s1, s2)
871: register char *s1, *s2;
872: {
873: do {
874: while (*s2 != '\0')
875: *s1++ = *s2++;
876: *s1++ = '\0';
877: } while (*++s2 != '\0');
878: *s1 = '\0';
879: }
880:
881:
882: /*
883: * Figure out who posted the article (which is locally entered).
884: * The results are placed in the header structure hp.
885: */
886: gensender(hp, logname)
887: struct hbuf *hp;
888: char *logname;
889: {
890: register char *fn, *p;
891: char buf[BUFLEN];
892: char *fullname(), *getenv();
893: int fd, n;
894:
895: fn = getenv("NAME");
896:
897: if (fn == NULL) {
898: (void) sprintf(buf, "%s/%s", userhome, ".name");
899: fd = open(buf, 0);
900: if (fd >= 0) {
901: n = read(fd, buf, sizeof buf);
902: (void) close(fd);
903: if (n > 0 && buf[0] >= 'A') {
904: fn = buf;
905: for (p=fn; *p; p++)
906: if (*p < ' ')
907: *p = '\0';
908: }
909: }
910: }
911:
912: if (fn == NULL)
913: fn = fullname(logname);
914:
915: (void) sprintf(hp->path, "%s", logname);
916: (void) sprintf(hp->from, "%s@%s%s (%s)", logname, FULLSYSNAME, MYDOMAIN, fn);
917: }
918:
919: /*
920: * Trap interrupts.
921: */
922: onsig(n)
923: int n;
924: {
925: static int numsigs = 0;
926: /*
927: * Most UNIX systems reset caught signals to SIG_DFL.
928: * This bad design requires that the trap be set again here.
929: * Unfortunately, if the signal recurs before the trap is set,
930: * the program will die, possibly leaving the lock in place.
931: */
932: if (++numsigs > 100) {
933: logerr("inews ran away looping on signal %d", n);
934: xxit(1);
935: }
936: (void) signal(n, onsig);
937: SigTrap = n;
938: }
939:
940: #ifdef BATCH
941: /*
942: * If the stdin begins with "#", we assume we have been fed a batched
943: * shell script which looks like this:
944: * #! rnews 1234
945: * article with 1234 chars
946: * #! rnews 4321
947: * article with 4321 chars
948: *
949: * In this case we just exec the unbatcher and let it unpack and call us back.
950: *
951: * Note that there is a potential security hole here. If the batcher is
952: * /bin/sh, someone could ship you arbitrary stuff to run as shell commands.
953: * The main protection you have is that the effective uid will be news, not
954: * uucp and not the super user. (That, plus the fact that BATCH is set to
955: * "unbatch" as the system is distributed.) If you want to run a batched link
956: * and you are security conscious, do not use /bin/sh as the unbatcher.
957: * the thing to do is to change BATCH in your localize.sh file from /bin/sh
958: * to some restricted shell which can only run rnews.
959: */
960: checkbatch()
961: {
962: int c;
963:
964: c = getc(stdin);
965: if (c != EOF)
966: (void) ungetc(c, stdin);
967: clearerr(stdin);
968: if (c == '#') {
969: char unbatcher[BUFLEN];
970:
971: (void) sprintf(unbatcher, "%s/%s", LIB, BATCH);
972: reset_stdin();
973: execl(unbatcher, "news-unpack", (char *)0);
974: xerror("Unable to exec shell to unpack news.");
975: }
976: }
977:
978: /*
979: * We've already done a read on stdin, and we want to seek back to the
980: * beginning. We want the real file descriptor (beyond buffers) to
981: * reflect the true beginning. Do whatever is necessary.
982: */
983: reset_stdin()
984: {
985: register FILE *ofd;
986: register int c;
987: char *ofdname;
988: long lseek();
989:
990: /* First try to seek back - if so, it's a cheap way back. */
991: if (lseek(0, 0L, 0) == 0L)
992: return;
993:
994: /* Can't seek, so have to copy input to a file and use that. */
995: ofdname = "/tmp/inewsXXXXXX";
996: (void) mktemp(ofdname);
997: ofd = fopen(ofdname, "w");
998: while ((c=getc(stdin)) != EOF)
999: putc(c, ofd);
1000: if (ferror(ofd))
1001: xerror("write failed on temp file %s", ofdname);
1002: (void) fclose(stdin);
1003: (void) fclose(ofd);
1004:
1005: /* Now for a few lower level hacks to reopen stdin and make
1006: * absolutely sure that the right fd's are done for the exec.
1007: */
1008: (void) close(0); /* make sure stdin is really closed. */
1009: (void) open(ofdname, 0); /* should return zero */
1010: (void) unlink(ofdname); /* to avoid cleaning it up later. */
1011: }
1012: #endif /* BATCH */
1013:
1014: /*
1015: * Exit and cleanup.
1016: */
1017: xxit(status)
1018: int status;
1019: {
1020: (void) unlink(INFILE);
1021: (void) unlink(ARTICLE);
1022: while (lockcount > 0)
1023: unlock();
1024: idunlock();
1025: exit(status);
1026: }
1027:
1028: rwaccess(fname)
1029: char *fname;
1030: {
1031: int fd;
1032:
1033: fd = open(fname, 2);
1034: if (fd < 0)
1035: return 0;
1036: (void) close(fd);
1037: return 1;
1038: }
1039:
1040: exists(fname)
1041: char *fname;
1042: {
1043: int fd;
1044:
1045: fd = open(fname, 0);
1046: if (fd < 0)
1047: return 0;
1048: (void) close(fd);
1049: return 1;
1050: }
1051:
1052: int lockcount = 0; /* no. of times we've called lock */
1053:
1054: #ifdef VMS
1055:
1056: #define SUBLOCK "/tmp/netnews.lck.1"
1057:
1058: /*
1059: * Newsystem locking.
1060: * These routines are different for VMS because we can not
1061: * effectively simulate links, and VMS supports multiple
1062: * version numbers of files
1063: */
1064: lock()
1065: {
1066: register int i;
1067: register int fd;
1068:
1069: if (lockcount++ == 0) {
1070: i = DEADTIME;
1071: while ((fd = creat(SUBLOCK, 0444)) < 0) {
1072: if (--i < 0) {
1073: (void) unlink(SUBLOCK);
1074: logerr("News system locked up");
1075: }
1076: if (i < -3)
1077: xerror("Unable to unlock news system");
1078: sleep((unsigned)1);
1079: }
1080: (void) close(fd);
1081: }
1082: }
1083:
1084: unlock()
1085: {
1086: if (--lockcount == 0)
1087: (void) unlink(SUBLOCK);
1088: }
1089:
1090: #else /* !VMS */
1091:
1092: /*
1093: * Newsystem locking.
1094: */
1095:
1096: #ifdef BSD4_2
1097: #include <sys/file.h>
1098: static int LockFd = -1;
1099: lock()
1100: {
1101: LockFd = open(SUBFILE,0);
1102: /* This will sleep until the other program releases the lock */
1103: /* We may need to alarm out of this, but I don't think so */
1104: (void) flock(LockFd, LOCK_EX);
1105: }
1106:
1107: unlock()
1108: {
1109: (void) flock(LockFd, LOCK_UN);
1110: (void) close(LockFd);
1111: }
1112: #else /* !BSD4_2 */
1113: /* Why doesn't USG unix have file locking????? */
1114: lock()
1115: {
1116: register int i;
1117: extern int errno;
1118:
1119: if (lockcount++ == 0) {
1120: i = DEADTIME;
1121: while (link(SUBFILE, LOCKFILE)) {
1122: if (errno != EEXIST)
1123: break;
1124: if (--i < 0)
1125: xerror("News system locked up");
1126: sleep((unsigned)1);
1127: }
1128: }
1129: }
1130:
1131: unlock()
1132: {
1133: if (--lockcount == 0)
1134: (void) unlink(LOCKFILE);
1135: }
1136: #endif /* !BSD4_2 */
1137: #endif /* !VMS */
1138:
1139: /*
1140: * Generate the name of the person responsible for posting this article,
1141: * in order to check that two articles were posted by the same person.
1142: */
1143: char *
1144: senderof(hp)
1145: struct hbuf *hp;
1146: {
1147: char *q, *tp;
1148: char *tailpath();
1149:
1150: if (hp->sender[0])
1151: tp = hp->sender;
1152: else if (hp->from[0])
1153: tp = hp->from;
1154: else
1155: tp = tailpath(hp);
1156:
1157: /* Remove full name */
1158: q = index(tp, ' ');
1159: if (q)
1160: *q = '\0';
1161:
1162: q = malloc((unsigned)(strlen(tp) + 1));
1163: (void) strcpy(q, tp);
1164: return q;
1165: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.