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