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