2 * fetchmail.c -- main driver module for fetchmail
4 * For license terms, see the file COPYING in this directory.
20 #include <sys/types.h>
22 #include <sys/resource.h>
25 #include <socks.h> /* SOCKSinit() */
26 #endif /* HAVE_SOCKS */
30 #include "fetchmail.h"
38 /* need these (and sys/types.h) for res_init() */
39 #include <netinet/in.h>
40 #include <arpa/nameser.h>
44 #define ENETUNREACH 128 /* Interactive doesn't know this */
45 #endif /* ENETUNREACH */
47 /* prototypes for internal functions */
48 static int load_params(int, char **, int);
49 static void dump_params (struct runctl *runp, struct query *, flag implicit);
50 static int query_host(struct query *);
52 /* controls the detail level of status/progress messages written to stderr */
53 int outlevel; /* see the O_.* constants above */
55 /* miscellaneous global controls */
56 struct runctl run; /* global controls for this run */
57 flag nodetach; /* if TRUE, don't detach daemon process */
58 flag quitmode; /* if --quit was set */
59 int quitind; /* optind after position of last --quit option */
60 flag check_only; /* if --probe was set */
61 flag versioninfo; /* emit only version info */
62 char *user; /* the name of the invoking user */
63 char *home; /* invoking user's home directory */
64 char *fmhome; /* fetchmail's home directory */
65 const char *program_name; /* the name to prefix error messages with */
66 flag configdump; /* dump control blocks for configurator */
67 const char *fetchmailhost; /* either `localhost' or the host's FQDN */
69 static int quitonly; /* if we should quit after killing the running daemon */
71 static int querystatus; /* status of query */
72 static int successes; /* count number of successful polls */
73 static int activecount; /* count number of active entries */
74 static struct runctl cmd_run; /* global options set from command line */
75 static time_t parsetime; /* time of last parse */
77 static void terminate_run(int);
78 static void terminate_poll(int);
81 static pwm_t *pwm; /* the handle */
82 static const char *pwmd_socket; /* current socket */
83 static const char *pwmd_file; /* current file */
86 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
87 /* drop SGID kmem privileage until we need it */
88 static void dropprivs(void)
98 if (gr && !strcmp(gr->gr_name, "kmem"))
100 extern void interface_set_gids(gid_t egid, gid_t rgid);
101 interface_set_gids(egid, rgid);
108 #if defined(ENABLE_NLS)
109 /** returns timestamp in current locale,
110 * and resets LC_TIME locale to POSIX. */
111 static char *timestamp (void)
114 static char buf[60]; /* RATS: ignore */
117 setlocale (LC_TIME, "");
118 strftime (buf, sizeof (buf), "%c", localtime(&now));
119 setlocale (LC_TIME, "C");
123 #define timestamp rfc822timestamp
126 static void donothing(int sig)
128 set_signal_handler(sig, donothing);
132 static void printcopyright(FILE *fp) {
133 fprintf(fp, GT_("Copyright (C) 2002, 2003 Eric S. Raymond\n"
134 "Copyright (C) 2004 Matthias Andree, Eric S. Raymond,\n"
135 " Robert M. Funk, Graham Wilson\n"
136 "Copyright (C) 2005 - 2012 Matthias Andree, Sunil Shetye\n"
138 fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
139 "are welcome to redistribute it under certain conditions. For details,\n"
140 "please see the file COPYING in the source or documentation directory.\n"));
142 /* Do not translate this */
143 fprintf(fp, "This product includes software developed by the OpenSSL Project\nfor use in the OpenSSL Toolkit. (http://www.openssl.org/)\n");
147 const char *iana_charset;
150 static void exit_with_pwmd_error(gpg_error_t error)
152 gpg_err_code_t code = gpg_err_code(error);
154 report(stderr, GT_("pwmd: error %i: %s\n"), code, pwmd_strerror(error));
161 /* Don't exit if daemonized. There may be other active accounts. */
166 static int do_pwmd_connect(const char *socketname, const char *filename)
177 if (!pwm || (pwm && socketname && !pwmd_socket) ||
178 (pwm && !socketname && pwmd_socket) ||
179 (pwm && socketname && pwmd_socket && strcmp(socketname, pwmd_socket))) {
183 pwm = pwmd_new("Fetchmail");
184 rc = pwmd_connect_url(pwm, socketname);
187 exit_with_pwmd_error(rc);
192 if (run.pinentry_timeout > 0) {
193 rc = pwmd_setopt(pwm, PWMD_OPTION_PINENTRY_TIMEOUT,
194 run.pinentry_timeout);
197 exit_with_pwmd_error(rc);
202 rc = pwmd_socket_type(pwm, &s);
205 exit_with_pwmd_error(rc);
209 if (!pwmd_file || strcmp(filename, pwmd_file)) {
210 if (s == PWMD_SOCKET_SSH)
211 /* use a local pinentry since X11 forwarding is broken. */
212 rc = pwmd_open2(pwm, filename);
214 rc = pwmd_open(pwm, filename);
217 exit_with_pwmd_error(rc);
222 /* May be null to use the default of ~/.pwmd/socket. */
223 pwmd_socket = socketname;
224 pwmd_file = filename;
228 static int get_pwmd_details(const char *pwmd_account, int protocol,
231 const char *prot = showproto(protocol);
234 char *tmp = xstrdup(pwmd_account);
237 for (i = 0; tmp[i]; i++) {
238 if (i && tmp[i] == '^')
243 * Get the hostname for this protocol. Element path must be
244 * account->[protocol]->hostname.
246 error = pwmd_command(pwm, &result, "GET %s\t%s\thostname", tmp, prot);
249 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
250 report(stderr, GT_("pwmd: %s->%s->hostname: %s\n"), pwmd_account, prot, pwmd_strerror(error));
260 exit_with_pwmd_error(error);
265 if (ctl->server.pollname != ctl->server.via)
266 xfree(ctl->server.via);
268 ctl->server.via = xstrdup(result);
270 if (ctl->server.queryname)
271 xfree(ctl->server.queryname);
273 ctl->server.queryname = xstrdup(ctl->server.via);
275 if (ctl->server.truename)
276 xfree(ctl->server.truename);
278 ctl->server.truename = xstrdup(ctl->server.queryname);
282 * Server port. Fetchmail tries standard ports for known services so it
283 * should be alright if this element isn't found. ctl->server.protocol is
284 * already set. This sets ctl->server.service.
286 error = pwmd_command(pwm, &result, "GET %s\t%s\tport", tmp, prot);
289 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND)
290 report(stderr, GT_("pwmd: %s->%s->port: %s\n"), pwmd_account, prot, pwmd_strerror(error));
292 exit_with_pwmd_error(error);
297 if (ctl->server.service)
298 xfree(ctl->server.service);
300 ctl->server.service = xstrdup(result);
305 * Get the remote username. Element must be account->username.
307 error = pwmd_command(pwm, &result, "GET %s\tusername", tmp);
310 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
311 report(stderr, GT_("pwmd: %s->username: %s\n"), pwmd_account, pwmd_strerror(error));
320 exit_with_pwmd_error(error);
326 xfree(ctl->remotename);
328 if (ctl->server.esmtp_name)
329 xfree(ctl->server.esmtp_name);
331 ctl->remotename = xstrdup(result);
332 ctl->server.esmtp_name = xstrdup(result);
337 * Get the remote password. Element must be account->password.
339 error = pwmd_command(pwm, &result, "GET %s\tpassword", tmp);
342 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
343 report(stderr, GT_("pwmd: %s->password: %s\n"), pwmd_account, pwmd_strerror(error));
352 exit_with_pwmd_error(error);
358 xfree(ctl->password);
360 ctl->password= xstrdup(result);
366 * If there is a ssl element and set to 1, enable ssl for this account.
367 * Element path must be account->[protocol]->ssl.
369 error = pwmd_command(pwm, &result, "GET %s\t%s\tssl", tmp, prot);
372 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
373 report(stderr, GT_("pwmd: %s->%s->ssl: %s\n"), pwmd_account, prot, pwmd_strerror(error));
382 exit_with_pwmd_error(error);
387 ctl->use_ssl = atoi(result) >= 1 ? FLAG_TRUE : FLAG_FALSE;
392 * account->[protocol]->sslfingerprint.
394 error = pwmd_command(pwm, &result, "GET %s\t%s\tsslfingerprint", tmp, prot);
397 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
398 report(stderr, GT_("pwmd: %s->%s->sslfingerprint: %s\n"), pwmd_account, prot, pwmd_strerror(error));
407 exit_with_pwmd_error(error);
412 if (ctl->sslfingerprint)
413 xfree(ctl->sslfingerprint);
415 ctl->sslfingerprint = xstrdup(result);
424 int main(int argc, char **argv)
427 int implicitmode = FALSE;
428 flag safewithbg = FALSE; /** if parsed options are compatible with a
429 fetchmail copy running in the background */
431 netrc_entry *netrc_list;
432 char *netrc_file, *tmpbuf;
436 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
440 envquery(argc, argv);
442 setlocale (LC_ALL, "");
443 bindtextdomain(PACKAGE, LOCALEDIR);
445 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
449 iana_charset = "US-ASCII";
453 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
457 * Note: because we can't initialize reporting before we know whether
458 * syslog is supposed to be on, this message will go to stdout and
459 * be lost when running in background.
461 if (outlevel >= O_VERBOSE)
465 report(stdout, GT_("fetchmail: invoked with"));
466 for (i = 0; i < argc; i++)
467 report(stdout, " %s", argv[i]);
468 report(stdout, "\n");
471 #define IDFILE_NAME ".fetchids"
472 run.idfile = prependdir (IDFILE_NAME, fmhome);
476 * We used to arrange for the lock to be removed on exit close
477 * to where the lock was asserted. Now we need to do it here, because
478 * we might have re-executed in background with an existing lock
479 * as the result of a changed rcfile (see the code near the execvp(3)
480 * call near the beginning of the polling loop for details). We want
481 * to be sure the lock gets nuked on any error exit, basically.
486 /* save the current directory */
487 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
488 report(stderr, GT_("could not get current working directory\n"));
496 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts, &safewithbg);
500 if (quitmode && quitind == argc)
506 const char *features =
509 #endif /* POP3_ENABLE */
512 #endif /* IMAP_ENABLE */
518 #endif /* RPA_ENABLE */
521 #endif /* NTLM_ENABLE */
524 #endif /* SDPS_ENABLE */
527 #endif /* ETRN_ENABLE */
530 #endif /* ODMR_ENABLE */
536 #endif /* OPIE_ENABLE */
537 #ifdef HAVE_PKG_hesiod
542 #endif /* HAVE_SOCKS */
545 #endif /* ENABLE_NLS */
548 #endif /* KERBEROS_V5 */
551 #endif /* HAVE_LIBPWMD */
553 printf(GT_("This is fetchmail release %s"), VERSION);
554 fputs(features, stdout);
556 printcopyright(stdout);
558 fputs("Fallback MDA: ", stdout);
560 fputs(FALLBACK_MDA, stdout);
562 fputs("(none)", stdout);
567 /* this is an attempt to help remote debugging */
568 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
571 /* avoid parsing the config file if all we're doing is killing a daemon */
573 implicitmode = load_params(argc, argv, optind);
576 /* nodetach -> turn off logfile option */
578 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("The nodetach option is in effect, ignoring logfile option.\n")); }
583 /* not in daemon mode -> turn off logfile option */
584 if (0 == run.poll_interval) {
585 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Not running in daemon mode, ignoring logfile option.\n")); }
590 /* log file not writable -> turn off logfile option */
591 if (run.logfile && 0 != access(run.logfile, F_OK)) {
592 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Logfile \"%s\" does not exist, ignoring logfile option.\n"), run.logfile); }
596 /* log file not writable -> turn off logfile option */
597 if (run.logfile && 0 != access(run.logfile, W_OK)) {
598 fprintf(stderr, GT_("Logfile \"%s\" is not writable, aborting.\n"), run.logfile);
604 /* logging should be set up early in case we were restarted from exec */
607 openlog(program_name, LOG_PID, LOG_MAIL);
608 /* precedence: logfile (if effective) overrides syslog. */
610 syslog(LOG_ERR, GT_("syslog and logfile options are both set, ignoring syslog, and logging to %s"), run.logfile);
612 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy below, too */
618 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy above, too */
621 /* initialize UID handling */
625 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
628 initialize_saved_lists(querylist, run.idfile);
630 #endif /* POP3_ENABLE */
632 /* construct the lockfile */
636 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
637 * Core dumps could otherwise contain passwords to be scavenged by a
640 if (outlevel < O_VERBOSE || run.poll_interval > 0)
642 struct rlimit corelimit;
643 corelimit.rlim_cur = 0;
644 corelimit.rlim_max = 0;
645 setrlimit(RLIMIT_CORE, &corelimit);
648 #define NETRC_FILE ".netrc"
649 /* parse the ~/.netrc file (if present) for future password lookups. */
650 netrc_file = prependdir (NETRC_FILE, home);
651 netrc_list = parse_netrc(netrc_file);
655 /* pick up passwords where we can */
656 for (ctl = querylist; ctl; ctl = ctl->next)
658 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
660 if (NO_PASSWORD(ctl))
661 /* Server won't care what the password is, but there
662 must be some non-null string here. */
663 ctl->password = ctl->remotename;
668 /* look up the pollname and account in the .netrc file. */
669 p = search_netrc(netrc_list,
670 ctl->server.pollname, ctl->remotename);
671 /* if we find a matching entry with a password, use it */
672 if (p && p->password)
673 ctl->password = xstrdup(p->password);
675 /* otherwise try with "via" name if there is one */
676 else if (ctl->server.via)
678 p = search_netrc(netrc_list,
679 ctl->server.via, ctl->remotename);
680 if (p && p->password)
681 ctl->password = xstrdup(p->password);
687 free_netrc(netrc_list);
690 /* perhaps we just want to check options? */
693 int havercfile = access(rcfile, 0);
695 printf(GT_("Taking options from command line%s%s\n"),
696 havercfile ? "" : GT_(" and "),
697 havercfile ? "" : rcfile);
699 if (querylist == NULL)
701 GT_("No mailservers set up -- perhaps %s is missing?\n"),
704 dump_params(&run, querylist, implicitmode);
708 /* dump options as a Python dictionary, for configurator use */
711 dump_config(&run, querylist);
715 /* check for another fetchmail running concurrently */
716 pid = fm_lock_state();
718 pid = bkgd ? -pid : pid;
720 /* if no mail servers listed and nothing in background, we're done */
721 if (!quitonly && pid == 0 && querylist == NULL) {
722 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
726 /* perhaps user asked us to kill the other fetchmail */
729 if (pid == 0 || pid == getpid())
730 /* this test enables re-execing on a changed rcfile
731 * for pid == getpid() */
734 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
738 else if (kill(pid, SIGTERM) < 0)
740 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
741 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
748 if (outlevel > O_SILENT)
749 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
750 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
751 /* We used to nuke the other process's lock here, with
752 * fm_lock_release(), which is broken. The other process
753 * needs to clear its lock by itself. */
757 /* wait for other process to exit */
758 maxwait = 10; /* seconds */
759 while (kill(pid, 0) == 0 && --maxwait >= 0) {
766 /* another fetchmail is running -- wake it up or die */
772 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
775 else if (!implicitmode)
778 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
785 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
789 else if (getpid() == pid)
790 /* this test enables re-execing on a changed rcfile */
792 else if (argc > 1 && !safewithbg)
795 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
798 fprintf(stderr, "argc = %d, arg list:\n", argc);
799 for (i = 1; i < argc; i++) fprintf(stderr, "arg %d = \"%s\"\n", i, argv[i]);
803 else if (kill(pid, SIGUSR1) == 0)
805 if (outlevel > O_SILENT)
807 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
814 * Should never happen -- possible only if a background fetchmail
815 * croaks after the first kill probe above but before the
816 * SIGUSR1/SIGHUP transmission.
819 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
821 return(PS_UNDEFINED);
825 /* pick up interactively any passwords we need but don't have */
826 for (ctl = querylist; ctl; ctl = ctl->next)
828 if (ctl->active && !(implicitmode && ctl->server.skip)
829 && !NO_PASSWORD(ctl) && !ctl->password)
834 GT_("fetchmail: can't find a password for %s@%s.\n"),
835 ctl->remotename, ctl->server.pollname);
838 const char* password_prompt = GT_("Enter password for %s@%s: ");
839 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
841 tmpbuf = (char *)xmalloc(pplen);
842 snprintf(tmpbuf, pplen, password_prompt,
843 ctl->remotename, ctl->server.pollname);
844 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
851 * Time to initiate the SOCKS library (this is not mandatory: it just
852 * registers the correct application name for logging purpose. If you
853 * have some problem, comment out these lines).
856 SOCKSinit("fetchmail");
857 #endif /* HAVE_SOCKS */
859 /* avoid zombies from plugins */
862 /* Fix up log destination - if the if() is true, the precedence rule
863 * above hasn't killed off the syslog option, because the logfile
864 * option is ineffective (because we're not detached or not in
865 * deamon mode), so kill it for the benefit of other parts of the
867 if (run.logfile && run.use_syslog)
871 * Maybe time to go to demon mode...
873 if (run.poll_interval)
878 rc = daemonize(run.logfile);
880 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
884 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
887 * We'll set up a handler for these when we're sleeping,
888 * but ignore them otherwise so as not to interrupt a poll.
890 set_signal_handler(SIGUSR1, SIG_IGN);
891 if (run.poll_interval && getuid() == ROOT_UID)
892 set_signal_handler(SIGHUP, SIG_IGN);
896 /* not in daemon mode */
899 if (!freopen(run.logfile, "a", stdout))
900 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
901 if (!freopen(run.logfile, "a", stderr))
902 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
908 /* beyond here we don't want more than one fetchmail running per user */
910 set_signal_handler(SIGABRT, terminate_run);
911 set_signal_handler(SIGINT, terminate_run);
912 set_signal_handler(SIGTERM, terminate_run);
913 set_signal_handler(SIGALRM, terminate_run);
914 set_signal_handler(SIGPIPE, SIG_IGN);
915 set_signal_handler(SIGQUIT, terminate_run);
917 /* here's the exclusion lock */
920 if (check_only && outlevel >= O_VERBOSE) {
921 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
925 * Query all hosts. If there's only one, the error return will
926 * reflect the status of that transaction.
930 * Check to see if the rcfile has been touched. If so,
931 * re-exec so the file will be reread. Doing it this way
932 * avoids all the complications of trying to deallocate the
933 * in-core control structures -- and the potential memory
943 if (strcmp(rcfile, "-") == 0) {
945 } else if (stat(rcfile, &rcstat) == -1) {
948 GT_("couldn't time-check %s (error %d)\n"),
953 * isatty() to make sure this is a background process since the
954 * lockfile is removed after each invokation.
956 else if (!isatty(1) && rcstat.st_mtime > parsetime)
958 else if (rcstat.st_mtime > parsetime)
961 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
964 /* restore the startup directory */
965 if (!currentwd[0] || chdir (currentwd) == -1)
966 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
970 * Matthias Andree: Isn't this prone to introduction of
971 * "false" programs by interfering with PATH? Those
972 * path-searching execs might not be the best ideas for
975 * Rob Funk: But is there any way for someone to modify
976 * the PATH variable of a running fetchmail? I don't know
979 * Dave's change makes fetchmail restart itself in exactly
980 * the way it was started from the shell (or shell script)
981 * in the first place. If you're concerned about PATH
982 * contamination, call fetchmail initially with a full
983 * path, and use Dave's patch.
985 * Not using a -p variant of exec means that the restart
986 * will break if both (a) the user depended on PATH to
987 * call fetchmail in the first place, and (b) the system
988 * doesn't save the whole path in argv[0] if the whole
989 * path wasn't used in the initial call. (If I recall
990 * correctly, Linux saves it but many other Unices don't.)
992 execvp(argv[0], argv);
993 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
996 #ifdef HAVE_RES_SEARCH
997 /* Boldly assume that we also have res_init() if we have
998 * res_search(), and call res_init() to re-read the resolv.conf
999 * file, so that we can pick up changes to that file that are
1000 * written by dhpccd, dhclient, pppd, openvpn and similar. */
1002 /* NOTE: This assumes that /etc/resolv.conf is written
1003 * atomically (i. e. a temporary file is written, flushed and
1004 * then renamed into place). To fix Debian Bug#389270. */
1006 /* NOTE: If this leaks memory or doesn't re-read
1007 * /etc/resolv.conf, we're in trouble. The res_init() interface
1008 * is only lightly documented :-( */
1014 for (ctl = querylist; ctl; ctl = ctl->next)
1018 if (!(implicitmode && ctl->server.skip))
1023 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
1024 ctl->server.pollname);
1028 /* check skip interval first so that it counts all polls */
1029 if (run.poll_interval && ctl->server.interval)
1031 if (ctl->server.poll_count++ % ctl->server.interval)
1033 if (outlevel >= O_VERBOSE)
1035 GT_("interval not reached, not querying %s\n"),
1036 ctl->server.pollname);
1043 * Don't do monitoring if we were woken by a signal.
1044 * Note that interface_approve() does its own error logging.
1046 if (!interface_approve(&ctl->server, !lastsig))
1048 #endif /* CAN_MONITOR */
1050 dofastuidl = 0; /* this is reset in the driver if required */
1054 * At each poll interval, check the pwmd server for
1055 * changes in host and auth settings.
1057 if (ctl->pwmd_file) {
1058 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1061 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol, ctl))
1065 querystatus = query_host(ctl);
1067 if (NUM_NONZERO(ctl->fastuidl))
1068 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
1070 /* leave the UIDL state alone if there have been any errors */
1072 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
1073 uid_swap_lists(ctl);
1075 uid_discard_new_list(ctl);
1077 #endif /* POP3_ENABLE */
1079 if (querystatus == PS_SUCCESS)
1081 else if (!check_only &&
1082 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
1086 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
1088 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
1090 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
1092 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
1094 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
1096 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
1098 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
1100 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
1102 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
1104 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
1106 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
1108 report(stdout,GT_("Query status=11 (DNS)\n")); break;
1110 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
1112 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
1114 report(stdout,GT_("Query status=%d\n"),querystatus);
1119 if (ctl->server.monitor)
1122 * Allow some time for the link to quiesce. One
1123 * second is usually sufficient, three is safe.
1124 * Note: this delay is important - don't remove!
1127 interface_note_activity(&ctl->server);
1129 #endif /* CAN_MONITOR */
1139 /* close connections cleanly */
1143 * OK, we've polled. Now sleep.
1145 if (run.poll_interval)
1148 * Because passwords can expire, it may happen that *all*
1149 * hosts are now out of the loop due to authfail
1150 * conditions. If this happens daemon-mode fetchmail
1151 * should softly and silently vanish away, rather than
1152 * spinning uselessly.
1156 for (ctl = querylist; ctl; ctl = ctl->next)
1157 if (ctl->active && !(implicitmode && ctl->server.skip))
1162 report(stderr, GT_("All connections are wedged. Exiting.\n"));
1163 /* FIXME: someday, send notification mail */
1167 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1168 || outlevel > O_NORMAL)
1170 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
1173 * With this simple hack, we make it possible for a foreground
1174 * fetchmail to wake up one in daemon mode. What we want is the
1175 * side effect of interrupting any sleep that may be going on,
1176 * forcing fetchmail to re-poll its hosts. The second line is
1177 * for people who think all system daemons wake up on SIGHUP.
1179 set_signal_handler(SIGUSR1, donothing);
1180 if (getuid() == ROOT_UID)
1181 set_signal_handler(SIGHUP, donothing);
1184 * OK, now pause until it's time for the next poll cycle.
1185 * A nonzero return indicates we received a wakeup signal;
1186 * unwedge all servers in case the problem has been
1187 * manually repaired.
1189 if ((lastsig = interruptible_idle(run.poll_interval)))
1191 if (outlevel > O_SILENT)
1192 #ifdef SYS_SIGLIST_DECLARED
1194 GT_("awakened by %s\n"), sys_siglist[lastsig]);
1197 GT_("awakened by signal %d\n"), lastsig);
1199 for (ctl = querylist; ctl; ctl = ctl->next)
1200 ctl->wedged = FALSE;
1203 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1204 || outlevel > O_NORMAL)
1205 report(stdout, GT_("awakened at %s\n"), timestamp());
1207 } while (run.poll_interval);
1209 if (outlevel >= O_VERBOSE)
1210 report(stdout, GT_("normal termination, status %d\n"),
1211 successes ? PS_SUCCESS : querystatus);
1217 else if (querystatus)
1220 /* in case we interrupted before a successful fetch */
1224 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
1227 * If force is off, modify dstl fields only when they're empty (treat srcl
1228 * as defaults). If force is on, modify each dstl field whenever scrcl
1229 * is nonempty (treat srcl as an override).
1231 if (force ? !!*srcl : !*dstl)
1233 struct idlist *cpl = copy_str_list(*srcl);
1235 append_str_list(dstl, &cpl);
1239 static void optmerge(struct query *h2, struct query *h1, int force)
1240 /* merge two options records */
1242 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
1243 list_merge(&h2->localnames, &h1->localnames, force);
1244 list_merge(&h2->mailboxes, &h1->mailboxes, force);
1245 list_merge(&h2->smtphunt, &h1->smtphunt, force);
1246 list_merge(&h2->domainlist, &h1->domainlist, force);
1247 list_merge(&h2->antispam, &h1->antispam, force);
1249 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
1250 FLAG_MERGE(server.via);
1251 FLAG_MERGE(server.protocol);
1252 FLAG_MERGE(server.service);
1253 FLAG_MERGE(server.interval);
1254 FLAG_MERGE(server.authenticate);
1255 FLAG_MERGE(server.timeout);
1256 FLAG_MERGE(server.envelope);
1257 FLAG_MERGE(server.envskip);
1258 FLAG_MERGE(server.qvirtual);
1259 FLAG_MERGE(server.skip);
1260 FLAG_MERGE(server.dns);
1261 FLAG_MERGE(server.checkalias);
1262 FLAG_MERGE(server.principal);
1265 FLAG_MERGE(server.interface);
1266 FLAG_MERGE(server.interface_pair);
1267 FLAG_MERGE(server.monitor);
1270 FLAG_MERGE(server.plugin);
1271 FLAG_MERGE(server.plugout);
1272 FLAG_MERGE(server.tracepolls);
1273 FLAG_MERGE(server.badheader);
1274 FLAG_MERGE(server.retrieveerror);
1276 FLAG_MERGE(wildcard);
1277 FLAG_MERGE(remotename);
1278 FLAG_MERGE(password);
1281 FLAG_MERGE(listener);
1282 FLAG_MERGE(smtpaddress);
1283 FLAG_MERGE(smtpname);
1284 FLAG_MERGE(preconnect);
1285 FLAG_MERGE(postconnect);
1289 FLAG_MERGE(limitflush);
1290 FLAG_MERGE(fetchall);
1291 FLAG_MERGE(rewrite);
1292 FLAG_MERGE(forcecr);
1293 FLAG_MERGE(stripcr);
1294 FLAG_MERGE(pass8bits);
1295 FLAG_MERGE(dropstatus);
1296 FLAG_MERGE(dropdelivered);
1297 FLAG_MERGE(mimedecode);
1300 FLAG_MERGE(warnings);
1301 FLAG_MERGE(fetchlimit);
1302 FLAG_MERGE(fetchsizelimit);
1303 FLAG_MERGE(fastuidl);
1304 FLAG_MERGE(batchlimit);
1306 FLAG_MERGE(use_ssl);
1308 FLAG_MERGE(sslcert);
1309 FLAG_MERGE(sslproto);
1310 FLAG_MERGE(sslcertck);
1311 FLAG_MERGE(sslcertfile);
1312 FLAG_MERGE(sslcertpath);
1313 FLAG_MERGE(sslcommonname);
1314 FLAG_MERGE(sslfingerprint);
1316 FLAG_MERGE(expunge);
1318 FLAG_MERGE(properties);
1322 /** Load configuration files.
1323 * \return - true if no servers found on the command line
1324 * - false if servers found on the command line */
1325 static int load_params(int argc, char **argv, int optind)
1327 int implicitmode, st;
1329 struct query def_opts, *ctl;
1333 run.bouncemail = TRUE;
1334 run.softbounce = TRUE; /* treat permanent errors as temporary */
1335 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1337 memset(&def_opts, '\0', sizeof(struct query));
1338 def_opts.smtp_socket = -1;
1339 def_opts.smtpaddress = (char *)0;
1340 def_opts.smtpname = (char *)0;
1341 def_opts.server.protocol = P_AUTO;
1342 def_opts.server.timeout = CLIENT_TIMEOUT;
1343 def_opts.server.esmtp_name = user;
1344 def_opts.server.badheader = BHREJECT;
1345 def_opts.warnings = WARNING_INTERVAL;
1346 def_opts.remotename = user;
1347 def_opts.listener = SMTP_MODE;
1348 def_opts.fetchsizelimit = 100;
1349 def_opts.fastuidl = 4;
1351 /* get the location of rcfile */
1353 p = strrchr (rcfile, '/');
1354 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1355 *p = 0; /* replace '/' by '0' */
1356 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1357 *p = '/'; /* restore '/' */
1358 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1359 strcpy (rcfiledir, "/");
1362 /* note the parse time, so we can pick up on modifications */
1363 if (strcmp(rcfile, "-") == 0)
1364 parsetime = time(NULL);
1366 if (stat(rcfile, &rcstat) != -1)
1367 parsetime = rcstat.st_mtime;
1368 else if (errno != ENOENT)
1369 report(stderr, GT_("couldn't time-check the run-control file\n"));
1372 /* this builds the host list */
1373 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1375 * FIXME: someday, send notification mail here if backgrounded.
1376 * Right now, that can happen if the user changes the rcfile
1377 * while the fetchmail is running in background. Do similarly
1378 * for the other exit() calls in this function.
1382 if ((implicitmode = (optind >= argc)))
1385 for (ctl = querylist; ctl; ctl = ctl->next) {
1386 ctl->active = !ctl->server.skip;
1388 if (ctl->pwmd_file) {
1390 * Cannot get an element path without a service.
1392 if (ctl->server.protocol <= 1) {
1393 report(stderr, GT_("fetchmail: %s configuration invalid, pwmd_file requires a protocol specification\n"),
1394 ctl->server.pollname);
1399 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1402 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol,
1406 time(&rcstat.st_mtime);
1411 for (ctl = querylist; ctl; ctl = ctl->next)
1412 ctl->active = !ctl->server.skip;
1416 for (; optind < argc; optind++)
1418 flag predeclared = FALSE;
1421 * If hostname corresponds to a host known from the rc file,
1422 * simply declare it active. Otherwise synthesize a host
1423 * record from command line and defaults
1425 for (ctl = querylist; ctl; ctl = ctl->next)
1426 if (!strcmp(ctl->server.pollname, argv[optind])
1427 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1429 /* Is this correct? */
1430 if (predeclared && outlevel >= O_VERBOSE)
1431 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1435 if (ctl->pwmd_file) {
1437 * Cannot get an element path without a service.
1439 if (ctl->server.protocol <= 1) {
1440 report(stderr, GT_("%s configuration invalid, pwmd_file requires a protocol specification\n"),
1441 ctl->server.pollname);
1445 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1446 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1449 if (get_pwmd_details(ctl->server.pollname,
1450 ctl->server.protocol, ctl))
1459 * Allocate and link record without copying in
1460 * command-line args; we'll do that with the optmerge
1463 ctl = hostalloc((struct query *)NULL);
1465 if (cmd_opts.pwmd_file) {
1467 * Cannot get an element path without a service.
1469 if (cmd_opts.server.protocol == 0 || cmd_opts.server.protocol == 1) {
1470 report(stderr, GT_("Option --pwmd-file needs a service (-p) parameter.\n"));
1474 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1475 if (do_pwmd_connect(cmd_opts.pwmd_socket, cmd_opts.pwmd_file))
1478 if (get_pwmd_details(argv[optind], cmd_opts.server.protocol,
1484 ctl->server.pollname = xstrdup(argv[optind]);
1487 ctl->server.pollname = xstrdup(argv[optind]);
1490 ctl->server.lead_server = (struct hostdata *)NULL;
1495 * If there's a defaults record, merge it and lose it.
1496 * FIXME: we don't currently free all entries that might be in struct query.
1498 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1502 for (ctl = querylist->next; ctl; ctl = ctl->next)
1503 optmerge(ctl, querylist, FALSE);
1505 querylist = querylist->next;
1506 free(tmpq->server.pollname);
1510 /* don't allow a defaults record after the first */
1511 for (ctl = querylist; ctl; ctl = ctl->next) {
1512 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1513 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1518 /* use localhost if we never fetch the FQDN of this host */
1519 fetchmailhost = "localhost";
1521 /* here's where we override globals */
1522 if (cmd_run.logfile)
1523 run.logfile = cmd_run.logfile;
1525 run.idfile = cmd_run.idfile;
1526 if (cmd_run.pidfile)
1527 run.pidfile = cmd_run.pidfile;
1528 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1529 if (cmd_run.poll_interval >= 0)
1530 run.poll_interval = cmd_run.poll_interval;
1531 if (cmd_run.invisible)
1532 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1533 if (cmd_run.showdots)
1534 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1535 if (cmd_run.use_syslog)
1536 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1537 if (cmd_run.postmaster)
1538 run.postmaster = cmd_run.postmaster;
1539 if (cmd_run.bouncemail)
1540 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1541 if (cmd_run.softbounce)
1542 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1544 /* check and daemon options are not compatible */
1545 if (check_only && run.poll_interval)
1546 run.poll_interval = 0;
1549 * DNS support is required for some protocols. We used to
1550 * do this unconditionally, but it made fetchmail excessively
1551 * vulnerable to misconfigured DNS setups.
1553 * If we're using ETRN or ODMR, the smtp hunt list is the
1554 * list of systems we're polling on behalf of; these have
1555 * to be fully-qualified domain names. The default for
1556 * this list should be the FQDN of localhost.
1558 * If we're using Kerberos for authentication, we need
1559 * the FQDN in order to generate capability keys.
1561 for (ctl = querylist; ctl; ctl = ctl->next)
1563 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1564 || ctl->server.authenticate == A_KERBEROS_V5))
1566 fetchmailhost = host_fqdn(1);
1570 if (!ctl) /* list exhausted */
1571 fetchmailhost = host_fqdn(0);
1573 /* this code enables flags to be turned off */
1574 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1576 else if (flag == FLAG_FALSE)\
1581 /* merge in wired defaults, do sanity checks and prepare internal fields */
1582 for (ctl = querylist; ctl; ctl = ctl->next)
1584 ctl->wedged = FALSE;
1586 /* merge in defaults */
1587 optmerge(ctl, &def_opts, FALSE);
1589 /* force command-line options */
1590 optmerge(ctl, &cmd_opts, TRUE);
1593 * queryname has to be set up for inactive servers too.
1594 * Otherwise the UIDL code core-dumps on startup.
1596 if (ctl->server.via)
1597 ctl->server.queryname = xstrdup(ctl->server.via);
1599 ctl->server.queryname = xstrdup(ctl->server.pollname);
1602 * We no longer do DNS lookups at startup.
1603 * This is a kluge. It enables users to edit their
1604 * configurations when DNS isn't available.
1606 ctl->server.truename = xstrdup(ctl->server.queryname);
1608 if (configdump || ctl->active )
1610 DEFAULT(ctl->keep, FALSE);
1611 DEFAULT(ctl->fetchall, FALSE);
1612 DEFAULT(ctl->flush, FALSE);
1613 DEFAULT(ctl->limitflush, FALSE);
1614 DEFAULT(ctl->rewrite, TRUE);
1615 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1616 DEFAULT(ctl->forcecr, FALSE);
1617 DEFAULT(ctl->pass8bits, FALSE);
1618 DEFAULT(ctl->dropstatus, FALSE);
1619 DEFAULT(ctl->dropdelivered, FALSE);
1620 DEFAULT(ctl->mimedecode, FALSE);
1621 DEFAULT(ctl->idle, FALSE);
1622 DEFAULT(ctl->server.dns, TRUE);
1623 DEFAULT(ctl->use_ssl, FALSE);
1624 DEFAULT(ctl->sslcertck, FALSE);
1625 DEFAULT(ctl->server.checkalias, FALSE);
1628 * XXX FIXME: do we need this check or can we rely on the .y
1629 * parser handling this?
1633 report(stderr, GT_("SSL support is not compiled in.\n"));
1636 #endif /* SSL_ENABLE */
1639 if (ctl->server.authenticate == A_KERBEROS_V5) {
1640 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1645 if (ctl->server.authenticate == A_GSSAPI) {
1646 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1652 * Make sure we have a nonempty host list to forward to.
1655 save_str(&ctl->smtphunt, "localhost", FALSE);
1658 * Make sure we have a nonempty list of domains to fetch from.
1660 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1661 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1663 /* if `user' doesn't name a real local user, try to run as root */
1664 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1667 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1668 if (!ctl->localnames) /* for local delivery via SMTP */
1669 save_str_pair(&ctl->localnames, user, NULL);
1673 * can't handle multidrop mailboxes without "envelope"
1674 * option, this causes truckloads full of support complaints
1675 * "all mail forwarded to postmaster"
1677 if (MULTIDROP(ctl) && !ctl->server.envelope)
1679 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1680 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1683 /* if no folders were specified, set up the null one as default */
1684 if (!ctl->mailboxes)
1685 save_str(&ctl->mailboxes, (char *)NULL, 0);
1687 /* maybe user overrode timeout on command line? */
1688 if (ctl->server.timeout == -1)
1689 ctl->server.timeout = CLIENT_TIMEOUT;
1692 if (ctl->server.service) {
1693 int port = servport(ctl->server.service);
1696 (void) fprintf(stderr,
1697 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1698 ctl->server.pollname);
1702 if (ctl->listener == LMTP_MODE)
1706 for (idp = ctl->smtphunt; idp; idp = idp->next)
1710 if (!(cp = strrchr(idp->id, '/'))
1711 || (0 == strcmp(cp + 1, SMTP_PORT))
1712 || servport(cp + 1) == SMTP_PORT_NUM)
1714 (void) fprintf(stderr,
1715 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1716 ctl->server.pollname);
1723 * "I beg to you, have mercy on the we[a]k minds like myself."
1724 * wrote Pehr Anderson. Your petition is granted.
1726 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1728 (void) fprintf(stderr,
1729 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1735 * If the user didn't set a last-resort user to get misaddressed
1736 * multidrop mail, set an appropriate default here.
1738 if (!run.postmaster)
1740 if (getuid() != ROOT_UID) /* ordinary user */
1741 run.postmaster = user;
1743 run.postmaster = "postmaster";
1746 return(implicitmode);
1749 static void terminate_poll(int sig)
1750 /* to be executed at the end of a poll cycle */
1754 report(stdout, GT_("terminated with signal %d\n"), sig);
1758 * Update UID information at end of each poll, rather than at end
1759 * of run, because that way we don't lose all UIDL information since
1760 * the beginning of time if fetchmail crashes.
1763 write_saved_lists(querylist, run.idfile);
1764 #endif /* POP3_ENABLE */
1767 static void terminate_run(int sig)
1768 /* to be executed on normal or signal-induced termination */
1772 terminate_poll(sig);
1775 * Craig Metz, the RFC1938 one-time-password guy, points out:
1776 * "Remember that most kernels don't zero pages before handing them to the
1777 * next process and many kernels share pages between user and kernel space.
1778 * You'd be very surprised what you can find from a short program to do a
1779 * malloc() and then dump the contents of the pages you got. By zeroing
1780 * the secrets at end of run (earlier if you can), you make sure the next
1781 * guy can't get the password/pass phrase."
1783 * Right you are, Craig!
1785 for (ctl = querylist; ctl; ctl = ctl->next)
1787 memset(ctl->password, '\0', strlen(ctl->password));
1790 if (activecount == 0)
1793 exit(successes ? PS_SUCCESS : querystatus);
1797 * Sequence of protocols to try when autoprobing, most capable to least.
1799 static const int autoprobe[] =
1803 #endif /* IMAP_ENABLE */
1806 #endif /* POP3_ENABLE */
1809 static int query_host(struct query *ctl)
1810 /* perform fetch transaction with single host */
1816 * If we're syslogging the progress messages are automatically timestamped.
1817 * Force timestamping if we're going to a logfile.
1819 if (outlevel >= O_VERBOSE)
1821 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1823 ctl->server.pollname,
1824 showproto(ctl->server.protocol),
1828 switch (ctl->server.protocol) {
1830 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1832 ctl->server.protocol = autoprobe[i];
1834 st = query_host(ctl);
1837 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1840 ctl->server.protocol = P_AUTO;
1846 } while (st == PS_REPOLL);
1848 report(stderr, GT_("POP3 support is not configured.\n"));
1850 #endif /* POP3_ENABLE */
1856 } while (st == PS_REPOLL);
1858 report(stderr, GT_("IMAP support is not configured.\n"));
1860 #endif /* IMAP_ENABLE */
1864 report(stderr, GT_("ETRN support is not configured.\n"));
1869 #endif /* ETRN_ENABLE */
1872 report(stderr, GT_("ODMR support is not configured.\n"));
1876 #endif /* ODMR_ENABLE */
1879 report(stderr, GT_("unsupported protocol selected.\n"));
1884 * If we're syslogging the progress messages are automatically timestamped.
1885 * Force timestamping if we're going to a logfile.
1887 if (outlevel >= O_VERBOSE)
1889 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1891 ctl->server.pollname,
1892 showproto(ctl->server.protocol),
1899 static int print_id_of(struct uid_db_record *rec, void *unused)
1903 printf("\t%s\n", rec->id);
1906 static void dump_params (struct runctl *runp,
1907 struct query *querylist, flag implicit)
1908 /* display query parameters in English */
1912 if (runp->poll_interval)
1913 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1915 printf(GT_("Logfile is %s\n"), runp->logfile);
1916 if (strcmp(runp->idfile, IDFILE_NAME))
1917 printf(GT_("Idfile is %s\n"), runp->idfile);
1918 if (runp->use_syslog)
1919 printf(GT_("Progress messages will be logged via syslog\n"));
1920 if (runp->invisible)
1921 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1923 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1924 if (runp->postmaster)
1925 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1928 if (!runp->bouncemail)
1929 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1930 else if (outlevel >= O_VERBOSE)
1931 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1933 if (!runp->softbounce)
1934 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1935 else if (outlevel >= O_VERBOSE)
1936 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1938 for (ctl = querylist; ctl; ctl = ctl->next)
1940 if (!ctl->active || (implicit && ctl->server.skip))
1943 printf(GT_("Options for retrieving from %s@%s:\n"),
1944 ctl->remotename, visbuf(ctl->server.pollname));
1946 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1947 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1949 if (ctl->server.interval)
1950 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1951 " Poll of this server will occur every %d intervals.\n",
1952 ctl->server.interval), ctl->server.interval);
1953 if (ctl->server.truename)
1954 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1955 if (ctl->server.skip || outlevel >= O_VERBOSE)
1956 printf(ctl->server.skip
1957 ? GT_(" This host will not be queried when no host is specified.\n")
1958 : GT_(" This host will be queried when no host is specified.\n"));
1959 if (!NO_PASSWORD(ctl))
1962 printf(GT_(" Password will be prompted for.\n"));
1963 else if (outlevel >= O_VERBOSE)
1965 printf(GT_(" Password = \"%s\".\n"),
1966 visbuf(ctl->password));
1970 if (ctl->server.protocol == P_POP3
1971 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1972 && (ctl->server.authenticate == A_KERBEROS_V5))
1973 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1974 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1976 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1977 if (ctl->server.service)
1978 printf(GT_(" (using service %s)"), ctl->server.service);
1979 else if (outlevel >= O_VERBOSE)
1980 printf(GT_(" (using default port)"));
1983 switch (ctl->server.authenticate)
1986 printf(GT_(" All available authentication methods will be tried.\n"));
1989 printf(GT_(" Password authentication will be forced.\n"));
1992 printf(GT_(" MSN authentication will be forced.\n"));
1995 printf(GT_(" NTLM authentication will be forced.\n"));
1998 printf(GT_(" OTP authentication will be forced.\n"));
2001 printf(GT_(" CRAM-MD5 authentication will be forced.\n"));
2004 printf(GT_(" GSSAPI authentication will be forced.\n"));
2007 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
2010 printf(GT_(" End-to-end encryption assumed.\n"));
2013 printf(GT_(" APOP authentication will be forced.\n"));
2018 if (ctl->server.principal != (char *) NULL)
2019 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
2022 printf(GT_(" SSL encrypted sessions enabled.\n"));
2024 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
2025 if (ctl->sslcertck) {
2026 printf(GT_(" SSL server certificate checking enabled.\n"));
2028 if (ctl->sslcertfile != NULL)
2029 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
2030 if (ctl->sslcertpath != NULL)
2031 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
2032 if (ctl->sslcommonname != NULL)
2033 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
2034 if (ctl->sslfingerprint != NULL)
2035 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
2037 if (ctl->server.timeout > 0)
2038 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
2039 if (ctl->server.timeout == CLIENT_TIMEOUT)
2040 printf(GT_(" (default).\n"));
2044 if (MAILBOX_PROTOCOL(ctl))
2046 if (!ctl->mailboxes->id)
2047 printf(GT_(" Default mailbox selected.\n"));
2052 printf(GT_(" Selected mailboxes are:"));
2053 for (idp = ctl->mailboxes; idp; idp = idp->next)
2054 printf(" %s", idp->id);
2057 printf(ctl->fetchall
2058 ? GT_(" All messages will be retrieved (--all on).\n")
2059 : GT_(" Only new messages will be retrieved (--all off).\n"));
2061 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
2062 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
2064 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
2065 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
2066 printf(ctl->limitflush
2067 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
2068 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
2070 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
2071 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
2073 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
2074 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
2076 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
2077 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
2078 printf(ctl->pass8bits
2079 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
2080 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
2081 printf(ctl->mimedecode
2082 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
2083 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
2085 ? GT_(" Idle after poll is enabled (idle on).\n")
2086 : GT_(" Idle after poll is disabled (idle off).\n"));
2087 printf(ctl->dropstatus
2088 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
2089 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
2090 printf(ctl->dropdelivered
2091 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
2092 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
2093 if (NUM_NONZERO(ctl->limit))
2095 if (NUM_NONZERO(ctl->limit))
2096 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
2097 ctl->limit, ctl->limit);
2098 else if (outlevel >= O_VERBOSE)
2099 printf(GT_(" No message size limit (--limit 0).\n"));
2100 if (run.poll_interval > 0)
2101 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
2102 ctl->warnings, ctl->warnings);
2103 else if (outlevel >= O_VERBOSE)
2104 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
2106 if (NUM_NONZERO(ctl->fetchlimit))
2107 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
2108 ctl->fetchlimit, ctl->fetchlimit);
2109 else if (outlevel >= O_VERBOSE)
2110 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
2111 if (NUM_NONZERO(ctl->fetchsizelimit))
2112 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
2113 ctl->fetchsizelimit, ctl->fetchsizelimit);
2114 else if (outlevel >= O_VERBOSE)
2115 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
2116 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
2118 if (ctl->fastuidl == 1)
2119 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
2121 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
2123 else if (outlevel >= O_VERBOSE)
2124 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
2125 if (NUM_NONZERO(ctl->batchlimit))
2126 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
2127 else if (outlevel >= O_VERBOSE)
2128 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
2129 if (MAILBOX_PROTOCOL(ctl))
2131 if (NUM_NONZERO(ctl->expunge))
2132 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
2133 else if (outlevel >= O_VERBOSE)
2134 printf(GT_(" No forced expunges (--expunge 0).\n"));
2137 else /* ODMR or ETRN */
2141 printf(GT_(" Domains for which mail will be fetched are:"));
2142 for (idp = ctl->domainlist; idp; idp = idp->next)
2144 printf(" %s", idp->id);
2145 if (!idp->val.status.mark)
2146 printf(GT_(" (default)"));
2151 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
2152 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
2153 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
2160 printf(GT_(" Messages will be %cMTP-forwarded to:"),
2162 for (idp = ctl->smtphunt; idp; idp = idp->next)
2164 printf(" %s", idp->id);
2165 if (!idp->val.status.mark)
2166 printf(GT_(" (default)"));
2170 if (ctl->smtpaddress)
2171 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
2174 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
2177 if (MAILBOX_PROTOCOL(ctl))
2179 if (ctl->antispam != (struct idlist *)NULL)
2183 printf(GT_(" Recognized listener spam block responses are:"));
2184 for (idp = ctl->antispam; idp; idp = idp->next)
2185 printf(" %d", idp->val.status.num);
2188 else if (outlevel >= O_VERBOSE)
2189 printf(GT_(" Spam-blocking disabled\n"));
2191 if (ctl->preconnect)
2192 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
2193 visbuf(ctl->preconnect));
2194 else if (outlevel >= O_VERBOSE)
2195 printf(GT_(" No pre-connection command.\n"));
2196 if (ctl->postconnect)
2197 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
2198 visbuf(ctl->postconnect));
2199 else if (outlevel >= O_VERBOSE)
2200 printf(GT_(" No post-connection command.\n"));
2201 if (MAILBOX_PROTOCOL(ctl)) {
2202 if (!ctl->localnames)
2203 printf(GT_(" No localnames declared for this host.\n"));
2209 for (idp = ctl->localnames; idp; idp = idp->next)
2212 if (count > 1 || ctl->wildcard)
2213 printf(GT_(" Multi-drop mode: "));
2215 printf(GT_(" Single-drop mode: "));
2217 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
2218 if (outlevel >= O_VERBOSE)
2220 for (idp = ctl->localnames; idp; idp = idp->next)
2222 printf("\t%s -> %s\n", idp->id, idp->val.id2);
2224 printf("\t%s\n", idp->id);
2226 fputs("\t*\n", stdout);
2229 if (count > 1 || ctl->wildcard)
2231 printf(ctl->server.dns
2232 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
2233 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
2234 if (ctl->server.dns)
2236 if (ctl->server.checkalias)
2237 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
2239 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
2241 if (ctl->server.envelope == STRING_DISABLED)
2242 printf(GT_(" Envelope-address routing is disabled\n"));
2245 printf(GT_(" Envelope header is assumed to be: %s\n"),
2246 ctl->server.envelope ? ctl->server.envelope : "Received");
2247 if (ctl->server.envskip || outlevel >= O_VERBOSE)
2248 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
2249 ctl->server.envskip);
2250 if (ctl->server.qvirtual)
2251 printf(GT_(" Prefix %s will be removed from user id\n"),
2252 ctl->server.qvirtual);
2253 else if (outlevel >= O_VERBOSE)
2254 printf(GT_(" No prefix stripping\n"));
2257 if (ctl->server.akalist)
2259 printf(GT_(" Predeclared mailserver aliases:"));
2260 for (idp = ctl->server.akalist; idp; idp = idp->next)
2261 printf(" %s", idp->id);
2265 if (ctl->server.localdomains)
2267 printf(GT_(" Local domains:"));
2268 for (idp = ctl->server.localdomains; idp; idp = idp->next)
2269 printf(" %s", idp->id);
2276 if (ctl->server.interface)
2277 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
2278 else if (outlevel >= O_VERBOSE)
2279 printf(GT_(" No interface requirement specified.\n"));
2280 if (ctl->server.monitor)
2281 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
2282 else if (outlevel >= O_VERBOSE)
2283 printf(GT_(" No monitor interface specified.\n"));
2286 if (ctl->server.plugin)
2287 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
2288 else if (outlevel >= O_VERBOSE)
2289 printf(GT_(" No plugin command specified.\n"));
2290 if (ctl->server.plugout)
2291 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
2292 else if (outlevel >= O_VERBOSE)
2293 printf(GT_(" No plugout command specified.\n"));
2295 if (MAILBOX_PROTOCOL(ctl))
2299 if (!(count = uid_db_n_records(&ctl->oldsaved)))
2300 printf(GT_(" No UIDs saved from this host.\n"));
2304 printf(GT_(" %d UIDs saved.\n"), count);
2305 traverse_uid_db(&ctl->oldsaved, print_id_of, NULL);
2309 if (ctl->server.tracepolls)
2310 printf(GT_(" Poll trace information will be added to the Received header.\n"));
2311 else if (outlevel >= O_VERBOSE)
2312 printf(GT_(" No poll trace information will be added to the Received header.\n"));
2314 switch (ctl->server.badheader) {
2316 if (outlevel >= O_VERBOSE)
2317 printf(GT_(" Messages with bad headers will be rejected.\n"));
2320 printf(GT_(" Messages with bad headers will be passed on.\n"));
2324 switch (ctl->server.retrieveerror) {
2326 if (outlevel >= O_VERBOSE)
2327 printf(GT_(" Messages with fetch body errors will cause the session to abort.\n"));
2330 printf(GT_(" Messages with fetch body errors will be skipped, the session will continue.\n"));
2333 printf(GT_(" Messages with fetch body errors will be marked seen, the session will continue.\n"));
2337 if (ctl->properties)
2338 printf(GT_(" Pass-through properties \"%s\".\n"),
2339 visbuf(ctl->properties));
2343 /* fetchmail.c ends here */