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_PASSWORD)
327 /* Server won't care what the password is, but there
328 must be some non-null string here. */
329 ctl->password = ctl->remotename;
334 /* look up the pollname and account in the .netrc file. */
335 p = search_netrc(netrc_list,
336 ctl->server.pollname, ctl->remotename);
337 /* if we find a matching entry with a password, use it */
338 if (p && p->password)
339 ctl->password = xstrdup(p->password);
341 /* otherwise try with "via" name if there is one */
342 else if (ctl->server.via)
344 p = search_netrc(netrc_list,
345 ctl->server.via, ctl->remotename);
346 if (p && p->password)
347 ctl->password = xstrdup(p->password);
353 /* perhaps we just want to check options? */
356 int havercfile = access(rcfile, 0);
358 printf(_("Taking options from command line%s%s\n"),
359 havercfile ? "" : _(" and "),
360 havercfile ? "" : rcfile);
362 if (outlevel >= O_VERBOSE)
363 printf(_("Lockfile at %s\n"), tmpbuf);
365 if (querylist == NULL)
367 _("No mailservers set up -- perhaps %s is missing?\n"),
370 dump_params(&run, querylist, implicitmode);
374 /* dump options as a Python dictionary, for configurator use */
377 dump_config(&run, querylist);
381 /* check for another fetchmail running concurrently */
383 if ((lockfile = (char *) malloc(strlen(tmpbuf) + 1)) == NULL)
385 report(stderr,_("fetchmail: cannot allocate memory for lock name.\n"));
389 (void) strcpy(lockfile, tmpbuf);
390 if ((lockfp = fopen(lockfile, "r")) != NULL )
392 bkgd = (fscanf(lockfp,"%d %d", &pid, &st) == 2);
394 if (kill(pid, 0) == -1) {
395 fprintf(stderr,_("fetchmail: removing stale lockfile\n"));
400 fclose(lockfp); /* not checking should be safe, file mode was "r" */
403 /* if no mail servers listed and nothing in background, we're done */
404 if (!(quitmode && argc == 2) && pid == -1 && querylist == NULL) {
405 (void)fputs(_("fetchmail: no mailservers have been specified.\n"),stderr);
409 /* perhaps user asked us to kill the other fetchmail */
414 fprintf(stderr,_("fetchmail: no other fetchmail is running\n"));
418 else if (kill(pid, SIGTERM) < 0)
420 fprintf(stderr,_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
421 bkgd ? _("background") : _("foreground"), pid);
426 fprintf(stderr,_("fetchmail: %s fetchmail at %d killed.\n"),
427 bkgd ? _("background") : _("foreground"), pid);
436 /* another fetchmail is running -- wake it up or die */
442 _("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
445 else if (!implicitmode)
448 _("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
455 _("fetchmail: another foreground fetchmail is running at %d.\n"),
461 /* this test enables re-execing on a changed rcfile */
463 lock_acquired = TRUE;
467 _("fetchmail: can't accept options while a background fetchmail is running.\n"));
471 else if (kill(pid, SIGUSR1) == 0)
474 _("fetchmail: background fetchmail at %d awakened.\n"),
481 * Should never happen -- possible only if a background fetchmail
482 * croaks after the first kill probe above but before the
483 * SIGUSR1/SIGHUP transmission.
486 _("fetchmail: elder sibling at %d died mysteriously.\n"),
488 return(PS_UNDEFINED);
492 /* pick up interactively any passwords we need but don't have */
493 for (ctl = querylist; ctl; ctl = ctl->next)
495 if (ctl->active && !(implicitmode && ctl->server.skip)
496 && ctl->server.preauthenticate == A_PASSWORD
502 _("fetchmail: can't find a password for %s@%s.\n"),
503 ctl->remotename, ctl->server.pollname);
508 char* password_prompt = _("Enter password for %s@%s: ");
510 xalloca(tmpbuf, char *, strlen(password_prompt) +
511 strlen(ctl->remotename) +
512 strlen(ctl->server.pollname) + 1);
513 (void) sprintf(tmpbuf, password_prompt,
514 ctl->remotename, ctl->server.pollname);
515 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
521 * Time to initiate the SOCKS library (this is not mandatory: it just
522 * registers the correct application name for logging purpose. If you
523 * have some problem, comment out these lines).
526 SOCKSinit("fetchmail");
527 #endif /* HAVE_SOCKS */
530 * Maybe time to go to demon mode...
532 if (run.poll_interval)
537 daemonize(run.logfile, terminate_run);
538 report(stdout, _("starting fetchmail %s daemon \n"), VERSION);
541 * We'll set up a handler for these when we're sleeping,
542 * but ignore them otherwise so as not to interrupt a poll.
544 signal(SIGUSR1, SIG_IGN);
545 if (run.poll_interval && !getuid())
546 signal(SIGHUP, SIG_IGN);
548 else if (run.logfile && access(run.logfile, F_OK) == 0)
550 freopen(run.logfile, "a", stdout);
551 freopen(run.logfile, "a", stderr);
559 /* beyond here we don't want more than one fetchmail running per user */
561 signal(SIGABRT, terminate_run);
562 signal(SIGINT, terminate_run);
563 signal(SIGTERM, terminate_run);
564 signal(SIGALRM, terminate_run);
565 signal(SIGPIPE, terminate_run);
566 signal(SIGQUIT, terminate_run);
568 /* here's the exclusion lock */
570 #define O_SYNC 0 /* use it if we have it */
574 if ((st = open(lockfile, O_WRONLY|O_CREAT|O_EXCL|O_SYNC, 0666)) != -1)
576 sprintf(tmpbuf,"%d", getpid());
577 write(st, tmpbuf, strlen(tmpbuf));
578 if (run.poll_interval)
580 sprintf(tmpbuf," %d", run.poll_interval);
581 write(st, tmpbuf, strlen(tmpbuf));
583 close(st); /* should be safe, fd was opened with O_SYNC */
584 lock_acquired = TRUE;
588 fprintf(stderr, _("fetchmail: lock creation failed.\n"));
594 * Query all hosts. If there's only one, the error return will
595 * reflect the status of that transaction.
599 * Check to see if the rcfile has been touched. If so,
600 * re-exec so the file will be reread. Doing it this way
601 * avoids all the complications of trying to deallocate the
602 * in-core control structures -- and the potential memory
607 if (stat(rcfile, &rcstat) == -1)
611 _("couldn't time-check %s (error %d)\n"),
614 else if (rcstat.st_mtime > parsetime)
616 report(stdout, _("restarting fetchmail (%s changed)\n"), rcfile);
618 * Matthias Andree: Isn't this prone to introduction of
619 * "false" programs by interfering with PATH? Those
620 * path-searching execs might not be the best ideas for
623 * Rob Funk: But is there any way for someone to modify
624 * the PATH variable of a running fetchmail? I don't know
627 * Dave's change makes fetchmail restart itself in exactly
628 * the way it was started from the shell (or shell script)
629 * in the first place. If you're concerned about PATH
630 * contamination, call fetchmail initially with a full
631 * path, and use Dave's patch.
633 * Not using a -p variant of exec means that the restart
634 * will break if both (a) the user depended on PATH to
635 * call fetchmail in the first place, and (b) the system
636 * doesn't save the whole path in argv[0] if the whole
637 * path wasn't used in the initial call. (If I recall
638 * correctly, Linux saves it but many other Unices don't.)
640 execvp(argv[0], argv);
641 report(stderr, _("attempt to re-exec fetchmail failed\n"));
644 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
646 * This was an efficiency hack that backfired. The theory
647 * was that using TCP/IP for DNS queries would get us better
648 * reliability and shave off some per-UDP-packet costs.
649 * Unfortunately it interacted badly with diald, which effectively
650 * filters out DNS queries over TCP/IP for reasons having to do
651 * with some obscure Linux kernel problem involving bootstrapping of
652 * dynamically-addressed links. I don't understand this mess
653 * and don't want to, so it's "See ya!" to this hack.
655 sethostent(TRUE); /* use TCP/IP for mailserver queries */
656 #endif /* HAVE_RES_SEARCH */
660 for (ctl = querylist; ctl; ctl = ctl->next)
664 if (!(implicitmode && ctl->server.skip))
669 _("poll of %s skipped (failed authentication or too many timeouts)\n"),
670 ctl->server.pollname);
674 /* check skip interval first so that it counts all polls */
675 if (run.poll_interval && ctl->server.interval)
677 if (ctl->server.poll_count++ % ctl->server.interval)
679 if (outlevel >= O_VERBOSE)
681 _("interval not reached, not querying %s\n"),
682 ctl->server.pollname);
687 #if (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__)
689 * Don't do monitoring if we were woken by a signal.
690 * Note that interface_approve() does its own error logging.
692 if (!interface_approve(&ctl->server, !lastsig))
694 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
696 querystatus = query_host(ctl);
699 /* leave the UIDL state alone if there have been any errors */
701 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
703 #endif /* POP3_ENABLE */
705 if (querystatus == PS_SUCCESS)
707 else if (!check_only &&
708 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
712 report(stdout,_("Query status=0 (SUCCESS)\n"));break;
714 report(stdout,_("Query status=1 (NOMAIL)\n")); break;
716 report(stdout,_("Query status=2 (SOCKET)\n")); break;
718 report(stdout,_("Query status=3 (AUTHFAIL)\n"));break;
720 report(stdout,_("Query status=4 (PROTOCOL)\n"));break;
722 report(stdout,_("Query status=5 (SYNTAX)\n")); break;
724 report(stdout,_("Query status=6 (IOERR)\n")); break;
726 report(stdout,_("Query status=7 (ERROR)\n")); break;
728 report(stdout,_("Query status=8 (EXCLUDE)\n")); break;
730 report(stdout,_("Query status=9 (LOCKBUSY)\n"));break;
732 report(stdout,_("Query status=10 (SMTP)\n")); break;
734 report(stdout,_("Query status=11 (DNS)\n")); break;
736 report(stdout,_("Query status=12 (BSMTP)\n")); break;
738 report(stdout,_("Query status=13 (MAXFETCH)\n"));break;
740 report(stdout,_("Query status=%d\n"),querystatus);
744 #if (defined(linux) && !INET6_ENABLE) || defined (__FreeBSD__)
745 if (ctl->server.monitor)
748 * Allow some time for the link to quiesce. One
749 * second is usually sufficient, three is safe.
750 * Note: this delay is important - don't remove!
753 interface_note_activity(&ctl->server);
755 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
759 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
760 endhostent(); /* release TCP/IP connection to nameserver */
761 #endif /* HAVE_RES_SEARCH */
763 /* close connections cleanly */
767 * OK, we've polled. Now sleep.
769 if (run.poll_interval)
772 * Because passwords can expire, it may happen that *all*
773 * hosts are now out of the loop due to authfail
774 * conditions. If this happens daemon-mode fetchmail
775 * should softly and silently vanish away, rather than
776 * spinning uselessly.
780 for (ctl = querylist; ctl; ctl = ctl->next)
781 if (ctl->active && !(implicitmode && ctl->server.skip))
786 report(stderr, _("All connections are wedged. Exiting.\n"));
787 /* FIXME: someday, send notification mail */
791 if (outlevel >= O_VERBOSE)
793 _("fetchmail: sleeping at %s\n"), timestamp());
796 * OK, now pause util it's time for the next poll cycle.
797 * A nonzero return indicates we received a wakeup signal;
798 * unwedge all servers in case the problem has been
801 if ((lastsig = interruptible_idle(run.poll_interval)))
803 #ifdef SYS_SIGLIST_DECLARED
805 _("awakened by %s\n"), sys_siglist[lastsig]);
808 _("awakened by signal %d\n"), lastsig);
810 for (ctl = querylist; ctl; ctl = ctl->next)
814 if (outlevel >= O_VERBOSE)
815 report(stdout, _("awakened at %s\n"), timestamp());
820 if (outlevel >= O_VERBOSE)
821 report(stdout, _("normal termination, status %d\n"),
822 successes ? PS_SUCCESS : querystatus);
828 else if (querystatus)
831 /* in case we interrupted before a successful fetch */
834 exit(successes ? : querystatus);
837 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
840 * If force is off, modify dstl fields only when they're empty (treat srcl
841 * as defaults). If force is on, modify each dstl field whenever scrcl
842 * is nonempty (treat srcl as an override).
844 if (force ? !!*srcl : !*dstl)
846 struct idlist *cpl = copy_str_list(*srcl);
848 append_str_list(dstl, &cpl);
852 static void optmerge(struct query *h2, struct query *h1, int force)
853 /* merge two options records */
855 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
856 list_merge(&h2->localnames, &h1->localnames, force);
857 list_merge(&h2->mailboxes, &h1->mailboxes, force);
858 list_merge(&h2->smtphunt, &h1->smtphunt, force);
859 list_merge(&h2->antispam, &h1->antispam, force);
861 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
862 FLAG_MERGE(server.via);
863 FLAG_MERGE(server.protocol);
865 FLAG_MERGE(server.service);
866 FLAG_MERGE(server.netsec);
867 #else /* INET6_ENABLE */
868 FLAG_MERGE(server.port);
869 #endif /* INET6_ENABLE */
870 FLAG_MERGE(server.interval);
871 FLAG_MERGE(server.preauthenticate);
872 FLAG_MERGE(server.timeout);
873 FLAG_MERGE(server.envelope);
874 FLAG_MERGE(server.envskip);
875 FLAG_MERGE(server.qvirtual);
876 FLAG_MERGE(server.skip);
877 FLAG_MERGE(server.dns);
878 FLAG_MERGE(server.checkalias);
879 FLAG_MERGE(server.uidl);
880 FLAG_MERGE(server.principal);
882 #if defined(linux) || defined(__FreeBSD__)
883 FLAG_MERGE(server.interface);
884 FLAG_MERGE(server.monitor);
885 FLAG_MERGE(server.interface_pair);
886 #endif /* linux || defined(__FreeBSD__) */
888 FLAG_MERGE(server.plugin);
889 FLAG_MERGE(server.plugout);
891 FLAG_MERGE(wildcard);
892 FLAG_MERGE(remotename);
893 FLAG_MERGE(password);
896 FLAG_MERGE(listener);
897 FLAG_MERGE(smtpaddress);
898 FLAG_MERGE(smtpname);
899 FLAG_MERGE(preconnect);
900 FLAG_MERGE(postconnect);
904 FLAG_MERGE(fetchall);
908 FLAG_MERGE(pass8bits);
909 FLAG_MERGE(dropstatus);
910 FLAG_MERGE(dropdelivered);
911 FLAG_MERGE(mimedecode);
914 FLAG_MERGE(warnings);
915 FLAG_MERGE(fetchlimit);
916 FLAG_MERGE(batchlimit);
924 FLAG_MERGE(properties);
928 static int load_params(int argc, char **argv, int optind)
930 int implicitmode, st;
932 struct query def_opts, *ctl;
935 run.bouncemail = TRUE;
936 run.spambounce = FALSE; /* don't bounce back to innocent bystanders */
938 memset(&def_opts, '\0', sizeof(struct query));
939 def_opts.smtp_socket = -1;
940 def_opts.smtpaddress = (char *)0;
941 def_opts.smtpname = (char *)0;
942 #define ANTISPAM(n) save_str(&def_opts.antispam, STRING_DUMMY, 0)->val.status.num = (n)
943 ANTISPAM(571); /* sendmail */
944 ANTISPAM(550); /* old exim */
945 ANTISPAM(501); /* new exim */
946 ANTISPAM(554); /* Postfix */
949 def_opts.server.protocol = P_AUTO;
950 def_opts.server.timeout = CLIENT_TIMEOUT;
951 def_opts.warnings = WARNING_INTERVAL;
952 def_opts.remotename = user;
953 def_opts.listener = SMTP_MODE;
955 /* note the parse time, so we can pick up on modifications */
956 parsetime = 0; /* foil compiler warnings */
957 if (stat(rcfile, &rcstat) != -1)
958 parsetime = rcstat.st_mtime;
959 else if (errno != ENOENT)
960 report(stderr, _("couldn't time-check the run-control file\n"));
962 /* this builds the host list */
963 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
965 * FIXME: someday, send notification mail here if backgrounded.
966 * Right now, that can happen if the user changes the rcfile
967 * while the fetchmail is running in background. Do similarly
968 * for the other exit() calls in this function.
972 if ((implicitmode = (optind >= argc)))
974 for (ctl = querylist; ctl; ctl = ctl->next)
978 for (; optind < argc; optind++)
980 flag predeclared = FALSE;
983 * If hostname corresponds to a host known from the rc file,
984 * simply declare it active. Otherwise synthesize a host
985 * record from command line and defaults
987 for (ctl = querylist; ctl; ctl = ctl->next)
988 if (!strcmp(ctl->server.pollname, argv[optind])
989 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
991 /* Is this correct? */
992 if (predeclared && outlevel == O_VERBOSE)
993 fprintf(stderr,_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1001 * Allocate and link record without copying in
1002 * command-line args; we'll do that with the optmerge
1005 ctl = hostalloc((struct query *)NULL);
1007 ctl->server.pollname = xstrdup(argv[optind]);
1009 ctl->server.lead_server = (struct hostdata *)NULL;
1014 * If there's a defaults record, merge it and lose it.
1016 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1018 for (ctl = querylist->next; ctl; ctl = ctl->next)
1019 optmerge(ctl, querylist, FALSE);
1020 querylist = querylist->next;
1023 /* don't allow a defaults record after the first */
1024 for (ctl = querylist; ctl; ctl = ctl->next)
1025 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0)
1028 /* use localhost if we never fetch the FQDN of this host */
1029 fetchmailhost = "localhost";
1031 /* here's where we override globals */
1032 if (cmd_run.logfile)
1033 run.logfile = cmd_run.logfile;
1035 run.idfile = cmd_run.idfile;
1036 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1037 if (cmd_run.poll_interval >= 0)
1038 run.poll_interval = cmd_run.poll_interval;
1039 if (cmd_run.invisible)
1040 run.invisible = cmd_run.invisible;
1041 if (cmd_run.showdots)
1042 run.showdots = cmd_run.showdots;
1043 if (cmd_run.use_syslog)
1044 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1045 if (cmd_run.postmaster)
1046 run.postmaster = cmd_run.postmaster;
1047 if (cmd_run.bouncemail)
1048 run.bouncemail = cmd_run.bouncemail;
1050 /* check and daemon options are not compatible */
1051 if (check_only && run.poll_interval)
1052 run.poll_interval = 0;
1054 /* merge in wired defaults, do sanity checks and prepare internal fields */
1055 for (ctl = querylist; ctl; ctl = ctl->next)
1057 ctl->wedged = FALSE;
1059 if (configdump || ctl->active )
1061 /* merge in defaults */
1062 optmerge(ctl, &def_opts, FALSE);
1064 /* force command-line options */
1065 optmerge(ctl, &cmd_opts, TRUE);
1067 /* this code enables flags to be turned off */
1068 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1070 else if (flag == FLAG_FALSE)\
1074 DEFAULT(ctl->keep, FALSE);
1075 DEFAULT(ctl->fetchall, FALSE);
1076 DEFAULT(ctl->flush, FALSE);
1077 DEFAULT(ctl->rewrite, TRUE);
1078 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1079 DEFAULT(ctl->forcecr, FALSE);
1080 DEFAULT(ctl->pass8bits, FALSE);
1081 DEFAULT(ctl->dropstatus, FALSE);
1082 DEFAULT(ctl->dropdelivered, FALSE);
1083 DEFAULT(ctl->mimedecode, FALSE);
1084 DEFAULT(ctl->idle, FALSE);
1085 DEFAULT(ctl->server.dns, TRUE);
1086 DEFAULT(ctl->server.uidl, FALSE);
1088 DEFAULT(ctl->use_ssl, FALSE);
1090 DEFAULT(ctl->server.checkalias, FALSE);
1094 * DNS support is required for some protocols. We used to
1095 * do this unconditionally, but it made fetchmail excessively
1096 * vulnerable to misconfigured DNS setups.
1098 * If we're using ETRN or ODMR, the smtp hunt list is the
1099 * list of systems we're polling on behalf of; these have
1100 * to be fully-qualified domain names. The default for
1101 * this list should be the FQDN of localhost.
1103 * If we're using Kerberos for authentication, we need
1104 * the FQDN in order to generate capability keys. */
1105 if (ctl->server.protocol == P_ETRN
1107 || ctl->server.protocol == P_ODMR
1108 #endif /* ODMR_ENABLE */
1109 || ctl->server.preauthenticate == A_KERBEROS_V4
1110 || ctl->server.preauthenticate == A_KERBEROS_V5)
1111 if (strcmp(fetchmailhost, "localhost") == 0)
1112 fetchmailhost = host_fqdn();
1115 * Make sure we have a nonempty host list to forward to.
1118 save_str(&ctl->smtphunt, fetchmailhost, FALSE);
1120 /* if `user' doesn't name a real local user, try to run as root */
1121 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1124 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1125 if (!ctl->localnames) /* for local delivery via SMTP */
1126 save_str_pair(&ctl->localnames, user, NULL);
1128 #if !defined(HAVE_GETHOSTBYNAME) || !defined(HAVE_RES_SEARCH)
1129 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1130 if (ctl->localnames && ctl->localnames->next && ctl->server.dns)
1132 ctl->server.dns = FALSE;
1133 report(stderr, _("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1135 #endif /* !HAVE_GETHOSTBYNAME || !HAVE_RES_SEARCH */
1139 * Compute the true name of the mailserver host.
1140 * There are two clashing cases here:
1142 * (1) The poll name is a label, possibly on one of several
1143 * poll configurations for the same host. In this case
1144 * the `via' option will be present and give the true name.
1146 * (2) The poll name is the true one, the via name is
1147 * localhost. This is going to be typical for ssh-using
1150 * We're going to assume the via name is true unless it's
1153 if (ctl->server.via && strcmp(ctl->server.via, "localhost"))
1154 ctl->server.queryname = xstrdup(ctl->server.via);
1156 ctl->server.queryname = xstrdup(ctl->server.pollname);
1159 /* If either the pollname or vianame are "hesiod" we want to
1160 lookup the user's hesiod pobox host */
1162 if (!strcasecmp(ctl->server.queryname, "hesiod")) {
1163 struct hes_postoffice *hes_p;
1164 hes_p = hes_getmailhost(ctl->remotename);
1165 if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
1166 free(ctl->server.queryname);
1167 ctl->server.queryname = xstrdup(hes_p->po_host);
1168 if (ctl->server.via)
1169 free(ctl->server.via);
1170 ctl->server.via = xstrdup(hes_p->po_host);
1173 _("couldn't find HESIOD pobox for %s\n"),
1180 * We may have to canonicalize the server truename for later use.
1181 * Do this just once for each lead server, if necessary, in order
1182 * to minimize DNS round trips.
1184 if (ctl->server.lead_server)
1186 char *leadname = ctl->server.lead_server->truename;
1188 /* prevent core dump from ill-formed or duplicate entry */
1191 report(stderr, _("Lead server has no name.\n"));
1195 ctl->server.truename = xstrdup(leadname);
1197 #ifdef HAVE_GETHOSTBYNAME
1198 else if (!configdump)
1200 if (ctl->server.preauthenticate==A_KERBEROS_V4 ||
1201 ctl->server.preauthenticate==A_KERBEROS_V5 ||
1202 (ctl->server.dns && MULTIDROP(ctl)))
1204 struct hostent *namerec;
1206 /* compute the canonical name of the host */
1208 namerec = gethostbyname(ctl->server.queryname);
1209 if (namerec == (struct hostent *)NULL)
1212 _("couldn't find canonical DNS name of %s\n"),
1213 ctl->server.pollname);
1214 ctl->server.truename = xstrdup(ctl->server.queryname);
1215 ctl->server.trueaddr = NULL;
1218 ctl->server.truename=xstrdup((char *)namerec->h_name);
1220 #endif /* HAVE_GETHOSTBYNAME */
1222 #ifdef HAVE_GETHOSTBYNAME
1223 struct hostent *namerec;
1225 /* <fetchmail@mail.julianhaight.com>
1226 Get the host's IP, so we can report it like this:
1228 Received: from hostname [10.0.0.1]
1230 do we actually need to gethostbyname to find the IP?
1231 it seems like it would be faster to do this later, when
1232 we are actually resolving the hostname for a connection,
1233 but I ain't that smart, so I don't know where to make
1237 namerec = gethostbyname(ctl->server.queryname);
1238 if (namerec == (struct hostent *)NULL)
1241 _("couldn't find canonical DNS name of %s\n"),
1242 ctl->server.pollname);
1246 ctl->server.truename=xstrdup((char *)namerec->h_name);
1247 ctl->server.trueaddr=xmalloc(namerec->h_length);
1248 memcpy(ctl->server.trueaddr,
1249 namerec->h_addr_list[0],
1253 ctl->server.truename = xstrdup(ctl->server.queryname);
1254 #endif /* HAVE_GETHOSTBYNAME */
1258 /* if no folders were specified, set up the null one as default */
1259 if (!ctl->mailboxes)
1260 save_str(&ctl->mailboxes, (char *)NULL, 0);
1262 /* maybe user overrode timeout on command line? */
1263 if (ctl->server.timeout == -1)
1264 ctl->server.timeout = CLIENT_TIMEOUT;
1268 if (ctl->server.port < 0)
1270 (void) fprintf(stderr,
1271 _("%s configuration invalid, port number cannot be negative\n"),
1272 ctl->server.pollname);
1275 if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
1277 (void) fprintf(stderr,
1278 _("%s configuration invalid, RPOP requires a privileged port\n"),
1279 ctl->server.pollname);
1282 if (ctl->listener == LMTP_MODE)
1286 for (idp = ctl->smtphunt; idp; idp = idp->next)
1290 if (!(cp = strrchr(idp->id, '/')) ||
1291 (atoi(++cp) == SMTP_PORT))
1293 (void) fprintf(stderr,
1294 _("%s configuration invalid, LMTP can't use default SMTP port\n"),
1295 ctl->server.pollname);
1300 #endif /* !INET6_ENABLE */
1303 * "I beg to you, have mercy on the week minds like myself."
1304 * wrote Pehr Anderson. Your petition is granted.
1306 if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
1308 (void) fprintf(stderr,
1309 _("Both fetchall and keep on in daemon mode is a mistake!\n"));
1316 /* initialize UID handling */
1317 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
1320 initialize_saved_lists(querylist, run.idfile);
1321 #endif /* POP3_ENABLE */
1324 * If the user didn't set a last-resort user to get misaddressed
1325 * multidrop mail, set an appropriate default here.
1327 if (!run.postmaster)
1329 if (getuid()) /* ordinary user */
1330 run.postmaster = user;
1332 run.postmaster = "postmaster";
1335 return(implicitmode);
1338 static void terminate_poll(int sig)
1339 /* to be executed at the end of a poll cycle */
1342 * Close all SMTP delivery sockets. For optimum performance
1343 * we'd like to hold them open til end of run, but (1) this
1344 * loses if our poll interval is longer than the MTA's inactivity
1345 * timeout, and (2) some MTAs (like smail) don't deliver after
1346 * each message, but rather queue up mail and wait to actually
1347 * deliver it until the input socket is closed.
1349 * Sending SMTP QUIT on signal is theoretically nice, but led to a
1350 * subtle bug. If fetchmail was terminated by signal while it was
1351 * shipping message text, it would hang forever waiting for a
1352 * command acknowledge. In theory we could enable the QUIT
1353 * only outside of the message send. In practice, we don't
1354 * care. All mailservers hang up on a dropped TCP/IP connection
1359 report(stdout, _("terminated with signal %d\n"), sig);
1364 /* terminate all SMTP connections cleanly */
1365 for (ctl = querylist; ctl; ctl = ctl->next)
1366 if (ctl->smtp_socket != -1)
1368 SMTP_quit(ctl->smtp_socket);
1369 SockClose(ctl->smtp_socket);
1370 ctl->smtp_socket = -1;
1376 * Update UID information at end of each poll, rather than at end
1377 * of run, because that way we don't lose all UIDL information since
1378 * the beginning of time if fetchmail crashes.
1381 write_saved_lists(querylist, run.idfile);
1382 #endif /* POP3_ENABLE */
1385 static void terminate_run(int sig)
1386 /* to be executed on normal or signal-induced termination */
1390 terminate_poll(sig);
1393 * Craig Metz, the RFC1938 one-time-password guy, points out:
1394 * "Remember that most kernels don't zero pages before handing them to the
1395 * next process and many kernels share pages between user and kernel space.
1396 * You'd be very surprised what you can find from a short program to do a
1397 * malloc() and then dump the contents of the pages you got. By zeroing
1398 * the secrets at end of run (earlier if you can), you make sure the next
1399 * guy can't get the password/pass phrase."
1401 * Right you are, Craig!
1403 for (ctl = querylist; ctl; ctl = ctl->next)
1405 memset(ctl->password, '\0', strlen(ctl->password));
1407 #if !defined(HAVE_ATEXIT) && !defined(HAVE_ON_EXIT)
1411 if (activecount == 0)
1414 exit(successes ? PS_SUCCESS : querystatus);
1418 * Sequence of protocols to try when autoprobing, most capable to least.
1420 static const int autoprobe[] =
1424 #endif /* IMAP_ENABLE */
1427 #endif /* POP3_ENABLE */
1430 #endif /* POP2_ENABLE */
1433 static int query_host(struct query *ctl)
1434 /* perform fetch transaction with single host */
1439 * If we're syslogging the progress messages are automatically timestamped.
1440 * Force timestamping if we're going to a logfile.
1442 if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
1444 report(stdout, _("%s querying %s (protocol %s) at %s\n"),
1446 ctl->server.pollname,
1447 showproto(ctl->server.protocol),
1450 switch (ctl->server.protocol) {
1452 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1454 ctl->server.protocol = autoprobe[i];
1455 if ((st = query_host(ctl)) == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP)
1458 ctl->server.protocol = P_AUTO;
1462 return(doPOP2(ctl));
1464 report(stderr, _("POP2 support is not configured.\n"));
1465 return(PS_PROTOCOL);
1466 #endif /* POP2_ENABLE */
1472 return(doPOP3(ctl));
1474 report(stderr, _("POP3 support is not configured.\n"));
1475 return(PS_PROTOCOL);
1476 #endif /* POP3_ENABLE */
1483 return(doIMAP(ctl));
1485 report(stderr, _("IMAP support is not configured.\n"));
1486 return(PS_PROTOCOL);
1487 #endif /* IMAP_ENABLE */
1490 report(stderr, _("ETRN support is not configured.\n"));
1491 return(PS_PROTOCOL);
1493 #ifdef HAVE_GETHOSTBYNAME
1494 return(doETRN(ctl));
1496 report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
1497 return(PS_PROTOCOL);
1498 #endif /* HAVE_GETHOSTBYNAME */
1499 #endif /* ETRN_ENABLE */
1502 report(stderr, _("ODMR support is not configured.\n"));
1503 return(PS_PROTOCOL);
1505 #ifdef HAVE_GETHOSTBYNAME
1506 return(doODMR(ctl));
1508 report(stderr, _("Cannot support ODMR without gethostbyname(2).\n"));
1509 return(PS_PROTOCOL);
1510 #endif /* HAVE_GETHOSTBYNAME */
1511 #endif /* ODMR_ENABLE */
1513 report(stderr, _("unsupported protocol selected.\n"));
1514 return(PS_PROTOCOL);
1518 static void dump_params (struct runctl *runp,
1519 struct query *querylist, flag implicit)
1520 /* display query parameters in English */
1524 if (runp->poll_interval)
1525 printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
1527 printf(_("Logfile is %s\n"), runp->logfile);
1528 if (strcmp(runp->idfile, IDFILE_NAME))
1529 printf(_("Idfile is %s\n"), runp->idfile);
1530 #if defined(HAVE_SYSLOG)
1531 if (runp->use_syslog)
1532 printf(_("Progress messages will be logged via syslog\n"));
1534 if (runp->invisible)
1535 printf(_("Fetchmail will masquerade and will not generate Received\n"));
1537 printf(_("Fetchmail will show progress dots even in logfiles.\n"));
1538 if (runp->postmaster)
1539 printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1542 if (!runp->bouncemail)
1543 printf(_("Fetchmail will direct error mail to the postmaster.\n"));
1544 else if (outlevel >= O_VERBOSE)
1545 printf(_("Fetchmail will direct error mail to the sender.\n"));
1547 for (ctl = querylist; ctl; ctl = ctl->next)
1549 if (!ctl->active || (implicit && ctl->server.skip))
1552 printf(_("Options for retrieving from %s@%s:\n"),
1553 ctl->remotename, visbuf(ctl->server.pollname));
1555 if (ctl->server.via && (ctl->server.protocol < P_ETRN))
1556 printf(_(" Mail will be retrieved via %s\n"), ctl->server.via);
1558 if (ctl->server.interval)
1559 printf(_(" Poll of this server will occur every %d intervals.\n"),
1560 ctl->server.interval);
1561 if (ctl->server.truename)
1562 printf(_(" True name of server is %s.\n"), ctl->server.truename);
1563 if (ctl->server.skip || outlevel >= O_VERBOSE)
1564 printf(_(" This host %s be queried when no host is specified.\n"),
1565 ctl->server.skip ? _("will not") : _("will"));
1567 * Don't poll for password when there is one or when using the ETRN
1568 * or GSSAPI or KERBEROS protocol
1570 /* ETRN, IMAP_GSS, and IMAP_K4 do not need a password, so skip this */
1571 if ( (ctl->server.protocol != P_ETRN)
1573 && (ctl->server.preauthenticate != A_GSSAPI)
1575 && (ctl->server.preauthenticate != A_KERBEROS_V4)
1576 && (ctl->server.preauthenticate != A_KERBEROS_V5))
1579 printf(_(" Password will be prompted for.\n"));
1580 else if (outlevel >= O_VERBOSE)
1582 if (ctl->server.protocol == P_APOP)
1583 printf(_(" APOP secret = \"%s\".\n"),
1584 visbuf(ctl->password));
1585 else if (ctl->server.protocol == P_RPOP)
1586 printf(_(" RPOP id = \"%s\".\n"),
1587 visbuf(ctl->password));
1589 printf(_(" Password = \"%s\".\n"),
1590 visbuf(ctl->password));
1594 if (ctl->server.protocol == P_POP3
1596 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1597 #else /* INET6_ENABLE */
1598 && ctl->server.port == KPOP_PORT
1599 #endif /* INET6_ENABLE */
1600 && (ctl->server.preauthenticate == A_KERBEROS_V4 ||
1601 ctl->server.preauthenticate == A_KERBEROS_V5))
1602 printf(_(" Protocol is KPOP with Kerberos %s authentication"),
1603 ctl->server.preauthenticate == A_KERBEROS_V5 ? "V" : "IV");
1605 printf(_(" Protocol is %s"), showproto(ctl->server.protocol));
1607 if (ctl->server.service)
1608 printf(_(" (using service %s)"), ctl->server.service);
1609 if (ctl->server.netsec)
1610 printf(_(" (using network security options %s)"), ctl->server.netsec);
1611 #else /* INET6_ENABLE */
1612 if (ctl->server.port)
1613 printf(_(" (using port %d)"), ctl->server.port);
1614 #endif /* INET6_ENABLE */
1615 else if (outlevel >= O_VERBOSE)
1616 printf(_(" (using default port)"));
1617 if (ctl->server.uidl && (ctl->server.protocol < P_ETRN))
1618 printf(_(" (forcing UIDL use)"));
1621 if (ctl->server.preauthenticate == A_KERBEROS_V4)
1622 printf(_(" Kerberos V4 preauthentication enabled.\n"));
1623 else if (ctl->server.preauthenticate == A_KERBEROS_V5)
1624 printf(_(" Kerberos V5 preauthentication enabled.\n"));
1625 else if (ctl->server.preauthenticate == A_SSH)
1626 printf(_(" End-to-end encryption assumed.\n"));
1627 if (ctl->server.principal != (char *) NULL) {
1628 printf(_(" Mail service principal is: %s\n"), ctl->server.principal);
1632 printf(" SSL encrypted sessions enabled.\n");
1634 if (ctl->server.timeout > 0)
1635 printf(_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1636 if (ctl->server.timeout == CLIENT_TIMEOUT)
1637 printf(_(" (default).\n"));
1641 if (ctl->server.protocol < P_ETRN) {
1642 if (!ctl->mailboxes->id)
1643 printf(_(" Default mailbox selected.\n"));
1648 printf(_(" Selected mailboxes are:"));
1649 for (idp = ctl->mailboxes; idp; idp = idp->next)
1650 printf(" %s", idp->id);
1653 printf(_(" %s messages will be retrieved (--all %s).\n"),
1654 ctl->fetchall ? _("All") : _("Only new"),
1655 ctl->fetchall ? "on" : "off");
1656 printf(_(" Fetched messages %s be kept on the server (--keep %s).\n"),
1657 ctl->keep ? _("will") : _("will not"),
1658 ctl->keep ? "on" : "off");
1659 printf(_(" Old messages %s be flushed before message retrieval (--flush %s).\n"),
1660 ctl->flush ? _("will") : _("will not"),
1661 ctl->flush ? "on" : "off");
1662 printf(_(" Rewrite of server-local addresses is %s (--norewrite %s).\n"),
1663 ctl->rewrite ? _("enabled") : _("disabled"),
1664 ctl->rewrite ? "off" : "on");
1665 printf(_(" Carriage-return stripping is %s (stripcr %s).\n"),
1666 ctl->stripcr ? _("enabled") : _("disabled"),
1667 ctl->stripcr ? "on" : "off");
1668 printf(_(" Carriage-return forcing is %s (forcecr %s).\n"),
1669 ctl->forcecr ? _("enabled") : _("disabled"),
1670 ctl->forcecr ? "on" : "off");
1671 printf(_(" Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
1672 ctl->pass8bits ? _("disabled") : _("enabled"),
1673 ctl->pass8bits ? "on" : "off");
1674 printf(_(" MIME decoding is %s (mimedecode %s).\n"),
1675 ctl->mimedecode ? _("enabled") : _("disabled"),
1676 ctl->mimedecode ? "on" : "off");
1677 printf(_(" Idle after poll is %s (idle %s).\n"),
1678 ctl->idle ? _("enabled") : _("disabled"),
1679 ctl->idle ? "on" : "off");
1680 printf(_(" Nonempty Status lines will be %s (dropstatus %s)\n"),
1681 ctl->dropstatus ? _("discarded") : _("kept"),
1682 ctl->dropstatus ? "on" : "off");
1683 printf(_(" Delivered-To lines will be %s (dropdelivered %s)\n"),
1684 ctl->dropdelivered ? _("discarded") : _("kept"),
1685 ctl->dropdelivered ? "on" : "off");
1686 if (NUM_NONZERO(ctl->limit))
1688 if (NUM_NONZERO(ctl->limit))
1689 printf(_(" Message size limit is %d octets (--limit %d).\n"),
1690 ctl->limit, ctl->limit);
1691 else if (outlevel >= O_VERBOSE)
1692 printf(_(" No message size limit (--limit 0).\n"));
1693 if (run.poll_interval > 0)
1694 printf(_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1695 ctl->warnings, ctl->warnings);
1696 else if (outlevel >= O_VERBOSE)
1697 printf(_(" Size warnings on every poll (--warnings 0).\n"));
1699 if (NUM_NONZERO(ctl->fetchlimit))
1700 printf(_(" Received-message limit is %d (--fetchlimit %d).\n"),
1701 ctl->fetchlimit, ctl->fetchlimit);
1702 else if (outlevel >= O_VERBOSE)
1703 printf(_(" No received-message limit (--fetchlimit 0).\n"));
1704 if (NUM_NONZERO(ctl->batchlimit))
1705 printf(_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1706 else if (outlevel >= O_VERBOSE)
1707 printf(_(" No SMTP message batch limit (--batchlimit 0).\n"));
1708 if (ctl->server.protocol < P_ETRN)
1710 if (NUM_NONZERO(ctl->expunge))
1711 printf(_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1712 else if (outlevel >= O_VERBOSE)
1713 printf(_(" No forced expunges (--expunge 0).\n"));
1717 printf(_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1718 else if (ctl->mda && (ctl->server.protocol < P_ETRN))
1719 printf(_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1724 printf(_(" Messages will be %cMTP-forwarded to:"), ctl->listener);
1725 for (idp = ctl->smtphunt; idp; idp = idp->next)
1727 printf(" %s", idp->id);
1728 if (!idp->val.status.mark)
1729 printf(_(" (default)"));
1732 if (ctl->smtpaddress)
1733 printf(_(" Host part of MAIL FROM line will be %s\n"),
1736 printf(_(" Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1739 if (ctl->server.protocol < P_ETRN)
1741 if (ctl->antispam != (struct idlist *)NULL)
1745 printf(_(" Recognized listener spam block responses are:"));
1746 for (idp = ctl->antispam; idp; idp = idp->next)
1747 printf(" %d", idp->val.status.num);
1750 else if (outlevel >= O_VERBOSE)
1751 printf(_(" Spam-blocking disabled\n"));
1753 if (ctl->preconnect)
1754 printf(_(" Server connection will be brought up with \"%s\".\n"),
1755 visbuf(ctl->preconnect));
1756 else if (outlevel >= O_VERBOSE)
1757 printf(_(" No pre-connection command.\n"));
1758 if (ctl->postconnect)
1759 printf(_(" Server connection will be taken down with \"%s\".\n"),
1760 visbuf(ctl->postconnect));
1761 else if (outlevel >= O_VERBOSE)
1762 printf(_(" No post-connection command.\n"));
1763 if (ctl->server.protocol < P_ETRN) {
1764 if (!ctl->localnames)
1765 printf(_(" No localnames declared for this host.\n"));
1771 for (idp = ctl->localnames; idp; idp = idp->next)
1774 if (count > 1 || ctl->wildcard)
1775 printf(_(" Multi-drop mode: "));
1777 printf(_(" Single-drop mode: "));
1779 printf(_("%d local name(s) recognized.\n"), count);
1780 if (outlevel >= O_VERBOSE)
1782 for (idp = ctl->localnames; idp; idp = idp->next)
1784 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1786 printf("\t%s\n", idp->id);
1788 fputs("\t*\n", stdout);
1791 if (count > 1 || ctl->wildcard)
1793 printf(_(" DNS lookup for multidrop addresses is %s.\n"),
1794 ctl->server.dns ? _("enabled") : _("disabled"));
1795 if (ctl->server.dns)
1797 printf(_(" Server aliases will be compared with multidrop addresses by "));
1798 if (ctl->server.checkalias)
1799 printf(_("IP address.\n"));
1801 printf(_("name.\n"));
1803 if (ctl->server.envelope == STRING_DISABLED)
1804 printf(_(" Envelope-address routing is disabled\n"));
1807 printf(_(" Envelope header is assumed to be: %s\n"),
1808 ctl->server.envelope ? ctl->server.envelope:_("Received"));
1809 if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
1810 printf(_(" Number of envelope header to be parsed: %d\n"),
1811 ctl->server.envskip);
1812 if (ctl->server.qvirtual)
1813 printf(_(" Prefix %s will be removed from user id\n"),
1814 ctl->server.qvirtual);
1815 else if (outlevel >= O_VERBOSE)
1816 printf(_(" No prefix stripping\n"));
1819 if (ctl->server.akalist)
1823 printf(_(" Predeclared mailserver aliases:"));
1824 for (idp = ctl->server.akalist; idp; idp = idp->next)
1825 printf(" %s", idp->id);
1828 if (ctl->server.localdomains)
1832 printf(_(" Local domains:"));
1833 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1834 printf(" %s", idp->id);
1840 #if defined(linux) || defined(__FreeBSD__)
1841 if (ctl->server.interface)
1842 printf(_(" Connection must be through interface %s.\n"), ctl->server.interface);
1843 else if (outlevel >= O_VERBOSE)
1844 printf(_(" No interface requirement specified.\n"));
1845 if (ctl->server.monitor)
1846 printf(_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1847 else if (outlevel >= O_VERBOSE)
1848 printf(_(" No monitor interface specified.\n"));
1851 if (ctl->server.plugin)
1852 printf(_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1853 else if (outlevel >= O_VERBOSE)
1854 printf(_(" No plugin command specified.\n"));
1855 if (ctl->server.plugout)
1856 printf(_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1857 else if (outlevel >= O_VERBOSE)
1858 printf(_(" No plugout command specified.\n"));
1860 if (ctl->server.protocol > P_POP2 && (ctl->server.protocol < P_ETRN))
1863 printf(_(" No UIDs saved from this host.\n"));
1869 for (idp = ctl->oldsaved; idp; idp = idp->next)
1872 printf(_(" %d UIDs saved.\n"), count);
1873 if (outlevel >= O_VERBOSE)
1874 for (idp = ctl->oldsaved; idp; idp = idp->next)
1875 printf("\t%s\n", idp->id);
1879 if (ctl->properties)
1880 printf(_(" Pass-through properties \"%s\".\n"),
1881 visbuf(ctl->properties));
1885 /* fetchmail.c ends here */