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