![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to getbbent.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / bboards|
Return to getbbent.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / bboards |
1.1 root 1: /* getbbent.c - subroutines for accessing the BBoards file */
2:
3: /* LINTLIBRARY */
4:
5: #include "bboards.h"
6: #ifndef MMDFONLY
7: #include "../h/strings.h"
8: #else MMDFONLY
9: #include "strings.h"
10: #endif MMDFONLY
11: #include <ctype.h>
12: #include <pwd.h>
13: #include <grp.h>
14: #include <stdio.h>
15: #include <sys/types.h>
16: #include <sys/stat.h>
17:
18:
19: #define NOTOK (-1)
20: #define OK 0
21:
22:
23: #define MaxBBAka 100
24: #define MaxBBLdr 100
25: #define MaxBBDist 100
26:
27: #define COLON ':'
28: #define COMMA ','
29: #define NEWLINE '\n'
30:
31:
32: #define ARCHIVE "archive"
33: #define CNTFILE ".cnt"
34: #define DSTFILE ".dist"
35: #define MAPFILE ".map"
36:
37: /* */
38:
39: static int BBuid = -1;
40:
41: static unsigned int BBflags = SB_NULL;
42:
43: static char BBName[BUFSIZ] = BBOARDS;
44: static char BBDir[BUFSIZ] = "";
45: static char BBData[BUFSIZ] = "";
46:
47: static FILE *BBfile = NULL;
48:
49:
50: static struct bboard BB;
51: static struct bboard *bb = &BB;
52:
53: static int BBload = 1;
54:
55: static char BBFile[BUFSIZ];
56: static char BBArchive[BUFSIZ];
57: static char BBInfo[BUFSIZ];
58: static char BBMap[BUFSIZ];
59: static char *BBAkas[MaxBBAka];
60: static char *BBLeaders[MaxBBLdr];
61: static char *BBDists[MaxBBDist];
62: static char BBAddr[BUFSIZ];
63: static char BBRequest[BUFSIZ];
64: static char BBDate[BUFSIZ];
65: static char BBErrors[BUFSIZ];
66:
67:
68: char *bbskip (), *getcpy ();
69:
70: char *crypt (), *getpass ();
71: struct group *getgrnam ();
72: struct passwd *getpwnam (), *getpwuid ();
73:
74: /* */
75:
76: int setbbfile (file, f)
77: register char *file;
78: register int f;
79: {
80: if (BBuid == -1)
81: return setbbinfo (BBOARDS, file, f);
82:
83: (void) strcpy (BBData, file);
84:
85: BBflags = SB_NULL;
86: (void) endbbent ();
87:
88: return setbbent (f);
89: }
90:
91: /* */
92:
93: int setbbinfo (user, file, f)
94: register char *user,
95: *file;
96: register int f;
97: {
98: register struct passwd *pw;
99:
100: if ((pw = getpwnam (user)) == NULL) {
101: (void) sprintf (BBErrors, "unknown user: %s", user);
102: return 0;
103: }
104:
105: return setpwinfo (pw, file, f);
106: }
107:
108:
109: int setpwinfo (pw, file, f)
110: register struct passwd *pw;
111: register char *file;
112: register int f;
113: {
114: if (!setpwaux (pw, file))
115: return 0;
116:
117: BBflags = SB_NULL;
118: (void) endbbent ();
119:
120: return setbbent (f);
121: }
122:
123: /* */
124:
125: static int setbbaux (name, file)
126: register char *name,
127: *file;
128: {
129: register struct passwd *pw;
130:
131: if ((pw = getpwnam (name)) == NULL) {
132: (void) sprintf (BBErrors, "unknown user: %s", name);
133: return 0;
134: }
135:
136: return setpwaux (pw, file);
137: }
138:
139:
140: static int setpwaux (pw, file)
141: register struct passwd *pw;
142: register char *file;
143: {
144: (void) strcpy (BBName, pw -> pw_name);
145: BBuid = pw -> pw_uid;
146: (void) strcpy (BBDir, pw -> pw_dir);
147: (void) sprintf (BBData, "%s/%s",
148: *file != '/' ? BBDir : "",
149: *file != '/' ? file : file + 1);
150:
151: BBflags = SB_NULL;
152:
153: return 1;
154: }
155:
156: /* */
157:
158: int setbbent (f)
159: register int f;
160: {
161: if (BBfile == NULL) {
162: if (BBuid == -1 && !setbbaux (BBOARDS, BBDB))
163: return 0;
164:
165: if ((BBfile = fopen (BBData, "r")) == NULL) {
166: (void) sprintf (BBErrors, "unable to open: %s", BBData);
167: return 0;
168: }
169: }
170: else
171: rewind (BBfile);
172:
173: BBflags |= f;
174: return (BBfile != NULL);
175: }
176:
177:
178: int endbbent () {
179: if (BBfile != NULL && !(BBflags & SB_STAY)) {
180: (void) fclose (BBfile);
181: BBfile = NULL;
182: }
183:
184: return 1;
185: }
186:
187:
188: long getbbtime () {
189: struct stat st;
190:
191: if (BBfile == NULL) {
192: if (BBuid == -1 && !setbbaux (BBOARDS, BBDB))
193: return 0;
194:
195: if (stat (BBData, &st) == NOTOK) {
196: (void) sprintf (BBErrors, "unable to stat: %s", BBData);
197: return 0;
198: }
199: }
200: else
201: if (fstat (fileno (BBfile), &st) == NOTOK) {
202: (void) sprintf (BBErrors, "unable to fstat: %s", BBData);
203: return 0;
204: }
205:
206: return ((long) st.st_mtime);
207: }
208:
209: /* */
210:
211: struct bboard *getbbent () {
212: register char *p,
213: *q,
214: *r,
215: *d,
216: *f,
217: **s;
218: static char line[BUFSIZ];
219:
220: if (BBfile == NULL && !setbbent (SB_NULL))
221: return NULL;
222:
223: if ((p = fgets (line, sizeof line, BBfile)) == NULL)
224: return NULL;
225:
226: bb -> bb_name = p;
227: p = q = bbskip (p, COLON);
228: p = bb -> bb_file = bbskip (p, COLON);
229: bb -> bb_archive = bb -> bb_info = bb -> bb_map = "";
230: p = bb -> bb_passwd = bbskip (p, COLON);
231: p = r = bbskip (p, COLON);
232: p = bb -> bb_addr = bbskip (p, COLON);
233: p = bb -> bb_request = bbskip (p, COLON);
234: p = bb -> bb_relay = bbskip (p, COLON);
235: p = d = bbskip (p, COLON);
236: p = f = bbskip (p, COLON);
237: (void) bbskip (p, NEWLINE);
238:
239: s = bb -> bb_aka = BBAkas;
240: while (*q) {
241: *s++ = q;
242: q = bbskip (q, COMMA);
243: }
244: *s = NULL;
245:
246: s = bb -> bb_leader = BBLeaders;
247: if (*r == NULL) {
248: if (!(BBflags & SB_FAST))
249: *s++ = BBName;
250: }
251: else
252: while (*r) {
253: *s++ = r;
254: r = bbskip (r, COMMA);
255: }
256: *s = NULL;
257:
258: s = bb -> bb_dist = BBDists;
259: while (*d) {
260: *s++ = d;
261: d = bbskip (d, COMMA);
262: }
263: *s = NULL;
264:
265: if (*f)
266: (void) sscanf (f, "%o", &bb -> bb_flags);
267: else
268: bb -> bb_flags = BB_NULL;
269: bb -> bb_count = bb -> bb_maxima = 0;
270: bb -> bb_date = NULL;
271: bb -> bb_next = bb -> bb_link = bb -> bb_chain = NULL;
272:
273: if (BBload)
274: BBread ();
275:
276: return bb;
277: }
278:
279: /* */
280:
281: struct bboard *getbbnam (name)
282: register char *name;
283: {
284: register struct bboard *b = NULL;
285:
286: if (!setbbent (SB_NULL))
287: return NULL;
288: BBload = 0;
289: while ((b = getbbent ()) && strcmp (name, b -> bb_name))
290: continue;
291: BBload = 1;
292: (void) endbbent ();
293:
294: if (b != NULL)
295: BBread ();
296:
297: return b;
298: }
299:
300:
301: struct bboard *getbbaka (aka)
302: register char *aka;
303: {
304: register char **ap;
305: register struct bboard *b = NULL;
306:
307: if (!setbbent (SB_NULL))
308: return NULL;
309: BBload = 0;
310: while ((b = getbbent ()) != NULL)
311: for (ap = b -> bb_aka; *ap; ap++)
312: if (strcmp (aka, *ap) == 0)
313: goto hit;
314: hit: ;
315: BBload = 1;
316: (void) endbbent ();
317:
318: if (b != NULL)
319: BBread ();
320:
321: return b;
322: }
323:
324: /* */
325:
326: static int BBread () {
327: register int i;
328: register char *cp,
329: *dp,
330: *p,
331: *r;
332: char prf[BUFSIZ];
333: static char line[BUFSIZ];
334: register FILE * info;
335:
336: if (BBflags & SB_FAST)
337: return;
338:
339: p = index (bb -> bb_request, '@');
340: r = index (bb -> bb_addr, '@');
341: BBRequest[0] = NULL;
342:
343: if (*bb -> bb_request == '-')
344: if (p == NULL && r && *r == '@')
345: (void) sprintf (BBRequest, "%s%s%s",
346: bb -> bb_name, bb -> bb_request, r);
347: else
348: (void) sprintf (BBRequest, "%s%s",
349: bb -> bb_name, bb -> bb_request);
350: else
351: if (p == NULL && r && *r == '@' && *bb -> bb_request)
352: (void) sprintf (BBRequest, "%s%s", bb -> bb_request, r);
353:
354: if (BBRequest[0])
355: bb -> bb_request = BBRequest;
356: else
357: if (*bb -> bb_request == NULL)
358: bb -> bb_request = *bb -> bb_addr ? bb -> bb_addr
359: : bb -> bb_leader[0];
360:
361: if (*bb -> bb_addr == '@') {
362: (void) sprintf (BBAddr, "%s%s", bb -> bb_name, bb -> bb_addr);
363: bb -> bb_addr = BBAddr;
364: }
365: else
366: if (*bb -> bb_addr == NULL)
367: bb -> bb_addr = bb -> bb_name;
368:
369: if (*bb -> bb_file == NULL)
370: return;
371: if (*bb -> bb_file != '/') {
372: (void) sprintf (BBFile, "%s/%s", BBDir, bb -> bb_file);
373: bb -> bb_file = BBFile;
374: }
375:
376: if ((cp = rindex (bb -> bb_file, '/')) == NULL || *++cp == NULL)
377: (void) strcpy (prf, ""), cp = bb -> bb_file;
378: else
379: (void) sprintf (prf, "%.*s", cp - bb -> bb_file, bb -> bb_file);
380: if ((dp = index (cp, '.')) == NULL)
381: dp = cp + strlen (cp);
382:
383: (void) sprintf (BBArchive, "%s%s/%s", prf, ARCHIVE, cp);
384: bb -> bb_archive = BBArchive;
385: (void) sprintf (BBInfo, "%s.%.*s%s", prf, dp - cp, cp, CNTFILE);
386: bb -> bb_info = BBInfo;
387: (void) sprintf (BBMap, "%s.%.*s%s", prf, dp - cp, cp, MAPFILE);
388: bb -> bb_map = BBMap;
389:
390: if ((info = fopen (bb -> bb_info, "r")) == NULL)
391: return;
392:
393: if (fgets (line, sizeof line, info) && (i = atoi (line)) > 0)
394: bb -> bb_maxima = (unsigned) i;
395: if (!feof (info) && fgets (line, sizeof line, info)) {
396: (void) strcpy (BBDate, line);
397: if (cp = index (BBDate, NEWLINE))
398: *cp = NULL;
399: bb -> bb_date = BBDate;
400: }
401:
402: (void) fclose (info);
403: }
404:
405: /* */
406:
407: int ldrbb (b)
408: register struct bboard *b;
409: {
410: register char *p,
411: **q,
412: **r;
413: static int uid = 0,
414: gid = 0;
415: static char username[10] = "";
416: register struct passwd *pw;
417: register struct group *gr;
418:
419: if (b == NULL)
420: return 0;
421: if (BBuid == -1 && !setbbaux (BBOARDS, BBDB))
422: return 0;
423:
424: if (username[0] == NULL) {
425: if ((pw = getpwuid (uid = getuid ())) == NULL)
426: return 0;
427: gid = getgid ();
428: (void) strcpy (username, pw -> pw_name);
429: }
430:
431: if (uid == BBuid)
432: return 1;
433:
434: q = b -> bb_leader;
435: while (p = *q++)
436: if (*p == '=') {
437: if ((gr = getgrnam (++p)) == NULL)
438: continue;
439: if (gid == gr -> gr_gid)
440: return 1;
441: r = gr -> gr_mem;
442: while (p = *r++)
443: if (strcmp (username, p) == 0)
444: return 1;
445: }
446: else
447: if (strcmp (username, p) == 0)
448: return 1;
449:
450: return 0;
451: }
452:
453: /* */
454:
455: int ldrchk (b)
456: register struct bboard *b;
457: {
458: if (b == NULL)
459: return 0;
460:
461: if (*b -> bb_passwd == NULL)
462: return 1;
463:
464: if (strcmp (b -> bb_passwd,
465: crypt (getpass ("Password: "), b -> bb_passwd)) == 0)
466: return 1;
467:
468: fprintf (stderr, "Sorry\n");
469: return 0;
470: }
471:
472: /* */
473:
474: struct bboard *getbbcpy (bp)
475: register struct bboard *bp;
476: {
477: register char **p,
478: **q;
479: register struct bboard *b;
480:
481: if (bp == NULL)
482: return NULL;
483:
484: b = (struct bboard *) malloc ((unsigned) sizeof *b);
485: if (b == NULL)
486: return NULL;
487:
488: b -> bb_name = getcpy (bp -> bb_name);
489: b -> bb_file = getcpy (bp -> bb_file);
490: b -> bb_archive = getcpy (bp -> bb_archive);
491: b -> bb_info = getcpy (bp -> bb_info);
492: b -> bb_map = getcpy (bp -> bb_map);
493: b -> bb_passwd = getcpy (bp -> bb_passwd);
494: b -> bb_flags = bp -> bb_flags;
495: b -> bb_count = bp -> bb_count;
496: b -> bb_maxima = bp -> bb_maxima;
497: b -> bb_date = getcpy (bp -> bb_date);
498: b -> bb_addr = getcpy (bp -> bb_addr);
499: b -> bb_request = getcpy (bp -> bb_request);
500: b -> bb_relay = getcpy (bp -> bb_relay);
501:
502: for (p = bp -> bb_aka; *p; p++)
503: continue;
504: b -> bb_aka =
505: q = (char **) calloc ((unsigned) (p - bp -> bb_aka + 1), sizeof *q);
506: if (q == NULL)
507: return NULL;
508: for (p = bp -> bb_aka; *p; *q++ = getcpy (*p++))
509: continue;
510: *q = NULL;
511:
512: for (p = bp -> bb_leader; *p; p++)
513: continue;
514: b -> bb_leader =
515: q = (char **) calloc ((unsigned) (p - bp -> bb_leader + 1), sizeof *q);
516: if (q == NULL)
517: return NULL;
518: for (p = bp -> bb_leader; *p; *q++ = getcpy (*p++))
519: continue;
520: *q = NULL;
521:
522: for (p = bp -> bb_dist; *p; p++)
523: continue;
524: b -> bb_dist =
525: q = (char **) calloc ((unsigned) (p - bp -> bb_dist + 1), sizeof *q);
526: if (q == NULL)
527: return NULL;
528: for (p = bp -> bb_dist; *p; *q++ = getcpy (*p++))
529: continue;
530: *q = NULL;
531:
532: b -> bb_next = bp -> bb_next;
533: b -> bb_link = bp -> bb_link;
534: b -> bb_chain = bp -> bb_chain;
535:
536: return b;
537: }
538:
539: /* */
540:
541: int getbbdist (bb, action)
542: register struct bboard *bb;
543: register int (*action) ();
544: {
545: register int result;
546: register char **dp;
547:
548: BBErrors[0] = NULL;
549: for (dp = bb -> bb_dist; *dp; dp++)
550: if (result = getbbitem (bb, *dp, action))
551: return result;
552:
553: return result;
554: }
555:
556: char *getbberr () {
557: return (BBErrors[0] ? BBErrors : NULL);
558: };
559:
560: /* */
561:
562: static int getbbitem (bb, item, action)
563: register struct bboard *bb;
564: register char *item;
565: register int (*action) ();
566: {
567: register int result;
568: register char *cp,
569: *dp,
570: *hp,
571: *np;
572: char mbox[BUFSIZ],
573: buffer[BUFSIZ],
574: file[BUFSIZ],
575: host[BUFSIZ],
576: prf[BUFSIZ];
577: register FILE *fp;
578:
579: switch (*item) {
580: case '*':
581: switch (*++item) {
582: case '/':
583: hp = item;
584: break;
585:
586: case NULL:
587: if ((cp = rindex (bb -> bb_file, '/')) == NULL || *++cp == NULL)
588: (void) strcpy (prf, ""), cp = bb -> bb_file;
589: else
590: (void) sprintf (prf, "%.*s", cp - bb -> bb_file, bb -> bb_file);
591: if ((dp = index (cp, '.')) == NULL)
592: dp = cp + strlen (cp);
593: (void) sprintf (file, "%s.%.*s%s", prf, dp - cp, cp, DSTFILE);
594: hp = file;
595: break;
596:
597: default:
598: (void) sprintf (file, "%s/%s", BBDir, item);
599: hp = file;
600: break;
601: }
602:
603: if ((fp = fopen (hp, "r")) == NULL)
604: return bblose ("unable to read file %s", hp);
605: while (fgets (buffer, sizeof buffer, fp)) {
606: if (np = index (buffer, '\n'))
607: *np = NULL;
608: if (result = getbbitem (bb, buffer, action)) {
609: (void) fclose (fp);
610: (void) bblose ("error with file %s, item %s", hp, buffer);
611: return result;
612: }
613: }
614: (void) fclose (fp);
615: return OK;
616:
617: default:
618: if (hp = rindex (item, '@')) {
619: *hp++ = NULL;
620: (void) strcpy (mbox, item);
621: (void) strcpy (host, hp);
622: *--hp = '@';
623: }
624: else {
625: (void) sprintf (mbox, "%s%s", DISTADR, bb -> bb_name);
626: (void) strcpy (host, item);
627: }
628: if (result = (*action) (mbox, host))
629: (void) bblose ("action (%s, %s) returned 0%o", mbox, host, result);
630: return result;
631: }
632: }
633:
634: /* */
635:
636: /* VARARGS1 */
637:
638: static int bblose (fmt, a, b, c)
639: char *fmt,
640: *a,
641: *b,
642: *c;
643: {
644: if (BBErrors[0] == NULL)
645: (void) sprintf (BBErrors, fmt, a, b, c);
646:
647: return NOTOK;
648: }
649:
650: /* */
651:
652: void make_lower (s1, s2)
653: register char *s1,
654: *s2;
655: {
656: if (s1 == NULL || s2 == NULL)
657: return;
658:
659: for (; *s2; s2++)
660: *s1++ = isupper (*s2) ? tolower (*s2) : *s2;
661: *s1 = NULL;
662: }
663:
664: /* */
665:
666: static char *bbskip (p, c)
667: register char *p,
668: c;
669: {
670: if (p == NULL)
671: return NULL;
672:
673: while (*p && *p != c)
674: p++;
675: if (*p)
676: *p++ = NULL;
677:
678: return p;
679: }
680:
681:
682: static char *getcpy (s)
683: register char *s;
684: {
685: register char *p;
686:
687: if (s == NULL)
688: return NULL;
689:
690: if (p = malloc ((unsigned) (strlen (s) + 1)))
691: (void) strcpy (p, s);
692: return p;
693: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.