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