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 (char *s1, char *s2, char *s3) NO_RETURN;
 151 static void error (char *s1, char *s2, 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 (char *s1, char *s2, 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   int 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 (inname)
 555      char *inname;
 556 {
 557   struct stat stat1, stat2;
 558   char *indir, *fname;
 559   int status;
 560
 561   if (! (fname = strrchr (inname, '/')))
 562     return NULL;
 563
 564   fname++;
 565
 566   if (stat (MAILDIR, &stat1) < 0)
 567     return NULL;
 568
 569   indir = (char *) xmalloc (fname - inname + 1);
 570   strncpy (indir, inname, fname - inname);
 571   indir[fname-inname] = '\0';
 572
 573
 574   status = stat (indir, &stat2);
 575
 576   free (indir);
 577
 578   if (status < 0)
 579     return NULL;
 580
 581   if (stat1.st_dev == stat2.st_dev
 582       && stat1.st_ino == stat2.st_ino)
 583     return fname;
 584
 585   return NULL;
 586 }
 587 #endif /* MAIL_USE_MAILLOCK */
 588 \f
 589 /* Print error message and exit.  */
 590
 591 static void
 592 fatal (char *s1, char *s2, char *s3)
 593 {
 594   if (delete_lockname)
 595     unlink (delete_lockname);
 596   error (s1, s2, s3);
 597   exit (EXIT_FAILURE);
 598 }
 599
 600 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 601    are args for it or null. */
 602
 603 static void
 604 error (char *s1, char *s2, char *s3)
 605 {
 606   fprintf (stderr, "movemail: ");
 607   if (s3)
 608     fprintf (stderr, s1, s2, s3);
 609   else if (s2)
 610     fprintf (stderr, s1, s2);
 611   else
 612     fprintf (stderr, "%s", s1);
 613   fprintf (stderr, "\n");
 614 }
 615
 616 static void
 617 pfatal_with_name (char *name)
 618 {
 619   fatal ("%s for %s", strerror (errno), name);
 620 }
 621
 622 static void
 623 pfatal_and_delete (char *name)
 624 {
 625   char *s = strerror (errno);
 626   unlink (name);
 627   fatal ("%s for %s", s, name);
 628 }
 629
 630 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 631
 632 static char *
 633 concat (char *s1, char *s2, char *s3)
 634 {
 635   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 636   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 637
 638   strcpy (result, s1);
 639   strcpy (result + len1, s2);
 640   strcpy (result + len1 + len2, s3);
 641   *(result + len1 + len2 + len3) = 0;
 642
 643   return result;
 644 }
 645
 646 /* Like malloc but get fatal error if memory is exhausted.  */
 647
 648 static long *
 649 xmalloc (unsigned int size)
 650 {
 651   long *result = (long *) malloc (size);
 652   if (!result)
 653     fatal ("virtual memory exhausted", 0, 0);
 654   return result;
 655 }
 656 \f
 657 /* This is the guts of the interface to the Post Office Protocol.  */
 658
 659 #ifdef MAIL_USE_POP
 660
 661 #ifndef WINDOWSNT
 662 #include <sys/socket.h>
 663 #include <netinet/in.h>
 664 #include <netdb.h>
 665 #else
 666 #undef _WINSOCKAPI_
 667 #include <winsock.h>
 668 #endif
 669 #include <pwd.h>
 670 #include <string.h>
 671
 672 #define NOTOK (-1)
 673 #define OK 0
 674 #define DONE 1
 675
 676 char *progname;
 677 FILE *sfi;
 678 FILE *sfo;
 679 char ibuffer[BUFSIZ];
 680 char obuffer[BUFSIZ];
 681 char Errmsg[200];               /* POP errors, at least, can exceed
 682                                    the original length of 80.  */
 683
 684 /*
 685  * The full valid syntax for a POP mailbox specification for movemail
 686  * is "po:username:hostname".  The ":hostname" is optional; if it is
 687  * omitted, the MAILHOST environment variable will be consulted.  Note
 688  * that by the time popmail() is called the "po:" has been stripped
 689  * off of the front of the mailbox name.
 690  *
 691  * If the mailbox is in the form "po:username:hostname", then it is
 692  * modified by this function -- the second colon is replaced by a
 693  * null.
 694  *
 695  * Return a value suitable for passing to `exit'.
 696  */
 697
 698 static int
 699 popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order)
 700 {
 701   int nmsgs, nbytes;
 702   register int i;
 703   int mbfi;
 704   FILE *mbf;
 705   char *getenv (const char *);
 706   popserver server;
 707   int start, end, increment;
 708   char *user, *hostname;
 709
 710   user = mailbox;
 711   if ((hostname = strchr (mailbox, ':')))
 712     *hostname++ = '\0';
 713
 714   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 715   if (! server)
 716     {
 717       error ("Error connecting to POP server: %s", pop_error, 0);
 718       return EXIT_FAILURE;
 719     }
 720
 721   if (pop_stat (server, &nmsgs, &nbytes))
 722     {
 723       error ("Error getting message count from POP server: %s", pop_error, 0);
 724       return EXIT_FAILURE;
 725     }
 726
 727   if (!nmsgs)
 728     {
 729       pop_close (server);
 730       return EXIT_SUCCESS;
 731     }
 732
 733   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 734   if (mbfi < 0)
 735     {
 736       pop_close (server);
 737       error ("Error in open: %s, %s", strerror (errno), outfile);
 738       return EXIT_FAILURE;
 739     }
 740   fchown (mbfi, getuid (), -1);
 741
 742   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 743     {
 744       pop_close (server);
 745       error ("Error in fdopen: %s", strerror (errno), 0);
 746       close (mbfi);
 747       unlink (outfile);
 748       return EXIT_FAILURE;
 749     }
 750
 751   if (reverse_order)
 752     {
 753       start = nmsgs;
 754       end = 1;
 755       increment = -1;
 756     }
 757   else
 758     {
 759       start = 1;
 760       end = nmsgs;
 761       increment = 1;
 762     }
 763
 764   for (i = start; i * increment <= end * increment; i += increment)
 765     {
 766       mbx_delimit_begin (mbf);
 767       if (pop_retr (server, i, mbf) != OK)
 768         {
 769           error ("%s", Errmsg, 0);
 770           close (mbfi);
 771           return EXIT_FAILURE;
 772         }
 773       mbx_delimit_end (mbf);
 774       fflush (mbf);
 775       if (ferror (mbf))
 776         {
 777           error ("Error in fflush: %s", strerror (errno), 0);
 778           pop_close (server);
 779           close (mbfi);
 780           return EXIT_FAILURE;
 781         }
 782     }
 783
 784   /* On AFS, a call to write only modifies the file in the local
 785    *     workstation's AFS cache.  The changes are not written to the server
 786    *      until a call to fsync or close is made.  Users with AFS home
 787    *      directories have lost mail when over quota because these checks were
 788    *      not made in previous versions of movemail. */
 789
 790 #ifdef BSD_SYSTEM
 791   if (fsync (mbfi) < 0)
 792     {
 793       error ("Error in fsync: %s", strerror (errno), 0);
 794       return EXIT_FAILURE;
 795     }
 796 #endif
 797
 798   if (close (mbfi) == -1)
 799     {
 800       error ("Error in close: %s", strerror (errno), 0);
 801       return EXIT_FAILURE;
 802     }
 803
 804   if (! preserve)
 805     for (i = 1; i <= nmsgs; i++)
 806       {
 807         if (pop_delete (server, i))
 808           {
 809             error ("Error from POP server: %s", pop_error, 0);
 810             pop_close (server);
 811             return EXIT_FAILURE;
 812           }
 813       }
 814
 815   if (pop_quit (server))
 816     {
 817       error ("Error from POP server: %s", pop_error, 0);
 818       return EXIT_FAILURE;
 819     }
 820
 821   return EXIT_SUCCESS;
 822 }
 823
 824 static int
 825 pop_retr (popserver server, int msgno, FILE *arg)
 826 {
 827   char *line;
 828   int ret;
 829
 830   if (pop_retrieve_first (server, msgno, &line))
 831     {
 832       char *error = concat ("Error from POP server: ", pop_error, "");
 833       strncpy (Errmsg, error, sizeof (Errmsg));
 834       Errmsg[sizeof (Errmsg)-1] = '\0';
 835       free(error);
 836       return (NOTOK);
 837     }
 838
 839   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 840     {
 841       if (! line)
 842         break;
 843
 844       if (mbx_write (line, ret, arg) != OK)
 845         {
 846           strcpy (Errmsg, strerror (errno));
 847           pop_close (server);
 848           return (NOTOK);
 849         }
 850     }
 851
 852   if (ret)
 853     {
 854       char *error = concat ("Error from POP server: ", pop_error, "");
 855       strncpy (Errmsg, error, sizeof (Errmsg));
 856       Errmsg[sizeof (Errmsg)-1] = '\0';
 857       free(error);
 858       return (NOTOK);
 859     }
 860
 861   return (OK);
 862 }
 863
 864 /* Do this as a macro instead of using strcmp to save on execution time. */
 865 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 866                          && (a[1] == 'r') \
 867                          && (a[2] == 'o') \
 868                          && (a[3] == 'm') \
 869                          && (a[4] == ' '))
 870
 871 static int
 872 mbx_write (char *line, int len, FILE *mbf)
 873 {
 874 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 875   if (IS_FROM_LINE (line))
 876     {
 877       if (fputc ('>', mbf) == EOF)
 878         return (NOTOK);
 879     }
 880 #endif
 881   if (line[0] == '\037')
 882     {
 883       if (fputs ("^_", mbf) == EOF)
 884         return (NOTOK);
 885       line++;
 886       len--;
 887     }
 888   if (fwrite (line, 1, len, mbf) != len)
 889     return (NOTOK);
 890   if (fputc (0x0a, mbf) == EOF)
 891     return (NOTOK);
 892   return (OK);
 893 }
 894
 895 static int
 896 mbx_delimit_begin (FILE *mbf)
 897 {
 898   time_t now;
 899   struct tm *ltime;
 900   char fromline[40] = "From movemail ";
 901
 902   now = time (NULL);
 903   ltime = localtime (&now);
 904
 905   strcat (fromline, asctime (ltime));
 906
 907   if (fputs (fromline, mbf) == EOF)
 908     return (NOTOK);
 909   return (OK);
 910 }
 911
 912 static int
 913 mbx_delimit_end (FILE *mbf)
 914 {
 915   if (putc ('\n', mbf) == EOF)
 916     return (NOTOK);
 917   return (OK);
 918 }
 919
 920 #endif /* MAIL_USE_POP */
 921 \f
 922 #ifndef HAVE_STRERROR
 923 char *
 924 strerror (errnum)
 925      int errnum;
 926 {
 927   extern char *sys_errlist[];
 928   extern int sys_nerr;
 929
 930   if (errnum >= 0 && errnum < sys_nerr)
 931     return sys_errlist[errnum];
 932   return (char *) "Unknown error";
 933 }
 934
 935 #endif /* ! HAVE_STRERROR */
 936
 937 /* arch-tag: 1c323112-41fe-4fe5-8de9-494de631f73f
 938    (do not change this comment) */
 939
 940 /* movemail.c ends here */