lib-src/movemail.c

   1 /* movemail foo bar -- move file foo to file bar,
   2    locking file foo the way /bin/mail respects.
   3
   4 Copyright (C) 1986, 1992-1994, 1996, 1999, 2001-2011
   5   Free Software Foundation, Inc.
   6
   7 This file is part of GNU Emacs.
   8
   9 GNU Emacs is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 GNU Emacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* Important notice: defining MAIL_USE_FLOCK or MAIL_USE_LOCKF *will
  24    cause loss of mail* if you do it on a system that does not normally
  25    use flock as its way of interlocking access to inbox files.  The
  26    setting of MAIL_USE_FLOCK and MAIL_USE_LOCKF *must agree* with the
  27    system's own conventions.  It is not a choice that is up to you.
  28
  29    So, if your system uses lock files rather than flock, then the only way
  30    you can get proper operation is to enable movemail to write lockfiles there.
  31    This means you must either give that directory access modes
  32    that permit everyone to write lockfiles in it, or you must make movemail
  33    a setuid or setgid program.  */
  34
  35 /*
  36  * Modified January, 1986 by Michael R. Gretzinger (Project Athena)
  37  *
  38  * Added POP (Post Office Protocol) service.  When compiled -DMAIL_USE_POP
  39  * movemail will accept input filename arguments of the form
  40  * "po:username".  This will cause movemail to open a connection to
  41  * a pop server running on $MAILHOST (environment variable).  Movemail
  42  * must be setuid to root in order to work with POP.
  43  *
  44  * New module: popmail.c
  45  * Modified routines:
  46  *      main - added code within #ifdef MAIL_USE_POP; added setuid (getuid ())
  47  *              after POP code.
  48  * New routines in movemail.c:
  49  *      get_errmsg - return pointer to system error message
  50  *
  51  * Modified August, 1993 by Jonathan Kamens (OpenVision Technologies)
  52  *
  53  * Move all of the POP code into a separate file, "pop.c".
  54  * Use strerror instead of get_errmsg.
  55  *
  56  */
  57
  58 #include <config.h>
  59 #include <sys/types.h>
  60 #include <sys/stat.h>
  61 #include <sys/file.h>
  62 #include <stdio.h>
  63 #include <errno.h>
  64 #include <time.h>
  65
  66 #include <getopt.h>
  67 #include <unistd.h>
  68 #ifdef HAVE_FCNTL_H
  69 #include <fcntl.h>
  70 #endif
  71 #include <string.h>
  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 #ifdef WINDOWSNT
  82 #include "ntlib.h"
  83 #undef access
  84 #undef unlink
  85 #define fork() 0
  86 #define wait(var) (*(var) = 0)
  87 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
  88    though the locking call succeeds (and indeed blocks local access from
  89    other NT programs).  If you have direct file access using an NFS
  90    client or something other than Samba, the locking call might work
  91    properly - make sure it does before you enable this!
  92
  93    [18-Feb-97 andrewi] I now believe my comment above to be incorrect,
  94    since it was based on a misunderstanding of how locking calls are
  95    implemented and used on Unix.  */
  96 //#define DISABLE_DIRECT_ACCESS
  97
  98 #include <fcntl.h>
  99 #endif /* WINDOWSNT */
 100
 101 #ifndef F_OK
 102 #define F_OK 0
 103 #define X_OK 1
 104 #define W_OK 2
 105 #define R_OK 4
 106 #endif
 107
 108 #ifdef WINDOWSNT
 109 #include <sys/locking.h>
 110 #endif
 111
 112 #ifdef MAIL_USE_LOCKF
 113 #define MAIL_USE_SYSTEM_LOCK
 114 #endif
 115
 116 #ifdef MAIL_USE_FLOCK
 117 #define MAIL_USE_SYSTEM_LOCK
 118 #endif
 119
 120 #ifdef MAIL_USE_MMDF
 121 extern int lk_open (), lk_close ();
 122 #endif
 123
 124 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
 125         (defined (HAVE_LIBMAIL) || defined (HAVE_LIBLOCKFILE)) && \
 126         defined (HAVE_MAILLOCK_H)
 127 #include <maillock.h>
 128 /* We can't use maillock unless we know what directory system mail
 129    files appear in. */
 130 #ifdef MAILDIR
 131 #define MAIL_USE_MAILLOCK
 132 static char *mail_spool_name (char *);
 133 #endif
 134 #endif
 135
 136 #ifndef HAVE_STRERROR
 137 char *strerror (int);
 138 #endif
 139
 140 static void fatal (const char *s1, const char *s2, const char *s3) NO_RETURN;
 141 static void error (const char *s1, const char *s2, const char *s3);
 142 static void pfatal_with_name (char *name) NO_RETURN;
 143 static void pfatal_and_delete (char *name) NO_RETURN;
 144 static char *concat (const char *s1, const char *s2, const char *s3);
 145 static long *xmalloc (unsigned int size);
 146 #ifdef MAIL_USE_POP
 147 static int popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order);
 148 static int pop_retr (popserver server, int msgno, FILE *arg);
 149 static int mbx_write (char *line, int len, FILE *mbf);
 150 static int mbx_delimit_begin (FILE *mbf);
 151 static int mbx_delimit_end (FILE *mbf);
 152 #endif
 153
 154 /* Nonzero means this is name of a lock file to delete on fatal error.  */
 155 static char *delete_lockname;
 156
 157 int
 158 main (int argc, char **argv)
 159 {
 160   char *inname, *outname;
 161   int indesc, outdesc;
 162   ssize_t nread;
 163   int wait_status;
 164   int c, preserve_mail = 0;
 165
 166 #ifndef MAIL_USE_SYSTEM_LOCK
 167   struct stat st;
 168   int tem;
 169   char *lockname;
 170   char *tempname;
 171   size_t inname_dirlen;
 172   int desc;
 173 #endif /* not MAIL_USE_SYSTEM_LOCK */
 174
 175 #ifdef MAIL_USE_MAILLOCK
 176   char *spool_name;
 177 #endif
 178
 179 #ifdef MAIL_USE_POP
 180   int pop_reverse_order = 0;
 181 # define ARGSTR "pr"
 182 #else /* ! MAIL_USE_POP */
 183 # define ARGSTR "p"
 184 #endif /* MAIL_USE_POP */
 185
 186   uid_t real_gid = getgid();
 187   uid_t priv_gid = getegid();
 188
 189 #ifdef WINDOWSNT
 190   /* Ensure all file i/o is in binary mode. */
 191   _fmode = _O_BINARY;
 192 #endif
 193
 194   delete_lockname = 0;
 195
 196   while ((c = getopt (argc, argv, ARGSTR)) != EOF)
 197     {
 198       switch (c) {
 199 #ifdef MAIL_USE_POP
 200       case 'r':
 201         pop_reverse_order = 1;
 202         break;
 203 #endif
 204       case 'p':
 205         preserve_mail++;
 206         break;
 207       default:
 208         exit (EXIT_FAILURE);
 209       }
 210     }
 211
 212   if (
 213 #ifdef MAIL_USE_POP
 214       (argc - optind < 2) || (argc - optind > 3)
 215 #else
 216       (argc - optind != 2)
 217 #endif
 218       )
 219     {
 220 #ifdef MAIL_USE_POP
 221       fprintf (stderr, "Usage: movemail [-p] [-r] inbox destfile%s\n",
 222                " [POP-password]");
 223 #else
 224       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
 225 #endif
 226       exit (EXIT_FAILURE);
 227     }
 228
 229   inname = argv[optind];
 230   outname = argv[optind+1];
 231
 232 #ifdef MAIL_USE_MMDF
 233   mmdf_init (argv[0]);
 234 #endif
 235
 236   if (*outname == 0)
 237     fatal ("Destination file name is empty", 0, 0);
 238
 239 #ifdef MAIL_USE_POP
 240   if (!strncmp (inname, "po:", 3))
 241     {
 242       int status;
 243
 244       status = popmail (inname + 3, outname, preserve_mail,
 245                         (argc - optind == 3) ? argv[optind+2] : NULL,
 246                         pop_reverse_order);
 247       exit (status);
 248     }
 249
 250   if (setuid (getuid ()) < 0)
 251     fatal ("Failed to drop privileges", 0, 0);
 252
 253 #endif /* MAIL_USE_POP */
 254
 255 #ifndef DISABLE_DIRECT_ACCESS
 256 #ifndef MAIL_USE_MMDF
 257 #ifndef MAIL_USE_SYSTEM_LOCK
 258 #ifdef MAIL_USE_MAILLOCK
 259   spool_name = mail_spool_name (inname);
 260   if (spool_name)
 261     {
 262 #ifdef lint
 263       lockname = 0;
 264 #endif
 265     }
 266   else
 267 #endif
 268     {
 269       #ifndef DIRECTORY_SEP
 270        #define DIRECTORY_SEP '/'
 271       #endif
 272       #ifndef IS_DIRECTORY_SEP
 273        #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
 274       #endif
 275
 276       /* Use a lock file named after our first argument with .lock appended:
 277          If it exists, the mail file is locked.  */
 278       /* Note: this locking mechanism is *required* by the mailer
 279          (on systems which use it) to prevent loss of mail.
 280
 281          On systems that use a lock file, extracting the mail without locking
 282          WILL occasionally cause loss of mail due to timing errors!
 283
 284          So, if creation of the lock file fails
 285          due to access permission on the mail spool directory,
 286          you simply MUST change the permission
 287          and/or make movemail a setgid program
 288          so it can create lock files properly.
 289
 290          You might also wish to verify that your system is one
 291          which uses lock files for this purpose.  Some systems use other methods.
 292
 293          If your system uses the `flock' system call for mail locking,
 294          define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
 295          and recompile movemail.  If the s- file for your system
 296          should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
 297          to bug-gnu-emacs@prep.ai.mit.edu so we can fix it.  */
 298
 299       lockname = concat (inname, ".lock", "");
 300       for (inname_dirlen = strlen (inname);
 301            inname_dirlen && !IS_DIRECTORY_SEP (inname[inname_dirlen - 1]);
 302            inname_dirlen--)
 303         continue;
 304       tempname = (char *) xmalloc (inname_dirlen + sizeof "EXXXXXX");
 305
 306       while (1)
 307         {
 308           /* Create the lock file, but not under the lock file name.  */
 309           /* Give up if cannot do that.  */
 310
 311           memcpy (tempname, inname, inname_dirlen);
 312           strcpy (tempname + inname_dirlen, "EXXXXXX");
 313 #ifdef HAVE_MKSTEMP
 314           desc = mkstemp (tempname);
 315 #else
 316           mktemp (tempname);
 317           if (!*tempname)
 318             desc = -1;
 319           else
 320             {
 321               unlink (tempname);
 322               desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0600);
 323             }
 324 #endif
 325           if (desc < 0)
 326             {
 327               int mkstemp_errno = errno;
 328               char *message = (char *) xmalloc (strlen (tempname) + 50);
 329               sprintf (message, "creating %s, which would become the lock file",
 330                        tempname);
 331               errno = mkstemp_errno;
 332               pfatal_with_name (message);
 333             }
 334           close (desc);
 335
 336           tem = link (tempname, lockname);
 337
 338 #ifdef EPERM
 339           if (tem < 0 && errno == EPERM)
 340             fatal ("Unable to create hard link between %s and %s",
 341                    tempname, lockname);
 342 #endif
 343
 344           unlink (tempname);
 345           if (tem >= 0)
 346             break;
 347           sleep (1);
 348
 349           /* If lock file is five minutes old, unlock it.
 350              Five minutes should be good enough to cope with crashes
 351              and wedgitude, and long enough to avoid being fooled
 352              by time differences between machines.  */
 353           if (stat (lockname, &st) >= 0)
 354             {
 355               time_t now = time (0);
 356               if (st.st_ctime < now - 300)
 357                 unlink (lockname);
 358             }
 359         }
 360
 361       delete_lockname = lockname;
 362     }
 363 #endif /* not MAIL_USE_SYSTEM_LOCK */
 364 #endif /* not MAIL_USE_MMDF */
 365
 366   if (fork () == 0)
 367     {
 368       int lockcount = 0;
 369       int status = 0;
 370 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 371       time_t touched_lock;
 372 # ifdef lint
 373       touched_lock = 0;
 374 # endif
 375 #endif
 376
 377       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 378         fatal ("Failed to drop privileges", 0, 0);
 379
 380 #ifndef MAIL_USE_MMDF
 381 #ifdef MAIL_USE_SYSTEM_LOCK
 382       indesc = open (inname, O_RDWR);
 383 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 384       indesc = open (inname, O_RDONLY);
 385 #endif /* not MAIL_USE_SYSTEM_LOCK */
 386 #else  /* MAIL_USE_MMDF */
 387       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 388 #endif /* MAIL_USE_MMDF */
 389
 390       if (indesc < 0)
 391         pfatal_with_name (inname);
 392
 393 #ifdef BSD_SYSTEM
 394       /* In case movemail is setuid to root, make sure the user can
 395          read the output file.  */
 396       /* This is desirable for all systems
 397          but I don't want to assume all have the umask system call */
 398       umask (umask (0) & 0333);
 399 #endif /* BSD_SYSTEM */
 400       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 401       if (outdesc < 0)
 402         pfatal_with_name (outname);
 403
 404       if (setregid (-1, priv_gid) < 0)
 405         fatal ("Failed to regain privileges", 0, 0);
 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                 time_t 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       /* Prevent symlink attacks truncating other users' mailboxes */
 501       if (setregid (-1, real_gid) < 0)
 502         fatal ("Failed to drop privileges", 0, 0);
 503
 504       /* Check to make sure no errors before we zap the inbox.  */
 505       if (close (outdesc) != 0)
 506         pfatal_and_delete (outname);
 507
 508 #ifdef MAIL_USE_SYSTEM_LOCK
 509       if (! preserve_mail)
 510         {
 511           if (ftruncate (indesc, 0L) != 0)
 512             pfatal_with_name (inname);
 513         }
 514 #endif /* MAIL_USE_SYSTEM_LOCK */
 515
 516 #ifdef MAIL_USE_MMDF
 517       lk_close (indesc, 0, 0, 0);
 518 #else
 519       close (indesc);
 520 #endif
 521
 522 #ifndef MAIL_USE_SYSTEM_LOCK
 523       if (! preserve_mail)
 524         {
 525           /* Delete the input file; if we can't, at least get rid of its
 526              contents.  */
 527 #ifdef MAIL_UNLINK_SPOOL
 528           /* This is generally bad to do, because it destroys the permissions
 529              that were set on the file.  Better to just empty the file.  */
 530           if (unlink (inname) < 0 && errno != ENOENT)
 531 #endif /* MAIL_UNLINK_SPOOL */
 532             creat (inname, 0600);
 533         }
 534 #endif /* not MAIL_USE_SYSTEM_LOCK */
 535
 536       /* End of mailbox truncation */
 537       if (setregid (-1, priv_gid) < 0)
 538         fatal ("Failed to regain privileges", 0, 0);
 539
 540 #ifdef MAIL_USE_MAILLOCK
 541       /* This has to occur in the child, i.e., in the process that
 542          acquired the lock! */
 543       if (spool_name)
 544         mailunlock ();
 545 #endif
 546       exit (EXIT_SUCCESS);
 547     }
 548
 549   wait (&wait_status);
 550   if (!WIFEXITED (wait_status))
 551     exit (EXIT_FAILURE);
 552   else if (WRETCODE (wait_status) != 0)
 553     exit (WRETCODE (wait_status));
 554
 555 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 556 #ifdef MAIL_USE_MAILLOCK
 557   if (! spool_name)
 558 #endif /* MAIL_USE_MAILLOCK */
 559     unlink (lockname);
 560 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 561
 562 #endif /* ! DISABLE_DIRECT_ACCESS */
 563
 564   return EXIT_SUCCESS;
 565 }
 566
 567 #ifdef MAIL_USE_MAILLOCK
 568 /* This function uses stat to confirm that the mail directory is
 569    identical to the directory of the input file, rather than just
 570    string-comparing the two paths, because one or both of them might
 571    be symbolic links pointing to some other directory. */
 572 static char *
 573 mail_spool_name (char *inname)
 574 {
 575   struct stat stat1, stat2;
 576   char *indir, *fname;
 577   int status;
 578
 579   if (! (fname = strrchr (inname, '/')))
 580     return NULL;
 581
 582   fname++;
 583
 584   if (stat (MAILDIR, &stat1) < 0)
 585     return NULL;
 586
 587   indir = (char *) xmalloc (fname - inname + 1);
 588   strncpy (indir, inname, fname - inname);
 589   indir[fname-inname] = '\0';
 590
 591
 592   status = stat (indir, &stat2);
 593
 594   free (indir);
 595
 596   if (status < 0)
 597     return NULL;
 598
 599   if (stat1.st_dev == stat2.st_dev
 600       && stat1.st_ino == stat2.st_ino)
 601     return fname;
 602
 603   return NULL;
 604 }
 605 #endif /* MAIL_USE_MAILLOCK */
 606 \f
 607 /* Print error message and exit.  */
 608
 609 static void
 610 fatal (const char *s1, const char *s2, const char *s3)
 611 {
 612   if (delete_lockname)
 613     unlink (delete_lockname);
 614   error (s1, s2, s3);
 615   exit (EXIT_FAILURE);
 616 }
 617
 618 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 619    are args for it or null. */
 620
 621 static void
 622 error (const char *s1, const char *s2, const char *s3)
 623 {
 624   fprintf (stderr, "movemail: ");
 625   if (s3)
 626     fprintf (stderr, s1, s2, s3);
 627   else if (s2)
 628     fprintf (stderr, s1, s2);
 629   else
 630     fprintf (stderr, "%s", s1);
 631   fprintf (stderr, "\n");
 632 }
 633
 634 static void
 635 pfatal_with_name (char *name)
 636 {
 637   fatal ("%s for %s", strerror (errno), name);
 638 }
 639
 640 static void
 641 pfatal_and_delete (char *name)
 642 {
 643   char *s = strerror (errno);
 644   unlink (name);
 645   fatal ("%s for %s", s, name);
 646 }
 647
 648 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 649
 650 static char *
 651 concat (const char *s1, const char *s2, const char *s3)
 652 {
 653   size_t 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 static long *
 667 xmalloc (unsigned int size)
 668 {
 669   long *result = (long *) malloc (size);
 670   if (!result)
 671     fatal ("virtual memory exhausted", 0, 0);
 672   return result;
 673 }
 674 \f
 675 /* This is the guts of the interface to the Post Office Protocol.  */
 676
 677 #ifdef MAIL_USE_POP
 678
 679 #ifndef WINDOWSNT
 680 #include <sys/socket.h>
 681 #include <netinet/in.h>
 682 #include <netdb.h>
 683 #else
 684 #undef _WINSOCKAPI_
 685 #include <winsock.h>
 686 #endif
 687 #include <pwd.h>
 688 #include <string.h>
 689
 690 #define NOTOK (-1)
 691 #define OK 0
 692
 693 static char Errmsg[200];        /* POP errors, at least, can exceed
 694                                    the original length of 80.  */
 695
 696 /*
 697  * The full valid syntax for a POP mailbox specification for movemail
 698  * is "po:username:hostname".  The ":hostname" is optional; if it is
 699  * omitted, the MAILHOST environment variable will be consulted.  Note
 700  * that by the time popmail() is called the "po:" has been stripped
 701  * off of the front of the mailbox name.
 702  *
 703  * If the mailbox is in the form "po:username:hostname", then it is
 704  * modified by this function -- the second colon is replaced by a
 705  * null.
 706  *
 707  * Return a value suitable for passing to `exit'.
 708  */
 709
 710 static int
 711 popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order)
 712 {
 713   int nmsgs, nbytes;
 714   register int i;
 715   int mbfi;
 716   FILE *mbf;
 717   char *getenv (const char *);
 718   popserver server;
 719   int start, end, increment;
 720   char *user, *hostname;
 721
 722   user = mailbox;
 723   if ((hostname = strchr (mailbox, ':')))
 724     *hostname++ = '\0';
 725
 726   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 727   if (! server)
 728     {
 729       error ("Error connecting to POP server: %s", pop_error, 0);
 730       return EXIT_FAILURE;
 731     }
 732
 733   if (pop_stat (server, &nmsgs, &nbytes))
 734     {
 735       error ("Error getting message count from POP server: %s", pop_error, 0);
 736       return EXIT_FAILURE;
 737     }
 738
 739   if (!nmsgs)
 740     {
 741       pop_close (server);
 742       return EXIT_SUCCESS;
 743     }
 744
 745   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 746   if (mbfi < 0)
 747     {
 748       pop_close (server);
 749       error ("Error in open: %s, %s", strerror (errno), outfile);
 750       return EXIT_FAILURE;
 751     }
 752
 753   if (fchown (mbfi, getuid (), -1) != 0)
 754     {
 755       int fchown_errno = errno;
 756       struct stat st;
 757       if (fstat (mbfi, &st) != 0 || st.st_uid != getuid ())
 758         {
 759           pop_close (server);
 760           error ("Error in fchown: %s, %s", strerror (fchown_errno), outfile);
 761           return EXIT_FAILURE;
 762         }
 763     }
 764
 765   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 766     {
 767       pop_close (server);
 768       error ("Error in fdopen: %s", strerror (errno), 0);
 769       close (mbfi);
 770       unlink (outfile);
 771       return EXIT_FAILURE;
 772     }
 773
 774   if (reverse_order)
 775     {
 776       start = nmsgs;
 777       end = 1;
 778       increment = -1;
 779     }
 780   else
 781     {
 782       start = 1;
 783       end = nmsgs;
 784       increment = 1;
 785     }
 786
 787   for (i = start; i * increment <= end * increment; i += increment)
 788     {
 789       mbx_delimit_begin (mbf);
 790       if (pop_retr (server, i, mbf) != OK)
 791         {
 792           error ("%s", Errmsg, 0);
 793           close (mbfi);
 794           return EXIT_FAILURE;
 795         }
 796       mbx_delimit_end (mbf);
 797       fflush (mbf);
 798       if (ferror (mbf))
 799         {
 800           error ("Error in fflush: %s", strerror (errno), 0);
 801           pop_close (server);
 802           close (mbfi);
 803           return EXIT_FAILURE;
 804         }
 805     }
 806
 807   /* On AFS, a call to write only modifies the file in the local
 808    *     workstation's AFS cache.  The changes are not written to the server
 809    *      until a call to fsync or close is made.  Users with AFS home
 810    *      directories have lost mail when over quota because these checks were
 811    *      not made in previous versions of movemail. */
 812
 813 #ifdef BSD_SYSTEM
 814   if (fsync (mbfi) < 0)
 815     {
 816       error ("Error in fsync: %s", strerror (errno), 0);
 817       return EXIT_FAILURE;
 818     }
 819 #endif
 820
 821   if (close (mbfi) == -1)
 822     {
 823       error ("Error in close: %s", strerror (errno), 0);
 824       return EXIT_FAILURE;
 825     }
 826
 827   if (! preserve)
 828     for (i = 1; i <= nmsgs; i++)
 829       {
 830         if (pop_delete (server, i))
 831           {
 832             error ("Error from POP server: %s", pop_error, 0);
 833             pop_close (server);
 834             return EXIT_FAILURE;
 835           }
 836       }
 837
 838   if (pop_quit (server))
 839     {
 840       error ("Error from POP server: %s", pop_error, 0);
 841       return EXIT_FAILURE;
 842     }
 843
 844   return EXIT_SUCCESS;
 845 }
 846
 847 static int
 848 pop_retr (popserver server, int msgno, FILE *arg)
 849 {
 850   char *line;
 851   int ret;
 852
 853   if (pop_retrieve_first (server, msgno, &line))
 854     {
 855       char *msg = concat ("Error from POP server: ", pop_error, "");
 856       strncpy (Errmsg, msg, sizeof (Errmsg));
 857       Errmsg[sizeof (Errmsg)-1] = '\0';
 858       free (msg);
 859       return (NOTOK);
 860     }
 861
 862   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 863     {
 864       if (! line)
 865         break;
 866
 867       if (mbx_write (line, ret, arg) != OK)
 868         {
 869           strcpy (Errmsg, strerror (errno));
 870           pop_close (server);
 871           return (NOTOK);
 872         }
 873     }
 874
 875   if (ret)
 876     {
 877       char *msg = concat ("Error from POP server: ", pop_error, "");
 878       strncpy (Errmsg, msg, sizeof (Errmsg));
 879       Errmsg[sizeof (Errmsg)-1] = '\0';
 880       free (msg);
 881       return (NOTOK);
 882     }
 883
 884   return (OK);
 885 }
 886
 887 static int
 888 mbx_write (char *line, int len, FILE *mbf)
 889 {
 890 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 891   /* Do this as a macro instead of using strcmp to save on execution time. */
 892   # define IS_FROM_LINE(a) ((a[0] == 'F')       \
 893                             && (a[1] == 'r')    \
 894                             && (a[2] == 'o')    \
 895                             && (a[3] == 'm')    \
 896                             && (a[4] == ' '))
 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 static int
 918 mbx_delimit_begin (FILE *mbf)
 919 {
 920   time_t now;
 921   struct tm *ltime;
 922   char fromline[40] = "From movemail ";
 923
 924   now = time (NULL);
 925   ltime = localtime (&now);
 926
 927   strcat (fromline, asctime (ltime));
 928
 929   if (fputs (fromline, mbf) == EOF)
 930     return (NOTOK);
 931   return (OK);
 932 }
 933
 934 static int
 935 mbx_delimit_end (FILE *mbf)
 936 {
 937   if (putc ('\n', mbf) == EOF)
 938     return (NOTOK);
 939   return (OK);
 940 }
 941
 942 #endif /* MAIL_USE_POP */
 943 \f
 944 #ifndef HAVE_STRERROR
 945 char *
 946 strerror (errnum)
 947      int errnum;
 948 {
 949   extern char *sys_errlist[];
 950   extern int sys_nerr;
 951
 952   if (errnum >= 0 && errnum < sys_nerr)
 953     return sys_errlist[errnum];
 954   return (char *) "Unknown error";
 955 }
 956
 957 #endif /* ! HAVE_STRERROR */
 958
 959
 960 /* movemail.c ends here */