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"
53 #define ENETUNREACH 128 /* Interactive doesn't know this */
54 #endif /* ENETUNREACH */
56 /* prototypes for internal functions */
57 static int load_params(int, char **, int);
58 static void dump_params (struct runctl *runp, struct query *, flag implicit);
59 static int query_host(struct query *);
61 /* controls the detail level of status/progress messages written to stderr */
62 int outlevel; /* see the O_.* constants above */
64 /* miscellaneous global controls */
65 struct runctl run; /* global controls for this run */
66 flag nodetach; /* if TRUE, don't detach daemon process */
67 flag quitmode; /* if --quit was set */
68 flag check_only; /* if --probe was set */
69 flag versioninfo; /* emit only version info */
70 char *user; /* the name of the invoking user */
71 char *home; /* invoking user's home directory */
72 char *fmhome; /* fetchmail's home directory */
73 char *program_name; /* the name to prefix error messages with */
74 flag configdump; /* dump control blocks for configurator */
75 const char *fetchmailhost; /* either `localhost' or the host's FQDN */
80 #endif /* NET_SECURITY */
82 static char *lockfile; /* name of lockfile */
83 static int lock_acquired; /* have we acquired a lock */
84 static int querystatus; /* status of query */
85 static int successes; /* count number of successful polls */
86 static struct runctl cmd_run; /* global options set from command line */
87 static time_t parsetime; /* time of last parse */
89 static void terminate_run(int);
90 static void terminate_poll(int);
93 static void unlockit(int n, void *p)
95 static void unlockit(void)
97 /* must-do actions for exit (but we can't count on being able to do malloc) */
99 if (lockfile && lock_acquired)
104 /* drop SGID kmem privileage until we need it */
105 static void dropprivs(void)
115 if (gr && !strcmp(gr->gr_name, "kmem"))
117 extern void interface_set_gids(gid_t egid, gid_t rgid);
118 interface_set_gids(egid, rgid);
124 int main(int argc, char **argv)
126 int st, bkgd = FALSE;
127 int parsestatus, implicitmode = FALSE;
130 netrc_entry *netrc_list;
131 char *netrc_file, *tmpbuf;
139 envquery(argc, argv);
141 bindtextdomain(PACKAGE, LOCALEDIR);
146 * Note: because we can't initialize reporting before we know whether
147 * syslog is supposed to be on, this message will go to stdout and
148 * be lost when running in background.
150 if (outlevel >= O_VERBOSE)
154 report(stdout, "fetchmail: invoked with");
155 for (i = 0; i < argc; i++)
156 report(stdout, " %s", argv[i]);
157 report(stdout, "\n");
160 #define IDFILE_NAME ".fetchids"
161 run.idfile = (char *) xmalloc(strlen(fmhome)+sizeof(IDFILE_NAME)+2);
162 strcpy(run.idfile, fmhome);
163 strcat(run.idfile, "/");
164 strcat(run.idfile, IDFILE_NAME);
169 * We used to arrange for the lockfile to be removed on exit close
170 * to where the lock was asserted. Now we need to do it here, because
171 * we might have re-executed in background with an existing lockfile
172 * as the result of a changed rcfile (see the code near the execvp(3)
173 * call near the beginning of the polling loop for details). We want
174 * to be sure the lockfile gets nuked on any error exit, basically.
180 on_exit(unlockit, (char *)NULL);
183 if ((parsestatus = parsecmdline(argc,argv, &cmd_run, &cmd_opts)) < 0)
188 printf(_("This is fetchmail release %s"), VERSION);
191 #endif /* POP2_ENABLE */
194 #endif /* POP3_ENABLE */
197 #endif /* IMAP_ENABLE */
203 #endif /* RPA_ENABLE */
206 #endif /* NTLM_ENABLE */
209 #endif /* SDPS_ENABLE */
212 #endif /* ETRN_ENABLE */
218 #endif /* OPIE_ENABLE */
221 #endif /* INET6_ENABLE */
224 #endif /* NET_SECURITY */
227 #endif /* HAVE_SOCKS */
230 #endif /* ENABLE_NLS */
234 /* this is an attempt to help remote debugging */
238 /* avoid parsing the config file if all we're doing is killing a daemon */
239 if (!(quitmode && argc == 2))
240 implicitmode = load_params(argc, argv, optind);
242 #if defined(HAVE_SYSLOG)
243 /* logging should be set up early in case we were restarted from exec */
246 #if defined(LOG_MAIL)
247 openlog(program_name, LOG_PID, LOG_MAIL);
249 /* Assume BSD4.2 openlog with two arguments */
250 openlog(program_name, LOG_PID);
256 report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
258 /* set up to do lock protocol */
259 #define FETCHMAIL_PIDFILE "fetchmail.pid"
261 xalloca(tmpbuf, char *,
262 sizeof(PID_DIR) + sizeof(FETCHMAIL_PIDFILE));
263 sprintf(tmpbuf, "%s/%s", PID_DIR, FETCHMAIL_PIDFILE);
265 xalloca(tmpbuf, char *, strlen(fmhome) + sizeof(FETCHMAIL_PIDFILE) + 2);
266 strcpy(tmpbuf, fmhome);
270 strcat(tmpbuf, FETCHMAIL_PIDFILE);
272 #undef FETCHMAIL_PIDFILE
274 #ifdef HAVE_SETRLIMIT
276 * Before getting passwords, disable core dumps unless -v -d0 mode is on.
277 * Core dumps could otherwise contain passwords to be scavenged by a
280 if (outlevel < O_VERBOSE || run.poll_interval > 0)
282 struct rlimit corelimit;
283 corelimit.rlim_cur = 0;
284 corelimit.rlim_max = 0;
285 setrlimit(RLIMIT_CORE, &corelimit);
287 #endif /* HAVE_SETRLIMIT */
289 #define NETRC_FILE ".netrc"
290 /* parse the ~/.netrc file (if present) for future password lookups. */
291 xalloca(netrc_file, char *, strlen(home) + sizeof(NETRC_FILE) + 2);
292 strcpy (netrc_file, home);
293 strcat (netrc_file, "/");
294 strcat (netrc_file, NETRC_FILE);
295 netrc_list = parse_netrc(netrc_file);
298 /* pick up passwords where we can */
299 for (ctl = querylist; ctl; ctl = ctl->next)
301 if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
303 if (ctl->server.preauthenticate == A_KERBEROS_V4 ||
304 ctl->server.preauthenticate == A_KERBEROS_V5 ||
305 ctl->server.preauthenticate == A_SSH ||
307 ctl->server.protocol == P_IMAP_GSS ||
309 ctl->server.protocol == P_IMAP_K4)
310 /* Server won't care what the password is, but there
311 must be some non-null string here. */
312 ctl->password = ctl->remotename;
317 /* look up the pollname and account in the .netrc file. */
318 p = search_netrc(netrc_list,
319 ctl->server.pollname, ctl->remotename);
320 /* if we find a matching entry with a password, use it */
321 if (p && p->password)
322 ctl->password = xstrdup(p->password);
324 /* otherwise try with "via" name if there is one */
325 else if (ctl->server.via)
327 p = search_netrc(netrc_list,
328 ctl->server.via, ctl->remotename);
329 if (p && p->password)
330 ctl->password = xstrdup(p->password);
336 /* perhaps we just want to check options? */
339 int havercfile = access(rcfile, 0);
341 printf(_("Taking options from command line%s%s\n"),
342 havercfile ? "" : _(" and "),
343 havercfile ? "" : rcfile);
345 if (outlevel >= O_VERBOSE)
346 printf(_("Lockfile at %s\n"), tmpbuf);
348 if (querylist == NULL)
350 _("No mailservers set up -- perhaps %s is missing?\n"),
353 dump_params(&run, querylist, implicitmode);
357 /* dump options as a Python dictionary, for configurator use */
360 dump_config(&run, querylist);
364 /* check for another fetchmail running concurrently */
366 if ((lockfile = (char *) malloc(strlen(tmpbuf) + 1)) == NULL)
368 report(stderr,_("fetchmail: cannot allocate memory for lock name.\n"));
372 (void) strcpy(lockfile, tmpbuf);
373 if ((lockfp = fopen(lockfile, "r")) != NULL )
375 bkgd = (fscanf(lockfp,"%d %d", &pid, &st) == 2);
377 if (kill(pid, 0) == -1) {
378 fprintf(stderr,_("fetchmail: removing stale lockfile\n"));
383 fclose(lockfp); /* not checking should be safe, file mode was "r" */
386 /* if no mail servers listed and nothing in background, we're done */
387 if (!(quitmode && argc == 2) && pid == -1 && querylist == NULL) {
388 (void)fputs(_("fetchmail: no mailservers have been specified.\n"),stderr);
392 /* perhaps user asked us to kill the other fetchmail */
397 fprintf(stderr,_("fetchmail: no other fetchmail is running\n"));
401 else if (kill(pid, SIGTERM) < 0)
403 fprintf(stderr,_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
404 bkgd ? _("background") : _("foreground"), pid);
409 fprintf(stderr,_("fetchmail: %s fetchmail at %d killed.\n"),
410 bkgd ? _("background") : _("foreground"), pid);
419 /* another fetchmail is running -- wake it up or die */
425 _("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
428 else if (!implicitmode)
431 _("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
438 _("fetchmail: another foreground fetchmail is running at %d.\n"),
444 /* this test enables re-execing on a changed rcfile */
446 lock_acquired = TRUE;
450 _("fetchmail: can't accept options while a background fetchmail is running.\n"));
454 else if (kill(pid, SIGUSR1) == 0)
457 _("fetchmail: background fetchmail at %d awakened.\n"),
464 * Should never happen -- possible only if a background fetchmail
465 * croaks after the first kill probe above but before the
466 * SIGUSR1/SIGHUP transmission.
469 _("fetchmail: elder sibling at %d died mysteriously.\n"),
471 return(PS_UNDEFINED);
475 /* pick up interactively any passwords we need but don't have */
476 for (ctl = querylist; ctl; ctl = ctl->next)
478 if (ctl->active && !(implicitmode && ctl->server.skip)
479 && ctl->server.protocol != P_ETRN
480 && ctl->server.protocol != P_IMAP_K4
482 && ctl->server.protocol != P_IMAP_GSS
488 _("fetchmail: can't find a password for %s@s.\n"),
489 ctl->remotename, ctl->server.pollname);
494 char* password_prompt = _("Enter password for %s@%s: ");
496 xalloca(tmpbuf, char *, strlen(password_prompt) +
497 strlen(ctl->remotename) +
498 strlen(ctl->server.pollname) + 1);
499 (void) sprintf(tmpbuf, password_prompt,
500 ctl->remotename, ctl->server.pollname);
501 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
506 * Time to initiate the SOCKS library (this is not mandatory: it just
507 * registers the correct application name for logging purpose. If you
508 * have some problem, comment out these lines).
511 SOCKSinit("fetchmail");
512 #endif /* HAVE_SOCKS */
515 * Maybe time to go to demon mode...
517 if (run.poll_interval)
520 daemonize(run.logfile, terminate_run);
521 report(stdout, _("starting fetchmail %s daemon \n"), VERSION);
524 * We'll set up a handler for these when we're sleeping,
525 * but ignore them otherwise so as not to interrupt a poll.
527 signal(SIGUSR1, SIG_IGN);
528 if (run.poll_interval && !getuid())
529 signal(SIGHUP, SIG_IGN);
531 else if (run.logfile && access(run.logfile, F_OK) == 0)
533 freopen(run.logfile, "a", stdout);
534 freopen(run.logfile, "a", stderr);
542 /* beyond here we don't want more than one fetchmail running per user */
544 signal(SIGABRT, terminate_run);
545 signal(SIGINT, terminate_run);
546 signal(SIGTERM, terminate_run);
547 signal(SIGALRM, terminate_run);
548 signal(SIGPIPE, terminate_run);
549 signal(SIGQUIT, terminate_run);
551 /* here's the exclusion lock */
553 #define O_SYNC 0 /* use it if we have it */
555 if ((st = open(lockfile, O_WRONLY|O_CREAT|O_EXCL|O_SYNC, 0666)) != -1)
557 sprintf(tmpbuf,"%d", getpid());
558 write(st, tmpbuf, strlen(tmpbuf));
559 if (run.poll_interval)
561 sprintf(tmpbuf," %d", run.poll_interval);
562 write(st, tmpbuf, strlen(tmpbuf));
564 close(st); /* should be safe, fd was opened with O_SYNC */
565 lock_acquired = TRUE;
569 * Query all hosts. If there's only one, the error return will
570 * reflect the status of that transaction.
574 * Check to see if the rcfile has been touched. If so,
575 * re-exec so the file will be reread. Doing it this way
576 * avoids all the complications of trying to deallocate the
577 * in-core control structures -- and the potential memory
582 if (stat(rcfile, &rcstat) == -1)
586 _("couldn't time-check %s (error %d)\n"),
589 else if (rcstat.st_mtime > parsetime)
591 report(stdout, _("restarting fetchmail (%s changed)\n"), rcfile);
592 execvp("fetchmail", argv);
593 report(stderr, _("attempt to re-exec fetchmail failed\n"));
596 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
598 * This was an efficiency hack that backfired. The theory
599 * was that using TCP/IP for DNS queries would get us better
600 * reliability and shave off some per-UDP-packet costs.
601 * Unfortunately it interacted badly with diald, which effectively
602 * filters out DNS queries over TCP/IP for reasons having to do
603 * with some obscure kernel problem involving bootstrapping of
604 * dynamically-addressed links. I don't understand this mess
605 * and don't want to, so it's "See ya!" to this hack.
607 sethostent(TRUE); /* use TCP/IP for mailserver queries */
608 #endif /* HAVE_RES_SEARCH */
611 for (ctl = querylist; ctl; ctl = ctl->next)
613 if (ctl->active && !(implicitmode && ctl->server.skip))
618 _("poll of %s skipped (failed authentication or too many timeouts)\n"),
619 ctl->server.pollname);
623 /* check skip interval first so that it counts all polls */
624 if (run.poll_interval && ctl->server.interval)
626 if (ctl->server.poll_count++ % ctl->server.interval)
628 if (outlevel >= O_VERBOSE)
630 _("interval not reached, not querying %s\n"),
631 ctl->server.pollname);
636 #if (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__)
638 * Don't do monitoring if we were woken by a signal.
639 * Note that interface_approve() does its own error logging.
641 if (!interface_approve(&ctl->server, !lastsig))
643 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
645 querystatus = query_host(ctl);
650 #endif /* POP3_ENABLE */
652 if (querystatus == PS_SUCCESS)
654 else if (!check_only &&
655 ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
659 report(stdout, "Query status=0 (SUCCESS)\n"); break ;
661 report(stdout, "Query status=1 (NOMAIL)\n"); break ;
663 report(stdout, "Query status=2 (SOCKET)\n"); break ;
665 report(stdout, "Query status=3 (AUTHFAIL)\n"); break ;
667 report(stdout, "Query status=4 (PROTOCOL)\n"); break ;
669 report(stdout, "Query status=5 (SYNTAX)\n"); break ;
671 report(stdout, "Query status=6 (IOERR)\n"); break ;
673 report(stdout, "Query status=7 (ERROR)\n"); break ;
675 report(stdout, "Query status=8 (EXCLUDE)\n"); break ;
677 report(stdout, "Query status=9 (LOCKBUSY)\n"); break ;
679 report(stdout, "Query status=10 (SMTP)\n"); break ;
681 report(stdout, "Query status=11 (DNS)\n"); break ;
683 report(stdout, "Query status=12 (BSMTP)\n"); break ;
685 report(stdout, "Query status=13 (MAXFETCH)\n"); break ;
687 report(stdout, _("Query status=%d\n"), querystatus); break;
690 #if (defined(linux) && !INET6_ENABLE) || defined (__FreeBSD__)
691 if (ctl->server.monitor)
694 * Allow some time for the link to quiesce. One
695 * second is usually sufficient, three is safe.
696 * Note: this delay is important - don't remove!
699 interface_note_activity(&ctl->server);
701 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
705 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
706 endhostent(); /* release TCP/IP connection to nameserver */
707 #endif /* HAVE_RES_SEARCH */
709 /* close connections cleanly */
713 * OK, we've polled. Now sleep.
715 if (run.poll_interval)
718 * Because passwords can expire, it may happen that *all*
719 * hosts are now out of the loop due to authfail
720 * conditions. If this happens daemon-mode fetchmail
721 * should softly and silently vanish away, rather than
722 * spinning uselessly.
726 for (ctl = querylist; ctl; ctl = ctl->next)
727 if (ctl->active && !(implicitmode && ctl->server.skip))
732 report(stderr, _("All connections are wedged. Exiting.\n"));
733 /* FIXME: someday, send notification mail */
737 if (outlevel >= O_VERBOSE)
739 _("fetchmail: sleeping at %s\n"), rfc822timestamp());
742 * OK, now pause util it's time for the next poll cycle.
743 * A nonzero return indicates we received a wakeup signal;
744 * unwedge all servers in case the problem has been
747 if ((lastsig = interruptible_idle(run.poll_interval)))
749 #ifdef SYS_SIGLIST_DECLARED
751 _("awakened by %s\n"), sys_siglist[lastsig]);
754 _("awakened by signal %d\n"), lastsig);
756 for (ctl = querylist; ctl; ctl = ctl->next)
760 if (outlevel >= O_VERBOSE)
761 report(stdout, _("awakened at %s\n"), rfc822timestamp());
766 if (outlevel >= O_VERBOSE)
767 report(stdout, _("normal termination, status %d\n"),
768 successes ? PS_SUCCESS : querystatus);
771 exit(successes ? PS_SUCCESS : querystatus);
774 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
777 * If force is off, modify dstl fields only when they're empty (treat srcl
778 * as defaults). If force is on, modify each dstl field whenever scrcl
779 * is nonempty (treat srcl as an override).
781 if (force ? !!*srcl : !*dstl)
783 struct idlist *cpl = copy_str_list(*srcl);
785 append_str_list(dstl, &cpl);
789 static void optmerge(struct query *h2, struct query *h1, int force)
790 /* merge two options records */
792 list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
793 list_merge(&h2->localnames, &h1->localnames, force);
794 list_merge(&h2->mailboxes, &h1->mailboxes, force);
795 list_merge(&h2->smtphunt, &h1->smtphunt, force);
796 list_merge(&h2->antispam, &h1->antispam, force);
798 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
799 FLAG_MERGE(server.via);
800 FLAG_MERGE(server.protocol);
802 FLAG_MERGE(server.service);
803 FLAG_MERGE(server.netsec);
804 #else /* INET6_ENABLE */
805 FLAG_MERGE(server.port);
806 #endif /* INET6_ENABLE */
807 FLAG_MERGE(server.interval);
808 FLAG_MERGE(server.preauthenticate);
809 FLAG_MERGE(server.timeout);
810 FLAG_MERGE(server.envelope);
811 FLAG_MERGE(server.envskip);
812 FLAG_MERGE(server.qvirtual);
813 FLAG_MERGE(server.skip);
814 FLAG_MERGE(server.dns);
815 FLAG_MERGE(server.checkalias);
816 FLAG_MERGE(server.uidl);
818 #if defined(linux) || defined(__FreeBSD__)
819 FLAG_MERGE(server.interface);
820 FLAG_MERGE(server.monitor);
821 FLAG_MERGE(server.interface_pair);
822 #endif /* linux || defined(__FreeBSD__) */
824 FLAG_MERGE(server.plugin);
825 FLAG_MERGE(server.plugout);
827 FLAG_MERGE(wildcard);
828 FLAG_MERGE(remotename);
829 FLAG_MERGE(password);
832 FLAG_MERGE(listener);
833 FLAG_MERGE(smtpaddress);
834 FLAG_MERGE(smtpname);
835 FLAG_MERGE(preconnect);
836 FLAG_MERGE(postconnect);
840 FLAG_MERGE(fetchall);
844 FLAG_MERGE(pass8bits);
845 FLAG_MERGE(dropstatus);
846 FLAG_MERGE(mimedecode);
849 FLAG_MERGE(warnings);
850 FLAG_MERGE(fetchlimit);
851 FLAG_MERGE(batchlimit);
859 FLAG_MERGE(properties);
863 static int load_params(int argc, char **argv, int optind)
865 int implicitmode, st;
867 struct query def_opts, *ctl;
870 run.bouncemail = TRUE;
872 memset(&def_opts, '\0', sizeof(struct query));
873 def_opts.smtp_socket = -1;
874 def_opts.smtpaddress = (char *)0;
875 #define ANTISPAM(n) save_str(&def_opts.antispam, STRING_DUMMY, 0)->val.status.num = (n)
876 ANTISPAM(571); /* sendmail */
877 ANTISPAM(550); /* old exim */
878 ANTISPAM(501); /* new exim */
879 ANTISPAM(554); /* Postfix */
882 def_opts.server.protocol = P_AUTO;
883 def_opts.server.timeout = CLIENT_TIMEOUT;
884 def_opts.warnings = WARNING_INTERVAL;
885 def_opts.remotename = user;
886 def_opts.listener = SMTP_MODE;
888 /* note the parse time, so we can pick up on modifications */
889 parsetime = 0; /* foil compiler warnings */
890 if (stat(rcfile, &rcstat) != -1)
891 parsetime = rcstat.st_mtime;
892 else if (errno != ENOENT)
893 report(stderr, _("couldn't time-check the run-control file\n"));
895 /* this builds the host list */
896 if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
898 * FIXME: someday, send notification mail here if backgrounded.
899 * Right now, that can happen if the user changes the rcfile
900 * while the fetchmail is running in background. Do similarly
901 * for the other exit() calls in this function.
905 if ((implicitmode = (optind >= argc)))
907 for (ctl = querylist; ctl; ctl = ctl->next)
911 for (; optind < argc; optind++)
913 flag predeclared = FALSE;
916 * If hostname corresponds to a host known from the rc file,
917 * simply declare it active. Otherwise synthesize a host
918 * record from command line and defaults
920 for (ctl = querylist; ctl; ctl = ctl->next)
921 if (!strcmp(ctl->server.pollname, argv[optind])
922 || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
924 /* Is this correct? */
925 if (predeclared && outlevel == O_VERBOSE)
926 fprintf(stderr,_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
934 * Allocate and link record without copying in
935 * command-line args; we'll do that with the optmerge
938 ctl = hostalloc((struct query *)NULL);
940 ctl->server.pollname = xstrdup(argv[optind]);
942 ctl->server.lead_server = (struct hostdata *)NULL;
947 * If there's a defaults record, merge it and lose it.
949 if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
951 for (ctl = querylist->next; ctl; ctl = ctl->next)
952 optmerge(ctl, querylist, FALSE);
953 querylist = querylist->next;
956 /* don't allow a defaults record after the first */
957 for (ctl = querylist; ctl; ctl = ctl->next)
958 if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0)
961 /* use localhost if we never fetch the FQDN of this host */
962 fetchmailhost = "localhost";
964 /* here's where we override globals */
966 run.logfile = cmd_run.logfile;
968 run.idfile = cmd_run.idfile;
969 /* do this before the keep/fetchall test below, otherwise -d0 may fail */
970 if (cmd_run.poll_interval >= 0)
971 run.poll_interval = cmd_run.poll_interval;
972 if (cmd_run.invisible)
973 run.invisible = cmd_run.invisible;
974 if (cmd_run.use_syslog)
975 run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
976 if (cmd_run.postmaster)
977 run.postmaster = cmd_run.postmaster;
978 if (cmd_run.bouncemail)
979 run.bouncemail = cmd_run.bouncemail;
981 /* check and daemon options are not compatible */
982 if (check_only && run.poll_interval)
983 run.poll_interval = 0;
985 /* merge in wired defaults, do sanity checks and prepare internal fields */
986 for (ctl = querylist; ctl; ctl = ctl->next)
990 if (configdump || (ctl->active && !(implicitmode && ctl->server.skip)))
992 /* merge in defaults */
993 optmerge(ctl, &def_opts, FALSE);
995 /* force command-line options */
996 optmerge(ctl, &cmd_opts, TRUE);
998 /* this code enables flags to be turned off */
999 #define DEFAULT(flag, dflt) if (flag == FLAG_TRUE)\
1001 else if (flag == FLAG_FALSE)\
1005 DEFAULT(ctl->keep, FALSE);
1006 DEFAULT(ctl->fetchall, FALSE);
1007 DEFAULT(ctl->flush, FALSE);
1008 DEFAULT(ctl->rewrite, TRUE);
1009 DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1010 DEFAULT(ctl->forcecr, FALSE);
1011 DEFAULT(ctl->pass8bits, FALSE);
1012 DEFAULT(ctl->dropstatus, FALSE);
1013 DEFAULT(ctl->mimedecode, FALSE);
1014 DEFAULT(ctl->idle, FALSE);
1015 DEFAULT(ctl->server.dns, TRUE);
1016 DEFAULT(ctl->server.uidl, FALSE);
1018 DEFAULT(ctl->use_ssl, FALSE);
1020 DEFAULT(ctl->server.checkalias, FALSE);
1024 * DNS support is required for some protocols. We used to
1025 * do this unconditionally, but it made fetchmail excessively
1026 * vulnerable to misconfigured DNS setups.
1028 * If we're using ETRN, the smtp hunt list is the list of
1029 * systems we're polling on behalf of; these have to be
1030 * fully-qualified domain names. The default for this list
1031 * should be the FQDN of localhost.
1033 * If we're using Kerberos for authentication, we need
1034 * the FQDN in order to generate capability keys.
1036 if (ctl->server.protocol == P_ETRN
1037 || ctl->server.preauthenticate == A_KERBEROS_V4
1038 || ctl->server.preauthenticate == A_KERBEROS_V5)
1039 if (strcmp(fetchmailhost, "localhost") == 0)
1040 fetchmailhost = host_fqdn();
1043 * Make sure we have a nonempty host list to forward to.
1046 save_str(&ctl->smtphunt, fetchmailhost, FALSE);
1048 /* if `user' doesn't name a real local user, try to run as root */
1049 if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1052 ctl->uid = pw->pw_uid; /* for local delivery via MDA */
1053 if (!ctl->localnames) /* for local delivery via SMTP */
1054 save_str_pair(&ctl->localnames, user, NULL);
1056 #if !defined(HAVE_GETHOSTBYNAME) || !defined(HAVE_RES_SEARCH)
1057 /* can't handle multidrop mailboxes unless we can do DNS lookups */
1058 if (ctl->localnames && ctl->localnames->next && ctl->server.dns)
1060 ctl->server.dns = FALSE;
1061 report(stderr, _("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1063 #endif /* !HAVE_GETHOSTBYNAME || !HAVE_RES_SEARCH */
1067 * Compute the true name of the mailserver host.
1068 * There are two clashing cases here:
1070 * (1) The poll name is a label, possibly on one of several
1071 * poll configurations for the same host. In this case
1072 * the `via' option will be present and give the true name.
1074 * (2) The poll name is the true one, the via name is
1075 * localhost. This is going to be typical for ssh-using
1078 * We're going to assume the via name is true unless it's
1081 if (ctl->server.via && strcmp(ctl->server.via, "localhost"))
1082 ctl->server.queryname = xstrdup(ctl->server.via);
1084 ctl->server.queryname = xstrdup(ctl->server.pollname);
1087 /* If either the pollname or vianame are "hesiod" we want to
1088 lookup the user's hesiod pobox host */
1090 if (!strcasecmp(ctl->server.queryname, "hesiod")) {
1091 struct hes_postoffice *hes_p;
1092 hes_p = hes_getmailhost(ctl->remotename);
1093 if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
1094 free(ctl->server.queryname);
1095 ctl->server.queryname = xstrdup(hes_p->po_host);
1096 if (ctl->server.via)
1097 free(ctl->server.via);
1098 ctl->server.via = xstrdup(hes_p->po_host);
1101 _("couldn't find HESIOD pobox for %s\n"),
1108 * We may have to canonicalize the server truename for later use.
1109 * Do this just once for each lead server, if necessary, in order
1110 * to minimize DNS round trips.
1112 if (ctl->server.lead_server)
1114 char *leadname = ctl->server.lead_server->truename;
1116 /* prevent core dump from ill-formed or duplicate entry */
1120 _("Lead server has no name.\n"));
1124 ctl->server.truename = xstrdup(leadname);
1126 #ifdef HAVE_GETHOSTBYNAME
1127 else if (!configdump && (ctl->server.preauthenticate==A_KERBEROS_V4 ||
1128 ctl->server.preauthenticate==A_KERBEROS_V5 ||
1129 (ctl->server.dns && MULTIDROP(ctl))))
1131 struct hostent *namerec;
1133 /* compute the canonical name of the host */
1135 namerec = gethostbyname(ctl->server.queryname);
1136 if (namerec == (struct hostent *)NULL)
1139 _("couldn't find canonical DNS name of %s\n"),
1140 ctl->server.pollname);
1144 ctl->server.truename=xstrdup((char *)namerec->h_name);
1146 #endif /* HAVE_GETHOSTBYNAME */
1148 #ifdef HAVE_GETHOSTBYNAME
1149 struct hostent *namerec;
1151 /* <fetchmail@mail.julianhaight.com>
1152 Get the host's IP, so we can report it like this:
1154 Received: from hostname [10.0.0.1]
1156 do we actually need to gethostbyname to find the IP?
1157 it seems like it would be faster to do this later, when
1158 we are actually resolving the hostname for a connection,
1159 but I ain't that smart, so I don't know where to make
1163 namerec = gethostbyname(ctl->server.queryname);
1164 if (namerec == (struct hostent *)NULL)
1167 _("couldn't find canonical DNS name of %s\n"),
1168 ctl->server.pollname);
1172 ctl->server.truename=xstrdup((char *)namerec->h_name);
1173 ctl->server.trueaddr=xmalloc(namerec->h_length);
1174 memcpy(ctl->server.trueaddr,
1175 namerec->h_addr_list[0],
1179 ctl->server.truename = xstrdup(ctl->server.queryname);
1180 #endif /* HAVE_GETHOSTBYNAME */
1183 /* if no folders were specified, set up the null one as default */
1184 if (!ctl->mailboxes)
1185 save_str(&ctl->mailboxes, (char *)NULL, 0);
1187 /* maybe user overrode timeout on command line? */
1188 if (ctl->server.timeout == -1)
1189 ctl->server.timeout = CLIENT_TIMEOUT;
1193 if (ctl->server.port < 0)
1195 (void) fprintf(stderr,
1196 _("%s configuration invalid, port number cannot be negative\n"),
1197 ctl->server.pollname);
1200 if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
1202 (void) fprintf(stderr,
1203 _("%s configuration invalid, RPOP requires a privileged port\n"),
1204 ctl->server.pollname);
1207 if (ctl->listener == LMTP_MODE)
1211 for (idp = ctl->smtphunt; idp; idp = idp->next)
1215 if (!(cp = strrchr(idp->id, '/')) ||
1216 (atoi(++cp) == SMTP_PORT))
1218 (void) fprintf(stderr,
1219 _("%s configuration invalid, LMTP can't use default SMTP port\n"),
1220 ctl->server.pollname);
1225 #endif /* !INET6_ENABLE */
1228 * "I beg to you, have mercy on the week minds like myself."
1229 * wrote Pehr Anderson. Your petition is granted.
1231 if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
1233 (void) fprintf(stderr,
1234 _("Both fetchall and keep on in daemon mode is a mistake!\n"));
1241 /* initialize UID handling */
1242 if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
1245 initialize_saved_lists(querylist, run.idfile);
1246 #endif /* POP3_ENABLE */
1249 * If the user didn't set a last-resort user to get misaddressed
1250 * multidrop mail, set an appropriate default here.
1252 if (!run.postmaster)
1254 if (getuid()) /* ordinary user */
1255 run.postmaster = user;
1257 run.postmaster = "postmaster";
1260 return(implicitmode);
1263 static void terminate_poll(int sig)
1264 /* to be executed at the end of a poll cycle */
1267 * Close all SMTP delivery sockets. For optimum performance
1268 * we'd like to hold them open til end of run, but (1) this
1269 * loses if our poll interval is longer than the MTA's inactivity
1270 * timeout, and (2) some MTAs (like smail) don't deliver after
1271 * each message, but rather queue up mail and wait to actually
1272 * deliver it until the input socket is closed.
1274 * Sending SMTP QUIT on signal is theoretically nice, but led to a
1275 * subtle bug. If fetchmail was terminated by signal while it was
1276 * shipping message text, it would hang forever waiting for a
1277 * command acknowledge. In theory we could enable the QUIT
1278 * only outside of the message send. In practice, we don't
1279 * care. All mailservers hang up on a dropped TCP/IP connection
1284 report(stdout, _("terminated with signal %d\n"), sig);
1289 /* terminate all SMTP connections cleanly */
1290 for (ctl = querylist; ctl; ctl = ctl->next)
1291 if (ctl->smtp_socket != -1)
1293 SMTP_quit(ctl->smtp_socket);
1294 SockClose(ctl->smtp_socket);
1295 ctl->smtp_socket = -1;
1301 * Update UID information at end of each poll, rather than at end
1302 * of run, because that way we don't lose all UIDL information since
1303 * the beginning of time if fetchmail crashes.
1306 write_saved_lists(querylist, run.idfile);
1307 #endif /* POP3_ENABLE */
1310 static void terminate_run(int sig)
1311 /* to be executed on normal or signal-induced termination */
1315 terminate_poll(sig);
1318 * Craig Metz, the RFC1938 one-time-password guy, points out:
1319 * "Remember that most kernels don't zero pages before handing them to the
1320 * next process and many kernels share pages between user and kernel space.
1321 * You'd be very surprised what you can find from a short program to do a
1322 * malloc() and then dump the contents of the pages you got. By zeroing
1323 * the secrets at end of run (earlier if you can), you make sure the next
1324 * guy can't get the password/pass phrase."
1326 * Right you are, Craig!
1328 for (ctl = querylist; ctl; ctl = ctl->next)
1330 memset(ctl->password, '\0', strlen(ctl->password));
1332 #if !defined(HAVE_ATEXIT) && !defined(HAVE_ON_EXIT)
1336 exit(successes ? PS_SUCCESS : querystatus);
1340 * Sequence of protocols to try when autoprobing, most capable to least.
1342 static const int autoprobe[] =
1346 #endif /* IMAP_ENABLE */
1349 #endif /* POP3_ENABLE */
1352 #endif /* POP2_ENABLE */
1355 static int query_host(struct query *ctl)
1356 /* perform fetch transaction with single host */
1361 * If we're syslogging the progress messages are automatically timestamped.
1362 * Force timestamping if we're going to a logfile.
1364 if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
1366 report(stdout, _("%s querying %s (protocol %s) at %s\n"),
1368 ctl->server.pollname,
1369 showproto(ctl->server.protocol),
1372 switch (ctl->server.protocol) {
1374 for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1376 ctl->server.protocol = autoprobe[i];
1377 if ((st = query_host(ctl)) == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP)
1380 ctl->server.protocol = P_AUTO;
1384 return(doPOP2(ctl));
1386 report(stderr, _("POP2 support is not configured.\n"));
1387 return(PS_PROTOCOL);
1388 #endif /* POP2_ENABLE */
1394 return(doPOP3(ctl));
1396 report(stderr, _("POP3 support is not configured.\n"));
1397 return(PS_PROTOCOL);
1398 #endif /* POP3_ENABLE */
1402 case P_IMAP_CRAM_MD5:
1408 return(doIMAP(ctl));
1410 report(stderr, _("IMAP support is not configured.\n"));
1411 return(PS_PROTOCOL);
1412 #endif /* IMAP_ENABLE */
1415 report(stderr, _("ETRN support is not configured.\n"));
1416 return(PS_PROTOCOL);
1418 #ifdef HAVE_GETHOSTBYNAME
1419 return(doETRN(ctl));
1421 report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
1422 return(PS_PROTOCOL);
1423 #endif /* HAVE_GETHOSTBYNAME */
1424 #endif /* ETRN_ENABLE */
1426 report(stderr, _("unsupported protocol selected.\n"));
1427 return(PS_PROTOCOL);
1431 static void dump_params (struct runctl *runp,
1432 struct query *querylist, flag implicit)
1433 /* display query parameters in English */
1437 if (runp->poll_interval)
1438 printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
1440 printf(_("Logfile is %s\n"), runp->logfile);
1441 if (strcmp(runp->idfile, IDFILE_NAME))
1442 printf(_("Idfile is %s\n"), runp->idfile);
1443 #if defined(HAVE_SYSLOG)
1444 if (runp->use_syslog)
1445 printf(_("Progress messages will be logged via syslog\n"));
1447 if (runp->invisible)
1448 printf(_("Fetchmail will masquerade and will not generate Received\n"));
1449 if (runp->postmaster)
1450 printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1453 if (!runp->bouncemail)
1454 printf(_("Fetchmail will direct error mail to the postmaster.\n"));
1455 else if (outlevel >= O_VERBOSE)
1456 printf(_("Fetchmail will direct error mail to the sender.\n"));
1458 for (ctl = querylist; ctl; ctl = ctl->next)
1460 if (!ctl->active || (implicit && ctl->server.skip))
1463 printf(_("Options for retrieving from %s@%s:\n"),
1464 ctl->remotename, visbuf(ctl->server.pollname));
1466 if (ctl->server.via && (ctl->server.protocol != P_ETRN))
1467 printf(_(" Mail will be retrieved via %s\n"), ctl->server.via);
1469 if (ctl->server.interval)
1470 printf(_(" Poll of this server will occur every %d intervals.\n"),
1471 ctl->server.interval);
1472 if (ctl->server.truename)
1473 printf(_(" True name of server is %s.\n"), ctl->server.truename);
1474 if (ctl->server.skip || outlevel >= O_VERBOSE)
1475 printf(_(" This host %s be queried when no host is specified.\n"),
1476 ctl->server.skip ? _("will not") : _("will"));
1478 * Don't poll for password when there is one or when using the ETRN
1479 * or IMAP-GSS protocol
1481 /* ETRN, IMAP_GSS, and IMAP_K4 do not need a password, so skip this */
1482 if ( (ctl->server.protocol != P_ETRN)
1484 && (ctl->server.protocol != P_IMAP_GSS)
1486 && (ctl->server.protocol != P_IMAP_K4) ) {
1488 printf(_(" Password will be prompted for.\n"));
1489 else if (outlevel >= O_VERBOSE)
1491 if (ctl->server.protocol == P_APOP)
1492 printf(_(" APOP secret = \"%s\".\n"),
1493 visbuf(ctl->password));
1494 else if (ctl->server.protocol == P_RPOP)
1495 printf(_(" RPOP id = \"%s\".\n"),
1496 visbuf(ctl->password));
1498 printf(_(" Password = \"%s\".\n"),
1499 visbuf(ctl->password));
1503 if (ctl->server.protocol == P_POP3
1505 && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1506 #else /* INET6_ENABLE */
1507 && ctl->server.port == KPOP_PORT
1508 #endif /* INET6_ENABLE */
1509 && (ctl->server.preauthenticate == A_KERBEROS_V4 ||
1510 ctl->server.preauthenticate == A_KERBEROS_V5))
1511 printf(_(" Protocol is KPOP with Kerberos %s authentication"),
1512 ctl->server.preauthenticate == A_KERBEROS_V5 ? "V" : "IV");
1514 printf(_(" Protocol is %s"), showproto(ctl->server.protocol));
1516 if (ctl->server.service)
1517 printf(_(" (using service %s)"), ctl->server.service);
1518 if (ctl->server.netsec)
1519 printf(_(" (using network security options %s)"), ctl->server.netsec);
1520 #else /* INET6_ENABLE */
1521 if (ctl->server.port)
1522 printf(_(" (using port %d)"), ctl->server.port);
1523 #endif /* INET6_ENABLE */
1524 else if (outlevel >= O_VERBOSE)
1525 printf(_(" (using default port)"));
1526 if (ctl->server.uidl && (ctl->server.protocol != P_ETRN))
1527 printf(_(" (forcing UIDL use)"));
1530 if (ctl->server.preauthenticate == A_KERBEROS_V4)
1531 printf(_(" Kerberos V4 preauthentication enabled.\n"));
1532 else if (ctl->server.preauthenticate == A_KERBEROS_V5)
1533 printf(_(" Kerberos V5 preauthentication enabled.\n"));
1534 else if (ctl->server.preauthenticate == A_SSH)
1535 printf(_(" End-to-end encryption assumed.\n"));
1538 printf(" SSL encrypted sessions enabled.\n");
1540 if (ctl->server.timeout > 0)
1541 printf(_(" Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1542 if (ctl->server.timeout == CLIENT_TIMEOUT)
1543 printf(_(" (default).\n"));
1547 if (ctl->server.protocol != P_ETRN) {
1548 if (!ctl->mailboxes->id)
1549 printf(_(" Default mailbox selected.\n"));
1554 printf(_(" Selected mailboxes are:"));
1555 for (idp = ctl->mailboxes; idp; idp = idp->next)
1556 printf(" %s", idp->id);
1559 printf(_(" %s messages will be retrieved (--all %s).\n"),
1560 ctl->fetchall ? _("All") : _("Only new"),
1561 ctl->fetchall ? "on" : "off");
1562 printf(_(" Fetched messages %s be kept on the server (--keep %s).\n"),
1563 ctl->keep ? _("will") : _("will not"),
1564 ctl->keep ? "on" : "off");
1565 printf(_(" Old messages %s be flushed before message retrieval (--flush %s).\n"),
1566 ctl->flush ? _("will") : _("will not"),
1567 ctl->flush ? "on" : "off");
1568 printf(_(" Rewrite of server-local addresses is %s (--norewrite %s).\n"),
1569 ctl->rewrite ? _("enabled") : _("disabled"),
1570 ctl->rewrite ? "off" : "on");
1571 printf(_(" Carriage-return stripping is %s (stripcr %s).\n"),
1572 ctl->stripcr ? _("enabled") : _("disabled"),
1573 ctl->stripcr ? "on" : "off");
1574 printf(_(" Carriage-return forcing is %s (forcecr %s).\n"),
1575 ctl->forcecr ? _("enabled") : _("disabled"),
1576 ctl->forcecr ? "on" : "off");
1577 printf(_(" Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
1578 ctl->pass8bits ? _("disabled") : _("enabled"),
1579 ctl->pass8bits ? "on" : "off");
1580 printf(_(" MIME decoding is %s (mimedecode %s).\n"),
1581 ctl->mimedecode ? _("enabled") : _("disabled"),
1582 ctl->mimedecode ? "on" : "off");
1583 printf(_(" Idle after poll is %s (idle %s).\n"),
1584 ctl->idle ? _("enabled") : _("disabled"),
1585 ctl->idle ? "on" : "off");
1586 printf(_(" Nonempty Status lines will be %s (dropstatus %s)\n"),
1587 ctl->dropstatus ? _("discarded") : _("kept"),
1588 ctl->dropstatus ? "on" : "off");
1589 if (NUM_NONZERO(ctl->limit))
1591 if (NUM_NONZERO(ctl->limit))
1592 printf(_(" Message size limit is %d octets (--limit %d).\n"),
1593 ctl->limit, ctl->limit);
1594 else if (outlevel >= O_VERBOSE)
1595 printf(_(" No message size limit (--limit 0).\n"));
1596 if (run.poll_interval > 0)
1597 printf(_(" Message size warning interval is %d seconds (--warnings %d).\n"),
1598 ctl->warnings, ctl->warnings);
1599 else if (outlevel >= O_VERBOSE)
1600 printf(_(" Size warnings on every poll (--warnings 0).\n"));
1602 if (NUM_NONZERO(ctl->fetchlimit))
1603 printf(_(" Received-message limit is %d (--fetchlimit %d).\n"),
1604 ctl->fetchlimit, ctl->fetchlimit);
1605 else if (outlevel >= O_VERBOSE)
1606 printf(_(" No received-message limit (--fetchlimit 0).\n"));
1607 if (NUM_NONZERO(ctl->batchlimit))
1608 printf(_(" SMTP message batch limit is %d.\n"), ctl->batchlimit);
1609 else if (outlevel >= O_VERBOSE)
1610 printf(_(" No SMTP message batch limit (--batchlimit 0).\n"));
1611 if (ctl->server.protocol == P_IMAP)
1613 if (NUM_NONZERO(ctl->expunge))
1614 printf(_(" Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1615 else if (outlevel >= O_VERBOSE)
1616 printf(_(" No forced expunges (--expunge 0).\n"));
1620 printf(_(" Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1621 else if (ctl->mda && (ctl->server.protocol != P_ETRN))
1622 printf(_(" Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1627 printf(_(" Messages will be %cMTP-forwarded to:"), ctl->listener);
1628 for (idp = ctl->smtphunt; idp; idp = idp->next)
1630 printf(" %s", idp->id);
1631 if (!idp->val.status.mark)
1632 printf(_(" (default)"));
1635 if (ctl->smtpaddress)
1636 printf(_(" Host part of MAIL FROM line will be %s\n"),
1639 if (ctl->server.protocol != P_ETRN)
1641 if (ctl->antispam != (struct idlist *)NULL)
1645 printf(_(" Recognized listener spam block responses are:"));
1646 for (idp = ctl->antispam; idp; idp = idp->next)
1647 printf(" %d", idp->val.status.num);
1650 else if (outlevel >= O_VERBOSE)
1651 printf(_(" Spam-blocking disabled\n"));
1653 if (ctl->preconnect)
1654 printf(_(" Server connection will be brought up with \"%s\".\n"),
1655 visbuf(ctl->preconnect));
1656 else if (outlevel >= O_VERBOSE)
1657 printf(_(" No pre-connection command.\n"));
1658 if (ctl->postconnect)
1659 printf(_(" Server connection will be taken down with \"%s\".\n"),
1660 visbuf(ctl->postconnect));
1661 else if (outlevel >= O_VERBOSE)
1662 printf(_(" No post-connection command.\n"));
1663 if (ctl->server.protocol != P_ETRN) {
1664 if (!ctl->localnames)
1665 printf(_(" No localnames declared for this host.\n"));
1671 for (idp = ctl->localnames; idp; idp = idp->next)
1674 if (count > 1 || ctl->wildcard)
1675 printf(_(" Multi-drop mode: "));
1677 printf(_(" Single-drop mode: "));
1679 printf(_("%d local name(s) recognized.\n"), count);
1680 if (outlevel >= O_VERBOSE)
1682 for (idp = ctl->localnames; idp; idp = idp->next)
1684 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1686 printf("\t%s\n", idp->id);
1688 fputs("\t*\n", stdout);
1691 if (count > 1 || ctl->wildcard)
1693 printf(_(" DNS lookup for multidrop addresses is %s.\n"),
1694 ctl->server.dns ? _("enabled") : _("disabled"));
1695 if (ctl->server.dns)
1697 printf(_(" Server aliases will be compared with multidrop addresses by "));
1698 if (ctl->server.checkalias)
1699 printf(_("IP address.\n"));
1701 printf(_("name.\n"));
1703 if (ctl->server.envelope == STRING_DISABLED)
1704 printf(_(" Envelope-address routing is disabled\n"));
1707 printf(_(" Envelope header is assumed to be: %s\n"),
1708 ctl->server.envelope ? ctl->server.envelope:_("Received"));
1709 if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
1710 printf(_(" Number of envelope header to be parsed: %d\n"),
1711 ctl->server.envskip);
1712 if (ctl->server.qvirtual)
1713 printf(_(" Prefix %s will be removed from user id\n"),
1714 ctl->server.qvirtual);
1715 else if (outlevel >= O_VERBOSE)
1716 printf(_(" No prefix stripping\n"));
1719 if (ctl->server.akalist)
1723 printf(_(" Predeclared mailserver aliases:"));
1724 for (idp = ctl->server.akalist; idp; idp = idp->next)
1725 printf(" %s", idp->id);
1728 if (ctl->server.localdomains)
1732 printf(_(" Local domains:"));
1733 for (idp = ctl->server.localdomains; idp; idp = idp->next)
1734 printf(" %s", idp->id);
1740 #if defined(linux) || defined(__FreeBSD__)
1741 if (ctl->server.interface)
1742 printf(_(" Connection must be through interface %s.\n"), ctl->server.interface);
1743 else if (outlevel >= O_VERBOSE)
1744 printf(_(" No interface requirement specified.\n"));
1745 if (ctl->server.monitor)
1746 printf(_(" Polling loop will monitor %s.\n"), ctl->server.monitor);
1747 else if (outlevel >= O_VERBOSE)
1748 printf(_(" No monitor interface specified.\n"));
1751 if (ctl->server.plugin)
1752 printf(_(" Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1753 else if (outlevel >= O_VERBOSE)
1754 printf(_(" No plugin command specified.\n"));
1755 if (ctl->server.plugout)
1756 printf(_(" Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1757 else if (outlevel >= O_VERBOSE)
1758 printf(_(" No plugout command specified.\n"));
1760 if (ctl->server.protocol > P_POP2 && (ctl->server.protocol != P_ETRN))
1763 printf(_(" No UIDs saved from this host.\n"));
1769 for (idp = ctl->oldsaved; idp; idp = idp->next)
1772 printf(_(" %d UIDs saved.\n"), count);
1773 if (outlevel >= O_VERBOSE)
1774 for (idp = ctl->oldsaved; idp; idp = idp->next)
1775 printf("\t%s\n", idp->id);
1779 if (ctl->properties)
1780 printf(_(" Pass-through properties \"%s\".\n"),
1781 visbuf(ctl->properties));
1785 /* fetchmail.c ends here */