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, terminate_run);
 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 && (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((char *)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     int i, st = 0;
1366
1367     /*
1368      * If we're syslogging the progress messages are automatically timestamped.
1369      * Force timestamping if we're going to a logfile.
1370      */
1371     if (outlevel >= O_VERBOSE)
1372     {
1373         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1374                VERSION,
1375                ctl->server.pollname,
1376                showproto(ctl->server.protocol),
1377                timestamp());
1378     }
1379
1380     switch (ctl->server.protocol) {
1381     case P_AUTO:
1382         for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1383         {
1384             ctl->server.protocol = autoprobe[i];
1385             do {
1386                 st = query_host(ctl);
1387             } while
1388                 (st == PS_REPOLL);
1389             if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1390                 break;
1391         }
1392         ctl->server.protocol = P_AUTO;
1393         break;
1394     case P_POP2:
1395 #ifdef POP2_ENABLE
1396         st = doPOP2(ctl);
1397 #else
1398         report(stderr, GT_("POP2 support is not configured.\n"));
1399         st = PS_PROTOCOL;
1400 #endif /* POP2_ENABLE */
1401         break;
1402     case P_POP3:
1403     case P_APOP:
1404     case P_RPOP:
1405 #ifdef POP3_ENABLE
1406         do {
1407             st = doPOP3(ctl);
1408         } while (st == PS_REPOLL);
1409 #else
1410         report(stderr, GT_("POP3 support is not configured.\n"));
1411         st = PS_PROTOCOL;
1412 #endif /* POP3_ENABLE */
1413         break;
1414     case P_IMAP:
1415 #ifdef IMAP_ENABLE
1416         do {
1417             st = doIMAP(ctl);
1418         } while (st == PS_REPOLL);
1419 #else
1420         report(stderr, GT_("IMAP support is not configured.\n"));
1421         st = PS_PROTOCOL;
1422 #endif /* IMAP_ENABLE */
1423         break;
1424     case P_ETRN:
1425 #ifndef ETRN_ENABLE
1426         report(stderr, GT_("ETRN support is not configured.\n"));
1427         st = PS_PROTOCOL;
1428 #else
1429         st = doETRN(ctl);
1430         break;
1431 #endif /* ETRN_ENABLE */
1432     case P_ODMR:
1433 #ifndef ODMR_ENABLE
1434         report(stderr, GT_("ODMR support is not configured.\n"));
1435         st = PS_PROTOCOL;
1436 #else
1437         st = doODMR(ctl);
1438 #endif /* ODMR_ENABLE */
1439         break;
1440     default:
1441         report(stderr, GT_("unsupported protocol selected.\n"));
1442         st = PS_PROTOCOL;
1443     }
1444
1445     /*
1446      * If we're syslogging the progress messages are automatically timestamped.
1447      * Force timestamping if we're going to a logfile.
1448      */
1449     if (outlevel >= O_VERBOSE)
1450     {
1451         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1452                VERSION,
1453                ctl->server.pollname,
1454                showproto(ctl->server.protocol),
1455                timestamp());
1456     }
1457
1458     return(st);
1459 }
1460
1461 static void dump_params (struct runctl *runp,
1462                          struct query *querylist, flag implicit)
1463 /* display query parameters in English */
1464 {
1465     struct query *ctl;
1466
1467     if (runp->poll_interval)
1468         printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1469     if (runp->logfile)
1470         printf(GT_("Logfile is %s\n"), runp->logfile);
1471     if (strcmp(runp->idfile, IDFILE_NAME))
1472         printf(GT_("Idfile is %s\n"), runp->idfile);
1473 #if defined(HAVE_SYSLOG)
1474     if (runp->use_syslog)
1475         printf(GT_("Progress messages will be logged via syslog\n"));
1476 #endif
1477     if (runp->invisible)
1478         printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1479     if (runp->showdots)
1480         printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1481     if (runp->postmaster)
1482         printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1483                runp->postmaster);
1484
1485     if (!runp->bouncemail)
1486         printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1487     else if (outlevel >= O_VERBOSE)
1488         printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1489
1490     for (ctl = querylist; ctl; ctl = ctl->next)
1491     {
1492         if (!ctl->active || (implicit && ctl->server.skip))
1493             continue;
1494
1495         printf(GT_("Options for retrieving from %s@%s:\n"),
1496                ctl->remotename, visbuf(ctl->server.pollname));
1497
1498         if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1499             printf(GT_("  Mail will be retrieved via %s\n"), ctl->server.via);
1500
1501         if (ctl->server.interval)
1502             printf(ngettext("  Poll of this server will occur every %d interval.\n",
1503                             "  Poll of this server will occur every %d intervals.\n",
1504                             ctl->server.interval), ctl->server.interval);
1505         if (ctl->server.truename)
1506             printf(GT_("  True name of server is %s.\n"), ctl->server.truename);
1507         if (ctl->server.skip || outlevel >= O_VERBOSE)
1508             printf(ctl->server.skip
1509                    ? GT_("  This host will not be queried when no host is specified.\n")
1510                    : GT_("  This host will be queried when no host is specified.\n"));
1511         if (!NO_PASSWORD(ctl))
1512         {
1513             if (!ctl->password)
1514                 printf(GT_("  Password will be prompted for.\n"));
1515             else if (outlevel >= O_VERBOSE)
1516             {
1517                 if (ctl->server.protocol == P_APOP)
1518                     printf(GT_("  APOP secret = \"%s\".\n"),
1519                            visbuf(ctl->password));
1520                 else if (ctl->server.protocol == P_RPOP)
1521                     printf(GT_("  RPOP id = \"%s\".\n"),
1522                            visbuf(ctl->password));
1523                 else
1524                     printf(GT_("  Password = \"%s\".\n"),
1525                                                         visbuf(ctl->password));
1526             }
1527         }
1528
1529         if (ctl->server.protocol == P_POP3
1530             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1531             && (ctl->server.authenticate == A_KERBEROS_V4 ||
1532                 ctl->server.authenticate == A_KERBEROS_V5))
1533             printf(GT_("  Protocol is KPOP with Kerberos %s authentication"),
1534                    ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1535         else
1536             printf(GT_("  Protocol is %s"), showproto(ctl->server.protocol));
1537         if (ctl->server.service)
1538             printf(GT_(" (using service %s)"), ctl->server.service);
1539         else if (outlevel >= O_VERBOSE)
1540             printf(GT_(" (using default port)"));
1541         if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1542             printf(GT_(" (forcing UIDL use)"));
1543         putchar('.');
1544         putchar('\n');
1545         switch (ctl->server.authenticate)
1546         {
1547         case A_ANY:
1548             printf(GT_("  All available authentication methods will be tried.\n"));
1549             break;
1550         case A_PASSWORD:
1551             printf(GT_("  Password authentication will be forced.\n"));
1552             break;
1553         case A_MSN:
1554             printf(GT_("  MSN authentication will be forced.\n"));
1555             break;
1556         case A_NTLM:
1557             printf(GT_("  NTLM authentication will be forced.\n"));
1558             break;
1559         case A_OTP:
1560             printf(GT_("  OTP authentication will be forced.\n"));
1561             break;
1562         case A_CRAM_MD5:
1563             printf(GT_("  CRAM-Md5 authentication will be forced.\n"));
1564             break;
1565         case A_GSSAPI:
1566             printf(GT_("  GSSAPI authentication will be forced.\n"));
1567             break;
1568         case A_KERBEROS_V4:
1569             printf(GT_("  Kerberos V4 authentication will be forced.\n"));
1570             break;
1571         case A_KERBEROS_V5:
1572             printf(GT_("  Kerberos V5 authentication will be forced.\n"));
1573             break;
1574         case A_SSH:
1575             printf(GT_("  End-to-end encryption assumed.\n"));
1576             break;
1577         }
1578         if (ctl->server.principal != (char *) NULL)
1579             printf(GT_("  Mail service principal is: %s\n"), ctl->server.principal);
1580 #ifdef  SSL_ENABLE
1581         if (ctl->use_ssl)
1582             printf(GT_("  SSL encrypted sessions enabled.\n"));
1583         if (ctl->sslproto)
1584             printf(GT_("  SSL protocol: %s.\n"), ctl->sslproto);
1585         if (ctl->sslcertck) {
1586             printf(GT_("  SSL server certificate checking enabled.\n"));
1587             if (ctl->sslcertpath != NULL)
1588                 printf(GT_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1589         }
1590         if (ctl->sslfingerprint != NULL)
1591                 printf(GT_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1592 #endif
1593         if (ctl->server.timeout > 0)
1594             printf(GT_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1595         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
1596             printf(GT_(" (default).\n"));
1597         else
1598             printf(".\n");
1599
1600         if (MAILBOX_PROTOCOL(ctl))
1601         {
1602             if (!ctl->mailboxes->id)
1603                 printf(GT_("  Default mailbox selected.\n"));
1604             else
1605             {
1606                 struct idlist *idp;
1607
1608                 printf(GT_("  Selected mailboxes are:"));
1609                 for (idp = ctl->mailboxes; idp; idp = idp->next)
1610                     printf(" %s", (char *)idp->id);
1611                 printf("\n");
1612             }
1613             printf(ctl->fetchall
1614                    ? GT_("  All messages will be retrieved (--all on).\n")
1615                    : GT_("  Only new messages will be retrieved (--all off).\n"));
1616             printf(ctl->keep
1617                    ? GT_("  Fetched messages will be kept on the server (--keep on).\n")
1618                    : GT_("  Fetched messages will not be kept on the server (--keep off).\n"));
1619             printf(ctl->flush
1620                    ? GT_("  Old messages will be flushed before message retrieval (--flush on).\n")
1621                    : GT_("  Old messages will not be flushed before message retrieval (--flush off).\n"));
1622             printf(ctl->limitflush
1623                    ? GT_("  Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1624                    : GT_("  Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1625             printf(ctl->rewrite
1626                    ? GT_("  Rewrite of server-local addresses is enabled (--norewrite off).\n")
1627                    : GT_("  Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1628             printf(ctl->stripcr
1629                    ? GT_("  Carriage-return stripping is enabled (stripcr on).\n")
1630                    : GT_("  Carriage-return stripping is disabled (stripcr off).\n"));
1631             printf(ctl->forcecr
1632                    ? GT_("  Carriage-return forcing is enabled (forcecr on).\n")
1633                    : GT_("  Carriage-return forcing is disabled (forcecr off).\n"));
1634             printf(ctl->pass8bits
1635                    ? GT_("  Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1636                    : GT_("  Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1637             printf(ctl->mimedecode
1638                    ? GT_("  MIME decoding is enabled (mimedecode on).\n")
1639                    : GT_("  MIME decoding is disabled (mimedecode off).\n"));
1640             printf(ctl->idle
1641                    ? GT_("  Idle after poll is enabled (idle on).\n")
1642                    : GT_("  Idle after poll is disabled (idle off).\n"));
1643             printf(ctl->dropstatus
1644                    ? GT_("  Nonempty Status lines will be discarded (dropstatus on)\n")
1645                    : GT_("  Nonempty Status lines will be kept (dropstatus off)\n"));
1646             printf(ctl->dropdelivered
1647                    ? GT_("  Delivered-To lines will be discarded (dropdelivered on)\n")
1648                    : GT_("  Delivered-To lines will be kept (dropdelivered off)\n"));
1649             if (NUM_NONZERO(ctl->limit))
1650             {
1651                 if (NUM_NONZERO(ctl->limit))
1652                     printf(GT_("  Message size limit is %d octets (--limit %d).\n"),
1653                            ctl->limit, ctl->limit);
1654                 else if (outlevel >= O_VERBOSE)
1655                     printf(GT_("  No message size limit (--limit 0).\n"));
1656                 if (run.poll_interval > 0)
1657                     printf(GT_("  Message size warning interval is %d seconds (--warnings %d).\n"),
1658                            ctl->warnings, ctl->warnings);
1659                 else if (outlevel >= O_VERBOSE)
1660                     printf(GT_("  Size warnings on every poll (--warnings 0).\n"));
1661             }
1662             if (NUM_NONZERO(ctl->fetchlimit))
1663                 printf(GT_("  Received-message limit is %d (--fetchlimit %d).\n"),
1664                        ctl->fetchlimit, ctl->fetchlimit);
1665             else if (outlevel >= O_VERBOSE)
1666                 printf(GT_("  No received-message limit (--fetchlimit 0).\n"));
1667             if (NUM_NONZERO(ctl->fetchsizelimit))
1668                 printf(GT_("  Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1669                        ctl->fetchsizelimit, ctl->fetchsizelimit);
1670             else if (outlevel >= O_VERBOSE)
1671                 printf(GT_("  No fetch message size limit (--fetchsizelimit 0).\n"));
1672             if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1673             {
1674                 if (ctl->fastuidl == 1)
1675                     printf(GT_("  Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1676                 else
1677                     printf(GT_("  Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1678             }
1679             else if (outlevel >= O_VERBOSE)
1680                 printf(GT_("   Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1681             if (NUM_NONZERO(ctl->batchlimit))
1682                 printf(GT_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
1683             else if (outlevel >= O_VERBOSE)
1684                 printf(GT_("  No SMTP message batch limit (--batchlimit 0).\n"));
1685             if (MAILBOX_PROTOCOL(ctl))
1686             {
1687                 if (NUM_NONZERO(ctl->expunge))
1688                     printf(GT_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1689                 else if (outlevel >= O_VERBOSE)
1690                     printf(GT_("  No forced expunges (--expunge 0).\n"));
1691             }
1692         }
1693         else    /* ODMR or ETRN */
1694         {
1695             struct idlist *idp;
1696
1697             printf(GT_("  Domains for which mail will be fetched are:"));
1698             for (idp = ctl->domainlist; idp; idp = idp->next)
1699             {
1700                 printf(" %s", (char *)idp->id);
1701                 if (!idp->val.status.mark)
1702                     printf(GT_(" (default)"));
1703             }
1704             printf("\n");
1705         }
1706         if (ctl->bsmtp)
1707             printf(GT_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1708         else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1709             printf(GT_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1710         else
1711         {
1712             struct idlist *idp;
1713
1714             if (ctl->smtphunt)
1715             {
1716                 printf(GT_("  Messages will be %cMTP-forwarded to:"),
1717                        ctl->listener);
1718                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1719                 {
1720                     printf(" %s", (char *)idp->id);
1721                     if (!idp->val.status.mark)
1722                         printf(GT_(" (default)"));
1723                 }
1724                 printf("\n");
1725             }
1726             if (ctl->smtpaddress)
1727                 printf(GT_("  Host part of MAIL FROM line will be %s\n"),
1728                        ctl->smtpaddress);
1729             if (ctl->smtpname)
1730                 printf(GT_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1731                        ctl->smtpname);
1732         }
1733         if (MAILBOX_PROTOCOL(ctl))
1734         {
1735                 if (ctl->antispam != (struct idlist *)NULL)
1736                 {
1737                     struct idlist *idp;
1738
1739                     printf(GT_("  Recognized listener spam block responses are:"));
1740                     for (idp = ctl->antispam; idp; idp = idp->next)
1741                         printf(" %d", idp->val.status.num);
1742                     printf("\n");
1743                 }
1744                 else if (outlevel >= O_VERBOSE)
1745                     printf(GT_("  Spam-blocking disabled\n"));
1746         }
1747         if (ctl->preconnect)
1748             printf(GT_("  Server connection will be brought up with \"%s\".\n"),
1749                    visbuf(ctl->preconnect));
1750         else if (outlevel >= O_VERBOSE)
1751             printf(GT_("  No pre-connection command.\n"));
1752         if (ctl->postconnect)
1753             printf(GT_("  Server connection will be taken down with \"%s\".\n"),
1754                    visbuf(ctl->postconnect));
1755         else if (outlevel >= O_VERBOSE)
1756             printf(GT_("  No post-connection command.\n"));
1757         if (MAILBOX_PROTOCOL(ctl)) {
1758                 if (!ctl->localnames)
1759                     printf(GT_("  No localnames declared for this host.\n"));
1760                 else
1761                 {
1762                     struct idlist *idp;
1763                     int count = 0;
1764
1765                     for (idp = ctl->localnames; idp; idp = idp->next)
1766                         ++count;
1767
1768                     if (count > 1 || ctl->wildcard)
1769                         printf(GT_("  Multi-drop mode: "));
1770                     else
1771                         printf(GT_("  Single-drop mode: "));
1772
1773                     printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1774                     if (outlevel >= O_VERBOSE)
1775                     {
1776                         for (idp = ctl->localnames; idp; idp = idp->next)
1777                             if (idp->val.id2)
1778                                 printf("\t%s -> %s\n", (char *)idp->id, (char *)idp->val.id2);
1779                             else
1780                                 printf("\t%s\n", (char *)idp->id);
1781                         if (ctl->wildcard)
1782                             fputs("\t*\n", stdout);
1783                     }
1784
1785                     if (count > 1 || ctl->wildcard)
1786                     {
1787                         printf(ctl->server.dns
1788                                ? GT_("  DNS lookup for multidrop addresses is enabled.\n")
1789                                : GT_("  DNS lookup for multidrop addresses is disabled.\n"));
1790                         if (ctl->server.dns)
1791                         {
1792                             if (ctl->server.checkalias)
1793                                 printf(GT_("  Server aliases will be compared with multidrop addresses by IP address.\n"));
1794                             else
1795                                 printf(GT_("  Server aliases will be compared with multidrop addresses by name.\n"));
1796                         }
1797                         if (ctl->server.envelope == STRING_DISABLED)
1798                             printf(GT_("  Envelope-address routing is disabled\n"));
1799                         else
1800                         {
1801                             printf(GT_("  Envelope header is assumed to be: %s\n"),
1802                                    ctl->server.envelope ? ctl->server.envelope : "Received");
1803                             if (ctl->server.envskip || outlevel >= O_VERBOSE)
1804                                 printf(GT_("  Number of envelope headers to be skipped over: %d\n"),
1805                                        ctl->server.envskip);
1806                             if (ctl->server.qvirtual)
1807                                 printf(GT_("  Prefix %s will be removed from user id\n"),
1808                                        ctl->server.qvirtual);
1809                             else if (outlevel >= O_VERBOSE)
1810                                 printf(GT_("  No prefix stripping\n"));
1811                         }
1812
1813                         if (ctl->server.akalist)
1814                         {
1815                             struct idlist *idp;
1816
1817                             printf(GT_("  Predeclared mailserver aliases:"));
1818                             for (idp = ctl->server.akalist; idp; idp = idp->next)
1819                                 printf(" %s", (char *)idp->id);
1820                             putchar('\n');
1821                         }
1822                         if (ctl->server.localdomains)
1823                         {
1824                             struct idlist *idp;
1825
1826                             printf(GT_("  Local domains:"));
1827                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
1828                                 printf(" %s", (char *)idp->id);
1829                             putchar('\n');
1830                         }
1831                     }
1832                 }
1833         }
1834 #ifdef CAN_MONITOR
1835         if (ctl->server.interface)
1836             printf(GT_("  Connection must be through interface %s.\n"), ctl->server.interface);
1837         else if (outlevel >= O_VERBOSE)
1838             printf(GT_("  No interface requirement specified.\n"));
1839         if (ctl->server.monitor)
1840             printf(GT_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
1841         else if (outlevel >= O_VERBOSE)
1842             printf(GT_("  No monitor interface specified.\n"));
1843 #endif
1844
1845         if (ctl->server.plugin)
1846             printf(GT_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1847         else if (outlevel >= O_VERBOSE)
1848             printf(GT_("  No plugin command specified.\n"));
1849         if (ctl->server.plugout)
1850             printf(GT_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1851         else if (outlevel >= O_VERBOSE)
1852             printf(GT_("  No plugout command specified.\n"));
1853
1854         if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1855         {
1856             if (!ctl->oldsaved)
1857                 printf(GT_("  No UIDs saved from this host.\n"));
1858             else
1859             {
1860                 struct idlist *idp;
1861                 int count = 0;
1862
1863                 for (idp = ctl->oldsaved; idp; idp = idp->next)
1864                     ++count;
1865
1866                 printf(GT_("  %d UIDs saved.\n"), count);
1867                 if (outlevel >= O_VERBOSE)
1868                     for (idp = ctl->oldsaved; idp; idp = idp->next)
1869                         printf("\t%s\n", (char *)idp->id);
1870             }
1871         }
1872
1873         if (ctl->server.tracepolls)
1874             printf(GT_("  Poll trace information will be added to the Received header.\n"));
1875         else if (outlevel >= O_VERBOSE)
1876             printf(GT_("  No poll trace information will be added to the Received header.\n.\n"));
1877
1878         if (ctl->properties)
1879             printf(GT_("  Pass-through properties \"%s\".\n"),
1880                    visbuf(ctl->properties));
1881     }
1882 }
1883
1884 /* fetchmail.c ends here */