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 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  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 #define NO_SHORTNAMES   /* Tell config not to load remap.h */
  58 #include <../src/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 <../src/syswait.h>
  65 #include <getopt.h>
  66 #ifdef MAIL_USE_POP
  67 #include "pop.h"
  68 #endif
  69
  70 #ifdef MSDOS
  71 #undef access
  72 #endif /* MSDOS */
  73
  74 #ifndef DIRECTORY_SEP
  75 #define DIRECTORY_SEP '/'
  76 #endif
  77 #ifndef IS_DIRECTORY_SEP
  78 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
  79 #endif
  80
  81 #ifdef WINDOWSNT
  82 #undef access
  83 #undef unlink
  84 #define fork() 0
  85 #define sys_wait(var) (*(var) = 0)
  86 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
  87    though the locking call succeeds (and indeed blocks local access from
  88    other NT programs).  If you have direct file access using an NFS
  89    client or something other than Samba, the locking call might work
  90    properly - make sure it does before you enable this! */
  91 #define DISABLE_DIRECT_ACCESS
  92 #endif /* WINDOWSNT */
  93
  94 #ifdef USG
  95 #include <fcntl.h>
  96 #include <unistd.h>
  97 #ifndef F_OK
  98 #define F_OK 0
  99 #define X_OK 1
 100 #define W_OK 2
 101 #define R_OK 4
 102 #endif
 103 #endif /* USG */
 104
 105 #ifdef HAVE_UNISTD_H
 106 #include <unistd.h>
 107 #endif
 108
 109 #if defined (XENIX) || defined (WINDOWSNT)
 110 #include <sys/locking.h>
 111 #endif
 112
 113 #ifdef MAIL_USE_LOCKF
 114 #define MAIL_USE_SYSTEM_LOCK
 115 #endif
 116
 117 #ifdef MAIL_USE_FLOCK
 118 #define MAIL_USE_SYSTEM_LOCK
 119 #endif
 120
 121 #ifdef MAIL_USE_MMDF
 122 extern int lk_open (), lk_close ();
 123 #endif
 124
 125 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
 126         defined (HAVE_LIBMAIL) && defined (HAVE_MAILLOCK_H)
 127 #include <maillock.h>
 128 /* We can't use maillock unless we know what directory system mail
 129    files appear in. */
 130 #ifdef MAILDIR
 131 #define MAIL_USE_MAILLOCK
 132 static char *mail_spool_name ();
 133 #endif
 134 #endif
 135
 136 /* Cancel substitutions made by config.h for Emacs.  */
 137 #undef open
 138 #undef read
 139 #undef write
 140 #undef close
 141
 142 #ifndef errno
 143 extern int errno;
 144 #endif
 145 char *strerror ();
 146
 147 void fatal ();
 148 void error ();
 149 void pfatal_with_name ();
 150 void pfatal_and_delete ();
 151 char *concat ();
 152 long *xmalloc ();
 153 int popmail ();
 154 int pop_retr ();
 155 int mbx_write ();
 156 int mbx_delimit_begin ();
 157 int mbx_delimit_end ();
 158
 159 /* Nonzero means this is name of a lock file to delete on fatal error.  */
 160 char *delete_lockname;
 161
 162 int
 163 main (argc, argv)
 164      int argc;
 165      char **argv;
 166 {
 167   char *inname, *outname;
 168   int indesc, outdesc;
 169   int nread;
 170   WAITTYPE status;
 171   int c, preserve_mail = 0;
 172
 173 #ifndef MAIL_USE_SYSTEM_LOCK
 174   struct stat st;
 175   long now;
 176   int tem;
 177   char *lockname, *p;
 178   char *tempname;
 179   int desc;
 180 #endif /* not MAIL_USE_SYSTEM_LOCK */
 181
 182 #ifdef MAIL_USE_MAILLOCK
 183   char *spool_name;
 184 #endif
 185
 186   delete_lockname = 0;
 187
 188   while ((c = getopt (argc, argv, "p")) != EOF)
 189     {
 190       switch (c) {
 191       case 'p':
 192         preserve_mail++;
 193         break;
 194       default:
 195         exit(1);
 196       }
 197     }
 198
 199   if (
 200 #ifdef MAIL_USE_POP
 201       (argc - optind < 2) || (argc - optind > 3)
 202 #else
 203       (argc - optind != 2)
 204 #endif
 205       )
 206     {
 207       fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n",
 208 #ifdef MAIL_USE_POP
 209                " [POP-password]"
 210 #else
 211                ""
 212 #endif
 213                );
 214       exit (1);
 215     }
 216
 217   inname = argv[optind];
 218   outname = argv[optind+1];
 219
 220 #ifdef MAIL_USE_MMDF
 221   mmdf_init (argv[0]);
 222 #endif
 223
 224   if (*outname == 0)
 225     fatal ("Destination file name is empty", 0);
 226
 227   /* Check access to output file.  */
 228   if (access (outname, F_OK) == 0 && access (outname, W_OK) != 0)
 229     pfatal_with_name (outname);
 230
 231   /* Also check that outname's directory is writable to the real uid.  */
 232   {
 233     char *buf = (char *) xmalloc (strlen (outname) + 1);
 234     char *p;
 235     strcpy (buf, outname);
 236     p = buf + strlen (buf);
 237     while (p > buf && !IS_DIRECTORY_SEP (p[-1]))
 238       *--p = 0;
 239     if (p == buf)
 240       *p++ = '.';
 241     if (access (buf, W_OK) != 0)
 242       pfatal_with_name (buf);
 243     free (buf);
 244   }
 245
 246 #ifdef MAIL_USE_POP
 247   if (!strncmp (inname, "po:", 3))
 248     {
 249       int status;
 250
 251       status = popmail (inname + 3, outname, preserve_mail,
 252                         (argc - optind == 3) ? argv[optind+2] : NULL);
 253       exit (status);
 254     }
 255
 256   setuid (getuid ());
 257 #endif /* MAIL_USE_POP */
 258
 259 #ifndef DISABLE_DIRECT_ACCESS
 260
 261   /* Check access to input file.  */
 262   if (access (inname, R_OK | W_OK) != 0)
 263     pfatal_with_name (inname);
 264
 265 #ifndef MAIL_USE_MMDF
 266 #ifndef MAIL_USE_SYSTEM_LOCK
 267 #ifdef MAIL_USE_MAILLOCK
 268   spool_name = mail_spool_name (inname);
 269   if (! spool_name)
 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, "%s--see source file lib-src/movemail.c",
 315                        tempname);
 316               pfatal_with_name (message);
 317             }
 318           close (desc);
 319
 320           tem = link (tempname, lockname);
 321           unlink (tempname);
 322           if (tem >= 0)
 323             break;
 324           sleep (1);
 325
 326           /* If lock file is five minutes old, unlock it.
 327              Five minutes should be good enough to cope with crashes
 328              and wedgitude, and long enough to avoid being fooled
 329              by time differences between machines.  */
 330           if (stat (lockname, &st) >= 0)
 331             {
 332               now = time (0);
 333               if (st.st_ctime < now - 300)
 334                 unlink (lockname);
 335             }
 336         }
 337
 338       delete_lockname = lockname;
 339     }
 340 #endif /* not MAIL_USE_SYSTEM_LOCK */
 341 #endif /* not MAIL_USE_MMDF */
 342
 343   if (fork () == 0)
 344     {
 345       int lockcount = 0;
 346       int status = 0;
 347 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 348       long touched_lock, now;
 349 #endif
 350
 351       setuid (getuid ());
 352
 353 #ifndef MAIL_USE_MMDF
 354 #ifdef MAIL_USE_SYSTEM_LOCK
 355       indesc = open (inname, O_RDWR);
 356 #else  /* if not MAIL_USE_SYSTEM_LOCK */
 357       indesc = open (inname, O_RDONLY);
 358 #endif /* not MAIL_USE_SYSTEM_LOCK */
 359 #else  /* MAIL_USE_MMDF */
 360       indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
 361 #endif /* MAIL_USE_MMDF */
 362
 363       if (indesc < 0)
 364         pfatal_with_name (inname);
 365
 366 #if defined (BSD_SYSTEM) || defined (XENIX)
 367       /* In case movemail is setuid to root, make sure the user can
 368          read the output file.  */
 369       /* This is desirable for all systems
 370          but I don't want to assume all have the umask system call */
 371       umask (umask (0) & 0333);
 372 #endif /* BSD_SYSTEM || XENIX */
 373       outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
 374       if (outdesc < 0)
 375         pfatal_with_name (outname);
 376
 377       /* This label exists so we can retry locking
 378          after a delay, if it got EAGAIN or EBUSY.  */
 379     retry_lock:
 380
 381       /* Try to lock it.  */
 382 #ifdef MAIL_USE_MAILLOCK
 383       if (spool_name)
 384         {
 385           /* The "0 - " is to make it a negative number if maillock returns
 386              non-zero. */
 387           status = 0 - maillock (spool_name, 1);
 388 #ifdef HAVE_TOUCHLOCK
 389           touched_lock = time (0);
 390 #endif
 391           lockcount = 5;
 392         }
 393       else
 394 #endif /* MAIL_USE_MAILLOCK */
 395         {
 396 #ifdef MAIL_USE_SYSTEM_LOCK
 397 #ifdef MAIL_USE_LOCKF
 398           status = lockf (indesc, F_LOCK, 0);
 399 #else /* not MAIL_USE_LOCKF */
 400 #ifdef XENIX
 401           status = locking (indesc, LK_RLCK, 0L);
 402 #else
 403 #ifdef WINDOWSNT
 404           status = locking (indesc, LK_RLCK, -1L);
 405 #else
 406           status = flock (indesc, LOCK_EX);
 407 #endif
 408 #endif
 409 #endif /* not MAIL_USE_LOCKF */
 410 #endif /* MAIL_USE_SYSTEM_LOCK */
 411         }
 412
 413       /* If it fails, retry up to 5 times
 414          for certain failure codes.  */
 415       if (status < 0)
 416         {
 417           if (++lockcount <= 5)
 418             {
 419 #ifdef EAGAIN
 420               if (errno == EAGAIN)
 421                 {
 422                   sleep (1);
 423                   goto retry_lock;
 424                 }
 425 #endif
 426 #ifdef EBUSY
 427               if (errno == EBUSY)
 428                 {
 429                   sleep (1);
 430                   goto retry_lock;
 431                 }
 432 #endif
 433             }
 434
 435           pfatal_with_name (inname);
 436         }
 437
 438       {
 439         char buf[1024];
 440
 441         while (1)
 442           {
 443             nread = read (indesc, buf, sizeof buf);
 444             if (nread != write (outdesc, buf, nread))
 445               {
 446                 int saved_errno = errno;
 447                 unlink (outname);
 448                 errno = saved_errno;
 449                 pfatal_with_name (outname);
 450               }
 451             if (nread < sizeof buf)
 452               break;
 453 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
 454             if (spool_name)
 455               {
 456                 now = time (0);
 457                 if (now - touched_lock > 60)
 458                   {
 459                     touchlock ();
 460                     touched_lock = now;
 461                   }
 462               }
 463 #endif /* MAIL_USE_MAILLOCK */
 464           }
 465       }
 466
 467 #ifdef BSD_SYSTEM
 468       if (fsync (outdesc) < 0)
 469         pfatal_and_delete (outname);
 470 #endif
 471
 472       /* Check to make sure no errors before we zap the inbox.  */
 473       if (close (outdesc) != 0)
 474         pfatal_and_delete (outname);
 475
 476 #ifdef MAIL_USE_SYSTEM_LOCK
 477       if (! preserve_mail)
 478         {
 479 #if defined (STRIDE) || defined (XENIX) || defined (WINDOWSNT)
 480           /* Stride, xenix have file locking, but no ftruncate.
 481              This mess will do. */
 482           close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
 483 #else
 484           ftruncate (indesc, 0L);
 485         }
 486 #endif /* STRIDE or XENIX */
 487 #endif /* MAIL_USE_SYSTEM_LOCK */
 488
 489 #ifdef MAIL_USE_MMDF
 490       lk_close (indesc, 0, 0, 0);
 491 #else
 492       close (indesc);
 493 #endif
 494
 495 #ifndef MAIL_USE_SYSTEM_LOCK
 496       if (! preserve_mail)
 497         {
 498           /* Delete the input file; if we can't, at least get rid of its
 499              contents.  */
 500 #ifdef MAIL_UNLINK_SPOOL
 501           /* This is generally bad to do, because it destroys the permissions
 502              that were set on the file.  Better to just empty the file.  */
 503           if (unlink (inname) < 0 && errno != ENOENT)
 504 #endif /* MAIL_UNLINK_SPOOL */
 505             creat (inname, 0600);
 506         }
 507 #endif /* not MAIL_USE_SYSTEM_LOCK */
 508
 509 #ifdef MAIL_USE_MAILLOCK
 510       /* This has to occur in the child, i.e., in the process that
 511          acquired the lock! */
 512       if (spool_name)
 513         mailunlock ();
 514 #endif
 515       exit (0);
 516     }
 517
 518   wait (&status);
 519   if (!WIFEXITED (status))
 520     exit (1);
 521   else if (WRETCODE (status) != 0)
 522     exit (WRETCODE (status));
 523
 524 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
 525 #ifdef MAIL_USE_MAILLOCK
 526   if (! spool_name)
 527 #endif /* MAIL_USE_MAILLOCK */
 528     unlink (lockname);
 529 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
 530
 531 #endif /* ! DISABLE_DIRECT_ACCESS */
 532
 533   return 0;
 534 }
 535
 536 #ifdef MAIL_USE_MAILLOCK
 537 /* This function uses stat to confirm that the mail directory is
 538    identical to the directory of the input file, rather than just
 539    string-comparing the two paths, because one or both of them might
 540    be symbolic links pointing to some other directory. */
 541 static char *
 542 mail_spool_name (inname)
 543      char *inname;
 544 {
 545   struct stat stat1, stat2;
 546   char *indir, *fname;
 547   int status;
 548
 549   if (! (fname = rindex (inname, '/')))
 550     return NULL;
 551
 552   fname++;
 553
 554   if (stat (MAILDIR, &stat1) < 0)
 555     return NULL;
 556
 557   indir = (char *) xmalloc (fname - inname + 1);
 558   strncpy (indir, inname, fname - inname);
 559   indir[fname-inname] = '\0';
 560
 561
 562   status = stat (indir, &stat2);
 563
 564   free (indir);
 565
 566   if (status < 0)
 567     return NULL;
 568
 569   if ((stat1.st_dev == stat2.st_dev) &&
 570       (stat1.st_ino == stat2.st_ino))
 571     return fname;
 572
 573   return NULL;
 574 }
 575 #endif /* MAIL_USE_MAILLOCK */
 576 \f
 577 /* Print error message and exit.  */
 578
 579 void
 580 fatal (s1, s2)
 581      char *s1, *s2;
 582 {
 583   if (delete_lockname)
 584     unlink (delete_lockname);
 585   error (s1, s2);
 586   exit (1);
 587 }
 588
 589 /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
 590
 591 void
 592 error (s1, s2, s3)
 593      char *s1, *s2, *s3;
 594 {
 595   fprintf (stderr, "movemail: ");
 596   fprintf (stderr, s1, s2, s3);
 597   fprintf (stderr, "\n");
 598 }
 599
 600 void
 601 pfatal_with_name (name)
 602      char *name;
 603 {
 604   char *s = concat ("", strerror (errno), " for %s");
 605   fatal (s, name);
 606 }
 607
 608 void
 609 pfatal_and_delete (name)
 610      char *name;
 611 {
 612   char *s = concat ("", strerror (errno), " for %s");
 613   unlink (name);
 614   fatal (s, name);
 615 }
 616
 617 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */
 618
 619 char *
 620 concat (s1, s2, s3)
 621      char *s1, *s2, *s3;
 622 {
 623   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 624   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
 625
 626   strcpy (result, s1);
 627   strcpy (result + len1, s2);
 628   strcpy (result + len1 + len2, s3);
 629   *(result + len1 + len2 + len3) = 0;
 630
 631   return result;
 632 }
 633
 634 /* Like malloc but get fatal error if memory is exhausted.  */
 635
 636 long *
 637 xmalloc (size)
 638      unsigned size;
 639 {
 640   long *result = (long *) malloc (size);
 641   if (!result)
 642     fatal ("virtual memory exhausted", 0);
 643   return result;
 644 }
 645 \f
 646 /* This is the guts of the interface to the Post Office Protocol.  */
 647
 648 #ifdef MAIL_USE_POP
 649
 650 #ifndef WINDOWSNT
 651 #include <sys/socket.h>
 652 #include <netinet/in.h>
 653 #include <netdb.h>
 654 #else
 655 #undef _WINSOCKAPI_
 656 #include <winsock.h>
 657 #endif
 658 #include <pwd.h>
 659
 660 #ifdef USG
 661 #include <fcntl.h>
 662 /* Cancel substitutions made by config.h for Emacs.  */
 663 #undef open
 664 #undef read
 665 #undef write
 666 #undef close
 667 #endif /* USG */
 668
 669 #define NOTOK (-1)
 670 #define OK 0
 671 #define DONE 1
 672
 673 char *progname;
 674 FILE *sfi;
 675 FILE *sfo;
 676 char ibuffer[BUFSIZ];
 677 char obuffer[BUFSIZ];
 678 char Errmsg[80];
 679
 680 popmail (user, outfile, preserve, password)
 681      char *user;
 682      char *outfile;
 683      int preserve;
 684      char *password;
 685 {
 686   int nmsgs, nbytes;
 687   register int i;
 688   int mbfi;
 689   FILE *mbf;
 690   char *getenv ();
 691   int mbx_write ();
 692   popserver server;
 693   extern char *strerror ();
 694
 695   server = pop_open (0, user, password, POP_NO_GETPASS);
 696   if (! server)
 697     {
 698       error (pop_error);
 699       return (1);
 700     }
 701
 702   if (pop_stat (server, &nmsgs, &nbytes))
 703     {
 704       error (pop_error);
 705       return (1);
 706     }
 707
 708   if (!nmsgs)
 709     {
 710       pop_close (server);
 711       return (0);
 712     }
 713
 714   mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 715   if (mbfi < 0)
 716     {
 717       pop_close (server);
 718       error ("Error in open: %s, %s", strerror (errno), outfile);
 719       return (1);
 720     }
 721   fchown (mbfi, getuid (), -1);
 722
 723   if ((mbf = fdopen (mbfi, "wb")) == NULL)
 724     {
 725       pop_close (server);
 726       error ("Error in fdopen: %s", strerror (errno));
 727       close (mbfi);
 728       unlink (outfile);
 729       return (1);
 730     }
 731
 732   for (i = 1; i <= nmsgs; i++)
 733     {
 734       mbx_delimit_begin (mbf);
 735       if (pop_retr (server, i, mbx_write, mbf) != OK)
 736         {
 737           error (Errmsg);
 738           close (mbfi);
 739           return (1);
 740         }
 741       mbx_delimit_end (mbf);
 742       fflush (mbf);
 743       if (ferror (mbf))
 744         {
 745           error ("Error in fflush: %s", strerror (errno));
 746           pop_close (server);
 747           close (mbfi);
 748           return (1);
 749         }
 750     }
 751
 752   /* On AFS, a call to write only modifies the file in the local
 753    *     workstation's AFS cache.  The changes are not written to the server
 754    *      until a call to fsync or close is made.  Users with AFS home
 755    *      directories have lost mail when over quota because these checks were
 756    *      not made in previous versions of movemail. */
 757
 758 #ifdef BSD_SYSTEM
 759   if (fsync (mbfi) < 0)
 760     {
 761       error ("Error in fsync: %s", strerror (errno));
 762       return (1);
 763     }
 764 #endif
 765
 766   if (close (mbfi) == -1)
 767     {
 768       error ("Error in close: %s", strerror (errno));
 769       return (1);
 770     }
 771
 772   if (! preserve)
 773     for (i = 1; i <= nmsgs; i++)
 774       {
 775         if (pop_delete (server, i))
 776           {
 777             error (pop_error);
 778             pop_close (server);
 779             return (1);
 780           }
 781       }
 782
 783   if (pop_quit (server))
 784     {
 785       error (pop_error);
 786       return (1);
 787     }
 788
 789   return (0);
 790 }
 791
 792 pop_retr (server, msgno, action, arg)
 793      popserver server;
 794      int (*action) ();
 795 {
 796   extern char *strerror ();
 797   char *line;
 798   int ret;
 799
 800   if (pop_retrieve_first (server, msgno, &line))
 801     {
 802       strncpy (Errmsg, pop_error, sizeof (Errmsg));
 803       Errmsg[sizeof (Errmsg)-1] = '\0';
 804       return (NOTOK);
 805     }
 806
 807   while (! (ret = pop_retrieve_next (server, &line)))
 808     {
 809       if (! line)
 810         break;
 811
 812       if ((*action)(line, arg) != OK)
 813         {
 814           strcpy (Errmsg, strerror (errno));
 815           pop_close (server);
 816           return (NOTOK);
 817         }
 818     }
 819
 820   if (ret)
 821     {
 822       strncpy (Errmsg, pop_error, sizeof (Errmsg));
 823       Errmsg[sizeof (Errmsg)-1] = '\0';
 824       return (NOTOK);
 825     }
 826
 827   return (OK);
 828 }
 829
 830 /* Do this as a macro instead of using strcmp to save on execution time. */
 831 #define IS_FROM_LINE(a) ((a[0] == 'F') \
 832                          && (a[1] == 'r') \
 833                          && (a[2] == 'o') \
 834                          && (a[3] == 'm') \
 835                          && (a[4] == ' '))
 836
 837 int
 838 mbx_write (line, mbf)
 839      char *line;
 840      FILE *mbf;
 841 {
 842   if (IS_FROM_LINE (line))
 843     {
 844       if (fputc ('>', mbf) == EOF)
 845         return (NOTOK);
 846     }
 847   if (fputs (line, mbf) == EOF)
 848     return (NOTOK);
 849   if (fputc (0x0a, mbf) == EOF)
 850     return (NOTOK);
 851   return (OK);
 852 }
 853
 854 int
 855 mbx_delimit_begin (mbf)
 856      FILE *mbf;
 857 {
 858   if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
 859     return (NOTOK);
 860   return (OK);
 861 }
 862
 863 mbx_delimit_end (mbf)
 864      FILE *mbf;
 865 {
 866   if (putc ('\037', mbf) == EOF)
 867     return (NOTOK);
 868   return (OK);
 869 }
 870
 871 #endif /* MAIL_USE_POP */
 872 \f
 873 #ifndef HAVE_STRERROR
 874 char *
 875 strerror (errnum)
 876      int errnum;
 877 {
 878   extern char *sys_errlist[];
 879   extern int sys_nerr;
 880
 881   if (errnum >= 0 && errnum < sys_nerr)
 882     return sys_errlist[errnum];
 883   return (char *) "Unknown error";
 884 }
 885
 886 #endif /* ! HAVE_STRERROR */