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