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 #ifdef HAVE_STRING_H
  72 #include <string.h>
  73 #endif
  74 #include "syswait.h"
  75 #ifdef MAIL_USE_POP
  76 #include "pop.h"
  77 #endif
  78
  79 #ifdef MSDOS
  80 #undef access
  81 #endif /* MSDOS */
  82
  83 #ifdef WINDOWSNT
  84 #include "ntlib.h"
  85 #undef access
  86 #undef unlink
  87 #define fork() 0
  88 #define wait(var) (*(var) = 0)
  89 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
  90    though the locking call succeeds (and indeed blocks local access from
  91    other NT programs).  If you have direct file access using an NFS
  92    client or something other than Samba, the locking call might work
  93    properly - make sure it does before you enable this!
  94
  95    [18-Feb-97 andrewi] I now believe my comment above to be incorrect,
  96    since it was based on a misunderstanding of how locking calls are
  97    implemented and used on Unix.  */
  98 //#define DISABLE_DIRECT_ACCESS
  99
 100 #include <fcntl.h>
 101 #endif /* WINDOWSNT */
 102
 103 #ifndef F_OK
 104 #define F_OK 0
 105 #define X_OK 1
 106 #define W_OK 2
 107 #define R_OK 4
 108 #endif
 109
 110 #ifdef WINDOWSNT
 111 #include <sys/locking.h>
 112 #endif
 113
 114 #ifdef MAIL_USE_LOCKF
 115 #define MAIL_USE_SYSTEM_LOCK
 116 #endif
 117
 118 #ifdef MAIL_USE_FLOCK
 119 #define MAIL_USE_SYSTEM_LOCK
 120 #endif
 121
 122 #ifdef MAIL_USE_MMDF
 123 extern int lk_open (), lk_close ();
 124 #endif
 125
 126 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
 127         (defined (HAVE_LIBMAIL) || defined (HAVE_LIBLOCKFILE)) && \
 128         defined (HAVE_MAILLOCK_H)
 129 #include <maillock.h>
 130 /* We can't use maillock unless we know what directory system mail
 131    files appear in. */
 132 #ifdef MAILDIR
 133 #define MAIL_USE_MAILLOCK
 134 static char *mail_spool_name ();
 135 #endif
 136 #endif
 137
 138 #ifndef HAVE_STRERROR
 139 char *strerror (int);
 140 #endif
 141
 142 static void fatal (const char *s1, const char *s2, const char *s3) NO_RETURN;
 143 static void error (const char *s1, const char *s2, const char *s3);
 144 static void pfatal_with_name (char *name) NO_RETURN;
 145 static void pfatal_and_delete (char *name) NO_RETURN;
 146 static char *concat (const char *s1, const char *s2, const char *s3);
 147 static long *xmalloc (unsigned int size);
 148 #ifdef MAIL_USE_POP
 149 static int popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order);
 150 static int pop_retr (popserver server, int msgno, FILE *arg);
 151 static int mbx_write (char *line, int len, FILE *mbf);
 152 static int mbx_delimit_begin (FILE *mbf);
 153 static int mbx_delimit_end (FILE *mbf);
 154 #endif
 155
 156 /* Nonzero means this is name of a lock file to delete on fatal error.  */
 157 static char *delete_lockname;
 158
 159 int
 160 main (int argc, char **argv)
 161 {
 162   char *inname, *outname;
 163   int indesc, outdesc;
 164   ssize_t nread;
 165   int wait_status;
 166   int c, preserve_mail = 0;
 167
 168 #ifndef MAIL_USE_SYSTEM_LOCK
 169   struct stat st;
 170   long now;
 171   int tem;
 172   char *lockname, *p;
 173   char *tempname;
 174   int desc;
 175 #endif /* not MAIL_USE_SYSTEM_LOCK */
 176
 177 #ifdef MAIL_USE_MAILLOCK
 178   char *spool_name;
 179 #endif
 180
 181 #ifdef MAIL_USE_POP
 182   int pop_reverse_order = 0;
 183 # define ARGSTR "pr"
 184 #else /* ! MAIL_USE_POP */
 185 # define ARGSTR "p"
 186 #endif /* MAIL_USE_POP */
 187
 188   uid_t real_gid = getgid();
 189   uid_t priv_gid = getegid();
 190
 191 #ifdef WINDOWSNT
 192   /* Ensure all file i/o is in binary mode. */
 193   _fmode = _O_BINARY;
 194 #endif
 195
 196   delete_lockname = 0;
 197
 198   while ((c = getopt (argc, argv, ARGSTR)) != EOF)
 199     {
 200       switch (c) {
 201 #ifdef MAIL_USE_POP
 202       case 'r':
 203         pop_reverse_order = 1;
 204         break;
 205 #endif
 206       case 'p':
 207         preserve_mail++;
 208         break;
 209       default:
 210         exit (EXIT_FAILURE);
 211       }
 212     }
 213
 214   if (
 215 #ifdef MAIL_USE_POP
 216       (argc - optind < 2) || (argc - optind > 3)
 217 #else
 218       (argc - optind != 2)
 219 #endif
 220       )
 221     {
 222 #ifdef MAIL_USE_POP
 223       fprintf (stderr, "Usage: movemail [-p] [-r] inbox destfile%s\n",
 224                " [POP-password]");
 225 #else
 226       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
 227 #endif
 228       exit (EXIT_FAILURE);
 229     }
 230
 231   inname = argv[optind];
 232   outname = argv[optind+1];
 233
 234 #ifdef MAIL_USE_MMDF
 235   mmdf_init (argv[0]);
 236 #endif
 237
 238   if (*outname == 0)
 239     fatal ("Destination file name is empty", 0, 0);
 240
 241 #ifdef MAIL_USE_POP
 242   if (!strncmp (inname, "po:", 3))
 243     {
 244       int status;
 245
 246       status = popmail (inname + 3, outname, preserve_mail,
 247                         (argc - optind == 3) ? argv[optind+2] : NULL,
 248                         pop_reverse_order);
 249       exit (status);
 250     }
 251
 252   if (setuid (getuid ()) < 0)
 253     fatal ("Failed to drop privileges", 0, 0);
 254
 255 #endif /* MAIL_USE_POP */
 256
 257 #ifndef DISABLE_DIRECT_ACCESS
 258 #ifndef MAIL_USE_MMDF
 259 #ifndef MAIL_USE_SYSTEM_LOCK
 260 #ifdef MAIL_USE_MAILLOCK
 261   spool_name = mail_spool_name (inname);
 262   if (! spool_name)
 263 #endif
 264     {
 265       #ifndef DIRECTORY_SEP
 266        #define DIRECTORY_SEP '/'
 267       #endif
 268       #ifndef IS_DIRECTORY_SEP
 269        #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
 270       #endif
 271
 272       /* Use a lock file named after our first argument with .lock appended:
 273          If it exists, the mail file is locked.  */
 274       /* Note: this locking mechanism is *required* by the mailer
 275          (on systems which use it) to prevent loss of mail.
 276
 277          On systems that use a lock file, extracting the mail without locking
 278          WILL occasionally cause loss of mail due to timing errors!
 279
 280          So, if creation of the lock file fails
 281          due to access permission on the mail spool directory,
 282          you simply MUST change the permission
 283          and/or make movemail a setgid program
 284          so it can create lock files properly.
 285
 286          You might also wish to verify that your system is one
 287          which uses lock files for this purpose.  Some systems use other methods.
 288
 289          If your system uses the `flock' system call for mail locking,
 290          define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
 291          and recompile movemail.  If the s- file for your system
 292          should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
 293          to bug-gnu-emacs@prep.ai.mit.edu so we can fix it.  */
 294
 295       lockname = concat (inname, ".lock", "");
 296       tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
 297       strcpy (tempname, inname);
 298       p = tempname + strlen (tempname);
 299       while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
 300         p--;
 301       *p = 0;
 302       strcpy (p, "EXXXXXX");
 303       mktemp (tempname);
 304       unlink (tempname);
 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           desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 311           if (desc < 0)
 312             {
 313               char *message = (char *) xmalloc (strlen (tempname) + 50);
 314               sprintf (message, "creating %s, which would become the lock file",
 315                        tempname);
 316               pfatal_with_name (message);
 317             }
 318           close (desc);
 319
 320           tem = link (tempname, lockname);
 321
 322 #ifdef EPERM
 323           if (tem < 0 && errno == EPERM)
 324             fatal ("Unable to create hard link between %s and %s",
 325                    tempname, lockname);
 326 #endif
 327
 328           unlink (tempname);
 329           if (tem >= 0)
 330             break;
 331           sleep (1);
 332
 333           /* If lock file is five minutes old, unlock it.
 334              Five minutes should be good enough to cope with crashes
 335              and wedgitude, and long enough to avoid being fooled
 336              by time differences between machines.  */
 337           if (stat (lockname, &st) >= 0)
 338             {
 339               now = time (0);
 340               if (st.st_ctime < now - 300)
 341                 unlink (lockname);
 342             }
 343         }
 344
 345       delete_lockname = lockname;
 346     }
 347 #endif /* not MAIL_USE_SYSTEM_LOCK */
 348 #endif /* not MAIL_USE_MMDF */
 349
 350   if (fork () == 0)
 351     {
 352       int lockcount = 0;
 353       int status = 0;
 354 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 355       time_t touched_lock, now;
 356 #endif
 357
 358       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 359         fatal ("Failed to drop privileges", 0, 0);
 360
 361 #ifndef MAIL_USE_MMDF
 362 #ifdef MAIL_USE_SYSTEM_LOCK
 363       indesc = open (inname, O_RDWR);
 364 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 365       indesc = open (inname, O_RDONLY);
 366 #endif /* not MAIL_USE_SYSTEM_LOCK */
 367 #else  /* MAIL_USE_MMDF */
 368       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 369 #endif /* MAIL_USE_MMDF */
 370
 371       if (indesc < 0)
 372         pfatal_with_name (inname);
 373
 374 #ifdef BSD_SYSTEM
 375       /* In case movemail is setuid to root, make sure the user can
 376          read the output file.  */
 377       /* This is desirable for all systems
 378          but I don't want to assume all have the umask system call */
 379       umask (umask (0) & 0333);
 380 #endif /* BSD_SYSTEM */
 381       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 382       if (outdesc < 0)
 383         pfatal_with_name (outname);
 384
 385       if (setregid (-1, priv_gid) < 0)
 386         fatal ("Failed to regain privileges", 0, 0);
 387
 388       /* This label exists so we can retry locking
 389          after a delay, if it got EAGAIN or EBUSY.  */
 390     retry_lock:
 391
 392       /* Try to lock it.  */
 393 #ifdef MAIL_USE_MAILLOCK
 394       if (spool_name)
 395         {
 396           /* The "0 - " is to make it a negative number if maillock returns
 397              non-zero. */
 398           status = 0 - maillock (spool_name, 1);
 399 #ifdef HAVE_TOUCHLOCK
 400           touched_lock = time (0);
 401 #endif
 402           lockcount = 5;
 403         }
 404       else
 405 #endif /* MAIL_USE_MAILLOCK */
 406         {
 407 #ifdef MAIL_USE_SYSTEM_LOCK
 408 #ifdef MAIL_USE_LOCKF
 409           status = lockf (indesc, F_LOCK, 0);
 410 #else /* not MAIL_USE_LOCKF */
 411 #ifdef WINDOWSNT
 412           status = locking (indesc, LK_RLCK, -1L);
 413 #else
 414           status = flock (indesc, LOCK_EX);
 415 #endif
 416 #endif /* not MAIL_USE_LOCKF */
 417 #endif /* MAIL_USE_SYSTEM_LOCK */
 418         }
 419
 420       /* If it fails, retry up to 5 times
 421          for certain failure codes.  */
 422       if (status < 0)
 423         {
 424           if (++lockcount <= 5)
 425             {
 426 #ifdef EAGAIN
 427               if (errno == EAGAIN)
 428                 {
 429                   sleep (1);
 430                   goto retry_lock;
 431                 }
 432 #endif
 433 #ifdef EBUSY
 434               if (errno == EBUSY)
 435                 {
 436                   sleep (1);
 437                   goto retry_lock;
 438                 }
 439 #endif
 440             }
 441
 442           pfatal_with_name (inname);
 443         }
 444
 445       {
 446         char buf[1024];
 447
 448         while (1)
 449           {
 450             nread = read (indesc, buf, sizeof buf);
 451             if (nread < 0)
 452               pfatal_with_name (inname);
 453             if (nread != write (outdesc, buf, nread))
 454               {
 455                 int saved_errno = errno;
 456                 unlink (outname);
 457                 errno = saved_errno;
 458                 pfatal_with_name (outname);
 459               }
 460             if (nread < sizeof buf)
 461               break;
 462 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 463             if (spool_name)
 464               {
 465                 now = time (0);
 466                 if (now - touched_lock > 60)
 467                   {
 468                     touchlock ();
 469                     touched_lock = now;
 470                   }
 471               }
 472 #endif /* MAIL_USE_MAILLOCK */
 473           }
 474       }
 475
 476 #ifdef BSD_SYSTEM
 477       if (fsync (outdesc) < 0)
 478         pfatal_and_delete (outname);
 479 #endif
 480
 481       /* Prevent symlink attacks truncating other users' mailboxes */
 482       if (setregid (-1, real_gid) < 0)
 483         fatal ("Failed to drop privileges", 0, 0);
 484
 485       /* Check to make sure no errors before we zap the inbox.  */
 486       if (close (outdesc) != 0)
 487         pfatal_and_delete (outname);
 488
 489 #ifdef MAIL_USE_SYSTEM_LOCK
 490       if (! preserve_mail)
 491         {
 492           if (ftruncate (indesc, 0L) != 0)
 493             pfatal_with_name (inname);
 494         }
 495 #endif /* MAIL_USE_SYSTEM_LOCK */
 496
 497 #ifdef MAIL_USE_MMDF
 498       lk_close (indesc, 0, 0, 0);
 499 #else
 500       close (indesc);
 501 #endif
 502
 503 #ifndef MAIL_USE_SYSTEM_LOCK
 504       if (! preserve_mail)
 505         {
 506           /* Delete the input file; if we can't, at least get rid of its
 507              contents.  */
 508 #ifdef MAIL_UNLINK_SPOOL
 509           /* This is generally bad to do, because it destroys the permissions
 510              that were set on the file.  Better to just empty the file.  */
 511           if (unlink (inname) < 0 && errno != ENOENT)
 512 #endif /* MAIL_UNLINK_SPOOL */
 513             creat (inname, 0600);
 514         }
 515 #endif /* not MAIL_USE_SYSTEM_LOCK */
 516
 517       /* End of mailbox truncation */
 518       if (setregid (-1, priv_gid) < 0)
 519         fatal ("Failed to regain privileges", 0, 0);
 520
 521 #ifdef MAIL_USE_MAILLOCK
 522       /* This has to occur in the child, i.e., in the process that
 523          acquired the lock! */
 524       if (spool_name)
 525         mailunlock ();
 526 #endif
 527       exit (EXIT_SUCCESS);
 528     }
 529
 530   wait (&wait_status);
 531   if (!WIFEXITED (wait_status))
 532     exit (EXIT_FAILURE);
 533   else if (WRETCODE (wait_status) != 0)
 534     exit (WRETCODE (wait_status));
 535
 536 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 537 #ifdef MAIL_USE_MAILLOCK
 538   if (! spool_name)
 539 #endif /* MAIL_USE_MAILLOCK */
 540     unlink (lockname);
 541 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 542
 543 #endif /* ! DISABLE_DIRECT_ACCESS */
 544
 545   return EXIT_SUCCESS;
 546 }
 547
 548 #ifdef MAIL_USE_MAILLOCK
 549 /* This function uses stat to confirm that the mail directory is
 550    identical to the directory of the input file, rather than just
 551    string-comparing the two paths, because one or both of them might
 552    be symbolic links pointing to some other directory. */
 553 static char *
 554 mail_spool_name (char *inname)
 555 {
 556   struct stat stat1, stat2;
 557   char *indir, *fname;
 558   int status;
 559
 560   if (! (fname = strrchr (inname, '/')))
 561     return NULL;
 562
 563   fname++;
 564
 565   if (stat (MAILDIR, &stat1) < 0)
 566     return NULL;
 567
 568   indir = (char *) xmalloc (fname - inname + 1);
 569   strncpy (indir, inname, fname - inname);
 570   indir[fname-inname] = '\0';
 571
 572
 573   status = stat (indir, &stat2);
 574
 575   free (indir);
 576
 577   if (status < 0)
 578     return NULL;
 579
 580   if (stat1.st_dev == stat2.st_dev
 581       && stat1.st_ino == stat2.st_ino)
 582     return fname;
 583
 584   return NULL;
 585 }
 586 #endif /* MAIL_USE_MAILLOCK */
 587 \f
 588 /* Print error message and exit.  */
 589
 590 static void
 591 fatal (const char *s1, const char *s2, const char *s3)
 592 {
 593   if (delete_lockname)
 594     unlink (delete_lockname);
 595   error (s1, s2, s3);
 596   exit (EXIT_FAILURE);
 597 }
 598
 599 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 600    are args for it or null. */
 601
 602 static void
 603 error (const char *s1, const char *s2, const char *s3)
 604 {
 605   fprintf (stderr, "movemail: ");
 606   if (s3)
 607     fprintf (stderr, s1, s2, s3);
 608   else if (s2)
 609     fprintf (stderr, s1, s2);
 610   else
 611     fprintf (stderr, "%s", s1);
 612   fprintf (stderr, "\n");
 613 }
 614
 615 static void
 616 pfatal_with_name (char *name)
 617 {
 618   fatal ("%s for %s", strerror (errno), name);
 619 }
 620
 621 static void
 622 pfatal_and_delete (char *name)
 623 {
 624   char *s = strerror (errno);
 625   unlink (name);
 626   fatal ("%s for %s", s, name);
 627 }
 628
 629 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 630
 631 static char *
 632 concat (const char *s1, const char *s2, const char *s3)
 633 {
 634   size_t len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 635   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 636
 637   strcpy (result, s1);
 638   strcpy (result + len1, s2);
 639   strcpy (result + len1 + len2, s3);
 640   *(result + len1 + len2 + len3) = 0;
 641
 642   return result;
 643 }
 644
 645 /* Like malloc but get fatal error if memory is exhausted.  */
 646
 647 static long *
 648 xmalloc (unsigned int size)
 649 {
 650   long *result = (long *) malloc (size);
 651   if (!result)
 652     fatal ("virtual memory exhausted", 0, 0);
 653   return result;
 654 }
 655 \f
 656 /* This is the guts of the interface to the Post Office Protocol.  */
 657
 658 #ifdef MAIL_USE_POP
 659
 660 #ifndef WINDOWSNT
 661 #include <sys/socket.h>
 662 #include <netinet/in.h>
 663 #include <netdb.h>
 664 #else
 665 #undef _WINSOCKAPI_
 666 #include <winsock.h>
 667 #endif
 668 #include <pwd.h>
 669 #include <string.h>
 670
 671 #define NOTOK (-1)
 672 #define OK 0
 673
 674 static char Errmsg[200];        /* POP errors, at least, can exceed
 675                                    the original length of 80.  */
 676
 677 /*
 678  * The full valid syntax for a POP mailbox specification for movemail
 679  * is "po:username:hostname".  The ":hostname" is optional; if it is
 680  * omitted, the MAILHOST environment variable will be consulted.  Note
 681  * that by the time popmail() is called the "po:" has been stripped
 682  * off of the front of the mailbox name.
 683  *
 684  * If the mailbox is in the form "po:username:hostname", then it is
 685  * modified by this function -- the second colon is replaced by a
 686  * null.
 687  *
 688  * Return a value suitable for passing to `exit'.
 689  */
 690
 691 static int
 692 popmail (char *mailbox, char *outfile, int preserve, char *password, int reverse_order)
 693 {
 694   int nmsgs, nbytes;
 695   register int i;
 696   int mbfi;
 697   FILE *mbf;
 698   char *getenv (const char *);
 699   popserver server;
 700   int start, end, increment;
 701   char *user, *hostname;
 702
 703   user = mailbox;
 704   if ((hostname = strchr (mailbox, ':')))
 705     *hostname++ = '\0';
 706
 707   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 708   if (! server)
 709     {
 710       error ("Error connecting to POP server: %s", pop_error, 0);
 711       return EXIT_FAILURE;
 712     }
 713
 714   if (pop_stat (server, &nmsgs, &nbytes))
 715     {
 716       error ("Error getting message count from POP server: %s", pop_error, 0);
 717       return EXIT_FAILURE;
 718     }
 719
 720   if (!nmsgs)
 721     {
 722       pop_close (server);
 723       return EXIT_SUCCESS;
 724     }
 725
 726   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 727   if (mbfi < 0)
 728     {
 729       pop_close (server);
 730       error ("Error in open: %s, %s", strerror (errno), outfile);
 731       return EXIT_FAILURE;
 732     }
 733
 734   if (fchown (mbfi, getuid (), -1) != 0)
 735     {
 736       int fchown_errno = errno;
 737       struct stat st;
 738       if (fstat (mbfi, &st) != 0 || st.st_uid != getuid ())
 739         {
 740           pop_close (server);
 741           error ("Error in fchown: %s, %s", strerror (fchown_errno), outfile);
 742           return EXIT_FAILURE;
 743         }
 744     }
 745
 746   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 747     {
 748       pop_close (server);
 749       error ("Error in fdopen: %s", strerror (errno), 0);
 750       close (mbfi);
 751       unlink (outfile);
 752       return EXIT_FAILURE;
 753     }
 754
 755   if (reverse_order)
 756     {
 757       start = nmsgs;
 758       end = 1;
 759       increment = -1;
 760     }
 761   else
 762     {
 763       start = 1;
 764       end = nmsgs;
 765       increment = 1;
 766     }
 767
 768   for (i = start; i * increment <= end * increment; i += increment)
 769     {
 770       mbx_delimit_begin (mbf);
 771       if (pop_retr (server, i, mbf) != OK)
 772         {
 773           error ("%s", Errmsg, 0);
 774           close (mbfi);
 775           return EXIT_FAILURE;
 776         }
 777       mbx_delimit_end (mbf);
 778       fflush (mbf);
 779       if (ferror (mbf))
 780         {
 781           error ("Error in fflush: %s", strerror (errno), 0);
 782           pop_close (server);
 783           close (mbfi);
 784           return EXIT_FAILURE;
 785         }
 786     }
 787
 788   /* On AFS, a call to write only modifies the file in the local
 789    *     workstation's AFS cache.  The changes are not written to the server
 790    *      until a call to fsync or close is made.  Users with AFS home
 791    *      directories have lost mail when over quota because these checks were
 792    *      not made in previous versions of movemail. */
 793
 794 #ifdef BSD_SYSTEM
 795   if (fsync (mbfi) < 0)
 796     {
 797       error ("Error in fsync: %s", strerror (errno), 0);
 798       return EXIT_FAILURE;
 799     }
 800 #endif
 801
 802   if (close (mbfi) == -1)
 803     {
 804       error ("Error in close: %s", strerror (errno), 0);
 805       return EXIT_FAILURE;
 806     }
 807
 808   if (! preserve)
 809     for (i = 1; i <= nmsgs; i++)
 810       {
 811         if (pop_delete (server, i))
 812           {
 813             error ("Error from POP server: %s", pop_error, 0);
 814             pop_close (server);
 815             return EXIT_FAILURE;
 816           }
 817       }
 818
 819   if (pop_quit (server))
 820     {
 821       error ("Error from POP server: %s", pop_error, 0);
 822       return EXIT_FAILURE;
 823     }
 824
 825   return EXIT_SUCCESS;
 826 }
 827
 828 static int
 829 pop_retr (popserver server, int msgno, FILE *arg)
 830 {
 831   char *line;
 832   int ret;
 833
 834   if (pop_retrieve_first (server, msgno, &line))
 835     {
 836       char *msg = concat ("Error from POP server: ", pop_error, "");
 837       strncpy (Errmsg, msg, sizeof (Errmsg));
 838       Errmsg[sizeof (Errmsg)-1] = '\0';
 839       free (msg);
 840       return (NOTOK);
 841     }
 842
 843   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 844     {
 845       if (! line)
 846         break;
 847
 848       if (mbx_write (line, ret, arg) != OK)
 849         {
 850           strcpy (Errmsg, strerror (errno));
 851           pop_close (server);
 852           return (NOTOK);
 853         }
 854     }
 855
 856   if (ret)
 857     {
 858       char *msg = concat ("Error from POP server: ", pop_error, "");
 859       strncpy (Errmsg, msg, sizeof (Errmsg));
 860       Errmsg[sizeof (Errmsg)-1] = '\0';
 861       free (msg);
 862       return (NOTOK);
 863     }
 864
 865   return (OK);
 866 }
 867
 868 static int
 869 mbx_write (char *line, int len, FILE *mbf)
 870 {
 871 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 872   /* Do this as a macro instead of using strcmp to save on execution time. */
 873   # define IS_FROM_LINE(a) ((a[0] == 'F')       \
 874                             && (a[1] == 'r')    \
 875                             && (a[2] == 'o')    \
 876                             && (a[3] == 'm')    \
 877                             && (a[4] == ' '))
 878   if (IS_FROM_LINE (line))
 879     {
 880       if (fputc ('>', mbf) == EOF)
 881         return (NOTOK);
 882     }
 883 #endif
 884   if (line[0] == '\037')
 885     {
 886       if (fputs ("^_", mbf) == EOF)
 887         return (NOTOK);
 888       line++;
 889       len--;
 890     }
 891   if (fwrite (line, 1, len, mbf) != len)
 892     return (NOTOK);
 893   if (fputc (0x0a, mbf) == EOF)
 894     return (NOTOK);
 895   return (OK);
 896 }
 897
 898 static int
 899 mbx_delimit_begin (FILE *mbf)
 900 {
 901   time_t now;
 902   struct tm *ltime;
 903   char fromline[40] = "From movemail ";
 904
 905   now = time (NULL);
 906   ltime = localtime (&now);
 907
 908   strcat (fromline, asctime (ltime));
 909
 910   if (fputs (fromline, mbf) == EOF)
 911     return (NOTOK);
 912   return (OK);
 913 }
 914
 915 static int
 916 mbx_delimit_end (FILE *mbf)
 917 {
 918   if (putc ('\n', mbf) == EOF)
 919     return (NOTOK);
 920   return (OK);
 921 }
 922
 923 #endif /* MAIL_USE_POP */
 924 \f
 925 #ifndef HAVE_STRERROR
 926 char *
 927 strerror (errnum)
 928      int errnum;
 929 {
 930   extern char *sys_errlist[];
 931   extern int sys_nerr;
 932
 933   if (errnum >= 0 && errnum < sys_nerr)
 934     return sys_errlist[errnum];
 935   return (char *) "Unknown error";
 936 }
 937
 938 #endif /* ! HAVE_STRERROR */
 939
 940
 941 /* movemail.c ends here */