![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to funcs.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 funcs.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: * funcs - functions used by many programs
16: */
17:
18: #ifdef SCCSID
19: static char *SccsId = "@(#)funcs.c 2.31 1/17/86";
20: #endif /* SCCSID */
21:
22: /*LINTLIBRARY*/
23:
24: #include "params.h"
25: #include <errno.h>
26: #if defined(USG) || defined(BSD4_2) || defined(BSD4_1C)
27: #include <fcntl.h>
28: #endif /* !v7 */
29:
30: extern char *Progname;
31:
32: /*
33: * News group matching.
34: *
35: * nglist is a list of newsgroups.
36: * sublist is a list of subscriptions.
37: * sublist may have "meta newsgroups" in it.
38: * All fields are NGDELIM separated,
39: * and there is an NGDELIM at the end of each argument.
40: *
41: * Currently implemented glitches:
42: * sublist uses 'all' like shell uses '*', and '.' like shell '/'.
43: * If subscription X matches Y, it also matches Y.anything.
44: */
45: ngmatch(nglist, sublist)
46: register char *nglist, *sublist;
47: {
48: register char *n, *s;
49: register int rc;
50:
51: rc = FALSE;
52: for (n = nglist; *n != '\0' && rc == FALSE;) {
53: for (s = sublist; *s != '\0';) {
54: if (*s != NEGCHAR)
55: rc = rc || ptrncmp(s, n);
56: else
57: rc = rc && !ptrncmp(s+1, n);
58: while (*s++ != NGDELIM && *s != '\0')
59: ;
60: }
61: while (*n++ != NGDELIM && *n != '\0')
62: ;
63: }
64: return rc;
65: }
66:
67: /*
68: * Compare two newsgroups for equality.
69: * The first one may be a "meta" newsgroup.
70: */
71: ptrncmp(ng1, ng2)
72: register char *ng1, *ng2;
73: {
74: while (*ng1 != NGDELIM && *ng1 != '\0') {
75: if (ng1[0]=='a' && ng1[1]=='l' && ng1[2]=='l') {
76: ng1 += 3;
77: while (*ng2 != NGDELIM && *ng2 != '.' && *ng2 != '\0')
78: if (ptrncmp(ng1, ng2++))
79: return(TRUE);
80: return ptrncmp(ng1, ng2);
81: } else if (*ng1++ != *ng2++)
82: return FALSE;
83: }
84: return *ng2 == '.' || *ng2 == NGDELIM || *ng2 == '\0';
85: }
86:
87: /*
88: * Exec the shell.
89: * This version resets uid, gid, and umask.
90: * Called with fsubr(ushell, s, NULL)
91: */
92: /* ARGSUSED */
93: ushell(s, dummy)
94: char *s, *dummy;
95: {
96: (void) umask(savmask);
97: (void) setgid(gid);
98: (void) setuid(uid);
99: xshell(s);
100: }
101:
102: /*
103: * Exec the shell.
104: */
105:
106: #ifdef lint
107: char **environ;
108: #else /* !lint */
109: extern char **environ;
110: #endif /* !lint */
111:
112: xshell(s)
113: char *s;
114: {
115: char *env[100], **envp;
116: char a[BUFLEN + 2];
117: extern char filename[];
118: /* set $A */
119: (void) sprintf(a, "A=%s", filename);
120: env[0] = a;
121: for (envp = env + 1 ; *environ != NULL && envp < env + 98 ; environ++)
122: if ((*environ)[0] != 'A' || (*environ)[1] != '=')
123: *envp++ = *environ;
124: *envp = NULL;
125:
126: execle(SHELL, SHELL, "-c", s, (char *)0, env);
127: xerror("No shell!");
128: }
129:
130: /*
131: * Fork and call a subroutine with two args.
132: * Return pid without waiting.
133: */
134: fsubr(f, s1, s2)
135: int (*f)();
136: char *s1, *s2;
137: {
138: register int pid;
139:
140: while ((pid = fork()) == -1)
141: sleep((unsigned)1);
142: if (pid == 0) {
143: (*f)(s1, s2);
144: exit(0);
145: }
146: return pid;
147: }
148:
149: /*
150: * Wait on a child process.
151: */
152: fwait(pid)
153: register int pid;
154: {
155: register int w;
156: int status;
157: int (*onhup)(), (*onint)();
158:
159: onint = signal(SIGINT, SIG_IGN);
160: onhup = signal(SIGHUP, SIG_IGN);
161: while ((w = wait(&status)) != pid && w != -1)
162: ;
163: if (w == -1)
164: status = -1;
165: (void) signal(SIGINT, onint);
166: (void) signal(SIGHUP, onhup);
167: return status;
168: }
169:
170: /*
171: * Strip trailing newlines, blanks, and tabs from 's'.
172: * Return TRUE if newline was found, else FALSE.
173: */
174: nstrip(s)
175: register char *s;
176: {
177: register char *p;
178: register int rc;
179:
180: rc = FALSE;
181: p = s;
182: while (*p)
183: if (*p++ == '\n')
184: rc = TRUE;
185: while (--p >= s && (*p == '\n' || *p == ' ' || *p == '\t'));
186: *++p = '\0';
187: return rc;
188: }
189:
190: /*
191: * Local open routine.
192: */
193: FILE *
194: xfopen(name, fmode)
195: register char *name, *fmode;
196: {
197: register FILE *fp;
198: char *fname;
199: extern int errno;
200:
201: if ((fp = fopen(name, fmode)) == NULL) {
202: #ifdef IHCC
203: /*
204: * IHCC users only see the "filename" that was in trouble,
205: * not the whole path. (for security!)
206: */
207: fname = rindex(name, '/') + 1;
208: #else
209: fname = name;
210: #endif
211: xerror("Cannot open %s (%s): %s", fname, fmode, errmsg(errno));
212: }
213: /* kludge for setuid not being honored for root */
214: if ((uid == 0) && (duid != 0) && ((*fmode == 'a') || (*fmode == 'w')))
215: (void) chown(name, duid, dgid);
216: return fp;
217: }
218:
219: char *
220: errmsg(code)
221: int code;
222: {
223: extern int sys_nerr;
224: extern char *sys_errlist[];
225: static char ebuf[6+5+1];
226:
227: if (code > sys_nerr) {
228: (void) sprintf(ebuf, "Error %d", code);
229: return ebuf;
230: } else
231: return sys_errlist[code];
232: }
233:
234: prefix(full, pref)
235: register char *full, *pref;
236: {
237: register char fc, pc;
238:
239: while ((pc = *pref++) != '\0') {
240: fc = *full++;
241: if (isupper(fc))
242: fc = tolower(fc);
243: if (isupper(pc))
244: pc = tolower(pc);
245: if (fc != pc)
246: return FALSE;
247: }
248: return TRUE;
249: }
250:
251: char *
252: dirname(ngname)
253: char *ngname;
254: {
255: static char rbuf[BUFLEN];
256: register char *p;
257:
258: (void) sprintf(rbuf, "%s/%s", SPOOL, ngname);
259:
260: for (p=rbuf+strlen(SPOOL); *p; p++)
261: if (*p == '.')
262: *p = '/';
263: return rbuf;
264: }
265:
266: /*
267: * Return TRUE iff ngname is a valid newsgroup name
268: */
269: validng(ngname)
270: char *ngname;
271: {
272: register FILE *fp;
273: register char *p, *q;
274: char abuf[BUFLEN];
275:
276: fp = xfopen(ACTIVE, "r");
277: while(fgets(abuf, BUFLEN, fp) != NULL) {
278: p = abuf;
279: q = ngname;
280: while (*p++ == *q++)
281: ;
282: if (*--q == '\0' && *--p == ' ') {
283: (void) fclose(fp);
284: return TRUE;
285: }
286: }
287: (void) fclose(fp);
288: return FALSE;
289: }
290:
291: /* VARARGS1 */
292: xerror(message, arg1, arg2, arg3)
293: char *message;
294: int arg1, arg2, arg3;
295: {
296: char buffer[128];
297:
298: fflush(stdout);
299: (void) sprintf(buffer, message, arg1, arg2, arg3);
300: logerr(buffer);
301: xxit(1);
302: }
303:
304: /* VARARGS1 */
305: log(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
306: char *fmt;
307: {
308: _dolog(0, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
309: }
310:
311: /* VARARGS1 */
312: logerr(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
313: char *fmt;
314: {
315: _dolog(1, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
316: }
317:
318: char *lfsuffix[] = {
319: "log",
320: "errlog",
321: 0
322: };
323:
324: /*
325: * Log the given message, with printf strings and parameters allowed,
326: * on the log file, if it can be written. The date and an attempt at
327: * figuring out the remote system name are also logged.
328: */
329: /* VARARGS1 */
330: _dolog(which, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
331: char *fmt;
332: {
333: FILE *logfile;
334: register char *p, *logtime;
335: int i;
336: char logfname[BUFLEN]; /* the log file */
337: char rmtsys[BUFLEN];
338: char msg[BUFLEN];
339: time_t t;
340:
341: (void) strcpy(rmtsys, header.path);
342: p = index(rmtsys, '!');
343: if (p == NULL)
344: p = index(rmtsys, ':');
345: if (p)
346: *p = 0;
347: else {
348: p = rindex(rmtsys, '@');
349: if (p)
350: (void) strcpy(rmtsys, p+1);
351: else
352: (void) strcpy(rmtsys, "local");
353: }
354:
355: (void) time(&t);
356: logtime = ctime(&t);
357: logtime[16] = 0;
358: logtime += 4;
359:
360:
361: (void) sprintf(msg, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9);
362:
363: if (which)
364: fprintf(stderr,"%s: %s\n", Progname, msg);
365:
366: for (i=0; i<=which;i++) {
367: (void) sprintf(logfname, "%s/%s", LIB, lfsuffix[i]);
368:
369: if (access(logfname, 0) == 0 && (logfile = fopen(logfname, "a")) != NULL) {
370: #if defined(USG) || defined(BSD4_2) || defined(BSD4_1C)
371: int flags;
372: flags = fcntl(fileno(logfile), F_GETFL, 0);
373: (void) fcntl(fileno(logfile), F_SETFL, flags|O_APPEND);
374: #else /* v7 */
375: (void) lseek(fileno(logfile), 0L, 2);
376: #endif /* v7 */
377: if (i)
378: fprintf(logfile, "%s\t%s\t%s: %s\n", logtime,
379: header.ident[0] ? header.ident : username, Progname, msg);
380: else
381: fprintf(logfile, "%s\t%s\t%s\n", logtime,
382: rmtsys, msg);
383: (void) fclose(logfile);
384: }
385: }
386: }
387: #ifdef VMS
388:
389: /*
390: * vmslink allows simulation of file linking under VMS.
391: */
392: vmslink(infile,outfile)
393: char *infile, *outfile;
394: {
395: FILE *fp;
396:
397: if (access(outfile,0) == 0) {
398: errno = EEXIST;
399: return -1;
400: }
401:
402: fp = fopen(outfile, "w");
403: if (fp == NULL) {
404: errno = EACCES;
405: return -1;
406: }
407:
408: (void) fprintf(fp, "%s", infile);
409: (void) fclose(fp);
410:
411: return 0;
412: }
413:
414: /*
415: * vmsdelete deletes all revisions of a file. It attempts to
416: * appear as unlink(2) under conventional Unix in other respects.
417: */
418: vmsdelete(file)
419: char *file;
420: {
421: int i;
422:
423: i = unlink(file);
424: if (i != 0)
425: return i;
426:
427: i = errno;
428: while (unlink(file) == 0)
429: ;
430: errno = i;
431:
432: return 0;
433: }
434:
435: /*
436: * Convert a Unix file to a VMS fixed record format file by
437: * executing the 'unixtovms' command.
438: */
439: unixtovms(file)
440: char *file;
441: {
442: char buf[BUFLEN];
443: sprintf(buf, "exec /etc/unixtovms %s", file);
444: return system(buf);
445: }
446:
447: /*
448: * Convert a VMS fixed record format file to a Unix file by
449: * executing the 'vmstounix' command.
450: */
451: vmstounix(file)
452: char *file;
453: {
454: char buf[BUFLEN];
455: sprintf(buf,"exec /etc/vmstounix %s", file);
456: return system(buf);
457: }
458: #endif /* VMS */
459:
460: #if !defined(BSD4_2) && !defined(BSD4_1C)
461: /*
462: * make a directory. Also make sure that the directory is owned
463: * by the right userid
464: */
465: mkdir(path, perm)
466: char *path;
467: int perm;
468: {
469: int pid, status;
470:
471: if (pid=fork()) {
472: status = fwait(pid);
473: #if defined(USG) && !defined(CHEAP)
474: if (pid=fork())
475: (void) fwait(pid);
476: else {
477: setgid(gid);
478: setuid(uid);
479: if (chown(path, duid, dgid) == 0)
480: (void) chmod(path, perm&(~N_UMASK));
481: _exit(0);
482: }
483: #endif /* USG && !CHEAP */
484: } else {
485: (void) setgid(dgid);
486: if (setuid(duid) < 0)
487: (void) umask(0);
488: else
489: (void) umask(perm&N_UMASK);
490: (void) execlp("mkdir", "mkdir", path, (char *)NULL);
491: perror(path);
492: _exit(1);
493: }
494: return status;
495: }
496: #endif /* !BSD4_2 && ! BSD4_1C */
497: #ifndef USG
498: char *
499: strpbrk(str, chars)
500: register char *str, *chars;
501: {
502: register char *cp;
503:
504: do {
505: cp = chars - 1;
506: while (*++cp) {
507: if (*str == *cp)
508: return str;
509: }
510: } while (*str++);
511: return NULL;
512: }
513: #endif /* !USG */
514:
515: #ifdef FASCIST
516: /*
517: * This routine checks to see if the posting user is allowed to
518: * post to the given newsgroup. If the username is not in the file
519: * $LIBDIR/authorized then the default in the symbol FASCIST is used.
520: *
521: * Format of the call:
522: * fascist(user, newgroups)
523: *
524: * Returns:
525: * FALSE, if authorized
526: * TRUE, if not
527: *
528: * Format of the file "authorized" is:
529: * user:allowed groups
530: *
531: * Example:
532: * root:net.all,mod.all
533: * naughty_person:junk,net.politics
534: * operator:!net.all,general,test,mod.unix
535: *
536: * An open environment could have FASCIST set to "all"
537: * and then individual entries could be made in the authorized file
538: * to prevent certain individuals from posting to such a wide
539: * area.
540: *
541: * Note that a distribution of "all" does NOT mean to allow postings
542: * only to local groups -- "all" includes "all.all".
543: * Use "all,!all.all" to get this behavior
544: *
545: * Eugene Spafford spaf@gatech May 22, 1985
546: */
547:
548: fascist(user, newsgroups)
549: register char *user, *newsgroups;
550: {
551: FILE *facfd;
552: char facuser[BUFLEN], facgroups[BUFLEN], factemp[BUFLEN];
553: register char *facptr;
554:
555: /* First, open the necessary file...$LIBDIR/authorized and see if there
556: * is an entry for this user
557: */
558:
559: (void) strncpy(facgroups, FASCIST, BUFLEN);
560: sprintf(factemp, "%s/%s", LIBDIR, "authorized");
561: facfd = fopen(factemp, "r");
562:
563: if (facfd != NULL) { /* If no such file, we go with the global default */
564: while (fscanf(facfd, "%[^:]:%s\n", facuser, factemp) != EOF)
565: if (strncmp(facuser, user, BUFLEN) == 0) {
566: (void) strcat(facgroups, ",");
567: (void) strcat(facgroups, factemp);
568: break;
569: }
570: fclose (facfd);
571: }
572: #ifdef DEBUG
573: fprintf(stderr, "facgroups = %s\n", facgroups);
574: fprintf(stderr, "newsgroups = %s\n", newsgroups);
575: #endif DEBUG
576:
577: /* We step through the newsgroups being posted to and check each against
578: * the restriction list. *ALL* posted groups must match the restriction
579: * list or we don't allow the posting.
580: */
581:
582: while (*newsgroups != '\0') {
583: facptr = factemp;
584: while (*newsgroups != '\0' && *newsgroups != NGDELIM)
585: *facptr++ = *newsgroups++;
586: *facptr = '\0';
587: if (*newsgroups == NGDELIM)
588: newsgroups++;
589:
590: #ifdef DEBUG
591: fprintf(stderr, "Checking newsgroup '%s'\n", factemp);
592: #endif
593:
594: if (ngmatch(factemp, facgroups) == FALSE)
595: return TRUE;
596: }
597:
598: /* must be okay -- return */
599: #ifdef DEBUG
600: fprintf (stderr, "Newsgroups approved for this poster.\n");
601: #endif DEBUG
602: return FALSE;
603: }
604: #endif FASCIST
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.