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"));
148 const char *iana_charset;
150 int main(int argc, char **argv)
153 int implicitmode = FALSE;
155 netrc_entry *netrc_list;
156 char *netrc_file, *tmpbuf;
160 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
164 envquery(argc, argv);
166 setlocale (LC_ALL, "");
167 bindtextdomain(PACKAGE, LOCALEDIR);
169 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
173 iana_charset = "US-ASCII";
177 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
181 * Note: because we can't initialize reporting before we know whether
182 * syslog is supposed to be on, this message will go to stdout and
183 * be lost when running in background.
185 if (outlevel >= O_VERBOSE)
189 report(stdout, GT_("fetchmail: invoked with"));
190 for (i = 0; i < argc; i++)
191 report(stdout, " %s", argv[i]);
192 report(stdout, "\n");
195 #define IDFILE_NAME ".fetchids"
196 run.idfile = prependdir (IDFILE_NAME, fmhome);
201 * We used to arrange for the lock to be removed on exit close
202 * to where the lock was asserted. Now we need to do it here, because
203 * we might have re-executed in background with an existing lock
204 * as the result of a changed rcfile (see the code near the execvp(3)
205 * call near the beginning of the polling loop for details). We want
206 * to be sure the lock gets nuked on any error exit, basically.
211 /* save the current directory */
212 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
213 report(stderr, GT_("could not get current working directory\n"));
221 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts);
225 if (quitmode && quitind == argc)
231 const char *features =
234 #endif /* POP2_ENABLE */
237 #endif /* POP3_ENABLE */
240 #endif /* IMAP_ENABLE */
246 #endif /* RPA_ENABLE */
249 #endif /* NTLM_ENABLE */
252 #endif /* SDPS_ENABLE */
255 #endif /* ETRN_ENABLE */
258 #endif /* ODMR_ENABLE */
264 #endif /* OPIE_ENABLE */
265 #ifdef HAVE_PKG_hesiod
270 #endif /* HAVE_SOCKS */
273 #endif /* ENABLE_NLS */
276 #endif /* KERBEROS_V4 */
279 #endif /* KERBEROS_V5 */
280 #ifndef HAVE_RES_SEARCH
284 printf(GT_("This is fetchmail release %s"), VERSION);
285 fputs(features, stdout);
287 printcopyright(stdout);
289 fputs("Fallback MDA: ", stdout);
291 fputs(FALLBACK_MDA, stdout);
293 fputs("(none)", stdout);
298 /* this is an attempt to help remote debugging */
299 if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
302 /* avoid parsing the config file if all we're doing is killing a daemon */
304 implicitmode = load_params(argc, argv, optind);
306 /* precedence: logfile (if effective) overrides syslog. */
307 if (run.logfile && run.poll_interval && !nodetach) {
311 #if defined(HAVE_SYSLOG)
312 /* logging should be set up early in case we were restarted from exec */
315 #if defined(LOG_MAIL)
316 openlog(program_name, LOG_PID, LOG_MAIL);
318 /* Assume BSD4.2 openlog with two arguments */
319 openlog(program_name, LOG_PID);
325 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
328 /* initialize UID handling */
332 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
335 initialize_saved_lists(querylist, run.idfile);
337 #endif /* POP3_ENABLE */
339 /* construct the lockfile */
342 #ifdef HAVE_SETRLIMIT
344 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
345 * Core dumps could otherwise contain passwords to be scavenged by a
348 if (outlevel < O_VERBOSE || run.poll_interval > 0)
350 struct rlimit corelimit;
351 corelimit.rlim_cur = 0;
352 corelimit.rlim_max = 0;
353 setrlimit(RLIMIT_CORE, &corelimit);
355 #endif /* HAVE_SETRLIMIT */
357 #define NETRC_FILE ".netrc"
358 /* parse the ~/.netrc file (if present) for future password lookups. */
359 netrc_file = prependdir (NETRC_FILE, home);
360 netrc_list = parse_netrc(netrc_file);
364 /* pick up passwords where we can */
365 for (ctl = querylist; ctl; ctl = ctl->next)
367 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
369 if (NO_PASSWORD(ctl))
370 /* Server won't care what the password is, but there
371 must be some non-null string here. */
372 ctl->password = ctl->remotename;
377 /* look up the pollname and account in the .netrc file. */
378 p = search_netrc(netrc_list,
379 ctl->server.pollname, ctl->remotename);
380 /* if we find a matching entry with a password, use it */
381 if (p && p->password)
382 ctl->password = xstrdup(p->password);
384 /* otherwise try with "via" name if there is one */
385 else if (ctl->server.via)
387 p = search_netrc(netrc_list,
388 ctl->server.via, ctl->remotename);
389 if (p && p->password)
390 ctl->password = xstrdup(p->password);
396 free_netrc(netrc_list);
399 /* perhaps we just want to check options? */
402 int havercfile = access(rcfile, 0);
404 printf(GT_("Taking options from command line%s%s\n"),
405 havercfile ? "" : GT_(" and "),
406 havercfile ? "" : rcfile);
408 if (querylist == NULL)
410 GT_("No mailservers set up -- perhaps %s is missing?\n"),
413 dump_params(&run, querylist, implicitmode);
417 /* dump options as a Python dictionary, for configurator use */
420 dump_config(&run, querylist);
424 /* check for another fetchmail running concurrently */
425 pid = fm_lock_state();
427 pid = bkgd ? -pid : pid;
429 /* if no mail servers listed and nothing in background, we're done */
430 if (!quitonly && pid == 0 && querylist == NULL) {
431 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
435 /* perhaps user asked us to kill the other fetchmail */
438 if (pid == 0 || pid == getpid())
439 /* this test enables re-execing on a changed rcfile
440 * for pid == getpid() */
443 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
447 else if (kill(pid, SIGTERM) < 0)
449 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
450 bkgd ? GT_("background") : GT_("foreground"), pid);
457 if (outlevel > O_SILENT)
458 fprintf(stderr,GT_("fetchmail: %s fetchmail at %d killed.\n"),
459 bkgd ? GT_("background") : GT_("foreground"), pid);
460 /* We used to nuke the other process's lock here, with
461 * fm_lock_release(), which is broken. The other process
462 * needs to clear its lock by itself. */
466 /* wait for other process to exit */
467 maxwait = 10; /* seconds */
468 while (kill(pid, 0) == 0 && --maxwait >= 0) {
475 /* another fetchmail is running -- wake it up or die */
481 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
484 else if (!implicitmode)
487 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
494 GT_("fetchmail: another foreground fetchmail is running at %d.\n"),
498 else if (getpid() == pid)
499 /* this test enables re-execing on a changed rcfile */
504 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
507 else if (kill(pid, SIGUSR1) == 0)
510 GT_("fetchmail: background fetchmail at %d awakened.\n"),
517 * Should never happen -- possible only if a background fetchmail
518 * croaks after the first kill probe above but before the
519 * SIGUSR1/SIGHUP transmission.
522 GT_("fetchmail: elder sibling at %d died mysteriously.\n"),
524 return(PS_UNDEFINED);
528 /* pick up interactively any passwords we need but don't have */
529 for (ctl = querylist; ctl; ctl = ctl->next)
531 if (ctl->active && !(implicitmode && ctl->server.skip)
532 && !NO_PASSWORD(ctl) && !ctl->password)
537 GT_("fetchmail: can't find a password for %s@%s.\n"),
538 ctl->remotename, ctl->server.pollname);
541 const char* password_prompt = GT_("Enter password for %s@%s: ");
542 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
544 tmpbuf = (char *)xmalloc(pplen);
545 snprintf(tmpbuf, pplen, password_prompt,
546 ctl->remotename, ctl->server.pollname);
547 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
554 * Time to initiate the SOCKS library (this is not mandatory: it just
555 * registers the correct application name for logging purpose. If you
556 * have some problem, comment out these lines).
559 SOCKSinit("fetchmail");
560 #endif /* HAVE_SOCKS */
562 /* avoid zombies from plugins */
565 /* Fix up log destination - if the if() is true, the precedence rule
566 * above hasn't killed off the syslog option, because the logfile
567 * option is ineffective (because we're not detached or not in
568 * deamon mode), so kill it for the benefit of other parts of the
570 if (run.logfile && run.use_syslog)
574 * Maybe time to go to demon mode...
576 if (run.poll_interval)
581 rc = daemonize(run.logfile);
583 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
587 report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
590 * We'll set up a handler for these when we're sleeping,
591 * but ignore them otherwise so as not to interrupt a poll.
593 set_signal_handler(SIGUSR1, SIG_IGN);
594 if (run.poll_interval && getuid() == ROOT_UID)
595 set_signal_handler(SIGHUP, SIG_IGN);
599 /* not in daemon mode */
600 if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
602 if (!freopen(run.logfile, "a", stdout))
603 report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
604 if (!freopen(run.logfile, "a", stderr))
605 report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
607 report(stdout, GT_("fetchmail: Warning: syslog and logfile are set. Check both for logs!\n"));
613 /* beyond here we don't want more than one fetchmail running per user */
615 set_signal_handler(SIGABRT, terminate_run);
616 set_signal_handler(SIGINT, terminate_run);
617 set_signal_handler(SIGTERM, terminate_run);
618 set_signal_handler(SIGALRM, terminate_run);
619 set_signal_handler(SIGPIPE, SIG_IGN);
620 set_signal_handler(SIGQUIT, terminate_run);
622 /* here's the exclusion lock */
625 if (check_only && outlevel >= O_VERBOSE) {
626 report(stdout, GT_("--check mode enabled, not fetching mail\n"));
630 * Query all hosts. If there's only one, the error return will
631 * reflect the status of that transaction.
635 * Check to see if the rcfile has been touched. If so,
636 * re-exec so the file will be reread. Doing it this way
637 * avoids all the complications of trying to deallocate the
638 * in-core control structures -- and the potential memory
643 if (strcmp(rcfile, "-") == 0) {
645 } else if (stat(rcfile, &rcstat) == -1) {
648 GT_("couldn't time-check %s (error %d)\n"),
651 else if (rcstat.st_mtime > parsetime)
653 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
656 /* restore the startup directory */
657 if (!currentwd[0] || chdir (currentwd) == -1)
658 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
662 * Matthias Andree: Isn't this prone to introduction of
663 * "false" programs by interfering with PATH? Those
664 * path-searching execs might not be the best ideas for
667 * Rob Funk: But is there any way for someone to modify
668 * the PATH variable of a running fetchmail? I don't know
671 * Dave's change makes fetchmail restart itself in exactly
672 * the way it was started from the shell (or shell script)
673 * in the first place. If you're concerned about PATH
674 * contamination, call fetchmail initially with a full
675 * path, and use Dave's patch.
677 * Not using a -p variant of exec means that the restart
678 * will break if both (a) the user depended on PATH to
679 * call fetchmail in the first place, and (b) the system
680 * doesn't save the whole path in argv[0] if the whole
681 * path wasn't used in the initial call. (If I recall
682 * correctly, Linux saves it but many other Unices don't.)
684 execvp(argv[0], argv);
685 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
688 #ifdef HAVE_RES_SEARCH
689 /* Boldly assume that we also have res_init() if we have
690 * res_search(), and call res_init() to re-read the resolv.conf
691 * file, so that we can pick up changes to that file that are
692 * written by dhpccd, dhclient, pppd, openvpn and similar. */
694 /* NOTE: This assumes that /etc/resolv.conf is written
695 * atomically (i. e. a temporary file is written, flushed and
696 * then renamed into place). To fix Debian Bug#389270. */
698 /* NOTE: If this leaks memory or doesn't re-read
699 * /etc/resolv.conf, we're in trouble. The res_init() interface
700 * is only lightly documented :-( */
706 for (ctl = querylist; ctl; ctl = ctl->next)
710 if (!(implicitmode && ctl->server.skip))
715 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
716 ctl->server.pollname);
720 /* check skip interval first so that it counts all polls */
721 if (run.poll_interval && ctl->server.interval)
723 if (ctl->server.poll_count++ % ctl->server.interval)
725 if (outlevel >= O_VERBOSE)
727 GT_("interval not reached, not querying %s\n"),
728 ctl->server.pollname);
735 * Don't do monitoring if we were woken by a signal.
736 * Note that interface_approve() does its own error logging.
738 if (!interface_approve(&ctl->server, !lastsig))
740 #endif /* CAN_MONITOR */
742 dofastuidl = 0; /* this is reset in the driver if required */
744 querystatus = query_host(ctl);
746 if (NUM_NONZERO(ctl->fastuidl))
747 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
749 /* leave the UIDL state alone if there have been any errors */
751 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
754 uid_discard_new_list(ctl);
756 #endif /* POP3_ENABLE */
758 if (querystatus == PS_SUCCESS)
760 else if (!check_only &&
761 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
765 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
767 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
769 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
771 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
773 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
775 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
777 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
779 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
781 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
783 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
785 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
787 report(stdout,GT_("Query status=11 (DNS)\n")); break;
789 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
791 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
793 report(stdout,GT_("Query status=%d\n"),querystatus);
798 if (ctl->server.monitor)
801 * Allow some time for the link to quiesce. One
802 * second is usually sufficient, three is safe.
803 * Note: this delay is important - don't remove!
806 interface_note_activity(&ctl->server);
808 #endif /* CAN_MONITOR */
812 /* close connections cleanly */
816 * OK, we've polled. Now sleep.
818 if (run.poll_interval)
821 * Because passwords can expire, it may happen that *all*
822 * hosts are now out of the loop due to authfail
823 * conditions. If this happens daemon-mode fetchmail
824 * should softly and silently vanish away, rather than
825 * spinning uselessly.
829 for (ctl = querylist; ctl; ctl = ctl->next)
830 if (ctl->active && !(implicitmode && ctl->server.skip))
835 report(stderr, GT_("All connections are wedged. Exiting.\n"));
836 /* FIXME: someday, send notification mail */
840 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
841 || outlevel > O_NORMAL)
843 GT_("sleeping at %s for %d seconds\n"), timestamp(), run.poll_interval);
846 * With this simple hack, we make it possible for a foreground
847 * fetchmail to wake up one in daemon mode. What we want is the
848 * side effect of interrupting any sleep that may be going on,
849 * forcing fetchmail to re-poll its hosts. The second line is
850 * for people who think all system daemons wake up on SIGHUP.
852 set_signal_handler(SIGUSR1, donothing);
853 if (getuid() == ROOT_UID)
854 set_signal_handler(SIGHUP, donothing);
857 * OK, now pause until it's time for the next poll cycle.
858 * A nonzero return indicates we received a wakeup signal;
859 * unwedge all servers in case the problem has been
862 if ((lastsig = interruptible_idle(run.poll_interval)))
864 if (outlevel > O_SILENT)
865 #ifdef SYS_SIGLIST_DECLARED
867 GT_("awakened by %s\n"), sys_siglist[lastsig]);
870 GT_("awakened by signal %d\n"), lastsig);
872 for (ctl = querylist; ctl; ctl = ctl->next)
876 if ((outlevel > O_SILENT && !run.use_syslog && isatty(1))
877 || outlevel > O_NORMAL)
878 report(stdout, GT_("awakened at %s\n"), timestamp());
880 } while (run.poll_interval);
882 if (outlevel >= O_VERBOSE)
883 report(stdout, GT_("normal termination, status %d\n"),
884 successes ? PS_SUCCESS : querystatus);
890 else if (querystatus)
893 /* in case we interrupted before a successful fetch */
897 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
900 * If force is off, modify dstl fields only when they're empty (treat srcl
901 * as defaults). If force is on, modify each dstl field whenever scrcl
902 * is nonempty (treat srcl as an override).
904 if (force ? !!*srcl : !*dstl)
906 struct idlist *cpl = copy_str_list(*srcl);
908 append_str_list(dstl, &cpl);
912 static void optmerge(struct query *h2, struct query *h1, int force)
913 /* merge two options records */
915 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
916 list_merge(&h2->localnames, &h1->localnames, force);
917 list_merge(&h2->mailboxes, &h1->mailboxes, force);
918 list_merge(&h2->smtphunt, &h1->smtphunt, force);
919 list_merge(&h2->domainlist, &h1->domainlist, force);
920 list_merge(&h2->antispam, &h1->antispam, force);
922 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
923 FLAG_MERGE(server.via);
924 FLAG_MERGE(server.protocol);
925 FLAG_MERGE(server.service);
926 FLAG_MERGE(server.interval);
927 FLAG_MERGE(server.authenticate);
928 FLAG_MERGE(server.timeout);
929 FLAG_MERGE(server.envelope);
930 FLAG_MERGE(server.envskip);
931 FLAG_MERGE(server.qvirtual);
932 FLAG_MERGE(server.skip);
933 FLAG_MERGE(server.dns);
934 FLAG_MERGE(server.checkalias);
935 FLAG_MERGE(server.uidl);
936 FLAG_MERGE(server.principal);
939 FLAG_MERGE(server.interface);
940 FLAG_MERGE(server.interface_pair);
941 FLAG_MERGE(server.monitor);
944 FLAG_MERGE(server.plugin);
945 FLAG_MERGE(server.plugout);
946 FLAG_MERGE(server.tracepolls);
947 FLAG_MERGE(server.badheader);
949 FLAG_MERGE(wildcard);
950 FLAG_MERGE(remotename);
951 FLAG_MERGE(password);
954 FLAG_MERGE(listener);
955 FLAG_MERGE(smtpaddress);
956 FLAG_MERGE(smtpname);
957 FLAG_MERGE(preconnect);
958 FLAG_MERGE(postconnect);
962 FLAG_MERGE(limitflush);
963 FLAG_MERGE(fetchall);
967 FLAG_MERGE(pass8bits);
968 FLAG_MERGE(dropstatus);
969 FLAG_MERGE(dropdelivered);
970 FLAG_MERGE(mimedecode);
973 FLAG_MERGE(warnings);
974 FLAG_MERGE(fetchlimit);
975 FLAG_MERGE(fetchsizelimit);
976 FLAG_MERGE(fastuidl);
977 FLAG_MERGE(batchlimit);
982 FLAG_MERGE(sslproto);
983 FLAG_MERGE(sslcertck);
984 FLAG_MERGE(sslcertfile);
985 FLAG_MERGE(sslcertpath);
986 FLAG_MERGE(sslcommonname);
987 FLAG_MERGE(sslfingerprint);
991 FLAG_MERGE(properties);
995 /** Load configuration files.
996 * \return - true if no servers found on the command line
997 * - false if servers found on the command line */
998 static int load_params(int argc, char **argv, int optind)
1000 int implicitmode, st;
1002 struct query def_opts, *ctl;
1006 run.bouncemail = TRUE;
1007 run.softbounce = TRUE; /* treat permanent errors as temporary */
1008 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
1010 memset(&def_opts, '\0', sizeof(struct query));
1011 def_opts.smtp_socket = -1;
1012 def_opts.smtpaddress = (char *)0;
1013 def_opts.smtpname = (char *)0;
1014 def_opts.server.protocol = P_AUTO;
1015 def_opts.server.timeout = CLIENT_TIMEOUT;
1016 def_opts.server.esmtp_name = user;
1017 def_opts.server.badheader = BHREJECT;
1018 def_opts.warnings = WARNING_INTERVAL;
1019 def_opts.remotename = user;
1020 def_opts.listener = SMTP_MODE;
1021 def_opts.fetchsizelimit = 100;
1022 def_opts.fastuidl = 4;
1024 /* get the location of rcfile */
1026 p = strrchr (rcfile, '/');
1027 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1028 *p = 0; /* replace '/' by '0' */
1029 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1030 *p = '/'; /* restore '/' */
1031 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
1032 strcpy (rcfiledir, "/");
1035 /* note the parse time, so we can pick up on modifications */
1036 if (strcmp(rcfile, "-") == 0)
1037 parsetime = time(NULL);
1039 if (stat(rcfile, &rcstat) != -1)
1040 parsetime = rcstat.st_mtime;
1041 else if (errno != ENOENT)
1042 report(stderr, GT_("couldn't time-check the run-control file\n"));
1045 /* this builds the host list */
1046 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1048 * FIXME: someday, send notification mail here if backgrounded.
1049 * Right now, that can happen if the user changes the rcfile
1050 * while the fetchmail is running in background. Do similarly
1051 * for the other exit() calls in this function.
1055 if ((implicitmode = (optind >= argc)))
1057 for (ctl = querylist; ctl; ctl = ctl->next)
1058 ctl->active = !ctl->server.skip;
1061 for (; optind < argc; optind++)
1063 flag predeclared = FALSE;
1066 * If hostname corresponds to a host known from the rc file,
1067 * simply declare it active. Otherwise synthesize a host
1068 * record from command line and defaults
1070 for (ctl = querylist; ctl; ctl = ctl->next)
1071 if (!strcmp(ctl->server.pollname, argv[optind])
1072 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1074 /* Is this correct? */
1075 if (predeclared && outlevel >= O_VERBOSE)
1076 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1084 * Allocate and link record without copying in
1085 * command-line args; we'll do that with the optmerge
1088 ctl = hostalloc((struct query *)NULL);
1090 ctl->server.pollname = xstrdup(argv[optind]);
1092 ctl->server.lead_server = (struct hostdata *)NULL;
1097 * If there's a defaults record, merge it and lose it.
1098 * FIXME: we don't currently free all entries that might be in struct query.
1100 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1104 for (ctl = querylist->next; ctl; ctl = ctl->next)
1105 optmerge(ctl, querylist, FALSE);
1107 querylist = querylist->next;
1108 free(tmpq->server.pollname);
1112 /* don't allow a defaults record after the first */
1113 for (ctl = querylist; ctl; ctl = ctl->next) {
1114 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1115 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1120 /* use localhost if we never fetch the FQDN of this host */
1121 fetchmailhost = "localhost";
1123 /* here's where we override globals */
1124 if (cmd_run.logfile)
1125 run.logfile = cmd_run.logfile;
1127 run.idfile = cmd_run.idfile;
1128 if (cmd_run.pidfile)
1129 run.pidfile = cmd_run.pidfile;
1130 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1131 if (cmd_run.poll_interval >= 0)
1132 run.poll_interval = cmd_run.poll_interval;
1133 if (cmd_run.invisible)
1134 run.invisible = (cmd_run.invisible == FLAG_TRUE);
1135 if (cmd_run.showdots)
1136 run.showdots = (cmd_run.showdots == FLAG_TRUE);
1137 if (cmd_run.use_syslog)
1138 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1139 if (cmd_run.postmaster)
1140 run.postmaster = cmd_run.postmaster;
1141 if (cmd_run.bouncemail)
1142 run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1143 if (cmd_run.softbounce)
1144 run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1146 /* check and daemon options are not compatible */
1147 if (check_only && run.poll_interval)
1148 run.poll_interval = 0;
1151 * DNS support is required for some protocols. We used to
1152 * do this unconditionally, but it made fetchmail excessively
1153 * vulnerable to misconfigured DNS setups.
1155 * If we're using ETRN or ODMR, the smtp hunt list is the
1156 * list of systems we're polling on behalf of; these have
1157 * to be fully-qualified domain names. The default for
1158 * this list should be the FQDN of localhost.
1160 * If we're using Kerberos for authentication, we need
1161 * the FQDN in order to generate capability keys.
1163 for (ctl = querylist; ctl; ctl = ctl->next)
1165 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1166 || ctl->server.authenticate == A_KERBEROS_V4
1167 || ctl->server.authenticate == A_KERBEROS_V5))
1169 fetchmailhost = host_fqdn(1);
1173 if (!ctl) /* list exhausted */
1174 fetchmailhost = host_fqdn(0);
1176 /* this code enables flags to be turned off */
1177 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1179 else if (flag == FLAG_FALSE)\
1184 /* merge in wired defaults, do sanity checks and prepare internal fields */
1185 for (ctl = querylist; ctl; ctl = ctl->next)
1187 ctl->wedged = FALSE;
1189 /* merge in defaults */
1190 optmerge(ctl, &def_opts, FALSE);
1192 /* force command-line options */
1193 optmerge(ctl, &cmd_opts, TRUE);
1196 * queryname has to be set up for inactive servers too.
1197 * Otherwise the UIDL code core-dumps on startup.
1199 if (ctl->server.via)
1200 ctl->server.queryname = xstrdup(ctl->server.via);
1202 ctl->server.queryname = xstrdup(ctl->server.pollname);
1205 * We no longer do DNS lookups at startup.
1206 * This is a kluge. It enables users to edit their
1207 * configurations when DNS isn't available.
1209 ctl->server.truename = xstrdup(ctl->server.queryname);
1211 if (configdump || ctl->active )
1213 DEFAULT(ctl->keep, FALSE);
1214 DEFAULT(ctl->fetchall, FALSE);
1215 DEFAULT(ctl->flush, FALSE);
1216 DEFAULT(ctl->limitflush, FALSE);
1217 DEFAULT(ctl->rewrite, TRUE);
1218 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1219 DEFAULT(ctl->forcecr, FALSE);
1220 DEFAULT(ctl->pass8bits, FALSE);
1221 DEFAULT(ctl->dropstatus, FALSE);
1222 DEFAULT(ctl->dropdelivered, FALSE);
1223 DEFAULT(ctl->mimedecode, FALSE);
1224 DEFAULT(ctl->idle, FALSE);
1225 DEFAULT(ctl->server.dns, TRUE);
1226 DEFAULT(ctl->server.uidl, FALSE);
1227 DEFAULT(ctl->use_ssl, FALSE);
1228 DEFAULT(ctl->sslcertck, FALSE);
1229 DEFAULT(ctl->server.checkalias, FALSE);
1232 * XXX FIXME: do we need this check or can we rely on the .y
1233 * parser handling this?
1237 report(stderr, GT_("SSL support is not compiled in.\n"));
1240 #endif /* SSL_ENABLE */
1243 if (ctl->server.authenticate == A_KERBEROS_V4) {
1244 report(stderr, GT_("KERBEROS v4 support is configured, but not compiled in.\n"));
1249 if (ctl->server.authenticate == A_KERBEROS_V5) {
1250 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1255 if (ctl->server.authenticate == A_GSSAPI) {
1256 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1262 * Make sure we have a nonempty host list to forward to.
1265 save_str(&ctl->smtphunt, "localhost", FALSE);
1268 * Make sure we have a nonempty list of domains to fetch from.
1270 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1271 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1273 /* if `user' doesn't name a real local user, try to run as root */
1274 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1277 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1278 if (!ctl->localnames) /* for local delivery via SMTP */
1279 save_str_pair(&ctl->localnames, user, NULL);
1281 #ifndef HAVE_RES_SEARCH
1282 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1283 if (MULTIDROP(ctl) && ctl->server.dns)
1285 ctl->server.dns = FALSE;
1286 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1288 #endif /* !HAVE_RES_SEARCH */
1291 * can't handle multidrop mailboxes without "envelope"
1292 * option, this causes truckloads full of support complaints
1293 * "all mail forwarded to postmaster"
1295 if (MULTIDROP(ctl) && !ctl->server.envelope)
1297 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1298 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1301 /* if no folders were specified, set up the null one as default */
1302 if (!ctl->mailboxes)
1303 save_str(&ctl->mailboxes, (char *)NULL, 0);
1305 /* maybe user overrode timeout on command line? */
1306 if (ctl->server.timeout == -1)
1307 ctl->server.timeout = CLIENT_TIMEOUT;
1310 if (ctl->server.service) {
1311 int port = servport(ctl->server.service);
1314 (void) fprintf(stderr,
1315 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1316 ctl->server.pollname);
1319 if (ctl->server.protocol == P_RPOP && port >= 1024)
1321 (void) fprintf(stderr,
1322 GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1323 ctl->server.pollname);
1327 if (ctl->listener == LMTP_MODE)
1331 for (idp = ctl->smtphunt; idp; idp = idp->next)
1335 if (!(cp = strrchr(idp->id, '/'))
1336 || (0 == strcmp(cp + 1, SMTP_PORT))
1337 || servport(cp + 1) == SMTP_PORT_NUM)
1339 (void) fprintf(stderr,
1340 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1341 ctl->server.pollname);
1348 * "I beg to you, have mercy on the we[a]k minds like myself."
1349 * wrote Pehr Anderson. Your petition is granted.
1351 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1353 (void) fprintf(stderr,
1354 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1360 * If the user didn't set a last-resort user to get misaddressed
1361 * multidrop mail, set an appropriate default here.
1363 if (!run.postmaster)
1365 if (getuid() != ROOT_UID) /* ordinary user */
1366 run.postmaster = user;
1368 run.postmaster = "postmaster";
1371 return(implicitmode);
1374 static RETSIGTYPE terminate_poll(int sig)
1375 /* to be executed at the end of a poll cycle */
1379 report(stdout, GT_("terminated with signal %d\n"), sig);
1383 * Update UID information at end of each poll, rather than at end
1384 * of run, because that way we don't lose all UIDL information since
1385 * the beginning of time if fetchmail crashes.
1388 write_saved_lists(querylist, run.idfile);
1389 #endif /* POP3_ENABLE */
1392 static RETSIGTYPE terminate_run(int sig)
1393 /* to be executed on normal or signal-induced termination */
1397 terminate_poll(sig);
1400 * Craig Metz, the RFC1938 one-time-password guy, points out:
1401 * "Remember that most kernels don't zero pages before handing them to the
1402 * next process and many kernels share pages between user and kernel space.
1403 * You'd be very surprised what you can find from a short program to do a
1404 * malloc() and then dump the contents of the pages you got. By zeroing
1405 * the secrets at end of run (earlier if you can), you make sure the next
1406 * guy can't get the password/pass phrase."
1408 * Right you are, Craig!
1410 for (ctl = querylist; ctl; ctl = ctl->next)
1412 memset(ctl->password, '\0', strlen(ctl->password));
1414 #if !defined(HAVE_ATEXIT)
1418 if (activecount == 0)
1421 exit(successes ? PS_SUCCESS : querystatus);
1425 * Sequence of protocols to try when autoprobing, most capable to least.
1427 static const int autoprobe[] =
1431 #endif /* IMAP_ENABLE */
1434 #endif /* POP3_ENABLE */
1437 #endif /* POP2_ENABLE */
1440 static int query_host(struct query *ctl)
1441 /* perform fetch transaction with single host */
1447 * If we're syslogging the progress messages are automatically timestamped.
1448 * Force timestamping if we're going to a logfile.
1450 if (outlevel >= O_VERBOSE)
1452 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1454 ctl->server.pollname,
1455 showproto(ctl->server.protocol),
1459 switch (ctl->server.protocol) {
1461 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1463 ctl->server.protocol = autoprobe[i];
1465 st = query_host(ctl);
1468 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1471 ctl->server.protocol = P_AUTO;
1477 report(stderr, GT_("POP2 support is not configured.\n"));
1479 #endif /* POP2_ENABLE */
1487 } while (st == PS_REPOLL);
1489 report(stderr, GT_("POP3 support is not configured.\n"));
1491 #endif /* POP3_ENABLE */
1497 } while (st == PS_REPOLL);
1499 report(stderr, GT_("IMAP support is not configured.\n"));
1501 #endif /* IMAP_ENABLE */
1505 report(stderr, GT_("ETRN support is not configured.\n"));
1510 #endif /* ETRN_ENABLE */
1513 report(stderr, GT_("ODMR support is not configured.\n"));
1517 #endif /* ODMR_ENABLE */
1520 report(stderr, GT_("unsupported protocol selected.\n"));
1525 * If we're syslogging the progress messages are automatically timestamped.
1526 * Force timestamping if we're going to a logfile.
1528 if (outlevel >= O_VERBOSE)
1530 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1532 ctl->server.pollname,
1533 showproto(ctl->server.protocol),
1540 static void dump_params (struct runctl *runp,
1541 struct query *querylist, flag implicit)
1542 /* display query parameters in English */
1546 if (runp->poll_interval)
1547 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1549 printf(GT_("Logfile is %s\n"), runp->logfile);
1550 if (strcmp(runp->idfile, IDFILE_NAME))
1551 printf(GT_("Idfile is %s\n"), runp->idfile);
1552 #if defined(HAVE_SYSLOG)
1553 if (runp->use_syslog)
1554 printf(GT_("Progress messages will be logged via syslog\n"));
1556 if (runp->invisible)
1557 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1559 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1560 if (runp->postmaster)
1561 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1564 if (!runp->bouncemail)
1565 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1566 else if (outlevel >= O_VERBOSE)
1567 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1569 if (!runp->softbounce)
1570 printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1571 else if (outlevel >= O_VERBOSE)
1572 printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1574 for (ctl = querylist; ctl; ctl = ctl->next)
1576 if (!ctl->active || (implicit && ctl->server.skip))
1579 printf(GT_("Options for retrieving from %s@%s:\n"),
1580 ctl->remotename, visbuf(ctl->server.pollname));
1582 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1583 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1585 if (ctl->server.interval)
1586 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1587 " Poll of this server will occur every %d intervals.\n",
1588 ctl->server.interval), ctl->server.interval);
1589 if (ctl->server.truename)
1590 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1591 if (ctl->server.skip || outlevel >= O_VERBOSE)
1592 printf(ctl->server.skip
1593 ? GT_(" This host will not be queried when no host is specified.\n")
1594 : GT_(" This host will be queried when no host is specified.\n"));
1595 if (!NO_PASSWORD(ctl))
1598 printf(GT_(" Password will be prompted for.\n"));
1599 else if (outlevel >= O_VERBOSE)
1601 if (ctl->server.protocol == P_APOP)
1602 printf(GT_(" APOP secret = \"%s\".\n"),
1603 visbuf(ctl->password));
1604 else if (ctl->server.protocol == P_RPOP)
1605 printf(GT_(" RPOP id = \"%s\".\n"),
1606 visbuf(ctl->password));
1608 printf(GT_(" Password = \"%s\".\n"),
1609 visbuf(ctl->password));
1613 if (ctl->server.protocol == P_POP3
1614 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1615 && (ctl->server.authenticate == A_KERBEROS_V4 ||
1616 ctl->server.authenticate == A_KERBEROS_V5))
1617 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1618 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1620 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1621 if (ctl->server.service)
1622 printf(GT_(" (using service %s)"), ctl->server.service);
1623 else if (outlevel >= O_VERBOSE)
1624 printf(GT_(" (using default port)"));
1625 if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1626 printf(GT_(" (forcing UIDL use)"));
1629 switch (ctl->server.authenticate)
1632 printf(GT_(" All available authentication methods will be tried.\n"));
1635 printf(GT_(" Password authentication will be forced.\n"));
1638 printf(GT_(" MSN authentication will be forced.\n"));
1641 printf(GT_(" NTLM authentication will be forced.\n"));
1644 printf(GT_(" OTP authentication will be forced.\n"));
1647 printf(GT_(" CRAM-Md5 authentication will be forced.\n"));
1650 printf(GT_(" GSSAPI authentication will be forced.\n"));
1653 printf(GT_(" Kerberos V4 authentication will be forced.\n"));
1656 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1659 printf(GT_(" End-to-end encryption assumed.\n"));
1662 if (ctl->server.principal != (char *) NULL)
1663 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1666 printf(GT_(" SSL encrypted sessions enabled.\n"));
1668 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
1669 if (ctl->sslcertck) {
1670 printf(GT_(" SSL server certificate checking enabled.\n"));
1672 if (ctl->sslcertfile != NULL)
1673 printf(GT_(" SSL trusted certificate file: %s\n"), ctl->sslcertfile);
1674 if (ctl->sslcertpath != NULL)
1675 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1676 if (ctl->sslcommonname != NULL)
1677 printf(GT_(" SSL server CommonName: %s\n"), ctl->sslcommonname);
1678 if (ctl->sslfingerprint != NULL)
1679 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1681 if (ctl->server.timeout > 0)
1682 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1683 if (ctl->server.timeout == CLIENT_TIMEOUT)
1684 printf(GT_(" (default).\n"));
1688 if (MAILBOX_PROTOCOL(ctl))
1690 if (!ctl->mailboxes->id)
1691 printf(GT_(" Default mailbox selected.\n"));
1696 printf(GT_(" Selected mailboxes are:"));
1697 for (idp = ctl->mailboxes; idp; idp = idp->next)
1698 printf(" %s", idp->id);
1701 printf(ctl->fetchall
1702 ? GT_(" All messages will be retrieved (--all on).\n")
1703 : GT_(" Only new messages will be retrieved (--all off).\n"));
1705 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
1706 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
1708 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
1709 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
1710 printf(ctl->limitflush
1711 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1712 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1714 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
1715 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1717 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
1718 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
1720 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
1721 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
1722 printf(ctl->pass8bits
1723 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1724 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1725 printf(ctl->mimedecode
1726 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
1727 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
1729 ? GT_(" Idle after poll is enabled (idle on).\n")
1730 : GT_(" Idle after poll is disabled (idle off).\n"));
1731 printf(ctl->dropstatus
1732 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
1733 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
1734 printf(ctl->dropdelivered
1735 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
1736 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
1737 if (NUM_NONZERO(ctl->limit))
1739 if (NUM_NONZERO(ctl->limit))
1740 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
1741 ctl->limit, ctl->limit);
1742 else if (outlevel >= O_VERBOSE)
1743 printf(GT_(" No message size limit (--limit 0).\n"));
1744 if (run.poll_interval > 0)
1745 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1746 ctl->warnings, ctl->warnings);
1747 else if (outlevel >= O_VERBOSE)
1748 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
1750 if (NUM_NONZERO(ctl->fetchlimit))
1751 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
1752 ctl->fetchlimit, ctl->fetchlimit);
1753 else if (outlevel >= O_VERBOSE)
1754 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
1755 if (NUM_NONZERO(ctl->fetchsizelimit))
1756 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1757 ctl->fetchsizelimit, ctl->fetchsizelimit);
1758 else if (outlevel >= O_VERBOSE)
1759 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
1760 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1762 if (ctl->fastuidl == 1)
1763 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1765 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1767 else if (outlevel >= O_VERBOSE)
1768 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1769 if (NUM_NONZERO(ctl->batchlimit))
1770 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1771 else if (outlevel >= O_VERBOSE)
1772 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
1773 if (MAILBOX_PROTOCOL(ctl))
1775 if (NUM_NONZERO(ctl->expunge))
1776 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1777 else if (outlevel >= O_VERBOSE)
1778 printf(GT_(" No forced expunges (--expunge 0).\n"));
1781 else /* ODMR or ETRN */
1785 printf(GT_(" Domains for which mail will be fetched are:"));
1786 for (idp = ctl->domainlist; idp; idp = idp->next)
1788 printf(" %s", idp->id);
1789 if (!idp->val.status.mark)
1790 printf(GT_(" (default)"));
1795 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1796 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1797 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1804 printf(GT_(" Messages will be %cMTP-forwarded to:"),
1806 for (idp = ctl->smtphunt; idp; idp = idp->next)
1808 printf(" %s", idp->id);
1809 if (!idp->val.status.mark)
1810 printf(GT_(" (default)"));
1814 if (ctl->smtpaddress)
1815 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
1818 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1821 if (MAILBOX_PROTOCOL(ctl))
1823 if (ctl->antispam != (struct idlist *)NULL)
1827 printf(GT_(" Recognized listener spam block responses are:"));
1828 for (idp = ctl->antispam; idp; idp = idp->next)
1829 printf(" %d", idp->val.status.num);
1832 else if (outlevel >= O_VERBOSE)
1833 printf(GT_(" Spam-blocking disabled\n"));
1835 if (ctl->preconnect)
1836 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
1837 visbuf(ctl->preconnect));
1838 else if (outlevel >= O_VERBOSE)
1839 printf(GT_(" No pre-connection command.\n"));
1840 if (ctl->postconnect)
1841 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
1842 visbuf(ctl->postconnect));
1843 else if (outlevel >= O_VERBOSE)
1844 printf(GT_(" No post-connection command.\n"));
1845 if (MAILBOX_PROTOCOL(ctl)) {
1846 if (!ctl->localnames)
1847 printf(GT_(" No localnames declared for this host.\n"));
1853 for (idp = ctl->localnames; idp; idp = idp->next)
1856 if (count > 1 || ctl->wildcard)
1857 printf(GT_(" Multi-drop mode: "));
1859 printf(GT_(" Single-drop mode: "));
1861 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1862 if (outlevel >= O_VERBOSE)
1864 for (idp = ctl->localnames; idp; idp = idp->next)
1866 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1868 printf("\t%s\n", idp->id);
1870 fputs("\t*\n", stdout);
1873 if (count > 1 || ctl->wildcard)
1875 printf(ctl->server.dns
1876 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
1877 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
1878 if (ctl->server.dns)
1880 if (ctl->server.checkalias)
1881 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
1883 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
1885 if (ctl->server.envelope == STRING_DISABLED)
1886 printf(GT_(" Envelope-address routing is disabled\n"));
1889 printf(GT_(" Envelope header is assumed to be: %s\n"),
1890 ctl->server.envelope ? ctl->server.envelope : "Received");
1891 if (ctl->server.envskip || outlevel >= O_VERBOSE)
1892 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
1893 ctl->server.envskip);
1894 if (ctl->server.qvirtual)
1895 printf(GT_(" Prefix %s will be removed from user id\n"),
1896 ctl->server.qvirtual);
1897 else if (outlevel >= O_VERBOSE)
1898 printf(GT_(" No prefix stripping\n"));
1901 if (ctl->server.akalist)
1903 printf(GT_(" Predeclared mailserver aliases:"));
1904 for (idp = ctl->server.akalist; idp; idp = idp->next)
1905 printf(" %s", idp->id);
1909 if (ctl->server.localdomains)
1911 printf(GT_(" Local domains:"));
1912 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1913 printf(" %s", idp->id);
1920 if (ctl->server.interface)
1921 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
1922 else if (outlevel >= O_VERBOSE)
1923 printf(GT_(" No interface requirement specified.\n"));
1924 if (ctl->server.monitor)
1925 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1926 else if (outlevel >= O_VERBOSE)
1927 printf(GT_(" No monitor interface specified.\n"));
1930 if (ctl->server.plugin)
1931 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1932 else if (outlevel >= O_VERBOSE)
1933 printf(GT_(" No plugin command specified.\n"));
1934 if (ctl->server.plugout)
1935 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1936 else if (outlevel >= O_VERBOSE)
1937 printf(GT_(" No plugout command specified.\n"));
1939 if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1942 printf(GT_(" No UIDs saved from this host.\n"));
1948 for (idp = ctl->oldsaved; idp; idp = idp->next)
1951 printf(GT_(" %d UIDs saved.\n"), count);
1952 if (outlevel >= O_VERBOSE)
1953 for (idp = ctl->oldsaved; idp; idp = idp->next)
1954 printf("\t%s\n", idp->id);
1958 if (ctl->server.tracepolls)
1959 printf(GT_(" Poll trace information will be added to the Received header.\n"));
1960 else if (outlevel >= O_VERBOSE)
1961 printf(GT_(" No poll trace information will be added to the Received header.\n"));
1963 switch (ctl->server.badheader) {
1965 if (outlevel >= O_VERBOSE)
1966 printf(GT_(" Messages with bad headers will be rejected.\n"));
1969 printf(GT_(" Messages with bad headers will be passed on.\n"));
1973 if (ctl->properties)
1974 printf(GT_(" Pass-through properties \"%s\".\n"),
1975 visbuf(ctl->properties));
1979 /* fetchmail.c ends here */