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