Pileus Git - ~andy/fetchmail/blob - fetchmail.c

   1 /*
   2  * fetchmail.c -- main driver module for fetchmail
   3  *
   4  * For license terms, see the file COPYING in this directory.
   5  */
   6 #include "config.h"
   7
   8 #include <stdio.h>
   9 #if defined(STDC_HEADERS)
  10 #include <stdlib.h>
  11 #endif
  12 #if defined(HAVE_UNISTD_H)
  13 #include <unistd.h>
  14 #endif
  15 #include <fcntl.h>
  16 #include <string.h>
  17 #include <signal.h>
  18 #if defined(HAVE_SYSLOG)
  19 #include <syslog.h>
  20 #endif
  21 #include <pwd.h>
  22 #ifdef __FreeBSD__
  23 #include <grp.h>
  24 #endif
  25 #include <errno.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #ifdef HAVE_SETRLIMIT
  29 #include <sys/resource.h>
  30 #endif /* HAVE_SETRLIMIT */
  31
  32 #ifdef HAVE_SOCKS
  33 #include <socks.h> /* SOCKSinit() */
  34 #endif /* HAVE_SOCKS */
  35
  36 #ifdef HAVE_LANGINFO_H
  37 #include <langinfo.h>
  38 #endif
  39
  40 #include "fetchmail.h"
  41 #include "socket.h"
  42 #include "tunable.h"
  43 #include "smtp.h"
  44 #include "netrc.h"
  45 #include "i18n.h"
  46 #include "lock.h"
  47
  48 #ifndef ENETUNREACH
  49 #define ENETUNREACH   128       /* Interactive doesn't know this */
  50 #endif /* ENETUNREACH */
  51
  52 /* prototypes for internal functions */
  53 static int load_params(int, char **, int);
  54 static void dump_params (struct runctl *runp, struct query *, flag implicit);
  55 static int query_host(struct query *);
  56
  57 /* controls the detail level of status/progress messages written to stderr */
  58 int outlevel;               /* see the O_.* constants above */
  59
  60 /* miscellaneous global controls */
  61 struct runctl run;          /* global controls for this run */
  62 flag nodetach;              /* if TRUE, don't detach daemon process */
  63 flag quitmode;              /* if --quit was set */
  64 int  quitind;               /* optind after position of last --quit option */
  65 flag check_only;            /* if --probe was set */
  66 flag versioninfo;           /* emit only version info */
  67 char *user;                 /* the name of the invoking user */
  68 char *home;                 /* invoking user's home directory */
  69 char *fmhome;               /* fetchmail's home directory */
  70 char *program_name;         /* the name to prefix error messages with */
  71 flag configdump;            /* dump control blocks for configurator */
  72 char *fetchmailhost;        /* either `localhost' or the host's FQDN */
  73
  74 static int quitonly;        /* if we should quit after killing the running daemon */
  75
  76 static int querystatus;         /* status of query */
  77 static int successes;           /* count number of successful polls */
  78 static int activecount;         /* count number of active entries */
  79 static struct runctl cmd_run;   /* global options set from command line */
  80 static time_t parsetime;        /* time of last parse */
  81
  82 static RETSIGTYPE terminate_run(int);
  83 static RETSIGTYPE terminate_poll(int);
  84
  85 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
  86 /* drop SGID kmem privileage until we need it */
  87 static void dropprivs(void)
  88 {
  89     struct group *gr;
  90     gid_t        egid;
  91     gid_t        rgid;
  92
  93     egid = getegid();
  94     rgid = getgid();
  95     gr = getgrgid(egid);
  96
  97     if (gr && !strcmp(gr->gr_name, "kmem"))
  98     {
  99         extern void interface_set_gids(gid_t egid, gid_t rgid);
 100         interface_set_gids(egid, rgid);
 101         setegid(rgid);
 102     }
 103 }
 104 #endif
 105
 106 #if defined(HAVE_SETLOCALE) && defined(ENABLE_NLS) && defined(HAVE_STRFTIME)
 107 #include <locale.h>
 108 /** returns timestamp in current locale,
 109  * and resets LC_TIME locale to POSIX. */
 110 static char *timestamp (void)
 111 {
 112     time_t      now;
 113     static char buf[60]; /* RATS: ignore */
 114
 115     time (&now);
 116     setlocale (LC_TIME, "");
 117     strftime (buf, sizeof (buf), "%c", localtime(&now));
 118     setlocale (LC_TIME, "C");
 119     return (buf);
 120 }
 121 #else
 122 #define timestamp rfc822timestamp
 123 #endif
 124
 125 static RETSIGTYPE donothing(int sig)
 126 {
 127     set_signal_handler(sig, donothing);
 128     lastsig = sig;
 129 }
 130
 131 static void printcopyright(FILE *fp) {
 132         fprintf(fp, GT_("Copyright (C) 2002, 2003 Eric S. Raymond\n"
 133                    "Copyright (C) 2004 Matthias Andree, Eric S. Raymond, Rob F. Funk, Graham Wilson\n"
 134                    "Copyright (C) 2005-2006 Matthias Andree, Sunil Shetye\n"
 135                    ));
 136         fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
 137                    "are welcome to redistribute it under certain conditions. For details,\n"
 138                    "please see the file COPYING in the source or documentation directory.\n"));
 139 }
 140
 141 const char *iana_charset;
 142
 143 int main(int argc, char **argv)
 144 {
 145     int bkgd = FALSE;
 146     int implicitmode = FALSE;
 147     struct query *ctl;
 148     netrc_entry *netrc_list;
 149     char *netrc_file, *tmpbuf;
 150     pid_t pid;
 151     int lastsig = 0;
 152
 153 #if defined(__FreeBSD__) && defined(__FreeBSD_USE_KVM)
 154     dropprivs();
 155 #endif
 156
 157     envquery(argc, argv);
 158 #ifdef ENABLE_NLS
 159     setlocale (LC_ALL, "");
 160     bindtextdomain(PACKAGE, LOCALEDIR);
 161     textdomain(PACKAGE);
 162     iana_charset = norm_charmap(nl_langinfo(CODESET)); /* normalize local
 163                                                           charset to
 164                                                           IANA charset. */
 165 #else
 166     iana_charset = "US-ASCII";
 167 #endif
 168
 169     if (getuid() == 0) {
 170         report(stderr, GT_("WARNING: Running as root is discouraged.\n"));
 171     }
 172
 173     /*
 174      * Note: because we can't initialize reporting before we  know whether
 175      * syslog is supposed to be on, this message will go to stdout and
 176      * be lost when running in background.
 177      */
 178     if (outlevel >= O_VERBOSE)
 179     {
 180         int i;
 181
 182         report(stdout, GT_("fetchmail: invoked with"));
 183         for (i = 0; i < argc; i++)
 184             report(stdout, " %s", argv[i]);
 185         report(stdout, "\n");
 186     }
 187
 188 #define IDFILE_NAME     ".fetchids"
 189     run.idfile = prependdir (IDFILE_NAME, fmhome);
 190
 191     outlevel = O_NORMAL;
 192
 193     /*
 194      * We used to arrange for the lock to be removed on exit close
 195      * to where the lock was asserted.  Now we need to do it here, because
 196      * we might have re-executed in background with an existing lock
 197      * as the result of a changed rcfile (see the code near the execvp(3)
 198      * call near the beginning of the polling loop for details).  We want
 199      * to be sure the lock gets nuked on any error exit, basically.
 200      */
 201     fm_lock_dispose();
 202
 203 #ifdef HAVE_GETCWD
 204     /* save the current directory */
 205     if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
 206         report(stderr, GT_("could not get current working directory\n"));
 207         currentwd[0] = 0;
 208     }
 209 #endif
 210
 211     {
 212         int i;
 213
 214         i = parsecmdline(argc, argv, &cmd_run, &cmd_opts);
 215         if (i < 0)
 216             exit(PS_SYNTAX);
 217
 218         if (quitmode && quitind == argc)
 219             quitonly = 1;
 220     }
 221
 222     if (versioninfo)
 223     {
 224         const char *features =
 225 #ifdef POP2_ENABLE
 226         "+POP2"
 227 #endif /* POP2_ENABLE */
 228 #ifndef POP3_ENABLE
 229         "-POP3"
 230 #endif /* POP3_ENABLE */
 231 #ifndef IMAP_ENABLE
 232         "-IMAP"
 233 #endif /* IMAP_ENABLE */
 234 #ifdef GSSAPI
 235         "+IMAP-GSS"
 236 #endif /* GSSAPI */
 237 #ifdef RPA_ENABLE
 238         "+RPA"
 239 #endif /* RPA_ENABLE */
 240 #ifdef NTLM_ENABLE
 241         "+NTLM"
 242 #endif /* NTLM_ENABLE */
 243 #ifdef SDPS_ENABLE
 244         "+SDPS"
 245 #endif /* SDPS_ENABLE */
 246 #ifndef ETRN_ENABLE
 247         "-ETRN"
 248 #endif /* ETRN_ENABLE */
 249 #ifndef ODMR_ENABLE
 250         "-ODMR"
 251 #endif /* ODMR_ENABLE */
 252 #ifdef SSL_ENABLE
 253         "+SSL"
 254 #endif
 255 #ifdef OPIE_ENABLE
 256         "+OPIE"
 257 #endif /* OPIE_ENABLE */
 258 #ifdef HAVE_PKG_hesiod
 259         "+HESIOD"
 260 #endif
 261 #ifdef HAVE_SOCKS
 262         "+SOCKS"
 263 #endif /* HAVE_SOCKS */
 264 #ifdef ENABLE_NLS
 265         "+NLS"
 266 #endif /* ENABLE_NLS */
 267         ".\n";
 268         printf(GT_("This is fetchmail release %s"), VERSION);
 269         fputs(features, stdout);
 270         puts("");
 271         printcopyright(stdout);
 272         puts("");
 273         fputs("Fallback MDA: ", stdout);
 274 #ifdef FALLBACK_MDA
 275         fputs(FALLBACK_MDA, stdout);
 276 #else
 277         fputs("(none)", stdout);
 278 #endif
 279         putchar('\n');
 280         fflush(stdout);
 281
 282         /* this is an attempt to help remote debugging */
 283         system("uname -a");
 284     }
 285
 286     /* avoid parsing the config file if all we're doing is killing a daemon */
 287     if (!quitonly)
 288         implicitmode = load_params(argc, argv, optind);
 289
 290 #if defined(HAVE_SYSLOG)
 291     /* logging should be set up early in case we were restarted from exec */
 292     if (run.use_syslog)
 293     {
 294 #if defined(LOG_MAIL)
 295         openlog(program_name, LOG_PID, LOG_MAIL);
 296 #else
 297         /* Assume BSD4.2 openlog with two arguments */
 298         openlog(program_name, LOG_PID);
 299 #endif
 300         report_init(-1);
 301     }
 302     else
 303 #endif
 304         report_init((run.poll_interval == 0 || nodetach) && !run.logfile);
 305
 306 #ifdef POP3_ENABLE
 307     /* initialize UID handling */
 308     {
 309         int st;
 310
 311         if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
 312             exit(st);
 313         else
 314             initialize_saved_lists(querylist, run.idfile);
 315     }
 316 #endif /* POP3_ENABLE */
 317
 318     /* construct the lockfile */
 319     fm_lock_setup(&run);
 320
 321 #ifdef HAVE_SETRLIMIT
 322     /*
 323      * Before getting passwords, disable core dumps unless -v -d0 mode is on.
 324      * Core dumps could otherwise contain passwords to be scavenged by a
 325      * cracker.
 326      */
 327     if (outlevel < O_VERBOSE || run.poll_interval > 0)
 328     {
 329         struct rlimit corelimit;
 330         corelimit.rlim_cur = 0;
 331         corelimit.rlim_max = 0;
 332         setrlimit(RLIMIT_CORE, &corelimit);
 333     }
 334 #endif /* HAVE_SETRLIMIT */
 335
 336 #define NETRC_FILE      ".netrc"
 337     /* parse the ~/.netrc file (if present) for future password lookups. */
 338     netrc_file = prependdir (NETRC_FILE, home);
 339     netrc_list = parse_netrc(netrc_file);
 340     free(netrc_file);
 341 #undef NETRC_FILE
 342
 343     /* pick up passwords where we can */
 344     for (ctl = querylist; ctl; ctl = ctl->next)
 345     {
 346         if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
 347         {
 348             if (NO_PASSWORD(ctl))
 349                 /* Server won't care what the password is, but there
 350                    must be some non-null string here.  */
 351                 ctl->password = ctl->remotename;
 352             else
 353             {
 354                 netrc_entry *p;
 355
 356                 /* look up the pollname and account in the .netrc file. */
 357                 p = search_netrc(netrc_list,
 358                                  ctl->server.pollname, ctl->remotename);
 359                 /* if we find a matching entry with a password, use it */
 360                 if (p && p->password)
 361                     ctl->password = xstrdup(p->password);
 362
 363                 /* otherwise try with "via" name if there is one */
 364                 else if (ctl->server.via)
 365                 {
 366                     p = search_netrc(netrc_list,
 367                                      ctl->server.via, ctl->remotename);
 368                     if (p && p->password)
 369                         ctl->password = xstrdup(p->password);
 370                 }
 371             }
 372         }
 373     }
 374
 375     free_netrc(netrc_list);
 376     netrc_list = 0;
 377
 378     /* perhaps we just want to check options? */
 379     if (versioninfo)
 380     {
 381         int havercfile = access(rcfile, 0);
 382
 383         printf(GT_("Taking options from command line%s%s\n"),
 384                                 havercfile ? "" :  GT_(" and "),
 385                                 havercfile ? "" : rcfile);
 386
 387         if (querylist == NULL)
 388             fprintf(stderr,
 389                     GT_("No mailservers set up -- perhaps %s is missing?\n"),
 390                     rcfile);
 391         else
 392             dump_params(&run, querylist, implicitmode);
 393         exit(0);
 394     }
 395
 396     /* dump options as a Python dictionary, for configurator use */
 397     if (configdump)
 398     {
 399         dump_config(&run, querylist);
 400         exit(0);
 401     }
 402
 403     /* check for another fetchmail running concurrently */
 404     pid = fm_lock_state();
 405     bkgd = (pid < 0);
 406     pid = bkgd ? -pid : pid;
 407
 408     /* if no mail servers listed and nothing in background, we're done */
 409     if (!quitonly && pid == 0 && querylist == NULL) {
 410         (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
 411         exit(PS_SYNTAX);
 412     }
 413
 414     /* perhaps user asked us to kill the other fetchmail */
 415     if (quitmode)
 416     {
 417         if (pid == 0 || pid == getpid())
 418             /* this test enables re-execing on a changed rcfile
 419              * for pid == getpid() */
 420         {
 421             if (quitonly) {
 422                 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
 423                 exit(PS_EXCLUDE);
 424             }
 425         }
 426         else if (kill(pid, SIGTERM) < 0)
 427         {
 428             fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %d; bailing out.\n"),
 429                     bkgd ? GT_("background") : GT_("foreground"), pid);
 430             exit(PS_EXCLUDE);
 431         }
 432         else
 433         {
 434             int maxwait;
 435
 436             if (outlevel > O_SILENT)
 437                 fprintf(stderr,GT_("fetchmail: %s fetchmail at %d killed.\n"),
 438                         bkgd ? GT_("background") : GT_("foreground"), pid);
 439             /* We used to nuke the other process's lock here, with
 440              * fm_lock_release(), which is broken. The other process
 441              * needs to clear its lock by itself. */
 442             if (quitonly)
 443                 exit(0);
 444
 445             /* wait for other process to exit */
 446             maxwait = 10; /* seconds */
 447             while (kill(pid, 0) == 0 && --maxwait >= 0) {
 448                 sleep(1);
 449             }
 450             pid = 0;
 451         }
 452     }
 453
 454     /* another fetchmail is running -- wake it up or die */
 455     if (pid != 0)
 456     {
 457         if (check_only)
 458         {
 459             fprintf(stderr,
 460                  GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
 461             return(PS_EXCLUDE);
 462         }
 463         else if (!implicitmode)
 464         {
 465             fprintf(stderr,
 466                  GT_("fetchmail: can't poll specified hosts with another fetchmail running at %d.\n"),
 467                  pid);
 468                 return(PS_EXCLUDE);
 469         }
 470         else if (!bkgd)
 471         {
 472             fprintf(stderr,
 473                  GT_("fetchmail: another foreground fetchmail is running at %d.\n"),
 474                  pid);
 475                 return(PS_EXCLUDE);
 476         }
 477         else if (getpid() == pid)
 478             /* this test enables re-execing on a changed rcfile */
 479             fm_lock_assert();
 480         else if (argc > 1)
 481         {
 482             fprintf(stderr,
 483                     GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
 484             return(PS_EXCLUDE);
 485         }
 486         else if (kill(pid, SIGUSR1) == 0)
 487         {
 488             fprintf(stderr,
 489                     GT_("fetchmail: background fetchmail at %d awakened.\n"),
 490                     pid);
 491             return(0);
 492         }
 493         else
 494         {
 495             /*
 496              * Should never happen -- possible only if a background fetchmail
 497              * croaks after the first kill probe above but before the
 498              * SIGUSR1/SIGHUP transmission.
 499              */
 500             fprintf(stderr,
 501                     GT_("fetchmail: elder sibling at %d died mysteriously.\n"),
 502                     pid);
 503             return(PS_UNDEFINED);
 504         }
 505     }
 506
 507     /* pick up interactively any passwords we need but don't have */
 508     for (ctl = querylist; ctl; ctl = ctl->next)
 509     {
 510         if (ctl->active && !(implicitmode && ctl->server.skip)
 511                 && !NO_PASSWORD(ctl) && !ctl->password)
 512         {
 513             if (!isatty(0))
 514             {
 515                 fprintf(stderr,
 516                         GT_("fetchmail: can't find a password for %s@%s.\n"),
 517                         ctl->remotename, ctl->server.pollname);
 518                 return(PS_AUTHFAIL);
 519             } else {
 520                 const char* password_prompt = GT_("Enter password for %s@%s: ");
 521                 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
 522
 523                 tmpbuf = xmalloc(pplen);
 524                 snprintf(tmpbuf, pplen, password_prompt,
 525                         ctl->remotename, ctl->server.pollname);
 526                 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
 527                 free(tmpbuf);
 528             }
 529         }
 530     }
 531
 532     /*
 533      * Time to initiate the SOCKS library (this is not mandatory: it just
 534      * registers the correct application name for logging purpose. If you
 535      * have some problem, comment out these lines).
 536      */
 537 #ifdef HAVE_SOCKS
 538     SOCKSinit("fetchmail");
 539 #endif /* HAVE_SOCKS */
 540
 541     /* avoid zombies from plugins */
 542     deal_with_sigchld();
 543
 544     /*
 545      * Maybe time to go to demon mode...
 546      */
 547     if (run.poll_interval)
 548     {
 549         if (!nodetach)
 550             daemonize(run.logfile);
 551         report(stdout, GT_("starting fetchmail %s daemon \n"), VERSION);
 552
 553         /*
 554          * We'll set up a handler for these when we're sleeping,
 555          * but ignore them otherwise so as not to interrupt a poll.
 556          */
 557         set_signal_handler(SIGUSR1, SIG_IGN);
 558         if (run.poll_interval && getuid() == ROOT_UID)
 559             set_signal_handler(SIGHUP, SIG_IGN);
 560     }
 561     else
 562     {
 563         if (run.logfile && !nodetach && access(run.logfile, F_OK) == 0)
 564         {
 565             if (!freopen(run.logfile, "a", stdout))
 566                     report(stderr, GT_("could not open %s to append logs to \n"), run.logfile);
 567             if (!freopen(run.logfile, "a", stderr))
 568                     report(stdout, GT_("could not open %s to append logs to \n"), run.logfile);
 569         }
 570     }
 571
 572     interface_init();
 573
 574     /* beyond here we don't want more than one fetchmail running per user */
 575     umask(0077);
 576     set_signal_handler(SIGABRT, terminate_run);
 577     set_signal_handler(SIGINT, terminate_run);
 578     set_signal_handler(SIGTERM, terminate_run);
 579     set_signal_handler(SIGALRM, terminate_run);
 580     set_signal_handler(SIGPIPE, terminate_run);
 581     set_signal_handler(SIGQUIT, terminate_run);
 582
 583     /* here's the exclusion lock */
 584     fm_lock_or_die();
 585
 586     /*
 587      * Query all hosts. If there's only one, the error return will
 588      * reflect the status of that transaction.
 589      */
 590     do {
 591         /*
 592          * Check to see if the rcfile has been touched.  If so,
 593          * re-exec so the file will be reread.  Doing it this way
 594          * avoids all the complications of trying to deallocate the
 595          * in-core control structures -- and the potential memory
 596          * leaks...
 597          */
 598         struct stat     rcstat;
 599
 600         if (strcmp(rcfile, "-") == 0) {
 601             /* do nothing */
 602         } else if (stat(rcfile, &rcstat) == -1) {
 603             if (errno != ENOENT)
 604                 report(stderr,
 605                        GT_("couldn't time-check %s (error %d)\n"),
 606                        rcfile, errno);
 607         }
 608         else if (rcstat.st_mtime > parsetime)
 609         {
 610             report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
 611
 612 #ifdef HAVE_GETCWD
 613             /* restore the startup directory */
 614             if (!currentwd[0] || chdir (currentwd) == -1)
 615                 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
 616 #endif
 617
 618             /*
 619              * Matthias Andree: Isn't this prone to introduction of
 620              * "false" programs by interfering with PATH? Those
 621              * path-searching execs might not be the best ideas for
 622              * this reason.
 623              *
 624              * Rob Funk: But is there any way for someone to modify
 625              * the PATH variable of a running fetchmail?  I don't know
 626              * of a way.
 627              *
 628              * Dave's change makes fetchmail restart itself in exactly
 629              * the way it was started from the shell (or shell script)
 630              * in the first place.  If you're concerned about PATH
 631              * contamination, call fetchmail initially with a full
 632              * path, and use Dave's patch.
 633              *
 634              * Not using a -p variant of exec means that the restart
 635              * will break if both (a) the user depended on PATH to
 636              * call fetchmail in the first place, and (b) the system
 637              * doesn't save the whole path in argv[0] if the whole
 638              * path wasn't used in the initial call.  (If I recall
 639              * correctly, Linux saves it but many other Unices don't.)
 640              */
 641             execvp(argv[0], argv);
 642             report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
 643         }
 644
 645 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
 646         /*
 647          * This was an efficiency hack that backfired.  The theory
 648          * was that using TCP/IP for DNS queries would get us better
 649          * reliability and shave off some per-UDP-packet costs.
 650          * Unfortunately it interacted badly with diald, which effectively
 651          * filters out DNS queries over TCP/IP for reasons having to do
 652          * with some obscure Linux kernel problem involving bootstrapping of
 653          * dynamically-addressed links.  I don't understand this mess
 654          * and don't want to, so it's "See ya!" to this hack.
 655          */
 656         sethostent(TRUE);       /* use TCP/IP for mailserver queries */
 657 #endif /* HAVE_RES_SEARCH */
 658
 659         activecount = 0;
 660         batchcount = 0;
 661         for (ctl = querylist; ctl; ctl = ctl->next)
 662             if (ctl->active)
 663             {
 664                 activecount++;
 665                 if (!(implicitmode && ctl->server.skip))
 666                 {
 667                     if (ctl->wedged)
 668                     {
 669                         report(stderr,
 670                                GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
 671                                ctl->server.pollname);
 672                         continue;
 673                     }
 674
 675                     /* check skip interval first so that it counts all polls */
 676                     if (run.poll_interval && ctl->server.interval)
 677                     {
 678                         if (ctl->server.poll_count++ % ctl->server.interval)
 679                         {
 680                             if (outlevel >= O_VERBOSE)
 681                                 report(stdout,
 682                                        GT_("interval not reached, not querying %s\n"),
 683                                        ctl->server.pollname);
 684                             continue;
 685                         }
 686                     }
 687
 688 #ifdef CAN_MONITOR
 689                     /*
 690                      * Don't do monitoring if we were woken by a signal.
 691                      * Note that interface_approve() does its own error logging.
 692                      */
 693                     if (!interface_approve(&ctl->server, !lastsig))
 694                         continue;
 695 #endif /* CAN_MONITOR */
 696
 697                     dofastuidl = 0; /* this is reset in the driver if required */
 698
 699                     querystatus = query_host(ctl);
 700
 701                     if (NUM_NONZERO(ctl->fastuidl))
 702                         ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
 703 #ifdef POP3_ENABLE
 704                     /* leave the UIDL state alone if there have been any errors */
 705                     if (!check_only &&
 706                                 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
 707                         uid_swap_lists(ctl);
 708                     else
 709                         uid_discard_new_list(ctl);
 710                     uid_reset_num(ctl);
 711 #endif  /* POP3_ENABLE */
 712
 713                     if (querystatus == PS_SUCCESS)
 714                         successes++;
 715                     else if (!check_only &&
 716                              ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
 717                         switch(querystatus)
 718                         {
 719                         case PS_SUCCESS:
 720                             report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
 721                         case PS_NOMAIL:
 722                             report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
 723                         case PS_SOCKET:
 724                             report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
 725                         case PS_AUTHFAIL:
 726                             report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
 727                         case PS_PROTOCOL:
 728                             report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
 729                         case PS_SYNTAX:
 730                             report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
 731                         case PS_IOERR:
 732                             report(stdout,GT_("Query status=6 (IOERR)\n"));  break;
 733                         case PS_ERROR:
 734                             report(stdout,GT_("Query status=7 (ERROR)\n"));  break;
 735                         case PS_EXCLUDE:
 736                             report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
 737                         case PS_LOCKBUSY:
 738                             report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
 739                         case PS_SMTP:
 740                             report(stdout,GT_("Query status=10 (SMTP)\n")); break;
 741                         case PS_DNS:
 742                             report(stdout,GT_("Query status=11 (DNS)\n")); break;
 743                         case PS_BSMTP:
 744                             report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
 745                         case PS_MAXFETCH:
 746                             report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
 747                         default:
 748                             report(stdout,GT_("Query status=%d\n"),querystatus);
 749                             break;
 750                         }
 751
 752 #ifdef CAN_MONITOR
 753                     if (ctl->server.monitor)
 754                     {
 755                         /*
 756                          * Allow some time for the link to quiesce.  One
 757                          * second is usually sufficient, three is safe.
 758                          * Note:  this delay is important - don't remove!
 759                          */
 760                         sleep(3);
 761                         interface_note_activity(&ctl->server);
 762                     }
 763 #endif /* CAN_MONITOR */
 764                 }
 765             }
 766
 767 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
 768         endhostent();           /* release TCP/IP connection to nameserver */
 769 #endif /* HAVE_RES_SEARCH */
 770
 771         /* close connections cleanly */
 772         terminate_poll(0);
 773
 774         /*
 775          * OK, we've polled.  Now sleep.
 776          */
 777         if (run.poll_interval)
 778         {
 779             /*
 780              * Because passwords can expire, it may happen that *all*
 781              * hosts are now out of the loop due to authfail
 782              * conditions.  If this happens daemon-mode fetchmail
 783              * should softly and silently vanish away, rather than
 784              * spinning uselessly.
 785              */
 786             int unwedged = 0;
 787
 788             for (ctl = querylist; ctl; ctl = ctl->next)
 789                 if (ctl->active && !(implicitmode && ctl->server.skip))
 790                     if (!ctl->wedged)
 791                         unwedged++;
 792             if (!unwedged)
 793             {
 794                 report(stderr, GT_("All connections are wedged.  Exiting.\n"));
 795                 /* FIXME: someday, send notification mail */
 796                 exit(PS_AUTHFAIL);
 797             }
 798
 799             if (outlevel > O_SILENT)
 800                 report(stdout,
 801                        GT_("sleeping at %s\n"), timestamp());
 802
 803             /*
 804              * With this simple hack, we make it possible for a foreground
 805              * fetchmail to wake up one in daemon mode.  What we want is the
 806              * side effect of interrupting any sleep that may be going on,
 807              * forcing fetchmail to re-poll its hosts.  The second line is
 808              * for people who think all system daemons wake up on SIGHUP.
 809              */
 810             set_signal_handler(SIGUSR1, donothing);
 811             if (getuid() == ROOT_UID)
 812                 set_signal_handler(SIGHUP, donothing);
 813
 814             /*
 815              * OK, now pause until it's time for the next poll cycle.
 816              * A nonzero return indicates we received a wakeup signal;
 817              * unwedge all servers in case the problem has been
 818              * manually repaired.
 819              */
 820             if ((lastsig = interruptible_idle(run.poll_interval)))
 821             {
 822                 if (outlevel > O_SILENT)
 823 #ifdef SYS_SIGLIST_DECLARED
 824                     report(stdout,
 825                        GT_("awakened by %s\n"), sys_siglist[lastsig]);
 826 #else
 827                     report(stdout,
 828                        GT_("awakened by signal %d\n"), lastsig);
 829 #endif
 830                 for (ctl = querylist; ctl; ctl = ctl->next)
 831                     ctl->wedged = FALSE;
 832             }
 833
 834             if (outlevel > O_SILENT)
 835                 report(stdout, GT_("awakened at %s\n"), timestamp());
 836         }
 837     } while
 838         (run.poll_interval);
 839
 840     if (outlevel >= O_VERBOSE)
 841         report(stdout, GT_("normal termination, status %d\n"),
 842                 successes ? PS_SUCCESS : querystatus);
 843
 844     terminate_run(0);
 845
 846     if (successes)
 847         exit(PS_SUCCESS);
 848     else if (querystatus)
 849         exit(querystatus);
 850     else
 851         /* in case we interrupted before a successful fetch */
 852         exit(PS_NOMAIL);
 853 }
 854
 855 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
 856 {
 857     /*
 858      * If force is off, modify dstl fields only when they're empty (treat srcl
 859      * as defaults).  If force is on, modify each dstl field whenever scrcl
 860      * is nonempty (treat srcl as an override).
 861      */
 862     if (force ? !!*srcl : !*dstl)
 863     {
 864         struct idlist *cpl = copy_str_list(*srcl);
 865
 866         append_str_list(dstl, &cpl);
 867     }
 868 }
 869
 870 static void optmerge(struct query *h2, struct query *h1, int force)
 871 /* merge two options records */
 872 {
 873     list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
 874     list_merge(&h2->localnames, &h1->localnames, force);
 875     list_merge(&h2->mailboxes, &h1->mailboxes, force);
 876     list_merge(&h2->smtphunt, &h1->smtphunt, force);
 877     list_merge(&h2->domainlist, &h1->domainlist, force);
 878     list_merge(&h2->antispam, &h1->antispam, force);
 879
 880 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
 881     FLAG_MERGE(server.via);
 882     FLAG_MERGE(server.protocol);
 883     FLAG_MERGE(server.service);
 884     FLAG_MERGE(server.interval);
 885     FLAG_MERGE(server.authenticate);
 886     FLAG_MERGE(server.timeout);
 887     FLAG_MERGE(server.envelope);
 888     FLAG_MERGE(server.envskip);
 889     FLAG_MERGE(server.qvirtual);
 890     FLAG_MERGE(server.skip);
 891     FLAG_MERGE(server.dns);
 892     FLAG_MERGE(server.checkalias);
 893     FLAG_MERGE(server.uidl);
 894     FLAG_MERGE(server.principal);
 895
 896 #ifdef CAN_MONITOR
 897     FLAG_MERGE(server.interface);
 898     FLAG_MERGE(server.interface_pair);
 899     FLAG_MERGE(server.monitor);
 900 #endif
 901
 902     FLAG_MERGE(server.plugin);
 903     FLAG_MERGE(server.plugout);
 904     FLAG_MERGE(server.tracepolls);
 905
 906     FLAG_MERGE(wildcard);
 907     FLAG_MERGE(remotename);
 908     FLAG_MERGE(password);
 909     FLAG_MERGE(mda);
 910     FLAG_MERGE(bsmtp);
 911     FLAG_MERGE(listener);
 912     FLAG_MERGE(smtpaddress);
 913     FLAG_MERGE(smtpname);
 914     FLAG_MERGE(preconnect);
 915     FLAG_MERGE(postconnect);
 916
 917     FLAG_MERGE(keep);
 918     FLAG_MERGE(flush);
 919     FLAG_MERGE(limitflush);
 920     FLAG_MERGE(fetchall);
 921     FLAG_MERGE(rewrite);
 922     FLAG_MERGE(forcecr);
 923     FLAG_MERGE(stripcr);
 924     FLAG_MERGE(pass8bits);
 925     FLAG_MERGE(dropstatus);
 926     FLAG_MERGE(dropdelivered);
 927     FLAG_MERGE(mimedecode);
 928     FLAG_MERGE(idle);
 929     FLAG_MERGE(limit);
 930     FLAG_MERGE(warnings);
 931     FLAG_MERGE(fetchlimit);
 932     FLAG_MERGE(fetchsizelimit);
 933     FLAG_MERGE(fastuidl);
 934     FLAG_MERGE(batchlimit);
 935 #ifdef  SSL_ENABLE
 936     FLAG_MERGE(use_ssl);
 937     FLAG_MERGE(sslkey);
 938     FLAG_MERGE(sslcert);
 939     FLAG_MERGE(sslproto);
 940     FLAG_MERGE(sslcertck);
 941     FLAG_MERGE(sslcertpath);
 942     FLAG_MERGE(sslfingerprint);
 943 #endif
 944     FLAG_MERGE(expunge);
 945
 946     FLAG_MERGE(properties);
 947 #undef FLAG_MERGE
 948 }
 949
 950 /** Load configuration files.
 951  * \return - true if no servers found on the command line
 952  *         - false if servers found on the command line */
 953 static int load_params(int argc, char **argv, int optind)
 954 {
 955     int implicitmode, st;
 956     struct passwd *pw;
 957     struct query def_opts, *ctl;
 958     struct stat rcstat;
 959     char *p;
 960
 961     run.bouncemail = TRUE;
 962     run.spambounce = FALSE;     /* don't bounce back to innocent bystanders */
 963
 964     memset(&def_opts, '\0', sizeof(struct query));
 965     def_opts.smtp_socket = -1;
 966     def_opts.smtpaddress = (char *)0;
 967     def_opts.smtpname = (char *)0;
 968     def_opts.server.protocol = P_AUTO;
 969     def_opts.server.timeout = CLIENT_TIMEOUT;
 970     def_opts.server.esmtp_name = user;
 971     def_opts.warnings = WARNING_INTERVAL;
 972     def_opts.remotename = user;
 973     def_opts.listener = SMTP_MODE;
 974     def_opts.fetchsizelimit = 100;
 975     def_opts.fastuidl = 4;
 976
 977     /* get the location of rcfile */
 978     rcfiledir[0] = 0;
 979     p = strrchr (rcfile, '/');
 980     if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
 981         *p = 0;                 /* replace '/' by '0' */
 982         strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
 983         *p = '/';               /* restore '/' */
 984         if (!rcfiledir[0])      /* "/.fetchmailrc" case */
 985             strcpy (rcfiledir, "/");
 986     }
 987
 988     /* note the parse time, so we can pick up on modifications */
 989     parsetime = 0;      /* foil compiler warnings */
 990     if (strcmp(rcfile, "-") == 0 || stat(rcfile, &rcstat) != -1)
 991         parsetime = rcstat.st_mtime;
 992     else if (errno != ENOENT)
 993         report(stderr, GT_("couldn't time-check the run-control file\n"));
 994
 995     /* this builds the host list */
 996     if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
 997         /*
 998          * FIXME: someday, send notification mail here if backgrounded.
 999          * Right now, that can happen if the user changes the rcfile
1000          * while the fetchmail is running in background.  Do similarly
1001          * for the other exit() calls in this function.
1002          */
1003         exit(st);
1004
1005     if ((implicitmode = (optind >= argc)))
1006     {
1007         for (ctl = querylist; ctl; ctl = ctl->next)
1008             ctl->active = !ctl->server.skip;
1009     }
1010     else
1011         for (; optind < argc; optind++)
1012         {
1013             flag        predeclared =  FALSE;
1014
1015             /*
1016              * If hostname corresponds to a host known from the rc file,
1017              * simply declare it active.  Otherwise synthesize a host
1018              * record from command line and defaults
1019              */
1020             for (ctl = querylist; ctl; ctl = ctl->next)
1021                 if (!strcmp(ctl->server.pollname, argv[optind])
1022                         || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1023                 {
1024                     /* Is this correct? */
1025                     if (predeclared && outlevel >= O_VERBOSE)
1026                         fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1027                     ctl->active = TRUE;
1028                     predeclared = TRUE;
1029                 }
1030
1031             if (!predeclared)
1032             {
1033                 /*
1034                  * Allocate and link record without copying in
1035                  * command-line args; we'll do that with the optmerge
1036                  * call later on.
1037                  */
1038                 ctl = hostalloc((struct query *)NULL);
1039                 ctl->server.via =
1040                     ctl->server.pollname = xstrdup(argv[optind]);
1041                 ctl->active = TRUE;
1042                 ctl->server.lead_server = (struct hostdata *)NULL;
1043             }
1044         }
1045
1046     /*
1047      * If there's a defaults record, merge it and lose it.
1048      */
1049     if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1050     {
1051         for (ctl = querylist->next; ctl; ctl = ctl->next)
1052             optmerge(ctl, querylist, FALSE);
1053         querylist = querylist->next;
1054     }
1055
1056     /* don't allow a defaults record after the first */
1057     for (ctl = querylist; ctl; ctl = ctl->next) {
1058         if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1059             fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1060             exit(PS_SYNTAX);
1061         }
1062     }
1063
1064     /* use localhost if we never fetch the FQDN of this host */
1065     fetchmailhost = "localhost";
1066
1067     /* here's where we override globals */
1068     if (cmd_run.logfile)
1069         run.logfile = cmd_run.logfile;
1070     if (cmd_run.idfile)
1071         run.idfile = cmd_run.idfile;
1072     if (cmd_run.pidfile)
1073         run.pidfile = cmd_run.pidfile;
1074     /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1075     if (cmd_run.poll_interval >= 0)
1076         run.poll_interval = cmd_run.poll_interval;
1077     if (cmd_run.invisible)
1078         run.invisible = cmd_run.invisible;
1079     if (cmd_run.showdots)
1080         run.showdots = cmd_run.showdots;
1081     if (cmd_run.use_syslog)
1082         run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1083     if (cmd_run.postmaster)
1084         run.postmaster = cmd_run.postmaster;
1085     if (cmd_run.bouncemail)
1086         run.bouncemail = cmd_run.bouncemail;
1087
1088     /* check and daemon options are not compatible */
1089     if (check_only && run.poll_interval)
1090         run.poll_interval = 0;
1091
1092     /*
1093      * DNS support is required for some protocols.  We used to
1094      * do this unconditionally, but it made fetchmail excessively
1095      * vulnerable to misconfigured DNS setups.
1096      *
1097      * If we're using ETRN or ODMR, the smtp hunt list is the
1098      * list of systems we're polling on behalf of; these have
1099      * to be fully-qualified domain names.  The default for
1100      * this list should be the FQDN of localhost.
1101      *
1102      * If we're using Kerberos for authentication, we need
1103      * the FQDN in order to generate capability keys.
1104      */
1105     for (ctl = querylist; ctl; ctl = ctl->next)
1106         if (ctl->active &&
1107                 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1108                  || ctl->server.authenticate == A_KERBEROS_V4
1109                  || ctl->server.authenticate == A_KERBEROS_V5))
1110         {
1111             fetchmailhost = host_fqdn(1);
1112             break;
1113         }
1114
1115     if (!ctl) /* list exhausted */
1116         fetchmailhost = host_fqdn(0);
1117
1118     /* this code enables flags to be turned off */
1119 #define DEFAULT(flag, dflt)     if (flag == FLAG_TRUE)\
1120                                         flag = TRUE;\
1121                                 else if (flag == FLAG_FALSE)\
1122                                         flag = FALSE;\
1123                                 else\
1124                                         flag = (dflt)
1125     /* one global gets treated specially */
1126     DEFAULT(run.showdots, run.poll_interval==0 || nodetach);
1127
1128     /* merge in wired defaults, do sanity checks and prepare internal fields */
1129     for (ctl = querylist; ctl; ctl = ctl->next)
1130     {
1131         ctl->wedged = FALSE;
1132
1133         /* merge in defaults */
1134         optmerge(ctl, &def_opts, FALSE);
1135
1136         /* force command-line options */
1137         optmerge(ctl, &cmd_opts, TRUE);
1138
1139         /*
1140          * queryname has to be set up for inactive servers too.
1141          * Otherwise the UIDL code core-dumps on startup.
1142          */
1143         if (ctl->server.via)
1144             ctl->server.queryname = xstrdup(ctl->server.via);
1145         else
1146             ctl->server.queryname = xstrdup(ctl->server.pollname);
1147
1148         /*
1149          * We no longer do DNS lookups at startup.
1150          * This is a kluge.  It enables users to edit their
1151          * configurations when DNS isn't available.
1152          */
1153         ctl->server.truename = xstrdup(ctl->server.queryname);
1154
1155         if (configdump || ctl->active )
1156         {
1157             DEFAULT(ctl->keep, FALSE);
1158             DEFAULT(ctl->fetchall, FALSE);
1159             DEFAULT(ctl->flush, FALSE);
1160             DEFAULT(ctl->limitflush, FALSE);
1161             DEFAULT(ctl->rewrite, TRUE);
1162             DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1163             DEFAULT(ctl->forcecr, FALSE);
1164             DEFAULT(ctl->pass8bits, FALSE);
1165             DEFAULT(ctl->dropstatus, FALSE);
1166             DEFAULT(ctl->dropdelivered, FALSE);
1167             DEFAULT(ctl->mimedecode, FALSE);
1168             DEFAULT(ctl->idle, FALSE);
1169             DEFAULT(ctl->server.dns, TRUE);
1170             DEFAULT(ctl->server.uidl, FALSE);
1171             DEFAULT(ctl->use_ssl, FALSE);
1172             DEFAULT(ctl->sslcertck, FALSE);
1173             DEFAULT(ctl->server.checkalias, FALSE);
1174 #ifndef SSL_ENABLE
1175             /*
1176              * XXX FIXME: do we need this check or can we rely on the .y
1177              * parser handling this?
1178              */
1179             if (ctl->use_ssl)
1180             {
1181                 report(stderr, GT_("SSL support is not compiled in.\n"));
1182                 exit(PS_SYNTAX);
1183             }
1184 #endif /* SSL_ENABLE */
1185 #undef DEFAULT
1186
1187             /*
1188              * Make sure we have a nonempty host list to forward to.
1189              */
1190             if (!ctl->smtphunt)
1191                 save_str(&ctl->smtphunt, "localhost", FALSE);
1192
1193             /*
1194              * Make sure we have a nonempty list of domains to fetch from.
1195              */
1196             if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1197                 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1198
1199             /* if `user' doesn't name a real local user, try to run as root */
1200             if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1201                 ctl->uid = 0;
1202             else
1203                 ctl->uid = pw->pw_uid;  /* for local delivery via MDA */
1204             if (!ctl->localnames)       /* for local delivery via SMTP */
1205                 save_str_pair(&ctl->localnames, user, NULL);
1206
1207 #ifndef HAVE_RES_SEARCH
1208             /* can't handle multidrop mailboxes unless we can do DNS lookups */
1209             if (MULTIDROP(ctl) && ctl->server.dns)
1210             {
1211                 ctl->server.dns = FALSE;
1212                 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1213             }
1214 #endif /* !HAVE_RES_SEARCH */
1215
1216             /*
1217              * can't handle multidrop mailboxes without "envelope"
1218              * option, this causes truckloads full of support complaints
1219              * "all mail forwarded to postmaster"
1220              */
1221             if (MULTIDROP(ctl) && !ctl->server.envelope)
1222             {
1223                 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1224                 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1225             }
1226
1227             /* if no folders were specified, set up the null one as default */
1228             if (!ctl->mailboxes)
1229                 save_str(&ctl->mailboxes, (char *)NULL, 0);
1230
1231             /* maybe user overrode timeout on command line? */
1232             if (ctl->server.timeout == -1)
1233                 ctl->server.timeout = CLIENT_TIMEOUT;
1234
1235             /* sanity checks */
1236             if (ctl->server.service) {
1237                 int port = servport(ctl->server.service);
1238                 if (port < 0)
1239                 {
1240                     (void) fprintf(stderr,
1241                                    GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1242                                    ctl->server.pollname);
1243                     exit(PS_SYNTAX);
1244                 }
1245                 if (ctl->server.protocol == P_RPOP && port >= 1024)
1246                 {
1247                     (void) fprintf(stderr,
1248                                    GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1249                                    ctl->server.pollname);
1250                     exit(PS_SYNTAX);
1251                 }
1252             }
1253             if (ctl->listener == LMTP_MODE)
1254             {
1255                 struct idlist   *idp;
1256
1257                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1258                 {
1259                     char        *cp;
1260
1261                     if (!(cp = strrchr(idp->id, '/'))
1262                         || (0 == strcmp(cp + 1, SMTP_PORT))
1263                         || servport(cp + 1) == SMTP_PORT_NUM)
1264                     {
1265                         (void) fprintf(stderr,
1266                                        GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1267                                        ctl->server.pollname);
1268                         exit(PS_SYNTAX);
1269                     }
1270                 }
1271             }
1272
1273             /*
1274              * "I beg to you, have mercy on the we[a]k minds like myself."
1275              * wrote Pehr Anderson.  Your petition is granted.
1276              */
1277             if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1278             {
1279                 (void) fprintf(stderr,
1280                                GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1281             }
1282         }
1283     }
1284
1285     /*
1286      * If the user didn't set a last-resort user to get misaddressed
1287      * multidrop mail, set an appropriate default here.
1288      */
1289     if (!run.postmaster)
1290     {
1291         if (getuid() != ROOT_UID)               /* ordinary user */
1292             run.postmaster = user;
1293         else                                    /* root */
1294             run.postmaster = "postmaster";
1295     }
1296
1297     return(implicitmode);
1298 }
1299
1300 static RETSIGTYPE terminate_poll(int sig)
1301 /* to be executed at the end of a poll cycle */
1302 {
1303
1304     if (sig != 0)
1305         report(stdout, GT_("terminated with signal %d\n"), sig);
1306
1307 #ifdef POP3_ENABLE
1308     /*
1309      * Update UID information at end of each poll, rather than at end
1310      * of run, because that way we don't lose all UIDL information since
1311      * the beginning of time if fetchmail crashes.
1312      */
1313     if (!check_only)
1314         write_saved_lists(querylist, run.idfile);
1315 #endif /* POP3_ENABLE */
1316 }
1317
1318 static RETSIGTYPE terminate_run(int sig)
1319 /* to be executed on normal or signal-induced termination */
1320 {
1321     struct query        *ctl;
1322
1323     terminate_poll(sig);
1324
1325     /*
1326      * Craig Metz, the RFC1938 one-time-password guy, points out:
1327      * "Remember that most kernels don't zero pages before handing them to the
1328      * next process and many kernels share pages between user and kernel space.
1329      * You'd be very surprised what you can find from a short program to do a
1330      * malloc() and then dump the contents of the pages you got. By zeroing
1331      * the secrets at end of run (earlier if you can), you make sure the next
1332      * guy can't get the password/pass phrase."
1333      *
1334      * Right you are, Craig!
1335      */
1336     for (ctl = querylist; ctl; ctl = ctl->next)
1337         if (ctl->password)
1338           memset(ctl->password, '\0', strlen(ctl->password));
1339
1340 #if !defined(HAVE_ATEXIT)
1341     fm_lock_release();
1342 #endif
1343
1344     if (activecount == 0)
1345         exit(PS_NOMAIL);
1346     else
1347         exit(successes ? PS_SUCCESS : querystatus);
1348 }
1349
1350 /*
1351  * Sequence of protocols to try when autoprobing, most capable to least.
1352  */
1353 static const int autoprobe[] =
1354 {
1355 #ifdef IMAP_ENABLE
1356     P_IMAP,
1357 #endif /* IMAP_ENABLE */
1358 #ifdef POP3_ENABLE
1359     P_POP3,
1360 #endif /* POP3_ENABLE */
1361 #ifdef POP2_ENABLE
1362     P_POP2
1363 #endif /* POP2_ENABLE */
1364 };
1365
1366 static int query_host(struct query *ctl)
1367 /* perform fetch transaction with single host */
1368 {
1369     size_t i;
1370     int st = 0;
1371
1372     /*
1373      * If we're syslogging the progress messages are automatically timestamped.
1374      * Force timestamping if we're going to a logfile.
1375      */
1376     if (outlevel >= O_VERBOSE)
1377     {
1378         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1379                VERSION,
1380                ctl->server.pollname,
1381                showproto(ctl->server.protocol),
1382                timestamp());
1383     }
1384
1385     switch (ctl->server.protocol) {
1386     case P_AUTO:
1387         for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1388         {
1389             ctl->server.protocol = autoprobe[i];
1390             do {
1391                 st = query_host(ctl);
1392             } while
1393                 (st == PS_REPOLL);
1394             if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1395                 break;
1396         }
1397         ctl->server.protocol = P_AUTO;
1398         break;
1399     case P_POP2:
1400 #ifdef POP2_ENABLE
1401         st = doPOP2(ctl);
1402 #else
1403         report(stderr, GT_("POP2 support is not configured.\n"));
1404         st = PS_PROTOCOL;
1405 #endif /* POP2_ENABLE */
1406         break;
1407     case P_POP3:
1408     case P_APOP:
1409     case P_RPOP:
1410 #ifdef POP3_ENABLE
1411         do {
1412             st = doPOP3(ctl);
1413         } while (st == PS_REPOLL);
1414 #else
1415         report(stderr, GT_("POP3 support is not configured.\n"));
1416         st = PS_PROTOCOL;
1417 #endif /* POP3_ENABLE */
1418         break;
1419     case P_IMAP:
1420 #ifdef IMAP_ENABLE
1421         do {
1422             st = doIMAP(ctl);
1423         } while (st == PS_REPOLL);
1424 #else
1425         report(stderr, GT_("IMAP support is not configured.\n"));
1426         st = PS_PROTOCOL;
1427 #endif /* IMAP_ENABLE */
1428         break;
1429     case P_ETRN:
1430 #ifndef ETRN_ENABLE
1431         report(stderr, GT_("ETRN support is not configured.\n"));
1432         st = PS_PROTOCOL;
1433 #else
1434         st = doETRN(ctl);
1435         break;
1436 #endif /* ETRN_ENABLE */
1437     case P_ODMR:
1438 #ifndef ODMR_ENABLE
1439         report(stderr, GT_("ODMR support is not configured.\n"));
1440         st = PS_PROTOCOL;
1441 #else
1442         st = doODMR(ctl);
1443 #endif /* ODMR_ENABLE */
1444         break;
1445     default:
1446         report(stderr, GT_("unsupported protocol selected.\n"));
1447         st = PS_PROTOCOL;
1448     }
1449
1450     /*
1451      * If we're syslogging the progress messages are automatically timestamped.
1452      * Force timestamping if we're going to a logfile.
1453      */
1454     if (outlevel >= O_VERBOSE)
1455     {
1456         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1457                VERSION,
1458                ctl->server.pollname,
1459                showproto(ctl->server.protocol),
1460                timestamp());
1461     }
1462
1463     return(st);
1464 }
1465
1466 static void dump_params (struct runctl *runp,
1467                          struct query *querylist, flag implicit)
1468 /* display query parameters in English */
1469 {
1470     struct query *ctl;
1471
1472     if (runp->poll_interval)
1473         printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1474     if (runp->logfile)
1475         printf(GT_("Logfile is %s\n"), runp->logfile);
1476     if (strcmp(runp->idfile, IDFILE_NAME))
1477         printf(GT_("Idfile is %s\n"), runp->idfile);
1478 #if defined(HAVE_SYSLOG)
1479     if (runp->use_syslog)
1480         printf(GT_("Progress messages will be logged via syslog\n"));
1481 #endif
1482     if (runp->invisible)
1483         printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1484     if (runp->showdots)
1485         printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1486     if (runp->postmaster)
1487         printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1488                runp->postmaster);
1489
1490     if (!runp->bouncemail)
1491         printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1492     else if (outlevel >= O_VERBOSE)
1493         printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1494
1495     for (ctl = querylist; ctl; ctl = ctl->next)
1496     {
1497         if (!ctl->active || (implicit && ctl->server.skip))
1498             continue;
1499
1500         printf(GT_("Options for retrieving from %s@%s:\n"),
1501                ctl->remotename, visbuf(ctl->server.pollname));
1502
1503         if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1504             printf(GT_("  Mail will be retrieved via %s\n"), ctl->server.via);
1505
1506         if (ctl->server.interval)
1507             printf(ngettext("  Poll of this server will occur every %d interval.\n",
1508                             "  Poll of this server will occur every %d intervals.\n",
1509                             ctl->server.interval), ctl->server.interval);
1510         if (ctl->server.truename)
1511             printf(GT_("  True name of server is %s.\n"), ctl->server.truename);
1512         if (ctl->server.skip || outlevel >= O_VERBOSE)
1513             printf(ctl->server.skip
1514                    ? GT_("  This host will not be queried when no host is specified.\n")
1515                    : GT_("  This host will be queried when no host is specified.\n"));
1516         if (!NO_PASSWORD(ctl))
1517         {
1518             if (!ctl->password)
1519                 printf(GT_("  Password will be prompted for.\n"));
1520             else if (outlevel >= O_VERBOSE)
1521             {
1522                 if (ctl->server.protocol == P_APOP)
1523                     printf(GT_("  APOP secret = \"%s\".\n"),
1524                            visbuf(ctl->password));
1525                 else if (ctl->server.protocol == P_RPOP)
1526                     printf(GT_("  RPOP id = \"%s\".\n"),
1527                            visbuf(ctl->password));
1528                 else
1529                     printf(GT_("  Password = \"%s\".\n"),
1530                                                         visbuf(ctl->password));
1531             }
1532         }
1533
1534         if (ctl->server.protocol == P_POP3
1535             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1536             && (ctl->server.authenticate == A_KERBEROS_V4 ||
1537                 ctl->server.authenticate == A_KERBEROS_V5))
1538             printf(GT_("  Protocol is KPOP with Kerberos %s authentication"),
1539                    ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1540         else
1541             printf(GT_("  Protocol is %s"), showproto(ctl->server.protocol));
1542         if (ctl->server.service)
1543             printf(GT_(" (using service %s)"), ctl->server.service);
1544         else if (outlevel >= O_VERBOSE)
1545             printf(GT_(" (using default port)"));
1546         if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1547             printf(GT_(" (forcing UIDL use)"));
1548         putchar('.');
1549         putchar('\n');
1550         switch (ctl->server.authenticate)
1551         {
1552         case A_ANY:
1553             printf(GT_("  All available authentication methods will be tried.\n"));
1554             break;
1555         case A_PASSWORD:
1556             printf(GT_("  Password authentication will be forced.\n"));
1557             break;
1558         case A_MSN:
1559             printf(GT_("  MSN authentication will be forced.\n"));
1560             break;
1561         case A_NTLM:
1562             printf(GT_("  NTLM authentication will be forced.\n"));
1563             break;
1564         case A_OTP:
1565             printf(GT_("  OTP authentication will be forced.\n"));
1566             break;
1567         case A_CRAM_MD5:
1568             printf(GT_("  CRAM-Md5 authentication will be forced.\n"));
1569             break;
1570         case A_GSSAPI:
1571             printf(GT_("  GSSAPI authentication will be forced.\n"));
1572             break;
1573         case A_KERBEROS_V4:
1574             printf(GT_("  Kerberos V4 authentication will be forced.\n"));
1575             break;
1576         case A_KERBEROS_V5:
1577             printf(GT_("  Kerberos V5 authentication will be forced.\n"));
1578             break;
1579         case A_SSH:
1580             printf(GT_("  End-to-end encryption assumed.\n"));
1581             break;
1582         }
1583         if (ctl->server.principal != (char *) NULL)
1584             printf(GT_("  Mail service principal is: %s\n"), ctl->server.principal);
1585 #ifdef  SSL_ENABLE
1586         if (ctl->use_ssl)
1587             printf(GT_("  SSL encrypted sessions enabled.\n"));
1588         if (ctl->sslproto)
1589             printf(GT_("  SSL protocol: %s.\n"), ctl->sslproto);
1590         if (ctl->sslcertck) {
1591             printf(GT_("  SSL server certificate checking enabled.\n"));
1592             if (ctl->sslcertpath != NULL)
1593                 printf(GT_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1594         }
1595         if (ctl->sslfingerprint != NULL)
1596                 printf(GT_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1597 #endif
1598         if (ctl->server.timeout > 0)
1599             printf(GT_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1600         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
1601             printf(GT_(" (default).\n"));
1602         else
1603             printf(".\n");
1604
1605         if (MAILBOX_PROTOCOL(ctl))
1606         {
1607             if (!ctl->mailboxes->id)
1608                 printf(GT_("  Default mailbox selected.\n"));
1609             else
1610             {
1611                 struct idlist *idp;
1612
1613                 printf(GT_("  Selected mailboxes are:"));
1614                 for (idp = ctl->mailboxes; idp; idp = idp->next)
1615                     printf(" %s", idp->id);
1616                 printf("\n");
1617             }
1618             printf(ctl->fetchall
1619                    ? GT_("  All messages will be retrieved (--all on).\n")
1620                    : GT_("  Only new messages will be retrieved (--all off).\n"));
1621             printf(ctl->keep
1622                    ? GT_("  Fetched messages will be kept on the server (--keep on).\n")
1623                    : GT_("  Fetched messages will not be kept on the server (--keep off).\n"));
1624             printf(ctl->flush
1625                    ? GT_("  Old messages will be flushed before message retrieval (--flush on).\n")
1626                    : GT_("  Old messages will not be flushed before message retrieval (--flush off).\n"));
1627             printf(ctl->limitflush
1628                    ? GT_("  Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1629                    : GT_("  Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1630             printf(ctl->rewrite
1631                    ? GT_("  Rewrite of server-local addresses is enabled (--norewrite off).\n")
1632                    : GT_("  Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1633             printf(ctl->stripcr
1634                    ? GT_("  Carriage-return stripping is enabled (stripcr on).\n")
1635                    : GT_("  Carriage-return stripping is disabled (stripcr off).\n"));
1636             printf(ctl->forcecr
1637                    ? GT_("  Carriage-return forcing is enabled (forcecr on).\n")
1638                    : GT_("  Carriage-return forcing is disabled (forcecr off).\n"));
1639             printf(ctl->pass8bits
1640                    ? GT_("  Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1641                    : GT_("  Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1642             printf(ctl->mimedecode
1643                    ? GT_("  MIME decoding is enabled (mimedecode on).\n")
1644                    : GT_("  MIME decoding is disabled (mimedecode off).\n"));
1645             printf(ctl->idle
1646                    ? GT_("  Idle after poll is enabled (idle on).\n")
1647                    : GT_("  Idle after poll is disabled (idle off).\n"));
1648             printf(ctl->dropstatus
1649                    ? GT_("  Nonempty Status lines will be discarded (dropstatus on)\n")
1650                    : GT_("  Nonempty Status lines will be kept (dropstatus off)\n"));
1651             printf(ctl->dropdelivered
1652                    ? GT_("  Delivered-To lines will be discarded (dropdelivered on)\n")
1653                    : GT_("  Delivered-To lines will be kept (dropdelivered off)\n"));
1654             if (NUM_NONZERO(ctl->limit))
1655             {
1656                 if (NUM_NONZERO(ctl->limit))
1657                     printf(GT_("  Message size limit is %d octets (--limit %d).\n"),
1658                            ctl->limit, ctl->limit);
1659                 else if (outlevel >= O_VERBOSE)
1660                     printf(GT_("  No message size limit (--limit 0).\n"));
1661                 if (run.poll_interval > 0)
1662                     printf(GT_("  Message size warning interval is %d seconds (--warnings %d).\n"),
1663                            ctl->warnings, ctl->warnings);
1664                 else if (outlevel >= O_VERBOSE)
1665                     printf(GT_("  Size warnings on every poll (--warnings 0).\n"));
1666             }
1667             if (NUM_NONZERO(ctl->fetchlimit))
1668                 printf(GT_("  Received-message limit is %d (--fetchlimit %d).\n"),
1669                        ctl->fetchlimit, ctl->fetchlimit);
1670             else if (outlevel >= O_VERBOSE)
1671                 printf(GT_("  No received-message limit (--fetchlimit 0).\n"));
1672             if (NUM_NONZERO(ctl->fetchsizelimit))
1673                 printf(GT_("  Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1674                        ctl->fetchsizelimit, ctl->fetchsizelimit);
1675             else if (outlevel >= O_VERBOSE)
1676                 printf(GT_("  No fetch message size limit (--fetchsizelimit 0).\n"));
1677             if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1678             {
1679                 if (ctl->fastuidl == 1)
1680                     printf(GT_("  Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1681                 else
1682                     printf(GT_("  Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1683             }
1684             else if (outlevel >= O_VERBOSE)
1685                 printf(GT_("   Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1686             if (NUM_NONZERO(ctl->batchlimit))
1687                 printf(GT_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
1688             else if (outlevel >= O_VERBOSE)
1689                 printf(GT_("  No SMTP message batch limit (--batchlimit 0).\n"));
1690             if (MAILBOX_PROTOCOL(ctl))
1691             {
1692                 if (NUM_NONZERO(ctl->expunge))
1693                     printf(GT_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1694                 else if (outlevel >= O_VERBOSE)
1695                     printf(GT_("  No forced expunges (--expunge 0).\n"));
1696             }
1697         }
1698         else    /* ODMR or ETRN */
1699         {
1700             struct idlist *idp;
1701
1702             printf(GT_("  Domains for which mail will be fetched are:"));
1703             for (idp = ctl->domainlist; idp; idp = idp->next)
1704             {
1705                 printf(" %s", idp->id);
1706                 if (!idp->val.status.mark)
1707                     printf(GT_(" (default)"));
1708             }
1709             printf("\n");
1710         }
1711         if (ctl->bsmtp)
1712             printf(GT_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1713         else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1714             printf(GT_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1715         else
1716         {
1717             struct idlist *idp;
1718
1719             if (ctl->smtphunt)
1720             {
1721                 printf(GT_("  Messages will be %cMTP-forwarded to:"),
1722                        ctl->listener);
1723                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1724                 {
1725                     printf(" %s", idp->id);
1726                     if (!idp->val.status.mark)
1727                         printf(GT_(" (default)"));
1728                 }
1729                 printf("\n");
1730             }
1731             if (ctl->smtpaddress)
1732                 printf(GT_("  Host part of MAIL FROM line will be %s\n"),
1733                        ctl->smtpaddress);
1734             if (ctl->smtpname)
1735                 printf(GT_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1736                        ctl->smtpname);
1737         }
1738         if (MAILBOX_PROTOCOL(ctl))
1739         {
1740                 if (ctl->antispam != (struct idlist *)NULL)
1741                 {
1742                     struct idlist *idp;
1743
1744                     printf(GT_("  Recognized listener spam block responses are:"));
1745                     for (idp = ctl->antispam; idp; idp = idp->next)
1746                         printf(" %d", idp->val.status.num);
1747                     printf("\n");
1748                 }
1749                 else if (outlevel >= O_VERBOSE)
1750                     printf(GT_("  Spam-blocking disabled\n"));
1751         }
1752         if (ctl->preconnect)
1753             printf(GT_("  Server connection will be brought up with \"%s\".\n"),
1754                    visbuf(ctl->preconnect));
1755         else if (outlevel >= O_VERBOSE)
1756             printf(GT_("  No pre-connection command.\n"));
1757         if (ctl->postconnect)
1758             printf(GT_("  Server connection will be taken down with \"%s\".\n"),
1759                    visbuf(ctl->postconnect));
1760         else if (outlevel >= O_VERBOSE)
1761             printf(GT_("  No post-connection command.\n"));
1762         if (MAILBOX_PROTOCOL(ctl)) {
1763                 if (!ctl->localnames)
1764                     printf(GT_("  No localnames declared for this host.\n"));
1765                 else
1766                 {
1767                     struct idlist *idp;
1768                     int count = 0;
1769
1770                     for (idp = ctl->localnames; idp; idp = idp->next)
1771                         ++count;
1772
1773                     if (count > 1 || ctl->wildcard)
1774                         printf(GT_("  Multi-drop mode: "));
1775                     else
1776                         printf(GT_("  Single-drop mode: "));
1777
1778                     printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1779                     if (outlevel >= O_VERBOSE)
1780                     {
1781                         for (idp = ctl->localnames; idp; idp = idp->next)
1782                             if (idp->val.id2)
1783                                 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1784                             else
1785                                 printf("\t%s\n", idp->id);
1786                         if (ctl->wildcard)
1787                             fputs("\t*\n", stdout);
1788                     }
1789
1790                     if (count > 1 || ctl->wildcard)
1791                     {
1792                         printf(ctl->server.dns
1793                                ? GT_("  DNS lookup for multidrop addresses is enabled.\n")
1794                                : GT_("  DNS lookup for multidrop addresses is disabled.\n"));
1795                         if (ctl->server.dns)
1796                         {
1797                             if (ctl->server.checkalias)
1798                                 printf(GT_("  Server aliases will be compared with multidrop addresses by IP address.\n"));
1799                             else
1800                                 printf(GT_("  Server aliases will be compared with multidrop addresses by name.\n"));
1801                         }
1802                         if (ctl->server.envelope == STRING_DISABLED)
1803                             printf(GT_("  Envelope-address routing is disabled\n"));
1804                         else
1805                         {
1806                             printf(GT_("  Envelope header is assumed to be: %s\n"),
1807                                    ctl->server.envelope ? ctl->server.envelope : "Received");
1808                             if (ctl->server.envskip || outlevel >= O_VERBOSE)
1809                                 printf(GT_("  Number of envelope headers to be skipped over: %d\n"),
1810                                        ctl->server.envskip);
1811                             if (ctl->server.qvirtual)
1812                                 printf(GT_("  Prefix %s will be removed from user id\n"),
1813                                        ctl->server.qvirtual);
1814                             else if (outlevel >= O_VERBOSE)
1815                                 printf(GT_("  No prefix stripping\n"));
1816                         }
1817
1818                         if (ctl->server.akalist)
1819                         {
1820                             struct idlist *idp;
1821
1822                             printf(GT_("  Predeclared mailserver aliases:"));
1823                             for (idp = ctl->server.akalist; idp; idp = idp->next)
1824                                 printf(" %s", idp->id);
1825                             putchar('\n');
1826                         }
1827                         if (ctl->server.localdomains)
1828                         {
1829                             struct idlist *idp;
1830
1831                             printf(GT_("  Local domains:"));
1832                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
1833                                 printf(" %s", idp->id);
1834                             putchar('\n');
1835                         }
1836                     }
1837                 }
1838         }
1839 #ifdef CAN_MONITOR
1840         if (ctl->server.interface)
1841             printf(GT_("  Connection must be through interface %s.\n"), ctl->server.interface);
1842         else if (outlevel >= O_VERBOSE)
1843             printf(GT_("  No interface requirement specified.\n"));
1844         if (ctl->server.monitor)
1845             printf(GT_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
1846         else if (outlevel >= O_VERBOSE)
1847             printf(GT_("  No monitor interface specified.\n"));
1848 #endif
1849
1850         if (ctl->server.plugin)
1851             printf(GT_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1852         else if (outlevel >= O_VERBOSE)
1853             printf(GT_("  No plugin command specified.\n"));
1854         if (ctl->server.plugout)
1855             printf(GT_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1856         else if (outlevel >= O_VERBOSE)
1857             printf(GT_("  No plugout command specified.\n"));
1858
1859         if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1860         {
1861             if (!ctl->oldsaved)
1862                 printf(GT_("  No UIDs saved from this host.\n"));
1863             else
1864             {
1865                 struct idlist *idp;
1866                 int count = 0;
1867
1868                 for (idp = ctl->oldsaved; idp; idp = idp->next)
1869                     ++count;
1870
1871                 printf(GT_("  %d UIDs saved.\n"), count);
1872                 if (outlevel >= O_VERBOSE)
1873                     for (idp = ctl->oldsaved; idp; idp = idp->next)
1874                         printf("\t%s\n", idp->id);
1875             }
1876         }
1877
1878         if (ctl->server.tracepolls)
1879             printf(GT_("  Poll trace information will be added to the Received header.\n"));
1880         else if (outlevel >= O_VERBOSE)
1881             printf(GT_("  No poll trace information will be added to the Received header.\n.\n"));
1882
1883         if (ctl->properties)
1884             printf(GT_("  Pass-through properties \"%s\".\n"),
1885                    visbuf(ctl->properties));
1886     }
1887 }
1888
1889 /* fetchmail.c ends here */