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, 92, 93, 94, 96, 1999 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  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 #define NO_SHORTNAMES   /* Tell config not to load remap.h */
  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 #if defined (XENIX) || defined (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_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   WAITTYPE 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(1);
 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       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n",
 231 #ifdef MAIL_USE_POP
 232                " [POP-password]"
 233 #else
 234                ""
 235 #endif
 236                );
 237       exit (1);
 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);
 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 #if defined (BSD_SYSTEM) || defined (XENIX)
 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 || XENIX */
 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 XENIX
 425           status = locking (indesc, LK_RLCK, 0L);
 426 #else
 427 #ifdef WINDOWSNT
 428           status = locking (indesc, LK_RLCK, -1L);
 429 #else
 430           status = flock (indesc, LOCK_EX);
 431 #endif
 432 #endif
 433 #endif /* not MAIL_USE_LOCKF */
 434 #endif /* MAIL_USE_SYSTEM_LOCK */
 435         }
 436
 437       /* If it fails, retry up to 5 times
 438          for certain failure codes.  */
 439       if (status < 0)
 440         {
 441           if (++lockcount <= 5)
 442             {
 443 #ifdef EAGAIN
 444               if (errno == EAGAIN)
 445                 {
 446                   sleep (1);
 447                   goto retry_lock;
 448                 }
 449 #endif
 450 #ifdef EBUSY
 451               if (errno == EBUSY)
 452                 {
 453                   sleep (1);
 454                   goto retry_lock;
 455                 }
 456 #endif
 457             }
 458
 459           pfatal_with_name (inname);
 460         }
 461
 462       {
 463         char buf[1024];
 464
 465         while (1)
 466           {
 467             nread = read (indesc, buf, sizeof buf);
 468             if (nread != write (outdesc, buf, nread))
 469               {
 470                 int saved_errno = errno;
 471                 unlink (outname);
 472                 errno = saved_errno;
 473                 pfatal_with_name (outname);
 474               }
 475             if (nread < sizeof buf)
 476               break;
 477 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 478             if (spool_name)
 479               {
 480                 now = time (0);
 481                 if (now - touched_lock > 60)
 482                   {
 483                     touchlock ();
 484                     touched_lock = now;
 485                   }
 486               }
 487 #endif /* MAIL_USE_MAILLOCK */
 488           }
 489       }
 490
 491 #ifdef BSD_SYSTEM
 492       if (fsync (outdesc) < 0)
 493         pfatal_and_delete (outname);
 494 #endif
 495
 496       /* Check to make sure no errors before we zap the inbox.  */
 497       if (close (outdesc) != 0)
 498         pfatal_and_delete (outname);
 499
 500 #ifdef MAIL_USE_SYSTEM_LOCK
 501       if (! preserve_mail)
 502         {
 503 #if defined (STRIDE) || defined (XENIX)
 504           /* Stride, xenix have file locking, but no ftruncate.
 505              This mess will do. */
 506           close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
 507 #else
 508           ftruncate (indesc, 0L);
 509 #endif /* STRIDE or XENIX */
 510         }
 511 #endif /* MAIL_USE_SYSTEM_LOCK */
 512
 513 #ifdef MAIL_USE_MMDF
 514       lk_close (indesc, 0, 0, 0);
 515 #else
 516       close (indesc);
 517 #endif
 518
 519 #ifndef MAIL_USE_SYSTEM_LOCK
 520       if (! preserve_mail)
 521         {
 522           /* Delete the input file; if we can't, at least get rid of its
 523              contents.  */
 524 #ifdef MAIL_UNLINK_SPOOL
 525           /* This is generally bad to do, because it destroys the permissions
 526              that were set on the file.  Better to just empty the file.  */
 527           if (unlink (inname) < 0 && errno != ENOENT)
 528 #endif /* MAIL_UNLINK_SPOOL */
 529             creat (inname, 0600);
 530         }
 531 #endif /* not MAIL_USE_SYSTEM_LOCK */
 532
 533 #ifdef MAIL_USE_MAILLOCK
 534       /* This has to occur in the child, i.e., in the process that
 535          acquired the lock! */
 536       if (spool_name)
 537         mailunlock ();
 538 #endif
 539       exit (0);
 540     }
 541
 542   wait (&status);
 543   if (!WIFEXITED (status))
 544     exit (1);
 545   else if (WRETCODE (status) != 0)
 546     exit (WRETCODE (status));
 547
 548 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 549 #ifdef MAIL_USE_MAILLOCK
 550   if (! spool_name)
 551 #endif /* MAIL_USE_MAILLOCK */
 552     unlink (lockname);
 553 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 554
 555 #endif /* ! DISABLE_DIRECT_ACCESS */
 556
 557   return 0;
 558 }
 559
 560 #ifdef MAIL_USE_MAILLOCK
 561 /* This function uses stat to confirm that the mail directory is
 562    identical to the directory of the input file, rather than just
 563    string-comparing the two paths, because one or both of them might
 564    be symbolic links pointing to some other directory. */
 565 static char *
 566 mail_spool_name (inname)
 567      char *inname;
 568 {
 569   struct stat stat1, stat2;
 570   char *indir, *fname;
 571   int status;
 572
 573   if (! (fname = rindex (inname, '/')))
 574     return NULL;
 575
 576   fname++;
 577
 578   if (stat (MAILDIR, &stat1) < 0)
 579     return NULL;
 580
 581   indir = (char *) xmalloc (fname - inname + 1);
 582   strncpy (indir, inname, fname - inname);
 583   indir[fname-inname] = '\0';
 584
 585
 586   status = stat (indir, &stat2);
 587
 588   free (indir);
 589
 590   if (status < 0)
 591     return NULL;
 592
 593   if (stat1.st_dev == stat2.st_dev
 594       && stat1.st_ino == stat2.st_ino)
 595     return fname;
 596
 597   return NULL;
 598 }
 599 #endif /* MAIL_USE_MAILLOCK */
 600 \f
 601 /* Print error message and exit.  */
 602
 603 void
 604 fatal (s1, s2)
 605      char *s1, *s2;
 606 {
 607   if (delete_lockname)
 608     unlink (delete_lockname);
 609   error (s1, s2, 0);
 610   exit (1);
 611 }
 612
 613 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 614    are args for it or null. */
 615
 616 void
 617 error (s1, s2, s3)
 618      char *s1, *s2, *s3;
 619 {
 620   fprintf (stderr, "movemail: ");
 621   if (s3)
 622     fprintf (stderr, s1, s2, s3);
 623   else if (s2)
 624     fprintf (stderr, s1, s2);
 625   else
 626     fprintf (stderr, s1);
 627   fprintf (stderr, "\n");
 628 }
 629
 630 void
 631 pfatal_with_name (name)
 632      char *name;
 633 {
 634   char *s = concat ("", strerror (errno), " for %s");
 635   fatal (s, name);
 636 }
 637
 638 void
 639 pfatal_and_delete (name)
 640      char *name;
 641 {
 642   char *s = concat ("", strerror (errno), " for %s");
 643   unlink (name);
 644   fatal (s, name);
 645 }
 646
 647 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 648
 649 char *
 650 concat (s1, s2, s3)
 651      char *s1, *s2, *s3;
 652 {
 653   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 654   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 655
 656   strcpy (result, s1);
 657   strcpy (result + len1, s2);
 658   strcpy (result + len1 + len2, s3);
 659   *(result + len1 + len2 + len3) = 0;
 660
 661   return result;
 662 }
 663
 664 /* Like malloc but get fatal error if memory is exhausted.  */
 665
 666 long *
 667 xmalloc (size)
 668      unsigned size;
 669 {
 670   long *result = (long *) malloc (size);
 671   if (!result)
 672     fatal ("virtual memory exhausted", 0);
 673   return result;
 674 }
 675 \f
 676 /* This is the guts of the interface to the Post Office Protocol.  */
 677
 678 #ifdef MAIL_USE_POP
 679
 680 #ifndef WINDOWSNT
 681 #include <sys/socket.h>
 682 #include <netinet/in.h>
 683 #include <netdb.h>
 684 #else
 685 #undef _WINSOCKAPI_
 686 #include <winsock.h>
 687 #endif
 688 #include <pwd.h>
 689
 690 #define NOTOK (-1)
 691 #define OK 0
 692 #define DONE 1
 693
 694 char *progname;
 695 FILE *sfi;
 696 FILE *sfo;
 697 char ibuffer[BUFSIZ];
 698 char obuffer[BUFSIZ];
 699 char Errmsg[200];               /* POP errors, at least, can exceed
 700                                    the original length of 80.  */
 701
 702 /*
 703  * The full legal syntax for a POP mailbox specification for movemail
 704  * is "po:username:hostname".  The ":hostname" is optional; if it is
 705  * omitted, the MAILHOST environment variable will be consulted.  Note
 706  * that by the time popmail() is called the "po:" has been stripped
 707  * off of the front of the mailbox name.
 708  *
 709  * If the mailbox is in the form "po:username:hostname", then it is
 710  * modified by this function -- the second colon is replaced by a
 711  * null.
 712  */
 713
 714 int
 715 popmail (mailbox, outfile, preserve, password, reverse_order)
 716      char *mailbox;
 717      char *outfile;
 718      int preserve;
 719      char *password;
 720      int reverse_order;
 721 {
 722   int nmsgs, nbytes;
 723   register int i;
 724   int mbfi;
 725   FILE *mbf;
 726   char *getenv ();
 727   popserver server;
 728   int start, end, increment;
 729   char *user, *hostname;
 730
 731   user = mailbox;
 732   if ((hostname = index(mailbox, ':')))
 733     *hostname++ = '\0';
 734
 735   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 736   if (! server)
 737     {
 738       error ("Error connecting to POP server: %s", pop_error, 0);
 739       return (1);
 740     }
 741
 742   if (pop_stat (server, &nmsgs, &nbytes))
 743     {
 744       error ("Error getting message count from POP server: %s", pop_error, 0);
 745       return (1);
 746     }
 747
 748   if (!nmsgs)
 749     {
 750       pop_close (server);
 751       return (0);
 752     }
 753
 754   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 755   if (mbfi < 0)
 756     {
 757       pop_close (server);
 758       error ("Error in open: %s, %s", strerror (errno), outfile);
 759       return (1);
 760     }
 761   fchown (mbfi, getuid (), -1);
 762
 763   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 764     {
 765       pop_close (server);
 766       error ("Error in fdopen: %s", strerror (errno), 0);
 767       close (mbfi);
 768       unlink (outfile);
 769       return (1);
 770     }
 771
 772   if (reverse_order)
 773     {
 774       start = nmsgs;
 775       end = 1;
 776       increment = -1;
 777     }
 778   else
 779     {
 780       start = 1;
 781       end = nmsgs;
 782       increment = 1;
 783     }
 784
 785   for (i = start; i * increment <= end * increment; i += increment)
 786     {
 787       mbx_delimit_begin (mbf);
 788       if (pop_retr (server, i, mbf) != OK)
 789         {
 790           error (Errmsg, 0, 0);
 791           close (mbfi);
 792           return (1);
 793         }
 794       mbx_delimit_end (mbf);
 795       fflush (mbf);
 796       if (ferror (mbf))
 797         {
 798           error ("Error in fflush: %s", strerror (errno), 0);
 799           pop_close (server);
 800           close (mbfi);
 801           return (1);
 802         }
 803     }
 804
 805   /* On AFS, a call to write only modifies the file in the local
 806    *     workstation's AFS cache.  The changes are not written to the server
 807    *      until a call to fsync or close is made.  Users with AFS home
 808    *      directories have lost mail when over quota because these checks were
 809    *      not made in previous versions of movemail. */
 810
 811 #ifdef BSD_SYSTEM
 812   if (fsync (mbfi) < 0)
 813     {
 814       error ("Error in fsync: %s", strerror (errno));
 815       return (1);
 816     }
 817 #endif
 818
 819   if (close (mbfi) == -1)
 820     {
 821       error ("Error in close: %s", strerror (errno), 0);
 822       return (1);
 823     }
 824
 825   if (! preserve)
 826     for (i = 1; i <= nmsgs; i++)
 827       {
 828         if (pop_delete (server, i))
 829           {
 830             error ("Error from POP server: %s", pop_error, 0);
 831             pop_close (server);
 832             return (1);
 833           }
 834       }
 835
 836   if (pop_quit (server))
 837     {
 838       error ("Error from POP server: %s", pop_error, 0);
 839       return (1);
 840     }
 841
 842   return (0);
 843 }
 844
 845 int
 846 pop_retr (server, msgno, arg)
 847      popserver server;
 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 ("\f\n0, unseen,,\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 ('\037', 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 */