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"
49 #define ENETUNREACH 128 /* Interactive doesn't know this */
50 #endif /* ENETUNREACH */
52 /* prototypes for internal functions */
53 static int load_params(int, char **, int);
54 static void dump_params (struct runctl *runp, struct query *, flag implicit);
55 static int query_host(struct query *);
57 /* controls the detail level of status/progress messages written to stderr */
58 int outlevel; /* see the O_.* constants above */
60 /* miscellaneous global controls */
61 struct runctl run; /* global controls for this run */
62 flag nodetach; /* if TRUE, don't detach daemon process */
63 flag quitmode; /* if --quit was set */
64 int quitind; /* optind after position of last --quit option */
65 flag check_only; /* if --probe was set */
66 flag versioninfo; /* emit only version info */
67 char *user; /* the name of the invoking user */
68 char *home; /* invoking user's home directory */
69 char *fmhome; /* fetchmail's home directory */
70 char *program_name; /* the name to prefix error messages with */
71 flag configdump; /* dump control blocks for configurator */
72 char *fetchmailhost; /* either `localhost' or the host's FQDN */
74 static int quitonly; /* if we should quit after killing the running daemon */
76 static int querystatus; /* status of query */
77 static int successes; /* count number of successful polls */
78 static int activecount; /* count number of active entries */
79 static struct runctl cmd_run; /* global options set from command line */
80 static time_t parsetime; /* time of last parse */
82 static RETSIGTYPE terminate_run(int);
83 static RETSIGTYPE terminate_poll(int);
85 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
86 /* drop SGID kmem privileage until we need it */
87 static void dropprivs(void)
97 if (gr && !strcmp(gr->gr_name, "kmem"))
99 extern void interface_set_gids(gid_t egid, gid_t rgid);
100 interface_set_gids(egid, rgid);
106 #if defined(HAVE_SETLOCALE) && defined(ENABLE_NLS) && defined(HAVE_STRFTIME)
108 /** returns timestamp in current locale,
109 * and resets LC_TIME locale to POSIX. */
110 static char *timestamp (void)
113 static char buf[60]; /* RATS: ignore */
116 setlocale (LC_TIME, "");
117 strftime (buf, sizeof (buf), "%c", localtime(&now));
118 setlocale (LC_TIME, "C");
122 #define timestamp rfc822timestamp
125 static RETSIGTYPE donothing(int sig)
127 set_signal_handler(sig, donothing);
131 static void printcopyright(FILE *fp) {
132 fprintf(fp, GT_("Copyright (C) 2002, 2003 Eric S. Raymond\n"
133 "Copyright (C) 2004 Matthias Andree, Eric S. Raymond, Rob F. Funk, Graham Wilson\n"
134 "Copyright (C) 2005-2006 Matthias Andree, Sunil Shetye\n"
136 fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
137 "are welcome to redistribute it under certain conditions. For details,\n"
138 "please see the file COPYING in the source or documentation directory.\n"));
141 const char *iana_charset;
143 int main(int argc, char **argv)
146 int implicitmode = FALSE;
148 netrc_entry *netrc_list;
149 char *netrc_file, *tmpbuf;
153 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
157 envquery(argc, argv);
159 setlocale (LC_ALL, "");
160 bindtextdomain(PACKAGE, LOCALEDIR);
162 iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
166 iana_charset = "US-ASCII";
170 report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
174 * Note: because we can't initialize reporting before we know whether
175 * syslog is supposed to be on, this message will go to stdout and
176 * be lost when running in background.
178 if (outlevel >= O_VERBOSE)
182 report(stdout, GT_("fetchmail: invoked with"));
183 for (i = 0; i < argc; i++)
184 report(stdout, " %s", argv[i]);
185 report(stdout, "\n");
188 #define IDFILE_NAME ".fetchids"
189 run.idfile = prependdir (IDFILE_NAME, fmhome);
194 * We used to arrange for the lock to be removed on exit close
195 * to where the lock was asserted. Now we need to do it here, because
196 * we might have re-executed in background with an existing lock
197 * as the result of a changed rcfile (see the code near the execvp(3)
198 * call near the beginning of the polling loop for details). We want
199 * to be sure the lock gets nuked on any error exit, basically.
204 /* save the current directory */
205 if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
206 report(stderr, GT_("could not get current working directory\n"));
214 i = parsecmdline(argc, argv, &cmd_run, &cmd_opts);
218 if (quitmode && quitind == argc)
224 const char *features =
227 #endif /* POP2_ENABLE */
230 #endif /* POP3_ENABLE */
233 #endif /* IMAP_ENABLE */
239 #endif /* RPA_ENABLE */
242 #endif /* NTLM_ENABLE */
245 #endif /* SDPS_ENABLE */
248 #endif /* ETRN_ENABLE */
251 #endif /* ODMR_ENABLE */
257 #endif /* OPIE_ENABLE */
258 #ifdef HAVE_PKG_hesiod
263 #endif /* HAVE_SOCKS */
266 #endif /* ENABLE_NLS */
268 printf(GT_("This is fetchmail release %s"), VERSION);
269 fputs(features, stdout);
271 printcopyright(stdout);
273 fputs("Fallback MDA: ", stdout);
275 fputs(FALLBACK_MDA, stdout);
277 fputs("(none)", stdout);
282 /* this is an attempt to help remote debugging */
286 /* avoid parsing the config file if all we're doing is killing a daemon */
288 implicitmode = load_params(argc, argv, optind);
290 #if defined(HAVE_SYSLOG)
291 /* logging should be set up early in case we were restarted from exec */
294 #if defined(LOG_MAIL)
295 openlog(program_name, LOG_PID, LOG_MAIL);
297 /* Assume BSD4.2 openlog with two arguments */
298 openlog(program_name, LOG_PID);
304 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
307 /* initialize UID handling */
311 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
314 initialize_saved_lists(querylist, run.idfile);
316 #endif /* POP3_ENABLE */
318 /* construct the lockfile */
321 #ifdef HAVE_SETRLIMIT
323 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
324 * Core dumps could otherwise contain passwords to be scavenged by a
327 if (outlevel < O_VERBOSE || run.poll_interval > 0)
329 struct rlimit corelimit;
330 corelimit.rlim_cur = 0;
331 corelimit.rlim_max = 0;
332 setrlimit(RLIMIT_CORE, &corelimit);
334 #endif /* HAVE_SETRLIMIT */
336 #define NETRC_FILE ".netrc"
337 /* parse the ~/.netrc file (if present) for future password lookups. */
338 netrc_file = prependdir (NETRC_FILE, home);
339 netrc_list = parse_netrc(netrc_file);
343 /* pick up passwords where we can */
344 for (ctl = querylist; ctl; ctl = ctl->next)
346 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
348 if (NO_PASSWORD(ctl))
349 /* Server won't care what the password is, but there
350 must be some non-null string here. */
351 ctl->password = ctl->remotename;
356 /* look up the pollname and account in the .netrc file. */
357 p = search_netrc(netrc_list,
358 ctl->server.pollname, ctl->remotename);
359 /* if we find a matching entry with a password, use it */
360 if (p && p->password)
361 ctl->password = xstrdup(p->password);
363 /* otherwise try with "via" name if there is one */
364 else if (ctl->server.via)
366 p = search_netrc(netrc_list,
367 ctl->server.via, ctl->remotename);
368 if (p && p->password)
369 ctl->password = xstrdup(p->password);
375 free_netrc(netrc_list);
378 /* perhaps we just want to check options? */
381 int havercfile = access(rcfile, 0);
383 printf(GT_("Taking options from command line%s%s\n"),
384 havercfile ? "" : GT_(" and "),
385 havercfile ? "" : rcfile);
387 if (querylist == NULL)
389 GT_("No mailservers set up -- perhaps %s is missing?\n"),
392 dump_params(&run, querylist, implicitmode);
396 /* dump options as a Python dictionary, for configurator use */
399 dump_config(&run, querylist);
403 /* check for another fetchmail running concurrently */
404 pid = fm_lock_state();
406 pid = bkgd ? -pid : pid;
408 /* if no mail servers listed and nothing in background, we're done */
409 if (!quitonly && pid == 0 && querylist == NULL) {
410 (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
414 /* perhaps user asked us to kill the other fetchmail */
417 if (pid == 0 || pid == getpid())
418 /* this test enables re-execing on a changed rcfile
419 * for pid == getpid() */
422 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
426 else if (kill(pid, SIGTERM) < 0)
428 fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
429 bkgd ? GT_("background") : GT_("foreground"), pid);
436 if (outlevel > O_SILENT)
437 fprintf(stderr,GT_("fetchmail: %s fetchmail at %d killed.\n"),
438 bkgd ? GT_("background") : GT_("foreground"), pid);
439 /* We used to nuke the other process's lock here, with
440 * fm_lock_release(), which is broken. The other process
441 * needs to clear its lock by itself. */
445 /* wait for other process to exit */
446 maxwait = 10; /* seconds */
447 while (kill(pid, 0) == 0 && --maxwait >= 0) {
454 /* another fetchmail is running -- wake it up or die */
460 GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
463 else if (!implicitmode)
466 GT_("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
473 GT_("fetchmail: another foreground fetchmail is running at %d.\n"),
477 else if (getpid() == pid)
478 /* this test enables re-execing on a changed rcfile */
483 GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
486 else if (kill(pid, SIGUSR1) == 0)
489 GT_("fetchmail: background fetchmail at %d awakened.\n"),
496 * Should never happen -- possible only if a background fetchmail
497 * croaks after the first kill probe above but before the
498 * SIGUSR1/SIGHUP transmission.
501 GT_("fetchmail: elder sibling at %d died mysteriously.\n"),
503 return(PS_UNDEFINED);
507 /* pick up interactively any passwords we need but don't have */
508 for (ctl = querylist; ctl; ctl = ctl->next)
510 if (ctl->active && !(implicitmode && ctl->server.skip)
511 && !NO_PASSWORD(ctl) && !ctl->password)
516 GT_("fetchmail: can't find a password for %s@%s.\n"),
517 ctl->remotename, ctl->server.pollname);
520 const char* password_prompt = GT_("Enter password for %s@%s: ");
521 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
523 tmpbuf = xmalloc(pplen);
524 snprintf(tmpbuf, pplen, password_prompt,
525 ctl->remotename, ctl->server.pollname);
526 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
533 * Time to initiate the SOCKS library (this is not mandatory: it just
534 * registers the correct application name for logging purpose. If you
535 * have some problem, comment out these lines).
538 SOCKSinit("fetchmail");
539 #endif /* HAVE_SOCKS */
541 /* avoid zombies from plugins */
545 * Maybe time to go to demon mode...
547 if (run.poll_interval)
550 daemonize(run.logfile);
551 report(stdout, GT_("starting fetchmail %s daemon \n"), VERSION);
554 * We'll set up a handler for these when we're sleeping,
555 * but ignore them otherwise so as not to interrupt a poll.
557 set_signal_handler(SIGUSR1, SIG_IGN);
558 if (run.poll_interval && getuid() == ROOT_UID)
559 set_signal_handler(SIGHUP, SIG_IGN);
563 if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
565 if (!freopen(run.logfile, "a", stdout))
566 report(stderr, GT_("could not open %s to append logs to \n"), run.logfile);
567 if (!freopen(run.logfile, "a", stderr))
568 report(stdout, GT_("could not open %s to append logs to \n"), run.logfile);
574 /* beyond here we don't want more than one fetchmail running per user */
576 set_signal_handler(SIGABRT, terminate_run);
577 set_signal_handler(SIGINT, terminate_run);
578 set_signal_handler(SIGTERM, terminate_run);
579 set_signal_handler(SIGALRM, terminate_run);
580 set_signal_handler(SIGPIPE, terminate_run);
581 set_signal_handler(SIGQUIT, terminate_run);
583 /* here's the exclusion lock */
587 * Query all hosts. If there's only one, the error return will
588 * reflect the status of that transaction.
592 * Check to see if the rcfile has been touched. If so,
593 * re-exec so the file will be reread. Doing it this way
594 * avoids all the complications of trying to deallocate the
595 * in-core control structures -- and the potential memory
600 if (strcmp(rcfile, "-") == 0) {
602 } else if (stat(rcfile, &rcstat) == -1) {
605 GT_("couldn't time-check %s (error %d)\n"),
608 else if (rcstat.st_mtime > parsetime)
610 report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
613 /* restore the startup directory */
614 if (!currentwd[0] || chdir (currentwd) == -1)
615 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
619 * Matthias Andree: Isn't this prone to introduction of
620 * "false" programs by interfering with PATH? Those
621 * path-searching execs might not be the best ideas for
624 * Rob Funk: But is there any way for someone to modify
625 * the PATH variable of a running fetchmail? I don't know
628 * Dave's change makes fetchmail restart itself in exactly
629 * the way it was started from the shell (or shell script)
630 * in the first place. If you're concerned about PATH
631 * contamination, call fetchmail initially with a full
632 * path, and use Dave's patch.
634 * Not using a -p variant of exec means that the restart
635 * will break if both (a) the user depended on PATH to
636 * call fetchmail in the first place, and (b) the system
637 * doesn't save the whole path in argv[0] if the whole
638 * path wasn't used in the initial call. (If I recall
639 * correctly, Linux saves it but many other Unices don't.)
641 execvp(argv[0], argv);
642 report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
645 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
647 * This was an efficiency hack that backfired. The theory
648 * was that using TCP/IP for DNS queries would get us better
649 * reliability and shave off some per-UDP-packet costs.
650 * Unfortunately it interacted badly with diald, which effectively
651 * filters out DNS queries over TCP/IP for reasons having to do
652 * with some obscure Linux kernel problem involving bootstrapping of
653 * dynamically-addressed links. I don't understand this mess
654 * and don't want to, so it's "See ya!" to this hack.
656 sethostent(TRUE); /* use TCP/IP for mailserver queries */
657 #endif /* HAVE_RES_SEARCH */
661 for (ctl = querylist; ctl; ctl = ctl->next)
665 if (!(implicitmode && ctl->server.skip))
670 GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
671 ctl->server.pollname);
675 /* check skip interval first so that it counts all polls */
676 if (run.poll_interval && ctl->server.interval)
678 if (ctl->server.poll_count++ % ctl->server.interval)
680 if (outlevel >= O_VERBOSE)
682 GT_("interval not reached, not querying %s\n"),
683 ctl->server.pollname);
690 * Don't do monitoring if we were woken by a signal.
691 * Note that interface_approve() does its own error logging.
693 if (!interface_approve(&ctl->server, !lastsig))
695 #endif /* CAN_MONITOR */
697 dofastuidl = 0; /* this is reset in the driver if required */
699 querystatus = query_host(ctl);
701 if (NUM_NONZERO(ctl->fastuidl))
702 ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
704 /* leave the UIDL state alone if there have been any errors */
706 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
709 uid_discard_new_list(ctl);
711 #endif /* POP3_ENABLE */
713 if (querystatus == PS_SUCCESS)
715 else if (!check_only &&
716 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
720 report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
722 report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
724 report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
726 report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
728 report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
730 report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
732 report(stdout,GT_("Query status=6 (IOERR)\n")); break;
734 report(stdout,GT_("Query status=7 (ERROR)\n")); break;
736 report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
738 report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
740 report(stdout,GT_("Query status=10 (SMTP)\n")); break;
742 report(stdout,GT_("Query status=11 (DNS)\n")); break;
744 report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
746 report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
748 report(stdout,GT_("Query status=%d\n"),querystatus);
753 if (ctl->server.monitor)
756 * Allow some time for the link to quiesce. One
757 * second is usually sufficient, three is safe.
758 * Note: this delay is important - don't remove!
761 interface_note_activity(&ctl->server);
763 #endif /* CAN_MONITOR */
767 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
768 endhostent(); /* release TCP/IP connection to nameserver */
769 #endif /* HAVE_RES_SEARCH */
771 /* close connections cleanly */
775 * OK, we've polled. Now sleep.
777 if (run.poll_interval)
780 * Because passwords can expire, it may happen that *all*
781 * hosts are now out of the loop due to authfail
782 * conditions. If this happens daemon-mode fetchmail
783 * should softly and silently vanish away, rather than
784 * spinning uselessly.
788 for (ctl = querylist; ctl; ctl = ctl->next)
789 if (ctl->active && !(implicitmode && ctl->server.skip))
794 report(stderr, GT_("All connections are wedged. Exiting.\n"));
795 /* FIXME: someday, send notification mail */
799 if (outlevel > O_SILENT)
801 GT_("sleeping at %s\n"), timestamp());
804 * With this simple hack, we make it possible for a foreground
805 * fetchmail to wake up one in daemon mode. What we want is the
806 * side effect of interrupting any sleep that may be going on,
807 * forcing fetchmail to re-poll its hosts. The second line is
808 * for people who think all system daemons wake up on SIGHUP.
810 set_signal_handler(SIGUSR1, donothing);
811 if (getuid() != ROOT_UID)
812 set_signal_handler(SIGHUP, donothing);
815 * OK, now pause until it's time for the next poll cycle.
816 * A nonzero return indicates we received a wakeup signal;
817 * unwedge all servers in case the problem has been
820 if ((lastsig = interruptible_idle(run.poll_interval)))
822 if (outlevel > O_SILENT)
823 #ifdef SYS_SIGLIST_DECLARED
825 GT_("awakened by %s\n"), sys_siglist[lastsig]);
828 GT_("awakened by signal %d\n"), lastsig);
830 for (ctl = querylist; ctl; ctl = ctl->next)
834 if (outlevel > O_SILENT)
835 report(stdout, GT_("awakened at %s\n"), timestamp());
840 if (outlevel >= O_VERBOSE)
841 report(stdout, GT_("normal termination, status %d\n"),
842 successes ? PS_SUCCESS : querystatus);
848 else if (querystatus)
851 /* in case we interrupted before a successful fetch */
855 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
858 * If force is off, modify dstl fields only when they're empty (treat srcl
859 * as defaults). If force is on, modify each dstl field whenever scrcl
860 * is nonempty (treat srcl as an override).
862 if (force ? !!*srcl : !*dstl)
864 struct idlist *cpl = copy_str_list(*srcl);
866 append_str_list(dstl, &cpl);
870 static void optmerge(struct query *h2, struct query *h1, int force)
871 /* merge two options records */
873 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
874 list_merge(&h2->localnames, &h1->localnames, force);
875 list_merge(&h2->mailboxes, &h1->mailboxes, force);
876 list_merge(&h2->smtphunt, &h1->smtphunt, force);
877 list_merge(&h2->domainlist, &h1->domainlist, force);
878 list_merge(&h2->antispam, &h1->antispam, force);
880 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
881 FLAG_MERGE(server.via);
882 FLAG_MERGE(server.protocol);
883 FLAG_MERGE(server.service);
884 FLAG_MERGE(server.interval);
885 FLAG_MERGE(server.authenticate);
886 FLAG_MERGE(server.timeout);
887 FLAG_MERGE(server.envelope);
888 FLAG_MERGE(server.envskip);
889 FLAG_MERGE(server.qvirtual);
890 FLAG_MERGE(server.skip);
891 FLAG_MERGE(server.dns);
892 FLAG_MERGE(server.checkalias);
893 FLAG_MERGE(server.uidl);
894 FLAG_MERGE(server.principal);
897 FLAG_MERGE(server.interface);
898 FLAG_MERGE(server.interface_pair);
899 FLAG_MERGE(server.monitor);
902 FLAG_MERGE(server.plugin);
903 FLAG_MERGE(server.plugout);
904 FLAG_MERGE(server.tracepolls);
906 FLAG_MERGE(wildcard);
907 FLAG_MERGE(remotename);
908 FLAG_MERGE(password);
911 FLAG_MERGE(listener);
912 FLAG_MERGE(smtpaddress);
913 FLAG_MERGE(smtpname);
914 FLAG_MERGE(preconnect);
915 FLAG_MERGE(postconnect);
919 FLAG_MERGE(limitflush);
920 FLAG_MERGE(fetchall);
924 FLAG_MERGE(pass8bits);
925 FLAG_MERGE(dropstatus);
926 FLAG_MERGE(dropdelivered);
927 FLAG_MERGE(mimedecode);
930 FLAG_MERGE(warnings);
931 FLAG_MERGE(fetchlimit);
932 FLAG_MERGE(fetchsizelimit);
933 FLAG_MERGE(fastuidl);
934 FLAG_MERGE(batchlimit);
939 FLAG_MERGE(sslproto);
940 FLAG_MERGE(sslcertck);
941 FLAG_MERGE(sslcertpath);
942 FLAG_MERGE(sslfingerprint);
946 FLAG_MERGE(properties);
950 /** Load configuration files.
951 * \return - true if no servers found on the command line
952 * - false if servers found on the command line */
953 static int load_params(int argc, char **argv, int optind)
955 int implicitmode, st;
957 struct query def_opts, *ctl;
961 run.bouncemail = TRUE;
962 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
964 memset(&def_opts, '\0', sizeof(struct query));
965 def_opts.smtp_socket = -1;
966 def_opts.smtpaddress = (char *)0;
967 def_opts.smtpname = (char *)0;
968 def_opts.server.protocol = P_AUTO;
969 def_opts.server.timeout = CLIENT_TIMEOUT;
970 def_opts.server.esmtp_name = user;
971 def_opts.warnings = WARNING_INTERVAL;
972 def_opts.remotename = user;
973 def_opts.listener = SMTP_MODE;
974 def_opts.fetchsizelimit = 100;
975 def_opts.fastuidl = 4;
977 /* get the location of rcfile */
979 p = strrchr (rcfile, '/');
980 if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
981 *p = 0; /* replace '/' by '0' */
982 strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
983 *p = '/'; /* restore '/' */
984 if (!rcfiledir[0]) /* "/.fetchmailrc" case */
985 strcpy (rcfiledir, "/");
988 /* note the parse time, so we can pick up on modifications */
989 parsetime = 0; /* foil compiler warnings */
990 if (strcmp(rcfile, "-") == 0 || stat(rcfile, &rcstat) != -1)
991 parsetime = rcstat.st_mtime;
992 else if (errno != ENOENT)
993 report(stderr, GT_("couldn't time-check the run-control file\n"));
995 /* this builds the host list */
996 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
998 * FIXME: someday, send notification mail here if backgrounded.
999 * Right now, that can happen if the user changes the rcfile
1000 * while the fetchmail is running in background. Do similarly
1001 * for the other exit() calls in this function.
1005 if ((implicitmode = (optind >= argc)))
1007 for (ctl = querylist; ctl; ctl = ctl->next)
1008 ctl->active = !ctl->server.skip;
1011 for (; optind < argc; optind++)
1013 flag predeclared = FALSE;
1016 * If hostname corresponds to a host known from the rc file,
1017 * simply declare it active. Otherwise synthesize a host
1018 * record from command line and defaults
1020 for (ctl = querylist; ctl; ctl = ctl->next)
1021 if (!strcmp(ctl->server.pollname, argv[optind])
1022 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1024 /* Is this correct? */
1025 if (predeclared && outlevel >= O_VERBOSE)
1026 fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1034 * Allocate and link record without copying in
1035 * command-line args; we'll do that with the optmerge
1038 ctl = hostalloc((struct query *)NULL);
1040 ctl->server.pollname = xstrdup(argv[optind]);
1042 ctl->server.lead_server = (struct hostdata *)NULL;
1047 * If there's a defaults record, merge it and lose it.
1049 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1051 for (ctl = querylist->next; ctl; ctl = ctl->next)
1052 optmerge(ctl, querylist, FALSE);
1053 querylist = querylist->next;
1056 /* don't allow a defaults record after the first */
1057 for (ctl = querylist; ctl; ctl = ctl->next) {
1058 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1059 fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1064 /* use localhost if we never fetch the FQDN of this host */
1065 fetchmailhost = "localhost";
1067 /* here's where we override globals */
1068 if (cmd_run.logfile)
1069 run.logfile = cmd_run.logfile;
1071 run.idfile = cmd_run.idfile;
1072 if (cmd_run.pidfile)
1073 run.pidfile = cmd_run.pidfile;
1074 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1075 if (cmd_run.poll_interval >= 0)
1076 run.poll_interval = cmd_run.poll_interval;
1077 if (cmd_run.invisible)
1078 run.invisible = cmd_run.invisible;
1079 if (cmd_run.showdots)
1080 run.showdots = cmd_run.showdots;
1081 if (cmd_run.use_syslog)
1082 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1083 if (cmd_run.postmaster)
1084 run.postmaster = cmd_run.postmaster;
1085 if (cmd_run.bouncemail)
1086 run.bouncemail = cmd_run.bouncemail;
1088 /* check and daemon options are not compatible */
1089 if (check_only && run.poll_interval)
1090 run.poll_interval = 0;
1093 * DNS support is required for some protocols. We used to
1094 * do this unconditionally, but it made fetchmail excessively
1095 * vulnerable to misconfigured DNS setups.
1097 * If we're using ETRN or ODMR, the smtp hunt list is the
1098 * list of systems we're polling on behalf of; these have
1099 * to be fully-qualified domain names. The default for
1100 * this list should be the FQDN of localhost.
1102 * If we're using Kerberos for authentication, we need
1103 * the FQDN in order to generate capability keys.
1105 for (ctl = querylist; ctl; ctl = ctl->next)
1107 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1108 || ctl->server.authenticate == A_KERBEROS_V4
1109 || ctl->server.authenticate == A_KERBEROS_V5))
1111 fetchmailhost = host_fqdn(1);
1115 if (!ctl) /* list exhausted */
1116 fetchmailhost = host_fqdn(0);
1118 /* this code enables flags to be turned off */
1119 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1121 else if (flag == FLAG_FALSE)\
1125 /* one global gets treated specially */
1126 DEFAULT(run.showdots, run.poll_interval==0 || nodetach);
1128 /* merge in wired defaults, do sanity checks and prepare internal fields */
1129 for (ctl = querylist; ctl; ctl = ctl->next)
1131 ctl->wedged = FALSE;
1133 /* merge in defaults */
1134 optmerge(ctl, &def_opts, FALSE);
1136 /* force command-line options */
1137 optmerge(ctl, &cmd_opts, TRUE);
1140 * queryname has to be set up for inactive servers too.
1141 * Otherwise the UIDL code core-dumps on startup.
1143 if (ctl->server.via)
1144 ctl->server.queryname = xstrdup(ctl->server.via);
1146 ctl->server.queryname = xstrdup(ctl->server.pollname);
1149 * We no longer do DNS lookups at startup.
1150 * This is a kluge. It enables users to edit their
1151 * configurations when DNS isn't available.
1153 ctl->server.truename = xstrdup(ctl->server.queryname);
1155 if (configdump || ctl->active )
1157 DEFAULT(ctl->keep, FALSE);
1158 DEFAULT(ctl->fetchall, FALSE);
1159 DEFAULT(ctl->flush, FALSE);
1160 DEFAULT(ctl->limitflush, FALSE);
1161 DEFAULT(ctl->rewrite, TRUE);
1162 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1163 DEFAULT(ctl->forcecr, FALSE);
1164 DEFAULT(ctl->pass8bits, FALSE);
1165 DEFAULT(ctl->dropstatus, FALSE);
1166 DEFAULT(ctl->dropdelivered, FALSE);
1167 DEFAULT(ctl->mimedecode, FALSE);
1168 DEFAULT(ctl->idle, FALSE);
1169 DEFAULT(ctl->server.dns, TRUE);
1170 DEFAULT(ctl->server.uidl, FALSE);
1171 DEFAULT(ctl->use_ssl, FALSE);
1172 DEFAULT(ctl->sslcertck, FALSE);
1173 DEFAULT(ctl->server.checkalias, FALSE);
1176 * XXX FIXME: do we need this check or can we rely on the .y
1177 * parser handling this?
1181 report(stderr, GT_("SSL support is not compiled in.\n"));
1184 #endif /* SSL_ENABLE */
1188 * Make sure we have a nonempty host list to forward to.
1191 save_str(&ctl->smtphunt, "localhost", FALSE);
1194 * Make sure we have a nonempty list of domains to fetch from.
1196 if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1197 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1199 /* if `user' doesn't name a real local user, try to run as root */
1200 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1203 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1204 if (!ctl->localnames) /* for local delivery via SMTP */
1205 save_str_pair(&ctl->localnames, user, NULL);
1207 #ifndef HAVE_RES_SEARCH
1208 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1209 if (MULTIDROP(ctl) && ctl->server.dns)
1211 ctl->server.dns = FALSE;
1212 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1214 #endif /* !HAVE_RES_SEARCH */
1217 * can't handle multidrop mailboxes without "envelope"
1218 * option, this causes truckloads full of support complaints
1219 * "all mail forwarded to postmaster"
1221 if (MULTIDROP(ctl) && !ctl->server.envelope)
1223 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1224 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1227 /* if no folders were specified, set up the null one as default */
1228 if (!ctl->mailboxes)
1229 save_str(&ctl->mailboxes, (char *)NULL, 0);
1231 /* maybe user overrode timeout on command line? */
1232 if (ctl->server.timeout == -1)
1233 ctl->server.timeout = CLIENT_TIMEOUT;
1236 if (ctl->server.service) {
1237 int port = servport(ctl->server.service);
1240 (void) fprintf(stderr,
1241 GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1242 ctl->server.pollname);
1245 if (ctl->server.protocol == P_RPOP && port >= 1024)
1247 (void) fprintf(stderr,
1248 GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1249 ctl->server.pollname);
1253 if (ctl->listener == LMTP_MODE)
1257 for (idp = ctl->smtphunt; idp; idp = idp->next)
1261 if (!(cp = strrchr(idp->id, '/'))
1262 || (0 == strcmp(cp + 1, SMTP_PORT))
1263 || servport(cp + 1) == SMTP_PORT_NUM)
1265 (void) fprintf(stderr,
1266 GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1267 ctl->server.pollname);
1274 * "I beg to you, have mercy on the we[a]k minds like myself."
1275 * wrote Pehr Anderson. Your petition is granted.
1277 if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1279 (void) fprintf(stderr,
1280 GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1286 * If the user didn't set a last-resort user to get misaddressed
1287 * multidrop mail, set an appropriate default here.
1289 if (!run.postmaster)
1291 if (getuid() != ROOT_UID) /* ordinary user */
1292 run.postmaster = user;
1294 run.postmaster = "postmaster";
1297 return(implicitmode);
1300 static RETSIGTYPE terminate_poll(int sig)
1301 /* to be executed at the end of a poll cycle */
1305 report(stdout, GT_("terminated with signal %d\n"), sig);
1309 * Update UID information at end of each poll, rather than at end
1310 * of run, because that way we don't lose all UIDL information since
1311 * the beginning of time if fetchmail crashes.
1314 write_saved_lists(querylist, run.idfile);
1315 #endif /* POP3_ENABLE */
1318 static RETSIGTYPE terminate_run(int sig)
1319 /* to be executed on normal or signal-induced termination */
1323 terminate_poll(sig);
1326 * Craig Metz, the RFC1938 one-time-password guy, points out:
1327 * "Remember that most kernels don't zero pages before handing them to the
1328 * next process and many kernels share pages between user and kernel space.
1329 * You'd be very surprised what you can find from a short program to do a
1330 * malloc() and then dump the contents of the pages you got. By zeroing
1331 * the secrets at end of run (earlier if you can), you make sure the next
1332 * guy can't get the password/pass phrase."
1334 * Right you are, Craig!
1336 for (ctl = querylist; ctl; ctl = ctl->next)
1338 memset(ctl->password, '\0', strlen(ctl->password));
1340 #if !defined(HAVE_ATEXIT)
1344 if (activecount == 0)
1347 exit(successes ? PS_SUCCESS : querystatus);
1351 * Sequence of protocols to try when autoprobing, most capable to least.
1353 static const int autoprobe[] =
1357 #endif /* IMAP_ENABLE */
1360 #endif /* POP3_ENABLE */
1363 #endif /* POP2_ENABLE */
1366 static int query_host(struct query *ctl)
1367 /* perform fetch transaction with single host */
1373 * If we're syslogging the progress messages are automatically timestamped.
1374 * Force timestamping if we're going to a logfile.
1376 if (outlevel >= O_VERBOSE)
1378 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1380 ctl->server.pollname,
1381 showproto(ctl->server.protocol),
1385 switch (ctl->server.protocol) {
1387 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1389 ctl->server.protocol = autoprobe[i];
1391 st = query_host(ctl);
1394 if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1397 ctl->server.protocol = P_AUTO;
1403 report(stderr, GT_("POP2 support is not configured.\n"));
1405 #endif /* POP2_ENABLE */
1413 } while (st == PS_REPOLL);
1415 report(stderr, GT_("POP3 support is not configured.\n"));
1417 #endif /* POP3_ENABLE */
1423 } while (st == PS_REPOLL);
1425 report(stderr, GT_("IMAP support is not configured.\n"));
1427 #endif /* IMAP_ENABLE */
1431 report(stderr, GT_("ETRN support is not configured.\n"));
1436 #endif /* ETRN_ENABLE */
1439 report(stderr, GT_("ODMR support is not configured.\n"));
1443 #endif /* ODMR_ENABLE */
1446 report(stderr, GT_("unsupported protocol selected.\n"));
1451 * If we're syslogging the progress messages are automatically timestamped.
1452 * Force timestamping if we're going to a logfile.
1454 if (outlevel >= O_VERBOSE)
1456 report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1458 ctl->server.pollname,
1459 showproto(ctl->server.protocol),
1466 static void dump_params (struct runctl *runp,
1467 struct query *querylist, flag implicit)
1468 /* display query parameters in English */
1472 if (runp->poll_interval)
1473 printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1475 printf(GT_("Logfile is %s\n"), runp->logfile);
1476 if (strcmp(runp->idfile, IDFILE_NAME))
1477 printf(GT_("Idfile is %s\n"), runp->idfile);
1478 #if defined(HAVE_SYSLOG)
1479 if (runp->use_syslog)
1480 printf(GT_("Progress messages will be logged via syslog\n"));
1482 if (runp->invisible)
1483 printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1485 printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1486 if (runp->postmaster)
1487 printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1490 if (!runp->bouncemail)
1491 printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1492 else if (outlevel >= O_VERBOSE)
1493 printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1495 for (ctl = querylist; ctl; ctl = ctl->next)
1497 if (!ctl->active || (implicit && ctl->server.skip))
1500 printf(GT_("Options for retrieving from %s@%s:\n"),
1501 ctl->remotename, visbuf(ctl->server.pollname));
1503 if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1504 printf(GT_(" Mail will be retrieved via %s\n"), ctl->server.via);
1506 if (ctl->server.interval)
1507 printf(ngettext(" Poll of this server will occur every %d interval.\n",
1508 " Poll of this server will occur every %d intervals.\n",
1509 ctl->server.interval), ctl->server.interval);
1510 if (ctl->server.truename)
1511 printf(GT_(" True name of server is %s.\n"), ctl->server.truename);
1512 if (ctl->server.skip || outlevel >= O_VERBOSE)
1513 printf(ctl->server.skip
1514 ? GT_(" This host will not be queried when no host is specified.\n")
1515 : GT_(" This host will be queried when no host is specified.\n"));
1516 if (!NO_PASSWORD(ctl))
1519 printf(GT_(" Password will be prompted for.\n"));
1520 else if (outlevel >= O_VERBOSE)
1522 if (ctl->server.protocol == P_APOP)
1523 printf(GT_(" APOP secret = \"%s\".\n"),
1524 visbuf(ctl->password));
1525 else if (ctl->server.protocol == P_RPOP)
1526 printf(GT_(" RPOP id = \"%s\".\n"),
1527 visbuf(ctl->password));
1529 printf(GT_(" Password = \"%s\".\n"),
1530 visbuf(ctl->password));
1534 if (ctl->server.protocol == P_POP3
1535 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1536 && (ctl->server.authenticate == A_KERBEROS_V4 ||
1537 ctl->server.authenticate == A_KERBEROS_V5))
1538 printf(GT_(" Protocol is KPOP with Kerberos %s authentication"),
1539 ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1541 printf(GT_(" Protocol is %s"), showproto(ctl->server.protocol));
1542 if (ctl->server.service)
1543 printf(GT_(" (using service %s)"), ctl->server.service);
1544 else if (outlevel >= O_VERBOSE)
1545 printf(GT_(" (using default port)"));
1546 if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1547 printf(GT_(" (forcing UIDL use)"));
1550 switch (ctl->server.authenticate)
1553 printf(GT_(" All available authentication methods will be tried.\n"));
1556 printf(GT_(" Password authentication will be forced.\n"));
1559 printf(GT_(" MSN authentication will be forced.\n"));
1562 printf(GT_(" NTLM authentication will be forced.\n"));
1565 printf(GT_(" OTP authentication will be forced.\n"));
1568 printf(GT_(" CRAM-Md5 authentication will be forced.\n"));
1571 printf(GT_(" GSSAPI authentication will be forced.\n"));
1574 printf(GT_(" Kerberos V4 authentication will be forced.\n"));
1577 printf(GT_(" Kerberos V5 authentication will be forced.\n"));
1580 printf(GT_(" End-to-end encryption assumed.\n"));
1583 if (ctl->server.principal != (char *) NULL)
1584 printf(GT_(" Mail service principal is: %s\n"), ctl->server.principal);
1587 printf(GT_(" SSL encrypted sessions enabled.\n"));
1589 printf(GT_(" SSL protocol: %s.\n"), ctl->sslproto);
1590 if (ctl->sslcertck) {
1591 printf(GT_(" SSL server certificate checking enabled.\n"));
1592 if (ctl->sslcertpath != NULL)
1593 printf(GT_(" SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1595 if (ctl->sslfingerprint != NULL)
1596 printf(GT_(" SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1598 if (ctl->server.timeout > 0)
1599 printf(GT_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1600 if (ctl->server.timeout == CLIENT_TIMEOUT)
1601 printf(GT_(" (default).\n"));
1605 if (MAILBOX_PROTOCOL(ctl))
1607 if (!ctl->mailboxes->id)
1608 printf(GT_(" Default mailbox selected.\n"));
1613 printf(GT_(" Selected mailboxes are:"));
1614 for (idp = ctl->mailboxes; idp; idp = idp->next)
1615 printf(" %s", idp->id);
1618 printf(ctl->fetchall
1619 ? GT_(" All messages will be retrieved (--all on).\n")
1620 : GT_(" Only new messages will be retrieved (--all off).\n"));
1622 ? GT_(" Fetched messages will be kept on the server (--keep on).\n")
1623 : GT_(" Fetched messages will not be kept on the server (--keep off).\n"));
1625 ? GT_(" Old messages will be flushed before message retrieval (--flush on).\n")
1626 : GT_(" Old messages will not be flushed before message retrieval (--flush off).\n"));
1627 printf(ctl->limitflush
1628 ? GT_(" Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1629 : GT_(" Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1631 ? GT_(" Rewrite of server-local addresses is enabled (--norewrite off).\n")
1632 : GT_(" Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1634 ? GT_(" Carriage-return stripping is enabled (stripcr on).\n")
1635 : GT_(" Carriage-return stripping is disabled (stripcr off).\n"));
1637 ? GT_(" Carriage-return forcing is enabled (forcecr on).\n")
1638 : GT_(" Carriage-return forcing is disabled (forcecr off).\n"));
1639 printf(ctl->pass8bits
1640 ? GT_(" Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1641 : GT_(" Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1642 printf(ctl->mimedecode
1643 ? GT_(" MIME decoding is enabled (mimedecode on).\n")
1644 : GT_(" MIME decoding is disabled (mimedecode off).\n"));
1646 ? GT_(" Idle after poll is enabled (idle on).\n")
1647 : GT_(" Idle after poll is disabled (idle off).\n"));
1648 printf(ctl->dropstatus
1649 ? GT_(" Nonempty Status lines will be discarded (dropstatus on)\n")
1650 : GT_(" Nonempty Status lines will be kept (dropstatus off)\n"));
1651 printf(ctl->dropdelivered
1652 ? GT_(" Delivered-To lines will be discarded (dropdelivered on)\n")
1653 : GT_(" Delivered-To lines will be kept (dropdelivered off)\n"));
1654 if (NUM_NONZERO(ctl->limit))
1656 if (NUM_NONZERO(ctl->limit))
1657 printf(GT_(" Message size limit is %d octets (--limit %d).\n"),
1658 ctl->limit, ctl->limit);
1659 else if (outlevel >= O_VERBOSE)
1660 printf(GT_(" No message size limit (--limit 0).\n"));
1661 if (run.poll_interval > 0)
1662 printf(GT_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1663 ctl->warnings, ctl->warnings);
1664 else if (outlevel >= O_VERBOSE)
1665 printf(GT_(" Size warnings on every poll (--warnings 0).\n"));
1667 if (NUM_NONZERO(ctl->fetchlimit))
1668 printf(GT_(" Received-message limit is %d (--fetchlimit %d).\n"),
1669 ctl->fetchlimit, ctl->fetchlimit);
1670 else if (outlevel >= O_VERBOSE)
1671 printf(GT_(" No received-message limit (--fetchlimit 0).\n"));
1672 if (NUM_NONZERO(ctl->fetchsizelimit))
1673 printf(GT_(" Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1674 ctl->fetchsizelimit, ctl->fetchsizelimit);
1675 else if (outlevel >= O_VERBOSE)
1676 printf(GT_(" No fetch message size limit (--fetchsizelimit 0).\n"));
1677 if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1679 if (ctl->fastuidl == 1)
1680 printf(GT_(" Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1682 printf(GT_(" Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1684 else if (outlevel >= O_VERBOSE)
1685 printf(GT_(" Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1686 if (NUM_NONZERO(ctl->batchlimit))
1687 printf(GT_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1688 else if (outlevel >= O_VERBOSE)
1689 printf(GT_(" No SMTP message batch limit (--batchlimit 0).\n"));
1690 if (MAILBOX_PROTOCOL(ctl))
1692 if (NUM_NONZERO(ctl->expunge))
1693 printf(GT_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1694 else if (outlevel >= O_VERBOSE)
1695 printf(GT_(" No forced expunges (--expunge 0).\n"));
1698 else /* ODMR or ETRN */
1702 printf(GT_(" Domains for which mail will be fetched are:"));
1703 for (idp = ctl->domainlist; idp; idp = idp->next)
1705 printf(" %s", idp->id);
1706 if (!idp->val.status.mark)
1707 printf(GT_(" (default)"));
1712 printf(GT_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1713 else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1714 printf(GT_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1721 printf(GT_(" Messages will be %cMTP-forwarded to:"),
1723 for (idp = ctl->smtphunt; idp; idp = idp->next)
1725 printf(" %s", idp->id);
1726 if (!idp->val.status.mark)
1727 printf(GT_(" (default)"));
1731 if (ctl->smtpaddress)
1732 printf(GT_(" Host part of MAIL FROM line will be %s\n"),
1735 printf(GT_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1738 if (MAILBOX_PROTOCOL(ctl))
1740 if (ctl->antispam != (struct idlist *)NULL)
1744 printf(GT_(" Recognized listener spam block responses are:"));
1745 for (idp = ctl->antispam; idp; idp = idp->next)
1746 printf(" %d", idp->val.status.num);
1749 else if (outlevel >= O_VERBOSE)
1750 printf(GT_(" Spam-blocking disabled\n"));
1752 if (ctl->preconnect)
1753 printf(GT_(" Server connection will be brought up with \"%s\".\n"),
1754 visbuf(ctl->preconnect));
1755 else if (outlevel >= O_VERBOSE)
1756 printf(GT_(" No pre-connection command.\n"));
1757 if (ctl->postconnect)
1758 printf(GT_(" Server connection will be taken down with \"%s\".\n"),
1759 visbuf(ctl->postconnect));
1760 else if (outlevel >= O_VERBOSE)
1761 printf(GT_(" No post-connection command.\n"));
1762 if (MAILBOX_PROTOCOL(ctl)) {
1763 if (!ctl->localnames)
1764 printf(GT_(" No localnames declared for this host.\n"));
1770 for (idp = ctl->localnames; idp; idp = idp->next)
1773 if (count > 1 || ctl->wildcard)
1774 printf(GT_(" Multi-drop mode: "));
1776 printf(GT_(" Single-drop mode: "));
1778 printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1779 if (outlevel >= O_VERBOSE)
1781 for (idp = ctl->localnames; idp; idp = idp->next)
1783 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1785 printf("\t%s\n", idp->id);
1787 fputs("\t*\n", stdout);
1790 if (count > 1 || ctl->wildcard)
1792 printf(ctl->server.dns
1793 ? GT_(" DNS lookup for multidrop addresses is enabled.\n")
1794 : GT_(" DNS lookup for multidrop addresses is disabled.\n"));
1795 if (ctl->server.dns)
1797 if (ctl->server.checkalias)
1798 printf(GT_(" Server aliases will be compared with multidrop addresses by IP address.\n"));
1800 printf(GT_(" Server aliases will be compared with multidrop addresses by name.\n"));
1802 if (ctl->server.envelope == STRING_DISABLED)
1803 printf(GT_(" Envelope-address routing is disabled\n"));
1806 printf(GT_(" Envelope header is assumed to be: %s\n"),
1807 ctl->server.envelope ? ctl->server.envelope : "Received");
1808 if (ctl->server.envskip || outlevel >= O_VERBOSE)
1809 printf(GT_(" Number of envelope headers to be skipped over: %d\n"),
1810 ctl->server.envskip);
1811 if (ctl->server.qvirtual)
1812 printf(GT_(" Prefix %s will be removed from user id\n"),
1813 ctl->server.qvirtual);
1814 else if (outlevel >= O_VERBOSE)
1815 printf(GT_(" No prefix stripping\n"));
1818 if (ctl->server.akalist)
1822 printf(GT_(" Predeclared mailserver aliases:"));
1823 for (idp = ctl->server.akalist; idp; idp = idp->next)
1824 printf(" %s", idp->id);
1827 if (ctl->server.localdomains)
1831 printf(GT_(" Local domains:"));
1832 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1833 printf(" %s", idp->id);
1840 if (ctl->server.interface)
1841 printf(GT_(" Connection must be through interface %s.\n"), ctl->server.interface);
1842 else if (outlevel >= O_VERBOSE)
1843 printf(GT_(" No interface requirement specified.\n"));
1844 if (ctl->server.monitor)
1845 printf(GT_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1846 else if (outlevel >= O_VERBOSE)
1847 printf(GT_(" No monitor interface specified.\n"));
1850 if (ctl->server.plugin)
1851 printf(GT_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1852 else if (outlevel >= O_VERBOSE)
1853 printf(GT_(" No plugin command specified.\n"));
1854 if (ctl->server.plugout)
1855 printf(GT_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1856 else if (outlevel >= O_VERBOSE)
1857 printf(GT_(" No plugout command specified.\n"));
1859 if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1862 printf(GT_(" No UIDs saved from this host.\n"));
1868 for (idp = ctl->oldsaved; idp; idp = idp->next)
1871 printf(GT_(" %d UIDs saved.\n"), count);
1872 if (outlevel >= O_VERBOSE)
1873 for (idp = ctl->oldsaved; idp; idp = idp->next)
1874 printf("\t%s\n", idp->id);
1878 if (ctl->server.tracepolls)
1879 printf(GT_(" Poll trace information will be added to the Received header.\n"));
1880 else if (outlevel >= O_VERBOSE)
1881 printf(GT_(" No poll trace information will be added to the Received header.\n.\n"));
1883 if (ctl->properties)
1884 printf(GT_(" Pass-through properties \"%s\".\n"),
1885 visbuf(ctl->properties));
1889 /* fetchmail.c ends here */