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 Sunil Shetye\n"
141 "Copyright (C) 2005 - 2010 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);
310 /* precedence: logfile (if effective) overrides syslog. */
311 if (run.logfile && run.poll_interval && !nodetach) {
315 #if defined(HAVE_SYSLOG)
316 /* logging should be set up early in case we were restarted from exec */
319 #if defined(LOG_MAIL)
320 openlog(program_name, LOG_PID, LOG_MAIL);
322 /* Assume BSD4.2 openlog with two arguments */
323 openlog(program_name, LOG_PID);
329 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
332 /* initialize UID handling */
336 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
339 initialize_saved_lists(querylist, run.idfile);
341 #endif /* POP3_ENABLE */
343 /* construct the lockfile */
346 #ifdef HAVE_SETRLIMIT
348 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
349 * Core dumps could otherwise contain passwords to be scavenged by a
352 if (outlevel < O_VERBOSE || run.poll_interval > 0)
354 struct rlimit corelimit;
355 corelimit.rlim_cur = 0;
356 corelimit.rlim_max = 0;
357 setrlimit(RLIMIT_CORE, &corelimit);
359 #endif /* HAVE_SETRLIMIT */
361 #define NETRC_FILE ".netrc"
362 /* parse the ~/.netrc file (if present) for future password lookups. */
363 netrc_file = prependdir (NETRC_FILE, home);
364 netrc_list = parse_netrc(netrc_file);
368 /* pick up passwords where we can */
369 for (ctl = querylist; ctl; ctl = ctl->next)
371 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
373 if (NO_PASSWORD(ctl))
374 /* Server won't care what the password is, but there
375 must be some non-null string here. */
376 ctl->password = ctl->remotename;
381 /* look up the pollname and account in the .netrc file. */
382 p = search_netrc(netrc_list,
383 ctl->server.pollname, ctl->remotename);
384 /* if we find a matching entry with a password, use it */
385 if (p && p->password)
386 ctl->password = xstrdup(p->password);
388 /* otherwise try with "via" name if there is one */
389 else if (ctl->server.via)
391 p = search_netrc(netrc_list,
392 ctl->server.via, ctl->remotename);
393 if (p && p->password)
394 ctl->password = xstrdup(p->password);
400 free_netrc(netrc_list);
403 /* perhaps we just want to check options? */
406 int havercfile = access(rcfile, 0);
408 printf(GT_("Taking options from command line%s%s\n"),
409 havercfile ? "" : GT_(" and "),
410 havercfile ? "" : rcfile);
412 if (querylist == NULL)
414 GT_("No mailservers set up -- perhaps %s is missing?\n"),
417 dump_params(&run, querylist, implicitmode);
421 /* dump options as a Python dictionary, for configurator use */
424 dump_config(&run, querylist);
428 /* check for another fetchmail running concurrently */
429 pid = fm_lock_state();
431 pid = bkgd ? -pid : pid;
433 /* if no mail servers listed and nothing in background, we're done */
434 if (!quitonly && pid == 0 && querylist == NULL) {
435 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
439 /* perhaps user asked us to kill the other fetchmail */
442 if (pid == 0 || pid == getpid())
443 /* this test enables re-execing on a changed rcfile
444 * for pid == getpid() */
447 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
451 else if (kill(pid, SIGTERM) < 0)
453 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
454 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
461 if (outlevel > O_SILENT)
462 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
463 bkgd ? GT_("background") : GT_("foreground"), (long)pid);
464 /* We used to nuke the other process's lock here, with
465 * fm_lock_release(), which is broken. The other process
466 * needs to clear its lock by itself. */
470 /* wait for other process to exit */
471 maxwait = 10; /* seconds */
472 while (kill(pid, 0) == 0 && --maxwait >= 0) {
479 /* another fetchmail is running -- wake it up or die */
485 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
488 else if (!implicitmode)
491 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
498 GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
502 else if (getpid() == pid)
503 /* this test enables re-execing on a changed rcfile */
508 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
511 else if (kill(pid, SIGUSR1) == 0)
514 GT_("fetchmail: background fetchmail at %ld awakened.\n"),
521 * Should never happen -- possible only if a background fetchmail
522 * croaks after the first kill probe above but before the
523 * SIGUSR1/SIGHUP transmission.
526 GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
528 return(PS_UNDEFINED);
532 /* pick up interactively any passwords we need but don't have */
533 for (ctl = querylist; ctl; ctl = ctl->next)
535 if (ctl->active && !(implicitmode && ctl->server.skip)
536 && !NO_PASSWORD(ctl) && !ctl->password)
541 GT_("fetchmail: can't find a password for %s@%s.\n"),
542 ctl->remotename, ctl->server.pollname);
545 const char* password_prompt = GT_("Enter password for %s@%s: ");
546 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
548 tmpbuf = (char *)xmalloc(pplen);
549 snprintf(tmpbuf, pplen, password_prompt,
550 ctl->remotename, ctl->server.pollname);
551 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
558 * Time to initiate the SOCKS library (this is not mandatory: it just
559 * registers the correct application name for logging purpose. If you
560 * have some problem, comment out these lines).
563 SOCKSinit("fetchmail");
564 #endif /* HAVE_SOCKS */
566 /* avoid zombies from plugins */
569 /* Fix up log destination - if the if() is true, the precedence rule
570 * above hasn't killed off the syslog option, because the logfile
571 * option is ineffective (because we're not detached or not in
572 * deamon mode), so kill it for the benefit of other parts of the
574 if (run.logfile && run.use_syslog)
578 * Maybe time to go to demon mode...
580 if (run.poll_interval)
585 rc = daemonize(run.logfile);
587 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
591 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
594 * We'll set up a handler for these when we're sleeping,
595 * but ignore them otherwise so as not to interrupt a poll.
597 set_signal_handler(SIGUSR1, SIG_IGN);
598 if (run.poll_interval && getuid() == ROOT_UID)
599 set_signal_handler(SIGHUP, SIG_IGN);
603 /* not in daemon mode */
604 if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
606 if (!freopen(run.logfile, "a", stdout))
607 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
608 if (!freopen(run.logfile, "a", stderr))
609 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
611 report(stdout, GT_("fetchmail: Warning: syslog and logfile are set. Check both for logs!\n"));
617 /* beyond here we don't want more than one fetchmail running per user */
619 set_signal_handler(SIGABRT, terminate_run);
620 set_signal_handler(SIGINT, terminate_run);
621 set_signal_handler(SIGTERM, terminate_run);
622 set_signal_handler(SIGALRM, terminate_run);
623 set_signal_handler(SIGPIPE, SIG_IGN);
624 set_signal_handler(SIGQUIT, terminate_run);
626 /* here's the exclusion lock */
629 if (check_only && outlevel >= O_VERBOSE) {
630 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
634 * Query all hosts. If there's only one, the error return will
635 * reflect the status of that transaction.
639 * Check to see if the rcfile has been touched. If so,
640 * re-exec so the file will be reread. Doing it this way
641 * avoids all the complications of trying to deallocate the
642 * in-core control structures -- and the potential memory
647 if (strcmp(rcfile, "-") == 0) {
649 } else if (stat(rcfile, &rcstat) == -1) {
652 GT_("couldn't time-check %s (error %d)\n"),
655 else if (rcstat.st_mtime > parsetime)
657 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
660 /* restore the startup directory */
661 if (!currentwd[0] || chdir (currentwd) == -1)
662 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
666 * Matthias Andree: Isn't this prone to introduction of
667 * "false" programs by interfering with PATH? Those
668 * path-searching execs might not be the best ideas for
671 * Rob Funk: But is there any way for someone to modify
672 * the PATH variable of a running fetchmail? I don't know
675 * Dave's change makes fetchmail restart itself in exactly
676 * the way it was started from the shell (or shell script)
677 * in the first place. If you're concerned about PATH
678 * contamination, call fetchmail initially with a full
679 * path, and use Dave's patch.
681 * Not using a -p variant of exec means that the restart
682 * will break if both (a) the user depended on PATH to
683 * call fetchmail in the first place, and (b) the system
684 * doesn't save the whole path in argv[0] if the whole
685 * path wasn't used in the initial call. (If I recall
686 * correctly, Linux saves it but many other Unices don't.)
688 execvp(argv[0], argv);
689 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
692 #ifdef HAVE_RES_SEARCH
693 /* Boldly assume that we also have res_init() if we have
694 * res_search(), and call res_init() to re-read the resolv.conf
695 * file, so that we can pick up changes to that file that are
696 * written by dhpccd, dhclient, pppd, openvpn and similar. */
698 /* NOTE: This assumes that /etc/resolv.conf is written
699 * atomically (i. e. a temporary file is written, flushed and
700 * then renamed into place). To fix Debian Bug#389270. */
702 /* NOTE: If this leaks memory or doesn't re-read
703 * /etc/resolv.conf, we're in trouble. The res_init() interface
704 * is only lightly documented :-( */
710 for (ctl = querylist; ctl; ctl = ctl->next)
714 if (!(implicitmode && ctl->server.skip))
719 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
720 ctl->server.pollname);
724 /* check skip interval first so that it counts all polls */
725 if (run.poll_interval && ctl->server.interval)
727 if (ctl->server.poll_count++ % ctl->server.interval)
729 if (outlevel >= O_VERBOSE)
731 GT_("interval not reached, not querying %s\n"),
732 ctl->server.pollname);
739 * Don't do monitoring if we were woken by a signal.
740 * Note that interface_approve() does its own error logging.
742 if (!interface_approve(&ctl->server, !lastsig))
744 #endif /* CAN_MONITOR */
746 dofastuidl = 0; /* this is reset in the driver if required */
748 querystatus = query_host(ctl);
750 if (NUM_NONZERO(ctl->fastuidl))
751 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
753 /* leave the UIDL state alone if there have been any errors */
755 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
758 uid_discard_new_list(ctl);
760 #endif /* POP3_ENABLE */
762 if (querystatus == PS_SUCCESS)
764 else if (!check_only &&
765 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
769 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
771 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
773 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
775 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
777 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
779 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
781 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
783 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
785 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
787 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
789 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
791 report(stdout,GT_("Query status=11 (DNS)\n")); break;
793 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
795 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
797 report(stdout,GT_("Query status=%d\n"),querystatus);
802 if (ctl->server.monitor)
805 * Allow some time for the link to quiesce. One
806 * second is usually sufficient, three is safe.
807 * Note: this delay is important - don't remove!
810 interface_note_activity(&ctl->server);
812 #endif /* CAN_MONITOR */
816 /* close connections cleanly */
820 * OK, we've polled. Now sleep.
822 if (run.poll_interval)
825 * Because passwords can expire, it may happen that *all*
826 * hosts are now out of the loop due to authfail
827 * conditions. If this happens daemon-mode fetchmail
828 * should softly and silently vanish away, rather than
829 * spinning uselessly.
833 for (ctl = querylist; ctl; ctl = ctl->next)
834 if (ctl->active && !(implicitmode && ctl->server.skip))
839 report(stderr, GT_("All connections are wedged. Exiting.\n"));
840 /* FIXME: someday, send notification mail */
844 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
845 || outlevel > O_NORMAL)
847 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
850 * With this simple hack, we make it possible for a foreground
851 * fetchmail to wake up one in daemon mode. What we want is the
852 * side effect of interrupting any sleep that may be going on,
853 * forcing fetchmail to re-poll its hosts. The second line is
854 * for people who think all system daemons wake up on SIGHUP.
856 set_signal_handler(SIGUSR1, donothing);
857 if (getuid() == ROOT_UID)
858 set_signal_handler(SIGHUP, donothing);
861 * OK, now pause until it's time for the next poll cycle.
862 * A nonzero return indicates we received a wakeup signal;
863 * unwedge all servers in case the problem has been
866 if ((lastsig = interruptible_idle(run.poll_interval)))
868 if (outlevel > O_SILENT)
869 #ifdef SYS_SIGLIST_DECLARED
871 GT_("awakened by %s\n"), sys_siglist[lastsig]);
874 GT_("awakened by signal %d\n"), lastsig);
876 for (ctl = querylist; ctl; ctl = ctl->next)
880 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
881 || outlevel > O_NORMAL)
882 report(stdout, GT_("awakened at %s\n"), timestamp());
884 } while (run.poll_interval);
886 if (outlevel >= O_VERBOSE)
887 report(stdout, GT_("normal termination, status %d\n"),
888 successes ? PS_SUCCESS : querystatus);
894 else if (querystatus)
897 /* in case we interrupted before a successful fetch */
901 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
904 * If force is off, modify dstl fields only when they're empty (treat srcl
905 * as defaults). If force is on, modify each dstl field whenever scrcl
906 * is nonempty (treat srcl as an override).
908 if (force ? !!*srcl : !*dstl)
910 struct idlist *cpl = copy_str_list(*srcl);
912 append_str_list(dstl, &cpl);
916 static void optmerge(struct query *h2, struct query *h1, int force)
917 /* merge two options records */
919 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
920 list_merge(&h2->localnames, &h1->localnames, force);
921 list_merge(&h2->mailboxes, &h1->mailboxes, force);
922 list_merge(&h2->smtphunt, &h1->smtphunt, force);
923 list_merge(&h2->domainlist, &h1->domainlist, force);
924 list_merge(&h2->antispam, &h1->antispam, force);
926 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
927 FLAG_MERGE(server.via);
928 FLAG_MERGE(server.protocol);
929 FLAG_MERGE(server.service);
930 FLAG_MERGE(server.interval);
931 FLAG_MERGE(server.authenticate);
932 FLAG_MERGE(server.timeout);
933 FLAG_MERGE(server.envelope);
934 FLAG_MERGE(server.envskip);
935 FLAG_MERGE(server.qvirtual);
936 FLAG_MERGE(server.skip);
937 FLAG_MERGE(server.dns);
938 FLAG_MERGE(server.checkalias);
939 FLAG_MERGE(server.uidl);
940 FLAG_MERGE(server.principal);
943 FLAG_MERGE(server.interface);
944 FLAG_MERGE(server.interface_pair);
945 FLAG_MERGE(server.monitor);
948 FLAG_MERGE(server.plugin);
949 FLAG_MERGE(server.plugout);
950 FLAG_MERGE(server.tracepolls);
951 FLAG_MERGE(server.badheader);
953 FLAG_MERGE(wildcard);
954 FLAG_MERGE(remotename);
955 FLAG_MERGE(password);
958 FLAG_MERGE(listener);
959 FLAG_MERGE(smtpaddress);
960 FLAG_MERGE(smtpname);
961 FLAG_MERGE(preconnect);
962 FLAG_MERGE(postconnect);
966 FLAG_MERGE(limitflush);
967 FLAG_MERGE(fetchall);
971 FLAG_MERGE(pass8bits);
972 FLAG_MERGE(dropstatus);
973 FLAG_MERGE(dropdelivered);
974 FLAG_MERGE(mimedecode);
977 FLAG_MERGE(warnings);
978 FLAG_MERGE(fetchlimit);
979 FLAG_MERGE(fetchsizelimit);
980 FLAG_MERGE(fastuidl);
981 FLAG_MERGE(batchlimit);
982 FLAG_MERGE(retrieveerrormode);
987 FLAG_MERGE(sslproto);
988 FLAG_MERGE(sslcertck);
989 FLAG_MERGE(sslcertfile);
990 FLAG_MERGE(sslcertpath);
991 FLAG_MERGE(sslcommonname);
992 FLAG_MERGE(sslfingerprint);
996 FLAG_MERGE(properties);
1000 /** Load configuration files.
1001 * \return - true if no servers found on the command line
1002 * - false if servers found on the command line */
1003 static int load_params(int argc, char **argv, int optind)
1005 int implicitmode, st;
1007 struct query def_opts, *ctl;
1011 run.bouncemail = TRUE;
1012 run.softbounce = TRUE; /* treat permanent errors as temporary */
1013 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1015 memset(&def_opts, '\0', sizeof(struct query));
1016 def_opts.smtp_socket = -1;
1017 def_opts.smtpaddress = (char *)0;
1018 def_opts.smtpname = (char *)0;
1019 def_opts.server.protocol = P_AUTO;
1020 def_opts.server.timeout = CLIENT_TIMEOUT;
1021 def_opts.server.esmtp_name = user;
1022 def_opts.server.badheader = BHREJECT;
1023 def_opts.warnings = WARNING_INTERVAL;
1024 def_opts.remotename = user;
1025 def_opts.listener = SMTP_MODE;
1026 def_opts.fetchsizelimit = 100;
1027 def_opts.fastuidl = 4;
1029 /* get the location of rcfile */
1031 p = strrchr (rcfile, '/');
1032 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1033 *p = 0; /* replace '/' by '0' */
1034 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1035 *p = '/'; /* restore '/' */
1036 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1037 strcpy (rcfiledir, "/");
1040 /* note the parse time, so we can pick up on modifications */
1041 if (strcmp(rcfile, "-") == 0)
1042 parsetime = time(NULL);
1044 if (stat(rcfile, &rcstat) != -1)
1045 parsetime = rcstat.st_mtime;
1046 else if (errno != ENOENT)
1047 report(stderr, GT_("couldn't time-check the run-control file\n"));
1050 /* this builds the host list */
1051 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1053 * FIXME: someday, send notification mail here if backgrounded.
1054 * Right now, that can happen if the user changes the rcfile
1055 * while the fetchmail is running in background. Do similarly
1056 * for the other exit() calls in this function.
1060 if ((implicitmode = (optind >= argc)))
1062 for (ctl = querylist; ctl; ctl = ctl->next)
1063 ctl->active = !ctl->server.skip;
1066 for (; optind < argc; optind++)
1068 flag predeclared = FALSE;
1071 * If hostname corresponds to a host known from the rc file,
1072 * simply declare it active. Otherwise synthesize a host
1073 * record from command line and defaults
1075 for (ctl = querylist; ctl; ctl = ctl->next)
1076 if (!strcmp(ctl->server.pollname, argv[optind])
1077 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1079 /* Is this correct? */
1080 if (predeclared && outlevel >= O_VERBOSE)
1081 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1089 * Allocate and link record without copying in
1090 * command-line args; we'll do that with the optmerge
1093 ctl = hostalloc((struct query *)NULL);
1095 ctl->server.pollname = xstrdup(argv[optind]);
1097 ctl->server.lead_server = (struct hostdata *)NULL;
1102 * If there's a defaults record, merge it and lose it.
1103 * FIXME: we don't currently free all entries that might be in struct query.
1105 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1109 for (ctl = querylist->next; ctl; ctl = ctl->next)
1110 optmerge(ctl, querylist, FALSE);
1112 querylist = querylist->next;
1113 free(tmpq->server.pollname);
1117 /* don't allow a defaults record after the first */
1118 for (ctl = querylist; ctl; ctl = ctl->next) {
1119 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1120 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1125 /* use localhost if we never fetch the FQDN of this host */
1126 fetchmailhost = "localhost";
1128 /* here's where we override globals */
1129 if (cmd_run.logfile)
1130 run.logfile = cmd_run.logfile;
1132 run.idfile = cmd_run.idfile;
1133 if (cmd_run.pidfile)
1134 run.pidfile = cmd_run.pidfile;
1135 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1136 if (cmd_run.poll_interval >= 0)
1137 run.poll_interval = cmd_run.poll_interval;
1138 if (cmd_run.invisible)
1139 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1140 if (cmd_run.showdots)
1141 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1142 if (cmd_run.use_syslog)
1143 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1144 if (cmd_run.postmaster)
1145 run.postmaster = cmd_run.postmaster;
1146 if (cmd_run.bouncemail)
1147 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1148 if (cmd_run.softbounce)
1149 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1151 /* check and daemon options are not compatible */
1152 if (check_only && run.poll_interval)
1153 run.poll_interval = 0;
1156 * DNS support is required for some protocols. We used to
1157 * do this unconditionally, but it made fetchmail excessively
1158 * vulnerable to misconfigured DNS setups.
1160 * If we're using ETRN or ODMR, the smtp hunt list is the
1161 * list of systems we're polling on behalf of; these have
1162 * to be fully-qualified domain names. The default for
1163 * this list should be the FQDN of localhost.
1165 * If we're using Kerberos for authentication, we need
1166 * the FQDN in order to generate capability keys.
1168 for (ctl = querylist; ctl; ctl = ctl->next)
1170 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1171 || ctl->server.authenticate == A_KERBEROS_V4
1172 || ctl->server.authenticate == A_KERBEROS_V5))
1174 fetchmailhost = host_fqdn(1);
1178 if (!ctl) /* list exhausted */
1179 fetchmailhost = host_fqdn(0);
1181 /* this code enables flags to be turned off */
1182 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1184 else if (flag == FLAG_FALSE)\
1189 /* merge in wired defaults, do sanity checks and prepare internal fields */
1190 for (ctl = querylist; ctl; ctl = ctl->next)
1192 ctl->wedged = FALSE;
1194 /* merge in defaults */
1195 optmerge(ctl, &def_opts, FALSE);
1197 /* force command-line options */
1198 optmerge(ctl, &cmd_opts, TRUE);
1201 * queryname has to be set up for inactive servers too.
1202 * Otherwise the UIDL code core-dumps on startup.
1204 if (ctl->server.via)
1205 ctl->server.queryname = xstrdup(ctl->server.via);
1207 ctl->server.queryname = xstrdup(ctl->server.pollname);
1210 * We no longer do DNS lookups at startup.
1211 * This is a kluge. It enables users to edit their
1212 * configurations when DNS isn't available.
1214 ctl->server.truename = xstrdup(ctl->server.queryname);
1216 if (configdump || ctl->active )
1218 DEFAULT(ctl->keep, FALSE);
1219 DEFAULT(ctl->fetchall, FALSE);
1220 DEFAULT(ctl->flush, FALSE);
1221 DEFAULT(ctl->limitflush, FALSE);
1222 DEFAULT(ctl->rewrite, TRUE);
1223 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1224 DEFAULT(ctl->forcecr, FALSE);
1225 DEFAULT(ctl->pass8bits, FALSE);
1226 DEFAULT(ctl->dropstatus, FALSE);
1227 DEFAULT(ctl->dropdelivered, FALSE);
1228 DEFAULT(ctl->mimedecode, FALSE);
1229 DEFAULT(ctl->idle, FALSE);
1230 DEFAULT(ctl->server.dns, TRUE);
1231 DEFAULT(ctl->server.uidl, FALSE);
1232 DEFAULT(ctl->use_ssl, FALSE);
1233 DEFAULT(ctl->sslcertck, FALSE);
1234 DEFAULT(ctl->server.checkalias, FALSE);
1237 * XXX FIXME: do we need this check or can we rely on the .y
1238 * parser handling this?
1242 report(stderr, GT_("SSL support is not compiled in.\n"));
1245 #endif /* SSL_ENABLE */
1248 if (ctl->server.authenticate == A_KERBEROS_V4) {
1249 report(stderr, GT_("KERBEROS v4 support is configured, but not compiled in.\n"));
1254 if (ctl->server.authenticate == A_KERBEROS_V5) {
1255 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1260 if (ctl->server.authenticate == A_GSSAPI) {
1261 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1267 * Make sure we have a nonempty host list to forward to.
1270 save_str(&ctl->smtphunt, "localhost", FALSE);
1273 * Make sure we have a nonempty list of domains to fetch from.
1275 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1276 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1278 /* if `user' doesn't name a real local user, try to run as root */
1279 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1282 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1283 if (!ctl->localnames) /* for local delivery via SMTP */
1284 save_str_pair(&ctl->localnames, user, NULL);
1286 #ifndef HAVE_RES_SEARCH
1287 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1288 if (MULTIDROP(ctl) && ctl->server.dns)
1290 ctl->server.dns = FALSE;
1291 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1293 #endif /* !HAVE_RES_SEARCH */
1296 * can't handle multidrop mailboxes without "envelope"
1297 * option, this causes truckloads full of support complaints
1298 * "all mail forwarded to postmaster"
1300 if (MULTIDROP(ctl) && !ctl->server.envelope)
1302 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1303 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1306 /* if no folders were specified, set up the null one as default */
1307 if (!ctl->mailboxes)
1308 save_str(&ctl->mailboxes, (char *)NULL, 0);
1310 /* maybe user overrode timeout on command line? */
1311 if (ctl->server.timeout == -1)
1312 ctl->server.timeout = CLIENT_TIMEOUT;
1315 if (ctl->server.service) {
1316 int port = servport(ctl->server.service);
1319 (void) fprintf(stderr,
1320 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1321 ctl->server.pollname);
1324 if (ctl->server.protocol == P_RPOP && port >= 1024)
1326 (void) fprintf(stderr,
1327 GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1328 ctl->server.pollname);
1332 if (ctl->listener == LMTP_MODE)
1336 for (idp = ctl->smtphunt; idp; idp = idp->next)
1340 if (!(cp = strrchr(idp->id, '/'))
1341 || (0 == strcmp(cp + 1, SMTP_PORT))
1342 || servport(cp + 1) == SMTP_PORT_NUM)
1344 (void) fprintf(stderr,
1345 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1346 ctl->server.pollname);
1353 * "I beg to you, have mercy on the we[a]k minds like myself."
1354 * wrote Pehr Anderson. Your petition is granted.
1356 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1358 (void) fprintf(stderr,
1359 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1365 * If the user didn't set a last-resort user to get misaddressed
1366 * multidrop mail, set an appropriate default here.
1368 if (!run.postmaster)
1370 if (getuid() != ROOT_UID) /* ordinary user */
1371 run.postmaster = user;
1373 run.postmaster = "postmaster";
1376 return(implicitmode);
1379 static RETSIGTYPE terminate_poll(int sig)
1380 /* to be executed at the end of a poll cycle */
1384 report(stdout, GT_("terminated with signal %d\n"), sig);
1388 * Update UID information at end of each poll, rather than at end
1389 * of run, because that way we don't lose all UIDL information since
1390 * the beginning of time if fetchmail crashes.
1393 write_saved_lists(querylist, run.idfile);
1394 #endif /* POP3_ENABLE */
1397 static RETSIGTYPE terminate_run(int sig)
1398 /* to be executed on normal or signal-induced termination */
1402 terminate_poll(sig);
1405 * Craig Metz, the RFC1938 one-time-password guy, points out:
1406 * "Remember that most kernels don't zero pages before handing them to the
1407 * next process and many kernels share pages between user and kernel space.
1408 * You'd be very surprised what you can find from a short program to do a
1409 * malloc() and then dump the contents of the pages you got. By zeroing
1410 * the secrets at end of run (earlier if you can), you make sure the next
1411 * guy can't get the password/pass phrase."
1413 * Right you are, Craig!
1415 for (ctl = querylist; ctl; ctl = ctl->next)
1417 memset(ctl->password, '\0', strlen(ctl->password));
1419 #if !defined(HAVE_ATEXIT)
1423 if (activecount == 0)
1426 exit(successes ? PS_SUCCESS : querystatus);
1430 * Sequence of protocols to try when autoprobing, most capable to least.
1432 static const int autoprobe[] =
1436 #endif /* IMAP_ENABLE */
1439 #endif /* POP3_ENABLE */
1442 #endif /* POP2_ENABLE */
1445 static int query_host(struct query *ctl)
1446 /* perform fetch transaction with single host */
1452 * If we're syslogging the progress messages are automatically timestamped.
1453 * Force timestamping if we're going to a logfile.
1455 if (outlevel >= O_VERBOSE)
1457 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1459 ctl->server.pollname,
1460 showproto(ctl->server.protocol),
1464 switch (ctl->server.protocol) {
1466 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1468 ctl->server.protocol = autoprobe[i];
1470 st = query_host(ctl);
1473 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1476 ctl->server.protocol = P_AUTO;
1482 report(stderr, GT_("POP2 support is not configured.\n"));
1484 #endif /* POP2_ENABLE */
1492 } while (st == PS_REPOLL);
1494 report(stderr, GT_("POP3 support is not configured.\n"));
1496 #endif /* POP3_ENABLE */
1502 } while (st == PS_REPOLL);
1504 report(stderr, GT_("IMAP support is not configured.\n"));
1506 #endif /* IMAP_ENABLE */
1510 report(stderr, GT_("ETRN support is not configured.\n"));
1515 #endif /* ETRN_ENABLE */
1518 report(stderr, GT_("ODMR support is not configured.\n"));
1522 #endif /* ODMR_ENABLE */
1525 report(stderr, GT_("unsupported protocol selected.\n"));
1530 * If we're syslogging the progress messages are automatically timestamped.
1531 * Force timestamping if we're going to a logfile.
1533 if (outlevel >= O_VERBOSE)
1535 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1537 ctl->server.pollname,
1538 showproto(ctl->server.protocol),
1545 static void dump_params (struct runctl *runp,
1546 struct query *querylist, flag implicit)
1547 /* display query parameters in English */
1551 if (runp->poll_interval)
1552 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1554 printf(GT_("Logfile is %s\n"), runp->logfile);
1555 if (strcmp(runp->idfile, IDFILE_NAME))
1556 printf(GT_("Idfile is %s\n"), runp->idfile);
1557 #if defined(HAVE_SYSLOG)
1558 if (runp->use_syslog)
1559 printf(GT_("Progress messages will be logged via syslog\n"));
1561 if (runp->invisible)
1562 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1564 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1565 if (runp->postmaster)
1566 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1569 if (!runp->bouncemail)
1570 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1571 else if (outlevel >= O_VERBOSE)
1572 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1574 if (!runp->softbounce)
1575 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1576 else if (outlevel >= O_VERBOSE)
1577 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1579 for (ctl = querylist; ctl; ctl = ctl->next)
1581 if (!ctl->active || (implicit && ctl->server.skip))
1584 printf(GT_("Options for retrieving from %s@%s:\n"),
1585 ctl->remotename, visbuf(ctl->server.pollname));
1587 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1588 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1590 if (ctl->server.interval)
1591 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1592 " Poll of this server will occur every %d intervals.\n",
1593 ctl->server.interval), ctl->server.interval);
1594 if (ctl->server.truename)
1595 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1596 if (ctl->server.skip || outlevel >= O_VERBOSE)
1597 printf(ctl->server.skip
1598 ? GT_(" This host will not be queried when no host is specified.\n")
1599 : GT_(" This host will be queried when no host is specified.\n"));
1600 if (!NO_PASSWORD(ctl))
1603 printf(GT_(" Password will be prompted for.\n"));
1604 else if (outlevel >= O_VERBOSE)
1606 if (ctl->server.protocol == P_APOP)
1607 printf(GT_(" APOP secret = \"%s\".\n"),
1608 visbuf(ctl->password));
1609 else if (ctl->server.protocol == P_RPOP)
1610 printf(GT_(" RPOP id = \"%s\".\n"),
1611 visbuf(ctl->password));
1613 printf(GT_(" Password = \"%s\".\n"),
1614 visbuf(ctl->password));
1618 if (ctl->server.protocol == P_POP3
1619 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1620 && (ctl->server.authenticate == A_KERBEROS_V4 ||
1621 ctl->server.authenticate == A_KERBEROS_V5))
1622 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1623 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1625 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1626 if (ctl->server.service)
1627 printf(GT_(" (using service %s)"), ctl->server.service);
1628 else if (outlevel >= O_VERBOSE)
1629 printf(GT_(" (using default port)"));
1630 if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1631 printf(GT_(" (forcing UIDL use)"));
1634 switch (ctl->server.authenticate)
1637 printf(GT_(" All available authentication methods will be tried.\n"));
1640 printf(GT_(" Password authentication will be forced.\n"));
1643 printf(GT_(" MSN authentication will be forced.\n"));
1646 printf(GT_(" NTLM authentication will be forced.\n"));
1649 printf(GT_(" OTP authentication will be forced.\n"));
1652 printf(GT_(" CRAM-Md5 authentication will be forced.\n"));
1655 printf(GT_(" GSSAPI authentication will be forced.\n"));
1658 printf(GT_(" Kerberos V4 authentication will be forced.\n"));
1661 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1664 printf(GT_(" End-to-end encryption assumed.\n"));
1667 if (ctl->server.principal != (char *) NULL)
1668 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1671 printf(GT_(" SSL encrypted sessions enabled.\n"));
1673 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
1674 if (ctl->sslcertck) {
1675 printf(GT_(" SSL server certificate checking enabled.\n"));
1677 if (ctl->sslcertfile != NULL)
1678 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
1679 if (ctl->sslcertpath != NULL)
1680 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1681 if (ctl->sslcommonname != NULL)
1682 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
1683 if (ctl->sslfingerprint != NULL)
1684 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1686 if (ctl->server.timeout > 0)
1687 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1688 if (ctl->server.timeout == CLIENT_TIMEOUT)
1689 printf(GT_(" (default).\n"));
1693 if (MAILBOX_PROTOCOL(ctl))
1695 if (!ctl->mailboxes->id)
1696 printf(GT_(" Default mailbox selected.\n"));
1701 printf(GT_(" Selected mailboxes are:"));
1702 for (idp = ctl->mailboxes; idp; idp = idp->next)
1703 printf(" %s", idp->id);
1706 printf(ctl->fetchall
1707 ? GT_(" All messages will be retrieved (--all on).\n")
1708 : GT_(" Only new messages will be retrieved (--all off).\n"));
1710 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
1711 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
1713 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
1714 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
1715 printf(ctl->limitflush
1716 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1717 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1719 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
1720 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1722 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
1723 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
1725 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
1726 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
1727 printf(ctl->pass8bits
1728 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1729 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1730 printf(ctl->mimedecode
1731 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
1732 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
1734 ? GT_(" Idle after poll is enabled (idle on).\n")
1735 : GT_(" Idle after poll is disabled (idle off).\n"));
1736 printf(ctl->dropstatus
1737 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
1738 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
1739 printf(ctl->dropdelivered
1740 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
1741 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
1742 if (NUM_NONZERO(ctl->limit))
1744 if (NUM_NONZERO(ctl->limit))
1745 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
1746 ctl->limit, ctl->limit);
1747 else if (outlevel >= O_VERBOSE)
1748 printf(GT_(" No message size limit (--limit 0).\n"));
1749 if (run.poll_interval > 0)
1750 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1751 ctl->warnings, ctl->warnings);
1752 else if (outlevel >= O_VERBOSE)
1753 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
1755 if (NUM_NONZERO(ctl->fetchlimit))
1756 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
1757 ctl->fetchlimit, ctl->fetchlimit);
1758 else if (outlevel >= O_VERBOSE)
1759 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
1760 if (NUM_NONZERO(ctl->fetchsizelimit))
1761 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1762 ctl->fetchsizelimit, ctl->fetchsizelimit);
1763 else if (outlevel >= O_VERBOSE)
1764 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
1765 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1767 if (ctl->fastuidl == 1)
1768 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1770 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1772 else if (outlevel >= O_VERBOSE)
1773 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1774 if (NUM_NONZERO(ctl->batchlimit))
1775 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1776 else if (outlevel >= O_VERBOSE)
1777 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
1778 if (MAILBOX_PROTOCOL(ctl))
1780 if (NUM_NONZERO(ctl->expunge))
1781 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1782 else if (outlevel >= O_VERBOSE)
1783 printf(GT_(" No forced expunges (--expunge 0).\n"));
1786 else /* ODMR or ETRN */
1790 printf(GT_(" Domains for which mail will be fetched are:"));
1791 for (idp = ctl->domainlist; idp; idp = idp->next)
1793 printf(" %s", idp->id);
1794 if (!idp->val.status.mark)
1795 printf(GT_(" (default)"));
1800 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1801 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1802 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1809 printf(GT_(" Messages will be %cMTP-forwarded to:"),
1811 for (idp = ctl->smtphunt; idp; idp = idp->next)
1813 printf(" %s", idp->id);
1814 if (!idp->val.status.mark)
1815 printf(GT_(" (default)"));
1819 if (ctl->smtpaddress)
1820 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
1823 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1826 if (MAILBOX_PROTOCOL(ctl))
1828 if (ctl->antispam != (struct idlist *)NULL)
1832 printf(GT_(" Recognized listener spam block responses are:"));
1833 for (idp = ctl->antispam; idp; idp = idp->next)
1834 printf(" %d", idp->val.status.num);
1837 else if (outlevel >= O_VERBOSE)
1838 printf(GT_(" Spam-blocking disabled\n"));
1840 if (ctl->preconnect)
1841 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
1842 visbuf(ctl->preconnect));
1843 else if (outlevel >= O_VERBOSE)
1844 printf(GT_(" No pre-connection command.\n"));
1845 if (ctl->postconnect)
1846 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
1847 visbuf(ctl->postconnect));
1848 else if (outlevel >= O_VERBOSE)
1849 printf(GT_(" No post-connection command.\n"));
1850 if (MAILBOX_PROTOCOL(ctl)) {
1851 if (!ctl->localnames)
1852 printf(GT_(" No localnames declared for this host.\n"));
1858 for (idp = ctl->localnames; idp; idp = idp->next)
1861 if (count > 1 || ctl->wildcard)
1862 printf(GT_(" Multi-drop mode: "));
1864 printf(GT_(" Single-drop mode: "));
1866 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1867 if (outlevel >= O_VERBOSE)
1869 for (idp = ctl->localnames; idp; idp = idp->next)
1871 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1873 printf("\t%s\n", idp->id);
1875 fputs("\t*\n", stdout);
1878 if (count > 1 || ctl->wildcard)
1880 printf(ctl->server.dns
1881 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
1882 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
1883 if (ctl->server.dns)
1885 if (ctl->server.checkalias)
1886 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
1888 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
1890 if (ctl->server.envelope == STRING_DISABLED)
1891 printf(GT_(" Envelope-address routing is disabled\n"));
1894 printf(GT_(" Envelope header is assumed to be: %s\n"),
1895 ctl->server.envelope ? ctl->server.envelope : "Received");
1896 if (ctl->server.envskip || outlevel >= O_VERBOSE)
1897 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
1898 ctl->server.envskip);
1899 if (ctl->server.qvirtual)
1900 printf(GT_(" Prefix %s will be removed from user id\n"),
1901 ctl->server.qvirtual);
1902 else if (outlevel >= O_VERBOSE)
1903 printf(GT_(" No prefix stripping\n"));
1906 if (ctl->server.akalist)
1908 printf(GT_(" Predeclared mailserver aliases:"));
1909 for (idp = ctl->server.akalist; idp; idp = idp->next)
1910 printf(" %s", idp->id);
1914 if (ctl->server.localdomains)
1916 printf(GT_(" Local domains:"));
1917 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1918 printf(" %s", idp->id);
1925 if (ctl->server.interface)
1926 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
1927 else if (outlevel >= O_VERBOSE)
1928 printf(GT_(" No interface requirement specified.\n"));
1929 if (ctl->server.monitor)
1930 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1931 else if (outlevel >= O_VERBOSE)
1932 printf(GT_(" No monitor interface specified.\n"));
1935 if (ctl->server.plugin)
1936 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1937 else if (outlevel >= O_VERBOSE)
1938 printf(GT_(" No plugin command specified.\n"));
1939 if (ctl->server.plugout)
1940 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1941 else if (outlevel >= O_VERBOSE)
1942 printf(GT_(" No plugout command specified.\n"));
1944 if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1947 printf(GT_(" No UIDs saved from this host.\n"));
1953 for (idp = ctl->oldsaved; idp; idp = idp->next)
1956 printf(GT_(" %d UIDs saved.\n"), count);
1957 if (outlevel >= O_VERBOSE)
1958 for (idp = ctl->oldsaved; idp; idp = idp->next)
1959 printf("\t%s\n", idp->id);
1963 if (ctl->server.tracepolls)
1964 printf(GT_(" Poll trace information will be added to the Received header.\n"));
1965 else if (outlevel >= O_VERBOSE)
1966 printf(GT_(" No poll trace information will be added to the Received header.\n"));
1968 switch (ctl->server.badheader) {
1970 if (outlevel >= O_VERBOSE)
1971 printf(GT_(" Messages with bad headers will be rejected.\n"));
1974 printf(GT_(" Messages with bad headers will be passed on.\n"));
1978 if (ctl->properties)
1979 printf(GT_(" Pass-through properties \"%s\".\n"),
1980 visbuf(ctl->properties));
1984 /* fetchmail.c ends here */