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.
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)
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
45 * main - added code within #ifdef MAIL_USE_POP; added setuid (getuid ())
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 #define DONT_ENCAPSULATE
59 #include <../src/config.h>
60 #include <sys/types.h>
65 #include "../src/sysfile.h"
66 #include "../src/syswait.h"
68 #include "../src/systime.h"
75 #include "../src/regex.h"
79 extern int optind, opterr;
82 char * strerror (int errnum);
83 #endif /* HAVE_STRERROR */
90 #define DIRECTORY_SEP '/'
92 #ifndef IS_DIRECTORY_SEP
93 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
100 #define sys_wait(var) (*(var) = 0)
101 /* Unfortunately, Samba doesn't seem to properly lock Unix files even
102 though the locking call succeeds (and indeed blocks local access from
103 other NT programs). If you have direct file access using an NFS
104 client or something other than Samba, the locking call might work
105 properly - make sure it does before you enable this! */
106 #define DISABLE_DIRECT_ACCESS
108 #endif /* WINDOWSNT */
110 #if defined (HAVE_UNISTD_H) || defined (USG)
112 #endif /* unistd.h */
120 #if defined (HAVE_FCNTL_H) || defined (USG)
124 #if defined (XENIX) || defined (WINDOWSNT)
125 #include <sys/locking.h>
128 #ifdef MAIL_USE_LOCKF
129 #define MAIL_USE_SYSTEM_LOCK
132 #ifdef MAIL_USE_FLOCK
133 #define MAIL_USE_SYSTEM_LOCK
137 extern int lk_open (), lk_close ();
140 /* Cancel substitutions made by config.h for Emacs. */
146 static void fatal (char *, char*);
147 static void error (char *, char *, char *);
148 static void pfatal_with_name (char *);
149 static void pfatal_and_delete (char *);
150 static char *concat (char *, char *, char *);
151 static long *xmalloc (unsigned int);
153 static int popmail (char *, char *, char *);
154 static int pop_retr (popserver server, int msgno, int (*action)(), void *arg);
155 static int mbx_write (char *, FILE *);
156 static int mbx_delimit_begin (FILE *);
157 static int mbx_delimit_end (FILE *);
158 static struct re_pattern_buffer* compile_regex (char* regexp_pattern);
159 static int pop_search_top (popserver server, int msgno, int lines,
160 struct re_pattern_buffer* regexp);
163 /* Nonzero means this is name of a lock file to delete on fatal error. */
164 char *delete_lockname;
170 struct re_pattern_buffer* regexp_pattern=0;
174 #define VERBOSE(x) if (verbose) { printf x; fflush(stdout); }
176 struct option longopts[] =
178 { "inbox", required_argument, NULL, 'i' },
179 { "outfile", required_argument, NULL, 'o' },
181 { "password", required_argument, NULL, 'p' },
182 { "reverse-pop-order", no_argument, NULL, 'x' },
183 { "keep-messages", no_argument, NULL, 'k' },
184 { "regex", required_argument, NULL, 'r' },
185 { "match-lines", required_argument, NULL, 'l' },
187 { "verbose", no_argument, NULL, 'v' },
192 main (int argc, char *argv[])
194 char *inname=0, *outname=0, *poppass=0;
195 #ifndef DISABLE_DIRECT_ACCESS
201 #ifndef MAIL_USE_SYSTEM_LOCK
208 #endif /* not MAIL_USE_SYSTEM_LOCK */
215 char* optstring = "i:o:p:l:r:xvk";
217 char* optstring = "i:o:v";
219 int opt = getopt_long (argc, argv, optstring, longopts, 0);
228 case 1: /* one of the standard arguments seen */
237 case 'i': /* infile */
241 case 'o': /* outfile */
245 case 'p': /* pop password */
248 case 'k': keep_messages=1; break;
249 case 'x': reverse = 1; break;
250 case 'l': /* lines to match */
251 match_lines = atoi (optarg);
254 case 'r': /* regular expression */
255 regexp_pattern = compile_regex (optarg);
258 case 'v': verbose = 1; break;
262 while (optind < argc)
265 inname = argv[optind];
267 outname = argv[optind];
269 poppass = argv[optind];
273 if (!inname || !outname)
275 fprintf (stderr, "Usage: movemail [-rvxk] [-l lines ] [-i] inbox [-o] destfile [[-p] POP-password]\n");
284 fatal ("Destination file name is empty", 0);
286 /* Check access to output file. */
287 if (access (outname, F_OK) == 0 && access (outname, W_OK) != 0)
288 pfatal_with_name (outname);
290 /* Also check that outname's directory is writable to the real uid. */
292 char *buf = (char *) xmalloc (strlen (outname) + 1);
294 strcpy (buf, outname);
295 cp = buf + strlen (buf);
296 while (cp > buf && !IS_DIRECTORY_SEP (cp[-1]))
300 if (access (buf, W_OK) != 0)
301 pfatal_with_name (buf);
306 if (!strncmp (inname, "po:", 3))
308 int retcode = popmail (inname + 3, outname, poppass);
315 #endif /* MAIL_USE_POP */
317 #ifndef DISABLE_DIRECT_ACCESS
319 /* Check access to input file. */
320 if (access (inname, R_OK | W_OK) != 0)
321 pfatal_with_name (inname);
323 #ifndef MAIL_USE_MMDF
324 #ifndef MAIL_USE_SYSTEM_LOCK
325 /* Use a lock file named after our first argument with .lock appended:
326 If it exists, the mail file is locked. */
327 /* Note: this locking mechanism is *required* by the mailer
328 (on systems which use it) to prevent loss of mail.
330 On systems that use a lock file, extracting the mail without locking
331 WILL occasionally cause loss of mail due to timing errors!
333 So, if creation of the lock file fails
334 due to access permission on the mail spool directory,
335 you simply MUST change the permission
336 and/or make movemail a setgid program
337 so it can create lock files properly.
339 You might also wish to verify that your system is one
340 which uses lock files for this purpose. Some systems use other methods.
342 If your system uses the `flock' system call for mail locking,
343 define MAIL_USE_SYSTEM_LOCK in config.h or the s-*.h file
344 and recompile movemail. If the s- file for your system
345 should define MAIL_USE_SYSTEM_LOCK but does not, send a bug report
346 to bug-gnu-emacs@prep.ai.mit.edu so we can fix it. */
348 lockname = concat (inname, ".lock", "");
349 tempname = (char *) xmalloc (strlen (inname) + strlen ("EXXXXXX") + 1);
350 strcpy (tempname, inname);
351 p = tempname + strlen (tempname);
352 while (p != tempname && !IS_DIRECTORY_SEP (p[-1]))
355 strcpy (p, "EXXXXXX");
361 /* Create the lock file, but not under the lock file name. */
362 /* Give up if cannot do that. */
363 desc = open (tempname, O_WRONLY | O_CREAT | O_EXCL, 0666);
366 char *message = (char *) xmalloc (strlen (tempname) + 50);
367 sprintf (message, "%s--see source file lib-src/movemail.c",
369 pfatal_with_name (message);
373 tem = link (tempname, lockname);
379 /* If lock file is five minutes old, unlock it.
380 Five minutes should be good enough to cope with crashes
381 and wedgitude, and long enough to avoid being fooled
382 by time differences between machines. */
383 if (stat (lockname, &st) >= 0)
386 if (st.st_ctime < now - 300)
391 delete_lockname = lockname;
392 #endif /* not MAIL_USE_SYSTEM_LOCK */
393 #endif /* not MAIL_USE_MMDF */
399 #ifndef MAIL_USE_MMDF
400 #ifdef MAIL_USE_SYSTEM_LOCK
401 indesc = open (inname, O_RDWR);
402 #else /* if not MAIL_USE_SYSTEM_LOCK */
403 indesc = open (inname, O_RDONLY);
404 #endif /* not MAIL_USE_SYSTEM_LOCK */
405 #else /* MAIL_USE_MMDF */
406 indesc = lk_open (inname, O_RDONLY, 0, 0, 10);
407 #endif /* MAIL_USE_MMDF */
410 pfatal_with_name (inname);
412 #if defined (BSD) || defined (XENIX)
413 /* In case movemail is setuid to root, make sure the user can
414 read the output file. */
415 /* This is desirable for all systems
416 but I don't want to assume all have the umask system call */
417 umask (umask (0) & 0333);
418 #endif /* BSD or Xenix */
419 outdesc = open (outname, O_WRONLY | O_CREAT | O_EXCL, 0666);
421 pfatal_with_name (outname);
422 #ifdef MAIL_USE_SYSTEM_LOCK
423 #ifdef MAIL_USE_LOCKF
424 if (lockf (indesc, F_LOCK, 0) < 0) pfatal_with_name (inname);
425 #else /* not MAIL_USE_LOCKF */
427 if (locking (indesc, LK_RLCK, 0L) < 0) pfatal_with_name (inname);
430 if (locking (indesc, LK_RLCK, -1L) < 0) pfatal_with_name (inname);
432 if (flock (indesc, LOCK_EX) < 0) pfatal_with_name (inname);
435 #endif /* not MAIL_USE_LOCKF */
436 #endif /* MAIL_USE_SYSTEM_LOCK */
443 nread = read (indesc, buf, sizeof buf);
444 if (nread != write (outdesc, buf, nread))
446 int saved_errno = errno;
449 pfatal_with_name (outname);
451 if (nread < sizeof buf)
457 if (fsync (outdesc) < 0)
458 pfatal_and_delete (outname);
461 /* Check to make sure no errors before we zap the inbox. */
462 if (close (outdesc) != 0)
463 pfatal_and_delete (outname);
465 #ifdef MAIL_USE_SYSTEM_LOCK
466 #if defined (STRIDE) || defined (XENIX) || defined (WINDOWSNT)
467 /* Stride, xenix have file locking, but no ftruncate. This mess will do. */
468 close (open (inname, O_CREAT | O_TRUNC | O_RDWR, 0666));
470 ftruncate (indesc, 0L);
471 #endif /* STRIDE or XENIX */
472 #endif /* MAIL_USE_SYSTEM_LOCK */
475 lk_close (indesc, 0, 0, 0);
480 #ifndef MAIL_USE_SYSTEM_LOCK
481 /* Delete the input file; if we can't, at least get rid of its
483 #ifdef MAIL_UNLINK_SPOOL
484 /* This is generally bad to do, because it destroys the permissions
485 that were set on the file. Better to just empty the file. */
486 if (unlink (inname) < 0 && errno != ENOENT)
487 #endif /* MAIL_UNLINK_SPOOL */
488 creat (inname, 0600);
489 #endif /* not MAIL_USE_SYSTEM_LOCK */
495 if (!WIFEXITED (status))
497 else if (WEXITSTATUS (status) != 0)
498 exit (WEXITSTATUS (status));
500 #if !defined (MAIL_USE_MMDF) && !defined (MAIL_USE_SYSTEM_LOCK)
502 #endif /* not MAIL_USE_MMDF and not MAIL_USE_SYSTEM_LOCK */
504 #endif /* ! DISABLE_DIRECT_ACCESS */
509 /* Print error message and exit. */
512 fatal (char *s1, char *s2)
515 unlink (delete_lockname);
516 error (s1, s2, NULL);
520 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
523 error (char *s1, char *s2, char *s3)
525 fprintf (stderr, "movemail: ");
526 fprintf (stderr, s1, s2, s3);
527 fprintf (stderr, "\n");
531 pfatal_with_name (char *name)
533 char *s = concat ("", strerror (errno), " for %s");
538 pfatal_and_delete (char *name)
540 char *s = concat ("", strerror (errno), " for %s");
545 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
548 concat (char *s1, char *s2, char *s3)
550 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
551 char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
554 strcpy (result + len1, s2);
555 strcpy (result + len1 + len2, s3);
556 *(result + len1 + len2 + len3) = 0;
561 /* Like malloc but get fatal error if memory is exhausted. */
564 xmalloc (unsigned int size)
566 long *result = (long *) malloc (size);
568 fatal ("virtual memory exhausted", 0);
572 /* This is the guts of the interface to the Post Office Protocol. */
577 #include <sys/socket.h>
578 #include <netinet/in.h>
587 #define POP_ERROR (-1)
588 #define POP_RETRIEVED (0)
594 char ibuffer[BUFSIZ];
595 char obuffer[BUFSIZ];
599 popmail (char *user, char *outfile, char *password)
604 short* retrieved_list;
608 VERBOSE(("opening server\r"));
609 server = pop_open (0, user, password, POP_NO_GETPASS);
612 error (pop_error, NULL, NULL);
616 VERBOSE(("stat'ing messages\r"));
617 if (pop_stat (server, &nmsgs, &nbytes))
619 error (pop_error, NULL, NULL);
625 VERBOSE(("closing server\n"));
630 /* build a retrieved table */
631 retrieved_list = (short*) xmalloc (sizeof (short) * (nmsgs+1));
632 memset (retrieved_list, 0, sizeof (short) * (nmsgs+1));
634 mbfi = open (outfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
638 error ("Error in open: %s, %s", strerror (errno), outfile);
641 #if !defined(__CYGWIN32__) && !defined(WINDOWSNT)
642 fchown (mbfi, getuid (), -1);
645 if ((mbf = fdopen (mbfi, "wb")) == NULL)
648 error ("Error in fdopen: %s", strerror (errno), NULL);
654 for (idx = 0; idx < nmsgs; idx++)
656 i = reverse ? nmsgs - idx : idx + 1;
657 VERBOSE(("checking message %d \r", i));
661 pop_search_top (server, i, match_lines, regexp_pattern) == POP_RETRIEVED)
663 VERBOSE(("retrieving message %d \r", i));
664 mbx_delimit_begin (mbf);
665 if (pop_retr (server, i, mbx_write, mbf) != POP_RETRIEVED)
667 error (Errmsg, NULL, NULL);
674 mbx_delimit_end (mbf);
678 error ("Error in fflush: %s", strerror (errno), NULL);
686 /* On AFS, a call to write only modifies the file in the local
687 * workstation's AFS cache. The changes are not written to the server
688 * until a call to fsync or close is made. Users with AFS home
689 * directories have lost mail when over quota because these checks were
690 * not made in previous versions of movemail. */
693 if (fsync (mbfi) < 0)
695 error ("Error in fsync: %s", strerror (errno), NULL);
700 if (close (mbfi) == -1)
702 error ("Error in close: %s", strerror (errno), NULL);
708 for (i = 1; i <= nmsgs; i++)
710 if (retrieved_list[i] == 1)
712 VERBOSE(("deleting message %d \r", i));
713 if (pop_delete (server, i))
715 error (pop_error, NULL, NULL);
723 VERBOSE(("closing server \n"));
724 if (pop_quit (server))
726 error (pop_error, NULL, NULL);
734 pop_retr (popserver server, int msgno, int (*action)(), void *arg)
739 if (pop_retrieve_first (server, msgno, &line))
741 strncpy (Errmsg, pop_error, sizeof (Errmsg));
742 Errmsg[sizeof (Errmsg)-1] = '\0';
746 while (! (ret = pop_retrieve_next (server, &line)))
751 if ((*action)(line, arg) != POP_RETRIEVED)
753 strcpy (Errmsg, strerror (errno));
761 strncpy (Errmsg, pop_error, sizeof (Errmsg));
762 Errmsg[sizeof (Errmsg)-1] = '\0';
766 return (POP_RETRIEVED);
769 /* search the top lines of each message looking for a match */
771 pop_search_top (popserver server, int msgno, int lines, struct re_pattern_buffer* regexp)
775 int match = POP_DONE;
777 if (pop_top_first (server, msgno, lines, &line))
779 strncpy (Errmsg, pop_error, sizeof (Errmsg));
780 Errmsg[sizeof (Errmsg)-1] = '\0';
784 while (! (ret = pop_top_next (server, &line)))
789 /* VERBOSE (("checking %s\n", line));*/
790 if (match != POP_RETRIEVED)
792 if ((ret = re_match (regexp, line, strlen (line), 0, 0)) == -2 )
794 strcpy (Errmsg, "error in regular expression");
800 match = POP_RETRIEVED;
807 strncpy (Errmsg, pop_error, sizeof (Errmsg));
808 Errmsg[sizeof (Errmsg)-1] = '\0';
815 /* Do this as a macro instead of using strcmp to save on execution time. */
816 #define IS_FROM_LINE(a) ((a[0] == 'F') \
823 mbx_write (char *line, FILE *mbf)
825 if (IS_FROM_LINE (line))
827 if (fputc ('>', mbf) == EOF)
830 if (fputs (line, mbf) == EOF)
832 if (fputc (0x0a, mbf) == EOF)
834 return (POP_RETRIEVED);
838 mbx_delimit_begin (FILE *mbf)
840 if (fputs ("\f\n0, unseen,,\n", mbf) == EOF)
842 return (POP_RETRIEVED);
846 mbx_delimit_end (FILE *mbf)
848 if (putc ('\037', mbf) == EOF)
850 return (POP_RETRIEVED);
853 /* Turn a name, which is an ed-style (but Emacs syntax) regular
854 expression, into a real regular expression by compiling it. */
855 static struct re_pattern_buffer*
856 compile_regex (char* pattern)
859 struct re_pattern_buffer *patbuf=0;
861 patbuf = (struct re_pattern_buffer*) xmalloc (sizeof (struct re_pattern_buffer));
862 patbuf->translate = NULL;
863 patbuf->fastmap = NULL;
864 patbuf->buffer = NULL;
865 patbuf->allocated = 0;
867 err = (char*) re_compile_pattern (pattern, strlen (pattern), patbuf);
870 error ("%s while compiling pattern", err, NULL);
879 #endif /* MAIL_USE_POP */
881 #ifndef HAVE_STRERROR
883 strerror (int errnum)
885 extern char *sys_errlist[];
888 if (errnum >= 0 && errnum < sys_nerr)
889 return sys_errlist[errnum];
890 return (char *) "Unknown error";
893 #endif /* ! HAVE_STRERROR */