lib-src/movemail.c

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