![[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 [Research Unix] / researchv10no / cmd / netnews / src|
Return to ifuncs.c CVS log | Up to [Research Unix] / researchv10no / cmd / netnews / src |
1.1 root 1: /*
2: * ifuncs - functions used by inews.
3: */
4:
5: static char *SccsId = "@(#)ifuncs.c 2.21 3/31/83";
6:
7: #include "iparams.h"
8:
9: /*
10: * Transmit this article to all interested systems.
11: */
12:
13: #ifdef u370
14: static struct srec srec;
15: static struct hbuf h;
16: #endif
17:
18: broadcast()
19: {
20: register char *nptr, *hptr;
21: register FILE *fp;
22: #ifndef u370
23: struct srec srec;
24: struct hbuf h;
25: #endif
26:
27: /* h is a local copy of the header we can scribble on */
28: fp = xfopen(ARTICLE, "r");
29: if (hread(&h, fp, TRUE) == NULL)
30: xerror("Cannot reread article");
31: fclose(fp);
32: if (h.distribution[0])
33: strcpy(h.nbuf, h.distribution);
34: ngcat(h.nbuf);
35:
36: /* break path into list of systems. */
37: hptr = nptr = h.path;
38: while (*hptr != '\0') {
39: if (index(NETCHRS, *hptr)) {
40: *hptr++ = '\0';
41: nptr = hptr;
42: } else
43: hptr++;
44: }
45: *nptr = '\0';
46:
47: /* loop once per system. */
48: lock();
49: s_openr();
50: while (s_read(&srec)) {
51: if (strncmp(srec.s_name, FULLSYSNAME, SNLN) == 0)
52: continue;
53: hptr = h.path;
54: while (*hptr != '\0') {
55: if (strncmp(srec.s_name, hptr, SNLN) == 0)
56: goto contin;
57: while (*hptr++ != '\0')
58: ;
59: }
60: if (ngmatch(h.nbuf, srec.s_nbuf)) {
61: transmit(&srec, xfopen(ARTICLE, "r"), 1);
62: }
63: contin:;
64: }
65: s_close();
66: unlock();
67: }
68:
69: /*
70: * Transmit file to system.
71: */
72: #define PROC 0004
73: transmit(sp, ifp, maynotify)
74: register struct srec *sp;
75: register FILE *ifp;
76: int maynotify;
77: {
78: register FILE *ofp;
79: register int c;
80: register char *ptr;
81: struct hbuf hh;
82: char TRANS[BUFLEN];
83: char *argv[20];
84: register int pid, fd;
85: extern char firstbufname[];
86:
87: /* A: afmt: the other machine runs an A news, so we xmit in A format */
88: int afmt = (index(sp->s_flags, 'A') != NULL);
89: /* B: use B format (this is the default - don't use this letter elsewise). */
90: /* F: append name to file */
91: int appfile = (index(sp->s_flags, 'F') != NULL);
92: /* L: local: don't send the article unless it was generated locally */
93: int local = (index(sp->s_flags, 'L') != NULL);
94: /* N: notify: don't send the article, just tell him we have it */
95: int notify = maynotify && (index(sp->s_flags, 'N') != NULL);
96: /* S: noshell: don't fork a shell to execute the xmit command */
97: int noshell = (index(sp->s_flags, 'S') != NULL);
98: /* U: useexist: use the -c option to uux to use the existing copy */
99: int useexist = (index(sp->s_flags, 'U') != NULL);
100:
101: if (local && mode == PROC)
102: return;
103: #ifdef DEBUG
104: printf("Transmitting to '%s'\n", sp->s_name);
105: #endif
106: if (!appfile && !useexist) {
107: if (hread(&hh, ifp, TRUE) == NULL) {
108: fprintf(stderr, "Bad header, not transmitting\n");
109: log("Bad header, not transmitting %s re %s to %s",
110: hh.ident, hh.title, sp->s_name);
111: return;
112: }
113: /* Taken out for obscure reasons - see the standard.
114: ngsquash(hh.nbuf, sp->s_nbuf);
115: */
116: if (hh.nbuf[0] == '\0') {
117: printf("Article not subscribed to by %s\n", sp->s_name);
118: return;
119: }
120: sprintf(TRANS, "%s/trXXXXXX", SPOOL);
121: }
122:
123: if (notify) {
124: char oldid[50];
125: sprintf(hh.title, "ihave %s %s", hh.ident, FULLSYSNAME);
126: sprintf(hh.nbuf, "to.%s.ctl", sp->s_name);
127: strcpy(oldid, hh.ident);
128: getident(&hh);
129: log("tell %s about %s, notif. id %s",
130: sp->s_name, oldid, hh.ident);
131: } else
132: log("xmit article %s to %s",
133: hh.ident, sp->s_name);
134:
135: if (appfile) {
136: if (firstbufname[0] == '\0')
137: xerror("No file name to xmit from");
138: ofp = fopen(sp->s_xmit, "a");
139: if (ofp == NULL)
140: xerror("Cannot append to %s", sp->s_xmit);
141: fprintf(ofp, "%s\n", firstbufname);
142: fclose(ofp);
143: return;
144: }
145: else
146: #ifdef UXMIT
147: if (useexist) {
148: if (firstbufname[0] == '\0')
149: xerror("No file name to xmit from");
150: if (*sp->s_xmit == '\0')
151: sprintf(bfr, UXMIT, sp->s_name, firstbufname);
152: else
153: sprintf(bfr, sp->s_xmit, firstbufname);
154: } else
155: #endif
156: {
157: ofp = xfopen(mktemp(TRANS), "w");
158: if (afmt)
159: ohwrite(&hh, ofp);
160: else
161: hwrite(&hh, ofp);
162: if (!notify)
163: while ((c = getc(ifp)) != EOF)
164: putc(c, ofp);
165: fclose(ifp);
166: fclose(ofp);
167: if (*sp->s_xmit == '\0')
168: sprintf(bfr, DFTXMIT, sp->s_name, TRANS);
169: else
170: sprintf(bfr, "(%s) < %s", sp->s_xmit, TRANS);
171: }
172:
173: /* At this point, the command to be executed is in bfr. */
174: if (noshell) {
175: if (pid = fork())
176: fwait(pid);
177: else {
178: close(0);
179: open(TRANS, 0);
180: ptr = sp->s_xmit;
181: for (pid = 0; pid < 19; pid++) {
182: while (isspace(*ptr))
183: *ptr++ = 0;
184: argv[pid] = ptr;
185: while (!isspace(*++ptr) && *ptr)
186: ;
187: if (!*ptr)
188: break;
189: }
190: argv[++pid] = 0;
191: execv(sp->s_xmit, argv);
192: xerror("Can't execv\n");
193: }
194: } else
195: system(bfr);
196: if (!appfile && !useexist)
197: unlink(TRANS);
198: }
199:
200: typedef struct {
201: char *dptr;
202: int dsize;
203: } datum;
204:
205: /*
206: * Return TRUE if we have seen this file before, else FALSE.
207: */
208: history(hp)
209: struct hbuf *hp;
210: {
211: register FILE *hfp;
212: register char *p;
213: datum lhs, rhs;
214: datum fetch();
215:
216: #ifdef DEBUG
217: fprintf(stderr,"history(%s)\n", hp->ident);
218: #endif
219: idlock(hp->ident);
220: #ifdef DBM
221: dbminit(ARTFILE);
222: lhs.dptr = hp->ident;
223: lhs.dsize = strlen(lhs.dptr) + 1;
224: rhs = fetch(lhs);
225: if (rhs.dptr)
226: return(TRUE);
227: #else
228: hfp = xfopen(ARTFILE, "r");
229: while (fgets(bfr, BUFLEN, hfp) != NULL) {
230: p = index(bfr, '\t');
231: if (p == NULL)
232: p = index(bfr, '\n');
233: if (p != NULL) /* can happen if nulls in file */
234: *p = 0;
235: if (strcmp(bfr, hp->ident)==0 ||
236: hp->oident[0] && strcmp(bfr, hp->oident)==0) {
237: fclose(hfp);
238: idunlock();
239: #ifdef DEBUG
240: fprintf(stderr,"history returns true\n");
241: #endif
242: return(TRUE);
243: }
244: }
245: fclose(hfp);
246: #endif
247: addhist(hp->ident);
248: addhist("\t");
249: #ifdef DEBUG
250: fprintf(stderr,"history returns false\n");
251: #endif
252: return(FALSE);
253: }
254:
255: static char histline[256]; /* Assumed initially zero */
256:
257: addhist(msg)
258: char *msg;
259: {
260: strcat(histline, msg);
261: }
262:
263: savehist()
264: {
265: register FILE *hfp;
266: datum lhs, rhs;
267: long fpos;
268: register char *p;
269:
270: hfp = xfopen(ARTFILE, "a");
271: fpos = ftell(hfp);
272: fprintf(hfp, "%s\n", histline);
273: fclose(hfp);
274: #ifdef DBM
275: /* We assume that history has already been called, calling dbminit. */
276: p = index(histline, '\t');
277: if (p)
278: *p = 0;
279: lhs.dptr = histline;
280: lhs.dsize = strlen(lhs.dptr) + 1;
281: rhs.dptr = (char *) &fpos;
282: rhs.dsize = sizeof fpos;
283: store(lhs, rhs);
284: #endif
285: histline[0] = 0;
286: idunlock();
287: }
288:
289: /*
290: * Save partial news.
291: */
292: newssave(fd, dummy)
293: FILE *fd, *dummy;
294: {
295: register FILE *tofd, *fromfd;
296: char sfname[BUFLEN];
297: register int c;
298: struct hbuf h;
299: time_t tim;
300:
301: if (fd == NULL)
302: fromfd = xfopen(INFILE, "r");
303: else
304: fromfd = fd;
305: umask(savmask);
306: setgid(gid);
307: setuid(uid);
308:
309: sprintf(sfname, "%s/%s", userhome, PARTIAL);
310: if ((tofd = fopen(sfname, "a")) == NULL)
311: xerror("Cannot save partial news");
312: time(&tim);
313: fprintf(tofd, "----- News saved at %s\n", arpadate(&tim));
314: while ((c = getc(fromfd)) != EOF)
315: putc(c, tofd);
316: fclose(fromfd);
317: fclose(tofd);
318: printf("News saved in %s\n", sfname);
319: xxit(0);
320: }
321:
322: /*
323: * Handle dates in header.
324: */
325:
326: dates(hp)
327: struct hbuf *hp;
328: {
329: long edt;
330:
331: time(&hp->rectime);
332: nstrip(strcpy(hp->recdate, arpadate(&hp->rectime)));
333: if (*hp->subdate) {
334: if (cgtdate(hp->subdate) < 0) {
335: log("Bad sub date '%s'", hp->subdate);
336: xerror("Cannot parse submittal date");
337: }
338: } else
339: strcpy(hp->subdate, hp->recdate);
340: if (*hp->expdate) {
341: if ((edt = cgtdate(hp->expdate)) < 0)
342: xerror("Cannot parse expiration date");
343: nstrip(strcpy(hp->expdate, arpadate(&edt)));
344: } else {
345: defexp = TRUE;
346: /*
347: * Default is now applied in expire.c
348: hp->exptime = hp->rectime + DFLTEXP;
349: nstrip(strcpy(hp->expdate, arpadate(&hp->exptime)));
350: */
351: }
352: }
353:
354: /*
355: * Exit and cleanup.
356: */
357: xxit(status)
358: int status;
359: {
360: unlink(INFILE);
361: unlink(ARTICLE);
362: while (lockcount > 0)
363: unlock();
364: idunlock();
365: exit(status);
366: }
367:
368: xerror(message, arg1, arg2)
369: char *message;
370: int arg1, arg2;
371: {
372: char buffer[128];
373:
374: fflush(stdout);
375: sprintf(buffer, message, arg1, arg2);
376: fprintf(stderr, "inews: %s.\n", buffer);
377: log(buffer);
378: xxit(1);
379: }
380:
381: #ifdef VMS
382:
383: #define SUBLOCK "/tmp/netnews.lck.1"
384:
385: /*
386: * Newsystem locking.
387: * These routines are different for VMS because we can not
388: * effectively simulate links, and VMS supports multiple
389: * version numbers of files
390: */
391: lock()
392: {
393: register int i;
394: register int fd;
395:
396: if (lockcount++ == 0) {
397: i = DEADTIME;
398: while ((fd = creat(SUBLOCK, 0444)) < 0) {
399: if (--i < 0) {
400: unlink(SUBLOCK);
401: log("News system locked up");
402: }
403: if (i < -3)
404: xerror("Unable to unlock news system");
405: sleep((unsigned)1);
406: }
407: close(fd);
408: }
409: }
410:
411: unlock()
412: {
413: if (--lockcount == 0)
414: unlink(SUBLOCK);
415: }
416:
417: #else VMS
418:
419: /*
420: * Newsystem locking.
421: */
422:
423: lock()
424: {
425: register int i;
426:
427: if (lockcount++ == 0) {
428: i = DEADTIME;
429: while (link(SUBFILE, LOCKFILE)) {
430: if (--i < 0)
431: xerror("News system locked up");
432: sleep((unsigned)1);
433: }
434: }
435: }
436:
437: unlock()
438: {
439: if (--lockcount == 0)
440: unlink(LOCKFILE);
441: }
442: #endif VMS
443:
444: char lockname[80];
445: idlock(str)
446: char *str;
447: {
448: register int i;
449: char tempname[80];
450: long now;
451: struct stat sbuf;
452: int fd;
453:
454: #ifdef VMS
455: sprintf(lockname, "/tmp/%s.l.1", str);
456: if ((fd = creat(lockname, 0444)) < 0) {
457: #else VMS
458: sprintf(tempname, "/tmp/LTMP.%d", getpid());
459: sprintf(lockname, "/tmp/L%s", str);
460: #ifdef FOURTEENMAX
461: lockname[5 /* /tmp/ */ + 14] = '\0';
462: #endif
463: close(creat(tempname, 0666));
464: while (link(tempname, lockname)) {
465: #endif VMS
466: time(&now);
467: i = stat(lockname, &sbuf);
468: if (i < 0) {
469: xerror("Directory permission problem in /tmp");
470: }
471: if (sbuf.st_mtime + 10*60 < now) {
472: unlink(lockname);
473: log("Article %s locked up", str);
474: continue;
475: }
476: log("waiting on lock for %s", lockname);
477: sleep((unsigned)60);
478: }
479: #ifdef VMS
480: close(fd);
481: #else
482: unlink(tempname);
483: #endif
484: unlink(tempname);
485: }
486:
487: idunlock()
488: {
489: unlink(lockname);
490: }
491:
492: /*
493: * Put a unique name into header.ident.
494: */
495: getident(hp)
496: struct hbuf *hp;
497: {
498: long seqn;
499: register FILE *fp;
500:
501: lock();
502: fp = xfopen(SEQFILE, "r");
503: fgets(bfr, BUFLEN, fp);
504: fclose(fp);
505: seqn = atol(bfr) + 1;
506: #ifdef VMS
507: unlink(SEQFILE);
508: #endif VMS
509: fp = xfopen(SEQFILE, "w");
510: fprintf(fp, "%ld\n", seqn);
511: fclose(fp);
512: unlock();
513: sprintf(hp->ident, "<%ld@%s%s>", seqn, FULLSYSNAME, MYDOMAIN);
514: }
515:
516: /*
517: * Log the given message, with printf strings and parameters allowed,
518: * on the log file, if it can be written. The date and an attempt at
519: * figuring out the remote system name are also logged.
520: */
521: log(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
522: char *fmt;
523: {
524: FILE *logfile;
525: char msg[256];
526: char *logtime, *p, *q;
527: char rmtsys[256];
528: char c;
529: long t;
530:
531: if (header.relayversion[0]) {
532: for (p=header.relayversion; p; p=index(p+1, 's'))
533: if (strncmp(p, "site ", 5) == 0)
534: break;
535: if (p == NULL)
536: goto crackpath;
537: p += 4;
538: while (*p == ' ' || *p == '\t')
539: p++;
540: for (q=p; *q && *q!=' ' && *q != '\t'; q++)
541: ;
542: c = *q;
543: strcpy(rmtsys, p);
544: *q = c;
545: } else {
546: crackpath:
547: strcpy(rmtsys, header.path);
548: p = index(rmtsys, '!');
549: if (p == NULL)
550: p = index(rmtsys, ':');
551: if (p)
552: *p = 0;
553: else {
554: p = rindex(rmtsys, '@');
555: if (p)
556: strcpy(rmtsys, p+1);
557: else
558: strcpy(rmtsys, "local");
559: }
560: }
561:
562: time(&t);
563: logtime = ctime(&t);
564: logtime[16] = 0;
565: logtime += 4;
566:
567: sprintf(msg, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
568:
569: lock();
570: if (access(logfname, 0)) {
571: unlock(0);
572: return;
573: }
574: logfile = fopen(logfname, "a");
575: if (logfile == NULL) {
576: unlock(0);
577: return;
578: }
579: fprintf(logfile, "%s %s\t%s\n", logtime, rmtsys, msg);
580: fclose(logfile);
581: unlock();
582: }
583:
584: /*
585: * Check if header.nbuf contains only valid newsgroup names;
586: * exit with error if not valid.
587: *
588: * a == TRUE means header.nbuf is subscription list
589: * a == FALSE means header.nbuf is newsgroup list
590: */
591:
592: ngfcheck(a)
593: int a;
594: {
595: char ngcheck[NGFSIZ]; /* Hold NGFILE newsgroups */
596: char tbuf[BUFLEN]; /* hold single header.nbuf news group */
597: register char *s1, *s2;
598: register FILE *f;
599:
600: s1 = ngcheck;
601: f = xfopen(NGFILE, "r");
602: while (fgets(bfr, BUFLEN, f) != NULL) {
603: for (s2 = bfr; *s2 != '\0' &&
604: *s2 != ' ' && *s2 != '\t' &&
605: *s2 != ':' && *s2 != '\n';) {
606: if (s1 >= &ngcheck[NGFSIZ-2])
607: xerror("NGFILE too long");
608: *s1++ = *s2++;
609: }
610: *s1++ = NGDELIM;
611: }
612: *s1 = '\0';
613: fclose(f);
614: for (s1 = header.nbuf; *s1 != '\0';) {
615: if (*s1 == NEGCHAR)
616: s1++;
617: s2 = tbuf;
618: while ((*s2++ = *s1++) != NGDELIM)
619: if (s1[-1] == ':')
620: xerror("Newsgroup cannot contain ':'");
621: *s2 = '\0';
622: s2 = tbuf;
623: if (!ngmatch(s2, ngcheck) && (!a || !ngmatch(ngcheck, s2))) {
624: ngdel(s2);
625: sprintf(bfr, "Bad news group \"%s\"", s2);
626: newssave(stdin, NULL);
627: xerror(bfr);
628: }
629: }
630: }
631:
632: /*
633: * Figure out who posted the article (which is locally entered).
634: * The results are placed in the header structure hp.
635: */
636: gensender(hp, logname)
637: struct hbuf *hp;
638: char *logname;
639: {
640: char *fn;
641: static char buf[100];
642: char buf2[100];
643: char *fullname(), *getenv();
644: char *p;
645: int fd;
646:
647: fn = getenv("NAME");
648:
649: if (fn == NULL) {
650: sprintf(buf, "%s/%s", getenv("HOME"), ".name");
651: fd = open(buf, 0);
652: if (fd >= 0) {
653: read(fd, buf2, sizeof buf2);
654: close(fd);
655: if (buf2[0] >= 'A')
656: fn = buf2;
657: for (p=fn; *p; p++)
658: if (*p < ' ')
659: *p = 0;
660: }
661: }
662:
663: if (fn == NULL)
664: fn = fullname(logname);
665:
666: sprintf(hp->path, "%s", logname);
667: sprintf(hp->from, "%s@%s%s (%s)", logname, FULLSYSNAME, MYDOMAIN, fn);
668: }
669:
670: /*
671: * Trap interrupts.
672: */
673: onsig(n)
674: int n;
675: {
676: static int numsigs = 0;
677: /*
678: * Most UNIX systems reset caught signals to SIG_DFL.
679: * This bad design requires that the trap be set again here.
680: * Unfortunately, if the signal recurs before the trap is set,
681: * the program will die, possibly leaving the lock in place.
682: */
683: if (++numsigs > 100) {
684: log("readnews ran away looping on signal %d", n);
685: xxit(1);
686: }
687: signal(n, onsig);
688: sigtrap = n;
689: }
690:
691: /*
692: * If the stdin begins with "#", we assume we have been fed a batched
693: * shell script which looks like this:
694: * #! rnews 1234
695: * article with 1234 chars
696: * #! rnews 4321
697: * article with 4321 chars
698: *
699: * In this case we just exec the unbatcher and let it unpack and call us back.
700: *
701: * Note that there is a potential security hole here. If the batcher is
702: * /bin/sh, someone could ship you arbitrary stuff to run as shell commands.
703: * The main protection you have is that the effective uid will be news, not
704: * uucp and not the super user. (That, plus the fact that BATCH is set to
705: * "unbatch" as the system is distributed.) If you want to run a batched link
706: * and you are security concious, do not use /bin/sh as the unbatcher.
707: * the thing to do is to change BATCH in your localize.sh file from /bin/sh
708: * to some restricted shell which can only run rnews.
709: */
710: checkbatch()
711: {
712: int c;
713:
714: #ifdef BATCH
715: c = getc(stdin);
716: ungetc(c, stdin);
717: clearerr(stdin);
718: if (c == '#') {
719: reset_stdin();
720: execl(BATCH, "news-unpack", 0);
721: xerror("Unable to exec shell to unpack news.\n");
722: }
723: #endif
724: }
725:
726: /*
727: * We've already done a read on stdin, and we want to seek back to the
728: * beginning. We want the real file descriptor (beyond buffers) to
729: * reflect the true beginning. Do whatever is necessary.
730: */
731: reset_stdin()
732: {
733: register FILE *ofd;
734: register int c;
735: char *ofdname;
736:
737: /* First try to seek back - if so, it's a cheap way back. */
738: if (lseek(0, 0L, 0) == 0)
739: return;
740:
741: /* Can't seek, so have to copy input to a file and use that. */
742: ofdname = "/tmp/inewsXXXXX";
743: mktemp(ofdname);
744: ofd = fopen(ofdname, "w");
745: while ((c=getc(stdin)) != EOF)
746: putc(c, ofd);
747: fclose(stdin);
748: fclose(ofd);
749:
750: /* Now for a few lower level hacks to reopen stdin and make
751: * absolutely sure that the right fd's are done for the exec.
752: */
753: close(0); /* to make sure stdin is really closed. */
754: open(ofdname, 0); /* returns zero */
755: unlink(ofdname); /* to avoid cleaning it up later. */
756: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.