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

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