(Fsnarf_documentation): Doc fix.
[emacs.git] / lib-src / movemail.c
bloba634e2966d72514cae3ce9ffe1060c87439a4bc8
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_LIBLOCKFILE)) && \
133 defined (HAVE_MAILLOCK_H)
134 #include <maillock.h>
135 /* We can't use maillock unless we know what directory system mail
136 files appear in. */
137 #ifdef MAILDIR
138 #define MAIL_USE_MAILLOCK
139 static char *mail_spool_name ();
140 #endif
141 #endif
143 #ifndef errno
144 extern int errno;
145 #endif
146 char *strerror ();
147 #ifdef HAVE_INDEX
148 extern char *index __P ((const char *, int));
149 #endif
150 #ifdef HAVE_RINDEX
151 extern char *rindex __P((const char *, int));
152 #endif
154 void fatal ();
155 void error ();
156 void pfatal_with_name ();
157 void pfatal_and_delete ();
158 char *concat ();
159 long *xmalloc ();
160 int popmail ();
161 int pop_retr ();
162 int mbx_write ();
163 int mbx_delimit_begin ();
164 int mbx_delimit_end ();
166 /* Nonzero means this is name of a lock file to delete on fatal error. */
167 char *delete_lockname;
170 main (argc, argv)
171 int argc;
172 char **argv;
174 char *inname, *outname;
175 int indesc, outdesc;
176 int nread;
177 WAITTYPE status;
178 int c, preserve_mail = 0;
180 #ifndef MAIL_USE_SYSTEM_LOCK
181 struct stat st;
182 long now;
183 int tem;
184 char *lockname, *p;
185 char *tempname;
186 int desc;
187 #endif /* not MAIL_USE_SYSTEM_LOCK */
189 #ifdef MAIL_USE_MAILLOCK
190 char *spool_name;
191 #endif
193 #ifdef MAIL_USE_POP
194 int pop_reverse_order = 0;
195 # define ARGSTR "pr"
196 #else /* ! MAIL_USE_POP */
197 # define ARGSTR "p"
198 #endif /* MAIL_USE_POP */
200 #ifdef WINDOWSNT
201 /* Ensure all file i/o is in binary mode. */
202 _fmode = _O_BINARY;
203 #endif
205 delete_lockname = 0;
207 while ((c = getopt (argc, argv, ARGSTR)) != EOF)
209 switch (c) {
210 #ifdef MAIL_USE_POP
211 case 'r':
212 pop_reverse_order = 1;
213 break;
214 #endif
215 case 'p':
216 preserve_mail++;
217 break;
218 default:
219 exit (EXIT_FAILURE);
223 if (
224 #ifdef MAIL_USE_POP
225 (argc - optind < 2) || (argc - optind > 3)
226 #else
227 (argc - optind != 2)
228 #endif
231 #ifdef MAIL_USE_POP
232 fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n",
233 " [POP-password]");
234 #else
235 fprintf (stderr, "Usage: movemail [-p] inbox destfile%s\n", "");
236 #endif
237 exit (EXIT_FAILURE);
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 (EXIT_SUCCESS);
542 wait (&status);
543 if (!WIFEXITED (status))
544 exit (EXIT_FAILURE);
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 EXIT_SUCCESS;
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 (EXIT_FAILURE);
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.
713 * Return a value suitable for passing to `exit'.
717 popmail (mailbox, outfile, preserve, password, reverse_order)
718 char *mailbox;
719 char *outfile;
720 int preserve;
721 char *password;
722 int reverse_order;
724 int nmsgs, nbytes;
725 register int i;
726 int mbfi;
727 FILE *mbf;
728 char *getenv ();
729 popserver server;
730 int start, end, increment;
731 char *user, *hostname;
733 user = mailbox;
734 if ((hostname = index(mailbox, ':')))
735 *hostname++ = '\0';
737 server = pop_open (hostname, user, password, POP_NO_GETPASS);
738 if (! server)
740 error ("Error connecting to POP server: %s", pop_error, 0);
741 return EXIT_FAILURE;
744 if (pop_stat (server, &nmsgs, &nbytes))
746 error ("Error getting message count from POP server: %s", pop_error, 0);
747 return EXIT_FAILURE;
750 if (!nmsgs)
752 pop_close (server);
753 return EXIT_SUCCESS;
756 mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
757 if (mbfi < 0)
759 pop_close (server);
760 error ("Error in open: %s, %s", strerror (errno), outfile);
761 return EXIT_FAILURE;
763 fchown (mbfi, getuid (), -1);
765 if ((mbf = fdopen (mbfi, "wb")) == NULL)
767 pop_close (server);
768 error ("Error in fdopen: %s", strerror (errno), 0);
769 close (mbfi);
770 unlink (outfile);
771 return EXIT_FAILURE;
774 if (reverse_order)
776 start = nmsgs;
777 end = 1;
778 increment = -1;
780 else
782 start = 1;
783 end = nmsgs;
784 increment = 1;
787 for (i = start; i * increment <= end * increment; i += increment)
789 mbx_delimit_begin (mbf);
790 if (pop_retr (server, i, mbf) != OK)
792 error (Errmsg, 0, 0);
793 close (mbfi);
794 return EXIT_FAILURE;
796 mbx_delimit_end (mbf);
797 fflush (mbf);
798 if (ferror (mbf))
800 error ("Error in fflush: %s", strerror (errno), 0);
801 pop_close (server);
802 close (mbfi);
803 return EXIT_FAILURE;
807 /* On AFS, a call to write only modifies the file in the local
808 * workstation's AFS cache. The changes are not written to the server
809 * until a call to fsync or close is made. Users with AFS home
810 * directories have lost mail when over quota because these checks were
811 * not made in previous versions of movemail. */
813 #ifdef BSD_SYSTEM
814 if (fsync (mbfi) < 0)
816 error ("Error in fsync: %s", strerror (errno), 0);
817 return EXIT_FAILURE;
819 #endif
821 if (close (mbfi) == -1)
823 error ("Error in close: %s", strerror (errno), 0);
824 return EXIT_FAILURE;
827 if (! preserve)
828 for (i = 1; i <= nmsgs; i++)
830 if (pop_delete (server, i))
832 error ("Error from POP server: %s", pop_error, 0);
833 pop_close (server);
834 return EXIT_FAILURE;
838 if (pop_quit (server))
840 error ("Error from POP server: %s", pop_error, 0);
841 return EXIT_FAILURE;
844 return EXIT_SUCCESS;
848 pop_retr (server, msgno, arg)
849 popserver server;
850 int msgno;
851 FILE *arg;
853 extern char *strerror ();
854 char *line;
855 int ret;
857 if (pop_retrieve_first (server, msgno, &line))
859 char *error = concat ("Error from POP server: ", pop_error, "");
860 strncpy (Errmsg, error, sizeof (Errmsg));
861 Errmsg[sizeof (Errmsg)-1] = '\0';
862 free(error);
863 return (NOTOK);
866 while ((ret = pop_retrieve_next (server, &line)) >= 0)
868 if (! line)
869 break;
871 if (mbx_write (line, ret, arg) != OK)
873 strcpy (Errmsg, strerror (errno));
874 pop_close (server);
875 return (NOTOK);
879 if (ret)
881 char *error = concat ("Error from POP server: ", pop_error, "");
882 strncpy (Errmsg, error, sizeof (Errmsg));
883 Errmsg[sizeof (Errmsg)-1] = '\0';
884 free(error);
885 return (NOTOK);
888 return (OK);
891 /* Do this as a macro instead of using strcmp to save on execution time. */
892 #define IS_FROM_LINE(a) ((a[0] == 'F') \
893 && (a[1] == 'r') \
894 && (a[2] == 'o') \
895 && (a[3] == 'm') \
896 && (a[4] == ' '))
899 mbx_write (line, len, mbf)
900 char *line;
901 int len;
902 FILE *mbf;
904 #ifdef MOVEMAIL_QUOTE_POP_FROM_LINES
905 if (IS_FROM_LINE (line))
907 if (fputc ('>', mbf) == EOF)
908 return (NOTOK);
910 #endif
911 if (line[0] == '\037')
913 if (fputs ("^_", mbf) == EOF)
914 return (NOTOK);
915 line++;
916 len--;
918 if (fwrite (line, 1, len, mbf) != len)
919 return (NOTOK);
920 if (fputc (0x0a, mbf) == EOF)
921 return (NOTOK);
922 return (OK);
926 mbx_delimit_begin (mbf)
927 FILE *mbf;
929 if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
930 return (NOTOK);
931 return (OK);
935 mbx_delimit_end (mbf)
936 FILE *mbf;
938 if (putc ('\037', mbf) == EOF)
939 return (NOTOK);
940 return (OK);
943 #endif /* MAIL_USE_POP */
945 #ifndef HAVE_STRERROR
946 char *
947 strerror (errnum)
948 int errnum;
950 extern char *sys_errlist[];
951 extern int sys_nerr;
953 if (errnum >= 0 && errnum < sys_nerr)
954 return sys_errlist[errnum];
955 return (char *) "Unknown error";
958 #endif /* ! HAVE_STRERROR */
960 /* arch-tag: 1c323112-41fe-4fe5-8de9-494de631f73f
961 (do not change this comment) */
963 /* movemail.c ends here */