fill in a few of the missing ChangeLog entries
[mmh] / uip / inc.c
1
2 /*
3  * inc.c -- incorporate messages from a maildrop into a folder
4  *
5  * $Id$
6  *
7  * This code is Copyright (c) 2002, by the authors of nmh.  See the
8  * COPYRIGHT file in the root directory of the nmh distribution for
9  * complete copyright information.
10  */
11
12 #ifdef MAILGROUP
13 /* Revised: Sat Apr 14 17:08:17 PDT 1990 (marvit@hplabs)
14  *    Added hpux hacks to set and reset gid to be "mail" as needed. The reset
15  *    is necessary so inc'ed mail is the group of the inc'er, rather than
16  *    "mail". We setgid to egid only when [un]locking the mail file. This
17  *    is also a major security precaution which will not be explained here.
18  *
19  * Fri Feb  7 16:04:57 PST 1992         John Romine <bug-mh@ics.uci.edu>
20  *   NB: I'm not 100% sure that this setgid stuff is secure even now.
21  *
22  * See the *GROUPPRIVS() macros later. I'm reasonably happy with the setgid
23  * attribute. Running setuid root is probably not a terribly good idea, though.
24  *       -- Peter Maydell <pmaydell@chiark.greenend.org.uk>, 04/1998
25  *
26  * Peter Maydell's patch slightly modified for nmh 0.28-pre2.
27  * Ruud de Rooij <ruud@debian.org>  Wed, 22 Jul 1998 13:24:22 +0200
28  */
29 #endif
30
31 #include <h/mh.h>
32 #include <fcntl.h>
33
34 #ifdef POP
35 # include <h/dropsbr.h>
36 # include <h/popsbr.h>
37 #endif
38
39 #ifdef HESIOD
40 # include <hesiod.h>
41 #endif
42
43 #include <h/fmt_scan.h>
44 #include <h/scansbr.h>
45 #include <h/signals.h>
46 #include <h/tws.h>
47 #include <h/mts.h>
48 #include <errno.h>
49 #include <signal.h>
50
51 #ifndef POP
52 # define POPminc(a) (a)
53 #else
54 # define POPminc(a)  0
55 #endif
56
57 #ifndef RPOP
58 # define RPOPminc(a) (a)
59 #else
60 # define RPOPminc(a)  0
61 #endif
62
63 #ifndef APOP
64 # define APOPminc(a) (a)
65 #else
66 # define APOPminc(a)  0
67 #endif
68
69 #ifndef KPOP
70 # define KPOPminc(a) (a)
71 #else
72 # define KPOPminc(a)  0
73 #endif
74
75 #ifndef CYRUS_SASL
76 # define SASLminc(a) (a)
77 #else
78 # define SASLminc(a)  0
79 #endif
80
81 static struct swit switches[] = {
82 #define AUDSW                      0
83     { "audit audit-file", 0 },
84 #define NAUDSW                     1
85     { "noaudit", 0 },
86 #define CHGSW                      2
87     { "changecur", 0 },
88 #define NCHGSW                     3
89     { "nochangecur", 0 },
90 #define FILESW                     4
91     { "file name", 0 },
92 #define FORMSW                     5
93     { "form formatfile", 0 },
94 #define FMTSW                      6
95     { "format string", 5 },
96 #define HOSTSW                     7
97     { "host hostname", POPminc (-4) },
98 #define USERSW                     8
99     { "user username", POPminc (-4) },
100 #define PACKSW                     9
101     { "pack file", POPminc (-4) },
102 #define NPACKSW                   10
103     { "nopack", POPminc (-6) },
104 #define APOPSW                    11
105     { "apop", APOPminc (-4) },
106 #define NAPOPSW                   12
107     { "noapop", APOPminc (-6) },
108 #define RPOPSW                    13
109     { "rpop", RPOPminc (-4) },
110 #define NRPOPSW                   14
111     { "norpop", RPOPminc (-6) },
112 #define SILSW                     15
113     { "silent", 0 },
114 #define NSILSW                    16
115     { "nosilent", 0 },
116 #define TRNCSW                    17
117     { "truncate", 0 },
118 #define NTRNCSW                   18
119     { "notruncate", 0 },
120 #define WIDTHSW                   19
121     { "width columns", 0 },
122 #define VERSIONSW                 20
123     { "version", 0 },
124 #define HELPSW                    21
125     { "help", 0 },
126 #define SNOOPSW                   22
127     { "snoop", -5 },
128 #define KPOPSW                    23
129     { "kpop", KPOPminc (-4) },
130 #define SASLSW                    24
131     { "sasl", SASLminc(-4) },
132 #define SASLMECHSW                25
133     { "saslmech", SASLminc(-8) },
134 #define PROXYSW                   26
135     { "proxy command", POPminc(-5) },
136     { NULL, 0 }
137 };
138
139 /*
140  * flags for the mail source
141  */
142 #define INC_FILE  0
143 #define INC_POP   1
144
145 static int inc_type;
146 static int snoop = 0;
147
148 #ifdef POP
149 extern char response[];
150
151 static char *packfile = NULL;
152 static int size;
153 static long pos;
154 static long start;
155 static long stop;
156
157 static int mbx_style = MMDF_FORMAT;
158 static int pd = NOTOK;
159 static FILE *pf = NULL;
160 #endif /* POP */
161
162 /* This is an attempt to simplify things by putting all the
163  * privilege ops into macros.
164  * *GROUPPRIVS() is related to handling the setgid MAIL property,
165  * and only applies if MAILGROUP is defined.
166  * *USERPRIVS() is related to handling the setuid root property,
167  * and only applies if POP is defined [why does POP => setuid root?]
168  * Basically, SAVEGROUPPRIVS() is called right at the top of main()
169  * to initialise things, and then DROPGROUPPRIVS() and GETGROUPPRIVS()
170  * do the obvious thing. TRYDROPGROUPPRIVS() has to be safe to call
171  * before DROPUSERPRIVS() is called [this is needed because setgid()
172  * sets both effective and real uids if euid is root.]
173  *
174  * There's probably a better implementation if we're allowed to use
175  * BSD-style setreuid() rather than using POSIX saved-ids.
176  * Anyway, if you're euid root it's a bit pointless to drop the group
177  * permissions...
178  *
179  * I'm pretty happy that the security is good provided we aren't setuid root.
180  * The only things we trust with group=mail privilege are lkfopen()
181  * and lkfclose().
182  */
183
184 /*
185  * For setting and returning to "mail" gid
186  */
187 #ifdef MAILGROUP
188 static int return_gid;
189 #ifndef POP
190 /* easy case; we're not setuid root, so can drop group privs
191  * immediately.
192  */
193 #define TRYDROPGROUPPRIVS() DROPGROUPPRIVS()
194 #else /* POP ie we are setuid root */
195 #define TRYDROPGROUPPRIVS() \
196 if (geteuid() != 0) DROPGROUPPRIVS()
197 #endif
198 #define DROPGROUPPRIVS() setgid(getgid())
199 #define GETGROUPPRIVS() setgid(return_gid)
200 #define SAVEGROUPPRIVS() return_gid = getegid()
201 #else
202 /* define *GROUPPRIVS() as null; this avoids having lots of "#ifdef MAILGROUP"s */
203 #define TRYDROPGROUPPRIVS()
204 #define DROPGROUPPRIVS()
205 #define GETGROUPPRIVS()
206 #define SAVEGROUPPRIVS()
207 #endif /* not MAILGROUP */
208
209 #ifdef POP
210 #define DROPUSERPRIVS() setuid(getuid())
211 #else
212 #define DROPUSERPRIVS()
213 #endif
214
215 /* these variables have to be globals so that done() can correctly clean up the lockfile */
216 static int locked = 0;
217 static char *newmail;
218 static FILE *in;
219
220 /*
221  * prototypes
222  */
223 char *map_name(char *);
224
225 #ifdef POP
226 int done(int);
227 static int pop_action(char *);
228 static int pop_pack(char *);
229 static int map_count(void);
230 #endif
231
232
233 int
234 main (int argc, char **argv)
235 {
236     int chgflag = 1, trnflag = 1;
237     int noisy = 1, width = 0;
238     int rpop, i, hghnum, msgnum;
239     int kpop = 0, sasl = 0;
240     char *cp, *maildir, *folder = NULL;
241     char *format = NULL, *form = NULL;
242     char *host = NULL, *user = NULL, *proxy = NULL;
243     char *audfile = NULL, *from = NULL, *saslmech = NULL;
244     char buf[BUFSIZ], **argp, *nfs, **arguments;
245     struct msgs *mp;
246     struct stat st, s1;
247     FILE *aud = NULL;
248     char        b[MAXPATHLEN + 1];
249     char        *maildir_copy;          /* copy of mail directory because the static gets overwritten */
250
251 #ifdef POP
252     int nmsgs, nbytes, p = 0;
253     char *pass = NULL;
254     char *MAILHOST_env_variable;
255 #endif
256
257 #ifdef MHE
258     FILE *mhe = NULL;
259 #endif
260
261 #ifdef HESIOD
262     struct hes_postoffice *po;
263 #endif
264
265 /* absolutely the first thing we do is save our privileges,
266  * and drop them if we can.
267  */
268     SAVEGROUPPRIVS();
269     TRYDROPGROUPPRIVS();
270
271 #ifdef LOCALE
272     setlocale(LC_ALL, "");
273 #endif
274     invo_name = r1bindex (argv[0], '/');
275
276     /* read user profile/context */
277     context_read();
278
279     mts_init (invo_name);
280     arguments = getarguments (invo_name, argc, argv, 1);
281     argp = arguments;
282
283 #ifdef POP
284     /*
285      * Scheme is:
286      *        use MAILHOST environment variable if present,
287      *  else try Hesiod.
288      *  If that fails, use the default (if any)
289      *  provided by mts.conf in mts_init()
290      */
291     if ((MAILHOST_env_variable = getenv("MAILHOST")) != NULL)
292         pophost = MAILHOST_env_variable;
293 # ifdef HESIOD
294     else if ((po = hes_getmailhost(getusername())) != NULL &&
295              strcmp(po->po_type, "POP") == 0)
296         pophost = po->po_host;
297 # endif /* HESIOD */
298     /*
299      * If there is a valid "pophost" entry in mts.conf,
300      * then use it as the default host.
301      */
302     if (pophost && *pophost)
303         host = pophost;
304
305     if ((cp = getenv ("MHPOPDEBUG")) && *cp)
306         snoop++;
307 #endif /* POP */
308
309     rpop = 0;
310
311     while ((cp = *argp++)) {
312         if (*cp == '-') {
313             switch (smatch (++cp, switches)) {
314             case AMBIGSW: 
315                 ambigsw (cp, switches);
316                 done (1);
317             case UNKWNSW: 
318                 adios (NULL, "-%s unknown", cp);
319
320             case HELPSW: 
321                 snprintf (buf, sizeof(buf), "%s [+folder] [switches]", invo_name);
322                 print_help (buf, switches, 1);
323                 done (1);
324             case VERSIONSW:
325                 print_version(invo_name);
326                 done (1);
327
328             case AUDSW: 
329                 if (!(cp = *argp++) || *cp == '-')
330                     adios (NULL, "missing argument to %s", argp[-2]);
331                 audfile = getcpy (m_maildir (cp));
332                 continue;
333             case NAUDSW: 
334                 audfile = NULL;
335                 continue;
336
337             case CHGSW: 
338                 chgflag++;
339                 continue;
340             case NCHGSW: 
341                 chgflag = 0;
342                 continue;
343
344             /*
345              * The flag `trnflag' has the value:
346              *
347              * 2 if -truncate is given
348              * 1 by default (truncating is default)
349              * 0 if -notruncate is given
350              */
351             case TRNCSW: 
352                 trnflag = 2;
353                 continue;
354             case NTRNCSW: 
355                 trnflag = 0;
356                 continue;
357
358             case FILESW: 
359                 if (!(cp = *argp++) || *cp == '-')
360                     adios (NULL, "missing argument to %s", argp[-2]);
361                 from = path (cp, TFILE);
362
363                 /*
364                  * If the truncate file is in default state,
365                  * change to not truncate.
366                  */
367                 if (trnflag == 1)
368                     trnflag = 0;
369                 continue;
370
371             case SILSW: 
372                 noisy = 0;
373                 continue;
374             case NSILSW: 
375                 noisy++;
376                 continue;
377
378             case FORMSW: 
379                 if (!(form = *argp++) || *form == '-')
380                     adios (NULL, "missing argument to %s", argp[-2]);
381                 format = NULL;
382                 continue;
383             case FMTSW: 
384                 if (!(format = *argp++) || *format == '-')
385                     adios (NULL, "missing argument to %s", argp[-2]);
386                 form = NULL;
387                 continue;
388
389             case WIDTHSW: 
390                 if (!(cp = *argp++) || *cp == '-')
391                     adios (NULL, "missing argument to %s", argp[-2]);
392                 width = atoi (cp);
393                 continue;
394
395             case HOSTSW:
396                 if (!(host = *argp++) || *host == '-')
397                     adios (NULL, "missing argument to %s", argp[-2]);
398                 continue;
399             case USERSW:
400                 if (!(user = *argp++) || *user == '-')
401                     adios (NULL, "missing argument to %s", argp[-2]);
402                 continue;
403
404             case PACKSW:
405 #ifndef POP
406                 if (!(cp = *argp++) || *cp == '-')
407                     adios (NULL, "missing argument to %s", argp[-2]);
408 #else /* POP */
409                 if (!(packfile = *argp++) || *packfile == '-')
410                     adios (NULL, "missing argument to %s", argp[-2]);
411 #endif /* POP */
412                 continue;
413             case NPACKSW:
414 #ifdef POP
415                 packfile = NULL;
416 #endif /* POP */
417                 continue;
418
419             case APOPSW:
420                 rpop = -1;
421                 continue;
422             case NAPOPSW:
423                 rpop = 0;
424                 continue;
425
426             case RPOPSW:
427                 rpop = 1;
428                 continue;
429             case NRPOPSW:
430                 rpop = 0;
431                 continue;
432
433             case KPOPSW:
434                 kpop = 1;
435                 continue;
436
437             case SNOOPSW:
438                 snoop++;
439                 continue;
440         
441             case SASLSW:
442                 sasl++;
443                 continue;
444         
445             case SASLMECHSW:
446                 if (!(saslmech = *argp++) || *saslmech == '-')
447                     adios (NULL, "missing argument to %s", argp[-2]);
448                 continue;
449             case PROXYSW:
450                 if (!(proxy = *argp++) || *proxy == '-')
451                     adios (NULL, "missing argument to %s", argp[-2]);
452                 continue;
453             }
454         }
455         if (*cp == '+' || *cp == '@') {
456             if (folder)
457                 adios (NULL, "only one folder at a time!");
458             else
459                 folder = path (cp + 1, *cp == '+' ? TFOLDER : TSUBCWF);
460         } else {
461             adios (NULL, "usage: %s [+folder] [switches]", invo_name);
462         }
463     }
464
465     /* NOTE: above this point you should use TRYDROPGROUPPRIVS(),
466      * not DROPGROUPPRIVS().
467      */
468 #ifdef POP
469     if (host && !*host)
470         host = NULL;
471     if (from || !host || rpop <= 0)
472         DROPUSERPRIVS();
473 #endif /* POP */
474
475     /* guarantee dropping group priveleges; we might not have done so earlier */
476     DROPGROUPPRIVS();
477
478     /*
479      * Where are we getting the new mail?
480      */
481     if (from)
482         inc_type = INC_FILE;
483 #ifdef POP
484     else if (host)
485         inc_type = INC_POP;
486 #endif
487     else
488         inc_type = INC_FILE;
489
490 #ifdef POP
491     /*
492      * Are we getting the mail from
493      * a POP server?
494      */
495     if (inc_type == INC_POP) {
496         if (user == NULL)
497             user = getusername ();
498         if ( strcmp( POPSERVICE, "kpop" ) == 0 ) {
499             kpop = 1;
500         }
501         if (kpop || sasl || ( rpop > 0))
502             pass = getusername ();
503         else
504             ruserpass (host, &user, &pass);
505
506         /*
507          * initialize POP connection
508          */
509         if (pop_init (host, user, pass, proxy, snoop, kpop ? 1 : rpop, kpop,
510                       sasl, saslmech) == NOTOK)
511             adios (NULL, "%s", response);
512
513         /* Check if there are any messages */
514         if (pop_stat (&nmsgs, &nbytes) == NOTOK)
515             adios (NULL, "%s", response);
516
517         if (rpop > 0)
518             DROPUSERPRIVS();
519         if (nmsgs == 0) {
520             pop_quit();
521             adios (NULL, "no mail to incorporate");
522         }
523     }
524 #endif /* POP */
525
526     /*
527      * We will get the mail from a file
528      * (typically the standard maildrop)
529      */
530
531     if (inc_type == INC_FILE) {
532         if (from)
533             newmail = from;
534         else if ((newmail = getenv ("MAILDROP")) && *newmail)
535             newmail = m_mailpath (newmail);
536         else if ((newmail = context_find ("maildrop")) && *newmail)
537             newmail = m_mailpath (newmail);
538         else {
539             newmail = concat (MAILDIR, "/", MAILFIL, NULL);
540         }
541         if (stat (newmail, &s1) == NOTOK || s1.st_size == 0)
542             adios (NULL, "no mail to incorporate");
543
544         if ((cp = strdup(newmail)) == (char *)0)
545             adios (maildir, "error allocating memory to copy newmail");
546
547         newmail = cp;
548     }
549
550 #ifdef POP
551     /* skip the folder setup */
552     if ((inc_type == INC_POP) && packfile)
553         goto go_to_it;
554 #endif /* POP */
555
556     if (!context_find ("path"))
557         free (path ("./", TFOLDER));
558     if (!folder)
559         folder = getfolder (0);
560     maildir = m_maildir (folder);
561
562     if ((maildir_copy = strdup(maildir)) == (char *)0)
563         adios (maildir, "error allocating memory to copy maildir");
564
565     if (stat (maildir, &st) == NOTOK) {
566         if (errno != ENOENT)
567             adios (maildir, "error on folder");
568         cp = concat ("Create folder \"", maildir, "\"? ", NULL);
569         if (noisy && !getanswer (cp))
570             done (1);
571         free (cp);
572         if (!makedir (maildir))
573             adios (NULL, "unable to create folder %s", maildir);
574     }
575
576     if (chdir (maildir) == NOTOK)
577         adios (maildir, "unable to change directory to");
578
579     /* read folder and create message structure */
580     if (!(mp = folder_read (folder)))
581         adios (NULL, "unable to read folder %s", folder);
582
583 #ifdef POP
584 go_to_it:
585 #endif /* POP */
586
587     if (inc_type == INC_FILE) {
588         if (access (newmail, W_OK) != NOTOK) {
589             locked++;
590             if (trnflag) {
591                 SIGNAL (SIGHUP, SIG_IGN);
592                 SIGNAL (SIGINT, SIG_IGN);
593                 SIGNAL (SIGQUIT, SIG_IGN);
594                 SIGNAL (SIGTERM, SIG_IGN);
595             }
596
597             GETGROUPPRIVS();       /* Reset gid to lock mail file */
598             in = lkfopen (newmail, "r");
599             DROPGROUPPRIVS();
600             if (in == NULL)
601                 adios (NULL, "unable to lock and fopen %s", newmail);
602             fstat (fileno(in), &s1);
603         } else {
604             trnflag = 0;
605             if ((in = fopen (newmail, "r")) == NULL)
606                 adios (newmail, "unable to read");
607         }
608     }
609
610     /* This shouldn't be necessary but it can't hurt. */
611     DROPGROUPPRIVS();
612
613     if (audfile) {
614         if ((i = stat (audfile, &st)) == NOTOK)
615             advise (NULL, "Creating Receive-Audit: %s", audfile);
616         if ((aud = fopen (audfile, "a")) == NULL)
617             adios (audfile, "unable to append to");
618         else if (i == NOTOK)
619             chmod (audfile, m_gmprot ());
620
621 #ifdef POP
622         fprintf (aud, from ? "<<inc>> %s -ms %s\n"
623                  : host ? "<<inc>> %s -host %s -user %s%s\n"
624                  : "<<inc>> %s\n",
625                  dtimenow (0), from ? from : host, user,
626                  rpop < 0 ? " -apop" : rpop > 0 ? " -rpop" : "");
627 #else /* POP */
628         fprintf (aud, from ? "<<inc>> %s  -ms %s\n" : "<<inc>> %s\n",
629                  dtimenow (0), from);
630 #endif /* POP */
631     }
632
633 #ifdef MHE
634     if (context_find ("mhe")) {
635         cp = concat (maildir, "/++", NULL);
636         i = stat (cp, &st);
637         if ((mhe = fopen (cp, "a")) == NULL)
638             admonish (cp, "unable to append to");
639         else
640             if (i == NOTOK)
641                 chmod (cp, m_gmprot ());
642         free (cp);
643     }
644 #endif /* MHE */
645
646     /* Get new format string */
647     nfs = new_fs (form, format, FORMAT);
648
649     if (noisy) {
650         printf ("Incorporating new mail into %s...\n\n", folder);
651         fflush (stdout);
652     }
653
654 #ifdef POP
655     /*
656      * Get the mail from a POP server
657      */
658     if (inc_type == INC_POP) {
659         if (packfile) {
660             packfile = path (packfile, TFILE);
661             if (stat (packfile, &st) == NOTOK) {
662                 if (errno != ENOENT)
663                     adios (packfile, "error on file");
664                 cp = concat ("Create file \"", packfile, "\"? ", NULL);
665                 if (noisy && !getanswer (cp))
666                     done (1);
667                 free (cp);
668             }
669             msgnum = map_count ();
670             if ((pd = mbx_open (packfile, mbx_style, getuid(), getgid(), m_gmprot()))
671                 == NOTOK)
672                 adios (packfile, "unable to open");
673             if ((pf = fdopen (pd, "w+")) == NULL)
674                 adios (NULL, "unable to fdopen %s", packfile);
675         } else {
676             hghnum = msgnum = mp->hghmsg;
677             /*
678              * Check if we have enough message space for all the new
679              * messages.  If not, then realloc the folder and add enough
680              * space for all new messages plus 10 additional slots.
681              */
682             if (mp->hghmsg + nmsgs >= mp->hghoff
683                 && !(mp = folder_realloc (mp, mp->lowoff, mp->hghmsg + nmsgs + 10)))
684                 adios (NULL, "unable to allocate folder storage");
685         }
686
687         for (i = 1; i <= nmsgs; i++) {
688             msgnum++;
689             if (packfile) {
690                 fseek (pf, 0L, SEEK_CUR);
691                 pos = ftell (pf);
692                 size = 0;
693                 fwrite (mmdlm1, 1, strlen (mmdlm1), pf);
694                 start = ftell (pf);
695
696                 if (pop_retr (i, pop_pack) == NOTOK)
697                     adios (NULL, "%s", response);
698
699                 fseek (pf, 0L, SEEK_CUR);
700                 stop = ftell (pf);
701                 if (fflush (pf))
702                     adios (packfile, "write error on");
703                 fseek (pf, start, SEEK_SET);
704             } else {
705                 cp = getcpy (m_name (msgnum));
706                 if ((pf = fopen (cp, "w+")) == NULL)
707                     adios (cp, "unable to write");
708                 chmod (cp, m_gmprot ());
709                 start = stop = 0L;
710
711                 if (pop_retr (i, pop_action) == NOTOK)
712                     adios (NULL, "%s", response);
713
714                 if (fflush (pf))
715                     adios (cp, "write error on");
716                 fseek (pf, 0L, SEEK_SET);
717             }
718             switch (p = scan (pf, msgnum, 0, nfs, width,
719                               packfile ? 0 : msgnum == mp->hghmsg + 1 && chgflag,
720                               1, NULL, stop - start, noisy)) {
721             case SCNEOF: 
722                 printf ("%*d  empty\n", DMAXFOLDER, msgnum);
723                 break;
724
725             case SCNFAT:
726                 trnflag = 0;
727                 noisy++;
728                 /* advise (cp, "unable to read"); already advised */
729                 /* fall thru */
730
731             case SCNERR:
732             case SCNNUM: 
733                 break;
734
735             case SCNMSG: 
736             case SCNENC:
737             default: 
738                 if (aud)
739                     fputs (scanl, aud);
740 # ifdef MHE
741                 if (mhe)
742                     fputs (scanl, mhe);
743 # endif /* MHE */
744                 if (noisy)
745                     fflush (stdout);
746                 if (!packfile) {
747                     clear_msg_flags (mp, msgnum);
748                     set_exists (mp, msgnum);
749                     set_unseen (mp, msgnum);
750                     mp->msgflags |= SEQMOD;
751                 }
752                 break;
753             }
754             if (packfile) {
755                 fseek (pf, stop, SEEK_SET);
756                 fwrite (mmdlm2, 1, strlen (mmdlm2), pf);
757                 if (fflush (pf) || ferror (pf)) {
758                     int e = errno;
759                     pop_quit ();
760                     errno = e;
761                     adios (packfile, "write error on");
762                 }
763                 map_write (packfile, pd, 0, 0L, start, stop, pos, size, noisy);
764             } else {
765                 if (ferror(pf) || fclose (pf)) {
766                     int e = errno;
767                     unlink (cp);
768                     pop_quit ();
769                     errno = e;
770                     adios (cp, "write error on");
771                 }
772                 free (cp);
773             }
774
775             if (trnflag && pop_dele (i) == NOTOK)
776                 adios (NULL, "%s", response);
777         }
778
779         if (pop_quit () == NOTOK)
780             adios (NULL, "%s", response);
781         if (packfile) {
782             mbx_close (packfile, pd);
783             pd = NOTOK;
784         }
785     }
786 #endif /* POP */
787
788     /*
789      * Get the mail from file (usually mail spool)
790      */
791     if (inc_type == INC_FILE) {
792         m_unknown (in);         /* the MAGIC invocation... */
793         hghnum = msgnum = mp->hghmsg;
794         for (i = 0;;) {
795             /*
796              * Check if we need to allocate more space for message status.
797              * If so, then add space for an additional 100 messages.
798              */
799             if (msgnum >= mp->hghoff
800                 && !(mp = folder_realloc (mp, mp->lowoff, mp->hghoff + 100))) {
801                 advise (NULL, "unable to allocate folder storage");
802                 i = NOTOK;
803                 break;
804             }
805
806 #if 0
807             /* copy file from spool to tmp file */
808             tmpfilenam = m_scratch ("", invo_name);
809             if ((fd = creat (tmpfilenam, m_gmprot ())) == NOTOK)
810                 adios (tmpfilenam, "unable to create");
811             chmod (tmpfilenam, m_gmprot ());
812             if (!(in2 = fdopen (fd, "r+")))
813                 adios (tmpfilenam, "unable to access");
814             cpymsg (in, in2);
815
816             /* link message into folder */
817             newmsg = folder_addmsg(mp, tmpfilenam);
818 #endif
819             /* create scanline for new message */
820             switch (i = scan (in, msgnum + 1, msgnum + 1, nfs, width,
821                               msgnum == hghnum && chgflag, 1, NULL, 0L, noisy)) {
822             case SCNFAT:
823             case SCNEOF: 
824                 break;
825
826             case SCNERR:
827                 if (aud)
828                     fputs ("inc aborted!\n", aud);
829                 advise (NULL, "aborted!");      /* doesn't clean up locks! */
830                 break;
831
832             case SCNNUM: 
833                 advise (NULL, "BUG in %s, number out of range", invo_name);
834                 break;
835
836             default: 
837                 advise (NULL, "BUG in %s, scan() botch (%d)", invo_name, i);
838                 break;
839
840             case SCNMSG:
841             case SCNENC:
842                 /*
843                  *  Run the external program hook on the message.
844                  */
845
846                 (void)snprintf(b, sizeof (b), "%s/%d", maildir_copy, msgnum + 1);
847                 (void)ext_hook("add-hook", b, (char *)0);
848
849                 if (aud)
850                     fputs (scanl, aud);
851 #ifdef MHE
852                 if (mhe)
853                     fputs (scanl, mhe);
854 #endif /* MHE */
855                 if (noisy)
856                     fflush (stdout);
857
858                 msgnum++;
859                 mp->hghmsg++;
860                 mp->nummsg++;
861                 if (mp->lowmsg == 0) mp->lowmsg = 1;
862
863                 clear_msg_flags (mp, msgnum);
864                 set_exists (mp, msgnum);
865                 set_unseen (mp, msgnum);
866                 mp->msgflags |= SEQMOD;
867                 continue;
868             }
869             break;
870         }
871     }
872
873 #ifdef POP
874     if (p < 0) {                /* error */
875 #else
876     if (i < 0) {                /* error */
877 #endif
878         if (locked) {
879             GETGROUPPRIVS();      /* Be sure we can unlock mail file */
880             (void) lkfclose (in, newmail); in = NULL;
881             DROPGROUPPRIVS();    /* And then return us to normal privileges */
882         } else {
883             fclose (in); in = NULL;
884         }
885         adios (NULL, "failed");
886     }
887
888     if (aud)
889         fclose (aud);
890
891 #ifdef MHE
892     if (mhe)
893         fclose (mhe);
894 #endif /* MHE */
895
896     if (noisy)
897         fflush (stdout);
898
899 #ifdef POP
900     if ((inc_type == INC_POP) && packfile)
901         done (0);
902 #endif /* POP */
903
904     /*
905      * truncate file we are incorporating from
906      */
907     if (inc_type == INC_FILE) {
908         if (trnflag) {
909             if (stat (newmail, &st) != NOTOK && s1.st_mtime != st.st_mtime)
910                 advise (NULL, "new messages have arrived!\007");
911             else {
912                 if ((i = creat (newmail, 0600)) != NOTOK)
913                     close (i);
914                 else
915                     admonish (newmail, "error zero'ing");
916                 unlink(map_name(newmail));
917             }
918         } else {
919             if (noisy)
920                 printf ("%s not zero'd\n", newmail);
921         }
922     }
923
924     if (msgnum == hghnum) {
925         admonish (NULL, "no messages incorporated");
926     } else {
927         context_replace (pfolder, folder);      /* update current folder */
928         if (chgflag)
929             mp->curmsg = hghnum + 1;
930         mp->hghmsg = msgnum;
931         if (mp->lowmsg == 0)
932             mp->lowmsg = 1;
933         if (chgflag)            /* sigh... */
934             seq_setcur (mp, mp->curmsg);
935     }
936
937     /*
938      * unlock the mail spool
939      */
940     if (inc_type == INC_FILE) {
941         if (locked) {
942            GETGROUPPRIVS();        /* Be sure we can unlock mail file */
943            (void) lkfclose (in, newmail); in = NULL;
944            DROPGROUPPRIVS();       /* And then return us to normal privileges */
945         } else {
946             fclose (in); in = NULL;
947         }
948     }
949
950     seq_setunseen (mp, 0);      /* set the Unseen-Sequence */
951     seq_save (mp);              /* synchronize sequences   */
952     context_save ();            /* save the context file   */
953     return done (0);
954 }
955
956
957 #if 0
958
959 /*
960  * Copy message message from spool into
961  * temporary file.  Massage the "From " line
962  * while copying.
963  */
964
965 cpymsg (FILE *in, FILE *out)
966 {
967     int state;
968     char *tmpbuf, name[NAMESZ];
969
970     for (;;) {
971         state = m_getfld (state, name, tmpbuf, rlwidth, in);
972         switch (state) {
973         case FLD:
974         case FLDPLUS:
975             break;
976         case BODY:
977             break;
978         case LENERR:
979         case FMTERR:
980             break;
981         case FILEEOF:
982             break;
983         default:
984         }
985     }
986 }
987 #endif /* if 0 */
988
989
990 int
991 done (int status)
992 {
993 #ifdef POP
994     if (packfile && pd != NOTOK)
995         mbx_close (packfile, pd);
996 #endif /* POP */
997     if (locked)
998     {
999         GETGROUPPRIVS();
1000         lkfclose(in, newmail);
1001         DROPGROUPPRIVS();
1002     }
1003     exit (status);
1004     return 1;  /* dead code to satisfy the compiler */
1005 }
1006
1007 #ifdef POP
1008 static int
1009 pop_action (char *s)
1010 {
1011     fprintf (pf, "%s\n", s);
1012     stop += strlen (s) + 1;
1013     return 0;  /* Is return value used?  This was missing before 1999-07-15. */
1014 }
1015
1016 static int
1017 pop_pack (char *s)
1018 {
1019     int j;
1020     char buffer[BUFSIZ];
1021
1022     snprintf (buffer, sizeof(buffer), "%s\n", s);
1023     for (j = 0; (j = stringdex (mmdlm1, buffer)) >= 0; buffer[j]++)
1024         continue;
1025     for (j = 0; (j = stringdex (mmdlm2, buffer)) >= 0; buffer[j]++)
1026         continue;
1027     fputs (buffer, pf);
1028     size += strlen (buffer) + 1;
1029     return 0;  /* Is return value used?  This was missing before 1999-07-15. */
1030 }
1031
1032 static int
1033 map_count (void)
1034 {
1035     int md;
1036     char *cp;
1037     struct drop d;
1038     struct stat st;
1039
1040     if (stat (packfile, &st) == NOTOK)
1041         return 0;
1042     if ((md = open (cp = map_name (packfile), O_RDONLY)) == NOTOK
1043             || map_chk (cp, md, &d, (long) st.st_size, 1)) {
1044         if (md != NOTOK)
1045             close (md);
1046         return 0;
1047     }
1048     close (md);
1049     return (d.d_id);
1050 }
1051 #endif /* POP */