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>
28 #include <sys/time.h> /* needed for Sun 4.1.2 */
30 #include <sys/resource.h>
31 #endif /* HAVE_SETRLIMIT */
32 #include <sys/utsname.h>
34 #ifdef HAVE_NET_SOCKET_H
35 #include <net/socket.h>
37 #ifdef HAVE_GETHOSTBYNAME
39 #endif /* HAVE_GETHOSTBYNAME */
46 #include "fetchmail.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 flag check_only; /* if --probe was set */
70 flag versioninfo; /* emit only version info */
71 char *user; /* the name of the invoking user */
72 char *home; /* invoking user's home directory */
73 char *fmhome; /* fetchmail's home directory */
74 char *program_name; /* the name to prefix error messages with */
75 flag configdump; /* dump control blocks for configurator */
76 const char *fetchmailhost; /* either `localhost' or the host's FQDN */
81 #endif /* NET_SECURITY */
83 static char *lockfile; /* name of lockfile */
84 static int lock_acquired; /* have we acquired a lock */
85 static int querystatus; /* status of query */
86 static int successes; /* count number of successful polls */
87 static int activecount; /* count number of active entries */
88 static struct runctl cmd_run; /* global options set from command line */
89 static time_t parsetime; /* time of last parse */
91 static void terminate_run(int);
92 static void terminate_poll(int);
95 static void unlockit(int n, void *p)
97 static void unlockit(void)
99 /* must-do actions for exit (but we can't count on being able to do malloc) */
101 if (lockfile && lock_acquired)
105 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
106 /* drop SGID kmem privileage until we need it */
107 static void dropprivs(void)
117 if (gr && !strcmp(gr->gr_name, "kmem"))
119 extern void interface_set_gids(gid_t egid, gid_t rgid);
120 interface_set_gids(egid, rgid);
126 #if defined(HAVE_SETLOCALE) && defined(ENABLE_NLS) && defined(HAVE_STRFTIME)
129 static char *timestamp (void)
135 setlocale (LC_TIME, "");
136 strftime (buf, sizeof (buf), "%c", localtime(&now));
137 setlocale (LC_TIME, "C");
141 #define timestamp rfc822timestamp
144 int main(int argc, char **argv)
146 int st, bkgd = FALSE;
147 int parsestatus, implicitmode = FALSE;
150 netrc_entry *netrc_list;
151 char *netrc_file, *tmpbuf;
155 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
159 envquery(argc, argv);
161 bindtextdomain(PACKAGE, LOCALEDIR);
166 * Note: because we can't initialize reporting before we know whether
167 * syslog is supposed to be on, this message will go to stdout and
168 * be lost when running in background.
170 if (outlevel >= O_VERBOSE)
174 report(stdout, _("fetchmail: invoked with"));
175 for (i = 0; i < argc; i++)
176 report(stdout, " %s", argv[i]);
177 report(stdout, "\n");
180 #define IDFILE_NAME ".fetchids"
181 run.idfile = (char *) xmalloc(strlen(fmhome)+sizeof(IDFILE_NAME)+2);
182 strcpy(run.idfile, fmhome);
183 strcat(run.idfile, "/");
184 strcat(run.idfile, IDFILE_NAME);
189 * We used to arrange for the lockfile to be removed on exit close
190 * to where the lock was asserted. Now we need to do it here, because
191 * we might have re-executed in background with an existing lockfile
192 * as the result of a changed rcfile (see the code near the execvp(3)
193 * call near the beginning of the polling loop for details). We want
194 * to be sure the lockfile gets nuked on any error exit, basically.
200 on_exit(unlockit, (char *)NULL);
203 if ((parsestatus = parsecmdline(argc,argv, &cmd_run, &cmd_opts)) < 0)
208 printf(_("This is fetchmail release %s"), VERSION);
211 #endif /* POP2_ENABLE */
214 #endif /* POP3_ENABLE */
217 #endif /* IMAP_ENABLE */
223 #endif /* RPA_ENABLE */
226 #endif /* NTLM_ENABLE */
229 #endif /* SDPS_ENABLE */
232 #endif /* ETRN_ENABLE */
235 #endif /* ODMR_ENABLE */
241 #endif /* OPIE_ENABLE */
244 #endif /* INET6_ENABLE */
247 #endif /* NET_SECURITY */
250 #endif /* HAVE_SOCKS */
253 #endif /* ENABLE_NLS */
257 /* this is an attempt to help remote debugging */
261 /* avoid parsing the config file if all we're doing is killing a daemon */
262 if (!(quitmode && argc == 2))
263 implicitmode = load_params(argc, argv, optind);
265 #if defined(HAVE_SYSLOG)
266 /* logging should be set up early in case we were restarted from exec */
269 #if defined(LOG_MAIL)
270 openlog(program_name, LOG_PID, LOG_MAIL);
272 /* Assume BSD4.2 openlog with two arguments */
273 openlog(program_name, LOG_PID);
279 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
281 /* set up to do lock protocol */
282 #define FETCHMAIL_PIDFILE "fetchmail.pid"
284 xalloca(tmpbuf, char *,
285 sizeof(PID_DIR) + sizeof(FETCHMAIL_PIDFILE));
286 sprintf(tmpbuf, "%s/%s", PID_DIR, FETCHMAIL_PIDFILE);
288 xalloca(tmpbuf, char *, strlen(fmhome) + sizeof(FETCHMAIL_PIDFILE) + 2);
289 strcpy(tmpbuf, fmhome);
293 strcat(tmpbuf, FETCHMAIL_PIDFILE);
295 #undef FETCHMAIL_PIDFILE
297 #ifdef HAVE_SETRLIMIT
299 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
300 * Core dumps could otherwise contain passwords to be scavenged by a
303 if (outlevel < O_VERBOSE || run.poll_interval > 0)
305 struct rlimit corelimit;
306 corelimit.rlim_cur = 0;
307 corelimit.rlim_max = 0;
308 setrlimit(RLIMIT_CORE, &corelimit);
310 #endif /* HAVE_SETRLIMIT */
312 #define NETRC_FILE ".netrc"
313 /* parse the ~/.netrc file (if present) for future password lookups. */
314 xalloca(netrc_file, char *, strlen(home) + sizeof(NETRC_FILE) + 2);
315 strcpy (netrc_file, home);
316 strcat (netrc_file, "/");
317 strcat (netrc_file, NETRC_FILE);
318 netrc_list = parse_netrc(netrc_file);
321 /* pick up passwords where we can */
322 for (ctl = querylist; ctl; ctl = ctl->next)
324 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
326 if (ctl->server.preauthenticate == A_KERBEROS_V4 ||
327 ctl->server.preauthenticate == A_KERBEROS_V5 ||
328 ctl->server.preauthenticate == A_SSH ||
330 ctl->server.protocol == P_IMAP_GSS ||
332 ctl->server.protocol == P_IMAP_K4)
333 /* Server won't care what the password is, but there
334 must be some non-null string here. */
335 ctl->password = ctl->remotename;
340 /* look up the pollname and account in the .netrc file. */
341 p = search_netrc(netrc_list,
342 ctl->server.pollname, ctl->remotename);
343 /* if we find a matching entry with a password, use it */
344 if (p && p->password)
345 ctl->password = xstrdup(p->password);
347 /* otherwise try with "via" name if there is one */
348 else if (ctl->server.via)
350 p = search_netrc(netrc_list,
351 ctl->server.via, ctl->remotename);
352 if (p && p->password)
353 ctl->password = xstrdup(p->password);
359 /* perhaps we just want to check options? */
362 int havercfile = access(rcfile, 0);
364 printf(_("Taking options from command line%s%s\n"),
365 havercfile ? "" : _(" and "),
366 havercfile ? "" : rcfile);
368 if (outlevel >= O_VERBOSE)
369 printf(_("Lockfile at %s\n"), tmpbuf);
371 if (querylist == NULL)
373 _("No mailservers set up -- perhaps %s is missing?\n"),
376 dump_params(&run, querylist, implicitmode);
380 /* dump options as a Python dictionary, for configurator use */
383 dump_config(&run, querylist);
387 /* check for another fetchmail running concurrently */
389 if ((lockfile = (char *) malloc(strlen(tmpbuf) + 1)) == NULL)
391 report(stderr,_("fetchmail: cannot allocate memory for lock name.\n"));
395 (void) strcpy(lockfile, tmpbuf);
396 if ((lockfp = fopen(lockfile, "r")) != NULL )
398 bkgd = (fscanf(lockfp,"%d %d", &pid, &st) == 2);
400 if (kill(pid, 0) == -1) {
401 fprintf(stderr,_("fetchmail: removing stale lockfile\n"));
406 fclose(lockfp); /* not checking should be safe, file mode was "r" */
409 /* if no mail servers listed and nothing in background, we're done */
410 if (!(quitmode && argc == 2) && pid == -1 && querylist == NULL) {
411 (void)fputs(_("fetchmail: no mailservers have been specified.\n"),stderr);
415 /* perhaps user asked us to kill the other fetchmail */
420 fprintf(stderr,_("fetchmail: no other fetchmail is running\n"));
424 else if (kill(pid, SIGTERM) < 0)
426 fprintf(stderr,_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
427 bkgd ? _("background") : _("foreground"), pid);
432 fprintf(stderr,_("fetchmail: %s fetchmail at %d killed.\n"),
433 bkgd ? _("background") : _("foreground"), pid);
442 /* another fetchmail is running -- wake it up or die */
448 _("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
451 else if (!implicitmode)
454 _("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
461 _("fetchmail: another foreground fetchmail is running at %d.\n"),
467 /* this test enables re-execing on a changed rcfile */
469 lock_acquired = TRUE;
473 _("fetchmail: can't accept options while a background fetchmail is running.\n"));
477 else if (kill(pid, SIGUSR1) == 0)
480 _("fetchmail: background fetchmail at %d awakened.\n"),
487 * Should never happen -- possible only if a background fetchmail
488 * croaks after the first kill probe above but before the
489 * SIGUSR1/SIGHUP transmission.
492 _("fetchmail: elder sibling at %d died mysteriously.\n"),
494 return(PS_UNDEFINED);
498 /* pick up interactively any passwords we need but don't have */
499 for (ctl = querylist; ctl; ctl = ctl->next)
501 if (ctl->active && !(implicitmode && ctl->server.skip)
502 && ctl->server.protocol != P_ETRN
503 && ctl->server.protocol != P_IMAP_K4
505 && ctl->server.protocol != P_IMAP_GSS
512 _("fetchmail: can't find a password for %s@%s.\n"),
513 ctl->remotename, ctl->server.pollname);
518 char* password_prompt = _("Enter password for %s@%s: ");
520 xalloca(tmpbuf, char *, strlen(password_prompt) +
521 strlen(ctl->remotename) +
522 strlen(ctl->server.pollname) + 1);
523 (void) sprintf(tmpbuf, password_prompt,
524 ctl->remotename, ctl->server.pollname);
525 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
531 * Time to initiate the SOCKS library (this is not mandatory: it just
532 * registers the correct application name for logging purpose. If you
533 * have some problem, comment out these lines).
536 SOCKSinit("fetchmail");
537 #endif /* HAVE_SOCKS */
540 * Maybe time to go to demon mode...
542 if (run.poll_interval)
547 daemonize(run.logfile, terminate_run);
548 report(stdout, _("starting fetchmail %s daemon \n"), VERSION);
551 * We'll set up a handler for these when we're sleeping,
552 * but ignore them otherwise so as not to interrupt a poll.
554 signal(SIGUSR1, SIG_IGN);
555 if (run.poll_interval && !getuid())
556 signal(SIGHUP, SIG_IGN);
558 else if (run.logfile && access(run.logfile, F_OK) == 0)
560 freopen(run.logfile, "a", stdout);
561 freopen(run.logfile, "a", stderr);
569 /* beyond here we don't want more than one fetchmail running per user */
571 signal(SIGABRT, terminate_run);
572 signal(SIGINT, terminate_run);
573 signal(SIGTERM, terminate_run);
574 signal(SIGALRM, terminate_run);
575 signal(SIGPIPE, terminate_run);
576 signal(SIGQUIT, terminate_run);
578 /* here's the exclusion lock */
580 #define O_SYNC 0 /* use it if we have it */
584 if ((st = open(lockfile, O_WRONLY|O_CREAT|O_EXCL|O_SYNC, 0666)) != -1)
586 sprintf(tmpbuf,"%d", getpid());
587 write(st, tmpbuf, strlen(tmpbuf));
588 if (run.poll_interval)
590 sprintf(tmpbuf," %d", run.poll_interval);
591 write(st, tmpbuf, strlen(tmpbuf));
593 close(st); /* should be safe, fd was opened with O_SYNC */
594 lock_acquired = TRUE;
598 fprintf(stderr, _("fetchmail: lock creation failed.\n"));
604 * Query all hosts. If there's only one, the error return will
605 * reflect the status of that transaction.
609 * Check to see if the rcfile has been touched. If so,
610 * re-exec so the file will be reread. Doing it this way
611 * avoids all the complications of trying to deallocate the
612 * in-core control structures -- and the potential memory
617 if (stat(rcfile, &rcstat) == -1)
621 _("couldn't time-check %s (error %d)\n"),
624 else if (rcstat.st_mtime > parsetime)
626 report(stdout, _("restarting fetchmail (%s changed)\n"), rcfile);
628 * Matthias Andree: Isn't this prone to introduction of
629 * "false" programs by interfering with PATH? Those
630 * path-searching execs might not be the best ideas for
633 * Rob Funk: But is there any way for someone to modify
634 * the PATH variable of a running fetchmail? I don't know
637 * Dave's change makes fetchmail restart itself in exactly
638 * the way it was started from the shell (or shell script)
639 * in the first place. If you're concerned about PATH
640 * contamination, call fetchmail initially with a full
641 * path, and use Dave's patch.
643 * Not using a -p variant of exec means that the restart
644 * will break if both (a) the user depended on PATH to
645 * call fetchmail in the first place, and (b) the system
646 * doesn't save the whole path in argv[0] if the whole
647 * path wasn't used in the initial call. (If I recall
648 * correctly, Linux saves it but many other Unices don't.)
650 execvp(argv[0], argv);
651 report(stderr, _("attempt to re-exec fetchmail failed\n"));
654 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
656 * This was an efficiency hack that backfired. The theory
657 * was that using TCP/IP for DNS queries would get us better
658 * reliability and shave off some per-UDP-packet costs.
659 * Unfortunately it interacted badly with diald, which effectively
660 * filters out DNS queries over TCP/IP for reasons having to do
661 * with some obscure Linux kernel problem involving bootstrapping of
662 * dynamically-addressed links. I don't understand this mess
663 * and don't want to, so it's "See ya!" to this hack.
665 sethostent(TRUE); /* use TCP/IP for mailserver queries */
666 #endif /* HAVE_RES_SEARCH */
670 for (ctl = querylist; ctl; ctl = ctl->next)
674 if (!(implicitmode && ctl->server.skip))
679 _("poll of %s skipped (failed authentication or too many timeouts)\n"),
680 ctl->server.pollname);
684 /* check skip interval first so that it counts all polls */
685 if (run.poll_interval && ctl->server.interval)
687 if (ctl->server.poll_count++ % ctl->server.interval)
689 if (outlevel >= O_VERBOSE)
691 _("interval not reached, not querying %s\n"),
692 ctl->server.pollname);
697 #if (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__)
699 * Don't do monitoring if we were woken by a signal.
700 * Note that interface_approve() does its own error logging.
702 if (!interface_approve(&ctl->server, !lastsig))
704 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
706 querystatus = query_host(ctl);
709 /* leave the UIDL state alone if there have been any errors */
711 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
713 #endif /* POP3_ENABLE */
715 if (querystatus == PS_SUCCESS)
717 else if (!check_only &&
718 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
722 report(stdout,_("Query status=0 (SUCCESS)\n"));break;
724 report(stdout,_("Query status=1 (NOMAIL)\n")); break;
726 report(stdout,_("Query status=2 (SOCKET)\n")); break;
728 report(stdout,_("Query status=3 (AUTHFAIL)\n"));break;
730 report(stdout,_("Query status=4 (PROTOCOL)\n"));break;
732 report(stdout,_("Query status=5 (SYNTAX)\n")); break;
734 report(stdout,_("Query status=6 (IOERR)\n")); break;
736 report(stdout,_("Query status=7 (ERROR)\n")); break;
738 report(stdout,_("Query status=8 (EXCLUDE)\n")); break;
740 report(stdout,_("Query status=9 (LOCKBUSY)\n"));break;
742 report(stdout,_("Query status=10 (SMTP)\n")); break;
744 report(stdout,_("Query status=11 (DNS)\n")); break;
746 report(stdout,_("Query status=12 (BSMTP)\n")); break;
748 report(stdout,_("Query status=13 (MAXFETCH)\n"));break;
750 report(stdout,_("Query status=%d\n"),querystatus);
754 #if (defined(linux) && !INET6_ENABLE) || defined (__FreeBSD__)
755 if (ctl->server.monitor)
758 * Allow some time for the link to quiesce. One
759 * second is usually sufficient, three is safe.
760 * Note: this delay is important - don't remove!
763 interface_note_activity(&ctl->server);
765 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
769 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
770 endhostent(); /* release TCP/IP connection to nameserver */
771 #endif /* HAVE_RES_SEARCH */
773 /* close connections cleanly */
777 * OK, we've polled. Now sleep.
779 if (run.poll_interval)
782 * Because passwords can expire, it may happen that *all*
783 * hosts are now out of the loop due to authfail
784 * conditions. If this happens daemon-mode fetchmail
785 * should softly and silently vanish away, rather than
786 * spinning uselessly.
790 for (ctl = querylist; ctl; ctl = ctl->next)
791 if (ctl->active && !(implicitmode && ctl->server.skip))
796 report(stderr, _("All connections are wedged. Exiting.\n"));
797 /* FIXME: someday, send notification mail */
801 if (outlevel >= O_VERBOSE)
803 _("fetchmail: sleeping at %s\n"), timestamp());
806 * OK, now pause util it's time for the next poll cycle.
807 * A nonzero return indicates we received a wakeup signal;
808 * unwedge all servers in case the problem has been
811 if ((lastsig = interruptible_idle(run.poll_interval)))
813 #ifdef SYS_SIGLIST_DECLARED
815 _("awakened by %s\n"), sys_siglist[lastsig]);
818 _("awakened by signal %d\n"), lastsig);
820 for (ctl = querylist; ctl; ctl = ctl->next)
824 if (outlevel >= O_VERBOSE)
825 report(stdout, _("awakened at %s\n"), timestamp());
830 if (outlevel >= O_VERBOSE)
831 report(stdout, _("normal termination, status %d\n"),
832 successes ? PS_SUCCESS : querystatus);
835 exit(successes ? PS_SUCCESS : querystatus);
838 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
841 * If force is off, modify dstl fields only when they're empty (treat srcl
842 * as defaults). If force is on, modify each dstl field whenever scrcl
843 * is nonempty (treat srcl as an override).
845 if (force ? !!*srcl : !*dstl)
847 struct idlist *cpl = copy_str_list(*srcl);
849 append_str_list(dstl, &cpl);
853 static void optmerge(struct query *h2, struct query *h1, int force)
854 /* merge two options records */
856 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
857 list_merge(&h2->localnames, &h1->localnames, force);
858 list_merge(&h2->mailboxes, &h1->mailboxes, force);
859 list_merge(&h2->smtphunt, &h1->smtphunt, force);
860 list_merge(&h2->antispam, &h1->antispam, force);
862 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
863 FLAG_MERGE(server.via);
864 FLAG_MERGE(server.protocol);
866 FLAG_MERGE(server.service);
867 FLAG_MERGE(server.netsec);
868 #else /* INET6_ENABLE */
869 FLAG_MERGE(server.port);
870 #endif /* INET6_ENABLE */
871 FLAG_MERGE(server.interval);
872 FLAG_MERGE(server.preauthenticate);
873 FLAG_MERGE(server.timeout);
874 FLAG_MERGE(server.envelope);
875 FLAG_MERGE(server.envskip);
876 FLAG_MERGE(server.qvirtual);
877 FLAG_MERGE(server.skip);
878 FLAG_MERGE(server.dns);
879 FLAG_MERGE(server.checkalias);
880 FLAG_MERGE(server.uidl);
881 FLAG_MERGE(server.principal);
883 #if defined(linux) || defined(__FreeBSD__)
884 FLAG_MERGE(server.interface);
885 FLAG_MERGE(server.monitor);
886 FLAG_MERGE(server.interface_pair);
887 #endif /* linux || defined(__FreeBSD__) */
889 FLAG_MERGE(server.plugin);
890 FLAG_MERGE(server.plugout);
892 FLAG_MERGE(wildcard);
893 FLAG_MERGE(remotename);
894 FLAG_MERGE(password);
897 FLAG_MERGE(listener);
898 FLAG_MERGE(smtpaddress);
899 FLAG_MERGE(smtpname);
900 FLAG_MERGE(preconnect);
901 FLAG_MERGE(postconnect);
905 FLAG_MERGE(fetchall);
909 FLAG_MERGE(pass8bits);
910 FLAG_MERGE(dropstatus);
911 FLAG_MERGE(dropdelivered);
912 FLAG_MERGE(mimedecode);
915 FLAG_MERGE(warnings);
916 FLAG_MERGE(fetchlimit);
917 FLAG_MERGE(batchlimit);
925 FLAG_MERGE(properties);
929 static int load_params(int argc, char **argv, int optind)
931 int implicitmode, st;
933 struct query def_opts, *ctl;
936 run.bouncemail = TRUE;
937 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
939 memset(&def_opts, '\0', sizeof(struct query));
940 def_opts.smtp_socket = -1;
941 def_opts.smtpaddress = (char *)0;
942 def_opts.smtpname = (char *)0;
943 #define ANTISPAM(n) save_str(&def_opts.antispam, STRING_DUMMY, 0)->val.status.num = (n)
944 ANTISPAM(571); /* sendmail */
945 ANTISPAM(550); /* old exim */
946 ANTISPAM(501); /* new exim */
947 ANTISPAM(554); /* Postfix */
950 def_opts.server.protocol = P_AUTO;
951 def_opts.server.timeout = CLIENT_TIMEOUT;
952 def_opts.warnings = WARNING_INTERVAL;
953 def_opts.remotename = user;
954 def_opts.listener = SMTP_MODE;
956 /* note the parse time, so we can pick up on modifications */
957 parsetime = 0; /* foil compiler warnings */
958 if (stat(rcfile, &rcstat) != -1)
959 parsetime = rcstat.st_mtime;
960 else if (errno != ENOENT)
961 report(stderr, _("couldn't time-check the run-control file\n"));
963 /* this builds the host list */
964 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
966 * FIXME: someday, send notification mail here if backgrounded.
967 * Right now, that can happen if the user changes the rcfile
968 * while the fetchmail is running in background. Do similarly
969 * for the other exit() calls in this function.
973 if ((implicitmode = (optind >= argc)))
975 for (ctl = querylist; ctl; ctl = ctl->next)
979 for (; optind < argc; optind++)
981 flag predeclared = FALSE;
984 * If hostname corresponds to a host known from the rc file,
985 * simply declare it active. Otherwise synthesize a host
986 * record from command line and defaults
988 for (ctl = querylist; ctl; ctl = ctl->next)
989 if (!strcmp(ctl->server.pollname, argv[optind])
990 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
992 /* Is this correct? */
993 if (predeclared && outlevel == O_VERBOSE)
994 fprintf(stderr,_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1002 * Allocate and link record without copying in
1003 * command-line args; we'll do that with the optmerge
1006 ctl = hostalloc((struct query *)NULL);
1008 ctl->server.pollname = xstrdup(argv[optind]);
1010 ctl->server.lead_server = (struct hostdata *)NULL;
1015 * If there's a defaults record, merge it and lose it.
1017 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1019 for (ctl = querylist->next; ctl; ctl = ctl->next)
1020 optmerge(ctl, querylist, FALSE);
1021 querylist = querylist->next;
1024 /* don't allow a defaults record after the first */
1025 for (ctl = querylist; ctl; ctl = ctl->next)
1026 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0)
1029 /* use localhost if we never fetch the FQDN of this host */
1030 fetchmailhost = "localhost";
1032 /* here's where we override globals */
1033 if (cmd_run.logfile)
1034 run.logfile = cmd_run.logfile;
1036 run.idfile = cmd_run.idfile;
1037 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1038 if (cmd_run.poll_interval >= 0)
1039 run.poll_interval = cmd_run.poll_interval;
1040 if (cmd_run.invisible)
1041 run.invisible = cmd_run.invisible;
1042 if (cmd_run.showdots)
1043 run.showdots = cmd_run.showdots;
1044 if (cmd_run.use_syslog)
1045 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1046 if (cmd_run.postmaster)
1047 run.postmaster = cmd_run.postmaster;
1048 if (cmd_run.bouncemail)
1049 run.bouncemail = cmd_run.bouncemail;
1051 /* check and daemon options are not compatible */
1052 if (check_only && run.poll_interval)
1053 run.poll_interval = 0;
1055 /* merge in wired defaults, do sanity checks and prepare internal fields */
1056 for (ctl = querylist; ctl; ctl = ctl->next)
1058 ctl->wedged = FALSE;
1060 if (configdump || ctl->active )
1062 /* merge in defaults */
1063 optmerge(ctl, &def_opts, FALSE);
1065 /* force command-line options */
1066 optmerge(ctl, &cmd_opts, TRUE);
1068 /* this code enables flags to be turned off */
1069 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1071 else if (flag == FLAG_FALSE)\
1075 DEFAULT(ctl->keep, FALSE);
1076 DEFAULT(ctl->fetchall, FALSE);
1077 DEFAULT(ctl->flush, FALSE);
1078 DEFAULT(ctl->rewrite, TRUE);
1079 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1080 DEFAULT(ctl->forcecr, FALSE);
1081 DEFAULT(ctl->pass8bits, FALSE);
1082 DEFAULT(ctl->dropstatus, FALSE);
1083 DEFAULT(ctl->dropdelivered, FALSE);
1084 DEFAULT(ctl->mimedecode, FALSE);
1085 DEFAULT(ctl->idle, FALSE);
1086 DEFAULT(ctl->server.dns, TRUE);
1087 DEFAULT(ctl->server.uidl, FALSE);
1089 DEFAULT(ctl->use_ssl, FALSE);
1091 DEFAULT(ctl->server.checkalias, FALSE);
1095 * DNS support is required for some protocols. We used to
1096 * do this unconditionally, but it made fetchmail excessively
1097 * vulnerable to misconfigured DNS setups.
1099 * If we're using ETRN or ODMR, the smtp hunt list is the
1100 * list of systems we're polling on behalf of; these have
1101 * to be fully-qualified domain names. The default for
1102 * this list should be the FQDN of localhost.
1104 * If we're using Kerberos for authentication, we need
1105 * the FQDN in order to generate capability keys. */
1106 if (ctl->server.protocol == P_ETRN
1108 || ctl->server.protocol == P_ODMR
1109 #endif /* ODMR_ENABLE */
1110 || ctl->server.preauthenticate == A_KERBEROS_V4
1111 || ctl->server.preauthenticate == A_KERBEROS_V5)
1112 if (strcmp(fetchmailhost, "localhost") == 0)
1113 fetchmailhost = host_fqdn();
1116 * Make sure we have a nonempty host list to forward to.
1119 save_str(&ctl->smtphunt, fetchmailhost, FALSE);
1121 /* if `user' doesn't name a real local user, try to run as root */
1122 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1125 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1126 if (!ctl->localnames) /* for local delivery via SMTP */
1127 save_str_pair(&ctl->localnames, user, NULL);
1129 #if !defined(HAVE_GETHOSTBYNAME) || !defined(HAVE_RES_SEARCH)
1130 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1131 if (ctl->localnames && ctl->localnames->next && ctl->server.dns)
1133 ctl->server.dns = FALSE;
1134 report(stderr, _("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1136 #endif /* !HAVE_GETHOSTBYNAME || !HAVE_RES_SEARCH */
1140 * Compute the true name of the mailserver host.
1141 * There are two clashing cases here:
1143 * (1) The poll name is a label, possibly on one of several
1144 * poll configurations for the same host. In this case
1145 * the `via' option will be present and give the true name.
1147 * (2) The poll name is the true one, the via name is
1148 * localhost. This is going to be typical for ssh-using
1151 * We're going to assume the via name is true unless it's
1154 if (ctl->server.via && strcmp(ctl->server.via, "localhost"))
1155 ctl->server.queryname = xstrdup(ctl->server.via);
1157 ctl->server.queryname = xstrdup(ctl->server.pollname);
1160 /* If either the pollname or vianame are "hesiod" we want to
1161 lookup the user's hesiod pobox host */
1163 if (!strcasecmp(ctl->server.queryname, "hesiod")) {
1164 struct hes_postoffice *hes_p;
1165 hes_p = hes_getmailhost(ctl->remotename);
1166 if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
1167 free(ctl->server.queryname);
1168 ctl->server.queryname = xstrdup(hes_p->po_host);
1169 if (ctl->server.via)
1170 free(ctl->server.via);
1171 ctl->server.via = xstrdup(hes_p->po_host);
1174 _("couldn't find HESIOD pobox for %s\n"),
1181 * We may have to canonicalize the server truename for later use.
1182 * Do this just once for each lead server, if necessary, in order
1183 * to minimize DNS round trips.
1185 if (ctl->server.lead_server)
1187 char *leadname = ctl->server.lead_server->truename;
1189 /* prevent core dump from ill-formed or duplicate entry */
1192 report(stderr, _("Lead server has no name.\n"));
1196 ctl->server.truename = xstrdup(leadname);
1198 #ifdef HAVE_GETHOSTBYNAME
1199 else if (!configdump)
1201 if (ctl->server.preauthenticate==A_KERBEROS_V4 ||
1202 ctl->server.preauthenticate==A_KERBEROS_V5 ||
1203 (ctl->server.dns && MULTIDROP(ctl)))
1205 struct hostent *namerec;
1207 /* compute the canonical name of the host */
1209 namerec = gethostbyname(ctl->server.queryname);
1210 if (namerec == (struct hostent *)NULL)
1213 _("couldn't find canonical DNS name of %s\n"),
1214 ctl->server.pollname);
1215 ctl->server.truename = xstrdup(ctl->server.queryname);
1216 ctl->server.trueaddr = NULL;
1219 ctl->server.truename=xstrdup((char *)namerec->h_name);
1221 #endif /* HAVE_GETHOSTBYNAME */
1223 #ifdef HAVE_GETHOSTBYNAME
1224 struct hostent *namerec;
1226 /* <fetchmail@mail.julianhaight.com>
1227 Get the host's IP, so we can report it like this:
1229 Received: from hostname [10.0.0.1]
1231 do we actually need to gethostbyname to find the IP?
1232 it seems like it would be faster to do this later, when
1233 we are actually resolving the hostname for a connection,
1234 but I ain't that smart, so I don't know where to make
1238 namerec = gethostbyname(ctl->server.queryname);
1239 if (namerec == (struct hostent *)NULL)
1242 _("couldn't find canonical DNS name of %s\n"),
1243 ctl->server.pollname);
1247 ctl->server.truename=xstrdup((char *)namerec->h_name);
1248 ctl->server.trueaddr=xmalloc(namerec->h_length);
1249 memcpy(ctl->server.trueaddr,
1250 namerec->h_addr_list[0],
1254 ctl->server.truename = xstrdup(ctl->server.queryname);
1255 #endif /* HAVE_GETHOSTBYNAME */
1259 /* if no folders were specified, set up the null one as default */
1260 if (!ctl->mailboxes)
1261 save_str(&ctl->mailboxes, (char *)NULL, 0);
1263 /* maybe user overrode timeout on command line? */
1264 if (ctl->server.timeout == -1)
1265 ctl->server.timeout = CLIENT_TIMEOUT;
1269 if (ctl->server.port < 0)
1271 (void) fprintf(stderr,
1272 _("%s configuration invalid, port number cannot be negative\n"),
1273 ctl->server.pollname);
1276 if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
1278 (void) fprintf(stderr,
1279 _("%s configuration invalid, RPOP requires a privileged port\n"),
1280 ctl->server.pollname);
1283 if (ctl->listener == LMTP_MODE)
1287 for (idp = ctl->smtphunt; idp; idp = idp->next)
1291 if (!(cp = strrchr(idp->id, '/')) ||
1292 (atoi(++cp) == SMTP_PORT))
1294 (void) fprintf(stderr,
1295 _("%s configuration invalid, LMTP can't use default SMTP port\n"),
1296 ctl->server.pollname);
1301 #endif /* !INET6_ENABLE */
1304 * "I beg to you, have mercy on the week minds like myself."
1305 * wrote Pehr Anderson. Your petition is granted.
1307 if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
1309 (void) fprintf(stderr,
1310 _("Both fetchall and keep on in daemon mode is a mistake!\n"));
1317 /* initialize UID handling */
1318 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
1321 initialize_saved_lists(querylist, run.idfile);
1322 #endif /* POP3_ENABLE */
1325 * If the user didn't set a last-resort user to get misaddressed
1326 * multidrop mail, set an appropriate default here.
1328 if (!run.postmaster)
1330 if (getuid()) /* ordinary user */
1331 run.postmaster = user;
1333 run.postmaster = "postmaster";
1336 return(implicitmode);
1339 static void terminate_poll(int sig)
1340 /* to be executed at the end of a poll cycle */
1343 * Close all SMTP delivery sockets. For optimum performance
1344 * we'd like to hold them open til end of run, but (1) this
1345 * loses if our poll interval is longer than the MTA's inactivity
1346 * timeout, and (2) some MTAs (like smail) don't deliver after
1347 * each message, but rather queue up mail and wait to actually
1348 * deliver it until the input socket is closed.
1350 * Sending SMTP QUIT on signal is theoretically nice, but led to a
1351 * subtle bug. If fetchmail was terminated by signal while it was
1352 * shipping message text, it would hang forever waiting for a
1353 * command acknowledge. In theory we could enable the QUIT
1354 * only outside of the message send. In practice, we don't
1355 * care. All mailservers hang up on a dropped TCP/IP connection
1360 report(stdout, _("terminated with signal %d\n"), sig);
1365 /* terminate all SMTP connections cleanly */
1366 for (ctl = querylist; ctl; ctl = ctl->next)
1367 if (ctl->smtp_socket != -1)
1369 SMTP_quit(ctl->smtp_socket);
1370 SockClose(ctl->smtp_socket);
1371 ctl->smtp_socket = -1;
1377 * Update UID information at end of each poll, rather than at end
1378 * of run, because that way we don't lose all UIDL information since
1379 * the beginning of time if fetchmail crashes.
1382 write_saved_lists(querylist, run.idfile);
1383 #endif /* POP3_ENABLE */
1386 static void terminate_run(int sig)
1387 /* to be executed on normal or signal-induced termination */
1391 terminate_poll(sig);
1394 * Craig Metz, the RFC1938 one-time-password guy, points out:
1395 * "Remember that most kernels don't zero pages before handing them to the
1396 * next process and many kernels share pages between user and kernel space.
1397 * You'd be very surprised what you can find from a short program to do a
1398 * malloc() and then dump the contents of the pages you got. By zeroing
1399 * the secrets at end of run (earlier if you can), you make sure the next
1400 * guy can't get the password/pass phrase."
1402 * Right you are, Craig!
1404 for (ctl = querylist; ctl; ctl = ctl->next)
1406 memset(ctl->password, '\0', strlen(ctl->password));
1408 #if !defined(HAVE_ATEXIT) && !defined(HAVE_ON_EXIT)
1412 if (activecount == 0)
1415 exit(successes ? PS_SUCCESS : querystatus);
1419 * Sequence of protocols to try when autoprobing, most capable to least.
1421 static const int autoprobe[] =
1425 #endif /* IMAP_ENABLE */
1428 #endif /* POP3_ENABLE */
1431 #endif /* POP2_ENABLE */
1434 static int query_host(struct query *ctl)
1435 /* perform fetch transaction with single host */
1440 * If we're syslogging the progress messages are automatically timestamped.
1441 * Force timestamping if we're going to a logfile.
1443 if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
1445 report(stdout, _("%s querying %s (protocol %s) at %s\n"),
1447 ctl->server.pollname,
1448 showproto(ctl->server.protocol),
1451 switch (ctl->server.protocol) {
1453 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1455 ctl->server.protocol = autoprobe[i];
1456 if ((st = query_host(ctl)) == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP)
1459 ctl->server.protocol = P_AUTO;
1463 return(doPOP2(ctl));
1465 report(stderr, _("POP2 support is not configured.\n"));
1466 return(PS_PROTOCOL);
1467 #endif /* POP2_ENABLE */
1473 return(doPOP3(ctl));
1475 report(stderr, _("POP3 support is not configured.\n"));
1476 return(PS_PROTOCOL);
1477 #endif /* POP3_ENABLE */
1481 case P_IMAP_CRAM_MD5:
1487 return(doIMAP(ctl));
1489 report(stderr, _("IMAP support is not configured.\n"));
1490 return(PS_PROTOCOL);
1491 #endif /* IMAP_ENABLE */
1494 report(stderr, _("ETRN support is not configured.\n"));
1495 return(PS_PROTOCOL);
1497 #ifdef HAVE_GETHOSTBYNAME
1498 return(doETRN(ctl));
1500 report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
1501 return(PS_PROTOCOL);
1502 #endif /* HAVE_GETHOSTBYNAME */
1503 #endif /* ETRN_ENABLE */
1506 report(stderr, _("ODMR support is not configured.\n"));
1507 return(PS_PROTOCOL);
1509 #ifdef HAVE_GETHOSTBYNAME
1510 return(doODMR(ctl));
1512 report(stderr, _("Cannot support ODMR without gethostbyname(2).\n"));
1513 return(PS_PROTOCOL);
1514 #endif /* HAVE_GETHOSTBYNAME */
1515 #endif /* ODMR_ENABLE */
1517 report(stderr, _("unsupported protocol selected.\n"));
1518 return(PS_PROTOCOL);
1522 static void dump_params (struct runctl *runp,
1523 struct query *querylist, flag implicit)
1524 /* display query parameters in English */
1528 if (runp->poll_interval)
1529 printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
1531 printf(_("Logfile is %s\n"), runp->logfile);
1532 if (strcmp(runp->idfile, IDFILE_NAME))
1533 printf(_("Idfile is %s\n"), runp->idfile);
1534 #if defined(HAVE_SYSLOG)
1535 if (runp->use_syslog)
1536 printf(_("Progress messages will be logged via syslog\n"));
1538 if (runp->invisible)
1539 printf(_("Fetchmail will masquerade and will not generate Received\n"));
1541 printf(_("Fetchmail will show progress dots even in logfiles.\n"));
1542 if (runp->postmaster)
1543 printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1546 if (!runp->bouncemail)
1547 printf(_("Fetchmail will direct error mail to the postmaster.\n"));
1548 else if (outlevel >= O_VERBOSE)
1549 printf(_("Fetchmail will direct error mail to the sender.\n"));
1551 for (ctl = querylist; ctl; ctl = ctl->next)
1553 if (!ctl->active || (implicit && ctl->server.skip))
1556 printf(_("Options for retrieving from %s@%s:\n"),
1557 ctl->remotename, visbuf(ctl->server.pollname));
1559 if (ctl->server.via && (ctl->server.protocol < P_ETRN))
1560 printf(_(" Mail will be retrieved via %s\n"), ctl->server.via);
1562 if (ctl->server.interval)
1563 printf(_(" Poll of this server will occur every %d intervals.\n"),
1564 ctl->server.interval);
1565 if (ctl->server.truename)
1566 printf(_(" True name of server is %s.\n"), ctl->server.truename);
1567 if (ctl->server.skip || outlevel >= O_VERBOSE)
1568 printf(_(" This host %s be queried when no host is specified.\n"),
1569 ctl->server.skip ? _("will not") : _("will"));
1571 * Don't poll for password when there is one or when using the ETRN
1572 * or IMAP-GSS protocol
1574 /* ETRN, IMAP_GSS, and IMAP_K4 do not need a password, so skip this */
1575 if ( (ctl->server.protocol != P_ETRN)
1577 && (ctl->server.protocol != P_IMAP_GSS)
1579 && (ctl->server.protocol != P_IMAP_K4) ) {
1581 printf(_(" Password will be prompted for.\n"));
1582 else if (outlevel >= O_VERBOSE)
1584 if (ctl->server.protocol == P_APOP)
1585 printf(_(" APOP secret = \"%s\".\n"),
1586 visbuf(ctl->password));
1587 else if (ctl->server.protocol == P_RPOP)
1588 printf(_(" RPOP id = \"%s\".\n"),
1589 visbuf(ctl->password));
1591 printf(_(" Password = \"%s\".\n"),
1592 visbuf(ctl->password));
1596 if (ctl->server.protocol == P_POP3
1598 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1599 #else /* INET6_ENABLE */
1600 && ctl->server.port == KPOP_PORT
1601 #endif /* INET6_ENABLE */
1602 && (ctl->server.preauthenticate == A_KERBEROS_V4 ||
1603 ctl->server.preauthenticate == A_KERBEROS_V5))
1604 printf(_(" Protocol is KPOP with Kerberos %s authentication"),
1605 ctl->server.preauthenticate == A_KERBEROS_V5 ? "V" : "IV");
1607 printf(_(" Protocol is %s"), showproto(ctl->server.protocol));
1609 if (ctl->server.service)
1610 printf(_(" (using service %s)"), ctl->server.service);
1611 if (ctl->server.netsec)
1612 printf(_(" (using network security options %s)"), ctl->server.netsec);
1613 #else /* INET6_ENABLE */
1614 if (ctl->server.port)
1615 printf(_(" (using port %d)"), ctl->server.port);
1616 #endif /* INET6_ENABLE */
1617 else if (outlevel >= O_VERBOSE)
1618 printf(_(" (using default port)"));
1619 if (ctl->server.uidl && (ctl->server.protocol < P_ETRN))
1620 printf(_(" (forcing UIDL use)"));
1623 if (ctl->server.preauthenticate == A_KERBEROS_V4)
1624 printf(_(" Kerberos V4 preauthentication enabled.\n"));
1625 else if (ctl->server.preauthenticate == A_KERBEROS_V5)
1626 printf(_(" Kerberos V5 preauthentication enabled.\n"));
1627 else if (ctl->server.preauthenticate == A_SSH)
1628 printf(_(" End-to-end encryption assumed.\n"));
1629 if (ctl->server.principal != (char *) NULL) {
1630 printf(_(" Mail service principal is: %s\n"), ctl->server.principal);
1634 printf(" SSL encrypted sessions enabled.\n");
1636 if (ctl->server.timeout > 0)
1637 printf(_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1638 if (ctl->server.timeout == CLIENT_TIMEOUT)
1639 printf(_(" (default).\n"));
1643 if (ctl->server.protocol < P_ETRN) {
1644 if (!ctl->mailboxes->id)
1645 printf(_(" Default mailbox selected.\n"));
1650 printf(_(" Selected mailboxes are:"));
1651 for (idp = ctl->mailboxes; idp; idp = idp->next)
1652 printf(" %s", idp->id);
1655 printf(_(" %s messages will be retrieved (--all %s).\n"),
1656 ctl->fetchall ? _("All") : _("Only new"),
1657 ctl->fetchall ? "on" : "off");
1658 printf(_(" Fetched messages %s be kept on the server (--keep %s).\n"),
1659 ctl->keep ? _("will") : _("will not"),
1660 ctl->keep ? "on" : "off");
1661 printf(_(" Old messages %s be flushed before message retrieval (--flush %s).\n"),
1662 ctl->flush ? _("will") : _("will not"),
1663 ctl->flush ? "on" : "off");
1664 printf(_(" Rewrite of server-local addresses is %s (--norewrite %s).\n"),
1665 ctl->rewrite ? _("enabled") : _("disabled"),
1666 ctl->rewrite ? "off" : "on");
1667 printf(_(" Carriage-return stripping is %s (stripcr %s).\n"),
1668 ctl->stripcr ? _("enabled") : _("disabled"),
1669 ctl->stripcr ? "on" : "off");
1670 printf(_(" Carriage-return forcing is %s (forcecr %s).\n"),
1671 ctl->forcecr ? _("enabled") : _("disabled"),
1672 ctl->forcecr ? "on" : "off");
1673 printf(_(" Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
1674 ctl->pass8bits ? _("disabled") : _("enabled"),
1675 ctl->pass8bits ? "on" : "off");
1676 printf(_(" MIME decoding is %s (mimedecode %s).\n"),
1677 ctl->mimedecode ? _("enabled") : _("disabled"),
1678 ctl->mimedecode ? "on" : "off");
1679 printf(_(" Idle after poll is %s (idle %s).\n"),
1680 ctl->idle ? _("enabled") : _("disabled"),
1681 ctl->idle ? "on" : "off");
1682 printf(_(" Nonempty Status lines will be %s (dropstatus %s)\n"),
1683 ctl->dropstatus ? _("discarded") : _("kept"),
1684 ctl->dropstatus ? "on" : "off");
1685 printf(_(" Delivered-To lines will be %s (dropdelivered %s)\n"),
1686 ctl->dropdelivered ? _("discarded") : _("kept"),
1687 ctl->dropdelivered ? "on" : "off");
1688 if (NUM_NONZERO(ctl->limit))
1690 if (NUM_NONZERO(ctl->limit))
1691 printf(_(" Message size limit is %d octets (--limit %d).\n"),
1692 ctl->limit, ctl->limit);
1693 else if (outlevel >= O_VERBOSE)
1694 printf(_(" No message size limit (--limit 0).\n"));
1695 if (run.poll_interval > 0)
1696 printf(_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1697 ctl->warnings, ctl->warnings);
1698 else if (outlevel >= O_VERBOSE)
1699 printf(_(" Size warnings on every poll (--warnings 0).\n"));
1701 if (NUM_NONZERO(ctl->fetchlimit))
1702 printf(_(" Received-message limit is %d (--fetchlimit %d).\n"),
1703 ctl->fetchlimit, ctl->fetchlimit);
1704 else if (outlevel >= O_VERBOSE)
1705 printf(_(" No received-message limit (--fetchlimit 0).\n"));
1706 if (NUM_NONZERO(ctl->batchlimit))
1707 printf(_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1708 else if (outlevel >= O_VERBOSE)
1709 printf(_(" No SMTP message batch limit (--batchlimit 0).\n"));
1710 if (ctl->server.protocol < P_ETRN)
1712 if (NUM_NONZERO(ctl->expunge))
1713 printf(_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1714 else if (outlevel >= O_VERBOSE)
1715 printf(_(" No forced expunges (--expunge 0).\n"));
1719 printf(_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1720 else if (ctl->mda && (ctl->server.protocol < P_ETRN))
1721 printf(_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1726 printf(_(" Messages will be %cMTP-forwarded to:"), ctl->listener);
1727 for (idp = ctl->smtphunt; idp; idp = idp->next)
1729 printf(" %s", idp->id);
1730 if (!idp->val.status.mark)
1731 printf(_(" (default)"));
1734 if (ctl->smtpaddress)
1735 printf(_(" Host part of MAIL FROM line will be %s\n"),
1738 printf(_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1741 if (ctl->server.protocol < P_ETRN)
1743 if (ctl->antispam != (struct idlist *)NULL)
1747 printf(_(" Recognized listener spam block responses are:"));
1748 for (idp = ctl->antispam; idp; idp = idp->next)
1749 printf(" %d", idp->val.status.num);
1752 else if (outlevel >= O_VERBOSE)
1753 printf(_(" Spam-blocking disabled\n"));
1755 if (ctl->preconnect)
1756 printf(_(" Server connection will be brought up with \"%s\".\n"),
1757 visbuf(ctl->preconnect));
1758 else if (outlevel >= O_VERBOSE)
1759 printf(_(" No pre-connection command.\n"));
1760 if (ctl->postconnect)
1761 printf(_(" Server connection will be taken down with \"%s\".\n"),
1762 visbuf(ctl->postconnect));
1763 else if (outlevel >= O_VERBOSE)
1764 printf(_(" No post-connection command.\n"));
1765 if (ctl->server.protocol < P_ETRN) {
1766 if (!ctl->localnames)
1767 printf(_(" No localnames declared for this host.\n"));
1773 for (idp = ctl->localnames; idp; idp = idp->next)
1776 if (count > 1 || ctl->wildcard)
1777 printf(_(" Multi-drop mode: "));
1779 printf(_(" Single-drop mode: "));
1781 printf(_("%d local name(s) recognized.\n"), count);
1782 if (outlevel >= O_VERBOSE)
1784 for (idp = ctl->localnames; idp; idp = idp->next)
1786 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1788 printf("\t%s\n", idp->id);
1790 fputs("\t*\n", stdout);
1793 if (count > 1 || ctl->wildcard)
1795 printf(_(" DNS lookup for multidrop addresses is %s.\n"),
1796 ctl->server.dns ? _("enabled") : _("disabled"));
1797 if (ctl->server.dns)
1799 printf(_(" Server aliases will be compared with multidrop addresses by "));
1800 if (ctl->server.checkalias)
1801 printf(_("IP address.\n"));
1803 printf(_("name.\n"));
1805 if (ctl->server.envelope == STRING_DISABLED)
1806 printf(_(" Envelope-address routing is disabled\n"));
1809 printf(_(" Envelope header is assumed to be: %s\n"),
1810 ctl->server.envelope ? ctl->server.envelope:_("Received"));
1811 if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
1812 printf(_(" Number of envelope header to be parsed: %d\n"),
1813 ctl->server.envskip);
1814 if (ctl->server.qvirtual)
1815 printf(_(" Prefix %s will be removed from user id\n"),
1816 ctl->server.qvirtual);
1817 else if (outlevel >= O_VERBOSE)
1818 printf(_(" No prefix stripping\n"));
1821 if (ctl->server.akalist)
1825 printf(_(" Predeclared mailserver aliases:"));
1826 for (idp = ctl->server.akalist; idp; idp = idp->next)
1827 printf(" %s", idp->id);
1830 if (ctl->server.localdomains)
1834 printf(_(" Local domains:"));
1835 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1836 printf(" %s", idp->id);
1842 #if defined(linux) || defined(__FreeBSD__)
1843 if (ctl->server.interface)
1844 printf(_(" Connection must be through interface %s.\n"), ctl->server.interface);
1845 else if (outlevel >= O_VERBOSE)
1846 printf(_(" No interface requirement specified.\n"));
1847 if (ctl->server.monitor)
1848 printf(_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1849 else if (outlevel >= O_VERBOSE)
1850 printf(_(" No monitor interface specified.\n"));
1853 if (ctl->server.plugin)
1854 printf(_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1855 else if (outlevel >= O_VERBOSE)
1856 printf(_(" No plugin command specified.\n"));
1857 if (ctl->server.plugout)
1858 printf(_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1859 else if (outlevel >= O_VERBOSE)
1860 printf(_(" No plugout command specified.\n"));
1862 if (ctl->server.protocol > P_POP2 && (ctl->server.protocol < P_ETRN))
1865 printf(_(" No UIDs saved from this host.\n"));
1871 for (idp = ctl->oldsaved; idp; idp = idp->next)
1874 printf(_(" %d UIDs saved.\n"), count);
1875 if (outlevel >= O_VERBOSE)
1876 for (idp = ctl->oldsaved; idp; idp = idp->next)
1877 printf("\t%s\n", idp->id);
1881 if (ctl->properties)
1882 printf(_(" Pass-through properties \"%s\".\n"),
1883 visbuf(ctl->properties));
1887 /* fetchmail.c ends here */