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