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 #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 #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   int 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] [-r] 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
 346 #ifdef EPERM
 347           if (tem < 0 && errno == EPERM)
 348             fatal ("Unable to create hard link between %s and %s",
 349                    tempname, lockname);
 350 #endif
 351
 352           unlink (tempname);
 353           if (tem >= 0)
 354             break;
 355           sleep (1);
 356
 357           /* If lock file is five minutes old, unlock it.
 358              Five minutes should be good enough to cope with crashes
 359              and wedgitude, and long enough to avoid being fooled
 360              by time differences between machines.  */
 361           if (stat (lockname, &st) >= 0)
 362             {
 363               now = time (0);
 364               if (st.st_ctime < now - 300)
 365                 unlink (lockname);
 366             }
 367         }
 368
 369       delete_lockname = lockname;
 370     }
 371 #endif /* not MAIL_USE_SYSTEM_LOCK */
 372 #endif /* not MAIL_USE_MMDF */
 373
 374   if (fork () == 0)
 375     {
 376       int lockcount = 0;
 377       int status = 0;
 378 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 379       time_t touched_lock, now;
 380 #endif
 381
 382       setuid (getuid ());
 383
 384 #ifndef MAIL_USE_MMDF
 385 #ifdef MAIL_USE_SYSTEM_LOCK
 386       indesc = open (inname, O_RDWR);
 387 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 388       indesc = open (inname, O_RDONLY);
 389 #endif /* not MAIL_USE_SYSTEM_LOCK */
 390 #else  /* MAIL_USE_MMDF */
 391       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 392 #endif /* MAIL_USE_MMDF */
 393
 394       if (indesc < 0)
 395         pfatal_with_name (inname);
 396
 397 #ifdef BSD_SYSTEM
 398       /* In case movemail is setuid to root, make sure the user can
 399          read the output file.  */
 400       /* This is desirable for all systems
 401          but I don't want to assume all have the umask system call */
 402       umask (umask (0) & 0333);
 403 #endif /* BSD_SYSTEM */
 404       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 405       if (outdesc < 0)
 406         pfatal_with_name (outname);
 407
 408       /* This label exists so we can retry locking
 409          after a delay, if it got EAGAIN or EBUSY.  */
 410     retry_lock:
 411
 412       /* Try to lock it.  */
 413 #ifdef MAIL_USE_MAILLOCK
 414       if (spool_name)
 415         {
 416           /* The "0 - " is to make it a negative number if maillock returns
 417              non-zero. */
 418           status = 0 - maillock (spool_name, 1);
 419 #ifdef HAVE_TOUCHLOCK
 420           touched_lock = time (0);
 421 #endif
 422           lockcount = 5;
 423         }
 424       else
 425 #endif /* MAIL_USE_MAILLOCK */
 426         {
 427 #ifdef MAIL_USE_SYSTEM_LOCK
 428 #ifdef MAIL_USE_LOCKF
 429           status = lockf (indesc, F_LOCK, 0);
 430 #else /* not MAIL_USE_LOCKF */
 431 #ifdef WINDOWSNT
 432           status = locking (indesc, LK_RLCK, -1L);
 433 #else
 434           status = flock (indesc, LOCK_EX);
 435 #endif
 436 #endif /* not MAIL_USE_LOCKF */
 437 #endif /* MAIL_USE_SYSTEM_LOCK */
 438         }
 439
 440       /* If it fails, retry up to 5 times
 441          for certain failure codes.  */
 442       if (status < 0)
 443         {
 444           if (++lockcount <= 5)
 445             {
 446 #ifdef EAGAIN
 447               if (errno == EAGAIN)
 448                 {
 449                   sleep (1);
 450                   goto retry_lock;
 451                 }
 452 #endif
 453 #ifdef EBUSY
 454               if (errno == EBUSY)
 455                 {
 456                   sleep (1);
 457                   goto retry_lock;
 458                 }
 459 #endif
 460             }
 461
 462           pfatal_with_name (inname);
 463         }
 464
 465       {
 466         char buf[1024];
 467
 468         while (1)
 469           {
 470             nread = read (indesc, buf, sizeof buf);
 471             if (nread < 0)
 472               pfatal_with_name (inname);
 473             if (nread != write (outdesc, buf, nread))
 474               {
 475                 int saved_errno = errno;
 476                 unlink (outname);
 477                 errno = saved_errno;
 478                 pfatal_with_name (outname);
 479               }
 480             if (nread < sizeof buf)
 481               break;
 482 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 483             if (spool_name)
 484               {
 485                 now = time (0);
 486                 if (now - touched_lock > 60)
 487                   {
 488                     touchlock ();
 489                     touched_lock = now;
 490                   }
 491               }
 492 #endif /* MAIL_USE_MAILLOCK */
 493           }
 494       }
 495
 496 #ifdef BSD_SYSTEM
 497       if (fsync (outdesc) < 0)
 498         pfatal_and_delete (outname);
 499 #endif
 500
 501       /* Check to make sure no errors before we zap the inbox.  */
 502       if (close (outdesc) != 0)
 503         pfatal_and_delete (outname);
 504
 505 #ifdef MAIL_USE_SYSTEM_LOCK
 506       if (! preserve_mail)
 507         {
 508           ftruncate (indesc, 0L);
 509         }
 510 #endif /* MAIL_USE_SYSTEM_LOCK */
 511
 512 #ifdef MAIL_USE_MMDF
 513       lk_close (indesc, 0, 0, 0);
 514 #else
 515       close (indesc);
 516 #endif
 517
 518 #ifndef MAIL_USE_SYSTEM_LOCK
 519       if (! preserve_mail)
 520         {
 521           /* Delete the input file; if we can't, at least get rid of its
 522              contents.  */
 523 #ifdef MAIL_UNLINK_SPOOL
 524           /* This is generally bad to do, because it destroys the permissions
 525              that were set on the file.  Better to just empty the file.  */
 526           if (unlink (inname) < 0 && errno != ENOENT)
 527 #endif /* MAIL_UNLINK_SPOOL */
 528             creat (inname, 0600);
 529         }
 530 #endif /* not MAIL_USE_SYSTEM_LOCK */
 531
 532 #ifdef MAIL_USE_MAILLOCK
 533       /* This has to occur in the child, i.e., in the process that
 534          acquired the lock! */
 535       if (spool_name)
 536         mailunlock ();
 537 #endif
 538       exit (EXIT_SUCCESS);
 539     }
 540
 541   wait (&status);
 542   if (!WIFEXITED (status))
 543     exit (EXIT_FAILURE);
 544   else if (WRETCODE (status) != 0)
 545     exit (WRETCODE (status));
 546
 547 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 548 #ifdef MAIL_USE_MAILLOCK
 549   if (! spool_name)
 550 #endif /* MAIL_USE_MAILLOCK */
 551     unlink (lockname);
 552 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 553
 554 #endif /* ! DISABLE_DIRECT_ACCESS */
 555
 556   return EXIT_SUCCESS;
 557 }
 558
 559 #ifdef MAIL_USE_MAILLOCK
 560 /* This function uses stat to confirm that the mail directory is
 561    identical to the directory of the input file, rather than just
 562    string-comparing the two paths, because one or both of them might
 563    be symbolic links pointing to some other directory. */
 564 static char *
 565 mail_spool_name (inname)
 566      char *inname;
 567 {
 568   struct stat stat1, stat2;
 569   char *indir, *fname;
 570   int status;
 571
 572   if (! (fname = rindex (inname, '/')))
 573     return NULL;
 574
 575   fname++;
 576
 577   if (stat (MAILDIR, &stat1) < 0)
 578     return NULL;
 579
 580   indir = (char *) xmalloc (fname - inname + 1);
 581   strncpy (indir, inname, fname - inname);
 582   indir[fname-inname] = '\0';
 583
 584
 585   status = stat (indir, &stat2);
 586
 587   free (indir);
 588
 589   if (status < 0)
 590     return NULL;
 591
 592   if (stat1.st_dev == stat2.st_dev
 593       && stat1.st_ino == stat2.st_ino)
 594     return fname;
 595
 596   return NULL;
 597 }
 598 #endif /* MAIL_USE_MAILLOCK */
 599 \f
 600 /* Print error message and exit.  */
 601
 602 void
 603 fatal (s1, s2, s3)
 604      char *s1, *s2, *s3;
 605 {
 606   if (delete_lockname)
 607     unlink (delete_lockname);
 608   error (s1, s2, s3);
 609   exit (EXIT_FAILURE);
 610 }
 611
 612 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 613    are args for it or null. */
 614
 615 void
 616 error (s1, s2, s3)
 617      char *s1, *s2, *s3;
 618 {
 619   fprintf (stderr, "movemail: ");
 620   if (s3)
 621     fprintf (stderr, s1, s2, s3);
 622   else if (s2)
 623     fprintf (stderr, s1, s2);
 624   else
 625     fprintf (stderr, s1);
 626   fprintf (stderr, "\n");
 627 }
 628
 629 void
 630 pfatal_with_name (name)
 631      char *name;
 632 {
 633   fatal ("%s for %s", strerror (errno), name);
 634 }
 635
 636 void
 637 pfatal_and_delete (name)
 638      char *name;
 639 {
 640   char *s = strerror (errno);
 641   unlink (name);
 642   fatal ("%s for %s", s, name);
 643 }
 644
 645 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 646
 647 char *
 648 concat (s1, s2, s3)
 649      char *s1, *s2, *s3;
 650 {
 651   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 652   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 653
 654   strcpy (result, s1);
 655   strcpy (result + len1, s2);
 656   strcpy (result + len1 + len2, s3);
 657   *(result + len1 + len2 + len3) = 0;
 658
 659   return result;
 660 }
 661
 662 /* Like malloc but get fatal error if memory is exhausted.  */
 663
 664 long *
 665 xmalloc (size)
 666      unsigned size;
 667 {
 668   long *result = (long *) malloc (size);
 669   if (!result)
 670     fatal ("virtual memory exhausted", 0, 0);
 671   return result;
 672 }
 673 \f
 674 /* This is the guts of the interface to the Post Office Protocol.  */
 675
 676 #ifdef MAIL_USE_POP
 677
 678 #ifndef WINDOWSNT
 679 #include <sys/socket.h>
 680 #include <netinet/in.h>
 681 #include <netdb.h>
 682 #else
 683 #undef _WINSOCKAPI_
 684 #include <winsock.h>
 685 #endif
 686 #include <pwd.h>
 687 #include <string.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 */