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