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