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, "creating %s, which would become the lock file",
 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 /*
 689  * The full legal syntax for a POP mailbox specification for movemail
 690  * is "po:username:hostname".  The ":hostname" is optional; if it is
 691  * omitted, the MAILHOST environment variable will be consulted.  Note
 692  * that by the time popmail() is called the "po:" has been stripped
 693  * off of the front of the mailbox name.
 694  *
 695  * If the mailbox is in the form "po:username:hostname", then it is
 696  * modified by this function -- the second colon is replaced by a
 697  * null.
 698  */
 699
 700 popmail (mailbox, outfile, preserve, password, reverse_order)
 701      char *mailbox;
 702      char *outfile;
 703      int preserve;
 704      char *password;
 705      int reverse_order;
 706 {
 707   int nmsgs, nbytes;
 708   register int i;
 709   int mbfi;
 710   FILE *mbf;
 711   char *getenv ();
 712   popserver server;
 713   int start, end, increment;
 714   char *user, *hostname;
 715
 716   user = mailbox;
 717   if ((hostname = index(mailbox, ':')))
 718     *hostname++ = '\0';
 719
 720   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 721   if (! server)
 722     {
 723       error ("Error connecting to POP server: %s", pop_error);
 724       return (1);
 725     }
 726
 727   if (pop_stat (server, &nmsgs, &nbytes))
 728     {
 729       error ("Error getting message count from POP server: %s", pop_error);
 730       return (1);
 731     }
 732
 733   if (!nmsgs)
 734     {
 735       pop_close (server);
 736       return (0);
 737     }
 738
 739   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 740   if (mbfi < 0)
 741     {
 742       pop_close (server);
 743       error ("Error in open: %s, %s", strerror (errno), outfile);
 744       return (1);
 745     }
 746   fchown (mbfi, getuid (), -1);
 747
 748   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 749     {
 750       pop_close (server);
 751       error ("Error in fdopen: %s", strerror (errno));
 752       close (mbfi);
 753       unlink (outfile);
 754       return (1);
 755     }
 756
 757   if (reverse_order)
 758     {
 759       start = nmsgs;
 760       end = 1;
 761       increment = -1;
 762     }
 763   else
 764     {
 765       start = 1;
 766       end = nmsgs;
 767       increment = 1;
 768     }
 769
 770   for (i = start; i * increment <= end * increment; i += increment)
 771     {
 772       mbx_delimit_begin (mbf);
 773       if (pop_retr (server, i, mbf) != OK)
 774         {
 775           error (Errmsg);
 776           close (mbfi);
 777           return (1);
 778         }
 779       mbx_delimit_end (mbf);
 780       fflush (mbf);
 781       if (ferror (mbf))
 782         {
 783           error ("Error in fflush: %s", strerror (errno));
 784           pop_close (server);
 785           close (mbfi);
 786           return (1);
 787         }
 788     }
 789
 790   /* On AFS, a call to write only modifies the file in the local
 791    *     workstation's AFS cache.  The changes are not written to the server
 792    *      until a call to fsync or close is made.  Users with AFS home
 793    *      directories have lost mail when over quota because these checks were
 794    *      not made in previous versions of movemail. */
 795
 796 #ifdef BSD_SYSTEM
 797   if (fsync (mbfi) < 0)
 798     {
 799       error ("Error in fsync: %s", strerror (errno));
 800       return (1);
 801     }
 802 #endif
 803
 804   if (close (mbfi) == -1)
 805     {
 806       error ("Error in close: %s", strerror (errno));
 807       return (1);
 808     }
 809
 810   if (! preserve)
 811     for (i = 1; i <= nmsgs; i++)
 812       {
 813         if (pop_delete (server, i))
 814           {
 815             error ("Error from POP server: %s", pop_error);
 816             pop_close (server);
 817             return (1);
 818           }
 819       }
 820
 821   if (pop_quit (server))
 822     {
 823       error ("Error from POP server: %s", pop_error);
 824       return (1);
 825     }
 826
 827   return (0);
 828 }
 829
 830 int
 831 pop_retr (server, msgno, arg)
 832      popserver server;
 833      FILE *arg;
 834 {
 835   extern char *strerror ();
 836   char *line;
 837   int ret;
 838
 839   if (pop_retrieve_first (server, msgno, &line))
 840     {
 841       char *error = concat ("Error from POP server: ", pop_error, "");
 842       strncpy (Errmsg, error, sizeof (Errmsg));
 843       Errmsg[sizeof (Errmsg)-1] = '\0';
 844       free(error);
 845       return (NOTOK);
 846     }
 847
 848   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 849     {
 850       if (! line)
 851         break;
 852
 853       if (mbx_write (line, ret, arg) != OK)
 854         {
 855           strcpy (Errmsg, strerror (errno));
 856           pop_close (server);
 857           return (NOTOK);
 858         }
 859     }
 860
 861   if (ret)
 862     {
 863       char *error = concat ("Error from POP server: ", pop_error, "");
 864       strncpy (Errmsg, error, sizeof (Errmsg));
 865       Errmsg[sizeof (Errmsg)-1] = '\0';
 866       free(error);
 867       return (NOTOK);
 868     }
 869
 870   return (OK);
 871 }
 872
 873 /* Do this as a macro instead of using strcmp to save on execution time. */
 874 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 875                          && (a[1] == 'r') \
 876                          && (a[2] == 'o') \
 877                          && (a[3] == 'm') \
 878                          && (a[4] == ' '))
 879
 880 int
 881 mbx_write (line, len, mbf)
 882      char *line;
 883      int len;
 884      FILE *mbf;
 885 {
 886 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 887   if (IS_FROM_LINE (line))
 888     {
 889       if (fputc ('>', mbf) == EOF)
 890         return (NOTOK);
 891     }
 892 #endif
 893   if (line[0] == '\037')
 894     {
 895       if (fputs ("^_", mbf) == EOF)
 896         return (NOTOK);
 897       line++;
 898       len--;
 899     }
 900   if (fwrite (line, 1, len, mbf) != len)
 901     return (NOTOK);
 902   if (fputc (0x0a, mbf) == EOF)
 903     return (NOTOK);
 904   return (OK);
 905 }
 906
 907 int
 908 mbx_delimit_begin (mbf)
 909      FILE *mbf;
 910 {
 911   if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
 912     return (NOTOK);
 913   return (OK);
 914 }
 915
 916 mbx_delimit_end (mbf)
 917      FILE *mbf;
 918 {
 919   if (putc ('\037', mbf) == EOF)
 920     return (NOTOK);
 921   return (OK);
 922 }
 923
 924 #endif /* MAIL_USE_POP */
 925 \f
 926 #ifndef HAVE_STRERROR
 927 char *
 928 strerror (errnum)
 929      int errnum;
 930 {
 931   extern char *sys_errlist[];
 932   extern int sys_nerr;
 933
 934   if (errnum >= 0 && errnum < sys_nerr)
 935     return sys_errlist[errnum];
 936   return (char *) "Unknown error";
 937 }
 938
 939 #endif /* ! HAVE_STRERROR */