lib-src/movemail.c

   1 /* movemail foo bar -- move file foo to file bar,
   2    locking file foo the way /bin/mail respects.
   3
   4 Copyright (C) 1986, 1992-1994, 1996, 1999, 2001-2011
   5   Free Software Foundation, Inc.
   6
   7 This file is part of GNU Emacs.
   8
   9 GNU Emacs is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 GNU Emacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* Important notice: defining MAIL_USE_FLOCK or MAIL_USE_LOCKF *will
  24    cause loss of mail* if you do it on a system that does not normally
  25    use flock as its way of interlocking access to inbox files.  The
  26    setting of MAIL_USE_FLOCK and MAIL_USE_LOCKF *must agree* with the
  27    system's own conventions.  It is not a choice that is up to you.
  28
  29    So, if your system uses lock files rather than flock, then the only way
  30    you can get proper operation is to enable movemail to write lockfiles there.
  31    This means you must either give that directory access modes
  32    that permit everyone to write lockfiles in it, or you must make movemail
  33    a setuid or setgid program.  */
  34
  35 /*
  36  * Modified January, 1986 by Michael R. Gretzinger (Project Athena)
  37  *
  38  * Added POP (Post Office Protocol) service.  When compiled -DMAIL_USE_POP
  39  * movemail will accept input filename arguments of the form
  40  * "po:username".  This will cause movemail to open a connection to
  41  * a pop server running on $MAILHOST (environment variable).  Movemail
  42  * must be setuid to root in order to work with POP.
  43  *
  44  * New module: popmail.c
  45  * Modified routines:
  46  *      main - added code within #ifdef MAIL_USE_POP; added setuid (getuid ())
  47  *              after POP code.
  48  * New routines in movemail.c:
  49  *      get_errmsg - return pointer to system error message
  50  *
  51  * Modified August, 1993 by Jonathan Kamens (OpenVision Technologies)
  52  *
  53  * Move all of the POP code into a separate file, "pop.c".
  54  * Use strerror instead of get_errmsg.
  55  *
  56  */
  57
  58 #include <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 <time.h>
  65
  66 #include <getopt.h>
  67 #include <unistd.h>
  68 #ifdef HAVE_FCNTL_H
  69 #include <fcntl.h>
  70 #endif
  71 #ifdef HAVE_STRING_H
  72 #include <string.h>
  73 #endif
  74 #include "syswait.h"
  75 #ifdef MAIL_USE_POP
  76 #include "pop.h"
  77 #endif
  78
  79 #ifdef MSDOS
  80 #undef access
  81 #endif /* MSDOS */
  82
  83 #ifndef DIRECTORY_SEP
  84 #define DIRECTORY_SEP '/'
  85 #endif
  86 #ifndef IS_DIRECTORY_SEP
  87 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
  88 #endif
  89
  90 #ifdef WINDOWSNT
  91 #include "ntlib.h"
  92 #undef access
  93 #undef unlink
  94 #define fork() 0
  95 #define wait(var) (*(var) = 0)
  96 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
  97    though the locking call succeeds (and indeed blocks local access from
  98    other NT programs).  If you have direct file access using an NFS
  99    client or something other than Samba, the locking call might work
 100    properly - make sure it does before you enable this!
 101
 102    [18-Feb-97 andrewi] I now believe my comment above to be incorrect,
 103    since it was based on a misunderstanding of how locking calls are
 104    implemented and used on Unix.  */
 105 //#define DISABLE_DIRECT_ACCESS
 106
 107 #include <fcntl.h>
 108 #endif /* WINDOWSNT */
 109
 110 #ifndef F_OK
 111 #define F_OK 0
 112 #define X_OK 1
 113 #define W_OK 2
 114 #define R_OK 4
 115 #endif
 116
 117 #ifdef WINDOWSNT
 118 #include <sys/locking.h>
 119 #endif
 120
 121 #ifdef MAIL_USE_LOCKF
 122 #define MAIL_USE_SYSTEM_LOCK
 123 #endif
 124
 125 #ifdef MAIL_USE_FLOCK
 126 #define MAIL_USE_SYSTEM_LOCK
 127 #endif
 128
 129 #ifdef MAIL_USE_MMDF
 130 extern int lk_open (), lk_close ();
 131 #endif
 132
 133 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
 134         (defined (HAVE_LIBMAIL) || defined (HAVE_LIBLOCKFILE)) && \
 135         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 HAVE_STRERROR
 146 char *strerror (int);
 147 #endif
 148
 149 static void fatal (const char *s1, const char *s2, const char *s3) NO_RETURN;
 150 static void error (const char *s1, const char *s2, const char *s3);
 151 static void pfatal_with_name (char *name) NO_RETURN;
 152 static void pfatal_and_delete (char *name) NO_RETURN;
 153 static char *concat (const char *s1, const char *s2, const char *s3);
 154 static long *xmalloc (unsigned int size);
 155 #ifdef MAIL_USE_POP
 156 static int popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order);
 157 static int pop_retr (popserver server, int msgno, FILE *arg);
 158 static int mbx_write (char *line, int len, FILE *mbf);
 159 static int mbx_delimit_begin (FILE *mbf);
 160 static int mbx_delimit_end (FILE *mbf);
 161 #endif
 162
 163 /* Nonzero means this is name of a lock file to delete on fatal error.  */
 164 static char *delete_lockname;
 165
 166 int
 167 main (int argc, char **argv)
 168 {
 169   char *inname, *outname;
 170   int indesc, outdesc;
 171   ssize_t nread;
 172   int status;
 173   int c, preserve_mail = 0;
 174
 175 #ifndef MAIL_USE_SYSTEM_LOCK
 176   struct stat st;
 177   long now;
 178   int tem;
 179   char *lockname, *p;
 180   char *tempname;
 181   int desc;
 182 #endif /* not MAIL_USE_SYSTEM_LOCK */
 183
 184 #ifdef MAIL_USE_MAILLOCK
 185   char *spool_name;
 186 #endif
 187
 188 #ifdef MAIL_USE_POP
 189   int pop_reverse_order = 0;
 190 # define ARGSTR "pr"
 191 #else /* ! MAIL_USE_POP */
 192 # define ARGSTR "p"
 193 #endif /* MAIL_USE_POP */
 194
 195   uid_t real_gid = getgid();
 196   uid_t priv_gid = getegid();
 197
 198 #ifdef WINDOWSNT
 199   /* Ensure all file i/o is in binary mode. */
 200   _fmode = _O_BINARY;
 201 #endif
 202
 203   delete_lockname = 0;
 204
 205   while ((c = getopt (argc, argv, ARGSTR)) != EOF)
 206     {
 207       switch (c) {
 208 #ifdef MAIL_USE_POP
 209       case 'r':
 210         pop_reverse_order = 1;
 211         break;
 212 #endif
 213       case 'p':
 214         preserve_mail++;
 215         break;
 216       default:
 217         exit (EXIT_FAILURE);
 218       }
 219     }
 220
 221   if (
 222 #ifdef MAIL_USE_POP
 223       (argc - optind < 2) || (argc - optind > 3)
 224 #else
 225       (argc - optind != 2)
 226 #endif
 227       )
 228     {
 229 #ifdef MAIL_USE_POP
 230       fprintf (stderr, "Usage: movemail [-p] [-r] inbox destfile%s\n",
 231                " [POP-password]");
 232 #else
 233       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
 234 #endif
 235       exit (EXIT_FAILURE);
 236     }
 237
 238   inname = argv[optind];
 239   outname = argv[optind+1];
 240
 241 #ifdef MAIL_USE_MMDF
 242   mmdf_init (argv[0]);
 243 #endif
 244
 245   if (*outname == 0)
 246     fatal ("Destination file name is empty", 0, 0);
 247
 248 #ifdef MAIL_USE_POP
 249   if (!strncmp (inname, "po:", 3))
 250     {
 251       int status;
 252
 253       status = popmail (inname + 3, outname, preserve_mail,
 254                         (argc - optind == 3) ? argv[optind+2] : NULL,
 255                         pop_reverse_order);
 256       exit (status);
 257     }
 258
 259   if (setuid (getuid ()) < 0)
 260     fatal ("Failed to drop privileges", 0, 0);
 261
 262 #endif /* MAIL_USE_POP */
 263
 264 #ifndef DISABLE_DIRECT_ACCESS
 265 #ifndef MAIL_USE_MMDF
 266 #ifndef MAIL_USE_SYSTEM_LOCK
 267 #ifdef MAIL_USE_MAILLOCK
 268   spool_name = mail_spool_name (inname);
 269   if (! spool_name)
 270 #endif
 271     {
 272       /* Use a lock file named after our first argument with .lock appended:
 273          If it exists, the mail file is locked.  */
 274       /* Note: this locking mechanism is *required* by the mailer
 275          (on systems which use it) to prevent loss of mail.
 276
 277          On systems that use a lock file, extracting the mail without locking
 278          WILL occasionally cause loss of mail due to timing errors!
 279
 280          So, if creation of the lock file fails
 281          due to access permission on the mail spool directory,
 282          you simply MUST change the permission
 283          and/or make movemail a setgid program
 284          so it can create lock files properly.
 285
 286          You might also wish to verify that your system is one
 287          which uses lock files for this purpose.  Some systems use other methods.
 288
 289          If your system uses the `flock' system call for mail locking,
 290          define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
 291          and recompile movemail.  If the s- file for your system
 292          should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
 293          to bug-gnu-emacs@prep.ai.mit.edu so we can fix it.  */
 294
 295       lockname = concat (inname, ".lock", "");
 296       tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
 297       strcpy (tempname, inname);
 298       p = tempname + strlen (tempname);
 299       while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
 300         p--;
 301       *p = 0;
 302       strcpy (p, "EXXXXXX");
 303       mktemp (tempname);
 304       unlink (tempname);
 305
 306       while (1)
 307         {
 308           /* Create the lock file, but not under the lock file name.  */
 309           /* Give up if cannot do that.  */
 310           desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 311           if (desc < 0)
 312             {
 313               char *message = (char *) xmalloc (strlen (tempname) + 50);
 314               sprintf (message, "creating %s, which would become the lock file",
 315                        tempname);
 316               pfatal_with_name (message);
 317             }
 318           close (desc);
 319
 320           tem = link (tempname, lockname);
 321
 322 #ifdef EPERM
 323           if (tem < 0 && errno == EPERM)
 324             fatal ("Unable to create hard link between %s and %s",
 325                    tempname, lockname);
 326 #endif
 327
 328           unlink (tempname);
 329           if (tem >= 0)
 330             break;
 331           sleep (1);
 332
 333           /* If lock file is five minutes old, unlock it.
 334              Five minutes should be good enough to cope with crashes
 335              and wedgitude, and long enough to avoid being fooled
 336              by time differences between machines.  */
 337           if (stat (lockname, &st) >= 0)
 338             {
 339               now = time (0);
 340               if (st.st_ctime < now - 300)
 341                 unlink (lockname);
 342             }
 343         }
 344
 345       delete_lockname = lockname;
 346     }
 347 #endif /* not MAIL_USE_SYSTEM_LOCK */
 348 #endif /* not MAIL_USE_MMDF */
 349
 350   if (fork () == 0)
 351     {
 352       int lockcount = 0;
 353       int status = 0;
 354 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 355       time_t touched_lock, now;
 356 #endif
 357
 358       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 359         fatal ("Failed to drop privileges", 0, 0);
 360
 361 #ifndef MAIL_USE_MMDF
 362 #ifdef MAIL_USE_SYSTEM_LOCK
 363       indesc = open (inname, O_RDWR);
 364 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 365       indesc = open (inname, O_RDONLY);
 366 #endif /* not MAIL_USE_SYSTEM_LOCK */
 367 #else  /* MAIL_USE_MMDF */
 368       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 369 #endif /* MAIL_USE_MMDF */
 370
 371       if (indesc < 0)
 372         pfatal_with_name (inname);
 373
 374 #ifdef BSD_SYSTEM
 375       /* In case movemail is setuid to root, make sure the user can
 376          read the output file.  */
 377       /* This is desirable for all systems
 378          but I don't want to assume all have the umask system call */
 379       umask (umask (0) & 0333);
 380 #endif /* BSD_SYSTEM */
 381       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 382       if (outdesc < 0)
 383         pfatal_with_name (outname);
 384
 385       if (setregid (-1, priv_gid) < 0)
 386         fatal ("Failed to regain privileges", 0, 0);
 387
 388       /* This label exists so we can retry locking
 389          after a delay, if it got EAGAIN or EBUSY.  */
 390     retry_lock:
 391
 392       /* Try to lock it.  */
 393 #ifdef MAIL_USE_MAILLOCK
 394       if (spool_name)
 395         {
 396           /* The "0 - " is to make it a negative number if maillock returns
 397              non-zero. */
 398           status = 0 - maillock (spool_name, 1);
 399 #ifdef HAVE_TOUCHLOCK
 400           touched_lock = time (0);
 401 #endif
 402           lockcount = 5;
 403         }
 404       else
 405 #endif /* MAIL_USE_MAILLOCK */
 406         {
 407 #ifdef MAIL_USE_SYSTEM_LOCK
 408 #ifdef MAIL_USE_LOCKF
 409           status = lockf (indesc, F_LOCK, 0);
 410 #else /* not MAIL_USE_LOCKF */
 411 #ifdef WINDOWSNT
 412           status = locking (indesc, LK_RLCK, -1L);
 413 #else
 414           status = flock (indesc, LOCK_EX);
 415 #endif
 416 #endif /* not MAIL_USE_LOCKF */
 417 #endif /* MAIL_USE_SYSTEM_LOCK */
 418         }
 419
 420       /* If it fails, retry up to 5 times
 421          for certain failure codes.  */
 422       if (status < 0)
 423         {
 424           if (++lockcount <= 5)
 425             {
 426 #ifdef EAGAIN
 427               if (errno == EAGAIN)
 428                 {
 429                   sleep (1);
 430                   goto retry_lock;
 431                 }
 432 #endif
 433 #ifdef EBUSY
 434               if (errno == EBUSY)
 435                 {
 436                   sleep (1);
 437                   goto retry_lock;
 438                 }
 439 #endif
 440             }
 441
 442           pfatal_with_name (inname);
 443         }
 444
 445       {
 446         char buf[1024];
 447
 448         while (1)
 449           {
 450             nread = read (indesc, buf, sizeof buf);
 451             if (nread < 0)
 452               pfatal_with_name (inname);
 453             if (nread != write (outdesc, buf, nread))
 454               {
 455                 int saved_errno = errno;
 456                 unlink (outname);
 457                 errno = saved_errno;
 458                 pfatal_with_name (outname);
 459               }
 460             if (nread < sizeof buf)
 461               break;
 462 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 463             if (spool_name)
 464               {
 465                 now = time (0);
 466                 if (now - touched_lock > 60)
 467                   {
 468                     touchlock ();
 469                     touched_lock = now;
 470                   }
 471               }
 472 #endif /* MAIL_USE_MAILLOCK */
 473           }
 474       }
 475
 476 #ifdef BSD_SYSTEM
 477       if (fsync (outdesc) < 0)
 478         pfatal_and_delete (outname);
 479 #endif
 480
 481       /* Prevent symlink attacks truncating other users' mailboxes */
 482       if (setregid (-1, real_gid) < 0)
 483         fatal ("Failed to drop privileges", 0, 0);
 484
 485       /* Check to make sure no errors before we zap the inbox.  */
 486       if (close (outdesc) != 0)
 487         pfatal_and_delete (outname);
 488
 489 #ifdef MAIL_USE_SYSTEM_LOCK
 490       if (! preserve_mail)
 491         {
 492           if (ftruncate (indesc, 0L) != 0)
 493             pfatal_with_name (inname);
 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 (setregid (-1, 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 static char *progname;
 676 static FILE *sfi;
 677 static FILE *sfo;
 678 static char ibuffer[BUFSIZ];
 679 static char obuffer[BUFSIZ];
 680 static 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
 937 /* movemail.c ends here */