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 - 2006, 2010 - 2011 Sunil Shetye\n"
137 "Copyright (C) 2005 - 2011 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);
426 int main(int argc, char **argv)
429 int implicitmode = FALSE;
430 flag safewithbg = FALSE; /** if parsed options are compatible with a
431 fetchmail copy running in the background */
433 netrc_entry *netrc_list;
434 char *netrc_file, *tmpbuf;
438 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
442 envquery(argc, argv);
444 setlocale (LC_ALL, "");
445 bindtextdomain(PACKAGE, LOCALEDIR);
447 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
451 iana_charset = "US-ASCII";
455 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
459 * Note: because we can't initialize reporting before we know whether
460 * syslog is supposed to be on, this message will go to stdout and
461 * be lost when running in background.
463 if (outlevel >= O_VERBOSE)
467 report(stdout, GT_("fetchmail: invoked with"));
468 for (i = 0; i < argc; i++)
469 report(stdout, " %s", argv[i]);
470 report(stdout, "\n");
473 #define IDFILE_NAME ".fetchids"
474 run.idfile = prependdir (IDFILE_NAME, fmhome);
479 * We used to arrange for the lock to be removed on exit close
480 * to where the lock was asserted. Now we need to do it here, because
481 * we might have re-executed in background with an existing lock
482 * as the result of a changed rcfile (see the code near the execvp(3)
483 * call near the beginning of the polling loop for details). We want
484 * to be sure the lock gets nuked on any error exit, basically.
489 /* save the current directory */
490 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
491 report(stderr, GT_("could not get current working directory\n"));
499 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts, &safewithbg);
503 if (quitmode && quitind == argc)
509 const char *features =
512 #endif /* POP3_ENABLE */
515 #endif /* IMAP_ENABLE */
521 #endif /* RPA_ENABLE */
524 #endif /* NTLM_ENABLE */
527 #endif /* SDPS_ENABLE */
530 #endif /* ETRN_ENABLE */
533 #endif /* ODMR_ENABLE */
539 #endif /* OPIE_ENABLE */
540 #ifdef HAVE_PKG_hesiod
545 #endif /* HAVE_SOCKS */
548 #endif /* ENABLE_NLS */
551 #endif /* KERBEROS_V5 */
554 #endif /* HAVE_LIBPWMD */
556 printf(GT_("This is fetchmail release %s"), VERSION);
557 fputs(features, stdout);
559 printcopyright(stdout);
561 fputs("Fallback MDA: ", stdout);
563 fputs(FALLBACK_MDA, stdout);
565 fputs("(none)", stdout);
570 /* this is an attempt to help remote debugging */
571 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
574 /* avoid parsing the config file if all we're doing is killing a daemon */
576 implicitmode = load_params(argc, argv, optind);
578 /* precedence: logfile (if effective) overrides syslog. */
579 if (run.logfile && run.poll_interval && !nodetach) {
583 /* logging should be set up early in case we were restarted from exec */
586 openlog(program_name, LOG_PID, LOG_MAIL);
590 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
593 /* initialize UID handling */
597 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
600 initialize_saved_lists(querylist, run.idfile);
602 #endif /* POP3_ENABLE */
604 /* construct the lockfile */
608 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
609 * Core dumps could otherwise contain passwords to be scavenged by a
612 if (outlevel < O_VERBOSE || run.poll_interval > 0)
614 struct rlimit corelimit;
615 corelimit.rlim_cur = 0;
616 corelimit.rlim_max = 0;
617 setrlimit(RLIMIT_CORE, &corelimit);
620 #define NETRC_FILE ".netrc"
621 /* parse the ~/.netrc file (if present) for future password lookups. */
622 netrc_file = prependdir (NETRC_FILE, home);
623 netrc_list = parse_netrc(netrc_file);
627 /* pick up passwords where we can */
628 for (ctl = querylist; ctl; ctl = ctl->next)
630 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
632 if (NO_PASSWORD(ctl))
633 /* Server won't care what the password is, but there
634 must be some non-null string here. */
635 ctl->password = ctl->remotename;
640 /* look up the pollname and account in the .netrc file. */
641 p = search_netrc(netrc_list,
642 ctl->server.pollname, ctl->remotename);
643 /* if we find a matching entry with a password, use it */
644 if (p && p->password)
645 ctl->password = xstrdup(p->password);
647 /* otherwise try with "via" name if there is one */
648 else if (ctl->server.via)
650 p = search_netrc(netrc_list,
651 ctl->server.via, ctl->remotename);
652 if (p && p->password)
653 ctl->password = xstrdup(p->password);
659 free_netrc(netrc_list);
662 /* perhaps we just want to check options? */
665 int havercfile = access(rcfile, 0);
667 printf(GT_("Taking options from command line%s%s\n"),
668 havercfile ? "" : GT_(" and "),
669 havercfile ? "" : rcfile);
671 if (querylist == NULL)
673 GT_("No mailservers set up -- perhaps %s is missing?\n"),
676 dump_params(&run, querylist, implicitmode);
680 /* dump options as a Python dictionary, for configurator use */
683 dump_config(&run, querylist);
687 /* check for another fetchmail running concurrently */
688 pid = fm_lock_state();
690 pid = bkgd ? -pid : pid;
692 /* if no mail servers listed and nothing in background, we're done */
693 if (!quitonly && pid == 0 && querylist == NULL) {
694 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
698 /* perhaps user asked us to kill the other fetchmail */
701 if (pid == 0 || pid == getpid())
702 /* this test enables re-execing on a changed rcfile
703 * for pid == getpid() */
706 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
710 else if (kill(pid, SIGTERM) < 0)
712 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
713 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
720 if (outlevel > O_SILENT)
721 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
722 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
723 /* We used to nuke the other process's lock here, with
724 * fm_lock_release(), which is broken. The other process
725 * needs to clear its lock by itself. */
729 /* wait for other process to exit */
730 maxwait = 10; /* seconds */
731 while (kill(pid, 0) == 0 && --maxwait >= 0) {
738 /* another fetchmail is running -- wake it up or die */
744 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
747 else if (!implicitmode)
750 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
757 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
761 else if (getpid() == pid)
762 /* this test enables re-execing on a changed rcfile */
764 else if (argc > 1 && !safewithbg)
767 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
770 fprintf(stderr, "argc = %d, arg list:\n", argc);
771 for (i = 1; i < argc; i++) fprintf(stderr, "arg %d = \"%s\"\n", i, argv[i]);
775 else if (kill(pid, SIGUSR1) == 0)
777 if (outlevel > O_SILENT)
779 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
786 * Should never happen -- possible only if a background fetchmail
787 * croaks after the first kill probe above but before the
788 * SIGUSR1/SIGHUP transmission.
791 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
793 return(PS_UNDEFINED);
797 /* pick up interactively any passwords we need but don't have */
798 for (ctl = querylist; ctl; ctl = ctl->next)
800 if (ctl->active && !(implicitmode && ctl->server.skip)
801 && !NO_PASSWORD(ctl) && !ctl->password)
806 GT_("fetchmail: can't find a password for %s@%s.\n"),
807 ctl->remotename, ctl->server.pollname);
810 const char* password_prompt = GT_("Enter password for %s@%s: ");
811 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
813 tmpbuf = (char *)xmalloc(pplen);
814 snprintf(tmpbuf, pplen, password_prompt,
815 ctl->remotename, ctl->server.pollname);
816 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
823 * Time to initiate the SOCKS library (this is not mandatory: it just
824 * registers the correct application name for logging purpose. If you
825 * have some problem, comment out these lines).
828 SOCKSinit("fetchmail");
829 #endif /* HAVE_SOCKS */
831 /* avoid zombies from plugins */
834 /* Fix up log destination - if the if() is true, the precedence rule
835 * above hasn't killed off the syslog option, because the logfile
836 * option is ineffective (because we're not detached or not in
837 * deamon mode), so kill it for the benefit of other parts of the
839 if (run.logfile && run.use_syslog)
843 * Maybe time to go to demon mode...
845 if (run.poll_interval)
850 rc = daemonize(run.logfile);
852 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
856 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
859 * We'll set up a handler for these when we're sleeping,
860 * but ignore them otherwise so as not to interrupt a poll.
862 set_signal_handler(SIGUSR1, SIG_IGN);
863 if (run.poll_interval && getuid() == ROOT_UID)
864 set_signal_handler(SIGHUP, SIG_IGN);
868 /* not in daemon mode */
869 if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
871 if (!freopen(run.logfile, "a", stdout))
872 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
873 if (!freopen(run.logfile, "a", stderr))
874 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
876 report(stdout, GT_("fetchmail: Warning: syslog and logfile are set. Check both for logs!\n"));
882 /* beyond here we don't want more than one fetchmail running per user */
884 set_signal_handler(SIGABRT, terminate_run);
885 set_signal_handler(SIGINT, terminate_run);
886 set_signal_handler(SIGTERM, terminate_run);
887 set_signal_handler(SIGALRM, terminate_run);
888 set_signal_handler(SIGPIPE, SIG_IGN);
889 set_signal_handler(SIGQUIT, terminate_run);
891 /* here's the exclusion lock */
894 if (check_only && outlevel >= O_VERBOSE) {
895 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
899 * Query all hosts. If there's only one, the error return will
900 * reflect the status of that transaction.
904 * Check to see if the rcfile has been touched. If so,
905 * re-exec so the file will be reread. Doing it this way
906 * avoids all the complications of trying to deallocate the
907 * in-core control structures -- and the potential memory
917 if (strcmp(rcfile, "-") == 0) {
919 } else if (stat(rcfile, &rcstat) == -1) {
922 GT_("couldn't time-check %s (error %d)\n"),
927 * isatty() to make sure this is a background process since the
928 * lockfile is removed after each invokation.
930 else if (!isatty(1) && rcstat.st_mtime > parsetime)
932 else if (rcstat.st_mtime > parsetime)
935 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
938 /* restore the startup directory */
939 if (!currentwd[0] || chdir (currentwd) == -1)
940 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
944 * Matthias Andree: Isn't this prone to introduction of
945 * "false" programs by interfering with PATH? Those
946 * path-searching execs might not be the best ideas for
949 * Rob Funk: But is there any way for someone to modify
950 * the PATH variable of a running fetchmail? I don't know
953 * Dave's change makes fetchmail restart itself in exactly
954 * the way it was started from the shell (or shell script)
955 * in the first place. If you're concerned about PATH
956 * contamination, call fetchmail initially with a full
957 * path, and use Dave's patch.
959 * Not using a -p variant of exec means that the restart
960 * will break if both (a) the user depended on PATH to
961 * call fetchmail in the first place, and (b) the system
962 * doesn't save the whole path in argv[0] if the whole
963 * path wasn't used in the initial call. (If I recall
964 * correctly, Linux saves it but many other Unices don't.)
966 execvp(argv[0], argv);
967 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
970 #ifdef HAVE_RES_SEARCH
971 /* Boldly assume that we also have res_init() if we have
972 * res_search(), and call res_init() to re-read the resolv.conf
973 * file, so that we can pick up changes to that file that are
974 * written by dhpccd, dhclient, pppd, openvpn and similar. */
976 /* NOTE: This assumes that /etc/resolv.conf is written
977 * atomically (i. e. a temporary file is written, flushed and
978 * then renamed into place). To fix Debian Bug#389270. */
980 /* NOTE: If this leaks memory or doesn't re-read
981 * /etc/resolv.conf, we're in trouble. The res_init() interface
982 * is only lightly documented :-( */
988 for (ctl = querylist; ctl; ctl = ctl->next)
992 if (!(implicitmode && ctl->server.skip))
997 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
998 ctl->server.pollname);
1002 /* check skip interval first so that it counts all polls */
1003 if (run.poll_interval && ctl->server.interval)
1005 if (ctl->server.poll_count++ % ctl->server.interval)
1007 if (outlevel >= O_VERBOSE)
1009 GT_("interval not reached, not querying %s\n"),
1010 ctl->server.pollname);
1017 * Don't do monitoring if we were woken by a signal.
1018 * Note that interface_approve() does its own error logging.
1020 if (!interface_approve(&ctl->server, !lastsig))
1022 #endif /* CAN_MONITOR */
1024 dofastuidl = 0; /* this is reset in the driver if required */
1028 * At each poll interval, check the pwmd server for
1029 * changes in host and auth settings.
1031 if (ctl->pwmd_file) {
1032 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1035 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol, ctl))
1039 querystatus = query_host(ctl);
1041 if (NUM_NONZERO(ctl->fastuidl))
1042 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
1044 /* leave the UIDL state alone if there have been any errors */
1046 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
1047 uid_swap_lists(ctl);
1049 uid_discard_new_list(ctl);
1051 #endif /* POP3_ENABLE */
1053 if (querystatus == PS_SUCCESS)
1055 else if (!check_only &&
1056 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
1060 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
1062 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
1064 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
1066 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
1068 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
1070 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
1072 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
1074 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
1076 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
1078 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
1080 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
1082 report(stdout,GT_("Query status=11 (DNS)\n")); break;
1084 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
1086 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
1088 report(stdout,GT_("Query status=%d\n"),querystatus);
1093 if (ctl->server.monitor)
1096 * Allow some time for the link to quiesce. One
1097 * second is usually sufficient, three is safe.
1098 * Note: this delay is important - don't remove!
1101 interface_note_activity(&ctl->server);
1103 #endif /* CAN_MONITOR */
1114 /* close connections cleanly */
1118 * OK, we've polled. Now sleep.
1120 if (run.poll_interval)
1123 * Because passwords can expire, it may happen that *all*
1124 * hosts are now out of the loop due to authfail
1125 * conditions. If this happens daemon-mode fetchmail
1126 * should softly and silently vanish away, rather than
1127 * spinning uselessly.
1131 for (ctl = querylist; ctl; ctl = ctl->next)
1132 if (ctl->active && !(implicitmode && ctl->server.skip))
1137 report(stderr, GT_("All connections are wedged. Exiting.\n"));
1138 /* FIXME: someday, send notification mail */
1142 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1143 || outlevel > O_NORMAL)
1145 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
1148 * With this simple hack, we make it possible for a foreground
1149 * fetchmail to wake up one in daemon mode. What we want is the
1150 * side effect of interrupting any sleep that may be going on,
1151 * forcing fetchmail to re-poll its hosts. The second line is
1152 * for people who think all system daemons wake up on SIGHUP.
1154 set_signal_handler(SIGUSR1, donothing);
1155 if (getuid() == ROOT_UID)
1156 set_signal_handler(SIGHUP, donothing);
1159 * OK, now pause until it's time for the next poll cycle.
1160 * A nonzero return indicates we received a wakeup signal;
1161 * unwedge all servers in case the problem has been
1162 * manually repaired.
1164 if ((lastsig = interruptible_idle(run.poll_interval)))
1166 if (outlevel > O_SILENT)
1167 #ifdef SYS_SIGLIST_DECLARED
1169 GT_("awakened by %s\n"), sys_siglist[lastsig]);
1172 GT_("awakened by signal %d\n"), lastsig);
1174 for (ctl = querylist; ctl; ctl = ctl->next)
1175 ctl->wedged = FALSE;
1178 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
1179 || outlevel > O_NORMAL)
1180 report(stdout, GT_("awakened at %s\n"), timestamp());
1182 } while (run.poll_interval);
1184 if (outlevel >= O_VERBOSE)
1185 report(stdout, GT_("normal termination, status %d\n"),
1186 successes ? PS_SUCCESS : querystatus);
1192 else if (querystatus)
1195 /* in case we interrupted before a successful fetch */
1199 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
1202 * If force is off, modify dstl fields only when they're empty (treat srcl
1203 * as defaults). If force is on, modify each dstl field whenever scrcl
1204 * is nonempty (treat srcl as an override).
1206 if (force ? !!*srcl : !*dstl)
1208 struct idlist *cpl = copy_str_list(*srcl);
1210 append_str_list(dstl, &cpl);
1214 static void optmerge(struct query *h2, struct query *h1, int force)
1215 /* merge two options records */
1217 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
1218 list_merge(&h2->localnames, &h1->localnames, force);
1219 list_merge(&h2->mailboxes, &h1->mailboxes, force);
1220 list_merge(&h2->smtphunt, &h1->smtphunt, force);
1221 list_merge(&h2->domainlist, &h1->domainlist, force);
1222 list_merge(&h2->antispam, &h1->antispam, force);
1224 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
1225 FLAG_MERGE(server.via);
1226 FLAG_MERGE(server.protocol);
1227 FLAG_MERGE(server.service);
1228 FLAG_MERGE(server.interval);
1229 FLAG_MERGE(server.authenticate);
1230 FLAG_MERGE(server.timeout);
1231 FLAG_MERGE(server.envelope);
1232 FLAG_MERGE(server.envskip);
1233 FLAG_MERGE(server.qvirtual);
1234 FLAG_MERGE(server.skip);
1235 FLAG_MERGE(server.dns);
1236 FLAG_MERGE(server.checkalias);
1237 FLAG_MERGE(server.principal);
1240 FLAG_MERGE(server.interface);
1241 FLAG_MERGE(server.interface_pair);
1242 FLAG_MERGE(server.monitor);
1245 FLAG_MERGE(server.plugin);
1246 FLAG_MERGE(server.plugout);
1247 FLAG_MERGE(server.tracepolls);
1248 FLAG_MERGE(server.badheader);
1249 FLAG_MERGE(server.retrieveerror);
1251 FLAG_MERGE(wildcard);
1252 FLAG_MERGE(remotename);
1253 FLAG_MERGE(password);
1256 FLAG_MERGE(listener);
1257 FLAG_MERGE(smtpaddress);
1258 FLAG_MERGE(smtpname);
1259 FLAG_MERGE(preconnect);
1260 FLAG_MERGE(postconnect);
1264 FLAG_MERGE(limitflush);
1265 FLAG_MERGE(fetchall);
1266 FLAG_MERGE(rewrite);
1267 FLAG_MERGE(forcecr);
1268 FLAG_MERGE(stripcr);
1269 FLAG_MERGE(pass8bits);
1270 FLAG_MERGE(dropstatus);
1271 FLAG_MERGE(dropdelivered);
1272 FLAG_MERGE(mimedecode);
1275 FLAG_MERGE(warnings);
1276 FLAG_MERGE(fetchlimit);
1277 FLAG_MERGE(fetchsizelimit);
1278 FLAG_MERGE(fastuidl);
1279 FLAG_MERGE(batchlimit);
1281 FLAG_MERGE(use_ssl);
1283 FLAG_MERGE(sslcert);
1284 FLAG_MERGE(sslproto);
1285 FLAG_MERGE(sslcertck);
1286 FLAG_MERGE(sslcertfile);
1287 FLAG_MERGE(sslcertpath);
1288 FLAG_MERGE(sslcommonname);
1289 FLAG_MERGE(sslfingerprint);
1291 FLAG_MERGE(expunge);
1293 FLAG_MERGE(properties);
1297 /** Load configuration files.
1298 * \return - true if no servers found on the command line
1299 * - false if servers found on the command line */
1300 static int load_params(int argc, char **argv, int optind)
1302 int implicitmode, st;
1304 struct query def_opts, *ctl;
1308 run.bouncemail = TRUE;
1309 run.softbounce = TRUE; /* treat permanent errors as temporary */
1310 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1312 memset(&def_opts, '\0', sizeof(struct query));
1313 def_opts.smtp_socket = -1;
1314 def_opts.smtpaddress = (char *)0;
1315 def_opts.smtpname = (char *)0;
1316 def_opts.server.protocol = P_AUTO;
1317 def_opts.server.timeout = CLIENT_TIMEOUT;
1318 def_opts.server.esmtp_name = user;
1319 def_opts.server.badheader = BHREJECT;
1320 def_opts.warnings = WARNING_INTERVAL;
1321 def_opts.remotename = user;
1322 def_opts.listener = SMTP_MODE;
1323 def_opts.fetchsizelimit = 100;
1324 def_opts.fastuidl = 4;
1326 /* get the location of rcfile */
1328 p = strrchr (rcfile, '/');
1329 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1330 *p = 0; /* replace '/' by '0' */
1331 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1332 *p = '/'; /* restore '/' */
1333 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1334 strcpy (rcfiledir, "/");
1337 /* note the parse time, so we can pick up on modifications */
1338 if (strcmp(rcfile, "-") == 0)
1339 parsetime = time(NULL);
1341 if (stat(rcfile, &rcstat) != -1)
1342 parsetime = rcstat.st_mtime;
1343 else if (errno != ENOENT)
1344 report(stderr, GT_("couldn't time-check the run-control file\n"));
1347 /* this builds the host list */
1348 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1350 * FIXME: someday, send notification mail here if backgrounded.
1351 * Right now, that can happen if the user changes the rcfile
1352 * while the fetchmail is running in background. Do similarly
1353 * for the other exit() calls in this function.
1357 if ((implicitmode = (optind >= argc)))
1360 for (ctl = querylist; ctl; ctl = ctl->next) {
1361 ctl->active = !ctl->server.skip;
1363 if (ctl->pwmd_file) {
1365 * Cannot get an element path without a service.
1367 if (ctl->server.protocol <= 1) {
1368 report(stderr, GT_("fetchmail: %s configuration invalid, pwmd_file requires a protocol specification\n"),
1369 ctl->server.pollname);
1374 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1377 if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol,
1381 time(&rcstat.st_mtime);
1386 for (ctl = querylist; ctl; ctl = ctl->next)
1387 ctl->active = !ctl->server.skip;
1391 for (; optind < argc; optind++)
1393 flag predeclared = FALSE;
1396 * If hostname corresponds to a host known from the rc file,
1397 * simply declare it active. Otherwise synthesize a host
1398 * record from command line and defaults
1400 for (ctl = querylist; ctl; ctl = ctl->next)
1401 if (!strcmp(ctl->server.pollname, argv[optind])
1402 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1404 /* Is this correct? */
1405 if (predeclared && outlevel >= O_VERBOSE)
1406 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1411 if (ctl->pwmd_file) {
1413 * Cannot get an element path without a service.
1415 if (ctl->server.protocol <= 1) {
1416 report(stderr, GT_("%s configuration invalid, pwmd_file requires a protocol specification\n"),
1417 ctl->server.pollname);
1421 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1422 if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1425 if (get_pwmd_details(ctl->server.pollname,
1426 ctl->server.protocol, ctl))
1435 * Allocate and link record without copying in
1436 * command-line args; we'll do that with the optmerge
1439 ctl = hostalloc((struct query *)NULL);
1442 if (cmd_opts.pwmd_file) {
1444 * Cannot get an element path without a service.
1446 if (cmd_opts.server.protocol == 0 || cmd_opts.server.protocol == 1) {
1447 report(stderr, GT_("Option --pwmd-file needs a service (-p) parameter.\n"));
1451 fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1452 if (do_pwmd_connect(cmd_opts.pwmd_socket, cmd_opts.pwmd_file))
1455 if (get_pwmd_details(argv[optind], cmd_opts.server.protocol,
1461 ctl->server.pollname = xstrdup(argv[optind]);
1464 ctl->server.pollname = xstrdup(argv[optind]);
1467 ctl->server.lead_server = (struct hostdata *)NULL;
1472 * If there's a defaults record, merge it and lose it.
1473 * FIXME: we don't currently free all entries that might be in struct query.
1475 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1479 for (ctl = querylist->next; ctl; ctl = ctl->next)
1480 optmerge(ctl, querylist, FALSE);
1482 querylist = querylist->next;
1483 free(tmpq->server.pollname);
1487 /* don't allow a defaults record after the first */
1488 for (ctl = querylist; ctl; ctl = ctl->next) {
1489 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1490 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1495 /* use localhost if we never fetch the FQDN of this host */
1496 fetchmailhost = "localhost";
1498 /* here's where we override globals */
1499 if (cmd_run.logfile)
1500 run.logfile = cmd_run.logfile;
1502 run.idfile = cmd_run.idfile;
1503 if (cmd_run.pidfile)
1504 run.pidfile = cmd_run.pidfile;
1505 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1506 if (cmd_run.poll_interval >= 0)
1507 run.poll_interval = cmd_run.poll_interval;
1508 if (cmd_run.invisible)
1509 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1510 if (cmd_run.showdots)
1511 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1512 if (cmd_run.use_syslog)
1513 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1514 if (cmd_run.postmaster)
1515 run.postmaster = cmd_run.postmaster;
1516 if (cmd_run.bouncemail)
1517 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1518 if (cmd_run.softbounce)
1519 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1521 /* check and daemon options are not compatible */
1522 if (check_only && run.poll_interval)
1523 run.poll_interval = 0;
1526 * DNS support is required for some protocols. We used to
1527 * do this unconditionally, but it made fetchmail excessively
1528 * vulnerable to misconfigured DNS setups.
1530 * If we're using ETRN or ODMR, the smtp hunt list is the
1531 * list of systems we're polling on behalf of; these have
1532 * to be fully-qualified domain names. The default for
1533 * this list should be the FQDN of localhost.
1535 * If we're using Kerberos for authentication, we need
1536 * the FQDN in order to generate capability keys.
1538 for (ctl = querylist; ctl; ctl = ctl->next)
1540 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1541 || ctl->server.authenticate == A_KERBEROS_V5))
1543 fetchmailhost = host_fqdn(1);
1547 if (!ctl) /* list exhausted */
1548 fetchmailhost = host_fqdn(0);
1550 /* this code enables flags to be turned off */
1551 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1553 else if (flag == FLAG_FALSE)\
1558 /* merge in wired defaults, do sanity checks and prepare internal fields */
1559 for (ctl = querylist; ctl; ctl = ctl->next)
1561 ctl->wedged = FALSE;
1563 /* merge in defaults */
1564 optmerge(ctl, &def_opts, FALSE);
1566 /* force command-line options */
1567 optmerge(ctl, &cmd_opts, TRUE);
1570 * queryname has to be set up for inactive servers too.
1571 * Otherwise the UIDL code core-dumps on startup.
1573 if (ctl->server.via)
1574 ctl->server.queryname = xstrdup(ctl->server.via);
1576 ctl->server.queryname = xstrdup(ctl->server.pollname);
1579 * We no longer do DNS lookups at startup.
1580 * This is a kluge. It enables users to edit their
1581 * configurations when DNS isn't available.
1583 ctl->server.truename = xstrdup(ctl->server.queryname);
1585 if (configdump || ctl->active )
1587 DEFAULT(ctl->keep, FALSE);
1588 DEFAULT(ctl->fetchall, FALSE);
1589 DEFAULT(ctl->flush, FALSE);
1590 DEFAULT(ctl->limitflush, FALSE);
1591 DEFAULT(ctl->rewrite, TRUE);
1592 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1593 DEFAULT(ctl->forcecr, FALSE);
1594 DEFAULT(ctl->pass8bits, FALSE);
1595 DEFAULT(ctl->dropstatus, FALSE);
1596 DEFAULT(ctl->dropdelivered, FALSE);
1597 DEFAULT(ctl->mimedecode, FALSE);
1598 DEFAULT(ctl->idle, FALSE);
1599 DEFAULT(ctl->server.dns, TRUE);
1600 DEFAULT(ctl->use_ssl, FALSE);
1601 DEFAULT(ctl->sslcertck, FALSE);
1602 DEFAULT(ctl->server.checkalias, FALSE);
1605 * XXX FIXME: do we need this check or can we rely on the .y
1606 * parser handling this?
1610 report(stderr, GT_("SSL support is not compiled in.\n"));
1613 #endif /* SSL_ENABLE */
1616 if (ctl->server.authenticate == A_KERBEROS_V5) {
1617 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1622 if (ctl->server.authenticate == A_GSSAPI) {
1623 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1629 * Make sure we have a nonempty host list to forward to.
1632 save_str(&ctl->smtphunt, "localhost", FALSE);
1635 * Make sure we have a nonempty list of domains to fetch from.
1637 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1638 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1640 /* if `user' doesn't name a real local user, try to run as root */
1641 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1644 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1645 if (!ctl->localnames) /* for local delivery via SMTP */
1646 save_str_pair(&ctl->localnames, user, NULL);
1649 * can't handle multidrop mailboxes without "envelope"
1650 * option, this causes truckloads full of support complaints
1651 * "all mail forwarded to postmaster"
1653 if (MULTIDROP(ctl) && !ctl->server.envelope)
1655 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1656 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1659 /* if no folders were specified, set up the null one as default */
1660 if (!ctl->mailboxes)
1661 save_str(&ctl->mailboxes, (char *)NULL, 0);
1663 /* maybe user overrode timeout on command line? */
1664 if (ctl->server.timeout == -1)
1665 ctl->server.timeout = CLIENT_TIMEOUT;
1668 if (ctl->server.service) {
1669 int port = servport(ctl->server.service);
1672 (void) fprintf(stderr,
1673 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1674 ctl->server.pollname);
1678 if (ctl->listener == LMTP_MODE)
1682 for (idp = ctl->smtphunt; idp; idp = idp->next)
1686 if (!(cp = strrchr(idp->id, '/'))
1687 || (0 == strcmp(cp + 1, SMTP_PORT))
1688 || servport(cp + 1) == SMTP_PORT_NUM)
1690 (void) fprintf(stderr,
1691 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1692 ctl->server.pollname);
1699 * "I beg to you, have mercy on the we[a]k minds like myself."
1700 * wrote Pehr Anderson. Your petition is granted.
1702 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1704 (void) fprintf(stderr,
1705 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1711 * If the user didn't set a last-resort user to get misaddressed
1712 * multidrop mail, set an appropriate default here.
1714 if (!run.postmaster)
1716 if (getuid() != ROOT_UID) /* ordinary user */
1717 run.postmaster = user;
1719 run.postmaster = "postmaster";
1722 return(implicitmode);
1725 static void terminate_poll(int sig)
1726 /* to be executed at the end of a poll cycle */
1730 report(stdout, GT_("terminated with signal %d\n"), sig);
1734 * Update UID information at end of each poll, rather than at end
1735 * of run, because that way we don't lose all UIDL information since
1736 * the beginning of time if fetchmail crashes.
1739 write_saved_lists(querylist, run.idfile);
1740 #endif /* POP3_ENABLE */
1743 static void terminate_run(int sig)
1744 /* to be executed on normal or signal-induced termination */
1748 terminate_poll(sig);
1751 * Craig Metz, the RFC1938 one-time-password guy, points out:
1752 * "Remember that most kernels don't zero pages before handing them to the
1753 * next process and many kernels share pages between user and kernel space.
1754 * You'd be very surprised what you can find from a short program to do a
1755 * malloc() and then dump the contents of the pages you got. By zeroing
1756 * the secrets at end of run (earlier if you can), you make sure the next
1757 * guy can't get the password/pass phrase."
1759 * Right you are, Craig!
1761 for (ctl = querylist; ctl; ctl = ctl->next)
1763 memset(ctl->password, '\0', strlen(ctl->password));
1765 if (activecount == 0)
1768 exit(successes ? PS_SUCCESS : querystatus);
1772 * Sequence of protocols to try when autoprobing, most capable to least.
1774 static const int autoprobe[] =
1778 #endif /* IMAP_ENABLE */
1781 #endif /* POP3_ENABLE */
1784 static int query_host(struct query *ctl)
1785 /* perform fetch transaction with single host */
1791 * If we're syslogging the progress messages are automatically timestamped.
1792 * Force timestamping if we're going to a logfile.
1794 if (outlevel >= O_VERBOSE)
1796 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1798 ctl->server.pollname,
1799 showproto(ctl->server.protocol),
1803 switch (ctl->server.protocol) {
1805 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1807 ctl->server.protocol = autoprobe[i];
1809 st = query_host(ctl);
1812 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1815 ctl->server.protocol = P_AUTO;
1821 } while (st == PS_REPOLL);
1823 report(stderr, GT_("POP3 support is not configured.\n"));
1825 #endif /* POP3_ENABLE */
1831 } while (st == PS_REPOLL);
1833 report(stderr, GT_("IMAP support is not configured.\n"));
1835 #endif /* IMAP_ENABLE */
1839 report(stderr, GT_("ETRN support is not configured.\n"));
1844 #endif /* ETRN_ENABLE */
1847 report(stderr, GT_("ODMR support is not configured.\n"));
1851 #endif /* ODMR_ENABLE */
1854 report(stderr, GT_("unsupported protocol selected.\n"));
1859 * If we're syslogging the progress messages are automatically timestamped.
1860 * Force timestamping if we're going to a logfile.
1862 if (outlevel >= O_VERBOSE)
1864 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1866 ctl->server.pollname,
1867 showproto(ctl->server.protocol),
1874 static int print_id_of(struct uid_db_record *rec, void *unused)
1878 printf("\t%s\n", rec->id);
1882 static void dump_params (struct runctl *runp,
1883 struct query *querylist, flag implicit)
1884 /* display query parameters in English */
1888 if (runp->poll_interval)
1889 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1891 printf(GT_("Logfile is %s\n"), runp->logfile);
1892 if (strcmp(runp->idfile, IDFILE_NAME))
1893 printf(GT_("Idfile is %s\n"), runp->idfile);
1894 if (runp->use_syslog)
1895 printf(GT_("Progress messages will be logged via syslog\n"));
1896 if (runp->invisible)
1897 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1899 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1900 if (runp->postmaster)
1901 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1904 if (!runp->bouncemail)
1905 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1906 else if (outlevel >= O_VERBOSE)
1907 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1909 if (!runp->softbounce)
1910 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1911 else if (outlevel >= O_VERBOSE)
1912 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1914 for (ctl = querylist; ctl; ctl = ctl->next)
1916 if (!ctl->active || (implicit && ctl->server.skip))
1919 printf(GT_("Options for retrieving from %s@%s:\n"),
1920 ctl->remotename, visbuf(ctl->server.pollname));
1922 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1923 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1925 if (ctl->server.interval)
1926 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1927 " Poll of this server will occur every %d intervals.\n",
1928 ctl->server.interval), ctl->server.interval);
1929 if (ctl->server.truename)
1930 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1931 if (ctl->server.skip || outlevel >= O_VERBOSE)
1932 printf(ctl->server.skip
1933 ? GT_(" This host will not be queried when no host is specified.\n")
1934 : GT_(" This host will be queried when no host is specified.\n"));
1935 if (!NO_PASSWORD(ctl))
1938 printf(GT_(" Password will be prompted for.\n"));
1939 else if (outlevel >= O_VERBOSE)
1941 printf(GT_(" Password = \"%s\".\n"),
1942 visbuf(ctl->password));
1946 if (ctl->server.protocol == P_POP3
1947 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1948 && (ctl->server.authenticate == A_KERBEROS_V5))
1949 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1950 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1952 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1953 if (ctl->server.service)
1954 printf(GT_(" (using service %s)"), ctl->server.service);
1955 else if (outlevel >= O_VERBOSE)
1956 printf(GT_(" (using default port)"));
1959 switch (ctl->server.authenticate)
1962 printf(GT_(" All available authentication methods will be tried.\n"));
1965 printf(GT_(" Password authentication will be forced.\n"));
1968 printf(GT_(" MSN authentication will be forced.\n"));
1971 printf(GT_(" NTLM authentication will be forced.\n"));
1974 printf(GT_(" OTP authentication will be forced.\n"));
1977 printf(GT_(" CRAM-MD5 authentication will be forced.\n"));
1980 printf(GT_(" GSSAPI authentication will be forced.\n"));
1983 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1986 printf(GT_(" End-to-end encryption assumed.\n"));
1989 printf(GT_(" APOP authentication will be forced.\n"));
1994 if (ctl->server.principal != (char *) NULL)
1995 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1998 printf(GT_(" SSL encrypted sessions enabled.\n"));
2000 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
2001 if (ctl->sslcertck) {
2002 printf(GT_(" SSL server certificate checking enabled.\n"));
2004 if (ctl->sslcertfile != NULL)
2005 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
2006 if (ctl->sslcertpath != NULL)
2007 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
2008 if (ctl->sslcommonname != NULL)
2009 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
2010 if (ctl->sslfingerprint != NULL)
2011 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
2013 if (ctl->server.timeout > 0)
2014 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
2015 if (ctl->server.timeout == CLIENT_TIMEOUT)
2016 printf(GT_(" (default).\n"));
2020 if (MAILBOX_PROTOCOL(ctl))
2022 if (!ctl->mailboxes->id)
2023 printf(GT_(" Default mailbox selected.\n"));
2028 printf(GT_(" Selected mailboxes are:"));
2029 for (idp = ctl->mailboxes; idp; idp = idp->next)
2030 printf(" %s", idp->id);
2033 printf(ctl->fetchall
2034 ? GT_(" All messages will be retrieved (--all on).\n")
2035 : GT_(" Only new messages will be retrieved (--all off).\n"));
2037 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
2038 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
2040 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
2041 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
2042 printf(ctl->limitflush
2043 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
2044 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
2046 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
2047 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
2049 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
2050 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
2052 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
2053 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
2054 printf(ctl->pass8bits
2055 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
2056 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
2057 printf(ctl->mimedecode
2058 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
2059 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
2061 ? GT_(" Idle after poll is enabled (idle on).\n")
2062 : GT_(" Idle after poll is disabled (idle off).\n"));
2063 printf(ctl->dropstatus
2064 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
2065 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
2066 printf(ctl->dropdelivered
2067 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
2068 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
2069 if (NUM_NONZERO(ctl->limit))
2071 if (NUM_NONZERO(ctl->limit))
2072 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
2073 ctl->limit, ctl->limit);
2074 else if (outlevel >= O_VERBOSE)
2075 printf(GT_(" No message size limit (--limit 0).\n"));
2076 if (run.poll_interval > 0)
2077 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
2078 ctl->warnings, ctl->warnings);
2079 else if (outlevel >= O_VERBOSE)
2080 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
2082 if (NUM_NONZERO(ctl->fetchlimit))
2083 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
2084 ctl->fetchlimit, ctl->fetchlimit);
2085 else if (outlevel >= O_VERBOSE)
2086 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
2087 if (NUM_NONZERO(ctl->fetchsizelimit))
2088 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
2089 ctl->fetchsizelimit, ctl->fetchsizelimit);
2090 else if (outlevel >= O_VERBOSE)
2091 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
2092 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
2094 if (ctl->fastuidl == 1)
2095 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
2097 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
2099 else if (outlevel >= O_VERBOSE)
2100 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
2101 if (NUM_NONZERO(ctl->batchlimit))
2102 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
2103 else if (outlevel >= O_VERBOSE)
2104 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
2105 if (MAILBOX_PROTOCOL(ctl))
2107 if (NUM_NONZERO(ctl->expunge))
2108 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
2109 else if (outlevel >= O_VERBOSE)
2110 printf(GT_(" No forced expunges (--expunge 0).\n"));
2113 else /* ODMR or ETRN */
2117 printf(GT_(" Domains for which mail will be fetched are:"));
2118 for (idp = ctl->domainlist; idp; idp = idp->next)
2120 printf(" %s", idp->id);
2121 if (!idp->val.status.mark)
2122 printf(GT_(" (default)"));
2127 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
2128 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
2129 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
2136 printf(GT_(" Messages will be %cMTP-forwarded to:"),
2138 for (idp = ctl->smtphunt; idp; idp = idp->next)
2140 printf(" %s", idp->id);
2141 if (!idp->val.status.mark)
2142 printf(GT_(" (default)"));
2146 if (ctl->smtpaddress)
2147 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
2150 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
2153 if (MAILBOX_PROTOCOL(ctl))
2155 if (ctl->antispam != (struct idlist *)NULL)
2159 printf(GT_(" Recognized listener spam block responses are:"));
2160 for (idp = ctl->antispam; idp; idp = idp->next)
2161 printf(" %d", idp->val.status.num);
2164 else if (outlevel >= O_VERBOSE)
2165 printf(GT_(" Spam-blocking disabled\n"));
2167 if (ctl->preconnect)
2168 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
2169 visbuf(ctl->preconnect));
2170 else if (outlevel >= O_VERBOSE)
2171 printf(GT_(" No pre-connection command.\n"));
2172 if (ctl->postconnect)
2173 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
2174 visbuf(ctl->postconnect));
2175 else if (outlevel >= O_VERBOSE)
2176 printf(GT_(" No post-connection command.\n"));
2177 if (MAILBOX_PROTOCOL(ctl)) {
2178 if (!ctl->localnames)
2179 printf(GT_(" No localnames declared for this host.\n"));
2185 for (idp = ctl->localnames; idp; idp = idp->next)
2188 if (count > 1 || ctl->wildcard)
2189 printf(GT_(" Multi-drop mode: "));
2191 printf(GT_(" Single-drop mode: "));
2193 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
2194 if (outlevel >= O_VERBOSE)
2196 for (idp = ctl->localnames; idp; idp = idp->next)
2198 printf("\t%s -> %s\n", idp->id, idp->val.id2);
2200 printf("\t%s\n", idp->id);
2202 fputs("\t*\n", stdout);
2205 if (count > 1 || ctl->wildcard)
2207 printf(ctl->server.dns
2208 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
2209 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
2210 if (ctl->server.dns)
2212 if (ctl->server.checkalias)
2213 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
2215 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
2217 if (ctl->server.envelope == STRING_DISABLED)
2218 printf(GT_(" Envelope-address routing is disabled\n"));
2221 printf(GT_(" Envelope header is assumed to be: %s\n"),
2222 ctl->server.envelope ? ctl->server.envelope : "Received");
2223 if (ctl->server.envskip || outlevel >= O_VERBOSE)
2224 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
2225 ctl->server.envskip);
2226 if (ctl->server.qvirtual)
2227 printf(GT_(" Prefix %s will be removed from user id\n"),
2228 ctl->server.qvirtual);
2229 else if (outlevel >= O_VERBOSE)
2230 printf(GT_(" No prefix stripping\n"));
2233 if (ctl->server.akalist)
2235 printf(GT_(" Predeclared mailserver aliases:"));
2236 for (idp = ctl->server.akalist; idp; idp = idp->next)
2237 printf(" %s", idp->id);
2241 if (ctl->server.localdomains)
2243 printf(GT_(" Local domains:"));
2244 for (idp = ctl->server.localdomains; idp; idp = idp->next)
2245 printf(" %s", idp->id);
2252 if (ctl->server.interface)
2253 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
2254 else if (outlevel >= O_VERBOSE)
2255 printf(GT_(" No interface requirement specified.\n"));
2256 if (ctl->server.monitor)
2257 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
2258 else if (outlevel >= O_VERBOSE)
2259 printf(GT_(" No monitor interface specified.\n"));
2262 if (ctl->server.plugin)
2263 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
2264 else if (outlevel >= O_VERBOSE)
2265 printf(GT_(" No plugin command specified.\n"));
2266 if (ctl->server.plugout)
2267 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
2268 else if (outlevel >= O_VERBOSE)
2269 printf(GT_(" No plugout command specified.\n"));
2271 if (MAILBOX_PROTOCOL(ctl))
2275 if (!(count = uid_db_n_records(&ctl->oldsaved)))
2276 printf(GT_(" No UIDs saved from this host.\n"));
2279 printf(GT_(" %d UIDs saved.\n"), count);
2280 traverse_uid_db(&ctl->oldsaved, print_id_of, NULL);
2284 if (ctl->server.tracepolls)
2285 printf(GT_(" Poll trace information will be added to the Received header.\n"));
2286 else if (outlevel >= O_VERBOSE)
2287 printf(GT_(" No poll trace information will be added to the Received header.\n"));
2289 switch (ctl->server.badheader) {
2291 if (outlevel >= O_VERBOSE)
2292 printf(GT_(" Messages with bad headers will be rejected.\n"));
2295 printf(GT_(" Messages with bad headers will be passed on.\n"));
2299 switch (ctl->server.retrieveerror) {
2301 if (outlevel >= O_VERBOSE)
2302 printf(GT_(" Messages with fetch body errors will cause the session to abort.\n"));
2305 printf(GT_(" Messages with fetch body errors will be skipped, the session will continue.\n"));
2308 printf(GT_(" Messages with fetch body errors will be marked seen, the session will continue.\n"));
2312 if (ctl->properties)
2313 printf(GT_(" Pass-through properties \"%s\".\n"),
2314 visbuf(ctl->properties));
2318 /* fetchmail.c ends here */