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-2015 Free Software
   5 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/lockf 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 <stdbool.h>
  63 #include <stdio.h>
  64 #include <errno.h>
  65 #include <time.h>
  66
  67 #include <getopt.h>
  68 #include <unistd.h>
  69 #include <fcntl.h>
  70 #include <signal.h>
  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 waitpid(child, var, flags) (*(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 #ifdef WINDOWSNT
 102 #include <sys/locking.h>
 103 #endif
 104
 105 /* If your system uses the `flock' or `lockf' system call for mail locking,
 106    define MAIL_USE_SYSTEM_LOCK.  If your system type should always define
 107    MAIL_USE_LOCKF or MAIL_USE_FLOCK but configure does not do this,
 108    please make a bug report.  */
 109
 110 #ifdef MAIL_USE_LOCKF
 111 #define MAIL_USE_SYSTEM_LOCK
 112 #endif
 113
 114 #ifdef MAIL_USE_FLOCK
 115 #define MAIL_USE_SYSTEM_LOCK
 116 #endif
 117
 118 #if (!defined MAIL_USE_SYSTEM_LOCK                              \
 119      && (defined HAVE_LIBMAIL || defined HAVE_LIBLOCKFILE)      \
 120      && defined HAVE_MAILLOCK_H)
 121 #include <maillock.h>
 122 /* We can't use maillock unless we know what directory system mail
 123    files appear in. */
 124 #ifdef MAILDIR
 125 #define MAIL_USE_MAILLOCK
 126 static char *mail_spool_name (char *);
 127 #endif
 128 #endif
 129
 130 static _Noreturn void fatal (const char *s1, const char *s2, const char *s3);
 131 static void error (const char *s1, const char *s2, const char *s3);
 132 static _Noreturn void pfatal_with_name (char *name);
 133 static _Noreturn void pfatal_and_delete (char *name);
 134 #ifdef MAIL_USE_POP
 135 static int popmail (char *, char *, bool, char *, bool);
 136 static bool pop_retr (popserver, int, FILE *);
 137 static bool mbx_write (char *, int, FILE *);
 138 static bool mbx_delimit_begin (FILE *);
 139 static bool mbx_delimit_end (FILE *);
 140 #endif
 141
 142 #if (defined MAIL_USE_MAILLOCK                                          \
 143      || (!defined DISABLE_DIRECT_ACCESS && !defined MAIL_USE_SYSTEM_LOCK))
 144 /* Like malloc but get fatal error if memory is exhausted.  */
 145
 146 static void *
 147 xmalloc (size_t size)
 148 {
 149   void *result = malloc (size);
 150   if (!result)
 151     fatal ("virtual memory exhausted", 0, 0);
 152   return result;
 153 }
 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;
 167   bool preserve_mail = false;
 168
 169 #ifndef MAIL_USE_SYSTEM_LOCK
 170   struct stat st;
 171   int tem;
 172   char *tempname;
 173   size_t inname_len, inname_dirlen;
 174   int desc;
 175 #endif /* not MAIL_USE_SYSTEM_LOCK */
 176
 177 #ifdef MAIL_USE_POP
 178   bool pop_reverse_order = false;
 179 # define ARGSTR "pr"
 180 #else /* ! MAIL_USE_POP */
 181 # define ARGSTR "p"
 182 #endif /* MAIL_USE_POP */
 183
 184   uid_t real_gid = getgid ();
 185   uid_t priv_gid = getegid ();
 186
 187   delete_lockname = 0;
 188
 189   while (0 <= (c = getopt (argc, argv, ARGSTR)))
 190     {
 191       switch (c) {
 192 #ifdef MAIL_USE_POP
 193       case 'r':
 194         pop_reverse_order = true;
 195         break;
 196 #endif
 197       case 'p':
 198         preserve_mail = true;
 199         break;
 200       default:
 201         return EXIT_FAILURE;
 202       }
 203     }
 204
 205   if (
 206 #ifdef MAIL_USE_POP
 207       (argc - optind < 2) || (argc - optind > 3)
 208 #else
 209       (argc - optind != 2)
 210 #endif
 211       )
 212     {
 213 #ifdef MAIL_USE_POP
 214       fprintf (stderr, "Usage: movemail [-p] [-r] inbox destfile%s\n",
 215                " [POP-password]");
 216 #else
 217       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
 218 #endif
 219       return EXIT_FAILURE;
 220     }
 221
 222   inname = argv[optind];
 223   outname = argv[optind+1];
 224
 225   if (*outname == 0)
 226     fatal ("Destination file name is empty", 0, 0);
 227
 228 #ifdef MAIL_USE_POP
 229   if (!strncmp (inname, "po:", 3))
 230     {
 231       int status;
 232
 233       status = popmail (inname + 3, outname, preserve_mail,
 234                         (argc - optind == 3) ? argv[optind+2] : NULL,
 235                         pop_reverse_order);
 236       return status;
 237     }
 238
 239   if (setuid (getuid ()) < 0)
 240     fatal ("Failed to drop privileges", 0, 0);
 241
 242 #endif /* MAIL_USE_POP */
 243
 244 #ifndef DISABLE_DIRECT_ACCESS
 245
 246   char *lockname = 0;
 247
 248 #ifdef MAIL_USE_MAILLOCK
 249   char *spool_name = 0;
 250 #endif
 251
 252 #ifndef MAIL_USE_SYSTEM_LOCK
 253 #ifdef MAIL_USE_MAILLOCK
 254   spool_name = mail_spool_name (inname);
 255 #endif
 256   if (! spool_name)
 257     {
 258       /* Use a lock file named after our first argument with .lock appended:
 259          If it exists, the mail file is locked.  */
 260       /* Note: this locking mechanism is *required* by the mailer
 261          (on systems which use it) to prevent loss of mail.
 262
 263          On systems that use a lock file, extracting the mail without locking
 264          WILL occasionally cause loss of mail due to timing errors!
 265
 266          So, if creation of the lock file fails due to access
 267          permission on the mail spool directory, you simply MUST
 268          change the permission and/or make movemail a setgid program
 269          so it can create lock files properly.
 270
 271          You might also wish to verify that your system is one which
 272          uses lock files for this purpose.  Some systems use other methods.  */
 273
 274       inname_len = strlen (inname);
 275       lockname = xmalloc (inname_len + sizeof ".lock");
 276       strcpy (lockname, inname);
 277       strcpy (lockname + inname_len, ".lock");
 278       for (inname_dirlen = inname_len;
 279            inname_dirlen && !IS_DIRECTORY_SEP (inname[inname_dirlen - 1]);
 280            inname_dirlen--)
 281         continue;
 282       tempname = xmalloc (inname_dirlen + sizeof "EXXXXXX");
 283
 284       while (true)
 285         {
 286           /* Create the lock file, but not under the lock file name.  */
 287           /* Give up if cannot do that.  */
 288
 289           memcpy (tempname, inname, inname_dirlen);
 290           strcpy (tempname + inname_dirlen, "EXXXXXX");
 291           desc = mkostemp (tempname, O_BINARY);
 292           if (desc < 0)
 293             {
 294               int mkostemp_errno = errno;
 295               error ("error while creating what would become the lock file",
 296                      0, 0);
 297               errno = mkostemp_errno;
 298               pfatal_with_name (tempname);
 299             }
 300           close (desc);
 301
 302           tem = link (tempname, lockname);
 303
 304           if (tem < 0 && errno != EEXIST)
 305             pfatal_with_name (lockname);
 306
 307           unlink (tempname);
 308           if (tem >= 0)
 309             break;
 310           sleep (1);
 311
 312           /* If lock file is five minutes old, unlock it.
 313              Five minutes should be good enough to cope with crashes
 314              and wedgitude, and long enough to avoid being fooled
 315              by time differences between machines.  */
 316           if (stat (lockname, &st) >= 0)
 317             {
 318               time_t now = time (0);
 319               if (st.st_ctime < now - 300)
 320                 {
 321                   unlink (lockname);
 322                   lockname = 0;
 323                 }
 324             }
 325         }
 326
 327       delete_lockname = lockname;
 328     }
 329 #endif /* not MAIL_USE_SYSTEM_LOCK */
 330
 331 #ifdef SIGCHLD
 332   signal (SIGCHLD, SIG_DFL);
 333 #endif
 334
 335   pid_t child = fork ();
 336   if (child < 0)
 337     fatal ("Error in fork; %s", strerror (errno), 0);
 338
 339   if (child == 0)
 340     {
 341       int lockcount = 0;
 342       int status = 0;
 343 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 344       time_t touched_lock IF_LINT (= 0);
 345 #endif
 346
 347       if (setuid (getuid ()) < 0 || setregid (-1, real_gid) < 0)
 348         fatal ("Failed to drop privileges", 0, 0);
 349
 350 #ifdef MAIL_USE_SYSTEM_LOCK
 351       indesc = open (inname, O_RDWR | O_BINARY);
 352 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 353       indesc = open (inname, O_RDONLY | O_BINARY);
 354 #endif /* not MAIL_USE_SYSTEM_LOCK */
 355
 356       if (indesc < 0)
 357         pfatal_with_name (inname);
 358
 359       /* Make sure the user can read the output file.  */
 360       umask (umask (0) & 0377);
 361
 362       outdesc = open (outname, O_WRONLY | O_BINARY | O_CREAT | O_EXCL, 0666);
 363       if (outdesc < 0)
 364         pfatal_with_name (outname);
 365
 366       if (setregid (-1, priv_gid) < 0)
 367         fatal ("Failed to regain privileges", 0, 0);
 368
 369       /* This label exists so we can retry locking
 370          after a delay, if it got EAGAIN or EBUSY.  */
 371     retry_lock:
 372
 373       /* Try to lock it.  */
 374 #ifdef MAIL_USE_MAILLOCK
 375       if (spool_name)
 376         {
 377           /* The "-" is to make it a negative number if maillock returns
 378              non-zero. */
 379           status = - maillock (spool_name, 1);
 380 #ifdef HAVE_TOUCHLOCK
 381           touched_lock = time (0);
 382 #endif
 383           lockcount = 5;
 384         }
 385       else
 386 #endif /* MAIL_USE_MAILLOCK */
 387         {
 388 #ifdef MAIL_USE_SYSTEM_LOCK
 389 #ifdef MAIL_USE_LOCKF
 390           status = lockf (indesc, F_LOCK, 0);
 391 #else /* not MAIL_USE_LOCKF */
 392 #ifdef WINDOWSNT
 393           status = locking (indesc, LK_RLCK, -1L);
 394 #else
 395           status = flock (indesc, LOCK_EX);
 396 #endif
 397 #endif /* not MAIL_USE_LOCKF */
 398 #endif /* MAIL_USE_SYSTEM_LOCK */
 399         }
 400
 401       /* If it fails, retry up to 5 times
 402          for certain failure codes.  */
 403       if (status < 0)
 404         {
 405           if (++lockcount <= 5 && (errno == EAGAIN || errno == EBUSY))
 406             {
 407               sleep (1);
 408               goto retry_lock;
 409             }
 410
 411           pfatal_with_name (inname);
 412         }
 413
 414       {
 415         char buf[1024];
 416
 417         while (true)
 418           {
 419             nread = read (indesc, buf, sizeof buf);
 420             if (nread < 0)
 421               pfatal_with_name (inname);
 422             if (nread != write (outdesc, buf, nread))
 423               {
 424                 int saved_errno = errno;
 425                 unlink (outname);
 426                 errno = saved_errno;
 427                 pfatal_with_name (outname);
 428               }
 429             if (nread < sizeof buf)
 430               break;
 431 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 432             if (spool_name)
 433               {
 434                 time_t now = time (0);
 435                 if (now - touched_lock > 60)
 436                   {
 437                     touchlock ();
 438                     touched_lock = now;
 439                   }
 440               }
 441 #endif /* MAIL_USE_MAILLOCK */
 442           }
 443       }
 444
 445       if (fsync (outdesc) != 0 && errno != EINVAL)
 446         pfatal_and_delete (outname);
 447
 448       /* Prevent symlink attacks truncating other users' mailboxes */
 449       if (setregid (-1, real_gid) < 0)
 450         fatal ("Failed to drop privileges", 0, 0);
 451
 452       /* Check to make sure no errors before we zap the inbox.  */
 453       if (close (outdesc) != 0)
 454         pfatal_and_delete (outname);
 455
 456 #ifdef MAIL_USE_SYSTEM_LOCK
 457       if (! preserve_mail)
 458         {
 459           if (ftruncate (indesc, 0) != 0)
 460             pfatal_with_name (inname);
 461         }
 462 #endif /* MAIL_USE_SYSTEM_LOCK */
 463
 464       close (indesc);
 465
 466 #ifndef MAIL_USE_SYSTEM_LOCK
 467       if (! preserve_mail)
 468         {
 469           /* Delete the input file; if we can't, at least get rid of its
 470              contents.  */
 471 #ifdef MAIL_UNLINK_SPOOL
 472           /* This is generally bad to do, because it destroys the permissions
 473              that were set on the file.  Better to just empty the file.  */
 474           if (unlink (inname) < 0 && errno != ENOENT)
 475 #endif /* MAIL_UNLINK_SPOOL */
 476             creat (inname, 0600);
 477         }
 478 #endif /* not MAIL_USE_SYSTEM_LOCK */
 479
 480       /* End of mailbox truncation */
 481       if (setregid (-1, priv_gid) < 0)
 482         fatal ("Failed to regain privileges", 0, 0);
 483
 484 #ifdef MAIL_USE_MAILLOCK
 485       /* This has to occur in the child, i.e., in the process that
 486          acquired the lock! */
 487       if (spool_name)
 488         mailunlock ();
 489 #endif
 490       return EXIT_SUCCESS;
 491     }
 492
 493   if (waitpid (child, &wait_status, 0) < 0)
 494     fatal ("Error in waitpid; %s", strerror (errno), 0);
 495   if (!WIFEXITED (wait_status))
 496     return EXIT_FAILURE;
 497   else if (WEXITSTATUS (wait_status) != 0)
 498     return WEXITSTATUS (wait_status);
 499
 500   if (lockname)
 501     unlink (lockname);
 502
 503 #endif /* ! DISABLE_DIRECT_ACCESS */
 504
 505   return EXIT_SUCCESS;
 506 }
 507
 508 #ifdef MAIL_USE_MAILLOCK
 509 /* This function uses stat to confirm that the mail directory is
 510    identical to the directory of the input file, rather than just
 511    string-comparing the two paths, because one or both of them might
 512    be symbolic links pointing to some other directory. */
 513 static char *
 514 mail_spool_name (char *inname)
 515 {
 516   struct stat stat1, stat2;
 517   char *indir, *fname;
 518   int status;
 519
 520   if (! (fname = strrchr (inname, '/')))
 521     return NULL;
 522
 523   fname++;
 524
 525   if (stat (MAILDIR, &stat1) < 0)
 526     return NULL;
 527
 528   indir = xmalloc (fname - inname + 1);
 529   memcpy (indir, inname, fname - inname);
 530   indir[fname-inname] = '\0';
 531
 532
 533   status = stat (indir, &stat2);
 534
 535   free (indir);
 536
 537   if (status < 0)
 538     return NULL;
 539
 540   if (stat1.st_dev == stat2.st_dev
 541       && stat1.st_ino == stat2.st_ino)
 542     return fname;
 543
 544   return NULL;
 545 }
 546 #endif /* MAIL_USE_MAILLOCK */
 547 \f
 548 /* Print error message and exit.  */
 549
 550 static void
 551 fatal (const char *s1, const char *s2, const char *s3)
 552 {
 553   if (delete_lockname)
 554     unlink (delete_lockname);
 555   error (s1, s2, s3);
 556   exit (EXIT_FAILURE);
 557 }
 558
 559 /* Print error message.  `s1' is printf control string, `s2' and `s3'
 560    are args for it or null. */
 561
 562 static void
 563 error (const char *s1, const char *s2, const char *s3)
 564 {
 565   fprintf (stderr, "movemail: ");
 566   if (s3)
 567     fprintf (stderr, s1, s2, s3);
 568   else if (s2)
 569     fprintf (stderr, s1, s2);
 570   else
 571     fprintf (stderr, "%s", s1);
 572   fprintf (stderr, "\n");
 573 }
 574
 575 static void
 576 pfatal_with_name (char *name)
 577 {
 578   fatal ("%s for %s", strerror (errno), name);
 579 }
 580
 581 static void
 582 pfatal_and_delete (char *name)
 583 {
 584   char *s = strerror (errno);
 585   unlink (name);
 586   fatal ("%s for %s", s, name);
 587 }
 588 \f
 589 /* This is the guts of the interface to the Post Office Protocol.  */
 590
 591 #ifdef MAIL_USE_POP
 592
 593 #ifndef WINDOWSNT
 594 #include <sys/socket.h>
 595 #include <netinet/in.h>
 596 #include <netdb.h>
 597 #else
 598 #undef _WINSOCKAPI_
 599 #include <winsock.h>
 600 #endif
 601 #include <pwd.h>
 602 #include <string.h>
 603
 604 /*
 605  * The full valid syntax for a POP mailbox specification for movemail
 606  * is "po:username:hostname".  The ":hostname" is optional; if it is
 607  * omitted, the MAILHOST environment variable will be consulted.  Note
 608  * that by the time popmail() is called the "po:" has been stripped
 609  * off of the front of the mailbox name.
 610  *
 611  * If the mailbox is in the form "po:username:hostname", then it is
 612  * modified by this function -- the second colon is replaced by a
 613  * null.
 614  *
 615  * Return a value suitable for passing to `exit'.
 616  */
 617
 618 static int
 619 popmail (char *mailbox, char *outfile, bool preserve, char *password,
 620          bool reverse_order)
 621 {
 622   int nmsgs, nbytes;
 623   int i;
 624   int mbfi;
 625   FILE *mbf;
 626   popserver server;
 627   int start, end, increment;
 628   char *user, *hostname;
 629
 630   user = mailbox;
 631   if ((hostname = strchr (mailbox, ':')))
 632     *hostname++ = '\0';
 633
 634   server = pop_open (hostname, user, password, POP_NO_GETPASS);
 635   if (! server)
 636     {
 637       error ("Error connecting to POP server: %s", pop_error, 0);
 638       return EXIT_FAILURE;
 639     }
 640
 641   if (pop_stat (server, &nmsgs, &nbytes))
 642     {
 643       error ("Error getting message count from POP server: %s", pop_error, 0);
 644       return EXIT_FAILURE;
 645     }
 646
 647   if (!nmsgs)
 648     {
 649       pop_close (server);
 650       return EXIT_SUCCESS;
 651     }
 652
 653   mbfi = open (outfile, O_WRONLY | O_BINARY | O_CREAT | O_EXCL, 0666);
 654   if (mbfi < 0)
 655     {
 656       pop_close (server);
 657       error ("Error in open: %s, %s", strerror (errno), outfile);
 658       return EXIT_FAILURE;
 659     }
 660
 661   if (fchown (mbfi, getuid (), -1) != 0)
 662     {
 663       int fchown_errno = errno;
 664       struct stat st;
 665       if (fstat (mbfi, &st) != 0 || st.st_uid != getuid ())
 666         {
 667           pop_close (server);
 668           error ("Error in fchown: %s, %s", strerror (fchown_errno), outfile);
 669           return EXIT_FAILURE;
 670         }
 671     }
 672
 673   mbf = fdopen (mbfi, "wb");
 674   if (!mbf)
 675     {
 676       pop_close (server);
 677       error ("Error in fdopen: %s", strerror (errno), 0);
 678       close (mbfi);
 679       unlink (outfile);
 680       return EXIT_FAILURE;
 681     }
 682
 683   if (reverse_order)
 684     {
 685       start = nmsgs;
 686       end = 1;
 687       increment = -1;
 688     }
 689   else
 690     {
 691       start = 1;
 692       end = nmsgs;
 693       increment = 1;
 694     }
 695
 696   for (i = start; i * increment <= end * increment; i += increment)
 697     if (! (mbx_delimit_begin (mbf)
 698            && pop_retr (server, i, mbf)
 699            && mbx_delimit_end (mbf)
 700            && fflush (mbf) == 0))
 701       {
 702         if (errno)
 703           error ("Error in POP retrieving: %s", strerror (errno), 0);
 704         pop_close (server);
 705         fclose (mbf);
 706         return EXIT_FAILURE;
 707       }
 708
 709   if (fsync (mbfi) != 0 && errno != EINVAL)
 710     {
 711       error ("Error in fsync: %s", strerror (errno), 0);
 712       fclose (mbf);
 713       return EXIT_FAILURE;
 714     }
 715
 716   if (fclose (mbf) != 0)
 717     {
 718       error ("Error in fclose: %s", strerror (errno), 0);
 719       return EXIT_FAILURE;
 720     }
 721
 722   if (! preserve)
 723     for (i = 1; i <= nmsgs; i++)
 724       {
 725         if (pop_delete (server, i))
 726           {
 727             error ("Error from POP server: %s", pop_error, 0);
 728             pop_close (server);
 729             return EXIT_FAILURE;
 730           }
 731       }
 732
 733   if (pop_quit (server))
 734     {
 735       error ("Error from POP server: %s", pop_error, 0);
 736       return EXIT_FAILURE;
 737     }
 738
 739   return EXIT_SUCCESS;
 740 }
 741
 742 static bool
 743 pop_retr (popserver server, int msgno, FILE *arg)
 744 {
 745   char *line;
 746   int ret;
 747
 748   if (pop_retrieve_first (server, msgno, &line))
 749     {
 750       error ("Error from POP server: %s", pop_error, 0);
 751       errno = 0;
 752       return false;
 753     }
 754
 755   while ((ret = pop_retrieve_next (server, &line)) >= 0)
 756     {
 757       if (! line)
 758         break;
 759
 760       if (! mbx_write (line, ret, arg))
 761         {
 762           int write_errno = errno;
 763           pop_close (server);
 764           errno = write_errno;
 765           return false;
 766         }
 767     }
 768
 769   if (ret)
 770     {
 771       error ("Error from POP server: %s", pop_error, 0);
 772       errno = 0;
 773       return false;
 774     }
 775
 776   return true;
 777 }
 778
 779 static bool
 780 mbx_write (char *line, int len, FILE *mbf)
 781 {
 782 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
 783   /* Do this as a macro instead of using strcmp to save on execution time. */
 784   # define IS_FROM_LINE(a) ((a[0] == 'F')       \
 785                             && (a[1] == 'r')    \
 786                             && (a[2] == 'o')    \
 787                             && (a[3] == 'm')    \
 788                             && (a[4] == ' '))
 789   if (IS_FROM_LINE (line))
 790     {
 791       if (fputc ('>', mbf) < 0)
 792         return false;
 793     }
 794 #endif
 795   if (line[0] == '\037')
 796     {
 797       if (fputs ("^_", mbf) < 0)
 798         return false;
 799       line++;
 800       len--;
 801     }
 802   return fwrite (line, 1, len, mbf) == len && 0 <= fputc ('\n', mbf);
 803 }
 804
 805 static bool
 806 mbx_delimit_begin (FILE *mbf)
 807 {
 808   time_t now = time (NULL);
 809   struct tm *ltime = localtime (&now);
 810   if (!ltime)
 811     return false;
 812
 813   char fromline[100];
 814   if (! strftime (fromline, sizeof fromline,
 815                   "From movemail %a %b %e %T %Y\n", ltime))
 816     {
 817       errno = EOVERFLOW;
 818       return false;
 819     }
 820   return 0 <= fputs (fromline, mbf);
 821 }
 822
 823 static bool
 824 mbx_delimit_end (FILE *mbf)
 825 {
 826   return 0 <= putc ('\n', mbf);
 827 }
 828
 829 #endif /* MAIL_USE_POP */