|
0
|
1 /* dropsbr.c - write to a mailbox */
|
|
|
2 #ifndef lint
|
|
|
3 static char ident[] = "@(#)$Id$";
|
|
|
4 #endif /* lint */
|
|
|
5
|
|
|
6 #include <stdio.h>
|
|
|
7 #ifndef MMDFONLY
|
|
|
8 #include "../h/mh.h"
|
|
|
9 #include "../h/dropsbr.h"
|
|
|
10 #include "../zotnet/mts.h"
|
|
|
11 #else /* MMDFONLY */
|
|
|
12 #include "dropsbr.h"
|
|
|
13 #include "strings.h"
|
|
|
14 #include "mmdfonly.h"
|
|
|
15 #endif /* MMDFONLY */
|
|
|
16 #include <errno.h>
|
|
|
17 #include <sys/types.h>
|
|
|
18 #include <sys/stat.h>
|
|
|
19 #if (defined(BSD42) || defined(SOCKETS)) && defined(NTOHLSWAP)
|
|
|
20 #undef NULLVP
|
|
|
21 #include <netinet/in.h>
|
|
|
22 #else
|
|
|
23 #define ntohl(n) (n)
|
|
|
24 #endif
|
|
|
25
|
|
|
26
|
|
|
27 #define MMDF 1
|
|
|
28 #define UUCP 2
|
|
|
29
|
|
|
30 /* */
|
|
|
31
|
|
|
32 static int mbx_style = MMDF;
|
|
|
33
|
|
|
34 static int mbx_create(), mbx_chk(), map_open();
|
|
|
35
|
|
|
36
|
|
|
37 off_t lseek ();
|
|
|
38
|
|
|
39 /* */
|
|
|
40
|
|
|
41 int mbx_mmdf () {
|
|
|
42 int style = mbx_style;
|
|
|
43
|
|
|
44 mbx_style = MMDF;
|
|
|
45 return style;
|
|
|
46 }
|
|
|
47
|
|
|
48
|
|
|
49 int mbx_uucp () {
|
|
|
50 int style = mbx_style;
|
|
|
51
|
|
|
52 mbx_style = UUCP;
|
|
|
53 return style;
|
|
|
54 }
|
|
|
55
|
|
|
56 /* */
|
|
|
57
|
|
|
58 int mbx_open (file, uid, gid, mode)
|
|
|
59 char *file;
|
|
|
60 int uid,
|
|
|
61 gid,
|
|
|
62 mode;
|
|
|
63 {
|
|
|
64 int clear,
|
|
|
65 fd;
|
|
|
66
|
|
|
67 if ((fd = mbx_Xopen (file, uid, gid, mode, &clear)) == NOTOK)
|
|
|
68 return fd;
|
|
|
69
|
|
|
70 if (!clear)
|
|
|
71 switch (mbx_style) {
|
|
|
72 case MMDF:
|
|
|
73 default:
|
|
|
74 if (mbx_chk (fd) == NOTOK) {
|
|
|
75 (void) close (fd);
|
|
|
76 return NOTOK;
|
|
|
77 }
|
|
|
78 break;
|
|
|
79
|
|
|
80 case UUCP:
|
|
|
81 if (lseek (fd, (off_t)0, 2) == (off_t) NOTOK) {
|
|
|
82 (void) close (fd);
|
|
|
83 return NOTOK;
|
|
|
84 }
|
|
|
85 break;
|
|
|
86 }
|
|
|
87
|
|
|
88 return fd;
|
|
|
89 }
|
|
|
90
|
|
|
91 /* */
|
|
|
92
|
|
|
93 int mbx_Xopen (file, uid, gid, mode, clear)
|
|
|
94 char *file;
|
|
|
95 int uid,
|
|
|
96 gid,
|
|
|
97 mode,
|
|
|
98 *clear;
|
|
|
99 {
|
|
|
100 register int j;
|
|
|
101 int count,
|
|
|
102 fd;
|
|
|
103 struct stat st;
|
|
|
104
|
|
|
105 for (*clear = 0, count = 4, j = 0; count > 0; count--)
|
|
|
106 if ((fd = lkopen (file, 6)) == NOTOK)
|
|
|
107 switch (errno) {
|
|
|
108 case ENOENT:
|
|
|
109 if (mbx_create (file, uid, gid, mode) == NOTOK)
|
|
|
110 return NOTOK;
|
|
|
111 (*clear)++;
|
|
|
112 break;
|
|
|
113
|
|
|
114 #ifdef BSD42
|
|
|
115 case EWOULDBLOCK:
|
|
|
116 #endif /* BSD42 */
|
|
|
117 case ETXTBSY:
|
|
|
118 j = errno;
|
|
|
119 sleep (5);
|
|
|
120 break;
|
|
|
121
|
|
|
122 default:
|
|
|
123 return NOTOK;
|
|
|
124 }
|
|
|
125 else {
|
|
|
126 *clear = fstat (fd, &st) != NOTOK && st.st_size == (off_t)0;
|
|
|
127 break;
|
|
|
128 }
|
|
|
129
|
|
|
130 errno = j;
|
|
|
131 return fd;
|
|
|
132 }
|
|
|
133
|
|
|
134 /* */
|
|
|
135
|
|
|
136 static int mbx_create (file, uid, gid, mode)
|
|
|
137 char *file;
|
|
|
138 int uid,
|
|
|
139 gid,
|
|
|
140 mode;
|
|
|
141 {
|
|
|
142 int fd;
|
|
|
143
|
|
|
144 if ((fd = creat (file, 0600)) == NOTOK)
|
|
|
145 return NOTOK;
|
|
|
146
|
|
|
147 (void) close (fd);
|
|
|
148 (void) chown (file, uid, gid);
|
|
|
149 (void) chmod (file, mode);
|
|
|
150
|
|
|
151 return OK;
|
|
|
152 }
|
|
|
153
|
|
|
154
|
|
|
155 static int mbx_chk (fd)
|
|
|
156 int fd;
|
|
|
157 {
|
|
|
158 int count;
|
|
|
159 char ldelim[BUFSIZ];
|
|
|
160
|
|
|
161 count = strlen (mmdlm2);
|
|
|
162
|
|
|
163 if (lseek (fd, (off_t) (-count), 2) == (off_t) NOTOK
|
|
|
164 || read (fd, ldelim, count) != count)
|
|
|
165 return NOTOK;
|
|
|
166 ldelim[count] = 0;
|
|
|
167
|
|
|
168 if (strcmp (ldelim, mmdlm2)
|
|
|
169 && write (fd, "\n", 1) != 1
|
|
|
170 && write (fd, mmdlm2, count) != count)
|
|
|
171 return NOTOK;
|
|
|
172
|
|
|
173 return OK;
|
|
|
174 }
|
|
|
175
|
|
|
176 /* */
|
|
|
177
|
|
|
178 int mbx_read (fp, pos, drops, noisy)
|
|
|
179 register FILE *fp;
|
|
|
180 register long pos;
|
|
|
181 struct drop **drops;
|
|
|
182 int noisy;
|
|
|
183 {
|
|
|
184 register int len,
|
|
|
185 size;
|
|
|
186 register long ld1,
|
|
|
187 ld2;
|
|
|
188 register char *bp;
|
|
|
189 char buffer[BUFSIZ];
|
|
|
190 register struct drop *cp,
|
|
|
191 *dp,
|
|
|
192 *ep,
|
|
|
193 *pp;
|
|
|
194
|
|
|
195 pp = (struct drop *) calloc ((unsigned) (len = MAXFOLDER), sizeof *dp);
|
|
|
196 if (pp == NULL) {
|
|
|
197 if (noisy)
|
|
|
198 admonish (NULLCP, "unable to allocate drop storage");
|
|
|
199 return NOTOK;
|
|
|
200 }
|
|
|
201
|
|
|
202 ld1 = (long) strlen (mmdlm1);
|
|
|
203 ld2 = (long) strlen (mmdlm2);
|
|
|
204
|
|
|
205 (void) fseek (fp, pos, 0);
|
|
|
206 for (ep = (dp = pp) + len - 1; fgets (buffer, sizeof buffer, fp);) {
|
|
|
207 size = 0;
|
|
|
208 if (strcmp (buffer, mmdlm1) == 0)
|
|
|
209 pos += ld1, dp -> d_start = (long) pos;
|
|
|
210 else {
|
|
|
211 dp -> d_start = (long)pos , pos += (long) strlen (buffer);
|
|
|
212 for (bp = buffer; *bp; bp++, size++)
|
|
|
213 if (*bp == '\n')
|
|
|
214 size++;
|
|
|
215 }
|
|
|
216
|
|
|
217 while (fgets (buffer, sizeof buffer, fp) != NULL)
|
|
|
218 if (strcmp (buffer, mmdlm2) == 0)
|
|
|
219 break;
|
|
|
220 else {
|
|
|
221 pos += (long) strlen (buffer);
|
|
|
222 for (bp = buffer; *bp; bp++, size++)
|
|
|
223 if (*bp == '\n')
|
|
|
224 size++;
|
|
|
225 }
|
|
|
226
|
|
|
227 if (dp -> d_start != (long) pos) {
|
|
|
228 dp -> d_id = 0;
|
|
|
229 dp -> d_size = (long) size;
|
|
|
230 dp -> d_stop = (long) pos;
|
|
|
231 dp++;
|
|
|
232 }
|
|
|
233 pos += ld2;
|
|
|
234
|
|
|
235 if (dp >= ep) {
|
|
|
236 register int curlen = dp - pp;
|
|
|
237
|
|
|
238 cp = (struct drop *) realloc ((char *) pp,
|
|
|
239 (unsigned) (len += MAXFOLDER) * sizeof *pp);
|
|
|
240 if (cp == NULL) {
|
|
|
241 if (noisy)
|
|
|
242 admonish (NULLCP, "unable to allocate drop storage");
|
|
|
243 free ((char *) pp);
|
|
|
244 return 0;
|
|
|
245 }
|
|
|
246 dp = cp + curlen, ep = (pp = cp) + len - 1;
|
|
|
247 }
|
|
|
248 }
|
|
|
249
|
|
|
250 if (dp == pp)
|
|
|
251 free ((char *) pp);
|
|
|
252 else
|
|
|
253 *drops = pp;
|
|
|
254 return (dp - pp);
|
|
|
255 }
|
|
|
256
|
|
|
257 /* */
|
|
|
258
|
|
|
259 int mbx_write (mailbox, md, fp, id, last, pos, stop, mapping, noisy)
|
|
|
260 char *mailbox;
|
|
|
261 register FILE *fp;
|
|
|
262 int md,
|
|
|
263 id,
|
|
|
264 mapping,
|
|
|
265 noisy;
|
|
|
266 long last;
|
|
|
267 register long pos,
|
|
|
268 stop;
|
|
|
269 {
|
|
|
270 register int i,
|
|
|
271 j,
|
|
|
272 size;
|
|
|
273 long start,
|
|
|
274 off;
|
|
|
275 register char *cp;
|
|
|
276 char buffer[BUFSIZ];
|
|
|
277
|
|
|
278 off = (long) lseek (md, (off_t)0, 1);
|
|
|
279 j = strlen (mmdlm1);
|
|
|
280 if (write (md, mmdlm1, j) != j)
|
|
|
281 return NOTOK;
|
|
|
282 start = (long) lseek (md, (off_t)0, 1);
|
|
|
283 size = 0;
|
|
|
284
|
|
|
285 (void) fseek (fp, pos, 0);
|
|
|
286 while (fgets (buffer, sizeof buffer, fp) != NULL && pos < stop) {
|
|
|
287 i = strlen (buffer);
|
|
|
288 for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++)
|
|
|
289 continue;
|
|
|
290 for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++)
|
|
|
291 continue;
|
|
|
292 if (write (md, buffer, i) != i)
|
|
|
293 return NOTOK;
|
|
|
294 pos += (long) i;
|
|
|
295 if (mapping)
|
|
|
296 for (cp = buffer; i-- > 0; size++)
|
|
|
297 if (*cp++ == '\n')
|
|
|
298 size++;
|
|
|
299 }
|
|
|
300
|
|
|
301 stop = (long) lseek (md, (off_t)0, 1);
|
|
|
302 j = strlen (mmdlm2);
|
|
|
303 if (write (md, mmdlm2, j) != j)
|
|
|
304 return NOTOK;
|
|
|
305 if (mapping)
|
|
|
306 (void) map_write (mailbox, md, id, last, start, stop, off, size, noisy);
|
|
|
307
|
|
|
308 return OK;
|
|
|
309 }
|
|
|
310
|
|
|
311 /* */
|
|
|
312
|
|
|
313 int mbx_copy (mailbox, md, fd, mapping, text, noisy)
|
|
|
314 char *mailbox;
|
|
|
315 int md,
|
|
|
316 fd,
|
|
|
317 mapping,
|
|
|
318 noisy;
|
|
|
319 char *text;
|
|
|
320 {
|
|
|
321 register int i,
|
|
|
322 j,
|
|
|
323 size;
|
|
|
324 long start,
|
|
|
325 stop,
|
|
|
326 pos;
|
|
|
327 register char *cp;
|
|
|
328 char buffer[BUFSIZ];
|
|
|
329 register FILE *fp;
|
|
|
330
|
|
|
331 pos = (long) lseek (md, (off_t)0, 1);
|
|
|
332 size = 0;
|
|
|
333
|
|
|
334 switch (mbx_style) {
|
|
|
335 case MMDF:
|
|
|
336 default:
|
|
|
337 j = strlen (mmdlm1);
|
|
|
338 if (write (md, mmdlm1, j) != j)
|
|
|
339 return NOTOK;
|
|
|
340 start = (long) lseek (md, (off_t)0, 1);
|
|
|
341
|
|
|
342 if (text) {
|
|
|
343 i = strlen (text);
|
|
|
344 if (write (md, text, i) != i)
|
|
|
345 return NOTOK;
|
|
|
346 for (cp = text; *cp++; size++)
|
|
|
347 if (*cp == '\n')
|
|
|
348 size++;
|
|
|
349 }
|
|
|
350
|
|
|
351 while ((i = read (fd, buffer, sizeof buffer)) > 0) {
|
|
|
352 for (j = 0;
|
|
|
353 (j = stringdex (mmdlm1, buffer)) >= 0;
|
|
|
354 buffer[j]++)
|
|
|
355 continue;
|
|
|
356 for (j = 0;
|
|
|
357 (j = stringdex (mmdlm2, buffer)) >= 0;
|
|
|
358 buffer[j]++)
|
|
|
359 continue;
|
|
|
360 if (write (md, buffer, i) != i)
|
|
|
361 return NOTOK;
|
|
|
362 if (mapping)
|
|
|
363 for (cp = buffer; i-- > 0; size++)
|
|
|
364 if (*cp++ == '\n')
|
|
|
365 size++;
|
|
|
366 }
|
|
|
367
|
|
|
368 stop = (long) lseek (md, (off_t)0, 1);
|
|
|
369 j = strlen (mmdlm2);
|
|
|
370 if (write (md, mmdlm2, j) != j)
|
|
|
371 return NOTOK;
|
|
|
372 if (mapping)
|
|
|
373 (void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
|
|
|
374 noisy);
|
|
|
375
|
|
|
376 return (i != NOTOK ? OK : NOTOK);
|
|
|
377
|
|
|
378 case UUCP: /* I hate this... */
|
|
|
379 if ((j = dup (fd)) == NOTOK)
|
|
|
380 return NOTOK;
|
|
|
381 if ((fp = fdopen (j, "r")) == NULL) {
|
|
|
382 (void) close (j);
|
|
|
383 return NOTOK;
|
|
|
384 }
|
|
|
385 start = (long) lseek (md, (off_t)0, 1);
|
|
|
386
|
|
|
387 if (text) {
|
|
|
388 i = strlen (text);
|
|
|
389 if (write (md, text, i) != i)
|
|
|
390 return NOTOK;
|
|
|
391 for (cp = text; *cp++; size++)
|
|
|
392 if (*cp == '\n')
|
|
|
393 size++;
|
|
|
394 }
|
|
|
395
|
|
|
396 for (j = 0; fgets (buffer, sizeof buffer, fp) != NULL; j++) {
|
|
|
397 #ifndef CONTENT_LENGTH
|
|
|
398 if (j != 0 && strncmp (buffer, "From ", 5) == 0) {
|
|
|
399 (void) write (md, ">", 1);
|
|
|
400 size++;
|
|
|
401 }
|
|
|
402 #endif
|
|
|
403 i = strlen (buffer);
|
|
|
404 if (write (md, buffer, i) != i) {
|
|
|
405 (void) fclose (fp);
|
|
|
406 return NOTOK;
|
|
|
407 }
|
|
|
408 if (mapping)
|
|
|
409 for (cp = buffer; i-- > 0; size++)
|
|
|
410 if (*cp++ == '\n')
|
|
|
411 size++;
|
|
|
412 }
|
|
|
413 if (write (md, "\n", 1) != 1) {
|
|
|
414 (void) fclose (fp);
|
|
|
415 return NOTOK;
|
|
|
416 }
|
|
|
417 if (mapping) size += 2;
|
|
|
418
|
|
|
419 (void) fclose (fp);
|
|
|
420 (void) (long) lseek (fd, (off_t)0, 2);
|
|
|
421 stop = (long) lseek (md, (off_t)0, 1);
|
|
|
422 if (mapping)
|
|
|
423 (void) map_write (mailbox, md, 0, (long)0, start, stop, pos, size,
|
|
|
424 noisy);
|
|
|
425
|
|
|
426 return OK;
|
|
|
427 }
|
|
|
428 }
|
|
|
429
|
|
|
430 /* */
|
|
|
431
|
|
|
432 int mbx_size (md, start, stop)
|
|
|
433 int md;
|
|
|
434 long start,
|
|
|
435 stop;
|
|
|
436 {
|
|
|
437 register int i,
|
|
|
438 fd;
|
|
|
439 register long pos;
|
|
|
440 register FILE *fp;
|
|
|
441
|
|
|
442 if ((fd = dup (md)) == NOTOK || (fp = fdopen (fd, "r")) == NULL) {
|
|
|
443 if (fd != NOTOK)
|
|
|
444 (void) close (fd);
|
|
|
445 return NOTOK;
|
|
|
446 }
|
|
|
447
|
|
|
448 (void) fseek (fp, start, 0);
|
|
|
449 for (i = 0, pos = stop - start; pos-- > 0; i++)
|
|
|
450 if (fgetc (fp) == '\n')
|
|
|
451 i++;
|
|
|
452
|
|
|
453 (void) fclose (fp);
|
|
|
454
|
|
|
455 return i;
|
|
|
456 }
|
|
|
457
|
|
|
458 /* */
|
|
|
459
|
|
|
460 int mbx_close (mailbox, md)
|
|
|
461 char *mailbox;
|
|
|
462 int md;
|
|
|
463 {
|
|
|
464 (void) lkclose (md, mailbox);
|
|
|
465
|
|
|
466 return OK;
|
|
|
467 }
|
|
|
468
|
|
|
469 /* */
|
|
|
470
|
|
|
471 /* This function is performed implicitly by getbbent.c:
|
|
|
472
|
|
|
473 bb -> bb_map = map_name (bb -> bb_file);
|
|
|
474 */
|
|
|
475
|
|
|
476 char *map_name (file)
|
|
|
477 register char *file;
|
|
|
478 {
|
|
|
479 register char *cp;
|
|
|
480 static char buffer[BUFSIZ];
|
|
|
481
|
|
|
482 if ((cp = r1bindex (file, '/')) == file)
|
|
|
483 (void) sprintf (buffer, ".%s.map", cp);
|
|
|
484 else
|
|
|
485 (void) sprintf (buffer, "%.*s.%s.map", cp - file, file, cp);
|
|
|
486
|
|
|
487 return buffer;
|
|
|
488 }
|
|
|
489
|
|
|
490 /* */
|
|
|
491
|
|
|
492 int map_read (file, pos, drops, noisy)
|
|
|
493 char *file;
|
|
|
494 long pos;
|
|
|
495 struct drop **drops;
|
|
|
496 int noisy;
|
|
|
497 {
|
|
|
498 register int i, j,
|
|
|
499 md,
|
|
|
500 msgp;
|
|
|
501 register char *cp;
|
|
|
502 struct drop d;
|
|
|
503 register struct drop *mp,
|
|
|
504 *dp;
|
|
|
505
|
|
|
506 if ((md = open (cp = map_name (file), 0)) == NOTOK
|
|
|
507 || map_chk (cp, md, mp = &d, pos, noisy)) {
|
|
|
508 if (md != NOTOK)
|
|
|
509 (void) close (md);
|
|
|
510 return 0;
|
|
|
511 }
|
|
|
512
|
|
|
513 msgp = mp -> d_id;
|
|
|
514 dp = (struct drop *) calloc ((unsigned) (msgp + 1), sizeof *dp);
|
|
|
515 if (dp == NULL) {
|
|
|
516 (void) close (md);
|
|
|
517 return 0;
|
|
|
518 }
|
|
|
519
|
|
|
520 bcopy ((char *) mp, (char *) dp, sizeof *dp);
|
|
|
521
|
|
|
522 (void) lseek (md, (off_t) sizeof *mp, 0);
|
|
|
523 if ((i = read (md, (char *) (dp + 1), msgp * sizeof *dp)) < sizeof *dp) {
|
|
|
524 i = 0;
|
|
|
525 free ((char *) dp);
|
|
|
526 }
|
|
|
527 else {
|
|
|
528 #ifdef NTOHLSWAP
|
|
|
529 register struct drop *tdp;
|
|
|
530 for (j = 0, tdp = dp; j <= i / sizeof(*dp); j++, tdp++) {
|
|
|
531 tdp->d_id = ntohl(tdp->d_id);
|
|
|
532 tdp->d_size = ntohl(tdp->d_size);
|
|
|
533 tdp->d_start = ntohl(tdp->d_start);
|
|
|
534 tdp->d_stop = ntohl(tdp->d_stop);
|
|
|
535 }
|
|
|
536 #endif
|
|
|
537 *drops = dp;
|
|
|
538 }
|
|
|
539
|
|
|
540 (void) close (md);
|
|
|
541
|
|
|
542 return (i / sizeof *dp);
|
|
|
543 }
|
|
|
544
|
|
|
545 /* */
|
|
|
546
|
|
|
547 int map_write (mailbox, md, id, last, start, stop, pos, size, noisy)
|
|
|
548 register char *mailbox;
|
|
|
549 int md,
|
|
|
550 id,
|
|
|
551 size,
|
|
|
552 noisy;
|
|
|
553 long last,
|
|
|
554 start,
|
|
|
555 stop,
|
|
|
556 pos;
|
|
|
557 {
|
|
|
558 register int i;
|
|
|
559 int clear,
|
|
|
560 fd,
|
|
|
561 td;
|
|
|
562 char *file;
|
|
|
563 register struct drop *dp;
|
|
|
564 struct drop d1,
|
|
|
565 d2,
|
|
|
566 *rp;
|
|
|
567 register FILE *fp;
|
|
|
568
|
|
|
569 if ((fd = map_open (file = map_name (mailbox), &clear, md)) == NOTOK)
|
|
|
570 return NOTOK;
|
|
|
571
|
|
|
572 if (!clear && map_chk (file, fd, &d1, pos, noisy)) {
|
|
|
573 (void) unlink (file);
|
|
|
574 (void) mbx_close (file, fd);
|
|
|
575 if ((fd = map_open (file, &clear, md)) == NOTOK)
|
|
|
576 return NOTOK;
|
|
|
577 clear++;
|
|
|
578 }
|
|
|
579
|
|
|
580 if (clear) {
|
|
|
581 if ((td = dup (md)) == NOTOK || (fp = fdopen (td, "r")) == NULL) {
|
|
|
582 if (noisy)
|
|
|
583 admonish (file, "unable to %s", td != NOTOK ? "fdopen" : "dup");
|
|
|
584 if (td != NOTOK)
|
|
|
585 (void) close (td);
|
|
|
586 (void) mbx_close (file, fd);
|
|
|
587 return NOTOK;
|
|
|
588 }
|
|
|
589
|
|
|
590 switch (i = mbx_read (fp, 0L, &rp, noisy)) {
|
|
|
591 case NOTOK:
|
|
|
592 (void) fclose (fp);
|
|
|
593 (void) mbx_close (file, fd);
|
|
|
594 return NOTOK;
|
|
|
595
|
|
|
596 case OK:
|
|
|
597 break;
|
|
|
598
|
|
|
599 default:
|
|
|
600 d1.d_id = 0;
|
|
|
601 for (dp = rp; i-- >0; dp++) {
|
|
|
602 if (dp -> d_start == start)
|
|
|
603 dp -> d_id = id;
|
|
|
604 #ifdef NTOHLSWAP
|
|
|
605 dp -> d_id = htonl(dp -> d_id);
|
|
|
606 dp -> d_size = htonl(dp -> d_size);
|
|
|
607 dp -> d_start = htonl(dp -> d_start);
|
|
|
608 dp -> d_stop = htonl(dp -> d_stop);
|
|
|
609 #endif
|
|
|
610 (void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
|
|
|
611 if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
|
|
|
612 if (noisy)
|
|
|
613 admonish (file, "write error");
|
|
|
614 (void) mbx_close (file, fd);
|
|
|
615 (void) fclose (fp);
|
|
|
616 return NOTOK;
|
|
|
617 }
|
|
|
618 }
|
|
|
619 free ((char *) rp);
|
|
|
620 break;
|
|
|
621 }
|
|
|
622 }
|
|
|
623 else {
|
|
|
624 if (last == 0)
|
|
|
625 last = d1.d_start;
|
|
|
626 dp = &d2;
|
|
|
627 #ifdef NTOHLSWAP
|
|
|
628 dp -> d_id = htonl(id);
|
|
|
629 dp -> d_size = htonl((long) (size ? size : mbx_size (fd, start, stop)));
|
|
|
630 dp -> d_start = htonl((long) start);
|
|
|
631 dp -> d_stop = htonl((long) stop);
|
|
|
632 #else
|
|
|
633 dp -> d_id = id;
|
|
|
634 dp -> d_size = (long) (size ? size : mbx_size (fd, start, stop));
|
|
|
635 dp -> d_start = (long) start;
|
|
|
636 dp -> d_stop = (long) stop;
|
|
|
637 #endif
|
|
|
638 (void) lseek (fd, (off_t) (++d1.d_id * sizeof *dp), 0);
|
|
|
639 if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
|
|
|
640 if (noisy)
|
|
|
641 admonish (file, "write error");
|
|
|
642 (void) mbx_close (file, fd);
|
|
|
643 return NOTOK;
|
|
|
644 }
|
|
|
645 }
|
|
|
646
|
|
|
647 dp = &d1;
|
|
|
648 #ifdef NTOHLSWAP
|
|
|
649 dp -> d_id = htonl(dp -> d_id);
|
|
|
650 dp -> d_size = htonl(DRVRSN);
|
|
|
651 dp -> d_start = htonl((long) last);
|
|
|
652 dp -> d_stop = htonl((long) lseek (md, (off_t)0, 1));
|
|
|
653 #else
|
|
|
654 dp -> d_size = DRVRSN;
|
|
|
655 dp -> d_start = (long) last;
|
|
|
656 dp -> d_stop = (long) lseek (md, (off_t)0, 1);
|
|
|
657 #endif
|
|
|
658
|
|
|
659 (void) lseek (fd, (off_t)0, 0);
|
|
|
660 if (write (fd, (char *) dp, sizeof *dp) != sizeof *dp) {
|
|
|
661 if (noisy)
|
|
|
662 admonish (file, "write error");
|
|
|
663 (void) mbx_close (file, fd);
|
|
|
664 return NOTOK;
|
|
|
665 }
|
|
|
666
|
|
|
667 (void) mbx_close (file, fd);
|
|
|
668
|
|
|
669 return OK;
|
|
|
670 }
|
|
|
671
|
|
|
672 /* */
|
|
|
673
|
|
|
674 static int map_open (file, clear, md)
|
|
|
675 char *file;
|
|
|
676 int *clear,
|
|
|
677 md;
|
|
|
678 {
|
|
|
679 int mode;
|
|
|
680 struct stat st;
|
|
|
681
|
|
|
682 mode = fstat (md, &st) != NOTOK ? (int) (st.st_mode & 0777) : m_gmprot ();
|
|
|
683 return mbx_Xopen (file, st.st_uid, st.st_gid, mode, clear);
|
|
|
684 }
|
|
|
685
|
|
|
686 /* */
|
|
|
687
|
|
|
688 int map_chk (file, fd, dp, pos, noisy)
|
|
|
689 char *file;
|
|
|
690 int fd,
|
|
|
691 noisy;
|
|
|
692 register struct drop *dp;
|
|
|
693 long pos;
|
|
|
694 {
|
|
|
695 long count;
|
|
|
696 struct drop d, tmpd;
|
|
|
697 register struct drop *dl;
|
|
|
698
|
|
|
699 if (read (fd, (char *) &tmpd, sizeof *dp) != sizeof *dp) {
|
|
|
700 #ifdef notdef
|
|
|
701 admonish (NULLCP, "%s: missing or partial index", file);
|
|
|
702 #endif /* notdef */
|
|
|
703 return NOTOK;
|
|
|
704 }
|
|
|
705 #ifndef NTOHLSWAP
|
|
|
706 *dp = tmpd; /* if ntohl(n)=(n), can use struct assign */
|
|
|
707 #else
|
|
|
708 dp->d_id = ntohl(tmpd.d_id);
|
|
|
709 dp->d_size = ntohl(tmpd.d_size);
|
|
|
710 dp->d_start = ntohl(tmpd.d_start);
|
|
|
711 dp->d_stop = ntohl(tmpd.d_stop);
|
|
|
712 #endif
|
|
|
713
|
|
|
714 if (dp -> d_size != DRVRSN) {
|
|
|
715 if (noisy)
|
|
|
716 admonish (NULLCP, "%s: version mismatch (%d != %d)", file,
|
|
|
717 dp->d_size, DRVRSN);
|
|
|
718 return NOTOK;
|
|
|
719 }
|
|
|
720
|
|
|
721 if (dp -> d_stop != (long) pos) {
|
|
|
722 if (noisy && pos != (long)0)
|
|
|
723 admonish (NULLCP,
|
|
|
724 "%s: pointer mismatch or incomplete index (%ld!=%ld)",
|
|
|
725 file, dp -> d_stop, (long) pos);
|
|
|
726 return NOTOK;
|
|
|
727 }
|
|
|
728
|
|
|
729 if ((long) ((dp -> d_id + 1) * sizeof *dp) != (long) lseek (fd, (off_t)0, 2)) {
|
|
|
730 if (noisy)
|
|
|
731 admonish (NULLCP, "%s: corrupt index(1)", file);
|
|
|
732 return NOTOK;
|
|
|
733 }
|
|
|
734
|
|
|
735 dl = &d;
|
|
|
736 count = (long) strlen (mmdlm2);
|
|
|
737 (void) lseek (fd, (off_t) (dp -> d_id * sizeof *dp), 0);
|
|
|
738 if (read (fd, (char *) dl, sizeof *dl) != sizeof *dl
|
|
|
739 #ifdef NTOHLSWAP
|
|
|
740 || (ntohl(dl -> d_stop) != dp -> d_stop
|
|
|
741 && ntohl(dl -> d_stop) + count != dp -> d_stop)) {
|
|
|
742 #else
|
|
|
743 || dl -> d_stop != dp -> d_stop
|
|
|
744 && dl -> d_stop + count != dp -> d_stop) {
|
|
|
745 #endif
|
|
|
746 if (noisy)
|
|
|
747 admonish (NULLCP, "%s: corrupt index(2)", file);
|
|
|
748 return NOTOK;
|
|
|
749 }
|
|
|
750
|
|
|
751 return OK;
|
|
|
752 }
|
