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);
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);
478 * We used to arrange for the lock to be removed on exit close
479 * to where the lock was asserted. Now we need to do it here, because
480 * we might have re-executed in background with an existing lock
481 * as the result of a changed rcfile (see the code near the execvp(3)
482 * call near the beginning of the polling loop for details). We want
483 * to be sure the lock gets nuked on any error exit, basically.
488 /* save the current directory */
489 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
490 report(stderr, GT_("could not get current working directory\n"));
498 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts, &safewithbg);
502 if (quitmode && quitind == argc)
508 const char *features =
511 #endif /* POP3_ENABLE */
514 #endif /* IMAP_ENABLE */
520 #endif /* RPA_ENABLE */
523 #endif /* NTLM_ENABLE */
526 #endif /* SDPS_ENABLE */
529 #endif /* ETRN_ENABLE */
532 #endif /* ODMR_ENABLE */
538 #endif /* OPIE_ENABLE */
539 #ifdef HAVE_PKG_hesiod
544 #endif /* HAVE_SOCKS */
547 #endif /* ENABLE_NLS */
550 #endif /* KERBEROS_V5 */
553 #endif /* HAVE_LIBPWMD */
555 printf(GT_("This is fetchmail release %s"), VERSION);
556 fputs(features, stdout);
558 printcopyright(stdout);
560 fputs("Fallback MDA: ", stdout);
562 fputs(FALLBACK_MDA, stdout);
564 fputs("(none)", stdout);
569 /* this is an attempt to help remote debugging */
570 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
573 /* avoid parsing the config file if all we're doing is killing a daemon */
575 implicitmode = load_params(argc, argv, optind);
577 /* precedence: logfile (if effective) overrides syslog. */
578 if (run.logfile && run.poll_interval && !nodetach) {
582 /* logging should be set up early in case we were restarted from exec */
585 openlog(program_name, LOG_PID, LOG_MAIL);
589 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
592 /* initialize UID handling */
596 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
599 initialize_saved_lists(querylist, run.idfile);
601 #endif /* POP3_ENABLE */
603 /* construct the lockfile */
607 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
608 * Core dumps could otherwise contain passwords to be scavenged by a
611 if (outlevel < O_VERBOSE || run.poll_interval > 0)
613 struct rlimit corelimit;
614 corelimit.rlim_cur = 0;
615 corelimit.rlim_max = 0;
616 setrlimit(RLIMIT_CORE, &corelimit);
619 #define NETRC_FILE ".netrc"
620 /* parse the ~/.netrc file (if present) for future password lookups. */
621 netrc_file = prependdir (NETRC_FILE, home);
622 netrc_list = parse_netrc(netrc_file);
626 /* pick up passwords where we can */
627 for (ctl = querylist; ctl; ctl = ctl->next)
629 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
631 if (NO_PASSWORD(ctl))
632 /* Server won't care what the password is, but there
633 must be some non-null string here. */
634 ctl->password = ctl->remotename;
639 /* look up the pollname and account in the .netrc file. */
640 p = search_netrc(netrc_list,
641 ctl->server.pollname, ctl->remotename);
642 /* if we find a matching entry with a password, use it */
643 if (p && p->password)
644 ctl->password = xstrdup(p->password);
646 /* otherwise try with "via" name if there is one */
647 else if (ctl->server.via)
649 p = search_netrc(netrc_list,
650 ctl->server.via, ctl->remotename);
651 if (p && p->password)
652 ctl->password = xstrdup(p->password);
658 free_netrc(netrc_list);
661 /* perhaps we just want to check options? */
664 int havercfile = access(rcfile, 0);
666 printf(GT_("Taking options from command line%s%s\n"),
667 havercfile ? "" : GT_(" and "),
668 havercfile ? "" : rcfile);
670 if (querylist == NULL)
672 GT_("No mailservers set up -- perhaps %s is missing?\n"),
675 dump_params(&run, querylist, implicitmode);
679 /* dump options as a Python dictionary, for configurator use */
682 dump_config(&run, querylist);
686 /* check for another fetchmail running concurrently */
687 pid = fm_lock_state();
689 pid = bkgd ? -pid : pid;
691 /* if no mail servers listed and nothing in background, we're done */
692 if (!quitonly && pid == 0 && querylist == NULL) {
693 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
697 /* perhaps user asked us to kill the other fetchmail */
700 if (pid == 0 || pid == getpid())
701 /* this test enables re-execing on a changed rcfile
702 * for pid == getpid() */
705 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
709 else if (kill(pid, SIGTERM) < 0)
711 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
712 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
719 if (outlevel > O_SILENT)
720 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
721 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
722 /* We used to nuke the other process's lock here, with
723 * fm_lock_release(), which is broken. The other process
724 * needs to clear its lock by itself. */
728 /* wait for other process to exit */
729 maxwait = 10; /* seconds */
730 while (kill(pid, 0) == 0 && --maxwait >= 0) {
737 /* another fetchmail is running -- wake it up or die */
743 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
746 else if (!implicitmode)
749 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
756 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
760 else if (getpid() == pid)
761 /* this test enables re-execing on a changed rcfile */
763 else if (argc > 1 && !safewithbg)
766 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
769 fprintf(stderr, "argc = %d, arg list:\n", argc);
770 for (i = 1; i < argc; i++) fprintf(stderr, "arg %d = \"%s\"\n", i, argv[i]);
774 else if (kill(pid, SIGUSR1) == 0)
776 if (outlevel > O_SILENT)
778 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
785 * Should never happen -- possible only if a background fetchmail
786 * croaks after the first kill probe above but before the
787 * SIGUSR1/SIGHUP transmission.
790 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
792 return(PS_UNDEFINED);
796 /* pick up interactively any passwords we need but don't have */
797 for (ctl = querylist; ctl; ctl = ctl->next)
799 if (ctl->active && !(implicitmode && ctl->server.skip)
800 && !NO_PASSWORD(ctl) && !ctl->password)
805 GT_("fetchmail: can't find a password for %s@%s.\n"),
806 ctl->remotename, ctl->server.pollname);
809 const char* password_prompt = GT_("Enter password for %s@%s: ");
810 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
812 tmpbuf = (char *)xmalloc(pplen);
813 snprintf(tmpbuf, pplen, password_prompt,
814 ctl->remotename, ctl->server.pollname);
815 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
822 * Time to initiate the SOCKS library (this is not mandatory: it just
823 * registers the correct application name for logging purpose. If you
824 * have some problem, comment out these lines).
827 SOCKSinit("fetchmail");
828 #endif /* HAVE_SOCKS */
830 /* avoid zombies from plugins */
833 /* Fix up log destination - if the if() is true, the precedence rule
834 * above hasn't killed off the syslog option, because the logfile
835 * option is ineffective (because we're not detached or not in
836 * deamon mode), so kill it for the benefit of other parts of the
838 if (run.logfile && run.use_syslog)
842 * Maybe time to go to demon mode...
844 if (run.poll_interval)
849 rc = daemonize(run.logfile);
851 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
855 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
858 * We'll set up a handler for these when we're sleeping,
859 * but ignore them otherwise so as not to interrupt a poll.
861 set_signal_handler(SIGUSR1, SIG_IGN);
862 if (run.poll_interval && getuid() == ROOT_UID)
863 set_signal_handler(SIGHUP, SIG_IGN);
867 /* not in daemon mode */
868 if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
870 if (!freopen(run.logfile, "a", stdout))
871 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
872 if (!freopen(run.logfile, "a", stderr))
873 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
875 report(stdout, GT_("fetchmail: Warning: syslog and logfile are set. Check both for logs!\n"));
881 /* beyond here we don't want more than one fetchmail running per user */
883 set_signal_handler(SIGABRT, terminate_run);
884 set_signal_handler(SIGINT, terminate_run);
885 set_signal_handler(SIGTERM, terminate_run);
886 set_signal_handler(SIGALRM, terminate_run);
887 set_signal_handler(SIGPIPE, SIG_IGN);
888 set_signal_handler(SIGQUIT, terminate_run);
890 /* here's the exclusion lock */
893 if (check_only && outlevel >= O_VERBOSE) {
894 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
898 * Query all hosts. If there's only one, the error return will
899 * reflect the status of that transaction.
903 * Check to see if the rcfile has been touched. If so,
904 * re-exec so the file will be reread. Doing it this way
905 * avoids all the complications of trying to deallocate the
906 * in-core control structures -- and the potential memory
916 if (strcmp(rcfile, "-") == 0) {
918 } else if (stat(rcfile, &rcstat) == -1) {
921 GT_("couldn't time-check %s (error %d)\n"),
926 * isatty() to make sure this is a background process since the
927 * lockfile is removed after each invokation.
929 else if (!isatty(1) && rcstat.st_mtime > parsetime)
931 else if (rcstat.st_mtime > parsetime)
934 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
937 /* restore the startup directory */
938 if (!currentwd[0] || chdir (currentwd) == -1)
939 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
943 * Matthias Andree: Isn't this prone to introduction of
944 * "false" programs by interfering with PATH? Those
945 * path-searching execs might not be the best ideas for
948 * Rob Funk: But is there any way for someone to modify
949 * the PATH variable of a running fetchmail? I don't know
952 * Dave's change makes fetchmail restart itself in exactly
953 * the way it was started from the shell (or shell script)
954 * in the first place. If you're concerned about PATH
955 * contamination, call fetchmail initially with a full
956 * path, and use Dave's patch.
958 * Not using a -p variant of exec means that the restart
959 * will break if both (a) the user depended on PATH to
960 * call fetchmail in the first place, and (b) the system
961 * doesn't save the whole path in argv[0] if the whole
962 * path wasn't used in the initial call. (If I recall
963 * correctly, Linux saves it but many other Unices don't.)
965 execvp(argv[0], argv);
966 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
969 #ifdef HAVE_RES_SEARCH
970 /* Boldly assume that we also have res_init() if we have
971 * res_search(), and call res_init() to re-read the resolv.conf
972 * file, so that we can pick up changes to that file that are
973 * written by dhpccd, dhclient, pppd, openvpn and similar. */
975 /* NOTE: This assumes that /etc/resolv.conf is written
976 * atomically (i. e. a temporary file is written, flushed and
977 * then renamed into place). To fix Debian Bug#389270. */
979 /* NOTE: If this leaks memory or doesn't re-read
980 * /etc/resolv.conf, we're in trouble. The res_init() interface
981 * is only lightly documented :-( */
987 for (ctl = querylist; ctl; ctl = ctl->next)
991 if (!(implicitmode && ctl->server.skip))
996 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
997 ctl->server.pollname);
1001 /* check skip interval first so that it counts all polls */
1002 if (run.poll_interval && ctl->server.interval)
1004 if (ctl->server.poll_count++ % ctl->server.interval)
1006 if (outlevel >= O_VERBOSE)
1008 GT_("interval not reached, not querying %s\n"),
1009 ctl->server.pollname);
1016 * Don't do monitoring if we were woken by a signal.
1017 * Note that interface_approve() does its own error logging.
1019 if (!interface_approve(&ctl->server, !lastsig))
1021 #endif /* CAN_MONITOR */
1023 dofastuidl = 0; /* this is reset in the driver if required */
1027 * At each poll interval, check the pwmd server for
1028 * changes in host and auth settings.
1030 if (ctl->pwmd_file) {
1031 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1034 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol, ctl))
1038 querystatus = query_host(ctl);
1040 if (NUM_NONZERO(ctl->fastuidl))
1041 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
1043 /* leave the UIDL state alone if there have been any errors */
1045 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
1046 uid_swap_lists(ctl);
1048 uid_discard_new_list(ctl);
1050 #endif /* POP3_ENABLE */
1052 if (querystatus == PS_SUCCESS)
1054 else if (!check_only &&
1055 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
1059 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
1061 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
1063 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
1065 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
1067 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
1069 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
1071 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
1073 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
1075 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
1077 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
1079 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
1081 report(stdout,GT_("Query status=11 (DNS)\n")); break;
1083 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
1085 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
1087 report(stdout,GT_("Query status=%d\n"),querystatus);
1092 if (ctl->server.monitor)
1095 * Allow some time for the link to quiesce. One
1096 * second is usually sufficient, three is safe.
1097 * Note: this delay is important - don't remove!
1100 interface_note_activity(&ctl->server);
1102 #endif /* CAN_MONITOR */
1113 /* close connections cleanly */
1117 * OK, we've polled. Now sleep.
1119 if (run.poll_interval)
1122 * Because passwords can expire, it may happen that *all*
1123 * hosts are now out of the loop due to authfail
1124 * conditions. If this happens daemon-mode fetchmail
1125 * should softly and silently vanish away, rather than
1126 * spinning uselessly.
1130 for (ctl = querylist; ctl; ctl = ctl->next)
1131 if (ctl->active && !(implicitmode && ctl->server.skip))
1136 report(stderr, GT_("All connections are wedged. Exiting.\n"));
1137 /* FIXME: someday, send notification mail */
1141 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1142 || outlevel > O_NORMAL)
1144 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
1147 * With this simple hack, we make it possible for a foreground
1148 * fetchmail to wake up one in daemon mode. What we want is the
1149 * side effect of interrupting any sleep that may be going on,
1150 * forcing fetchmail to re-poll its hosts. The second line is
1151 * for people who think all system daemons wake up on SIGHUP.
1153 set_signal_handler(SIGUSR1, donothing);
1154 if (getuid() == ROOT_UID)
1155 set_signal_handler(SIGHUP, donothing);
1158 * OK, now pause until it's time for the next poll cycle.
1159 * A nonzero return indicates we received a wakeup signal;
1160 * unwedge all servers in case the problem has been
1161 * manually repaired.
1163 if ((lastsig = interruptible_idle(run.poll_interval)))
1165 if (outlevel > O_SILENT)
1166 #ifdef SYS_SIGLIST_DECLARED
1168 GT_("awakened by %s\n"), sys_siglist[lastsig]);
1171 GT_("awakened by signal %d\n"), lastsig);
1173 for (ctl = querylist; ctl; ctl = ctl->next)
1174 ctl->wedged = FALSE;
1177 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1178 || outlevel > O_NORMAL)
1179 report(stdout, GT_("awakened at %s\n"), timestamp());
1181 } while (run.poll_interval);
1183 if (outlevel >= O_VERBOSE)
1184 report(stdout, GT_("normal termination, status %d\n"),
1185 successes ? PS_SUCCESS : querystatus);
1191 else if (querystatus)
1194 /* in case we interrupted before a successful fetch */
1198 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
1201 * If force is off, modify dstl fields only when they're empty (treat srcl
1202 * as defaults). If force is on, modify each dstl field whenever scrcl
1203 * is nonempty (treat srcl as an override).
1205 if (force ? !!*srcl : !*dstl)
1207 struct idlist *cpl = copy_str_list(*srcl);
1209 append_str_list(dstl, &cpl);
1213 static void optmerge(struct query *h2, struct query *h1, int force)
1214 /* merge two options records */
1216 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
1217 list_merge(&h2->localnames, &h1->localnames, force);
1218 list_merge(&h2->mailboxes, &h1->mailboxes, force);
1219 list_merge(&h2->smtphunt, &h1->smtphunt, force);
1220 list_merge(&h2->domainlist, &h1->domainlist, force);
1221 list_merge(&h2->antispam, &h1->antispam, force);
1223 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
1224 FLAG_MERGE(server.via);
1225 FLAG_MERGE(server.protocol);
1226 FLAG_MERGE(server.service);
1227 FLAG_MERGE(server.interval);
1228 FLAG_MERGE(server.authenticate);
1229 FLAG_MERGE(server.timeout);
1230 FLAG_MERGE(server.envelope);
1231 FLAG_MERGE(server.envskip);
1232 FLAG_MERGE(server.qvirtual);
1233 FLAG_MERGE(server.skip);
1234 FLAG_MERGE(server.dns);
1235 FLAG_MERGE(server.checkalias);
1236 FLAG_MERGE(server.principal);
1239 FLAG_MERGE(server.interface);
1240 FLAG_MERGE(server.interface_pair);
1241 FLAG_MERGE(server.monitor);
1244 FLAG_MERGE(server.plugin);
1245 FLAG_MERGE(server.plugout);
1246 FLAG_MERGE(server.tracepolls);
1247 FLAG_MERGE(server.badheader);
1248 FLAG_MERGE(server.retrieveerror);
1250 FLAG_MERGE(wildcard);
1251 FLAG_MERGE(remotename);
1252 FLAG_MERGE(password);
1255 FLAG_MERGE(listener);
1256 FLAG_MERGE(smtpaddress);
1257 FLAG_MERGE(smtpname);
1258 FLAG_MERGE(preconnect);
1259 FLAG_MERGE(postconnect);
1263 FLAG_MERGE(limitflush);
1264 FLAG_MERGE(fetchall);
1265 FLAG_MERGE(rewrite);
1266 FLAG_MERGE(forcecr);
1267 FLAG_MERGE(stripcr);
1268 FLAG_MERGE(pass8bits);
1269 FLAG_MERGE(dropstatus);
1270 FLAG_MERGE(dropdelivered);
1271 FLAG_MERGE(mimedecode);
1274 FLAG_MERGE(warnings);
1275 FLAG_MERGE(fetchlimit);
1276 FLAG_MERGE(fetchsizelimit);
1277 FLAG_MERGE(fastuidl);
1278 FLAG_MERGE(batchlimit);
1280 FLAG_MERGE(use_ssl);
1282 FLAG_MERGE(sslcert);
1283 FLAG_MERGE(sslproto);
1284 FLAG_MERGE(sslcertck);
1285 FLAG_MERGE(sslcertfile);
1286 FLAG_MERGE(sslcertpath);
1287 FLAG_MERGE(sslcommonname);
1288 FLAG_MERGE(sslfingerprint);
1290 FLAG_MERGE(expunge);
1292 FLAG_MERGE(properties);
1296 /** Load configuration files.
1297 * \return - true if no servers found on the command line
1298 * - false if servers found on the command line */
1299 static int load_params(int argc, char **argv, int optind)
1301 int implicitmode, st;
1303 struct query def_opts, *ctl;
1307 run.bouncemail = TRUE;
1308 run.softbounce = TRUE; /* treat permanent errors as temporary */
1309 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1311 memset(&def_opts, '\0', sizeof(struct query));
1312 def_opts.smtp_socket = -1;
1313 def_opts.smtpaddress = (char *)0;
1314 def_opts.smtpname = (char *)0;
1315 def_opts.server.protocol = P_AUTO;
1316 def_opts.server.timeout = CLIENT_TIMEOUT;
1317 def_opts.server.esmtp_name = user;
1318 def_opts.server.badheader = BHREJECT;
1319 def_opts.warnings = WARNING_INTERVAL;
1320 def_opts.remotename = user;
1321 def_opts.listener = SMTP_MODE;
1322 def_opts.fetchsizelimit = 100;
1323 def_opts.fastuidl = 4;
1325 /* get the location of rcfile */
1327 p = strrchr (rcfile, '/');
1328 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1329 *p = 0; /* replace '/' by '0' */
1330 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1331 *p = '/'; /* restore '/' */
1332 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1333 strcpy (rcfiledir, "/");
1336 /* note the parse time, so we can pick up on modifications */
1337 if (strcmp(rcfile, "-") == 0)
1338 parsetime = time(NULL);
1340 if (stat(rcfile, &rcstat) != -1)
1341 parsetime = rcstat.st_mtime;
1342 else if (errno != ENOENT)
1343 report(stderr, GT_("couldn't time-check the run-control file\n"));
1346 /* this builds the host list */
1347 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1349 * FIXME: someday, send notification mail here if backgrounded.
1350 * Right now, that can happen if the user changes the rcfile
1351 * while the fetchmail is running in background. Do similarly
1352 * for the other exit() calls in this function.
1356 if ((implicitmode = (optind >= argc)))
1359 for (ctl = querylist; ctl; ctl = ctl->next) {
1360 ctl->active = !ctl->server.skip;
1362 if (ctl->pwmd_file) {
1364 * Cannot get an element path without a service.
1366 if (ctl->server.protocol <= 1) {
1367 report(stderr, GT_("fetchmail: %s configuration invalid, pwmd_file requires a protocol specification\n"),
1368 ctl->server.pollname);
1373 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1376 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol,
1380 time(&rcstat.st_mtime);
1385 for (ctl = querylist; ctl; ctl = ctl->next)
1386 ctl->active = !ctl->server.skip;
1390 for (; optind < argc; optind++)
1392 flag predeclared = FALSE;
1395 * If hostname corresponds to a host known from the rc file,
1396 * simply declare it active. Otherwise synthesize a host
1397 * record from command line and defaults
1399 for (ctl = querylist; ctl; ctl = ctl->next)
1400 if (!strcmp(ctl->server.pollname, argv[optind])
1401 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1403 /* Is this correct? */
1404 if (predeclared && outlevel >= O_VERBOSE)
1405 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1410 if (ctl->pwmd_file) {
1412 * Cannot get an element path without a service.
1414 if (ctl->server.protocol <= 1) {
1415 report(stderr, GT_("%s configuration invalid, pwmd_file requires a protocol specification\n"),
1416 ctl->server.pollname);
1420 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1421 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1424 if (get_pwmd_details(ctl->server.pollname,
1425 ctl->server.protocol, ctl))
1434 * Allocate and link record without copying in
1435 * command-line args; we'll do that with the optmerge
1438 ctl = hostalloc((struct query *)NULL);
1441 if (cmd_opts.pwmd_file) {
1443 * Cannot get an element path without a service.
1445 if (cmd_opts.server.protocol == 0 || cmd_opts.server.protocol == 1) {
1446 report(stderr, GT_("Option --pwmd-file needs a service (-p) parameter.\n"));
1450 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1451 if (do_pwmd_connect(cmd_opts.pwmd_socket, cmd_opts.pwmd_file))
1454 if (get_pwmd_details(argv[optind], cmd_opts.server.protocol,
1460 ctl->server.pollname = xstrdup(argv[optind]);
1463 ctl->server.pollname = xstrdup(argv[optind]);
1466 ctl->server.lead_server = (struct hostdata *)NULL;
1471 * If there's a defaults record, merge it and lose it.
1472 * FIXME: we don't currently free all entries that might be in struct query.
1474 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1478 for (ctl = querylist->next; ctl; ctl = ctl->next)
1479 optmerge(ctl, querylist, FALSE);
1481 querylist = querylist->next;
1482 free(tmpq->server.pollname);
1486 /* don't allow a defaults record after the first */
1487 for (ctl = querylist; ctl; ctl = ctl->next) {
1488 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1489 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1494 /* use localhost if we never fetch the FQDN of this host */
1495 fetchmailhost = "localhost";
1497 /* here's where we override globals */
1498 if (cmd_run.logfile)
1499 run.logfile = cmd_run.logfile;
1501 run.idfile = cmd_run.idfile;
1502 if (cmd_run.pidfile)
1503 run.pidfile = cmd_run.pidfile;
1504 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1505 if (cmd_run.poll_interval >= 0)
1506 run.poll_interval = cmd_run.poll_interval;
1507 if (cmd_run.invisible)
1508 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1509 if (cmd_run.showdots)
1510 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1511 if (cmd_run.use_syslog)
1512 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1513 if (cmd_run.postmaster)
1514 run.postmaster = cmd_run.postmaster;
1515 if (cmd_run.bouncemail)
1516 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1517 if (cmd_run.softbounce)
1518 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1520 /* check and daemon options are not compatible */
1521 if (check_only && run.poll_interval)
1522 run.poll_interval = 0;
1525 * DNS support is required for some protocols. We used to
1526 * do this unconditionally, but it made fetchmail excessively
1527 * vulnerable to misconfigured DNS setups.
1529 * If we're using ETRN or ODMR, the smtp hunt list is the
1530 * list of systems we're polling on behalf of; these have
1531 * to be fully-qualified domain names. The default for
1532 * this list should be the FQDN of localhost.
1534 * If we're using Kerberos for authentication, we need
1535 * the FQDN in order to generate capability keys.
1537 for (ctl = querylist; ctl; ctl = ctl->next)
1539 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1540 || ctl->server.authenticate == A_KERBEROS_V5))
1542 fetchmailhost = host_fqdn(1);
1546 if (!ctl) /* list exhausted */
1547 fetchmailhost = host_fqdn(0);
1549 /* this code enables flags to be turned off */
1550 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1552 else if (flag == FLAG_FALSE)\
1557 /* merge in wired defaults, do sanity checks and prepare internal fields */
1558 for (ctl = querylist; ctl; ctl = ctl->next)
1560 ctl->wedged = FALSE;
1562 /* merge in defaults */
1563 optmerge(ctl, &def_opts, FALSE);
1565 /* force command-line options */
1566 optmerge(ctl, &cmd_opts, TRUE);
1569 * queryname has to be set up for inactive servers too.
1570 * Otherwise the UIDL code core-dumps on startup.
1572 if (ctl->server.via)
1573 ctl->server.queryname = xstrdup(ctl->server.via);
1575 ctl->server.queryname = xstrdup(ctl->server.pollname);
1578 * We no longer do DNS lookups at startup.
1579 * This is a kluge. It enables users to edit their
1580 * configurations when DNS isn't available.
1582 ctl->server.truename = xstrdup(ctl->server.queryname);
1584 if (configdump || ctl->active )
1586 DEFAULT(ctl->keep, FALSE);
1587 DEFAULT(ctl->fetchall, FALSE);
1588 DEFAULT(ctl->flush, FALSE);
1589 DEFAULT(ctl->limitflush, FALSE);
1590 DEFAULT(ctl->rewrite, TRUE);
1591 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1592 DEFAULT(ctl->forcecr, FALSE);
1593 DEFAULT(ctl->pass8bits, FALSE);
1594 DEFAULT(ctl->dropstatus, FALSE);
1595 DEFAULT(ctl->dropdelivered, FALSE);
1596 DEFAULT(ctl->mimedecode, FALSE);
1597 DEFAULT(ctl->idle, FALSE);
1598 DEFAULT(ctl->server.dns, TRUE);
1599 DEFAULT(ctl->use_ssl, FALSE);
1600 DEFAULT(ctl->sslcertck, FALSE);
1601 DEFAULT(ctl->server.checkalias, FALSE);
1604 * XXX FIXME: do we need this check or can we rely on the .y
1605 * parser handling this?
1609 report(stderr, GT_("SSL support is not compiled in.\n"));
1612 #endif /* SSL_ENABLE */
1615 if (ctl->server.authenticate == A_KERBEROS_V5) {
1616 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1621 if (ctl->server.authenticate == A_GSSAPI) {
1622 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1628 * Make sure we have a nonempty host list to forward to.
1631 save_str(&ctl->smtphunt, "localhost", FALSE);
1634 * Make sure we have a nonempty list of domains to fetch from.
1636 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1637 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1639 /* if `user' doesn't name a real local user, try to run as root */
1640 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1643 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1644 if (!ctl->localnames) /* for local delivery via SMTP */
1645 save_str_pair(&ctl->localnames, user, NULL);
1648 * can't handle multidrop mailboxes without "envelope"
1649 * option, this causes truckloads full of support complaints
1650 * "all mail forwarded to postmaster"
1652 if (MULTIDROP(ctl) && !ctl->server.envelope)
1654 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1655 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1658 /* if no folders were specified, set up the null one as default */
1659 if (!ctl->mailboxes)
1660 save_str(&ctl->mailboxes, (char *)NULL, 0);
1662 /* maybe user overrode timeout on command line? */
1663 if (ctl->server.timeout == -1)
1664 ctl->server.timeout = CLIENT_TIMEOUT;
1667 if (ctl->server.service) {
1668 int port = servport(ctl->server.service);
1671 (void) fprintf(stderr,
1672 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1673 ctl->server.pollname);
1677 if (ctl->listener == LMTP_MODE)
1681 for (idp = ctl->smtphunt; idp; idp = idp->next)
1685 if (!(cp = strrchr(idp->id, '/'))
1686 || (0 == strcmp(cp + 1, SMTP_PORT))
1687 || servport(cp + 1) == SMTP_PORT_NUM)
1689 (void) fprintf(stderr,
1690 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1691 ctl->server.pollname);
1698 * "I beg to you, have mercy on the we[a]k minds like myself."
1699 * wrote Pehr Anderson. Your petition is granted.
1701 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1703 (void) fprintf(stderr,
1704 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1710 * If the user didn't set a last-resort user to get misaddressed
1711 * multidrop mail, set an appropriate default here.
1713 if (!run.postmaster)
1715 if (getuid() != ROOT_UID) /* ordinary user */
1716 run.postmaster = user;
1718 run.postmaster = "postmaster";
1721 return(implicitmode);
1724 static void terminate_poll(int sig)
1725 /* to be executed at the end of a poll cycle */
1729 report(stdout, GT_("terminated with signal %d\n"), sig);
1733 * Update UID information at end of each poll, rather than at end
1734 * of run, because that way we don't lose all UIDL information since
1735 * the beginning of time if fetchmail crashes.
1738 write_saved_lists(querylist, run.idfile);
1739 #endif /* POP3_ENABLE */
1742 static void terminate_run(int sig)
1743 /* to be executed on normal or signal-induced termination */
1747 terminate_poll(sig);
1750 * Craig Metz, the RFC1938 one-time-password guy, points out:
1751 * "Remember that most kernels don't zero pages before handing them to the
1752 * next process and many kernels share pages between user and kernel space.
1753 * You'd be very surprised what you can find from a short program to do a
1754 * malloc() and then dump the contents of the pages you got. By zeroing
1755 * the secrets at end of run (earlier if you can), you make sure the next
1756 * guy can't get the password/pass phrase."
1758 * Right you are, Craig!
1760 for (ctl = querylist; ctl; ctl = ctl->next)
1762 memset(ctl->password, '\0', strlen(ctl->password));
1764 if (activecount == 0)
1767 exit(successes ? PS_SUCCESS : querystatus);
1771 * Sequence of protocols to try when autoprobing, most capable to least.
1773 static const int autoprobe[] =
1777 #endif /* IMAP_ENABLE */
1780 #endif /* POP3_ENABLE */
1783 static int query_host(struct query *ctl)
1784 /* perform fetch transaction with single host */
1790 * If we're syslogging the progress messages are automatically timestamped.
1791 * Force timestamping if we're going to a logfile.
1793 if (outlevel >= O_VERBOSE)
1795 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1797 ctl->server.pollname,
1798 showproto(ctl->server.protocol),
1802 switch (ctl->server.protocol) {
1804 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1806 ctl->server.protocol = autoprobe[i];
1808 st = query_host(ctl);
1811 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1814 ctl->server.protocol = P_AUTO;
1820 } while (st == PS_REPOLL);
1822 report(stderr, GT_("POP3 support is not configured.\n"));
1824 #endif /* POP3_ENABLE */
1830 } while (st == PS_REPOLL);
1832 report(stderr, GT_("IMAP support is not configured.\n"));
1834 #endif /* IMAP_ENABLE */
1838 report(stderr, GT_("ETRN support is not configured.\n"));
1843 #endif /* ETRN_ENABLE */
1846 report(stderr, GT_("ODMR support is not configured.\n"));
1850 #endif /* ODMR_ENABLE */
1853 report(stderr, GT_("unsupported protocol selected.\n"));
1858 * If we're syslogging the progress messages are automatically timestamped.
1859 * Force timestamping if we're going to a logfile.
1861 if (outlevel >= O_VERBOSE)
1863 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1865 ctl->server.pollname,
1866 showproto(ctl->server.protocol),
1873 static int print_id_of(struct uid_db_record *rec, void *unused)
1877 printf("\t%s\n", rec->id);
1881 static void dump_params (struct runctl *runp,
1882 struct query *querylist, flag implicit)
1883 /* display query parameters in English */
1887 if (runp->poll_interval)
1888 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1890 printf(GT_("Logfile is %s\n"), runp->logfile);
1891 if (strcmp(runp->idfile, IDFILE_NAME))
1892 printf(GT_("Idfile is %s\n"), runp->idfile);
1893 if (runp->use_syslog)
1894 printf(GT_("Progress messages will be logged via syslog\n"));
1895 if (runp->invisible)
1896 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1898 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1899 if (runp->postmaster)
1900 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1903 if (!runp->bouncemail)
1904 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1905 else if (outlevel >= O_VERBOSE)
1906 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1908 if (!runp->softbounce)
1909 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1910 else if (outlevel >= O_VERBOSE)
1911 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1913 for (ctl = querylist; ctl; ctl = ctl->next)
1915 if (!ctl->active || (implicit && ctl->server.skip))
1918 printf(GT_("Options for retrieving from %s@%s:\n"),
1919 ctl->remotename, visbuf(ctl->server.pollname));
1921 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1922 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1924 if (ctl->server.interval)
1925 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1926 " Poll of this server will occur every %d intervals.\n",
1927 ctl->server.interval), ctl->server.interval);
1928 if (ctl->server.truename)
1929 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1930 if (ctl->server.skip || outlevel >= O_VERBOSE)
1931 printf(ctl->server.skip
1932 ? GT_(" This host will not be queried when no host is specified.\n")
1933 : GT_(" This host will be queried when no host is specified.\n"));
1934 if (!NO_PASSWORD(ctl))
1937 printf(GT_(" Password will be prompted for.\n"));
1938 else if (outlevel >= O_VERBOSE)
1940 printf(GT_(" Password = \"%s\".\n"),
1941 visbuf(ctl->password));
1945 if (ctl->server.protocol == P_POP3
1946 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1947 && (ctl->server.authenticate == A_KERBEROS_V5))
1948 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1949 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1951 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1952 if (ctl->server.service)
1953 printf(GT_(" (using service %s)"), ctl->server.service);
1954 else if (outlevel >= O_VERBOSE)
1955 printf(GT_(" (using default port)"));
1958 switch (ctl->server.authenticate)
1961 printf(GT_(" All available authentication methods will be tried.\n"));
1964 printf(GT_(" Password authentication will be forced.\n"));
1967 printf(GT_(" MSN authentication will be forced.\n"));
1970 printf(GT_(" NTLM authentication will be forced.\n"));
1973 printf(GT_(" OTP authentication will be forced.\n"));
1976 printf(GT_(" CRAM-MD5 authentication will be forced.\n"));
1979 printf(GT_(" GSSAPI authentication will be forced.\n"));
1982 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1985 printf(GT_(" End-to-end encryption assumed.\n"));
1988 printf(GT_(" APOP authentication will be forced.\n"));
1993 if (ctl->server.principal != (char *) NULL)
1994 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1997 printf(GT_(" SSL encrypted sessions enabled.\n"));
1999 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
2000 if (ctl->sslcertck) {
2001 printf(GT_(" SSL server certificate checking enabled.\n"));
2003 if (ctl->sslcertfile != NULL)
2004 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
2005 if (ctl->sslcertpath != NULL)
2006 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
2007 if (ctl->sslcommonname != NULL)
2008 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
2009 if (ctl->sslfingerprint != NULL)
2010 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
2012 if (ctl->server.timeout > 0)
2013 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
2014 if (ctl->server.timeout == CLIENT_TIMEOUT)
2015 printf(GT_(" (default).\n"));
2019 if (MAILBOX_PROTOCOL(ctl))
2021 if (!ctl->mailboxes->id)
2022 printf(GT_(" Default mailbox selected.\n"));
2027 printf(GT_(" Selected mailboxes are:"));
2028 for (idp = ctl->mailboxes; idp; idp = idp->next)
2029 printf(" %s", idp->id);
2032 printf(ctl->fetchall
2033 ? GT_(" All messages will be retrieved (--all on).\n")
2034 : GT_(" Only new messages will be retrieved (--all off).\n"));
2036 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
2037 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
2039 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
2040 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
2041 printf(ctl->limitflush
2042 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
2043 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
2045 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
2046 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
2048 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
2049 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
2051 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
2052 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
2053 printf(ctl->pass8bits
2054 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
2055 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
2056 printf(ctl->mimedecode
2057 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
2058 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
2060 ? GT_(" Idle after poll is enabled (idle on).\n")
2061 : GT_(" Idle after poll is disabled (idle off).\n"));
2062 printf(ctl->dropstatus
2063 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
2064 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
2065 printf(ctl->dropdelivered
2066 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
2067 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
2068 if (NUM_NONZERO(ctl->limit))
2070 if (NUM_NONZERO(ctl->limit))
2071 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
2072 ctl->limit, ctl->limit);
2073 else if (outlevel >= O_VERBOSE)
2074 printf(GT_(" No message size limit (--limit 0).\n"));
2075 if (run.poll_interval > 0)
2076 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
2077 ctl->warnings, ctl->warnings);
2078 else if (outlevel >= O_VERBOSE)
2079 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
2081 if (NUM_NONZERO(ctl->fetchlimit))
2082 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
2083 ctl->fetchlimit, ctl->fetchlimit);
2084 else if (outlevel >= O_VERBOSE)
2085 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
2086 if (NUM_NONZERO(ctl->fetchsizelimit))
2087 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
2088 ctl->fetchsizelimit, ctl->fetchsizelimit);
2089 else if (outlevel >= O_VERBOSE)
2090 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
2091 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
2093 if (ctl->fastuidl == 1)
2094 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
2096 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
2098 else if (outlevel >= O_VERBOSE)
2099 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
2100 if (NUM_NONZERO(ctl->batchlimit))
2101 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
2102 else if (outlevel >= O_VERBOSE)
2103 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
2104 if (MAILBOX_PROTOCOL(ctl))
2106 if (NUM_NONZERO(ctl->expunge))
2107 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
2108 else if (outlevel >= O_VERBOSE)
2109 printf(GT_(" No forced expunges (--expunge 0).\n"));
2112 else /* ODMR or ETRN */
2116 printf(GT_(" Domains for which mail will be fetched are:"));
2117 for (idp = ctl->domainlist; idp; idp = idp->next)
2119 printf(" %s", idp->id);
2120 if (!idp->val.status.mark)
2121 printf(GT_(" (default)"));
2126 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
2127 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
2128 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
2135 printf(GT_(" Messages will be %cMTP-forwarded to:"),
2137 for (idp = ctl->smtphunt; idp; idp = idp->next)
2139 printf(" %s", idp->id);
2140 if (!idp->val.status.mark)
2141 printf(GT_(" (default)"));
2145 if (ctl->smtpaddress)
2146 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
2149 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
2152 if (MAILBOX_PROTOCOL(ctl))
2154 if (ctl->antispam != (struct idlist *)NULL)
2158 printf(GT_(" Recognized listener spam block responses are:"));
2159 for (idp = ctl->antispam; idp; idp = idp->next)
2160 printf(" %d", idp->val.status.num);
2163 else if (outlevel >= O_VERBOSE)
2164 printf(GT_(" Spam-blocking disabled\n"));
2166 if (ctl->preconnect)
2167 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
2168 visbuf(ctl->preconnect));
2169 else if (outlevel >= O_VERBOSE)
2170 printf(GT_(" No pre-connection command.\n"));
2171 if (ctl->postconnect)
2172 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
2173 visbuf(ctl->postconnect));
2174 else if (outlevel >= O_VERBOSE)
2175 printf(GT_(" No post-connection command.\n"));
2176 if (MAILBOX_PROTOCOL(ctl)) {
2177 if (!ctl->localnames)
2178 printf(GT_(" No localnames declared for this host.\n"));
2184 for (idp = ctl->localnames; idp; idp = idp->next)
2187 if (count > 1 || ctl->wildcard)
2188 printf(GT_(" Multi-drop mode: "));
2190 printf(GT_(" Single-drop mode: "));
2192 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
2193 if (outlevel >= O_VERBOSE)
2195 for (idp = ctl->localnames; idp; idp = idp->next)
2197 printf("\t%s -> %s\n", idp->id, idp->val.id2);
2199 printf("\t%s\n", idp->id);
2201 fputs("\t*\n", stdout);
2204 if (count > 1 || ctl->wildcard)
2206 printf(ctl->server.dns
2207 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
2208 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
2209 if (ctl->server.dns)
2211 if (ctl->server.checkalias)
2212 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
2214 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
2216 if (ctl->server.envelope == STRING_DISABLED)
2217 printf(GT_(" Envelope-address routing is disabled\n"));
2220 printf(GT_(" Envelope header is assumed to be: %s\n"),
2221 ctl->server.envelope ? ctl->server.envelope : "Received");
2222 if (ctl->server.envskip || outlevel >= O_VERBOSE)
2223 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
2224 ctl->server.envskip);
2225 if (ctl->server.qvirtual)
2226 printf(GT_(" Prefix %s will be removed from user id\n"),
2227 ctl->server.qvirtual);
2228 else if (outlevel >= O_VERBOSE)
2229 printf(GT_(" No prefix stripping\n"));
2232 if (ctl->server.akalist)
2234 printf(GT_(" Predeclared mailserver aliases:"));
2235 for (idp = ctl->server.akalist; idp; idp = idp->next)
2236 printf(" %s", idp->id);
2240 if (ctl->server.localdomains)
2242 printf(GT_(" Local domains:"));
2243 for (idp = ctl->server.localdomains; idp; idp = idp->next)
2244 printf(" %s", idp->id);
2251 if (ctl->server.interface)
2252 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
2253 else if (outlevel >= O_VERBOSE)
2254 printf(GT_(" No interface requirement specified.\n"));
2255 if (ctl->server.monitor)
2256 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
2257 else if (outlevel >= O_VERBOSE)
2258 printf(GT_(" No monitor interface specified.\n"));
2261 if (ctl->server.plugin)
2262 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
2263 else if (outlevel >= O_VERBOSE)
2264 printf(GT_(" No plugin command specified.\n"));
2265 if (ctl->server.plugout)
2266 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
2267 else if (outlevel >= O_VERBOSE)
2268 printf(GT_(" No plugout command specified.\n"));
2270 if (MAILBOX_PROTOCOL(ctl))
2274 if (!(count = uid_db_n_records(&ctl->oldsaved)))
2275 printf(GT_(" No UIDs saved from this host.\n"));
2278 printf(GT_(" %d UIDs saved.\n"), count);
2279 traverse_uid_db(&ctl->oldsaved, print_id_of, NULL);
2283 if (ctl->server.tracepolls)
2284 printf(GT_(" Poll trace information will be added to the Received header.\n"));
2285 else if (outlevel >= O_VERBOSE)
2286 printf(GT_(" No poll trace information will be added to the Received header.\n"));
2288 switch (ctl->server.badheader) {
2290 if (outlevel >= O_VERBOSE)
2291 printf(GT_(" Messages with bad headers will be rejected.\n"));
2294 printf(GT_(" Messages with bad headers will be passed on.\n"));
2298 switch (ctl->server.retrieveerror) {
2300 if (outlevel >= O_VERBOSE)
2301 printf(GT_(" Messages with fetch body errors will cause the session to abort.\n"));
2304 printf(GT_(" Messages with fetch body errors will be skipped, the session will continue.\n"));
2307 printf(GT_(" Messages with fetch body errors will be marked seen, the session will continue.\n"));
2311 if (ctl->properties)
2312 printf(GT_(" Pass-through properties \"%s\".\n"),
2313 visbuf(ctl->properties));
2317 /* fetchmail.c ends here */