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
 687 #define NOTOK (-1)
 688 #define OK 0
 689 #define DONE 1
 690
 691 char *progname;
 692 FILE *sfi;
 693 FILE *sfo;
 694 char ibuffer[BUFSIZ];
 695 char obuffer[BUFSIZ];
 696 char Errmsg[200];               /* POP errors, at least, can exceed
 697                                    the original length of 80.  */
 698
 699 /*
 700  * The full valid syntax for a POP mailbox specification for movemail
 701  * is "po:username:hostname".  The ":hostname" is optional; if it is
 702  * omitted, the MAILHOST environment variable will be consulted.  Note
 703  * that by the time popmail() is called the "po:" has been stripped
 704  * off of the front of the mailbox name.
 705  *
 706  * If the mailbox is in the form "po:username:hostname", then it is
 707  * modified by this function -- the second colon is replaced by a
 708  * null.
 709  *
 710  * Return a value suitable for passing to `exit'.
 711  */
 712
 713 int
 714 popmail (mailbox, outfile, preserve, password, reverse_order)
 715      char *mailbox;
 716      char *outfile;
 717      int preserve;
 718      char *password;
 719      int reverse_order;
 720 {
 721   int nmsgs, nbytes;
 722   register int i;
 723   int mbfi;
 724   FILE *mbf;
 725   char *getenv ();
 726   popserver server;
 727   int start, end, increment;
 728   char *user, *hostname;
 729
 730   user = mailbox;
 731   if ((hostname = index(mailbox, ':')))
 732     *hostname++ = '\0';
 733
 734   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 735   if (! server)
 736     {
 737       error ("Error connecting to POP server: %s", pop_error, 0);
 738       return EXIT_FAILURE;
 739     }
 740
 741   if (pop_stat (server, &nmsgs, &nbytes))
 742     {
 743       error ("Error getting message count from POP server: %s", pop_error, 0);
 744       return EXIT_FAILURE;
 745     }
 746
 747   if (!nmsgs)
 748     {
 749       pop_close (server);
 750       return EXIT_SUCCESS;
 751     }
 752
 753   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 754   if (mbfi < 0)
 755     {
 756       pop_close (server);
 757       error ("Error in open: %s, %s", strerror (errno), outfile);
 758       return EXIT_FAILURE;
 759     }
 760   fchown (mbfi, getuid (), -1);
 761
 762   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 763     {
 764       pop_close (server);
 765       error ("Error in fdopen: %s", strerror (errno), 0);
 766       close (mbfi);
 767       unlink (outfile);
 768       return EXIT_FAILURE;
 769     }
 770
 771   if (reverse_order)
 772     {
 773       start = nmsgs;
 774       end = 1;
 775       increment = -1;
 776     }
 777   else
 778     {
 779       start = 1;
 780       end = nmsgs;
 781       increment = 1;
 782     }
 783
 784   for (i = start; i * increment <= end * increment; i += increment)
 785     {
 786       mbx_delimit_begin (mbf);
 787       if (pop_retr (server, i, mbf) != OK)
 788         {
 789           error ("%s", Errmsg, 0);
 790           close (mbfi);
 791           return EXIT_FAILURE;
 792         }
 793       mbx_delimit_end (mbf);
 794       fflush (mbf);
 795       if (ferror (mbf))
 796         {
 797           error ("Error in fflush: %s", strerror (errno), 0);
 798           pop_close (server);
 799           close (mbfi);
 800           return EXIT_FAILURE;
 801         }
 802     }
 803
 804   /* On AFS, a call to write only modifies the file in the local
 805    *     workstation's AFS cache.  The changes are not written to the server
 806    *      until a call to fsync or close is made.  Users with AFS home
 807    *      directories have lost mail when over quota because these checks were
 808    *      not made in previous versions of movemail. */
 809
 810 #ifdef BSD_SYSTEM
 811   if (fsync (mbfi) < 0)
 812     {
 813       error ("Error in fsync: %s", strerror (errno), 0);
 814       return EXIT_FAILURE;
 815     }
 816 #endif
 817
 818   if (close (mbfi) == -1)
 819     {
 820       error ("Error in close: %s", strerror (errno), 0);
 821       return EXIT_FAILURE;
 822     }
 823
 824   if (! preserve)
 825     for (i = 1; i <= nmsgs; i++)
 826       {
 827         if (pop_delete (server, i))
 828           {
 829             error ("Error from POP server: %s", pop_error, 0);
 830             pop_close (server);
 831             return EXIT_FAILURE;
 832           }
 833       }
 834
 835   if (pop_quit (server))
 836     {
 837       error ("Error from POP server: %s", pop_error, 0);
 838       return EXIT_FAILURE;
 839     }
 840
 841   return EXIT_SUCCESS;
 842 }
 843
 844 int
 845 pop_retr (server, msgno, arg)
 846      popserver server;
 847      int msgno;
 848      FILE *arg;
 849 {
 850   extern char *strerror ();
 851   char *line;
 852   int ret;
 853
 854   if (pop_retrieve_first (server, msgno, &line))
 855     {
 856       char *error = concat ("Error from POP server: ", pop_error, "");
 857       strncpy (Errmsg, error, sizeof (Errmsg));
 858       Errmsg[sizeof (Errmsg)-1] = '\0';
 859       free(error);
 860       return (NOTOK);
 861     }
 862
 863   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 864     {
 865       if (! line)
 866         break;
 867
 868       if (mbx_write (line, ret, arg) != OK)
 869         {
 870           strcpy (Errmsg, strerror (errno));
 871           pop_close (server);
 872           return (NOTOK);
 873         }
 874     }
 875
 876   if (ret)
 877     {
 878       char *error = concat ("Error from POP server: ", pop_error, "");
 879       strncpy (Errmsg, error, sizeof (Errmsg));
 880       Errmsg[sizeof (Errmsg)-1] = '\0';
 881       free(error);
 882       return (NOTOK);
 883     }
 884
 885   return (OK);
 886 }
 887
 888 /* Do this as a macro instead of using strcmp to save on execution time. */
 889 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 890                          && (a[1] == 'r') \
 891                          && (a[2] == 'o') \
 892                          && (a[3] == 'm') \
 893                          && (a[4] == ' '))
 894
 895 int
 896 mbx_write (line, len, mbf)
 897      char *line;
 898      int len;
 899      FILE *mbf;
 900 {
 901 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 902   if (IS_FROM_LINE (line))
 903     {
 904       if (fputc ('>', mbf) == EOF)
 905         return (NOTOK);
 906     }
 907 #endif
 908   if (line[0] == '\037')
 909     {
 910       if (fputs ("^_", mbf) == EOF)
 911         return (NOTOK);
 912       line++;
 913       len--;
 914     }
 915   if (fwrite (line, 1, len, mbf) != len)
 916     return (NOTOK);
 917   if (fputc (0x0a, mbf) == EOF)
 918     return (NOTOK);
 919   return (OK);
 920 }
 921
 922 int
 923 mbx_delimit_begin (mbf)
 924      FILE *mbf;
 925 {
 926   if (fputs ("From movemail\n", mbf) == EOF)
 927     return (NOTOK);
 928   return (OK);
 929 }
 930
 931 int
 932 mbx_delimit_end (mbf)
 933      FILE *mbf;
 934 {
 935   if (putc ('\n', mbf) == EOF)
 936     return (NOTOK);
 937   return (OK);
 938 }
 939
 940 #endif /* MAIL_USE_POP */
 941 \f
 942 #ifndef HAVE_STRERROR
 943 char *
 944 strerror (errnum)
 945      int errnum;
 946 {
 947   extern char *sys_errlist[];
 948   extern int sys_nerr;
 949
 950   if (errnum >= 0 && errnum < sys_nerr)
 951     return sys_errlist[errnum];
 952   return (char *) "Unknown error";
 953 }
 954
 955 #endif /* ! HAVE_STRERROR */
 956
 957 /* arch-tag: 1c323112-41fe-4fe5-8de9-494de631f73f
 958    (do not change this comment) */
 959
 960 /* movemail.c ends here */