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