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