lib-src/movemail.c

   1 /* movemail foo bar -- move file foo to file bar,
   2    locking file foo the way /bin/mail respects.
   3    Copyright (C) 1986, 1992, 1993, 1994, 1996 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* Important notice: defining MAIL_USE_FLOCK or MAIL_USE_LOCKF *will
  23    cause loss of mail* if you do it on a system that does not normally
  24    use flock as its way of interlocking access to inbox files.  The
  25    setting of MAIL_USE_FLOCK and MAIL_USE_LOCKF *must agree* with the
  26    system's own conventions.  It is not a choice that is up to you.
  27
  28    So, if your system uses lock files rather than flock, then the only way
  29    you can get proper operation is to enable movemail to write lockfiles there.
  30    This means you must either give that directory access modes
  31    that permit everyone to write lockfiles in it, or you must make movemail
  32    a setuid or setgid program.  */
  33
  34 /*
  35  * Modified January, 1986 by Michael R. Gretzinger (Project Athena)
  36  *
  37  * Added POP (Post Office Protocol) service.  When compiled -DMAIL_USE_POP
  38  * movemail will accept input filename arguments of the form
  39  * "po:username".  This will cause movemail to open a connection to
  40  * a pop server running on $MAILHOST (environment variable).  Movemail
  41  * must be setuid to root in order to work with POP.
  42  *
  43  * New module: popmail.c
  44  * Modified routines:
  45  *      main - added code within #ifdef MAIL_USE_POP; added setuid (getuid ())
  46  *              after POP code.
  47  * New routines in movemail.c:
  48  *      get_errmsg - return pointer to system error message
  49  *
  50  * Modified August, 1993 by Jonathan Kamens (OpenVision Technologies)
  51  *
  52  * Move all of the POP code into a separate file, "pop.c".
  53  * Use strerror instead of get_errmsg.
  54  *
  55  */
  56
  57 #define NO_SHORTNAMES   /* Tell config not to load remap.h */
  58 #include <../src/config.h>
  59 #include <sys/types.h>
  60 #include <sys/stat.h>
  61 #include <sys/file.h>
  62 #include <stdio.h>
  63 #include <errno.h>
  64 #include <../src/syswait.h>
  65 #include <getopt.h>
  66 #ifdef MAIL_USE_POP
  67 #include "pop.h"
  68 #endif
  69
  70 #ifdef MSDOS
  71 #undef access
  72 #endif /* MSDOS */
  73
  74 #ifndef DIRECTORY_SEP
  75 #define DIRECTORY_SEP '/'
  76 #endif
  77 #ifndef IS_DIRECTORY_SEP
  78 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
  79 #endif
  80
  81 #ifdef WINDOWSNT
  82 #include "ntlib.h"
  83 #undef access
  84 #undef unlink
  85 #define fork() 0
  86 #define wait(var) (*(var) = 0)
  87 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
  88    though the locking call succeeds (and indeed blocks local access from
  89    other NT programs).  If you have direct file access using an NFS
  90    client or something other than Samba, the locking call might work
  91    properly - make sure it does before you enable this!
  92
  93    [18-Feb-97 andrewi] I now believe my comment above to be incorrect,
  94    since it was based on a misunderstanding of how locking calls are
  95    implemented and used on Unix.  */
  96 //#define DISABLE_DIRECT_ACCESS
  97
  98 /* Ensure all file i/o is in binary mode. */
  99 #include <fcntl.h>
 100 int _fmode = _O_BINARY;
 101 #endif /* WINDOWSNT */
 102
 103 /* Cancel substitutions made by config.h for Emacs.  */
 104 #undef open
 105 #undef read
 106 #undef write
 107 #undef close
 108
 109 #ifdef USG
 110 #include <fcntl.h>
 111 #include <unistd.h>
 112 #ifndef F_OK
 113 #define F_OK 0
 114 #define X_OK 1
 115 #define W_OK 2
 116 #define R_OK 4
 117 #endif
 118 #endif /* USG */
 119
 120 #ifdef HAVE_UNISTD_H
 121 #include <unistd.h>
 122 #endif
 123
 124 #ifdef STDC_HEADERS
 125 #include <stdlib.h>
 126 #endif
 127
 128 #if defined (XENIX) || defined (WINDOWSNT)
 129 #include <sys/locking.h>
 130 #endif
 131
 132 #ifdef MAIL_USE_LOCKF
 133 #define MAIL_USE_SYSTEM_LOCK
 134 #endif
 135
 136 #ifdef MAIL_USE_FLOCK
 137 #define MAIL_USE_SYSTEM_LOCK
 138 #endif
 139
 140 #ifdef MAIL_USE_MMDF
 141 extern int lk_open (), lk_close ();
 142 #endif
 143
 144 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
 145         defined (HAVE_LIBMAIL) && defined (HAVE_MAILLOCK_H)
 146 #include <maillock.h>
 147 /* We can't use maillock unless we know what directory system mail
 148    files appear in. */
 149 #ifdef MAILDIR
 150 #define MAIL_USE_MAILLOCK
 151 static char *mail_spool_name ();
 152 #endif
 153 #endif
 154
 155 #ifndef errno
 156 extern int errno;
 157 #endif
 158 char *strerror ();
 159 extern char *rindex ();
 160
 161 void fatal ();
 162 void error ();
 163 void pfatal_with_name ();
 164 void pfatal_and_delete ();
 165 char *concat ();
 166 long *xmalloc ();
 167 int popmail ();
 168 int pop_retr ();
 169 int mbx_write ();
 170 int mbx_delimit_begin ();
 171 int mbx_delimit_end ();
 172
 173 /* Nonzero means this is name of a lock file to delete on fatal error.  */
 174 char *delete_lockname;
 175
 176 int
 177 main (argc, argv)
 178      int argc;
 179      char **argv;
 180 {
 181   char *inname, *outname;
 182   int indesc, outdesc;
 183   int nread;
 184   WAITTYPE status;
 185   int c, preserve_mail = 0;
 186
 187 #ifndef MAIL_USE_SYSTEM_LOCK
 188   struct stat st;
 189   long now;
 190   int tem;
 191   char *lockname, *p;
 192   char *tempname;
 193   int desc;
 194 #endif /* not MAIL_USE_SYSTEM_LOCK */
 195
 196 #ifdef MAIL_USE_MAILLOCK
 197   char *spool_name;
 198 #endif
 199
 200 #ifdef MAIL_USE_POP
 201   int pop_reverse_order = 0;
 202 # define ARGSTR "pr"
 203 #else /* ! MAIL_USE_POP */
 204 # define ARGSTR "p"
 205 #endif /* MAIL_USE_POP */
 206
 207   delete_lockname = 0;
 208
 209   while ((c = getopt (argc, argv, ARGSTR)) != EOF)
 210     {
 211       switch (c) {
 212 #ifdef MAIL_USE_POP
 213       case 'r':
 214         pop_reverse_order = 1;
 215         break;
 216 #endif
 217       case 'p':
 218         preserve_mail++;
 219         break;
 220       default:
 221         exit(1);
 222       }
 223     }
 224
 225   if (
 226 #ifdef MAIL_USE_POP
 227       (argc - optind < 2) || (argc - optind > 3)
 228 #else
 229       (argc - optind != 2)
 230 #endif
 231       )
 232     {
 233       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n",
 234 #ifdef MAIL_USE_POP
 235                " [POP-password]"
 236 #else
 237                ""
 238 #endif
 239                );
 240       exit (1);
 241     }
 242
 243   inname = argv[optind];
 244   outname = argv[optind+1];
 245
 246 #ifdef MAIL_USE_MMDF
 247   mmdf_init (argv[0]);
 248 #endif
 249
 250   if (*outname == 0)
 251     fatal ("Destination file name is empty", 0);
 252
 253   /* Check access to output file.  */
 254   if (access (outname, F_OK) == 0 && access (outname, W_OK) != 0)
 255     pfatal_with_name (outname);
 256
 257   /* Also check that outname's directory is writable to the real uid.  */
 258   {
 259     char *buf = (char *) xmalloc (strlen (outname) + 1);
 260     char *p;
 261     strcpy (buf, outname);
 262     p = buf + strlen (buf);
 263     while (p > buf && !IS_DIRECTORY_SEP (p[-1]))
 264       *--p = 0;
 265     if (p == buf)
 266       *p++ = '.';
 267     if (access (buf, W_OK) != 0)
 268       pfatal_with_name (buf);
 269     free (buf);
 270   }
 271
 272 #ifdef MAIL_USE_POP
 273   if (!strncmp (inname, "po:", 3))
 274     {
 275       int status;
 276
 277       status = popmail (inname + 3, outname, preserve_mail,
 278                         (argc - optind == 3) ? argv[optind+2] : NULL,
 279                         pop_reverse_order);
 280       exit (status);
 281     }
 282
 283   setuid (getuid ());
 284 #endif /* MAIL_USE_POP */
 285
 286 #ifndef DISABLE_DIRECT_ACCESS
 287
 288   /* Check access to input file.  */
 289   if (access (inname, R_OK | W_OK) != 0)
 290     pfatal_with_name (inname);
 291
 292 #ifndef MAIL_USE_MMDF
 293 #ifndef MAIL_USE_SYSTEM_LOCK
 294 #ifdef MAIL_USE_MAILLOCK
 295   spool_name = mail_spool_name (inname);
 296   if (! spool_name)
 297 #endif
 298     {
 299       /* Use a lock file named after our first argument with .lock appended:
 300          If it exists, the mail file is locked.  */
 301       /* Note: this locking mechanism is *required* by the mailer
 302          (on systems which use it) to prevent loss of mail.
 303
 304          On systems that use a lock file, extracting the mail without locking
 305          WILL occasionally cause loss of mail due to timing errors!
 306
 307          So, if creation of the lock file fails
 308          due to access permission on the mail spool directory,
 309          you simply MUST change the permission
 310          and/or make movemail a setgid program
 311          so it can create lock files properly.
 312
 313          You might also wish to verify that your system is one
 314          which uses lock files for this purpose.  Some systems use other methods.
 315
 316          If your system uses the `flock' system call for mail locking,
 317          define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
 318          and recompile movemail.  If the s- file for your system
 319          should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
 320          to bug-gnu-emacs@prep.ai.mit.edu so we can fix it.  */
 321
 322       lockname = concat (inname, ".lock", "");
 323       tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
 324       strcpy (tempname, inname);
 325       p = tempname + strlen (tempname);
 326       while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
 327         p--;
 328       *p = 0;
 329       strcpy (p, "EXXXXXX");
 330       mktemp (tempname);
 331       unlink (tempname);
 332
 333       while (1)
 334         {
 335           /* Create the lock file, but not under the lock file name.  */
 336           /* Give up if cannot do that.  */
 337           desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 338           if (desc < 0)
 339             {
 340               char *message = (char *) xmalloc (strlen (tempname) + 50);
 341               sprintf (message, "%s--see source file lib-src/movemail.c",
 342                        tempname);
 343               pfatal_with_name (message);
 344             }
 345           close (desc);
 346
 347           tem = link (tempname, lockname);
 348           unlink (tempname);
 349           if (tem >= 0)
 350             break;
 351           sleep (1);
 352
 353           /* If lock file is five minutes old, unlock it.
 354              Five minutes should be good enough to cope with crashes
 355              and wedgitude, and long enough to avoid being fooled
 356              by time differences between machines.  */
 357           if (stat (lockname, &st) >= 0)
 358             {
 359               now = time (0);
 360               if (st.st_ctime < now - 300)
 361                 unlink (lockname);
 362             }
 363         }
 364
 365       delete_lockname = lockname;
 366     }
 367 #endif /* not MAIL_USE_SYSTEM_LOCK */
 368 #endif /* not MAIL_USE_MMDF */
 369
 370   if (fork () == 0)
 371     {
 372       int lockcount = 0;
 373       int status = 0;
 374 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 375       long touched_lock, now;
 376 #endif
 377
 378       setuid (getuid ());
 379
 380 #ifndef MAIL_USE_MMDF
 381 #ifdef MAIL_USE_SYSTEM_LOCK
 382       indesc = open (inname, O_RDWR);
 383 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 384       indesc = open (inname, O_RDONLY);
 385 #endif /* not MAIL_USE_SYSTEM_LOCK */
 386 #else  /* MAIL_USE_MMDF */
 387       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 388 #endif /* MAIL_USE_MMDF */
 389
 390       if (indesc < 0)
 391         pfatal_with_name (inname);
 392
 393 #if defined (BSD_SYSTEM) || defined (XENIX)
 394       /* In case movemail is setuid to root, make sure the user can
 395          read the output file.  */
 396       /* This is desirable for all systems
 397          but I don't want to assume all have the umask system call */
 398       umask (umask (0) & 0333);
 399 #endif /* BSD_SYSTEM || XENIX */
 400       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 401       if (outdesc < 0)
 402         pfatal_with_name (outname);
 403
 404       /* This label exists so we can retry locking
 405          after a delay, if it got EAGAIN or EBUSY.  */
 406     retry_lock:
 407
 408       /* Try to lock it.  */
 409 #ifdef MAIL_USE_MAILLOCK
 410       if (spool_name)
 411         {
 412           /* The "0 - " is to make it a negative number if maillock returns
 413              non-zero. */
 414           status = 0 - maillock (spool_name, 1);
 415 #ifdef HAVE_TOUCHLOCK
 416           touched_lock = time (0);
 417 #endif
 418           lockcount = 5;
 419         }
 420       else
 421 #endif /* MAIL_USE_MAILLOCK */
 422         {
 423 #ifdef MAIL_USE_SYSTEM_LOCK
 424 #ifdef MAIL_USE_LOCKF
 425           status = lockf (indesc, F_LOCK, 0);
 426 #else /* not MAIL_USE_LOCKF */
 427 #ifdef XENIX
 428           status = locking (indesc, LK_RLCK, 0L);
 429 #else
 430 #ifdef WINDOWSNT
 431           status = locking (indesc, LK_RLCK, -1L);
 432 #else
 433           status = flock (indesc, LOCK_EX);
 434 #endif
 435 #endif
 436 #endif /* not MAIL_USE_LOCKF */
 437 #endif /* MAIL_USE_SYSTEM_LOCK */
 438         }
 439
 440       /* If it fails, retry up to 5 times
 441          for certain failure codes.  */
 442       if (status < 0)
 443         {
 444           if (++lockcount <= 5)
 445             {
 446 #ifdef EAGAIN
 447               if (errno == EAGAIN)
 448                 {
 449                   sleep (1);
 450                   goto retry_lock;
 451                 }
 452 #endif
 453 #ifdef EBUSY
 454               if (errno == EBUSY)
 455                 {
 456                   sleep (1);
 457                   goto retry_lock;
 458                 }
 459 #endif
 460             }
 461
 462           pfatal_with_name (inname);
 463         }
 464
 465       {
 466         char buf[1024];
 467
 468         while (1)
 469           {
 470             nread = read (indesc, buf, sizeof buf);
 471             if (nread != write (outdesc, buf, nread))
 472               {
 473                 int saved_errno = errno;
 474                 unlink (outname);
 475                 errno = saved_errno;
 476                 pfatal_with_name (outname);
 477               }
 478             if (nread < sizeof buf)
 479               break;
 480 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 481             if (spool_name)
 482               {
 483                 now = time (0);
 484                 if (now - touched_lock > 60)
 485                   {
 486                     touchlock ();
 487                     touched_lock = now;
 488                   }
 489               }
 490 #endif /* MAIL_USE_MAILLOCK */
 491           }
 492       }
 493
 494 #ifdef BSD_SYSTEM
 495       if (fsync (outdesc) < 0)
 496         pfatal_and_delete (outname);
 497 #endif
 498
 499       /* Check to make sure no errors before we zap the inbox.  */
 500       if (close (outdesc) != 0)
 501         pfatal_and_delete (outname);
 502
 503 #ifdef MAIL_USE_SYSTEM_LOCK
 504       if (! preserve_mail)
 505         {
 506 #if defined (STRIDE) || defined (XENIX) || defined (WINDOWSNT)
 507           /* Stride, xenix have file locking, but no ftruncate.
 508              This mess will do. */
 509           close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
 510 #else
 511           ftruncate (indesc, 0L);
 512 #endif /* STRIDE or XENIX */
 513         }
 514 #endif /* MAIL_USE_SYSTEM_LOCK */
 515
 516 #ifdef MAIL_USE_MMDF
 517       lk_close (indesc, 0, 0, 0);
 518 #else
 519       close (indesc);
 520 #endif
 521
 522 #ifndef MAIL_USE_SYSTEM_LOCK
 523       if (! preserve_mail)
 524         {
 525           /* Delete the input file; if we can't, at least get rid of its
 526              contents.  */
 527 #ifdef MAIL_UNLINK_SPOOL
 528           /* This is generally bad to do, because it destroys the permissions
 529              that were set on the file.  Better to just empty the file.  */
 530           if (unlink (inname) < 0 && errno != ENOENT)
 531 #endif /* MAIL_UNLINK_SPOOL */
 532             creat (inname, 0600);
 533         }
 534 #endif /* not MAIL_USE_SYSTEM_LOCK */
 535
 536 #ifdef MAIL_USE_MAILLOCK
 537       /* This has to occur in the child, i.e., in the process that
 538          acquired the lock! */
 539       if (spool_name)
 540         mailunlock ();
 541 #endif
 542       exit (0);
 543     }
 544
 545   wait (&status);
 546   if (!WIFEXITED (status))
 547     exit (1);
 548   else if (WRETCODE (status) != 0)
 549     exit (WRETCODE (status));
 550
 551 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 552 #ifdef MAIL_USE_MAILLOCK
 553   if (! spool_name)
 554 #endif /* MAIL_USE_MAILLOCK */
 555     unlink (lockname);
 556 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 557
 558 #endif /* ! DISABLE_DIRECT_ACCESS */
 559
 560   return 0;
 561 }
 562
 563 #ifdef MAIL_USE_MAILLOCK
 564 /* This function uses stat to confirm that the mail directory is
 565    identical to the directory of the input file, rather than just
 566    string-comparing the two paths, because one or both of them might
 567    be symbolic links pointing to some other directory. */
 568 static char *
 569 mail_spool_name (inname)
 570      char *inname;
 571 {
 572   struct stat stat1, stat2;
 573   char *indir, *fname;
 574   int status;
 575
 576   if (! (fname = rindex (inname, '/')))
 577     return NULL;
 578
 579   fname++;
 580
 581   if (stat (MAILDIR, &stat1) < 0)
 582     return NULL;
 583
 584   indir = (char *) xmalloc (fname - inname + 1);
 585   strncpy (indir, inname, fname - inname);
 586   indir[fname-inname] = '\0';
 587
 588
 589   status = stat (indir, &stat2);
 590
 591   free (indir);
 592
 593   if (status < 0)
 594     return NULL;
 595
 596   if (stat1.st_dev == stat2.st_dev
 597       && stat1.st_ino == stat2.st_ino)
 598     return fname;
 599
 600   return NULL;
 601 }
 602 #endif /* MAIL_USE_MAILLOCK */
 603 \f
 604 /* Print error message and exit.  */
 605
 606 void
 607 fatal (s1, s2)
 608      char *s1, *s2;
 609 {
 610   if (delete_lockname)
 611     unlink (delete_lockname);
 612   error (s1, s2);
 613   exit (1);
 614 }
 615
 616 /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
 617
 618 void
 619 error (s1, s2, s3)
 620      char *s1, *s2, *s3;
 621 {
 622   fprintf (stderr, "movemail: ");
 623   fprintf (stderr, s1, s2, s3);
 624   fprintf (stderr, "\n");
 625 }
 626
 627 void
 628 pfatal_with_name (name)
 629      char *name;
 630 {
 631   char *s = concat ("", strerror (errno), " for %s");
 632   fatal (s, name);
 633 }
 634
 635 void
 636 pfatal_and_delete (name)
 637      char *name;
 638 {
 639   char *s = concat ("", strerror (errno), " for %s");
 640   unlink (name);
 641   fatal (s, name);
 642 }
 643
 644 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 645
 646 char *
 647 concat (s1, s2, s3)
 648      char *s1, *s2, *s3;
 649 {
 650   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 651   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 652
 653   strcpy (result, s1);
 654   strcpy (result + len1, s2);
 655   strcpy (result + len1 + len2, s3);
 656   *(result + len1 + len2 + len3) = 0;
 657
 658   return result;
 659 }
 660
 661 /* Like malloc but get fatal error if memory is exhausted.  */
 662
 663 long *
 664 xmalloc (size)
 665      unsigned size;
 666 {
 667   long *result = (long *) malloc (size);
 668   if (!result)
 669     fatal ("virtual memory exhausted", 0);
 670   return result;
 671 }
 672 \f
 673 /* This is the guts of the interface to the Post Office Protocol.  */
 674
 675 #ifdef MAIL_USE_POP
 676
 677 #ifndef WINDOWSNT
 678 #include <sys/socket.h>
 679 #include <netinet/in.h>
 680 #include <netdb.h>
 681 #else
 682 #undef _WINSOCKAPI_
 683 #include <winsock.h>
 684 #endif
 685 #include <pwd.h>
 686
 687 #define NOTOK (-1)
 688 #define OK 0
 689 #define DONE 1
 690
 691 char *progname;
 692 FILE *sfi;
 693 FILE *sfo;
 694 char ibuffer[BUFSIZ];
 695 char obuffer[BUFSIZ];
 696 char Errmsg[80];
 697
 698 popmail (user, outfile, preserve, password, reverse_order)
 699      char *user;
 700      char *outfile;
 701      int preserve;
 702      char *password;
 703      int reverse_order;
 704 {
 705   int nmsgs, nbytes;
 706   register int i;
 707   int mbfi;
 708   FILE *mbf;
 709   char *getenv ();
 710   popserver server;
 711   int start, end, increment;
 712
 713   server = pop_open (0, user, password, POP_NO_GETPASS);
 714   if (! server)
 715     {
 716       error ("Error connecting to POP server: %s", pop_error);
 717       return (1);
 718     }
 719
 720   if (pop_stat (server, &nmsgs, &nbytes))
 721     {
 722       error ("Error getting message count from POP server: %s", pop_error);
 723       return (1);
 724     }
 725
 726   if (!nmsgs)
 727     {
 728       pop_close (server);
 729       return (0);
 730     }
 731
 732   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 733   if (mbfi < 0)
 734     {
 735       pop_close (server);
 736       error ("Error in open: %s, %s", strerror (errno), outfile);
 737       return (1);
 738     }
 739   fchown (mbfi, getuid (), -1);
 740
 741   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 742     {
 743       pop_close (server);
 744       error ("Error in fdopen: %s", strerror (errno));
 745       close (mbfi);
 746       unlink (outfile);
 747       return (1);
 748     }
 749
 750   if (reverse_order)
 751     {
 752       start = nmsgs;
 753       end = 1;
 754       increment = -1;
 755     }
 756   else
 757     {
 758       start = 1;
 759       end = nmsgs;
 760       increment = 1;
 761     }
 762
 763   for (i = start; i * increment <= end * increment; i += increment)
 764     {
 765       mbx_delimit_begin (mbf);
 766       if (pop_retr (server, i, mbf) != OK)
 767         {
 768           error (Errmsg);
 769           close (mbfi);
 770           return (1);
 771         }
 772       mbx_delimit_end (mbf);
 773       fflush (mbf);
 774       if (ferror (mbf))
 775         {
 776           error ("Error in fflush: %s", strerror (errno));
 777           pop_close (server);
 778           close (mbfi);
 779           return (1);
 780         }
 781     }
 782
 783   /* On AFS, a call to write only modifies the file in the local
 784    *     workstation's AFS cache.  The changes are not written to the server
 785    *      until a call to fsync or close is made.  Users with AFS home
 786    *      directories have lost mail when over quota because these checks were
 787    *      not made in previous versions of movemail. */
 788
 789 #ifdef BSD_SYSTEM
 790   if (fsync (mbfi) < 0)
 791     {
 792       error ("Error in fsync: %s", strerror (errno));
 793       return (1);
 794     }
 795 #endif
 796
 797   if (close (mbfi) == -1)
 798     {
 799       error ("Error in close: %s", strerror (errno));
 800       return (1);
 801     }
 802
 803   if (! preserve)
 804     for (i = 1; i <= nmsgs; i++)
 805       {
 806         if (pop_delete (server, i))
 807           {
 808             error ("Error from POP server: %s", pop_error);
 809             pop_close (server);
 810             return (1);
 811           }
 812       }
 813
 814   if (pop_quit (server))
 815     {
 816       error ("Error from POP server: %s", pop_error);
 817       return (1);
 818     }
 819
 820   return (0);
 821 }
 822
 823 int
 824 pop_retr (server, msgno, arg)
 825      popserver server;
 826      FILE *arg;
 827 {
 828   extern char *strerror ();
 829   char *line;
 830   int ret;
 831
 832   if (pop_retrieve_first (server, msgno, &line))
 833     {
 834       char *error = concat ("Error from POP server: ", pop_error, "");
 835       strncpy (Errmsg, error, sizeof (Errmsg));
 836       Errmsg[sizeof (Errmsg)-1] = '\0';
 837       free(error);
 838       return (NOTOK);
 839     }
 840
 841   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 842     {
 843       if (! line)
 844         break;
 845
 846       if (mbx_write (line, ret, arg) != OK)
 847         {
 848           strcpy (Errmsg, strerror (errno));
 849           pop_close (server);
 850           return (NOTOK);
 851         }
 852     }
 853
 854   if (ret)
 855     {
 856       char *error = concat ("Error from POP server: ", pop_error, "");
 857       strncpy (Errmsg, error, sizeof (Errmsg));
 858       Errmsg[sizeof (Errmsg)-1] = '\0';
 859       free(error);
 860       return (NOTOK);
 861     }
 862
 863   return (OK);
 864 }
 865
 866 /* Do this as a macro instead of using strcmp to save on execution time. */
 867 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 868                          && (a[1] == 'r') \
 869                          && (a[2] == 'o') \
 870                          && (a[3] == 'm') \
 871                          && (a[4] == ' '))
 872
 873 int
 874 mbx_write (line, len, mbf)
 875      char *line;
 876      int len;
 877      FILE *mbf;
 878 {
 879 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 880   if (IS_FROM_LINE (line))
 881     {
 882       if (fputc ('>', mbf) == EOF)
 883         return (NOTOK);
 884     }
 885 #endif
 886   if (line[0] == '\037')
 887     {
 888       if (fputs ("^_", mbf) == EOF)
 889         return (NOTOK);
 890       line++;
 891       len--;
 892     }
 893   if (fwrite (line, 1, len, mbf) != len)
 894     return (NOTOK);
 895   if (fputc (0x0a, mbf) == EOF)
 896     return (NOTOK);
 897   return (OK);
 898 }
 899
 900 int
 901 mbx_delimit_begin (mbf)
 902      FILE *mbf;
 903 {
 904   if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
 905     return (NOTOK);
 906   return (OK);
 907 }
 908
 909 mbx_delimit_end (mbf)
 910      FILE *mbf;
 911 {
 912   if (putc ('\037', mbf) == EOF)
 913     return (NOTOK);
 914   return (OK);
 915 }
 916
 917 #endif /* MAIL_USE_POP */
 918 \f
 919 #ifndef HAVE_STRERROR
 920 char *
 921 strerror (errnum)
 922      int errnum;
 923 {
 924   extern char *sys_errlist[];
 925   extern int sys_nerr;
 926
 927   if (errnum >= 0 && errnum < sys_nerr)
 928     return sys_errlist[errnum];
 929   return (char *) "Unknown error";
 930 }
 931
 932 #endif /* ! HAVE_STRERROR */