2 * fetchmail.c -- main driver module for fetchmail
4 * For license terms, see the file COPYING in this directory.
9 #if defined(STDC_HEADERS)
12 #if defined(HAVE_UNISTD_H)
18 #if defined(HAVE_SYSLOG)
26 #include <sys/types.h>
29 #include <sys/resource.h>
30 #endif /* HAVE_SETRLIMIT */
33 #include <socks.h> /* SOCKSinit() */
34 #endif /* HAVE_SOCKS */
36 #ifdef HAVE_LANGINFO_H
40 #include "fetchmail.h"
48 /* need these (and sys/types.h) for res_init() */
49 #include <netinet/in.h>
50 #include <arpa/nameser.h>
54 #define ENETUNREACH 128 /* Interactive doesn't know this */
55 #endif /* ENETUNREACH */
57 /* prototypes for internal functions */
58 static int load_params(int, char **, int);
59 static void dump_params (struct runctl *runp, struct query *, flag implicit);
60 static int query_host(struct query *);
62 /* controls the detail level of status/progress messages written to stderr */
63 int outlevel; /* see the O_.* constants above */
65 /* miscellaneous global controls */
66 struct runctl run; /* global controls for this run */
67 flag nodetach; /* if TRUE, don't detach daemon process */
68 flag quitmode; /* if --quit was set */
69 int quitind; /* optind after position of last --quit option */
70 flag check_only; /* if --probe was set */
71 flag versioninfo; /* emit only version info */
72 char *user; /* the name of the invoking user */
73 char *home; /* invoking user's home directory */
74 char *fmhome; /* fetchmail's home directory */
75 const char *program_name; /* the name to prefix error messages with */
76 flag configdump; /* dump control blocks for configurator */
77 const char *fetchmailhost; /* either `localhost' or the host's FQDN */
79 static int quitonly; /* if we should quit after killing the running daemon */
81 static int querystatus; /* status of query */
82 static int successes; /* count number of successful polls */
83 static int activecount; /* count number of active entries */
84 static struct runctl cmd_run; /* global options set from command line */
85 static time_t parsetime; /* time of last parse */
87 static RETSIGTYPE terminate_run(int);
88 static RETSIGTYPE terminate_poll(int);
90 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
91 /* drop SGID kmem privileage until we need it */
92 static void dropprivs(void)
102 if (gr && !strcmp(gr->gr_name, "kmem"))
104 extern void interface_set_gids(gid_t egid, gid_t rgid);
105 interface_set_gids(egid, rgid);
111 #if defined(HAVE_SETLOCALE) && defined(ENABLE_NLS) && defined(HAVE_STRFTIME)
113 /** returns timestamp in current locale,
114 * and resets LC_TIME locale to POSIX. */
115 static char *timestamp (void)
118 static char buf[60]; /* RATS: ignore */
121 setlocale (LC_TIME, "");
122 strftime (buf, sizeof (buf), "%c", localtime(&now));
123 setlocale (LC_TIME, "C");
127 #define timestamp rfc822timestamp
130 static RETSIGTYPE donothing(int sig)
132 set_signal_handler(sig, donothing);
136 static void printcopyright(FILE *fp) {
137 fprintf(fp, GT_("Copyright (C) 2002, 2003 Eric S. Raymond\n"
138 "Copyright (C) 2004 Matthias Andree, Eric S. Raymond,\n"
139 " Robert M. Funk, Graham Wilson\n"
140 "Copyright (C) 2005 - 2006, 2010 - 2012 Sunil Shetye\n"
141 "Copyright (C) 2005 - 2012 Matthias Andree\n"
143 fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
144 "are welcome to redistribute it under certain conditions. For details,\n"
145 "please see the file COPYING in the source or documentation directory.\n"));
147 /* Do not translate this */
148 fprintf(fp, "This product includes software developed by the OpenSSL Project\nfor use in the OpenSSL Toolkit. (http://www.openssl.org/)\n");
152 const char *iana_charset;
154 int main(int argc, char **argv)
157 int implicitmode = FALSE;
159 netrc_entry *netrc_list;
160 char *netrc_file, *tmpbuf;
164 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
168 envquery(argc, argv);
170 setlocale (LC_ALL, "");
171 bindtextdomain(PACKAGE, LOCALEDIR);
173 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
177 iana_charset = "US-ASCII";
181 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
185 * Note: because we can't initialize reporting before we know whether
186 * syslog is supposed to be on, this message will go to stdout and
187 * be lost when running in background.
189 if (outlevel >= O_VERBOSE)
193 report(stdout, GT_("fetchmail: invoked with"));
194 for (i = 0; i < argc; i++)
195 report(stdout, " %s", argv[i]);
196 report(stdout, "\n");
199 #define IDFILE_NAME ".fetchids"
200 run.idfile = prependdir (IDFILE_NAME, fmhome);
205 * We used to arrange for the lock to be removed on exit close
206 * to where the lock was asserted. Now we need to do it here, because
207 * we might have re-executed in background with an existing lock
208 * as the result of a changed rcfile (see the code near the execvp(3)
209 * call near the beginning of the polling loop for details). We want
210 * to be sure the lock gets nuked on any error exit, basically.
215 /* save the current directory */
216 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
217 report(stderr, GT_("could not get current working directory\n"));
225 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts);
229 if (quitmode && quitind == argc)
235 const char *features =
238 #endif /* POP2_ENABLE */
241 #endif /* POP3_ENABLE */
244 #endif /* IMAP_ENABLE */
250 #endif /* RPA_ENABLE */
253 #endif /* NTLM_ENABLE */
256 #endif /* SDPS_ENABLE */
259 #endif /* ETRN_ENABLE */
262 #endif /* ODMR_ENABLE */
268 #endif /* OPIE_ENABLE */
269 #ifdef HAVE_PKG_hesiod
274 #endif /* HAVE_SOCKS */
277 #endif /* ENABLE_NLS */
280 #endif /* KERBEROS_V4 */
283 #endif /* KERBEROS_V5 */
284 #ifndef HAVE_RES_SEARCH
288 printf(GT_("This is fetchmail release %s"), VERSION);
289 fputs(features, stdout);
291 printcopyright(stdout);
293 fputs("Fallback MDA: ", stdout);
295 fputs(FALLBACK_MDA, stdout);
297 fputs("(none)", stdout);
302 /* this is an attempt to help remote debugging */
303 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
306 /* avoid parsing the config file if all we're doing is killing a daemon */
308 implicitmode = load_params(argc, argv, optind);
311 /* nodetach -> turn off logfile option */
313 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("The nodetach option is in effect, ignoring logfile option.\n")); }
318 /* not in daemon mode -> turn off logfile option */
319 if (0 == run.poll_interval) {
320 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Not running in daemon mode, ignoring logfile option.\n")); }
325 /* log file not writable -> turn off logfile option */
326 if (run.logfile && 0 != access(run.logfile, F_OK)) {
327 if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Logfile \"%s\" does not exist, ignoring logfile option.\n"), run.logfile); }
331 /* log file not writable -> turn off logfile option */
332 if (run.logfile && 0 != access(run.logfile, W_OK)) {
333 fprintf(stderr, GT_("Logfile \"%s\" is not writable, aborting.\n"), run.logfile);
339 #if defined(HAVE_SYSLOG)
340 /* logging should be set up early in case we were restarted from exec */
343 #if defined(LOG_MAIL)
344 openlog(program_name, LOG_PID, LOG_MAIL);
346 /* Assume BSD4.2 openlog with two arguments */
347 openlog(program_name, LOG_PID);
349 /* precedence: logfile (if effective) overrides syslog. */
351 syslog(LOG_ERR, GT_("syslog and logfile options are both set, ignoring syslog, and logging to %s"), run.logfile);
353 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy below, too */
360 report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy above, too */
363 /* initialize UID handling */
367 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
370 initialize_saved_lists(querylist, run.idfile);
372 #endif /* POP3_ENABLE */
374 /* construct the lockfile */
377 #ifdef HAVE_SETRLIMIT
379 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
380 * Core dumps could otherwise contain passwords to be scavenged by a
383 if (outlevel < O_VERBOSE || run.poll_interval > 0)
385 struct rlimit corelimit;
386 corelimit.rlim_cur = 0;
387 corelimit.rlim_max = 0;
388 setrlimit(RLIMIT_CORE, &corelimit);
390 #endif /* HAVE_SETRLIMIT */
392 #define NETRC_FILE ".netrc"
393 /* parse the ~/.netrc file (if present) for future password lookups. */
394 netrc_file = prependdir (NETRC_FILE, home);
395 netrc_list = parse_netrc(netrc_file);
399 /* pick up passwords where we can */
400 for (ctl = querylist; ctl; ctl = ctl->next)
402 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
404 if (NO_PASSWORD(ctl))
405 /* Server won't care what the password is, but there
406 must be some non-null string here. */
407 ctl->password = ctl->remotename;
412 /* look up the pollname and account in the .netrc file. */
413 p = search_netrc(netrc_list,
414 ctl->server.pollname, ctl->remotename);
415 /* if we find a matching entry with a password, use it */
416 if (p && p->password)
417 ctl->password = xstrdup(p->password);
419 /* otherwise try with "via" name if there is one */
420 else if (ctl->server.via)
422 p = search_netrc(netrc_list,
423 ctl->server.via, ctl->remotename);
424 if (p && p->password)
425 ctl->password = xstrdup(p->password);
431 free_netrc(netrc_list);
434 /* perhaps we just want to check options? */
437 int havercfile = access(rcfile, 0);
439 printf(GT_("Taking options from command line%s%s\n"),
440 havercfile ? "" : GT_(" and "),
441 havercfile ? "" : rcfile);
443 if (querylist == NULL)
445 GT_("No mailservers set up -- perhaps %s is missing?\n"),
448 dump_params(&run, querylist, implicitmode);
452 /* dump options as a Python dictionary, for configurator use */
455 dump_config(&run, querylist);
459 /* check for another fetchmail running concurrently */
460 pid = fm_lock_state();
462 pid = bkgd ? -pid : pid;
464 /* if no mail servers listed and nothing in background, we're done */
465 if (!quitonly && pid == 0 && querylist == NULL) {
466 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
470 /* perhaps user asked us to kill the other fetchmail */
473 if (pid == 0 || pid == getpid())
474 /* this test enables re-execing on a changed rcfile
475 * for pid == getpid() */
478 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
482 else if (kill(pid, SIGTERM) < 0)
484 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
485 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
492 if (outlevel > O_SILENT)
493 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
494 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
495 /* We used to nuke the other process's lock here, with
496 * fm_lock_release(), which is broken. The other process
497 * needs to clear its lock by itself. */
501 /* wait for other process to exit */
502 maxwait = 10; /* seconds */
503 while (kill(pid, 0) == 0 && --maxwait >= 0) {
510 /* another fetchmail is running -- wake it up or die */
516 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
519 else if (!implicitmode)
522 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
529 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
533 else if (getpid() == pid)
534 /* this test enables re-execing on a changed rcfile */
539 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
542 else if (kill(pid, SIGUSR1) == 0)
545 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
552 * Should never happen -- possible only if a background fetchmail
553 * croaks after the first kill probe above but before the
554 * SIGUSR1/SIGHUP transmission.
557 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
559 return(PS_UNDEFINED);
563 /* pick up interactively any passwords we need but don't have */
564 for (ctl = querylist; ctl; ctl = ctl->next)
566 if (ctl->active && !(implicitmode && ctl->server.skip)
567 && !NO_PASSWORD(ctl) && !ctl->password)
572 GT_("fetchmail: can't find a password for %s@%s.\n"),
573 ctl->remotename, ctl->server.pollname);
576 const char* password_prompt = GT_("Enter password for %s@%s: ");
577 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
579 tmpbuf = (char *)xmalloc(pplen);
580 snprintf(tmpbuf, pplen, password_prompt,
581 ctl->remotename, ctl->server.pollname);
582 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
589 * Time to initiate the SOCKS library (this is not mandatory: it just
590 * registers the correct application name for logging purpose. If you
591 * have some problem, comment out these lines).
594 SOCKSinit("fetchmail");
595 #endif /* HAVE_SOCKS */
597 /* avoid zombies from plugins */
600 /* Fix up log destination - if the if() is true, the precedence rule
601 * above hasn't killed off the syslog option, because the logfile
602 * option is ineffective (because we're not detached or not in
603 * deamon mode), so kill it for the benefit of other parts of the
605 if (run.logfile && run.use_syslog)
609 * Maybe time to go to demon mode...
611 if (run.poll_interval)
616 rc = daemonize(run.logfile);
618 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
622 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
625 * We'll set up a handler for these when we're sleeping,
626 * but ignore them otherwise so as not to interrupt a poll.
628 set_signal_handler(SIGUSR1, SIG_IGN);
629 if (run.poll_interval && getuid() == ROOT_UID)
630 set_signal_handler(SIGHUP, SIG_IGN);
634 /* not in daemon mode */
637 if (!freopen(run.logfile, "a", stdout))
638 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
639 if (!freopen(run.logfile, "a", stderr))
640 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
646 /* beyond here we don't want more than one fetchmail running per user */
648 set_signal_handler(SIGABRT, terminate_run);
649 set_signal_handler(SIGINT, terminate_run);
650 set_signal_handler(SIGTERM, terminate_run);
651 set_signal_handler(SIGALRM, terminate_run);
652 set_signal_handler(SIGPIPE, SIG_IGN);
653 set_signal_handler(SIGQUIT, terminate_run);
655 /* here's the exclusion lock */
658 if (check_only && outlevel >= O_VERBOSE) {
659 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
663 * Query all hosts. If there's only one, the error return will
664 * reflect the status of that transaction.
668 * Check to see if the rcfile has been touched. If so,
669 * re-exec so the file will be reread. Doing it this way
670 * avoids all the complications of trying to deallocate the
671 * in-core control structures -- and the potential memory
676 if (strcmp(rcfile, "-") == 0) {
678 } else if (stat(rcfile, &rcstat) == -1) {
681 GT_("couldn't time-check %s (error %d)\n"),
684 else if (rcstat.st_mtime > parsetime)
686 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
689 /* restore the startup directory */
690 if (!currentwd[0] || chdir (currentwd) == -1)
691 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
695 * Matthias Andree: Isn't this prone to introduction of
696 * "false" programs by interfering with PATH? Those
697 * path-searching execs might not be the best ideas for
700 * Rob Funk: But is there any way for someone to modify
701 * the PATH variable of a running fetchmail? I don't know
704 * Dave's change makes fetchmail restart itself in exactly
705 * the way it was started from the shell (or shell script)
706 * in the first place. If you're concerned about PATH
707 * contamination, call fetchmail initially with a full
708 * path, and use Dave's patch.
710 * Not using a -p variant of exec means that the restart
711 * will break if both (a) the user depended on PATH to
712 * call fetchmail in the first place, and (b) the system
713 * doesn't save the whole path in argv[0] if the whole
714 * path wasn't used in the initial call. (If I recall
715 * correctly, Linux saves it but many other Unices don't.)
717 execvp(argv[0], argv);
718 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
721 #ifdef HAVE_RES_SEARCH
722 /* Boldly assume that we also have res_init() if we have
723 * res_search(), and call res_init() to re-read the resolv.conf
724 * file, so that we can pick up changes to that file that are
725 * written by dhpccd, dhclient, pppd, openvpn and similar. */
727 /* NOTE: This assumes that /etc/resolv.conf is written
728 * atomically (i. e. a temporary file is written, flushed and
729 * then renamed into place). To fix Debian Bug#389270. */
731 /* NOTE: If this leaks memory or doesn't re-read
732 * /etc/resolv.conf, we're in trouble. The res_init() interface
733 * is only lightly documented :-( */
739 for (ctl = querylist; ctl; ctl = ctl->next)
743 if (!(implicitmode && ctl->server.skip))
748 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
749 ctl->server.pollname);
753 /* check skip interval first so that it counts all polls */
754 if (run.poll_interval && ctl->server.interval)
756 if (ctl->server.poll_count++ % ctl->server.interval)
758 if (outlevel >= O_VERBOSE)
760 GT_("interval not reached, not querying %s\n"),
761 ctl->server.pollname);
768 * Don't do monitoring if we were woken by a signal.
769 * Note that interface_approve() does its own error logging.
771 if (!interface_approve(&ctl->server, !lastsig))
773 #endif /* CAN_MONITOR */
775 dofastuidl = 0; /* this is reset in the driver if required */
777 querystatus = query_host(ctl);
779 if (NUM_NONZERO(ctl->fastuidl))
780 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
782 /* leave the UIDL state alone if there have been any errors */
784 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
787 uid_discard_new_list(ctl);
789 #endif /* POP3_ENABLE */
791 if (querystatus == PS_SUCCESS)
793 else if (!check_only &&
794 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
798 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
800 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
802 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
804 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
806 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
808 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
810 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
812 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
814 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
816 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
818 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
820 report(stdout,GT_("Query status=11 (DNS)\n")); break;
822 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
824 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
826 report(stdout,GT_("Query status=%d\n"),querystatus);
831 if (ctl->server.monitor)
834 * Allow some time for the link to quiesce. One
835 * second is usually sufficient, three is safe.
836 * Note: this delay is important - don't remove!
839 interface_note_activity(&ctl->server);
841 #endif /* CAN_MONITOR */
845 /* close connections cleanly */
849 * OK, we've polled. Now sleep.
851 if (run.poll_interval)
854 * Because passwords can expire, it may happen that *all*
855 * hosts are now out of the loop due to authfail
856 * conditions. If this happens daemon-mode fetchmail
857 * should softly and silently vanish away, rather than
858 * spinning uselessly.
862 for (ctl = querylist; ctl; ctl = ctl->next)
863 if (ctl->active && !(implicitmode && ctl->server.skip))
868 report(stderr, GT_("All connections are wedged. Exiting.\n"));
869 /* FIXME: someday, send notification mail */
873 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
874 || outlevel > O_NORMAL)
876 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
879 * With this simple hack, we make it possible for a foreground
880 * fetchmail to wake up one in daemon mode. What we want is the
881 * side effect of interrupting any sleep that may be going on,
882 * forcing fetchmail to re-poll its hosts. The second line is
883 * for people who think all system daemons wake up on SIGHUP.
885 set_signal_handler(SIGUSR1, donothing);
886 if (getuid() == ROOT_UID)
887 set_signal_handler(SIGHUP, donothing);
890 * OK, now pause until it's time for the next poll cycle.
891 * A nonzero return indicates we received a wakeup signal;
892 * unwedge all servers in case the problem has been
895 if ((lastsig = interruptible_idle(run.poll_interval)))
897 if (outlevel > O_SILENT)
898 #ifdef SYS_SIGLIST_DECLARED
900 GT_("awakened by %s\n"), sys_siglist[lastsig]);
903 GT_("awakened by signal %d\n"), lastsig);
905 for (ctl = querylist; ctl; ctl = ctl->next)
909 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
910 || outlevel > O_NORMAL)
911 report(stdout, GT_("awakened at %s\n"), timestamp());
913 } while (run.poll_interval);
915 if (outlevel >= O_VERBOSE)
916 report(stdout, GT_("normal termination, status %d\n"),
917 successes ? PS_SUCCESS : querystatus);
923 else if (querystatus)
926 /* in case we interrupted before a successful fetch */
930 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
933 * If force is off, modify dstl fields only when they're empty (treat srcl
934 * as defaults). If force is on, modify each dstl field whenever scrcl
935 * is nonempty (treat srcl as an override).
937 if (force ? !!*srcl : !*dstl)
939 struct idlist *cpl = copy_str_list(*srcl);
941 append_str_list(dstl, &cpl);
945 static void optmerge(struct query *h2, struct query *h1, int force)
946 /* merge two options records */
948 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
949 list_merge(&h2->localnames, &h1->localnames, force);
950 list_merge(&h2->mailboxes, &h1->mailboxes, force);
951 list_merge(&h2->smtphunt, &h1->smtphunt, force);
952 list_merge(&h2->domainlist, &h1->domainlist, force);
953 list_merge(&h2->antispam, &h1->antispam, force);
955 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
956 FLAG_MERGE(server.via);
957 FLAG_MERGE(server.protocol);
958 FLAG_MERGE(server.service);
959 FLAG_MERGE(server.interval);
960 FLAG_MERGE(server.authenticate);
961 FLAG_MERGE(server.timeout);
962 FLAG_MERGE(server.envelope);
963 FLAG_MERGE(server.envskip);
964 FLAG_MERGE(server.qvirtual);
965 FLAG_MERGE(server.skip);
966 FLAG_MERGE(server.dns);
967 FLAG_MERGE(server.checkalias);
968 FLAG_MERGE(server.uidl);
969 FLAG_MERGE(server.principal);
972 FLAG_MERGE(server.interface);
973 FLAG_MERGE(server.interface_pair);
974 FLAG_MERGE(server.monitor);
977 FLAG_MERGE(server.plugin);
978 FLAG_MERGE(server.plugout);
979 FLAG_MERGE(server.tracepolls);
980 FLAG_MERGE(server.badheader);
982 FLAG_MERGE(wildcard);
983 FLAG_MERGE(remotename);
984 FLAG_MERGE(password);
987 FLAG_MERGE(listener);
988 FLAG_MERGE(smtpaddress);
989 FLAG_MERGE(smtpname);
990 FLAG_MERGE(preconnect);
991 FLAG_MERGE(postconnect);
995 FLAG_MERGE(limitflush);
996 FLAG_MERGE(fetchall);
1000 FLAG_MERGE(pass8bits);
1001 FLAG_MERGE(dropstatus);
1002 FLAG_MERGE(dropdelivered);
1003 FLAG_MERGE(mimedecode);
1006 FLAG_MERGE(warnings);
1007 FLAG_MERGE(fetchlimit);
1008 FLAG_MERGE(fetchsizelimit);
1009 FLAG_MERGE(fastuidl);
1010 FLAG_MERGE(batchlimit);
1012 FLAG_MERGE(use_ssl);
1014 FLAG_MERGE(sslcert);
1015 FLAG_MERGE(sslproto);
1016 FLAG_MERGE(sslcertck);
1017 FLAG_MERGE(sslcertfile);
1018 FLAG_MERGE(sslcertpath);
1019 FLAG_MERGE(sslcommonname);
1020 FLAG_MERGE(sslfingerprint);
1022 FLAG_MERGE(expunge);
1024 FLAG_MERGE(properties);
1028 /** Load configuration files.
1029 * \return - true if no servers found on the command line
1030 * - false if servers found on the command line */
1031 static int load_params(int argc, char **argv, int optind)
1033 int implicitmode, st;
1035 struct query def_opts, *ctl;
1039 run.bouncemail = TRUE;
1040 run.softbounce = TRUE; /* treat permanent errors as temporary */
1041 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1043 memset(&def_opts, '\0', sizeof(struct query));
1044 def_opts.smtp_socket = -1;
1045 def_opts.smtpaddress = (char *)0;
1046 def_opts.smtpname = (char *)0;
1047 def_opts.server.protocol = P_AUTO;
1048 def_opts.server.timeout = CLIENT_TIMEOUT;
1049 def_opts.server.esmtp_name = user;
1050 def_opts.server.badheader = BHREJECT;
1051 def_opts.warnings = WARNING_INTERVAL;
1052 def_opts.remotename = user;
1053 def_opts.listener = SMTP_MODE;
1054 def_opts.fetchsizelimit = 100;
1055 def_opts.fastuidl = 4;
1057 /* get the location of rcfile */
1059 p = strrchr (rcfile, '/');
1060 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1061 *p = 0; /* replace '/' by '0' */
1062 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1063 *p = '/'; /* restore '/' */
1064 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1065 strcpy (rcfiledir, "/");
1068 /* note the parse time, so we can pick up on modifications */
1069 if (strcmp(rcfile, "-") == 0)
1070 parsetime = time(NULL);
1072 if (stat(rcfile, &rcstat) != -1)
1073 parsetime = rcstat.st_mtime;
1074 else if (errno != ENOENT)
1075 report(stderr, GT_("couldn't time-check the run-control file\n"));
1078 /* this builds the host list */
1079 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1081 * FIXME: someday, send notification mail here if backgrounded.
1082 * Right now, that can happen if the user changes the rcfile
1083 * while the fetchmail is running in background. Do similarly
1084 * for the other exit() calls in this function.
1088 if ((implicitmode = (optind >= argc)))
1090 for (ctl = querylist; ctl; ctl = ctl->next)
1091 ctl->active = !ctl->server.skip;
1094 for (; optind < argc; optind++)
1096 flag predeclared = FALSE;
1099 * If hostname corresponds to a host known from the rc file,
1100 * simply declare it active. Otherwise synthesize a host
1101 * record from command line and defaults
1103 for (ctl = querylist; ctl; ctl = ctl->next)
1104 if (!strcmp(ctl->server.pollname, argv[optind])
1105 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1107 /* Is this correct? */
1108 if (predeclared && outlevel >= O_VERBOSE)
1109 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1117 * Allocate and link record without copying in
1118 * command-line args; we'll do that with the optmerge
1121 ctl = hostalloc((struct query *)NULL);
1123 ctl->server.pollname = xstrdup(argv[optind]);
1125 ctl->server.lead_server = (struct hostdata *)NULL;
1130 * If there's a defaults record, merge it and lose it.
1131 * FIXME: we don't currently free all entries that might be in struct query.
1133 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1137 for (ctl = querylist->next; ctl; ctl = ctl->next)
1138 optmerge(ctl, querylist, FALSE);
1140 querylist = querylist->next;
1141 free(tmpq->server.pollname);
1145 /* don't allow a defaults record after the first */
1146 for (ctl = querylist; ctl; ctl = ctl->next) {
1147 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1148 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1153 /* use localhost if we never fetch the FQDN of this host */
1154 fetchmailhost = "localhost";
1156 /* here's where we override globals */
1157 if (cmd_run.logfile)
1158 run.logfile = cmd_run.logfile;
1160 run.idfile = cmd_run.idfile;
1161 if (cmd_run.pidfile)
1162 run.pidfile = cmd_run.pidfile;
1163 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1164 if (cmd_run.poll_interval >= 0)
1165 run.poll_interval = cmd_run.poll_interval;
1166 if (cmd_run.invisible)
1167 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1168 if (cmd_run.showdots)
1169 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1170 if (cmd_run.use_syslog)
1171 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1172 if (cmd_run.postmaster)
1173 run.postmaster = cmd_run.postmaster;
1174 if (cmd_run.bouncemail)
1175 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1176 if (cmd_run.softbounce)
1177 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1179 /* check and daemon options are not compatible */
1180 if (check_only && run.poll_interval)
1181 run.poll_interval = 0;
1184 * DNS support is required for some protocols. We used to
1185 * do this unconditionally, but it made fetchmail excessively
1186 * vulnerable to misconfigured DNS setups.
1188 * If we're using ETRN or ODMR, the smtp hunt list is the
1189 * list of systems we're polling on behalf of; these have
1190 * to be fully-qualified domain names. The default for
1191 * this list should be the FQDN of localhost.
1193 * If we're using Kerberos for authentication, we need
1194 * the FQDN in order to generate capability keys.
1196 for (ctl = querylist; ctl; ctl = ctl->next)
1198 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1199 || ctl->server.authenticate == A_KERBEROS_V4
1200 || ctl->server.authenticate == A_KERBEROS_V5))
1202 fetchmailhost = host_fqdn(1);
1206 if (!ctl) /* list exhausted */
1207 fetchmailhost = host_fqdn(0);
1209 /* this code enables flags to be turned off */
1210 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1212 else if (flag == FLAG_FALSE)\
1217 /* merge in wired defaults, do sanity checks and prepare internal fields */
1218 for (ctl = querylist; ctl; ctl = ctl->next)
1220 ctl->wedged = FALSE;
1222 /* merge in defaults */
1223 optmerge(ctl, &def_opts, FALSE);
1225 /* force command-line options */
1226 optmerge(ctl, &cmd_opts, TRUE);
1229 * queryname has to be set up for inactive servers too.
1230 * Otherwise the UIDL code core-dumps on startup.
1232 if (ctl->server.via)
1233 ctl->server.queryname = xstrdup(ctl->server.via);
1235 ctl->server.queryname = xstrdup(ctl->server.pollname);
1238 * We no longer do DNS lookups at startup.
1239 * This is a kluge. It enables users to edit their
1240 * configurations when DNS isn't available.
1242 ctl->server.truename = xstrdup(ctl->server.queryname);
1244 if (configdump || ctl->active )
1246 DEFAULT(ctl->keep, FALSE);
1247 DEFAULT(ctl->fetchall, FALSE);
1248 DEFAULT(ctl->flush, FALSE);
1249 DEFAULT(ctl->limitflush, FALSE);
1250 DEFAULT(ctl->rewrite, TRUE);
1251 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1252 DEFAULT(ctl->forcecr, FALSE);
1253 DEFAULT(ctl->pass8bits, FALSE);
1254 DEFAULT(ctl->dropstatus, FALSE);
1255 DEFAULT(ctl->dropdelivered, FALSE);
1256 DEFAULT(ctl->mimedecode, FALSE);
1257 DEFAULT(ctl->idle, FALSE);
1258 DEFAULT(ctl->server.dns, TRUE);
1259 DEFAULT(ctl->server.uidl, FALSE);
1260 DEFAULT(ctl->use_ssl, FALSE);
1261 DEFAULT(ctl->sslcertck, FALSE);
1262 DEFAULT(ctl->server.checkalias, FALSE);
1265 * XXX FIXME: do we need this check or can we rely on the .y
1266 * parser handling this?
1270 report(stderr, GT_("SSL support is not compiled in.\n"));
1273 #endif /* SSL_ENABLE */
1276 if (ctl->server.authenticate == A_KERBEROS_V4) {
1277 report(stderr, GT_("KERBEROS v4 support is configured, but not compiled in.\n"));
1282 if (ctl->server.authenticate == A_KERBEROS_V5) {
1283 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1288 if (ctl->server.authenticate == A_GSSAPI) {
1289 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1295 * Make sure we have a nonempty host list to forward to.
1298 save_str(&ctl->smtphunt, "localhost", FALSE);
1301 * Make sure we have a nonempty list of domains to fetch from.
1303 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1304 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1306 /* if `user' doesn't name a real local user, try to run as root */
1307 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1310 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1311 if (!ctl->localnames) /* for local delivery via SMTP */
1312 save_str_pair(&ctl->localnames, user, NULL);
1314 #ifndef HAVE_RES_SEARCH
1315 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1316 if (MULTIDROP(ctl) && ctl->server.dns)
1318 ctl->server.dns = FALSE;
1319 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1321 #endif /* !HAVE_RES_SEARCH */
1324 * can't handle multidrop mailboxes without "envelope"
1325 * option, this causes truckloads full of support complaints
1326 * "all mail forwarded to postmaster"
1328 if (MULTIDROP(ctl) && !ctl->server.envelope)
1330 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1331 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1334 /* if no folders were specified, set up the null one as default */
1335 if (!ctl->mailboxes)
1336 save_str(&ctl->mailboxes, (char *)NULL, 0);
1338 /* maybe user overrode timeout on command line? */
1339 if (ctl->server.timeout == -1)
1340 ctl->server.timeout = CLIENT_TIMEOUT;
1343 if (ctl->server.service) {
1344 int port = servport(ctl->server.service);
1347 (void) fprintf(stderr,
1348 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1349 ctl->server.pollname);
1352 if (ctl->server.protocol == P_RPOP && port >= 1024)
1354 (void) fprintf(stderr,
1355 GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1356 ctl->server.pollname);
1360 if (ctl->listener == LMTP_MODE)
1364 for (idp = ctl->smtphunt; idp; idp = idp->next)
1368 if (!(cp = strrchr(idp->id, '/'))
1369 || (0 == strcmp(cp + 1, SMTP_PORT))
1370 || servport(cp + 1) == SMTP_PORT_NUM)
1372 (void) fprintf(stderr,
1373 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1374 ctl->server.pollname);
1381 * "I beg to you, have mercy on the we[a]k minds like myself."
1382 * wrote Pehr Anderson. Your petition is granted.
1384 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1386 (void) fprintf(stderr,
1387 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1393 * If the user didn't set a last-resort user to get misaddressed
1394 * multidrop mail, set an appropriate default here.
1396 if (!run.postmaster)
1398 if (getuid() != ROOT_UID) /* ordinary user */
1399 run.postmaster = user;
1401 run.postmaster = "postmaster";
1404 return(implicitmode);
1407 static RETSIGTYPE terminate_poll(int sig)
1408 /* to be executed at the end of a poll cycle */
1412 report(stdout, GT_("terminated with signal %d\n"), sig);
1416 * Update UID information at end of each poll, rather than at end
1417 * of run, because that way we don't lose all UIDL information since
1418 * the beginning of time if fetchmail crashes.
1421 write_saved_lists(querylist, run.idfile);
1422 #endif /* POP3_ENABLE */
1425 static RETSIGTYPE terminate_run(int sig)
1426 /* to be executed on normal or signal-induced termination */
1430 terminate_poll(sig);
1433 * Craig Metz, the RFC1938 one-time-password guy, points out:
1434 * "Remember that most kernels don't zero pages before handing them to the
1435 * next process and many kernels share pages between user and kernel space.
1436 * You'd be very surprised what you can find from a short program to do a
1437 * malloc() and then dump the contents of the pages you got. By zeroing
1438 * the secrets at end of run (earlier if you can), you make sure the next
1439 * guy can't get the password/pass phrase."
1441 * Right you are, Craig!
1443 for (ctl = querylist; ctl; ctl = ctl->next)
1445 memset(ctl->password, '\0', strlen(ctl->password));
1447 #if !defined(HAVE_ATEXIT)
1451 if (activecount == 0)
1454 exit(successes ? PS_SUCCESS : querystatus);
1458 * Sequence of protocols to try when autoprobing, most capable to least.
1460 static const int autoprobe[] =
1464 #endif /* IMAP_ENABLE */
1467 #endif /* POP3_ENABLE */
1470 #endif /* POP2_ENABLE */
1473 static int query_host(struct query *ctl)
1474 /* perform fetch transaction with single host */
1480 * If we're syslogging the progress messages are automatically timestamped.
1481 * Force timestamping if we're going to a logfile.
1483 if (outlevel >= O_VERBOSE)
1485 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1487 ctl->server.pollname,
1488 showproto(ctl->server.protocol),
1492 switch (ctl->server.protocol) {
1494 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1496 ctl->server.protocol = autoprobe[i];
1498 st = query_host(ctl);
1501 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1504 ctl->server.protocol = P_AUTO;
1510 report(stderr, GT_("POP2 support is not configured.\n"));
1512 #endif /* POP2_ENABLE */
1520 } while (st == PS_REPOLL);
1522 report(stderr, GT_("POP3 support is not configured.\n"));
1524 #endif /* POP3_ENABLE */
1530 } while (st == PS_REPOLL);
1532 report(stderr, GT_("IMAP support is not configured.\n"));
1534 #endif /* IMAP_ENABLE */
1538 report(stderr, GT_("ETRN support is not configured.\n"));
1543 #endif /* ETRN_ENABLE */
1546 report(stderr, GT_("ODMR support is not configured.\n"));
1550 #endif /* ODMR_ENABLE */
1553 report(stderr, GT_("unsupported protocol selected.\n"));
1558 * If we're syslogging the progress messages are automatically timestamped.
1559 * Force timestamping if we're going to a logfile.
1561 if (outlevel >= O_VERBOSE)
1563 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1565 ctl->server.pollname,
1566 showproto(ctl->server.protocol),
1573 static void dump_params (struct runctl *runp,
1574 struct query *querylist, flag implicit)
1575 /* display query parameters in English */
1579 if (runp->poll_interval)
1580 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1582 printf(GT_("Logfile is %s\n"), runp->logfile);
1583 if (strcmp(runp->idfile, IDFILE_NAME))
1584 printf(GT_("Idfile is %s\n"), runp->idfile);
1585 #if defined(HAVE_SYSLOG)
1586 if (runp->use_syslog)
1587 printf(GT_("Progress messages will be logged via syslog\n"));
1589 if (runp->invisible)
1590 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1592 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1593 if (runp->postmaster)
1594 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1597 if (!runp->bouncemail)
1598 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1599 else if (outlevel >= O_VERBOSE)
1600 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1602 if (!runp->softbounce)
1603 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1604 else if (outlevel >= O_VERBOSE)
1605 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1607 for (ctl = querylist; ctl; ctl = ctl->next)
1609 if (!ctl->active || (implicit && ctl->server.skip))
1612 printf(GT_("Options for retrieving from %s@%s:\n"),
1613 ctl->remotename, visbuf(ctl->server.pollname));
1615 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1616 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1618 if (ctl->server.interval)
1619 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1620 " Poll of this server will occur every %d intervals.\n",
1621 ctl->server.interval), ctl->server.interval);
1622 if (ctl->server.truename)
1623 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1624 if (ctl->server.skip || outlevel >= O_VERBOSE)
1625 printf(ctl->server.skip
1626 ? GT_(" This host will not be queried when no host is specified.\n")
1627 : GT_(" This host will be queried when no host is specified.\n"));
1628 if (!NO_PASSWORD(ctl))
1631 printf(GT_(" Password will be prompted for.\n"));
1632 else if (outlevel >= O_VERBOSE)
1634 if (ctl->server.protocol == P_APOP)
1635 printf(GT_(" APOP secret = \"%s\".\n"),
1636 visbuf(ctl->password));
1637 else if (ctl->server.protocol == P_RPOP)
1638 printf(GT_(" RPOP id = \"%s\".\n"),
1639 visbuf(ctl->password));
1641 printf(GT_(" Password = \"%s\".\n"),
1642 visbuf(ctl->password));
1646 if (ctl->server.protocol == P_POP3
1647 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1648 && (ctl->server.authenticate == A_KERBEROS_V4 ||
1649 ctl->server.authenticate == A_KERBEROS_V5))
1650 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1651 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1653 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1654 if (ctl->server.service)
1655 printf(GT_(" (using service %s)"), ctl->server.service);
1656 else if (outlevel >= O_VERBOSE)
1657 printf(GT_(" (using default port)"));
1658 if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1659 printf(GT_(" (forcing UIDL use)"));
1662 switch (ctl->server.authenticate)
1665 printf(GT_(" All available authentication methods will be tried.\n"));
1668 printf(GT_(" Password authentication will be forced.\n"));
1671 printf(GT_(" MSN authentication will be forced.\n"));
1674 printf(GT_(" NTLM authentication will be forced.\n"));
1677 printf(GT_(" OTP authentication will be forced.\n"));
1680 printf(GT_(" CRAM-MD5 authentication will be forced.\n"));
1683 printf(GT_(" GSSAPI authentication will be forced.\n"));
1686 printf(GT_(" Kerberos V4 authentication will be forced.\n"));
1689 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1692 printf(GT_(" End-to-end encryption assumed.\n"));
1695 if (ctl->server.principal != (char *) NULL)
1696 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1699 printf(GT_(" SSL encrypted sessions enabled.\n"));
1701 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
1702 if (ctl->sslcertck) {
1703 printf(GT_(" SSL server certificate checking enabled.\n"));
1705 if (ctl->sslcertfile != NULL)
1706 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
1707 if (ctl->sslcertpath != NULL)
1708 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1709 if (ctl->sslcommonname != NULL)
1710 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
1711 if (ctl->sslfingerprint != NULL)
1712 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1714 if (ctl->server.timeout > 0)
1715 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1716 if (ctl->server.timeout == CLIENT_TIMEOUT)
1717 printf(GT_(" (default).\n"));
1721 if (MAILBOX_PROTOCOL(ctl))
1723 if (!ctl->mailboxes->id)
1724 printf(GT_(" Default mailbox selected.\n"));
1729 printf(GT_(" Selected mailboxes are:"));
1730 for (idp = ctl->mailboxes; idp; idp = idp->next)
1731 printf(" %s", idp->id);
1734 printf(ctl->fetchall
1735 ? GT_(" All messages will be retrieved (--all on).\n")
1736 : GT_(" Only new messages will be retrieved (--all off).\n"));
1738 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
1739 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
1741 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
1742 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
1743 printf(ctl->limitflush
1744 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1745 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1747 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
1748 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1750 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
1751 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
1753 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
1754 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
1755 printf(ctl->pass8bits
1756 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1757 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1758 printf(ctl->mimedecode
1759 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
1760 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
1762 ? GT_(" Idle after poll is enabled (idle on).\n")
1763 : GT_(" Idle after poll is disabled (idle off).\n"));
1764 printf(ctl->dropstatus
1765 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
1766 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
1767 printf(ctl->dropdelivered
1768 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
1769 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
1770 if (NUM_NONZERO(ctl->limit))
1772 if (NUM_NONZERO(ctl->limit))
1773 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
1774 ctl->limit, ctl->limit);
1775 else if (outlevel >= O_VERBOSE)
1776 printf(GT_(" No message size limit (--limit 0).\n"));
1777 if (run.poll_interval > 0)
1778 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1779 ctl->warnings, ctl->warnings);
1780 else if (outlevel >= O_VERBOSE)
1781 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
1783 if (NUM_NONZERO(ctl->fetchlimit))
1784 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
1785 ctl->fetchlimit, ctl->fetchlimit);
1786 else if (outlevel >= O_VERBOSE)
1787 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
1788 if (NUM_NONZERO(ctl->fetchsizelimit))
1789 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1790 ctl->fetchsizelimit, ctl->fetchsizelimit);
1791 else if (outlevel >= O_VERBOSE)
1792 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
1793 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1795 if (ctl->fastuidl == 1)
1796 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1798 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1800 else if (outlevel >= O_VERBOSE)
1801 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1802 if (NUM_NONZERO(ctl->batchlimit))
1803 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1804 else if (outlevel >= O_VERBOSE)
1805 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
1806 if (MAILBOX_PROTOCOL(ctl))
1808 if (NUM_NONZERO(ctl->expunge))
1809 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1810 else if (outlevel >= O_VERBOSE)
1811 printf(GT_(" No forced expunges (--expunge 0).\n"));
1814 else /* ODMR or ETRN */
1818 printf(GT_(" Domains for which mail will be fetched are:"));
1819 for (idp = ctl->domainlist; idp; idp = idp->next)
1821 printf(" %s", idp->id);
1822 if (!idp->val.status.mark)
1823 printf(GT_(" (default)"));
1828 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1829 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1830 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1837 printf(GT_(" Messages will be %cMTP-forwarded to:"),
1839 for (idp = ctl->smtphunt; idp; idp = idp->next)
1841 printf(" %s", idp->id);
1842 if (!idp->val.status.mark)
1843 printf(GT_(" (default)"));
1847 if (ctl->smtpaddress)
1848 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
1851 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1854 if (MAILBOX_PROTOCOL(ctl))
1856 if (ctl->antispam != (struct idlist *)NULL)
1860 printf(GT_(" Recognized listener spam block responses are:"));
1861 for (idp = ctl->antispam; idp; idp = idp->next)
1862 printf(" %d", idp->val.status.num);
1865 else if (outlevel >= O_VERBOSE)
1866 printf(GT_(" Spam-blocking disabled\n"));
1868 if (ctl->preconnect)
1869 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
1870 visbuf(ctl->preconnect));
1871 else if (outlevel >= O_VERBOSE)
1872 printf(GT_(" No pre-connection command.\n"));
1873 if (ctl->postconnect)
1874 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
1875 visbuf(ctl->postconnect));
1876 else if (outlevel >= O_VERBOSE)
1877 printf(GT_(" No post-connection command.\n"));
1878 if (MAILBOX_PROTOCOL(ctl)) {
1879 if (!ctl->localnames)
1880 printf(GT_(" No localnames declared for this host.\n"));
1886 for (idp = ctl->localnames; idp; idp = idp->next)
1889 if (count > 1 || ctl->wildcard)
1890 printf(GT_(" Multi-drop mode: "));
1892 printf(GT_(" Single-drop mode: "));
1894 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1895 if (outlevel >= O_VERBOSE)
1897 for (idp = ctl->localnames; idp; idp = idp->next)
1899 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1901 printf("\t%s\n", idp->id);
1903 fputs("\t*\n", stdout);
1906 if (count > 1 || ctl->wildcard)
1908 printf(ctl->server.dns
1909 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
1910 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
1911 if (ctl->server.dns)
1913 if (ctl->server.checkalias)
1914 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
1916 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
1918 if (ctl->server.envelope == STRING_DISABLED)
1919 printf(GT_(" Envelope-address routing is disabled\n"));
1922 printf(GT_(" Envelope header is assumed to be: %s\n"),
1923 ctl->server.envelope ? ctl->server.envelope : "Received");
1924 if (ctl->server.envskip || outlevel >= O_VERBOSE)
1925 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
1926 ctl->server.envskip);
1927 if (ctl->server.qvirtual)
1928 printf(GT_(" Prefix %s will be removed from user id\n"),
1929 ctl->server.qvirtual);
1930 else if (outlevel >= O_VERBOSE)
1931 printf(GT_(" No prefix stripping\n"));
1934 if (ctl->server.akalist)
1936 printf(GT_(" Predeclared mailserver aliases:"));
1937 for (idp = ctl->server.akalist; idp; idp = idp->next)
1938 printf(" %s", idp->id);
1942 if (ctl->server.localdomains)
1944 printf(GT_(" Local domains:"));
1945 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1946 printf(" %s", idp->id);
1953 if (ctl->server.interface)
1954 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
1955 else if (outlevel >= O_VERBOSE)
1956 printf(GT_(" No interface requirement specified.\n"));
1957 if (ctl->server.monitor)
1958 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1959 else if (outlevel >= O_VERBOSE)
1960 printf(GT_(" No monitor interface specified.\n"));
1963 if (ctl->server.plugin)
1964 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1965 else if (outlevel >= O_VERBOSE)
1966 printf(GT_(" No plugin command specified.\n"));
1967 if (ctl->server.plugout)
1968 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1969 else if (outlevel >= O_VERBOSE)
1970 printf(GT_(" No plugout command specified.\n"));
1972 if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1975 printf(GT_(" No UIDs saved from this host.\n"));
1981 for (idp = ctl->oldsaved; idp; idp = idp->next)
1984 printf(GT_(" %d UIDs saved.\n"), count);
1985 if (outlevel >= O_VERBOSE)
1986 for (idp = ctl->oldsaved; idp; idp = idp->next)
1987 printf("\t%s\n", idp->id);
1991 if (ctl->server.tracepolls)
1992 printf(GT_(" Poll trace information will be added to the Received header.\n"));
1993 else if (outlevel >= O_VERBOSE)
1994 printf(GT_(" No poll trace information will be added to the Received header.\n"));
1996 switch (ctl->server.badheader) {
1998 if (outlevel >= O_VERBOSE)
1999 printf(GT_(" Messages with bad headers will be rejected.\n"));
2002 printf(GT_(" Messages with bad headers will be passed on.\n"));
2006 if (ctl->properties)
2007 printf(GT_(" Pass-through properties \"%s\".\n"),
2008 visbuf(ctl->properties));
2012 /* fetchmail.c ends here */