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 Sunil Shetye\n"
137 "Copyright (C) 2005 - 2013 Matthias Andree\n"
139 fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
140 "are welcome to redistribute it under certain conditions. For details,\n"
141 "please see the file COPYING in the source or documentation directory.\n"));
143 /* Do not translate this */
144 fprintf(fp, "This product includes software developed by the OpenSSL Project\nfor use in the OpenSSL Toolkit. (http://www.openssl.org/)\n");
148 const char *iana_charset;
151 static void exit_with_pwmd_error(gpg_error_t error)
153 gpg_err_code_t code = gpg_err_code(error);
155 report(stderr, GT_("pwmd: error %i: %s\n"), code, pwmd_strerror(error));
162 /* Don't exit if daemonized. There may be other active accounts. */
167 static int do_pwmd_connect(const char *socketname, const char *filename)
178 if (!pwm || (pwm && socketname && !pwmd_socket) ||
179 (pwm && !socketname && pwmd_socket) ||
180 (pwm && socketname && pwmd_socket && strcmp(socketname, pwmd_socket))) {
184 pwm = pwmd_new("Fetchmail");
185 rc = pwmd_connect_url(pwm, socketname);
188 exit_with_pwmd_error(rc);
193 if (run.pinentry_timeout > 0) {
194 rc = pwmd_setopt(pwm, PWMD_OPTION_PINENTRY_TIMEOUT,
195 run.pinentry_timeout);
198 exit_with_pwmd_error(rc);
203 rc = pwmd_socket_type(pwm, &s);
206 exit_with_pwmd_error(rc);
210 if (!pwmd_file || strcmp(filename, pwmd_file)) {
211 if (s == PWMD_SOCKET_SSH)
212 /* use a local pinentry since X11 forwarding is broken. */
213 rc = pwmd_open2(pwm, filename);
215 rc = pwmd_open(pwm, filename);
218 exit_with_pwmd_error(rc);
223 /* May be null to use the default of ~/.pwmd/socket. */
224 pwmd_socket = socketname;
225 pwmd_file = filename;
229 static int get_pwmd_details(const char *pwmd_account, int protocol,
232 const char *prot = showproto(protocol);
235 char *tmp = xstrdup(pwmd_account);
238 for (i = 0; tmp[i]; i++) {
239 if (i && tmp[i] == '^')
244 * Get the hostname for this protocol. Element path must be
245 * account->[protocol]->hostname.
247 error = pwmd_command(pwm, &result, "GET %s\t%s\thostname", tmp, prot);
250 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
251 report(stderr, GT_("pwmd: %s->%s->hostname: %s\n"), pwmd_account, prot, pwmd_strerror(error));
261 exit_with_pwmd_error(error);
266 if (ctl->server.pollname != ctl->server.via)
267 xfree(ctl->server.via);
269 ctl->server.via = xstrdup(result);
271 if (ctl->server.queryname)
272 xfree(ctl->server.queryname);
274 ctl->server.queryname = xstrdup(ctl->server.via);
276 if (ctl->server.truename)
277 xfree(ctl->server.truename);
279 ctl->server.truename = xstrdup(ctl->server.queryname);
283 * Server port. Fetchmail tries standard ports for known services so it
284 * should be alright if this element isn't found. ctl->server.protocol is
285 * already set. This sets ctl->server.service.
287 error = pwmd_command(pwm, &result, "GET %s\t%s\tport", tmp, prot);
290 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND)
291 report(stderr, GT_("pwmd: %s->%s->port: %s\n"), pwmd_account, prot, pwmd_strerror(error));
293 exit_with_pwmd_error(error);
298 if (ctl->server.service)
299 xfree(ctl->server.service);
301 ctl->server.service = xstrdup(result);
306 * Get the remote username. Element must be account->username.
308 error = pwmd_command(pwm, &result, "GET %s\tusername", tmp);
311 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
312 report(stderr, GT_("pwmd: %s->username: %s\n"), pwmd_account, pwmd_strerror(error));
321 exit_with_pwmd_error(error);
327 xfree(ctl->remotename);
329 if (ctl->server.esmtp_name)
330 xfree(ctl->server.esmtp_name);
332 ctl->remotename = xstrdup(result);
333 ctl->server.esmtp_name = xstrdup(result);
338 * Get the remote password. Element must be account->password.
340 error = pwmd_command(pwm, &result, "GET %s\tpassword", tmp);
343 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
344 report(stderr, GT_("pwmd: %s->password: %s\n"), pwmd_account, pwmd_strerror(error));
353 exit_with_pwmd_error(error);
359 xfree(ctl->password);
361 ctl->password= xstrdup(result);
367 * If there is a ssl element and set to 1, enable ssl for this account.
368 * Element path must be account->[protocol]->ssl.
370 error = pwmd_command(pwm, &result, "GET %s\t%s\tssl", tmp, prot);
373 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
374 report(stderr, GT_("pwmd: %s->%s->ssl: %s\n"), pwmd_account, prot, pwmd_strerror(error));
383 exit_with_pwmd_error(error);
388 ctl->use_ssl = atoi(result) >= 1 ? FLAG_TRUE : FLAG_FALSE;
393 * account->[protocol]->sslfingerprint.
395 error = pwmd_command(pwm, &result, "GET %s\t%s\tsslfingerprint", tmp, prot);
398 if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
399 report(stderr, GT_("pwmd: %s->%s->sslfingerprint: %s\n"), pwmd_account, prot, pwmd_strerror(error));
408 exit_with_pwmd_error(error);
413 if (ctl->sslfingerprint)
414 xfree(ctl->sslfingerprint);
416 ctl->sslfingerprint = xstrdup(result);
425 int main(int argc, char **argv)
428 int implicitmode = FALSE;
429 flag safewithbg = FALSE; /** if parsed options are compatible with a
430 fetchmail copy running in the background */
432 netrc_entry *netrc_list;
433 char *netrc_file, *tmpbuf;
437 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
441 envquery(argc, argv);
443 setlocale (LC_ALL, "");
444 bindtextdomain(PACKAGE, LOCALEDIR);
446 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
450 iana_charset = "US-ASCII";
454 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
458 * Note: because we can't initialize reporting before we know whether
459 * syslog is supposed to be on, this message will go to stdout and
460 * be lost when running in background.
462 if (outlevel >= O_VERBOSE)
466 report(stdout, GT_("fetchmail: invoked with"));
467 for (i = 0; i < argc; i++)
468 report(stdout, " %s", argv[i]);
469 report(stdout, "\n");
472 #define IDFILE_NAME ".fetchids"
473 run.idfile = prependdir (IDFILE_NAME, fmhome);
477 * We used to arrange for the lock to be removed on exit close
478 * to where the lock was asserted. Now we need to do it here, because
479 * we might have re-executed in background with an existing lock
480 * as the result of a changed rcfile (see the code near the execvp(3)
481 * call near the beginning of the polling loop for details). We want
482 * to be sure the lock gets nuked on any error exit, basically.
487 /* save the current directory */
488 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
489 report(stderr, GT_("could not get current working directory\n"));
497 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts, &safewithbg);
501 if (quitmode && quitind == argc)
507 const char *features =
510 #endif /* POP3_ENABLE */
513 #endif /* IMAP_ENABLE */
519 #endif /* RPA_ENABLE */
522 #endif /* NTLM_ENABLE */
525 #endif /* SDPS_ENABLE */
528 #endif /* ETRN_ENABLE */
531 #endif /* ODMR_ENABLE */
537 #endif /* OPIE_ENABLE */
538 #ifdef HAVE_PKG_hesiod
543 #endif /* HAVE_SOCKS */
546 #endif /* ENABLE_NLS */
549 #endif /* KERBEROS_V5 */
552 #endif /* HAVE_LIBPWMD */
554 printf(GT_("This is fetchmail release %s"), VERSION);
555 fputs(features, stdout);
557 printcopyright(stdout);
559 fputs("Fallback MDA: ", stdout);
561 fputs(FALLBACK_MDA, stdout);
563 fputs("(none)", stdout);
568 /* this is an attempt to help remote debugging */
569 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
572 /* avoid parsing the config file if all we're doing is killing a daemon */
574 implicitmode = load_params(argc, argv, optind);
577 /* nodetach -> turn off logfile option */
579 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("The nodetach option is in effect, ignoring logfile option.\n")); }
584 /* not in daemon mode -> turn off logfile option */
585 if (0 == run.poll_interval) {
586 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Not running in daemon mode, ignoring logfile option.\n")); }
591 /* log file not writable -> turn off logfile option */
592 if (run.logfile && 0 != access(run.logfile, F_OK)) {
593 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Logfile \"%s\" does not exist, ignoring logfile option.\n"), run.logfile); }
597 /* log file not writable -> turn off logfile option */
598 if (run.logfile && 0 != access(run.logfile, W_OK)) {
599 fprintf(stderr, GT_("Logfile \"%s\" is not writable, aborting.\n"), run.logfile);
605 /* logging should be set up early in case we were restarted from exec */
608 openlog(program_name, LOG_PID, LOG_MAIL);
609 /* precedence: logfile (if effective) overrides syslog. */
611 syslog(LOG_ERR, GT_("syslog and logfile options are both set, ignoring syslog, and logging to %s"), run.logfile);
613 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy below, too */
619 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy above, too */
622 /* initialize UID handling */
626 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
629 initialize_saved_lists(querylist, run.idfile);
631 #endif /* POP3_ENABLE */
633 /* construct the lockfile */
637 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
638 * Core dumps could otherwise contain passwords to be scavenged by a
641 if (outlevel < O_VERBOSE || run.poll_interval > 0)
643 struct rlimit corelimit;
644 corelimit.rlim_cur = 0;
645 corelimit.rlim_max = 0;
646 setrlimit(RLIMIT_CORE, &corelimit);
649 #define NETRC_FILE ".netrc"
650 /* parse the ~/.netrc file (if present) for future password lookups. */
651 netrc_file = prependdir (NETRC_FILE, home);
652 netrc_list = parse_netrc(netrc_file);
656 /* pick up passwords where we can */
657 for (ctl = querylist; ctl; ctl = ctl->next)
659 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
661 if (NO_PASSWORD(ctl))
662 /* Server won't care what the password is, but there
663 must be some non-null string here. */
664 ctl->password = ctl->remotename;
669 /* look up the pollname and account in the .netrc file. */
670 p = search_netrc(netrc_list,
671 ctl->server.pollname, ctl->remotename);
672 /* if we find a matching entry with a password, use it */
673 if (p && p->password)
674 ctl->password = xstrdup(p->password);
676 /* otherwise try with "via" name if there is one */
677 else if (ctl->server.via)
679 p = search_netrc(netrc_list,
680 ctl->server.via, ctl->remotename);
681 if (p && p->password)
682 ctl->password = xstrdup(p->password);
688 free_netrc(netrc_list);
691 /* perhaps we just want to check options? */
694 int havercfile = access(rcfile, 0);
696 printf(GT_("Taking options from command line%s%s\n"),
697 havercfile ? "" : GT_(" and "),
698 havercfile ? "" : rcfile);
700 if (querylist == NULL)
702 GT_("No mailservers set up -- perhaps %s is missing?\n"),
705 dump_params(&run, querylist, implicitmode);
709 /* dump options as a Python dictionary, for configurator use */
712 dump_config(&run, querylist);
716 /* check for another fetchmail running concurrently */
717 pid = fm_lock_state();
719 pid = bkgd ? -pid : pid;
721 /* if no mail servers listed and nothing in background, we're done */
722 if (!quitonly && pid == 0 && querylist == NULL) {
723 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
727 /* perhaps user asked us to kill the other fetchmail */
730 if (pid == 0 || pid == getpid())
731 /* this test enables re-execing on a changed rcfile
732 * for pid == getpid() */
735 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
739 else if (kill(pid, SIGTERM) < 0)
741 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
742 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
749 if (outlevel > O_SILENT)
750 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
751 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
752 /* We used to nuke the other process's lock here, with
753 * fm_lock_release(), which is broken. The other process
754 * needs to clear its lock by itself. */
758 /* wait for other process to exit */
759 maxwait = 10; /* seconds */
760 while (kill(pid, 0) == 0 && --maxwait >= 0) {
767 /* another fetchmail is running -- wake it up or die */
773 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
776 else if (!implicitmode)
779 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
786 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
790 else if (getpid() == pid)
791 /* this test enables re-execing on a changed rcfile */
793 else if (argc > 1 && !safewithbg)
796 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
799 fprintf(stderr, "argc = %d, arg list:\n", argc);
800 for (i = 1; i < argc; i++) fprintf(stderr, "arg %d = \"%s\"\n", i, argv[i]);
804 else if (kill(pid, SIGUSR1) == 0)
806 if (outlevel > O_SILENT)
808 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
815 * Should never happen -- possible only if a background fetchmail
816 * croaks after the first kill probe above but before the
817 * SIGUSR1/SIGHUP transmission.
820 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
822 return(PS_UNDEFINED);
826 /* pick up interactively any passwords we need but don't have */
827 for (ctl = querylist; ctl; ctl = ctl->next)
829 if (ctl->active && !(implicitmode && ctl->server.skip)
830 && !NO_PASSWORD(ctl) && !ctl->password)
835 GT_("fetchmail: can't find a password for %s@%s.\n"),
836 ctl->remotename, ctl->server.pollname);
839 const char* password_prompt = GT_("Enter password for %s@%s: ");
840 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
842 tmpbuf = (char *)xmalloc(pplen);
843 snprintf(tmpbuf, pplen, password_prompt,
844 ctl->remotename, ctl->server.pollname);
845 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
852 * Time to initiate the SOCKS library (this is not mandatory: it just
853 * registers the correct application name for logging purpose. If you
854 * have some problem, comment out these lines).
857 SOCKSinit("fetchmail");
858 #endif /* HAVE_SOCKS */
860 /* avoid zombies from plugins */
863 /* Fix up log destination - if the if() is true, the precedence rule
864 * above hasn't killed off the syslog option, because the logfile
865 * option is ineffective (because we're not detached or not in
866 * deamon mode), so kill it for the benefit of other parts of the
868 if (run.logfile && run.use_syslog)
872 * Maybe time to go to demon mode...
874 if (run.poll_interval)
879 rc = daemonize(run.logfile);
881 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
885 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
888 * We'll set up a handler for these when we're sleeping,
889 * but ignore them otherwise so as not to interrupt a poll.
891 set_signal_handler(SIGUSR1, SIG_IGN);
892 if (run.poll_interval && getuid() == ROOT_UID)
893 set_signal_handler(SIGHUP, SIG_IGN);
897 /* not in daemon mode */
900 if (!freopen(run.logfile, "a", stdout))
901 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
902 if (!freopen(run.logfile, "a", stderr))
903 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
909 /* beyond here we don't want more than one fetchmail running per user */
911 set_signal_handler(SIGABRT, terminate_run);
912 set_signal_handler(SIGINT, terminate_run);
913 set_signal_handler(SIGTERM, terminate_run);
914 set_signal_handler(SIGALRM, terminate_run);
915 set_signal_handler(SIGPIPE, SIG_IGN);
916 set_signal_handler(SIGQUIT, terminate_run);
918 /* here's the exclusion lock */
921 if (check_only && outlevel >= O_VERBOSE) {
922 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
926 * Query all hosts. If there's only one, the error return will
927 * reflect the status of that transaction.
931 * Check to see if the rcfile has been touched. If so,
932 * re-exec so the file will be reread. Doing it this way
933 * avoids all the complications of trying to deallocate the
934 * in-core control structures -- and the potential memory
944 if (strcmp(rcfile, "-") == 0) {
946 } else if (stat(rcfile, &rcstat) == -1) {
949 GT_("couldn't time-check %s (error %d)\n"),
954 * isatty() to make sure this is a background process since the
955 * lockfile is removed after each invokation.
957 else if (!isatty(1) && rcstat.st_mtime > parsetime)
959 else if (rcstat.st_mtime > parsetime)
962 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
965 /* restore the startup directory */
966 if (!currentwd[0] || chdir (currentwd) == -1)
967 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
971 * Matthias Andree: Isn't this prone to introduction of
972 * "false" programs by interfering with PATH? Those
973 * path-searching execs might not be the best ideas for
976 * Rob Funk: But is there any way for someone to modify
977 * the PATH variable of a running fetchmail? I don't know
980 * Dave's change makes fetchmail restart itself in exactly
981 * the way it was started from the shell (or shell script)
982 * in the first place. If you're concerned about PATH
983 * contamination, call fetchmail initially with a full
984 * path, and use Dave's patch.
986 * Not using a -p variant of exec means that the restart
987 * will break if both (a) the user depended on PATH to
988 * call fetchmail in the first place, and (b) the system
989 * doesn't save the whole path in argv[0] if the whole
990 * path wasn't used in the initial call. (If I recall
991 * correctly, Linux saves it but many other Unices don't.)
993 execvp(argv[0], argv);
994 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
997 #ifdef HAVE_RES_SEARCH
998 /* Boldly assume that we also have res_init() if we have
999 * res_search(), and call res_init() to re-read the resolv.conf
1000 * file, so that we can pick up changes to that file that are
1001 * written by dhpccd, dhclient, pppd, openvpn and similar. */
1003 /* NOTE: This assumes that /etc/resolv.conf is written
1004 * atomically (i. e. a temporary file is written, flushed and
1005 * then renamed into place). To fix Debian Bug#389270. */
1007 /* NOTE: If this leaks memory or doesn't re-read
1008 * /etc/resolv.conf, we're in trouble. The res_init() interface
1009 * is only lightly documented :-( */
1015 for (ctl = querylist; ctl; ctl = ctl->next)
1019 if (!(implicitmode && ctl->server.skip))
1024 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
1025 ctl->server.pollname);
1029 /* check skip interval first so that it counts all polls */
1030 if (run.poll_interval && ctl->server.interval)
1032 if (ctl->server.poll_count++ % ctl->server.interval)
1034 if (outlevel >= O_VERBOSE)
1036 GT_("interval not reached, not querying %s\n"),
1037 ctl->server.pollname);
1044 * Don't do monitoring if we were woken by a signal.
1045 * Note that interface_approve() does its own error logging.
1047 if (!interface_approve(&ctl->server, !lastsig))
1049 #endif /* CAN_MONITOR */
1051 dofastuidl = 0; /* this is reset in the driver if required */
1055 * At each poll interval, check the pwmd server for
1056 * changes in host and auth settings.
1058 if (ctl->pwmd_file) {
1059 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1062 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol, ctl))
1066 querystatus = query_host(ctl);
1068 if (NUM_NONZERO(ctl->fastuidl))
1069 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
1071 /* leave the UIDL state alone if there have been any errors */
1073 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
1074 uid_swap_lists(ctl);
1076 uid_discard_new_list(ctl);
1078 #endif /* POP3_ENABLE */
1080 if (querystatus == PS_SUCCESS)
1082 else if (!check_only &&
1083 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
1087 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
1089 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
1091 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
1093 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
1095 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
1097 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
1099 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
1101 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
1103 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
1105 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
1107 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
1109 report(stdout,GT_("Query status=11 (DNS)\n")); break;
1111 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
1113 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
1115 report(stdout,GT_("Query status=%d\n"),querystatus);
1120 if (ctl->server.monitor)
1123 * Allow some time for the link to quiesce. One
1124 * second is usually sufficient, three is safe.
1125 * Note: this delay is important - don't remove!
1128 interface_note_activity(&ctl->server);
1130 #endif /* CAN_MONITOR */
1140 /* close connections cleanly */
1144 * OK, we've polled. Now sleep.
1146 if (run.poll_interval)
1149 * Because passwords can expire, it may happen that *all*
1150 * hosts are now out of the loop due to authfail
1151 * conditions. If this happens daemon-mode fetchmail
1152 * should softly and silently vanish away, rather than
1153 * spinning uselessly.
1157 for (ctl = querylist; ctl; ctl = ctl->next)
1158 if (ctl->active && !(implicitmode && ctl->server.skip))
1163 report(stderr, GT_("All connections are wedged. Exiting.\n"));
1164 /* FIXME: someday, send notification mail */
1168 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1169 || outlevel > O_NORMAL)
1171 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
1174 * With this simple hack, we make it possible for a foreground
1175 * fetchmail to wake up one in daemon mode. What we want is the
1176 * side effect of interrupting any sleep that may be going on,
1177 * forcing fetchmail to re-poll its hosts. The second line is
1178 * for people who think all system daemons wake up on SIGHUP.
1180 set_signal_handler(SIGUSR1, donothing);
1181 if (getuid() == ROOT_UID)
1182 set_signal_handler(SIGHUP, donothing);
1185 * OK, now pause until it's time for the next poll cycle.
1186 * A nonzero return indicates we received a wakeup signal;
1187 * unwedge all servers in case the problem has been
1188 * manually repaired.
1190 if ((lastsig = interruptible_idle(run.poll_interval)))
1192 if (outlevel > O_SILENT)
1193 #ifdef SYS_SIGLIST_DECLARED
1195 GT_("awakened by %s\n"), sys_siglist[lastsig]);
1198 GT_("awakened by signal %d\n"), lastsig);
1200 for (ctl = querylist; ctl; ctl = ctl->next)
1201 ctl->wedged = FALSE;
1204 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1205 || outlevel > O_NORMAL)
1206 report(stdout, GT_("awakened at %s\n"), timestamp());
1208 } while (run.poll_interval);
1210 if (outlevel >= O_VERBOSE)
1211 report(stdout, GT_("normal termination, status %d\n"),
1212 successes ? PS_SUCCESS : querystatus);
1218 else if (querystatus)
1221 /* in case we interrupted before a successful fetch */
1225 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
1228 * If force is off, modify dstl fields only when they're empty (treat srcl
1229 * as defaults). If force is on, modify each dstl field whenever scrcl
1230 * is nonempty (treat srcl as an override).
1232 if (force ? !!*srcl : !*dstl)
1234 struct idlist *cpl = copy_str_list(*srcl);
1236 append_str_list(dstl, &cpl);
1240 static void optmerge(struct query *h2, struct query *h1, int force)
1241 /* merge two options records */
1243 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
1244 list_merge(&h2->localnames, &h1->localnames, force);
1245 list_merge(&h2->mailboxes, &h1->mailboxes, force);
1246 list_merge(&h2->smtphunt, &h1->smtphunt, force);
1247 list_merge(&h2->domainlist, &h1->domainlist, force);
1248 list_merge(&h2->antispam, &h1->antispam, force);
1250 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
1251 FLAG_MERGE(server.via);
1252 FLAG_MERGE(server.protocol);
1253 FLAG_MERGE(server.service);
1254 FLAG_MERGE(server.interval);
1255 FLAG_MERGE(server.authenticate);
1256 FLAG_MERGE(server.timeout);
1257 FLAG_MERGE(server.envelope);
1258 FLAG_MERGE(server.envskip);
1259 FLAG_MERGE(server.qvirtual);
1260 FLAG_MERGE(server.skip);
1261 FLAG_MERGE(server.dns);
1262 FLAG_MERGE(server.checkalias);
1263 FLAG_MERGE(server.principal);
1266 FLAG_MERGE(server.interface);
1267 FLAG_MERGE(server.interface_pair);
1268 FLAG_MERGE(server.monitor);
1271 FLAG_MERGE(server.plugin);
1272 FLAG_MERGE(server.plugout);
1273 FLAG_MERGE(server.tracepolls);
1274 FLAG_MERGE(server.badheader);
1275 FLAG_MERGE(server.retrieveerror);
1277 FLAG_MERGE(wildcard);
1278 FLAG_MERGE(remotename);
1279 FLAG_MERGE(password);
1282 FLAG_MERGE(listener);
1283 FLAG_MERGE(smtpaddress);
1284 FLAG_MERGE(smtpname);
1285 FLAG_MERGE(preconnect);
1286 FLAG_MERGE(postconnect);
1290 FLAG_MERGE(limitflush);
1291 FLAG_MERGE(fetchall);
1292 FLAG_MERGE(rewrite);
1293 FLAG_MERGE(forcecr);
1294 FLAG_MERGE(stripcr);
1295 FLAG_MERGE(pass8bits);
1296 FLAG_MERGE(dropstatus);
1297 FLAG_MERGE(dropdelivered);
1298 FLAG_MERGE(mimedecode);
1301 FLAG_MERGE(warnings);
1302 FLAG_MERGE(fetchlimit);
1303 FLAG_MERGE(fetchsizelimit);
1304 FLAG_MERGE(fastuidl);
1305 FLAG_MERGE(batchlimit);
1307 FLAG_MERGE(use_ssl);
1309 FLAG_MERGE(sslcert);
1310 FLAG_MERGE(sslproto);
1311 FLAG_MERGE(sslcertck);
1312 FLAG_MERGE(sslcertfile);
1313 FLAG_MERGE(sslcertpath);
1314 FLAG_MERGE(sslcommonname);
1315 FLAG_MERGE(sslfingerprint);
1317 FLAG_MERGE(expunge);
1319 FLAG_MERGE(properties);
1323 /** Load configuration files.
1324 * \return - true if no servers found on the command line
1325 * - false if servers found on the command line */
1326 static int load_params(int argc, char **argv, int optind)
1328 int implicitmode, st;
1330 struct query def_opts, *ctl;
1334 run.bouncemail = TRUE;
1335 run.softbounce = TRUE; /* treat permanent errors as temporary */
1336 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1338 memset(&def_opts, '\0', sizeof(struct query));
1339 def_opts.smtp_socket = -1;
1340 def_opts.smtpaddress = (char *)0;
1341 def_opts.smtpname = (char *)0;
1342 def_opts.server.protocol = P_AUTO;
1343 def_opts.server.timeout = CLIENT_TIMEOUT;
1344 def_opts.server.esmtp_name = user;
1345 def_opts.server.badheader = BHREJECT;
1346 def_opts.warnings = WARNING_INTERVAL;
1347 def_opts.remotename = user;
1348 def_opts.listener = SMTP_MODE;
1349 def_opts.fetchsizelimit = 100;
1350 def_opts.fastuidl = 4;
1352 /* get the location of rcfile */
1354 p = strrchr (rcfile, '/');
1355 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1356 *p = 0; /* replace '/' by '0' */
1357 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1358 *p = '/'; /* restore '/' */
1359 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1360 strcpy (rcfiledir, "/");
1363 /* note the parse time, so we can pick up on modifications */
1364 if (strcmp(rcfile, "-") == 0)
1365 parsetime = time(NULL);
1367 if (stat(rcfile, &rcstat) != -1)
1368 parsetime = rcstat.st_mtime;
1369 else if (errno != ENOENT)
1370 report(stderr, GT_("couldn't time-check the run-control file\n"));
1373 /* this builds the host list */
1374 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1376 * FIXME: someday, send notification mail here if backgrounded.
1377 * Right now, that can happen if the user changes the rcfile
1378 * while the fetchmail is running in background. Do similarly
1379 * for the other exit() calls in this function.
1383 if ((implicitmode = (optind >= argc)))
1386 for (ctl = querylist; ctl; ctl = ctl->next) {
1387 ctl->active = !ctl->server.skip;
1389 if (ctl->pwmd_file) {
1391 * Cannot get an element path without a service.
1393 if (ctl->server.protocol <= 1) {
1394 report(stderr, GT_("fetchmail: %s configuration invalid, pwmd_file requires a protocol specification\n"),
1395 ctl->server.pollname);
1400 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1403 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol,
1407 time(&rcstat.st_mtime);
1412 for (ctl = querylist; ctl; ctl = ctl->next)
1413 ctl->active = !ctl->server.skip;
1417 for (; optind < argc; optind++)
1419 flag predeclared = FALSE;
1422 * If hostname corresponds to a host known from the rc file,
1423 * simply declare it active. Otherwise synthesize a host
1424 * record from command line and defaults
1426 for (ctl = querylist; ctl; ctl = ctl->next)
1427 if (!strcmp(ctl->server.pollname, argv[optind])
1428 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1430 /* Is this correct? */
1431 if (predeclared && outlevel >= O_VERBOSE)
1432 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1436 if (ctl->pwmd_file) {
1438 * Cannot get an element path without a service.
1440 if (ctl->server.protocol <= 1) {
1441 report(stderr, GT_("%s configuration invalid, pwmd_file requires a protocol specification\n"),
1442 ctl->server.pollname);
1446 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1447 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1450 if (get_pwmd_details(ctl->server.pollname,
1451 ctl->server.protocol, ctl))
1460 * Allocate and link record without copying in
1461 * command-line args; we'll do that with the optmerge
1464 ctl = hostalloc((struct query *)NULL);
1466 if (cmd_opts.pwmd_file) {
1468 * Cannot get an element path without a service.
1470 if (cmd_opts.server.protocol == 0 || cmd_opts.server.protocol == 1) {
1471 report(stderr, GT_("Option --pwmd-file needs a service (-p) parameter.\n"));
1475 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1476 if (do_pwmd_connect(cmd_opts.pwmd_socket, cmd_opts.pwmd_file))
1479 if (get_pwmd_details(argv[optind], cmd_opts.server.protocol,
1485 ctl->server.pollname = xstrdup(argv[optind]);
1488 ctl->server.pollname = xstrdup(argv[optind]);
1491 ctl->server.lead_server = (struct hostdata *)NULL;
1496 * If there's a defaults record, merge it and lose it.
1497 * FIXME: we don't currently free all entries that might be in struct query.
1499 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1503 for (ctl = querylist->next; ctl; ctl = ctl->next)
1504 optmerge(ctl, querylist, FALSE);
1506 querylist = querylist->next;
1507 free(tmpq->server.pollname);
1511 /* don't allow a defaults record after the first */
1512 for (ctl = querylist; ctl; ctl = ctl->next) {
1513 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1514 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1519 /* use localhost if we never fetch the FQDN of this host */
1520 fetchmailhost = "localhost";
1522 /* here's where we override globals */
1523 if (cmd_run.logfile)
1524 run.logfile = cmd_run.logfile;
1526 run.idfile = cmd_run.idfile;
1527 if (cmd_run.pidfile)
1528 run.pidfile = cmd_run.pidfile;
1529 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1530 if (cmd_run.poll_interval >= 0)
1531 run.poll_interval = cmd_run.poll_interval;
1532 if (cmd_run.invisible)
1533 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1534 if (cmd_run.showdots)
1535 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1536 if (cmd_run.use_syslog)
1537 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1538 if (cmd_run.postmaster)
1539 run.postmaster = cmd_run.postmaster;
1540 if (cmd_run.bouncemail)
1541 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1542 if (cmd_run.softbounce)
1543 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1545 /* check and daemon options are not compatible */
1546 if (check_only && run.poll_interval)
1547 run.poll_interval = 0;
1550 * DNS support is required for some protocols. We used to
1551 * do this unconditionally, but it made fetchmail excessively
1552 * vulnerable to misconfigured DNS setups.
1554 * If we're using ETRN or ODMR, the smtp hunt list is the
1555 * list of systems we're polling on behalf of; these have
1556 * to be fully-qualified domain names. The default for
1557 * this list should be the FQDN of localhost.
1559 * If we're using Kerberos for authentication, we need
1560 * the FQDN in order to generate capability keys.
1562 for (ctl = querylist; ctl; ctl = ctl->next)
1564 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1565 || ctl->server.authenticate == A_KERBEROS_V5))
1567 fetchmailhost = host_fqdn(1);
1571 if (!ctl) /* list exhausted */
1572 fetchmailhost = host_fqdn(0);
1574 /* this code enables flags to be turned off */
1575 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1577 else if (flag == FLAG_FALSE)\
1582 /* merge in wired defaults, do sanity checks and prepare internal fields */
1583 for (ctl = querylist; ctl; ctl = ctl->next)
1585 ctl->wedged = FALSE;
1587 /* merge in defaults */
1588 optmerge(ctl, &def_opts, FALSE);
1590 /* force command-line options */
1591 optmerge(ctl, &cmd_opts, TRUE);
1594 * queryname has to be set up for inactive servers too.
1595 * Otherwise the UIDL code core-dumps on startup.
1597 if (ctl->server.via)
1598 ctl->server.queryname = xstrdup(ctl->server.via);
1600 ctl->server.queryname = xstrdup(ctl->server.pollname);
1603 * We no longer do DNS lookups at startup.
1604 * This is a kluge. It enables users to edit their
1605 * configurations when DNS isn't available.
1607 ctl->server.truename = xstrdup(ctl->server.queryname);
1609 if (configdump || ctl->active )
1611 DEFAULT(ctl->keep, FALSE);
1612 DEFAULT(ctl->fetchall, FALSE);
1613 DEFAULT(ctl->flush, FALSE);
1614 DEFAULT(ctl->limitflush, FALSE);
1615 DEFAULT(ctl->rewrite, TRUE);
1616 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1617 DEFAULT(ctl->forcecr, FALSE);
1618 DEFAULT(ctl->pass8bits, FALSE);
1619 DEFAULT(ctl->dropstatus, FALSE);
1620 DEFAULT(ctl->dropdelivered, FALSE);
1621 DEFAULT(ctl->mimedecode, FALSE);
1622 DEFAULT(ctl->idle, FALSE);
1623 DEFAULT(ctl->server.dns, TRUE);
1624 DEFAULT(ctl->use_ssl, FALSE);
1625 DEFAULT(ctl->sslcertck, FALSE);
1626 DEFAULT(ctl->server.checkalias, FALSE);
1629 * XXX FIXME: do we need this check or can we rely on the .y
1630 * parser handling this?
1634 report(stderr, GT_("SSL support is not compiled in.\n"));
1637 #endif /* SSL_ENABLE */
1640 if (ctl->server.authenticate == A_KERBEROS_V5) {
1641 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1646 if (ctl->server.authenticate == A_GSSAPI) {
1647 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1653 * Make sure we have a nonempty host list to forward to.
1656 save_str(&ctl->smtphunt, "localhost", FALSE);
1659 * Make sure we have a nonempty list of domains to fetch from.
1661 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1662 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1664 /* if `user' doesn't name a real local user, try to run as root */
1665 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1668 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1669 if (!ctl->localnames) /* for local delivery via SMTP */
1670 save_str_pair(&ctl->localnames, user, NULL);
1674 * can't handle multidrop mailboxes without "envelope"
1675 * option, this causes truckloads full of support complaints
1676 * "all mail forwarded to postmaster"
1678 if (MULTIDROP(ctl) && !ctl->server.envelope)
1680 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1681 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1684 /* if no folders were specified, set up the null one as default */
1685 if (!ctl->mailboxes)
1686 save_str(&ctl->mailboxes, (char *)NULL, 0);
1688 /* maybe user overrode timeout on command line? */
1689 if (ctl->server.timeout == -1)
1690 ctl->server.timeout = CLIENT_TIMEOUT;
1693 if (ctl->server.service) {
1694 int port = servport(ctl->server.service);
1697 (void) fprintf(stderr,
1698 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1699 ctl->server.pollname);
1703 if (ctl->listener == LMTP_MODE)
1707 for (idp = ctl->smtphunt; idp; idp = idp->next)
1711 if (!(cp = strrchr(idp->id, '/'))
1712 || (0 == strcmp(cp + 1, SMTP_PORT))
1713 || servport(cp + 1) == SMTP_PORT_NUM)
1715 (void) fprintf(stderr,
1716 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1717 ctl->server.pollname);
1724 * "I beg to you, have mercy on the we[a]k minds like myself."
1725 * wrote Pehr Anderson. Your petition is granted.
1727 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1729 (void) fprintf(stderr,
1730 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1736 * If the user didn't set a last-resort user to get misaddressed
1737 * multidrop mail, set an appropriate default here.
1739 if (!run.postmaster)
1741 if (getuid() != ROOT_UID) /* ordinary user */
1742 run.postmaster = user;
1744 run.postmaster = "postmaster";
1747 return(implicitmode);
1750 static void terminate_poll(int sig)
1751 /* to be executed at the end of a poll cycle */
1755 report(stdout, GT_("terminated with signal %d\n"), sig);
1759 * Update UID information at end of each poll, rather than at end
1760 * of run, because that way we don't lose all UIDL information since
1761 * the beginning of time if fetchmail crashes.
1764 write_saved_lists(querylist, run.idfile);
1765 #endif /* POP3_ENABLE */
1768 static void terminate_run(int sig)
1769 /* to be executed on normal or signal-induced termination */
1773 terminate_poll(sig);
1776 * Craig Metz, the RFC1938 one-time-password guy, points out:
1777 * "Remember that most kernels don't zero pages before handing them to the
1778 * next process and many kernels share pages between user and kernel space.
1779 * You'd be very surprised what you can find from a short program to do a
1780 * malloc() and then dump the contents of the pages you got. By zeroing
1781 * the secrets at end of run (earlier if you can), you make sure the next
1782 * guy can't get the password/pass phrase."
1784 * Right you are, Craig!
1786 for (ctl = querylist; ctl; ctl = ctl->next)
1788 memset(ctl->password, '\0', strlen(ctl->password));
1791 if (activecount == 0)
1794 exit(successes ? PS_SUCCESS : querystatus);
1798 * Sequence of protocols to try when autoprobing, most capable to least.
1800 static const int autoprobe[] =
1804 #endif /* IMAP_ENABLE */
1807 #endif /* POP3_ENABLE */
1810 static int query_host(struct query *ctl)
1811 /* perform fetch transaction with single host */
1817 * If we're syslogging the progress messages are automatically timestamped.
1818 * Force timestamping if we're going to a logfile.
1820 if (outlevel >= O_VERBOSE)
1822 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1824 ctl->server.pollname,
1825 showproto(ctl->server.protocol),
1829 switch (ctl->server.protocol) {
1831 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1833 ctl->server.protocol = autoprobe[i];
1835 st = query_host(ctl);
1838 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1841 ctl->server.protocol = P_AUTO;
1847 } while (st == PS_REPOLL);
1849 report(stderr, GT_("POP3 support is not configured.\n"));
1851 #endif /* POP3_ENABLE */
1857 } while (st == PS_REPOLL);
1859 report(stderr, GT_("IMAP support is not configured.\n"));
1861 #endif /* IMAP_ENABLE */
1865 report(stderr, GT_("ETRN support is not configured.\n"));
1870 #endif /* ETRN_ENABLE */
1873 report(stderr, GT_("ODMR support is not configured.\n"));
1877 #endif /* ODMR_ENABLE */
1880 report(stderr, GT_("unsupported protocol selected.\n"));
1885 * If we're syslogging the progress messages are automatically timestamped.
1886 * Force timestamping if we're going to a logfile.
1888 if (outlevel >= O_VERBOSE)
1890 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1892 ctl->server.pollname,
1893 showproto(ctl->server.protocol),
1900 static int print_id_of(struct uid_db_record *rec, void *unused)
1904 printf("\t%s\n", rec->id);
1907 static void dump_params (struct runctl *runp,
1908 struct query *querylist, flag implicit)
1909 /* display query parameters in English */
1913 if (runp->poll_interval)
1914 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1916 printf(GT_("Logfile is %s\n"), runp->logfile);
1917 if (strcmp(runp->idfile, IDFILE_NAME))
1918 printf(GT_("Idfile is %s\n"), runp->idfile);
1919 if (runp->use_syslog)
1920 printf(GT_("Progress messages will be logged via syslog\n"));
1921 if (runp->invisible)
1922 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1924 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1925 if (runp->postmaster)
1926 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1929 if (!runp->bouncemail)
1930 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1931 else if (outlevel >= O_VERBOSE)
1932 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1934 if (!runp->softbounce)
1935 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1936 else if (outlevel >= O_VERBOSE)
1937 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1939 for (ctl = querylist; ctl; ctl = ctl->next)
1941 if (!ctl->active || (implicit && ctl->server.skip))
1944 printf(GT_("Options for retrieving from %s@%s:\n"),
1945 ctl->remotename, visbuf(ctl->server.pollname));
1947 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1948 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1950 if (ctl->server.interval)
1951 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1952 " Poll of this server will occur every %d intervals.\n",
1953 ctl->server.interval), ctl->server.interval);
1954 if (ctl->server.truename)
1955 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1956 if (ctl->server.skip || outlevel >= O_VERBOSE)
1957 printf(ctl->server.skip
1958 ? GT_(" This host will not be queried when no host is specified.\n")
1959 : GT_(" This host will be queried when no host is specified.\n"));
1960 if (!NO_PASSWORD(ctl))
1963 printf(GT_(" Password will be prompted for.\n"));
1964 else if (outlevel >= O_VERBOSE)
1966 printf(GT_(" Password = \"%s\".\n"),
1967 visbuf(ctl->password));
1971 if (ctl->server.protocol == P_POP3
1972 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1973 && (ctl->server.authenticate == A_KERBEROS_V5))
1974 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1975 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1977 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1978 if (ctl->server.service)
1979 printf(GT_(" (using service %s)"), ctl->server.service);
1980 else if (outlevel >= O_VERBOSE)
1981 printf(GT_(" (using default port)"));
1984 switch (ctl->server.authenticate)
1987 printf(GT_(" All available authentication methods will be tried.\n"));
1990 printf(GT_(" Password authentication will be forced.\n"));
1993 printf(GT_(" MSN authentication will be forced.\n"));
1996 printf(GT_(" NTLM authentication will be forced.\n"));
1999 printf(GT_(" OTP authentication will be forced.\n"));
2002 printf(GT_(" CRAM-MD5 authentication will be forced.\n"));
2005 printf(GT_(" GSSAPI authentication will be forced.\n"));
2008 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
2011 printf(GT_(" End-to-end encryption assumed.\n"));
2014 printf(GT_(" APOP authentication will be forced.\n"));
2019 if (ctl->server.principal != (char *) NULL)
2020 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
2023 printf(GT_(" SSL encrypted sessions enabled.\n"));
2025 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
2026 if (ctl->sslcertck) {
2027 printf(GT_(" SSL server certificate checking enabled.\n"));
2029 if (ctl->sslcertfile != NULL)
2030 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
2031 if (ctl->sslcertpath != NULL)
2032 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
2033 if (ctl->sslcommonname != NULL)
2034 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
2035 if (ctl->sslfingerprint != NULL)
2036 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
2038 if (ctl->server.timeout > 0)
2039 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
2040 if (ctl->server.timeout == CLIENT_TIMEOUT)
2041 printf(GT_(" (default).\n"));
2045 if (MAILBOX_PROTOCOL(ctl))
2047 if (!ctl->mailboxes->id)
2048 printf(GT_(" Default mailbox selected.\n"));
2053 printf(GT_(" Selected mailboxes are:"));
2054 for (idp = ctl->mailboxes; idp; idp = idp->next)
2055 printf(" %s", idp->id);
2058 printf(ctl->fetchall
2059 ? GT_(" All messages will be retrieved (--all on).\n")
2060 : GT_(" Only new messages will be retrieved (--all off).\n"));
2062 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
2063 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
2065 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
2066 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
2067 printf(ctl->limitflush
2068 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
2069 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
2071 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
2072 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
2074 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
2075 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
2077 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
2078 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
2079 printf(ctl->pass8bits
2080 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
2081 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
2082 printf(ctl->mimedecode
2083 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
2084 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
2086 ? GT_(" Idle after poll is enabled (idle on).\n")
2087 : GT_(" Idle after poll is disabled (idle off).\n"));
2088 printf(ctl->dropstatus
2089 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
2090 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
2091 printf(ctl->dropdelivered
2092 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
2093 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
2094 if (NUM_NONZERO(ctl->limit))
2096 if (NUM_NONZERO(ctl->limit))
2097 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
2098 ctl->limit, ctl->limit);
2099 else if (outlevel >= O_VERBOSE)
2100 printf(GT_(" No message size limit (--limit 0).\n"));
2101 if (run.poll_interval > 0)
2102 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
2103 ctl->warnings, ctl->warnings);
2104 else if (outlevel >= O_VERBOSE)
2105 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
2107 if (NUM_NONZERO(ctl->fetchlimit))
2108 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
2109 ctl->fetchlimit, ctl->fetchlimit);
2110 else if (outlevel >= O_VERBOSE)
2111 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
2112 if (NUM_NONZERO(ctl->fetchsizelimit))
2113 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
2114 ctl->fetchsizelimit, ctl->fetchsizelimit);
2115 else if (outlevel >= O_VERBOSE)
2116 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
2117 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
2119 if (ctl->fastuidl == 1)
2120 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
2122 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
2124 else if (outlevel >= O_VERBOSE)
2125 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
2126 if (NUM_NONZERO(ctl->batchlimit))
2127 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
2128 else if (outlevel >= O_VERBOSE)
2129 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
2130 if (MAILBOX_PROTOCOL(ctl))
2132 if (NUM_NONZERO(ctl->expunge))
2133 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
2134 else if (outlevel >= O_VERBOSE)
2135 printf(GT_(" No forced expunges (--expunge 0).\n"));
2138 else /* ODMR or ETRN */
2142 printf(GT_(" Domains for which mail will be fetched are:"));
2143 for (idp = ctl->domainlist; idp; idp = idp->next)
2145 printf(" %s", idp->id);
2146 if (!idp->val.status.mark)
2147 printf(GT_(" (default)"));
2152 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
2153 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
2154 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
2161 printf(GT_(" Messages will be %cMTP-forwarded to:"),
2163 for (idp = ctl->smtphunt; idp; idp = idp->next)
2165 printf(" %s", idp->id);
2166 if (!idp->val.status.mark)
2167 printf(GT_(" (default)"));
2171 if (ctl->smtpaddress)
2172 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
2175 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
2178 if (MAILBOX_PROTOCOL(ctl))
2180 if (ctl->antispam != (struct idlist *)NULL)
2184 printf(GT_(" Recognized listener spam block responses are:"));
2185 for (idp = ctl->antispam; idp; idp = idp->next)
2186 printf(" %d", idp->val.status.num);
2189 else if (outlevel >= O_VERBOSE)
2190 printf(GT_(" Spam-blocking disabled\n"));
2192 if (ctl->preconnect)
2193 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
2194 visbuf(ctl->preconnect));
2195 else if (outlevel >= O_VERBOSE)
2196 printf(GT_(" No pre-connection command.\n"));
2197 if (ctl->postconnect)
2198 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
2199 visbuf(ctl->postconnect));
2200 else if (outlevel >= O_VERBOSE)
2201 printf(GT_(" No post-connection command.\n"));
2202 if (MAILBOX_PROTOCOL(ctl)) {
2203 if (!ctl->localnames)
2204 printf(GT_(" No localnames declared for this host.\n"));
2210 for (idp = ctl->localnames; idp; idp = idp->next)
2213 if (count > 1 || ctl->wildcard)
2214 printf(GT_(" Multi-drop mode: "));
2216 printf(GT_(" Single-drop mode: "));
2218 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
2219 if (outlevel >= O_VERBOSE)
2221 for (idp = ctl->localnames; idp; idp = idp->next)
2223 printf("\t%s -> %s\n", idp->id, idp->val.id2);
2225 printf("\t%s\n", idp->id);
2227 fputs("\t*\n", stdout);
2230 if (count > 1 || ctl->wildcard)
2232 printf(ctl->server.dns
2233 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
2234 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
2235 if (ctl->server.dns)
2237 if (ctl->server.checkalias)
2238 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
2240 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
2242 if (ctl->server.envelope == STRING_DISABLED)
2243 printf(GT_(" Envelope-address routing is disabled\n"));
2246 printf(GT_(" Envelope header is assumed to be: %s\n"),
2247 ctl->server.envelope ? ctl->server.envelope : "Received");
2248 if (ctl->server.envskip || outlevel >= O_VERBOSE)
2249 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
2250 ctl->server.envskip);
2251 if (ctl->server.qvirtual)
2252 printf(GT_(" Prefix %s will be removed from user id\n"),
2253 ctl->server.qvirtual);
2254 else if (outlevel >= O_VERBOSE)
2255 printf(GT_(" No prefix stripping\n"));
2258 if (ctl->server.akalist)
2260 printf(GT_(" Predeclared mailserver aliases:"));
2261 for (idp = ctl->server.akalist; idp; idp = idp->next)
2262 printf(" %s", idp->id);
2266 if (ctl->server.localdomains)
2268 printf(GT_(" Local domains:"));
2269 for (idp = ctl->server.localdomains; idp; idp = idp->next)
2270 printf(" %s", idp->id);
2277 if (ctl->server.interface)
2278 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
2279 else if (outlevel >= O_VERBOSE)
2280 printf(GT_(" No interface requirement specified.\n"));
2281 if (ctl->server.monitor)
2282 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
2283 else if (outlevel >= O_VERBOSE)
2284 printf(GT_(" No monitor interface specified.\n"));
2287 if (ctl->server.plugin)
2288 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
2289 else if (outlevel >= O_VERBOSE)
2290 printf(GT_(" No plugin command specified.\n"));
2291 if (ctl->server.plugout)
2292 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
2293 else if (outlevel >= O_VERBOSE)
2294 printf(GT_(" No plugout command specified.\n"));
2296 if (MAILBOX_PROTOCOL(ctl))
2300 if (!(count = uid_db_n_records(&ctl->oldsaved)))
2301 printf(GT_(" No UIDs saved from this host.\n"));
2305 printf(GT_(" %d UIDs saved.\n"), count);
2306 traverse_uid_db(&ctl->oldsaved, print_id_of, NULL);
2310 if (ctl->server.tracepolls)
2311 printf(GT_(" Poll trace information will be added to the Received header.\n"));
2312 else if (outlevel >= O_VERBOSE)
2313 printf(GT_(" No poll trace information will be added to the Received header.\n"));
2315 switch (ctl->server.badheader) {
2317 if (outlevel >= O_VERBOSE)
2318 printf(GT_(" Messages with bad headers will be rejected.\n"));
2321 printf(GT_(" Messages with bad headers will be passed on.\n"));
2325 switch (ctl->server.retrieveerror) {
2327 if (outlevel >= O_VERBOSE)
2328 printf(GT_(" Messages with fetch body errors will cause the session to abort.\n"));
2331 printf(GT_(" Messages with fetch body errors will be skipped, the session will continue.\n"));
2334 printf(GT_(" Messages with fetch body errors will be marked seen, the session will continue.\n"));
2338 if (ctl->properties)
2339 printf(GT_(" Pass-through properties \"%s\".\n"),
2340 visbuf(ctl->properties));
2344 /* fetchmail.c ends here */