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