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, 2010, 2011, 2012  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   uid_t real_gid = getgid();
 201   uid_t priv_gid = getegid();
 202
 203 #ifdef WINDOWSNT
 204   /* Ensure all file i/o is in binary mode. */
 205   _fmode = _O_BINARY;
 206 #endif
 207
 208   delete_lockname = 0;
 209
 210   while ((c = getopt (argc, argv, ARGSTR)) != EOF)
 211     {
 212       switch (c) {
 213 #ifdef MAIL_USE_POP
 214       case 'r':
 215         pop_reverse_order = 1;
 216         break;
 217 #endif
 218       case 'p':
 219         preserve_mail++;
 220         break;
 221       default:
 222         exit (EXIT_FAILURE);
 223       }
 224     }
 225
 226   if (
 227 #ifdef MAIL_USE_POP
 228       (argc - optind < 2) || (argc - optind > 3)
 229 #else
 230       (argc - optind != 2)
 231 #endif
 232       )
 233     {
 234 #ifdef MAIL_USE_POP
 235       fprintf (stderr, "Usage: movemail [-p] [-r] inbox destfile%s\n",
 236                " [POP-password]");
 237 #else
 238       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
 239 #endif
 240       exit (EXIT_FAILURE);
 241     }
 242
 243   inname = argv[optind];
 244   outname = argv[optind+1];
 245
 246 #ifdef MAIL_USE_MMDF
 247   mmdf_init (argv[0]);
 248 #endif
 249
 250   if (*outname == 0)
 251     fatal ("Destination file name is empty", 0, 0);
 252
 253 #ifdef MAIL_USE_POP
 254   if (!strncmp (inname, "po:", 3))
 255     {
 256       int status;
 257
 258       status = popmail (inname + 3, outname, preserve_mail,
 259                         (argc - optind == 3) ? argv[optind+2] : NULL,
 260                         pop_reverse_order);
 261       exit (status);
 262     }
 263
 264   if (setuid (getuid ()) < 0)
 265     fatal ("Failed to drop privileges", 0, 0);
 266
 267 #endif /* MAIL_USE_POP */
 268
 269 #ifndef DISABLE_DIRECT_ACCESS
 270 #ifndef MAIL_USE_MMDF
 271 #ifndef MAIL_USE_SYSTEM_LOCK
 272 #ifdef MAIL_USE_MAILLOCK
 273   spool_name = mail_spool_name (inname);
 274   if (! spool_name)
 275 #endif
 276     {
 277       /* Use a lock file named after our first argument with .lock appended:
 278          If it exists, the mail file is locked.  */
 279       /* Note: this locking mechanism is *required* by the mailer
 280          (on systems which use it) to prevent loss of mail.
 281
 282          On systems that use a lock file, extracting the mail without locking
 283          WILL occasionally cause loss of mail due to timing errors!
 284
 285          So, if creation of the lock file fails
 286          due to access permission on the mail spool directory,
 287          you simply MUST change the permission
 288          and/or make movemail a setgid program
 289          so it can create lock files properly.
 290
 291          You might also wish to verify that your system is one
 292          which uses lock files for this purpose.  Some systems use other methods.
 293
 294          If your system uses the `flock' system call for mail locking,
 295          define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
 296          and recompile movemail.  If the s- file for your system
 297          should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
 298          to bug-gnu-emacs@prep.ai.mit.edu so we can fix it.  */
 299
 300       lockname = concat (inname, ".lock", "");
 301       tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
 302       strcpy (tempname, inname);
 303       p = tempname + strlen (tempname);
 304       while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
 305         p--;
 306       *p = 0;
 307       strcpy (p, "EXXXXXX");
 308       mktemp (tempname);
 309       unlink (tempname);
 310
 311       while (1)
 312         {
 313           /* Create the lock file, but not under the lock file name.  */
 314           /* Give up if cannot do that.  */
 315           desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 316           if (desc < 0)
 317             {
 318               char *message = (char *) xmalloc (strlen (tempname) + 50);
 319               sprintf (message, "creating %s, which would become the lock file",
 320                        tempname);
 321               pfatal_with_name (message);
 322             }
 323           close (desc);
 324
 325           tem = link (tempname, lockname);
 326
 327 #ifdef EPERM
 328           if (tem < 0 && errno == EPERM)
 329             fatal ("Unable to create hard link between %s and %s",
 330                    tempname, lockname);
 331 #endif
 332
 333           unlink (tempname);
 334           if (tem >= 0)
 335             break;
 336           sleep (1);
 337
 338           /* If lock file is five minutes old, unlock it.
 339              Five minutes should be good enough to cope with crashes
 340              and wedgitude, and long enough to avoid being fooled
 341              by time differences between machines.  */
 342           if (stat (lockname, &st) >= 0)
 343             {
 344               now = time (0);
 345               if (st.st_ctime < now - 300)
 346                 unlink (lockname);
 347             }
 348         }
 349
 350       delete_lockname = lockname;
 351     }
 352 #endif /* not MAIL_USE_SYSTEM_LOCK */
 353 #endif /* not MAIL_USE_MMDF */
 354
 355   if (fork () == 0)
 356     {
 357       int lockcount = 0;
 358       int status = 0;
 359 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 360       time_t touched_lock, now;
 361 #endif
 362
 363       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 364         fatal ("Failed to drop privileges", 0, 0);
 365
 366 #ifndef MAIL_USE_MMDF
 367 #ifdef MAIL_USE_SYSTEM_LOCK
 368       indesc = open (inname, O_RDWR);
 369 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 370       indesc = open (inname, O_RDONLY);
 371 #endif /* not MAIL_USE_SYSTEM_LOCK */
 372 #else  /* MAIL_USE_MMDF */
 373       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 374 #endif /* MAIL_USE_MMDF */
 375
 376       if (indesc < 0)
 377         pfatal_with_name (inname);
 378
 379 #ifdef BSD_SYSTEM
 380       /* In case movemail is setuid to root, make sure the user can
 381          read the output file.  */
 382       /* This is desirable for all systems
 383          but I don't want to assume all have the umask system call */
 384       umask (umask (0) & 0333);
 385 #endif /* BSD_SYSTEM */
 386       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 387       if (outdesc < 0)
 388         pfatal_with_name (outname);
 389
 390       if (setregid (-1, priv_gid) < 0)
 391         fatal ("Failed to regain privileges", 0, 0);
 392
 393       /* This label exists so we can retry locking
 394          after a delay, if it got EAGAIN or EBUSY.  */
 395     retry_lock:
 396
 397       /* Try to lock it.  */
 398 #ifdef MAIL_USE_MAILLOCK
 399       if (spool_name)
 400         {
 401           /* The "0 - " is to make it a negative number if maillock returns
 402              non-zero. */
 403           status = 0 - maillock (spool_name, 1);
 404 #ifdef HAVE_TOUCHLOCK
 405           touched_lock = time (0);
 406 #endif
 407           lockcount = 5;
 408         }
 409       else
 410 #endif /* MAIL_USE_MAILLOCK */
 411         {
 412 #ifdef MAIL_USE_SYSTEM_LOCK
 413 #ifdef MAIL_USE_LOCKF
 414           status = lockf (indesc, F_LOCK, 0);
 415 #else /* not MAIL_USE_LOCKF */
 416 #ifdef WINDOWSNT
 417           status = locking (indesc, LK_RLCK, -1L);
 418 #else
 419           status = flock (indesc, LOCK_EX);
 420 #endif
 421 #endif /* not MAIL_USE_LOCKF */
 422 #endif /* MAIL_USE_SYSTEM_LOCK */
 423         }
 424
 425       /* If it fails, retry up to 5 times
 426          for certain failure codes.  */
 427       if (status < 0)
 428         {
 429           if (++lockcount <= 5)
 430             {
 431 #ifdef EAGAIN
 432               if (errno == EAGAIN)
 433                 {
 434                   sleep (1);
 435                   goto retry_lock;
 436                 }
 437 #endif
 438 #ifdef EBUSY
 439               if (errno == EBUSY)
 440                 {
 441                   sleep (1);
 442                   goto retry_lock;
 443                 }
 444 #endif
 445             }
 446
 447           pfatal_with_name (inname);
 448         }
 449
 450       {
 451         char buf[1024];
 452
 453         while (1)
 454           {
 455             nread = read (indesc, buf, sizeof buf);
 456             if (nread < 0)
 457               pfatal_with_name (inname);
 458             if (nread != write (outdesc, buf, nread))
 459               {
 460                 int saved_errno = errno;
 461                 unlink (outname);
 462                 errno = saved_errno;
 463                 pfatal_with_name (outname);
 464               }
 465             if (nread < sizeof buf)
 466               break;
 467 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 468             if (spool_name)
 469               {
 470                 now = time (0);
 471                 if (now - touched_lock > 60)
 472                   {
 473                     touchlock ();
 474                     touched_lock = now;
 475                   }
 476               }
 477 #endif /* MAIL_USE_MAILLOCK */
 478           }
 479       }
 480
 481 #ifdef BSD_SYSTEM
 482       if (fsync (outdesc) < 0)
 483         pfatal_and_delete (outname);
 484 #endif
 485
 486       /* Prevent symlink attacks truncating other users' mailboxes */
 487       if (setregid (-1, real_gid) < 0)
 488         fatal ("Failed to drop privileges", 0, 0);
 489
 490       /* Check to make sure no errors before we zap the inbox.  */
 491       if (close (outdesc) != 0)
 492         pfatal_and_delete (outname);
 493
 494 #ifdef MAIL_USE_SYSTEM_LOCK
 495       if (! preserve_mail)
 496         {
 497           ftruncate (indesc, 0L);
 498         }
 499 #endif /* MAIL_USE_SYSTEM_LOCK */
 500
 501 #ifdef MAIL_USE_MMDF
 502       lk_close (indesc, 0, 0, 0);
 503 #else
 504       close (indesc);
 505 #endif
 506
 507 #ifndef MAIL_USE_SYSTEM_LOCK
 508       if (! preserve_mail)
 509         {
 510           /* Delete the input file; if we can't, at least get rid of its
 511              contents.  */
 512 #ifdef MAIL_UNLINK_SPOOL
 513           /* This is generally bad to do, because it destroys the permissions
 514              that were set on the file.  Better to just empty the file.  */
 515           if (unlink (inname) < 0 && errno != ENOENT)
 516 #endif /* MAIL_UNLINK_SPOOL */
 517             creat (inname, 0600);
 518         }
 519 #endif /* not MAIL_USE_SYSTEM_LOCK */
 520
 521       /* End of mailbox truncation */
 522       if (setregid (-1, priv_gid) < 0)
 523         fatal ("Failed to regain privileges", 0, 0);
 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 #include <string.h>
 681
 682 #define NOTOK (-1)
 683 #define OK 0
 684 #define DONE 1
 685
 686 char *progname;
 687 FILE *sfi;
 688 FILE *sfo;
 689 char ibuffer[BUFSIZ];
 690 char obuffer[BUFSIZ];
 691 char Errmsg[200];               /* POP errors, at least, can exceed
 692                                    the original length of 80.  */
 693
 694 /*
 695  * The full valid syntax for a POP mailbox specification for movemail
 696  * is "po:username:hostname".  The ":hostname" is optional; if it is
 697  * omitted, the MAILHOST environment variable will be consulted.  Note
 698  * that by the time popmail() is called the "po:" has been stripped
 699  * off of the front of the mailbox name.
 700  *
 701  * If the mailbox is in the form "po:username:hostname", then it is
 702  * modified by this function -- the second colon is replaced by a
 703  * null.
 704  *
 705  * Return a value suitable for passing to `exit'.
 706  */
 707
 708 int
 709 popmail (mailbox, outfile, preserve, password, reverse_order)
 710      char *mailbox;
 711      char *outfile;
 712      int preserve;
 713      char *password;
 714      int reverse_order;
 715 {
 716   int nmsgs, nbytes;
 717   register int i;
 718   int mbfi;
 719   FILE *mbf;
 720   char *getenv ();
 721   popserver server;
 722   int start, end, increment;
 723   char *user, *hostname;
 724
 725   user = mailbox;
 726   if ((hostname = index(mailbox, ':')))
 727     *hostname++ = '\0';
 728
 729   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 730   if (! server)
 731     {
 732       error ("Error connecting to POP server: %s", pop_error, 0);
 733       return EXIT_FAILURE;
 734     }
 735
 736   if (pop_stat (server, &nmsgs, &nbytes))
 737     {
 738       error ("Error getting message count from POP server: %s", pop_error, 0);
 739       return EXIT_FAILURE;
 740     }
 741
 742   if (!nmsgs)
 743     {
 744       pop_close (server);
 745       return EXIT_SUCCESS;
 746     }
 747
 748   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 749   if (mbfi < 0)
 750     {
 751       pop_close (server);
 752       error ("Error in open: %s, %s", strerror (errno), outfile);
 753       return EXIT_FAILURE;
 754     }
 755   fchown (mbfi, getuid (), -1);
 756
 757   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 758     {
 759       pop_close (server);
 760       error ("Error in fdopen: %s", strerror (errno), 0);
 761       close (mbfi);
 762       unlink (outfile);
 763       return EXIT_FAILURE;
 764     }
 765
 766   if (reverse_order)
 767     {
 768       start = nmsgs;
 769       end = 1;
 770       increment = -1;
 771     }
 772   else
 773     {
 774       start = 1;
 775       end = nmsgs;
 776       increment = 1;
 777     }
 778
 779   for (i = start; i * increment <= end * increment; i += increment)
 780     {
 781       mbx_delimit_begin (mbf);
 782       if (pop_retr (server, i, mbf) != OK)
 783         {
 784           error ("%s", Errmsg, 0);
 785           close (mbfi);
 786           return EXIT_FAILURE;
 787         }
 788       mbx_delimit_end (mbf);
 789       fflush (mbf);
 790       if (ferror (mbf))
 791         {
 792           error ("Error in fflush: %s", strerror (errno), 0);
 793           pop_close (server);
 794           close (mbfi);
 795           return EXIT_FAILURE;
 796         }
 797     }
 798
 799   /* On AFS, a call to write only modifies the file in the local
 800    *     workstation's AFS cache.  The changes are not written to the server
 801    *      until a call to fsync or close is made.  Users with AFS home
 802    *      directories have lost mail when over quota because these checks were
 803    *      not made in previous versions of movemail. */
 804
 805 #ifdef BSD_SYSTEM
 806   if (fsync (mbfi) < 0)
 807     {
 808       error ("Error in fsync: %s", strerror (errno), 0);
 809       return EXIT_FAILURE;
 810     }
 811 #endif
 812
 813   if (close (mbfi) == -1)
 814     {
 815       error ("Error in close: %s", strerror (errno), 0);
 816       return EXIT_FAILURE;
 817     }
 818
 819   if (! preserve)
 820     for (i = 1; i <= nmsgs; i++)
 821       {
 822         if (pop_delete (server, i))
 823           {
 824             error ("Error from POP server: %s", pop_error, 0);
 825             pop_close (server);
 826             return EXIT_FAILURE;
 827           }
 828       }
 829
 830   if (pop_quit (server))
 831     {
 832       error ("Error from POP server: %s", pop_error, 0);
 833       return EXIT_FAILURE;
 834     }
 835
 836   return EXIT_SUCCESS;
 837 }
 838
 839 int
 840 pop_retr (server, msgno, arg)
 841      popserver server;
 842      int msgno;
 843      FILE *arg;
 844 {
 845   extern char *strerror ();
 846   char *line;
 847   int ret;
 848
 849   if (pop_retrieve_first (server, msgno, &line))
 850     {
 851       char *error = concat ("Error from POP server: ", pop_error, "");
 852       strncpy (Errmsg, error, sizeof (Errmsg));
 853       Errmsg[sizeof (Errmsg)-1] = '\0';
 854       free(error);
 855       return (NOTOK);
 856     }
 857
 858   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 859     {
 860       if (! line)
 861         break;
 862
 863       if (mbx_write (line, ret, arg) != OK)
 864         {
 865           strcpy (Errmsg, strerror (errno));
 866           pop_close (server);
 867           return (NOTOK);
 868         }
 869     }
 870
 871   if (ret)
 872     {
 873       char *error = concat ("Error from POP server: ", pop_error, "");
 874       strncpy (Errmsg, error, sizeof (Errmsg));
 875       Errmsg[sizeof (Errmsg)-1] = '\0';
 876       free(error);
 877       return (NOTOK);
 878     }
 879
 880   return (OK);
 881 }
 882
 883 /* Do this as a macro instead of using strcmp to save on execution time. */
 884 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 885                          && (a[1] == 'r') \
 886                          && (a[2] == 'o') \
 887                          && (a[3] == 'm') \
 888                          && (a[4] == ' '))
 889
 890 int
 891 mbx_write (line, len, mbf)
 892      char *line;
 893      int len;
 894      FILE *mbf;
 895 {
 896 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 897   if (IS_FROM_LINE (line))
 898     {
 899       if (fputc ('>', mbf) == EOF)
 900         return (NOTOK);
 901     }
 902 #endif
 903   if (line[0] == '\037')
 904     {
 905       if (fputs ("^_", mbf) == EOF)
 906         return (NOTOK);
 907       line++;
 908       len--;
 909     }
 910   if (fwrite (line, 1, len, mbf) != len)
 911     return (NOTOK);
 912   if (fputc (0x0a, mbf) == EOF)
 913     return (NOTOK);
 914   return (OK);
 915 }
 916
 917 int
 918 mbx_delimit_begin (mbf)
 919      FILE *mbf;
 920 {
 921   time_t now;
 922   struct tm *ltime;
 923   char fromline[40] = "From movemail ";
 924
 925   now = time (NULL);
 926   ltime = localtime (&now);
 927
 928   strcat (fromline, asctime (ltime));
 929
 930   if (fputs (fromline, mbf) == EOF)
 931     return (NOTOK);
 932   return (OK);
 933 }
 934
 935 int
 936 mbx_delimit_end (mbf)
 937      FILE *mbf;
 938 {
 939   if (putc ('\n', mbf) == EOF)
 940     return (NOTOK);
 941   return (OK);
 942 }
 943
 944 #endif /* MAIL_USE_POP */
 945 \f
 946 #ifndef HAVE_STRERROR
 947 char *
 948 strerror (errnum)
 949      int errnum;
 950 {
 951   extern char *sys_errlist[];
 952   extern int sys_nerr;
 953
 954   if (errnum >= 0 && errnum < sys_nerr)
 955     return sys_errlist[errnum];
 956   return (char *) "Unknown error";
 957 }
 958
 959 #endif /* ! HAVE_STRERROR */
 960
 961 /* arch-tag: 1c323112-41fe-4fe5-8de9-494de631f73f
 962    (do not change this comment) */
 963
 964 /* movemail.c ends here */