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