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-2012
   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               error ("error while creating what would become the lock file",
 329                      0, 0);
 330               errno = mkstemp_errno;
 331               pfatal_with_name (tempname);
 332             }
 333           close (desc);
 334
 335           tem = link (tempname, lockname);
 336
 337 #ifdef EPERM
 338           if (tem < 0 && errno == EPERM)
 339             fatal ("Unable to create hard link between %s and %s",
 340                    tempname, lockname);
 341 #endif
 342
 343           unlink (tempname);
 344           if (tem >= 0)
 345             break;
 346           sleep (1);
 347
 348           /* If lock file is five minutes old, unlock it.
 349              Five minutes should be good enough to cope with crashes
 350              and wedgitude, and long enough to avoid being fooled
 351              by time differences between machines.  */
 352           if (stat (lockname, &st) >= 0)
 353             {
 354               time_t now = time (0);
 355               if (st.st_ctime < now - 300)
 356                 unlink (lockname);
 357             }
 358         }
 359
 360       delete_lockname = lockname;
 361     }
 362 #endif /* not MAIL_USE_SYSTEM_LOCK */
 363 #endif /* not MAIL_USE_MMDF */
 364
 365   if (fork () == 0)
 366     {
 367       int lockcount = 0;
 368       int status = 0;
 369 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 370       time_t touched_lock;
 371 # ifdef lint
 372       touched_lock = 0;
 373 # endif
 374 #endif
 375
 376       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 377         fatal ("Failed to drop privileges", 0, 0);
 378
 379 #ifndef MAIL_USE_MMDF
 380 #ifdef MAIL_USE_SYSTEM_LOCK
 381       indesc = open (inname, O_RDWR);
 382 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 383       indesc = open (inname, O_RDONLY);
 384 #endif /* not MAIL_USE_SYSTEM_LOCK */
 385 #else  /* MAIL_USE_MMDF */
 386       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 387 #endif /* MAIL_USE_MMDF */
 388
 389       if (indesc < 0)
 390         pfatal_with_name (inname);
 391
 392 #ifdef BSD_SYSTEM
 393       /* In case movemail is setuid to root, make sure the user can
 394          read the output file.  */
 395       /* This is desirable for all systems
 396          but I don't want to assume all have the umask system call */
 397       umask (umask (0) & 0333);
 398 #endif /* BSD_SYSTEM */
 399       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 400       if (outdesc < 0)
 401         pfatal_with_name (outname);
 402
 403       if (setregid (-1, priv_gid) < 0)
 404         fatal ("Failed to regain privileges", 0, 0);
 405
 406       /* This label exists so we can retry locking
 407          after a delay, if it got EAGAIN or EBUSY.  */
 408     retry_lock:
 409
 410       /* Try to lock it.  */
 411 #ifdef MAIL_USE_MAILLOCK
 412       if (spool_name)
 413         {
 414           /* The "0 - " is to make it a negative number if maillock returns
 415              non-zero. */
 416           status = 0 - maillock (spool_name, 1);
 417 #ifdef HAVE_TOUCHLOCK
 418           touched_lock = time (0);
 419 #endif
 420           lockcount = 5;
 421         }
 422       else
 423 #endif /* MAIL_USE_MAILLOCK */
 424         {
 425 #ifdef MAIL_USE_SYSTEM_LOCK
 426 #ifdef MAIL_USE_LOCKF
 427           status = lockf (indesc, F_LOCK, 0);
 428 #else /* not MAIL_USE_LOCKF */
 429 #ifdef WINDOWSNT
 430           status = locking (indesc, LK_RLCK, -1L);
 431 #else
 432           status = flock (indesc, LOCK_EX);
 433 #endif
 434 #endif /* not MAIL_USE_LOCKF */
 435 #endif /* MAIL_USE_SYSTEM_LOCK */
 436         }
 437
 438       /* If it fails, retry up to 5 times
 439          for certain failure codes.  */
 440       if (status < 0)
 441         {
 442           if (++lockcount <= 5)
 443             {
 444 #ifdef EAGAIN
 445               if (errno == EAGAIN)
 446                 {
 447                   sleep (1);
 448                   goto retry_lock;
 449                 }
 450 #endif
 451 #ifdef EBUSY
 452               if (errno == EBUSY)
 453                 {
 454                   sleep (1);
 455                   goto retry_lock;
 456                 }
 457 #endif
 458             }
 459
 460           pfatal_with_name (inname);
 461         }
 462
 463       {
 464         char buf[1024];
 465
 466         while (1)
 467           {
 468             nread = read (indesc, buf, sizeof buf);
 469             if (nread < 0)
 470               pfatal_with_name (inname);
 471             if (nread != write (outdesc, buf, nread))
 472               {
 473                 int saved_errno = errno;
 474                 unlink (outname);
 475                 errno = saved_errno;
 476                 pfatal_with_name (outname);
 477               }
 478             if (nread < sizeof buf)
 479               break;
 480 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 481             if (spool_name)
 482               {
 483                 time_t now = time (0);
 484                 if (now - touched_lock > 60)
 485                   {
 486                     touchlock ();
 487                     touched_lock = now;
 488                   }
 489               }
 490 #endif /* MAIL_USE_MAILLOCK */
 491           }
 492       }
 493
 494 #ifdef BSD_SYSTEM
 495       if (fsync (outdesc) < 0)
 496         pfatal_and_delete (outname);
 497 #endif
 498
 499       /* Prevent symlink attacks truncating other users' mailboxes */
 500       if (setregid (-1, real_gid) < 0)
 501         fatal ("Failed to drop privileges", 0, 0);
 502
 503       /* Check to make sure no errors before we zap the inbox.  */
 504       if (close (outdesc) != 0)
 505         pfatal_and_delete (outname);
 506
 507 #ifdef MAIL_USE_SYSTEM_LOCK
 508       if (! preserve_mail)
 509         {
 510           if (ftruncate (indesc, 0L) != 0)
 511             pfatal_with_name (inname);
 512         }
 513 #endif /* MAIL_USE_SYSTEM_LOCK */
 514
 515 #ifdef MAIL_USE_MMDF
 516       lk_close (indesc, 0, 0, 0);
 517 #else
 518       close (indesc);
 519 #endif
 520
 521 #ifndef MAIL_USE_SYSTEM_LOCK
 522       if (! preserve_mail)
 523         {
 524           /* Delete the input file; if we can't, at least get rid of its
 525              contents.  */
 526 #ifdef MAIL_UNLINK_SPOOL
 527           /* This is generally bad to do, because it destroys the permissions
 528              that were set on the file.  Better to just empty the file.  */
 529           if (unlink (inname) < 0 && errno != ENOENT)
 530 #endif /* MAIL_UNLINK_SPOOL */
 531             creat (inname, 0600);
 532         }
 533 #endif /* not MAIL_USE_SYSTEM_LOCK */
 534
 535       /* End of mailbox truncation */
 536       if (setregid (-1, priv_gid) < 0)
 537         fatal ("Failed to regain privileges", 0, 0);
 538
 539 #ifdef MAIL_USE_MAILLOCK
 540       /* This has to occur in the child, i.e., in the process that
 541          acquired the lock! */
 542       if (spool_name)
 543         mailunlock ();
 544 #endif
 545       exit (EXIT_SUCCESS);
 546     }
 547
 548   wait (&wait_status);
 549   if (!WIFEXITED (wait_status))
 550     exit (EXIT_FAILURE);
 551   else if (WRETCODE (wait_status) != 0)
 552     exit (WRETCODE (wait_status));
 553
 554 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 555 #ifdef MAIL_USE_MAILLOCK
 556   if (! spool_name)
 557 #endif /* MAIL_USE_MAILLOCK */
 558     unlink (lockname);
 559 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 560
 561 #endif /* ! DISABLE_DIRECT_ACCESS */
 562
 563   return EXIT_SUCCESS;
 564 }
 565
 566 #ifdef MAIL_USE_MAILLOCK
 567 /* This function uses stat to confirm that the mail directory is
 568    identical to the directory of the input file, rather than just
 569    string-comparing the two paths, because one or both of them might
 570    be symbolic links pointing to some other directory. */
 571 static char *
 572 mail_spool_name (char *inname)
 573 {
 574   struct stat stat1, stat2;
 575   char *indir, *fname;
 576   int status;
 577
 578   if (! (fname = strrchr (inname, '/')))
 579     return NULL;
 580
 581   fname++;
 582
 583   if (stat (MAILDIR, &stat1) < 0)
 584     return NULL;
 585
 586   indir = (char *) xmalloc (fname - inname + 1);
 587   strncpy (indir, inname, fname - inname);
 588   indir[fname-inname] = '\0';
 589
 590
 591   status = stat (indir, &stat2);
 592
 593   free (indir);
 594
 595   if (status < 0)
 596     return NULL;
 597
 598   if (stat1.st_dev == stat2.st_dev
 599       && stat1.st_ino == stat2.st_ino)
 600     return fname;
 601
 602   return NULL;
 603 }
 604 #endif /* MAIL_USE_MAILLOCK */
 605 \f
 606 /* Print error message and exit.  */
 607
 608 static void
 609 fatal (const char *s1, const char *s2, const char *s3)
 610 {
 611   if (delete_lockname)
 612     unlink (delete_lockname);
 613   error (s1, s2, s3);
 614   exit (EXIT_FAILURE);
 615 }
 616
 617 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 618    are args for it or null. */
 619
 620 static void
 621 error (const char *s1, const char *s2, const char *s3)
 622 {
 623   fprintf (stderr, "movemail: ");
 624   if (s3)
 625     fprintf (stderr, s1, s2, s3);
 626   else if (s2)
 627     fprintf (stderr, s1, s2);
 628   else
 629     fprintf (stderr, "%s", s1);
 630   fprintf (stderr, "\n");
 631 }
 632
 633 static void
 634 pfatal_with_name (char *name)
 635 {
 636   fatal ("%s for %s", strerror (errno), name);
 637 }
 638
 639 static void
 640 pfatal_and_delete (char *name)
 641 {
 642   char *s = strerror (errno);
 643   unlink (name);
 644   fatal ("%s for %s", s, name);
 645 }
 646
 647 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 648
 649 static char *
 650 concat (const char *s1, const char *s2, const char *s3)
 651 {
 652   size_t len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 653   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 654
 655   strcpy (result, s1);
 656   strcpy (result + len1, s2);
 657   strcpy (result + len1 + len2, s3);
 658   *(result + len1 + len2 + len3) = 0;
 659
 660   return result;
 661 }
 662
 663 /* Like malloc but get fatal error if memory is exhausted.  */
 664
 665 static long *
 666 xmalloc (unsigned int size)
 667 {
 668   long *result = (long *) malloc (size);
 669   if (!result)
 670     fatal ("virtual memory exhausted", 0, 0);
 671   return result;
 672 }
 673 \f
 674 /* This is the guts of the interface to the Post Office Protocol.  */
 675
 676 #ifdef MAIL_USE_POP
 677
 678 #ifndef WINDOWSNT
 679 #include <sys/socket.h>
 680 #include <netinet/in.h>
 681 #include <netdb.h>
 682 #else
 683 #undef _WINSOCKAPI_
 684 #include <winsock.h>
 685 #endif
 686 #include <pwd.h>
 687 #include <string.h>
 688
 689 #define NOTOK (-1)
 690 #define OK 0
 691
 692 static char Errmsg[200];        /* POP errors, at least, can exceed
 693                                    the original length of 80.  */
 694
 695 /*
 696  * The full valid syntax for a POP mailbox specification for movemail
 697  * is "po:username:hostname".  The ":hostname" is optional; if it is
 698  * omitted, the MAILHOST environment variable will be consulted.  Note
 699  * that by the time popmail() is called the "po:" has been stripped
 700  * off of the front of the mailbox name.
 701  *
 702  * If the mailbox is in the form "po:username:hostname", then it is
 703  * modified by this function -- the second colon is replaced by a
 704  * null.
 705  *
 706  * Return a value suitable for passing to `exit'.
 707  */
 708
 709 static int
 710 popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order)
 711 {
 712   int nmsgs, nbytes;
 713   register int i;
 714   int mbfi;
 715   FILE *mbf;
 716   char *getenv (const char *);
 717   popserver server;
 718   int start, end, increment;
 719   char *user, *hostname;
 720
 721   user = mailbox;
 722   if ((hostname = strchr (mailbox, ':')))
 723     *hostname++ = '\0';
 724
 725   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 726   if (! server)
 727     {
 728       error ("Error connecting to POP server: %s", pop_error, 0);
 729       return EXIT_FAILURE;
 730     }
 731
 732   if (pop_stat (server, &nmsgs, &nbytes))
 733     {
 734       error ("Error getting message count from POP server: %s", pop_error, 0);
 735       return EXIT_FAILURE;
 736     }
 737
 738   if (!nmsgs)
 739     {
 740       pop_close (server);
 741       return EXIT_SUCCESS;
 742     }
 743
 744   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 745   if (mbfi < 0)
 746     {
 747       pop_close (server);
 748       error ("Error in open: %s, %s", strerror (errno), outfile);
 749       return EXIT_FAILURE;
 750     }
 751
 752   if (fchown (mbfi, getuid (), -1) != 0)
 753     {
 754       int fchown_errno = errno;
 755       struct stat st;
 756       if (fstat (mbfi, &st) != 0 || st.st_uid != getuid ())
 757         {
 758           pop_close (server);
 759           error ("Error in fchown: %s, %s", strerror (fchown_errno), outfile);
 760           return EXIT_FAILURE;
 761         }
 762     }
 763
 764   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 765     {
 766       pop_close (server);
 767       error ("Error in fdopen: %s", strerror (errno), 0);
 768       close (mbfi);
 769       unlink (outfile);
 770       return EXIT_FAILURE;
 771     }
 772
 773   if (reverse_order)
 774     {
 775       start = nmsgs;
 776       end = 1;
 777       increment = -1;
 778     }
 779   else
 780     {
 781       start = 1;
 782       end = nmsgs;
 783       increment = 1;
 784     }
 785
 786   for (i = start; i * increment <= end * increment; i += increment)
 787     {
 788       mbx_delimit_begin (mbf);
 789       if (pop_retr (server, i, mbf) != OK)
 790         {
 791           error ("%s", Errmsg, 0);
 792           close (mbfi);
 793           return EXIT_FAILURE;
 794         }
 795       mbx_delimit_end (mbf);
 796       fflush (mbf);
 797       if (ferror (mbf))
 798         {
 799           error ("Error in fflush: %s", strerror (errno), 0);
 800           pop_close (server);
 801           close (mbfi);
 802           return EXIT_FAILURE;
 803         }
 804     }
 805
 806   /* On AFS, a call to write only modifies the file in the local
 807    *     workstation's AFS cache.  The changes are not written to the server
 808    *      until a call to fsync or close is made.  Users with AFS home
 809    *      directories have lost mail when over quota because these checks were
 810    *      not made in previous versions of movemail. */
 811
 812 #ifdef BSD_SYSTEM
 813   if (fsync (mbfi) < 0)
 814     {
 815       error ("Error in fsync: %s", strerror (errno), 0);
 816       return EXIT_FAILURE;
 817     }
 818 #endif
 819
 820   if (close (mbfi) == -1)
 821     {
 822       error ("Error in close: %s", strerror (errno), 0);
 823       return EXIT_FAILURE;
 824     }
 825
 826   if (! preserve)
 827     for (i = 1; i <= nmsgs; i++)
 828       {
 829         if (pop_delete (server, i))
 830           {
 831             error ("Error from POP server: %s", pop_error, 0);
 832             pop_close (server);
 833             return EXIT_FAILURE;
 834           }
 835       }
 836
 837   if (pop_quit (server))
 838     {
 839       error ("Error from POP server: %s", pop_error, 0);
 840       return EXIT_FAILURE;
 841     }
 842
 843   return EXIT_SUCCESS;
 844 }
 845
 846 static int
 847 pop_retr (popserver server, int msgno, FILE *arg)
 848 {
 849   char *line;
 850   int ret;
 851
 852   if (pop_retrieve_first (server, msgno, &line))
 853     {
 854       char *msg = concat ("Error from POP server: ", pop_error, "");
 855       strncpy (Errmsg, msg, sizeof (Errmsg));
 856       Errmsg[sizeof (Errmsg)-1] = '\0';
 857       free (msg);
 858       return (NOTOK);
 859     }
 860
 861   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 862     {
 863       if (! line)
 864         break;
 865
 866       if (mbx_write (line, ret, arg) != OK)
 867         {
 868           strcpy (Errmsg, strerror (errno));
 869           pop_close (server);
 870           return (NOTOK);
 871         }
 872     }
 873
 874   if (ret)
 875     {
 876       char *msg = concat ("Error from POP server: ", pop_error, "");
 877       strncpy (Errmsg, msg, sizeof (Errmsg));
 878       Errmsg[sizeof (Errmsg)-1] = '\0';
 879       free (msg);
 880       return (NOTOK);
 881     }
 882
 883   return (OK);
 884 }
 885
 886 static int
 887 mbx_write (char *line, int len, FILE *mbf)
 888 {
 889 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 890   /* Do this as a macro instead of using strcmp to save on execution time. */
 891   # define IS_FROM_LINE(a) ((a[0] == 'F')       \
 892                             && (a[1] == 'r')    \
 893                             && (a[2] == 'o')    \
 894                             && (a[3] == 'm')    \
 895                             && (a[4] == ' '))
 896   if (IS_FROM_LINE (line))
 897     {
 898       if (fputc ('>', mbf) == EOF)
 899         return (NOTOK);
 900     }
 901 #endif
 902   if (line[0] == '\037')
 903     {
 904       if (fputs ("^_", mbf) == EOF)
 905         return (NOTOK);
 906       line++;
 907       len--;
 908     }
 909   if (fwrite (line, 1, len, mbf) != len)
 910     return (NOTOK);
 911   if (fputc (0x0a, mbf) == EOF)
 912     return (NOTOK);
 913   return (OK);
 914 }
 915
 916 static int
 917 mbx_delimit_begin (FILE *mbf)
 918 {
 919   time_t now;
 920   struct tm *ltime;
 921   char fromline[40] = "From movemail ";
 922
 923   now = time (NULL);
 924   ltime = localtime (&now);
 925
 926   strcat (fromline, asctime (ltime));
 927
 928   if (fputs (fromline, mbf) == EOF)
 929     return (NOTOK);
 930   return (OK);
 931 }
 932
 933 static int
 934 mbx_delimit_end (FILE *mbf)
 935 {
 936   if (putc ('\n', mbf) == EOF)
 937     return (NOTOK);
 938   return (OK);
 939 }
 940
 941 #endif /* MAIL_USE_POP */
 942 \f
 943 #ifndef HAVE_STRERROR
 944 char *
 945 strerror (errnum)
 946      int errnum;
 947 {
 948   extern char *sys_errlist[];
 949   extern int sys_nerr;
 950
 951   if (errnum >= 0 && errnum < sys_nerr)
 952     return sys_errlist[errnum];
 953   return (char *) "Unknown error";
 954 }
 955
 956 #endif /* ! HAVE_STRERROR */
 957
 958
 959 /* movemail.c ends here */