*** empty log message ***
[emacs.git] / lib-src / movemail.c
blob61d58688901721359bdf256dc63d0f3a971f8de6
1 /* movemail foo bar -- move file foo to file bar,
2 locking file foo the way /bin/mail respects.
3 Copyright (C) 1986, 92, 93, 94, 96, 1999 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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.
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.
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. */
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.
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. */
35 * Modified January, 1986 by Michael R. Gretzinger (Project Athena)
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.
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
50 * Modified August, 1993 by Jonathan Kamens (OpenVision Technologies)
52 * Move all of the POP code into a separate file, "pop.c".
53 * Use strerror instead of get_errmsg.
57 #define NO_SHORTNAMES /* Tell config not to load remap.h */
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>
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 #include "syswait.h"
73 #ifdef MAIL_USE_POP
74 #include "pop.h"
75 #endif
77 #ifdef MSDOS
78 #undef access
79 #endif /* MSDOS */
81 #ifndef DIRECTORY_SEP
82 #define DIRECTORY_SEP '/'
83 #endif
84 #ifndef IS_DIRECTORY_SEP
85 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
86 #endif
88 #ifdef WINDOWSNT
89 #include "ntlib.h"
90 #undef access
91 #undef unlink
92 #define fork() 0
93 #define wait(var) (*(var) = 0)
94 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
95 though the locking call succeeds (and indeed blocks local access from
96 other NT programs). If you have direct file access using an NFS
97 client or something other than Samba, the locking call might work
98 properly - make sure it does before you enable this!
100 [18-Feb-97 andrewi] I now believe my comment above to be incorrect,
101 since it was based on a misunderstanding of how locking calls are
102 implemented and used on Unix. */
103 //#define DISABLE_DIRECT_ACCESS
105 #include <fcntl.h>
106 #endif /* WINDOWSNT */
108 #ifndef F_OK
109 #define F_OK 0
110 #define X_OK 1
111 #define W_OK 2
112 #define R_OK 4
113 #endif
115 #if defined (XENIX) || defined (WINDOWSNT)
116 #include <sys/locking.h>
117 #endif
119 #ifdef MAIL_USE_LOCKF
120 #define MAIL_USE_SYSTEM_LOCK
121 #endif
123 #ifdef MAIL_USE_FLOCK
124 #define MAIL_USE_SYSTEM_LOCK
125 #endif
127 #ifdef MAIL_USE_MMDF
128 extern int lk_open (), lk_close ();
129 #endif
131 #if !defined (MAIL_USE_SYSTEM_LOCK) && !defined (MAIL_USE_MMDF) && \
132 defined (HAVE_LIBMAIL) && defined (HAVE_MAILLOCK_H)
133 #include <maillock.h>
134 /* We can't use maillock unless we know what directory system mail
135 files appear in. */
136 #ifdef MAILDIR
137 #define MAIL_USE_MAILLOCK
138 static char *mail_spool_name ();
139 #endif
140 #endif
142 #ifndef errno
143 extern int errno;
144 #endif
145 char *strerror ();
146 #ifdef HAVE_INDEX
147 extern char *index __P ((const char *, int));
148 #endif
149 #ifdef HAVE_RINDEX
150 extern char *rindex __P((const char *, int));
151 #endif
153 void fatal ();
154 void error ();
155 void pfatal_with_name ();
156 void pfatal_and_delete ();
157 char *concat ();
158 long *xmalloc ();
159 int popmail ();
160 int pop_retr ();
161 int mbx_write ();
162 int mbx_delimit_begin ();
163 int mbx_delimit_end ();
165 /* Nonzero means this is name of a lock file to delete on fatal error. */
166 char *delete_lockname;
169 main (argc, argv)
170 int argc;
171 char **argv;
173 char *inname, *outname;
174 int indesc, outdesc;
175 int nread;
176 WAITTYPE status;
177 int c, preserve_mail = 0;
179 #ifndef MAIL_USE_SYSTEM_LOCK
180 struct stat st;
181 long now;
182 int tem;
183 char *lockname, *p;
184 char *tempname;
185 int desc;
186 #endif /* not MAIL_USE_SYSTEM_LOCK */
188 #ifdef MAIL_USE_MAILLOCK
189 char *spool_name;
190 #endif
192 #ifdef MAIL_USE_POP
193 int pop_reverse_order = 0;
194 # define ARGSTR "pr"
195 #else /* ! MAIL_USE_POP */
196 # define ARGSTR "p"
197 #endif /* MAIL_USE_POP */
199 #ifdef WINDOWSNT
200 /* Ensure all file i/o is in binary mode. */
201 _fmode = _O_BINARY;
202 #endif
204 delete_lockname = 0;
206 while ((c = getopt (argc, argv, ARGSTR)) != EOF)
208 switch (c) {
209 #ifdef MAIL_USE_POP
210 case 'r':
211 pop_reverse_order = 1;
212 break;
213 #endif
214 case 'p':
215 preserve_mail++;
216 break;
217 default:
218 exit(1);
222 if (
223 #ifdef MAIL_USE_POP
224 (argc - optind < 2) || (argc - optind > 3)
225 #else
226 (argc - optind != 2)
227 #endif
230 fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n",
231 #ifdef MAIL_USE_POP
232 " [POP-password]"
233 #else
235 #endif
237 exit (1);
240 inname = argv[optind];
241 outname = argv[optind+1];
243 #ifdef MAIL_USE_MMDF
244 mmdf_init (argv[0]);
245 #endif
247 if (*outname == 0)
248 fatal ("Destination file name is empty", 0);
250 /* Check access to output file. */
251 if (access (outname, F_OK) == 0 && access (outname, W_OK) != 0)
252 pfatal_with_name (outname);
254 /* Also check that outname's directory is writable to the real uid. */
256 char *buf = (char *) xmalloc (strlen (outname) + 1);
257 char *p;
258 strcpy (buf, outname);
259 p = buf + strlen (buf);
260 while (p > buf && !IS_DIRECTORY_SEP (p[-1]))
261 *--p = 0;
262 if (p == buf)
263 *p++ = '.';
264 if (access (buf, W_OK) != 0)
265 pfatal_with_name (buf);
266 free (buf);
269 #ifdef MAIL_USE_POP
270 if (!strncmp (inname, "po:", 3))
272 int status;
274 status = popmail (inname + 3, outname, preserve_mail,
275 (argc - optind == 3) ? argv[optind+2] : NULL,
276 pop_reverse_order);
277 exit (status);
280 setuid (getuid ());
281 #endif /* MAIL_USE_POP */
283 #ifndef DISABLE_DIRECT_ACCESS
285 /* Check access to input file. */
286 if (access (inname, R_OK | W_OK) != 0)
287 pfatal_with_name (inname);
289 #ifndef MAIL_USE_MMDF
290 #ifndef MAIL_USE_SYSTEM_LOCK
291 #ifdef MAIL_USE_MAILLOCK
292 spool_name = mail_spool_name (inname);
293 if (! spool_name)
294 #endif
296 /* Use a lock file named after our first argument with .lock appended:
297 If it exists, the mail file is locked. */
298 /* Note: this locking mechanism is *required* by the mailer
299 (on systems which use it) to prevent loss of mail.
301 On systems that use a lock file, extracting the mail without locking
302 WILL occasionally cause loss of mail due to timing errors!
304 So, if creation of the lock file fails
305 due to access permission on the mail spool directory,
306 you simply MUST change the permission
307 and/or make movemail a setgid program
308 so it can create lock files properly.
310 You might also wish to verify that your system is one
311 which uses lock files for this purpose. Some systems use other methods.
313 If your system uses the `flock' system call for mail locking,
314 define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
315 and recompile movemail. If the s- file for your system
316 should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
317 to bug-gnu-emacs@prep.ai.mit.edu so we can fix it. */
319 lockname = concat (inname, ".lock", "");
320 tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
321 strcpy (tempname, inname);
322 p = tempname + strlen (tempname);
323 while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
324 p--;
325 *p = 0;
326 strcpy (p, "EXXXXXX");
327 mktemp (tempname);
328 unlink (tempname);
330 while (1)
332 /* Create the lock file, but not under the lock file name. */
333 /* Give up if cannot do that. */
334 desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
335 if (desc < 0)
337 char *message = (char *) xmalloc (strlen (tempname) + 50);
338 sprintf (message, "creating %s, which would become the lock file",
339 tempname);
340 pfatal_with_name (message);
342 close (desc);
344 tem = link (tempname, lockname);
345 unlink (tempname);
346 if (tem >= 0)
347 break;
348 sleep (1);
350 /* If lock file is five minutes old, unlock it.
351 Five minutes should be good enough to cope with crashes
352 and wedgitude, and long enough to avoid being fooled
353 by time differences between machines. */
354 if (stat (lockname, &st) >= 0)
356 now = time (0);
357 if (st.st_ctime < now - 300)
358 unlink (lockname);
362 delete_lockname = lockname;
364 #endif /* not MAIL_USE_SYSTEM_LOCK */
365 #endif /* not MAIL_USE_MMDF */
367 if (fork () == 0)
369 int lockcount = 0;
370 int status = 0;
371 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
372 long touched_lock, now;
373 #endif
375 setuid (getuid ());
377 #ifndef MAIL_USE_MMDF
378 #ifdef MAIL_USE_SYSTEM_LOCK
379 indesc = open (inname, O_RDWR);
380 #else /* if not MAIL_USE_SYSTEM_LOCK */
381 indesc = open (inname, O_RDONLY);
382 #endif /* not MAIL_USE_SYSTEM_LOCK */
383 #else /* MAIL_USE_MMDF */
384 indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
385 #endif /* MAIL_USE_MMDF */
387 if (indesc < 0)
388 pfatal_with_name (inname);
390 #if defined (BSD_SYSTEM) || defined (XENIX)
391 /* In case movemail is setuid to root, make sure the user can
392 read the output file. */
393 /* This is desirable for all systems
394 but I don't want to assume all have the umask system call */
395 umask (umask (0) & 0333);
396 #endif /* BSD_SYSTEM || XENIX */
397 outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
398 if (outdesc < 0)
399 pfatal_with_name (outname);
401 /* This label exists so we can retry locking
402 after a delay, if it got EAGAIN or EBUSY. */
403 retry_lock:
405 /* Try to lock it. */
406 #ifdef MAIL_USE_MAILLOCK
407 if (spool_name)
409 /* The "0 - " is to make it a negative number if maillock returns
410 non-zero. */
411 status = 0 - maillock (spool_name, 1);
412 #ifdef HAVE_TOUCHLOCK
413 touched_lock = time (0);
414 #endif
415 lockcount = 5;
417 else
418 #endif /* MAIL_USE_MAILLOCK */
420 #ifdef MAIL_USE_SYSTEM_LOCK
421 #ifdef MAIL_USE_LOCKF
422 status = lockf (indesc, F_LOCK, 0);
423 #else /* not MAIL_USE_LOCKF */
424 #ifdef XENIX
425 status = locking (indesc, LK_RLCK, 0L);
426 #else
427 #ifdef WINDOWSNT
428 status = locking (indesc, LK_RLCK, -1L);
429 #else
430 status = flock (indesc, LOCK_EX);
431 #endif
432 #endif
433 #endif /* not MAIL_USE_LOCKF */
434 #endif /* MAIL_USE_SYSTEM_LOCK */
437 /* If it fails, retry up to 5 times
438 for certain failure codes. */
439 if (status < 0)
441 if (++lockcount <= 5)
443 #ifdef EAGAIN
444 if (errno == EAGAIN)
446 sleep (1);
447 goto retry_lock;
449 #endif
450 #ifdef EBUSY
451 if (errno == EBUSY)
453 sleep (1);
454 goto retry_lock;
456 #endif
459 pfatal_with_name (inname);
463 char buf[1024];
465 while (1)
467 nread = read (indesc, buf, sizeof buf);
468 if (nread != write (outdesc, buf, nread))
470 int saved_errno = errno;
471 unlink (outname);
472 errno = saved_errno;
473 pfatal_with_name (outname);
475 if (nread < sizeof buf)
476 break;
477 #if defined (MAIL_USE_MAILLOCK) && defined (HAVE_TOUCHLOCK)
478 if (spool_name)
480 now = time (0);
481 if (now - touched_lock > 60)
483 touchlock ();
484 touched_lock = now;
487 #endif /* MAIL_USE_MAILLOCK */
491 #ifdef BSD_SYSTEM
492 if (fsync (outdesc) < 0)
493 pfatal_and_delete (outname);
494 #endif
496 /* Check to make sure no errors before we zap the inbox. */
497 if (close (outdesc) != 0)
498 pfatal_and_delete (outname);
500 #ifdef MAIL_USE_SYSTEM_LOCK
501 if (! preserve_mail)
503 #if defined (STRIDE) || defined (XENIX)
504 /* Stride, xenix have file locking, but no ftruncate.
505 This mess will do. */
506 close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
507 #else
508 ftruncate (indesc, 0L);
509 #endif /* STRIDE or XENIX */
511 #endif /* MAIL_USE_SYSTEM_LOCK */
513 #ifdef MAIL_USE_MMDF
514 lk_close (indesc, 0, 0, 0);
515 #else
516 close (indesc);
517 #endif
519 #ifndef MAIL_USE_SYSTEM_LOCK
520 if (! preserve_mail)
522 /* Delete the input file; if we can't, at least get rid of its
523 contents. */
524 #ifdef MAIL_UNLINK_SPOOL
525 /* This is generally bad to do, because it destroys the permissions
526 that were set on the file. Better to just empty the file. */
527 if (unlink (inname) < 0 && errno != ENOENT)
528 #endif /* MAIL_UNLINK_SPOOL */
529 creat (inname, 0600);
531 #endif /* not MAIL_USE_SYSTEM_LOCK */
533 #ifdef MAIL_USE_MAILLOCK
534 /* This has to occur in the child, i.e., in the process that
535 acquired the lock! */
536 if (spool_name)
537 mailunlock ();
538 #endif
539 exit (0);
542 wait (&status);
543 if (!WIFEXITED (status))
544 exit (1);
545 else if (WRETCODE (status) != 0)
546 exit (WRETCODE (status));
548 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
549 #ifdef MAIL_USE_MAILLOCK
550 if (! spool_name)
551 #endif /* MAIL_USE_MAILLOCK */
552 unlink (lockname);
553 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
555 #endif /* ! DISABLE_DIRECT_ACCESS */
557 return 0;
560 #ifdef MAIL_USE_MAILLOCK
561 /* This function uses stat to confirm that the mail directory is
562 identical to the directory of the input file, rather than just
563 string-comparing the two paths, because one or both of them might
564 be symbolic links pointing to some other directory. */
565 static char *
566 mail_spool_name (inname)
567 char *inname;
569 struct stat stat1, stat2;
570 char *indir, *fname;
571 int status;
573 if (! (fname = rindex (inname, '/')))
574 return NULL;
576 fname++;
578 if (stat (MAILDIR, &stat1) < 0)
579 return NULL;
581 indir = (char *) xmalloc (fname - inname + 1);
582 strncpy (indir, inname, fname - inname);
583 indir[fname-inname] = '\0';
586 status = stat (indir, &stat2);
588 free (indir);
590 if (status < 0)
591 return NULL;
593 if (stat1.st_dev == stat2.st_dev
594 && stat1.st_ino == stat2.st_ino)
595 return fname;
597 return NULL;
599 #endif /* MAIL_USE_MAILLOCK */
601 /* Print error message and exit. */
603 void
604 fatal (s1, s2)
605 char *s1, *s2;
607 if (delete_lockname)
608 unlink (delete_lockname);
609 error (s1, s2, 0);
610 exit (1);
613 /* Print error message. `s1' is printf control string, `s2' and `s3'
614 are args for it or null. */
616 void
617 error (s1, s2, s3)
618 char *s1, *s2, *s3;
620 fprintf (stderr, "movemail: ");
621 if (s3)
622 fprintf (stderr, s1, s2, s3);
623 else if (s2)
624 fprintf (stderr, s1, s2);
625 else
626 fprintf (stderr, s1);
627 fprintf (stderr, "\n");
630 void
631 pfatal_with_name (name)
632 char *name;
634 char *s = concat ("", strerror (errno), " for %s");
635 fatal (s, name);
638 void
639 pfatal_and_delete (name)
640 char *name;
642 char *s = concat ("", strerror (errno), " for %s");
643 unlink (name);
644 fatal (s, name);
647 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
649 char *
650 concat (s1, s2, s3)
651 char *s1, *s2, *s3;
653 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
654 char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
656 strcpy (result, s1);
657 strcpy (result + len1, s2);
658 strcpy (result + len1 + len2, s3);
659 *(result + len1 + len2 + len3) = 0;
661 return result;
664 /* Like malloc but get fatal error if memory is exhausted. */
666 long *
667 xmalloc (size)
668 unsigned size;
670 long *result = (long *) malloc (size);
671 if (!result)
672 fatal ("virtual memory exhausted", 0);
673 return result;
676 /* This is the guts of the interface to the Post Office Protocol. */
678 #ifdef MAIL_USE_POP
680 #ifndef WINDOWSNT
681 #include <sys/socket.h>
682 #include <netinet/in.h>
683 #include <netdb.h>
684 #else
685 #undef _WINSOCKAPI_
686 #include <winsock.h>
687 #endif
688 #include <pwd.h>
690 #define NOTOK (-1)
691 #define OK 0
692 #define DONE 1
694 char *progname;
695 FILE *sfi;
696 FILE *sfo;
697 char ibuffer[BUFSIZ];
698 char obuffer[BUFSIZ];
699 char Errmsg[200]; /* POP errors, at least, can exceed
700 the original length of 80. */
703 * The full legal syntax for a POP mailbox specification for movemail
704 * is "po:username:hostname". The ":hostname" is optional; if it is
705 * omitted, the MAILHOST environment variable will be consulted. Note
706 * that by the time popmail() is called the "po:" has been stripped
707 * off of the front of the mailbox name.
709 * If the mailbox is in the form "po:username:hostname", then it is
710 * modified by this function -- the second colon is replaced by a
711 * null.
715 popmail (mailbox, outfile, preserve, password, reverse_order)
716 char *mailbox;
717 char *outfile;
718 int preserve;
719 char *password;
720 int reverse_order;
722 int nmsgs, nbytes;
723 register int i;
724 int mbfi;
725 FILE *mbf;
726 char *getenv ();
727 popserver server;
728 int start, end, increment;
729 char *user, *hostname;
731 user = mailbox;
732 if ((hostname = index(mailbox, ':')))
733 *hostname++ = '\0';
735 server = pop_open (hostname, user, password, POP_NO_GETPASS);
736 if (! server)
738 error ("Error connecting to POP server: %s", pop_error, 0);
739 return (1);
742 if (pop_stat (server, &nmsgs, &nbytes))
744 error ("Error getting message count from POP server: %s", pop_error, 0);
745 return (1);
748 if (!nmsgs)
750 pop_close (server);
751 return (0);
754 mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
755 if (mbfi < 0)
757 pop_close (server);
758 error ("Error in open: %s, %s", strerror (errno), outfile);
759 return (1);
761 fchown (mbfi, getuid (), -1);
763 if ((mbf = fdopen (mbfi, "wb")) == NULL)
765 pop_close (server);
766 error ("Error in fdopen: %s", strerror (errno), 0);
767 close (mbfi);
768 unlink (outfile);
769 return (1);
772 if (reverse_order)
774 start = nmsgs;
775 end = 1;
776 increment = -1;
778 else
780 start = 1;
781 end = nmsgs;
782 increment = 1;
785 for (i = start; i * increment <= end * increment; i += increment)
787 mbx_delimit_begin (mbf);
788 if (pop_retr (server, i, mbf) != OK)
790 error (Errmsg, 0, 0);
791 close (mbfi);
792 return (1);
794 mbx_delimit_end (mbf);
795 fflush (mbf);
796 if (ferror (mbf))
798 error ("Error in fflush: %s", strerror (errno), 0);
799 pop_close (server);
800 close (mbfi);
801 return (1);
805 /* On AFS, a call to write only modifies the file in the local
806 * workstation's AFS cache. The changes are not written to the server
807 * until a call to fsync or close is made. Users with AFS home
808 * directories have lost mail when over quota because these checks were
809 * not made in previous versions of movemail. */
811 #ifdef BSD_SYSTEM
812 if (fsync (mbfi) < 0)
814 error ("Error in fsync: %s", strerror (errno));
815 return (1);
817 #endif
819 if (close (mbfi) == -1)
821 error ("Error in close: %s", strerror (errno), 0);
822 return (1);
825 if (! preserve)
826 for (i = 1; i <= nmsgs; i++)
828 if (pop_delete (server, i))
830 error ("Error from POP server: %s", pop_error, 0);
831 pop_close (server);
832 return (1);
836 if (pop_quit (server))
838 error ("Error from POP server: %s", pop_error, 0);
839 return (1);
842 return (0);
846 pop_retr (server, msgno, arg)
847 popserver server;
848 FILE *arg;
850 extern char *strerror ();
851 char *line;
852 int ret;
854 if (pop_retrieve_first (server, msgno, &line))
856 char *error = concat ("Error from POP server: ", pop_error, "");
857 strncpy (Errmsg, error, sizeof (Errmsg));
858 Errmsg[sizeof (Errmsg)-1] = '\0';
859 free(error);
860 return (NOTOK);
863 while ((ret = pop_retrieve_next (server, &line)) >= 0)
865 if (! line)
866 break;
868 if (mbx_write (line, ret, arg) != OK)
870 strcpy (Errmsg, strerror (errno));
871 pop_close (server);
872 return (NOTOK);
876 if (ret)
878 char *error = concat ("Error from POP server: ", pop_error, "");
879 strncpy (Errmsg, error, sizeof (Errmsg));
880 Errmsg[sizeof (Errmsg)-1] = '\0';
881 free(error);
882 return (NOTOK);
885 return (OK);
888 /* Do this as a macro instead of using strcmp to save on execution time. */
889 #define IS_FROM_LINE(a) ((a[0] == 'F') \
890 && (a[1] == 'r') \
891 && (a[2] == 'o') \
892 && (a[3] == 'm') \
893 && (a[4] == ' '))
896 mbx_write (line, len, mbf)
897 char *line;
898 int len;
899 FILE *mbf;
901 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
902 if (IS_FROM_LINE (line))
904 if (fputc ('>', mbf) == EOF)
905 return (NOTOK);
907 #endif
908 if (line[0] == '\037')
910 if (fputs ("^_", mbf) == EOF)
911 return (NOTOK);
912 line++;
913 len--;
915 if (fwrite (line, 1, len, mbf) != len)
916 return (NOTOK);
917 if (fputc (0x0a, mbf) == EOF)
918 return (NOTOK);
919 return (OK);
923 mbx_delimit_begin (mbf)
924 FILE *mbf;
926 if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
927 return (NOTOK);
928 return (OK);
932 mbx_delimit_end (mbf)
933 FILE *mbf;
935 if (putc ('\037', mbf) == EOF)
936 return (NOTOK);
937 return (OK);
940 #endif /* MAIL_USE_POP */
942 #ifndef HAVE_STRERROR
943 char *
944 strerror (errnum)
945 int errnum;
947 extern char *sys_errlist[];
948 extern int sys_nerr;
950 if (errnum >= 0 && errnum < sys_nerr)
951 return sys_errlist[errnum];
952 return (char *) "Unknown error";
955 #endif /* ! HAVE_STRERROR */