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     FLAG_MERGE(server.badheader);
 948
 949     FLAG_MERGE(wildcard);
 950     FLAG_MERGE(remotename);
 951     FLAG_MERGE(password);
 952     FLAG_MERGE(mda);
 953     FLAG_MERGE(bsmtp);
 954     FLAG_MERGE(listener);
 955     FLAG_MERGE(smtpaddress);
 956     FLAG_MERGE(smtpname);
 957     FLAG_MERGE(preconnect);
 958     FLAG_MERGE(postconnect);
 959
 960     FLAG_MERGE(keep);
 961     FLAG_MERGE(flush);
 962     FLAG_MERGE(limitflush);
 963     FLAG_MERGE(fetchall);
 964     FLAG_MERGE(rewrite);
 965     FLAG_MERGE(forcecr);
 966     FLAG_MERGE(stripcr);
 967     FLAG_MERGE(pass8bits);
 968     FLAG_MERGE(dropstatus);
 969     FLAG_MERGE(dropdelivered);
 970     FLAG_MERGE(mimedecode);
 971     FLAG_MERGE(idle);
 972     FLAG_MERGE(limit);
 973     FLAG_MERGE(warnings);
 974     FLAG_MERGE(fetchlimit);
 975     FLAG_MERGE(fetchsizelimit);
 976     FLAG_MERGE(fastuidl);
 977     FLAG_MERGE(batchlimit);
 978 #ifdef  SSL_ENABLE
 979     FLAG_MERGE(use_ssl);
 980     FLAG_MERGE(sslkey);
 981     FLAG_MERGE(sslcert);
 982     FLAG_MERGE(sslproto);
 983     FLAG_MERGE(sslcertck);
 984     FLAG_MERGE(sslcertpath);
 985     FLAG_MERGE(sslcommonname);
 986     FLAG_MERGE(sslfingerprint);
 987 #endif
 988     FLAG_MERGE(expunge);
 989
 990     FLAG_MERGE(properties);
 991 #undef FLAG_MERGE
 992 }
 993
 994 /** Load configuration files.
 995  * \return - true if no servers found on the command line
 996  *         - false if servers found on the command line */
 997 static int load_params(int argc, char **argv, int optind)
 998 {
 999     int implicitmode, st;
1000     struct passwd *pw;
1001     struct query def_opts, *ctl;
1002     struct stat rcstat;
1003     char *p;
1004
1005     run.bouncemail = TRUE;
1006     run.softbounce = TRUE;      /* treat permanent errors as temporary */
1007     run.spambounce = FALSE;     /* don't bounce back to innocent bystanders */
1008
1009     memset(&def_opts, '\0', sizeof(struct query));
1010     def_opts.smtp_socket = -1;
1011     def_opts.smtpaddress = (char *)0;
1012     def_opts.smtpname = (char *)0;
1013     def_opts.server.protocol = P_AUTO;
1014     def_opts.server.timeout = CLIENT_TIMEOUT;
1015     def_opts.server.esmtp_name = user;
1016     def_opts.server.badheader = BHREJECT;
1017     def_opts.warnings = WARNING_INTERVAL;
1018     def_opts.remotename = user;
1019     def_opts.listener = SMTP_MODE;
1020     def_opts.fetchsizelimit = 100;
1021     def_opts.fastuidl = 4;
1022
1023     /* get the location of rcfile */
1024     rcfiledir[0] = 0;
1025     p = strrchr (rcfile, '/');
1026     if (p && (size_t)(p - rcfile) < sizeof (rcfiledir)) {
1027         *p = 0;                 /* replace '/' by '0' */
1028         strlcpy (rcfiledir, rcfile, sizeof(rcfiledir));
1029         *p = '/';               /* restore '/' */
1030         if (!rcfiledir[0])      /* "/.fetchmailrc" case */
1031             strcpy (rcfiledir, "/");
1032     }
1033
1034     /* note the parse time, so we can pick up on modifications */
1035     parsetime = 0;      /* foil compiler warnings */
1036     if (strcmp(rcfile, "-") == 0 || stat(rcfile, &rcstat) != -1)
1037         parsetime = rcstat.st_mtime;
1038     else if (errno != ENOENT)
1039         report(stderr, GT_("couldn't time-check the run-control file\n"));
1040
1041     /* this builds the host list */
1042     if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
1043         /*
1044          * FIXME: someday, send notification mail here if backgrounded.
1045          * Right now, that can happen if the user changes the rcfile
1046          * while the fetchmail is running in background.  Do similarly
1047          * for the other exit() calls in this function.
1048          */
1049         exit(st);
1050
1051     if ((implicitmode = (optind >= argc)))
1052     {
1053         for (ctl = querylist; ctl; ctl = ctl->next)
1054             ctl->active = !ctl->server.skip;
1055     }
1056     else
1057         for (; optind < argc; optind++)
1058         {
1059             flag        predeclared =  FALSE;
1060
1061             /*
1062              * If hostname corresponds to a host known from the rc file,
1063              * simply declare it active.  Otherwise synthesize a host
1064              * record from command line and defaults
1065              */
1066             for (ctl = querylist; ctl; ctl = ctl->next)
1067                 if (!strcmp(ctl->server.pollname, argv[optind])
1068                         || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
1069                 {
1070                     /* Is this correct? */
1071                     if (predeclared && outlevel >= O_VERBOSE)
1072                         fprintf(stderr,GT_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
1073                     ctl->active = TRUE;
1074                     predeclared = TRUE;
1075                 }
1076
1077             if (!predeclared)
1078             {
1079                 /*
1080                  * Allocate and link record without copying in
1081                  * command-line args; we'll do that with the optmerge
1082                  * call later on.
1083                  */
1084                 ctl = hostalloc((struct query *)NULL);
1085                 ctl->server.via =
1086                     ctl->server.pollname = xstrdup(argv[optind]);
1087                 ctl->active = TRUE;
1088                 ctl->server.lead_server = (struct hostdata *)NULL;
1089             }
1090         }
1091
1092     /*
1093      * If there's a defaults record, merge it and lose it.
1094      */
1095     if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1096     {
1097         for (ctl = querylist->next; ctl; ctl = ctl->next)
1098             optmerge(ctl, querylist, FALSE);
1099         querylist = querylist->next;
1100     }
1101
1102     /* don't allow a defaults record after the first */
1103     for (ctl = querylist; ctl; ctl = ctl->next) {
1104         if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1105             fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1106             exit(PS_SYNTAX);
1107         }
1108     }
1109
1110     /* use localhost if we never fetch the FQDN of this host */
1111     fetchmailhost = "localhost";
1112
1113     /* here's where we override globals */
1114     if (cmd_run.logfile)
1115         run.logfile = cmd_run.logfile;
1116     if (cmd_run.idfile)
1117         run.idfile = cmd_run.idfile;
1118     if (cmd_run.pidfile)
1119         run.pidfile = cmd_run.pidfile;
1120     /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1121     if (cmd_run.poll_interval >= 0)
1122         run.poll_interval = cmd_run.poll_interval;
1123     if (cmd_run.invisible)
1124         run.invisible = cmd_run.invisible;
1125     if (cmd_run.showdots)
1126         run.showdots = cmd_run.showdots;
1127     if (cmd_run.use_syslog)
1128         run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1129     if (cmd_run.postmaster)
1130         run.postmaster = cmd_run.postmaster;
1131     if (cmd_run.bouncemail)
1132         run.bouncemail = cmd_run.bouncemail;
1133     if (cmd_run.softbounce)
1134         run.softbounce = cmd_run.softbounce;
1135
1136     /* check and daemon options are not compatible */
1137     if (check_only && run.poll_interval)
1138         run.poll_interval = 0;
1139
1140     /*
1141      * DNS support is required for some protocols.  We used to
1142      * do this unconditionally, but it made fetchmail excessively
1143      * vulnerable to misconfigured DNS setups.
1144      *
1145      * If we're using ETRN or ODMR, the smtp hunt list is the
1146      * list of systems we're polling on behalf of; these have
1147      * to be fully-qualified domain names.  The default for
1148      * this list should be the FQDN of localhost.
1149      *
1150      * If we're using Kerberos for authentication, we need
1151      * the FQDN in order to generate capability keys.
1152      */
1153     for (ctl = querylist; ctl; ctl = ctl->next)
1154         if (ctl->active &&
1155                 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1156                  || ctl->server.authenticate == A_KERBEROS_V4
1157                  || ctl->server.authenticate == A_KERBEROS_V5))
1158         {
1159             fetchmailhost = host_fqdn(1);
1160             break;
1161         }
1162
1163     if (!ctl) /* list exhausted */
1164         fetchmailhost = host_fqdn(0);
1165
1166     /* this code enables flags to be turned off */
1167 #define DEFAULT(flag, dflt)     if (flag == FLAG_TRUE)\
1168                                         flag = TRUE;\
1169                                 else if (flag == FLAG_FALSE)\
1170                                         flag = FALSE;\
1171                                 else\
1172                                         flag = (dflt)
1173
1174     /* merge in wired defaults, do sanity checks and prepare internal fields */
1175     for (ctl = querylist; ctl; ctl = ctl->next)
1176     {
1177         ctl->wedged = FALSE;
1178
1179         /* merge in defaults */
1180         optmerge(ctl, &def_opts, FALSE);
1181
1182         /* force command-line options */
1183         optmerge(ctl, &cmd_opts, TRUE);
1184
1185         /*
1186          * queryname has to be set up for inactive servers too.
1187          * Otherwise the UIDL code core-dumps on startup.
1188          */
1189         if (ctl->server.via)
1190             ctl->server.queryname = xstrdup(ctl->server.via);
1191         else
1192             ctl->server.queryname = xstrdup(ctl->server.pollname);
1193
1194         /*
1195          * We no longer do DNS lookups at startup.
1196          * This is a kluge.  It enables users to edit their
1197          * configurations when DNS isn't available.
1198          */
1199         ctl->server.truename = xstrdup(ctl->server.queryname);
1200
1201         if (configdump || ctl->active )
1202         {
1203             DEFAULT(ctl->keep, FALSE);
1204             DEFAULT(ctl->fetchall, FALSE);
1205             DEFAULT(ctl->flush, FALSE);
1206             DEFAULT(ctl->limitflush, FALSE);
1207             DEFAULT(ctl->rewrite, TRUE);
1208             DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1209             DEFAULT(ctl->forcecr, FALSE);
1210             DEFAULT(ctl->pass8bits, FALSE);
1211             DEFAULT(ctl->dropstatus, FALSE);
1212             DEFAULT(ctl->dropdelivered, FALSE);
1213             DEFAULT(ctl->mimedecode, FALSE);
1214             DEFAULT(ctl->idle, FALSE);
1215             DEFAULT(ctl->server.dns, TRUE);
1216             DEFAULT(ctl->server.uidl, FALSE);
1217             DEFAULT(ctl->use_ssl, FALSE);
1218             DEFAULT(ctl->sslcertck, FALSE);
1219             DEFAULT(ctl->server.checkalias, FALSE);
1220 #ifndef SSL_ENABLE
1221             /*
1222              * XXX FIXME: do we need this check or can we rely on the .y
1223              * parser handling this?
1224              */
1225             if (ctl->use_ssl)
1226             {
1227                 report(stderr, GT_("SSL support is not compiled in.\n"));
1228                 exit(PS_SYNTAX);
1229             }
1230 #endif /* SSL_ENABLE */
1231 #undef DEFAULT
1232 #ifndef KERBEROS_V4
1233             if (ctl->server.authenticate == A_KERBEROS_V4) {
1234                 report(stderr, GT_("KERBEROS v4 support is configured, but not compiled in.\n"));
1235                 exit(PS_SYNTAX);
1236             }
1237 #endif
1238 #ifndef KERBEROS_V5
1239             if (ctl->server.authenticate == A_KERBEROS_V5) {
1240                 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1241                 exit(PS_SYNTAX);
1242             }
1243 #endif
1244 #ifndef GSSAPI
1245             if (ctl->server.authenticate == A_GSSAPI) {
1246                 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1247                 exit(PS_SYNTAX);
1248             }
1249 #endif
1250
1251             /*
1252              * Make sure we have a nonempty host list to forward to.
1253              */
1254             if (!ctl->smtphunt)
1255                 save_str(&ctl->smtphunt, "localhost", FALSE);
1256
1257             /*
1258              * Make sure we have a nonempty list of domains to fetch from.
1259              */
1260             if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1261                 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1262
1263             /* if `user' doesn't name a real local user, try to run as root */
1264             if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1265                 ctl->uid = 0;
1266             else
1267                 ctl->uid = pw->pw_uid;  /* for local delivery via MDA */
1268             if (!ctl->localnames)       /* for local delivery via SMTP */
1269                 save_str_pair(&ctl->localnames, user, NULL);
1270
1271 #ifndef HAVE_RES_SEARCH
1272             /* can't handle multidrop mailboxes unless we can do DNS lookups */
1273             if (MULTIDROP(ctl) && ctl->server.dns)
1274             {
1275                 ctl->server.dns = FALSE;
1276                 report(stderr, GT_("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1277             }
1278 #endif /* !HAVE_RES_SEARCH */
1279
1280             /*
1281              * can't handle multidrop mailboxes without "envelope"
1282              * option, this causes truckloads full of support complaints
1283              * "all mail forwarded to postmaster"
1284              */
1285             if (MULTIDROP(ctl) && !ctl->server.envelope)
1286             {
1287                 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1288                 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1289             }
1290
1291             /* if no folders were specified, set up the null one as default */
1292             if (!ctl->mailboxes)
1293                 save_str(&ctl->mailboxes, (char *)NULL, 0);
1294
1295             /* maybe user overrode timeout on command line? */
1296             if (ctl->server.timeout == -1)
1297                 ctl->server.timeout = CLIENT_TIMEOUT;
1298
1299             /* sanity checks */
1300             if (ctl->server.service) {
1301                 int port = servport(ctl->server.service);
1302                 if (port < 0)
1303                 {
1304                     (void) fprintf(stderr,
1305                                    GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1306                                    ctl->server.pollname);
1307                     exit(PS_SYNTAX);
1308                 }
1309                 if (ctl->server.protocol == P_RPOP && port >= 1024)
1310                 {
1311                     (void) fprintf(stderr,
1312                                    GT_("fetchmail: %s configuration invalid, RPOP requires a privileged port\n"),
1313                                    ctl->server.pollname);
1314                     exit(PS_SYNTAX);
1315                 }
1316             }
1317             if (ctl->listener == LMTP_MODE)
1318             {
1319                 struct idlist   *idp;
1320
1321                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1322                 {
1323                     char        *cp;
1324
1325                     if (!(cp = strrchr(idp->id, '/'))
1326                         || (0 == strcmp(cp + 1, SMTP_PORT))
1327                         || servport(cp + 1) == SMTP_PORT_NUM)
1328                     {
1329                         (void) fprintf(stderr,
1330                                        GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1331                                        ctl->server.pollname);
1332                         exit(PS_SYNTAX);
1333                     }
1334                 }
1335             }
1336
1337             /*
1338              * "I beg to you, have mercy on the we[a]k minds like myself."
1339              * wrote Pehr Anderson.  Your petition is granted.
1340              */
1341             if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1342             {
1343                 (void) fprintf(stderr,
1344                                GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1345             }
1346         }
1347     }
1348
1349     /*
1350      * If the user didn't set a last-resort user to get misaddressed
1351      * multidrop mail, set an appropriate default here.
1352      */
1353     if (!run.postmaster)
1354     {
1355         if (getuid() != ROOT_UID)               /* ordinary user */
1356             run.postmaster = user;
1357         else                                    /* root */
1358             run.postmaster = "postmaster";
1359     }
1360
1361     return(implicitmode);
1362 }
1363
1364 static RETSIGTYPE terminate_poll(int sig)
1365 /* to be executed at the end of a poll cycle */
1366 {
1367
1368     if (sig != 0)
1369         report(stdout, GT_("terminated with signal %d\n"), sig);
1370
1371 #ifdef POP3_ENABLE
1372     /*
1373      * Update UID information at end of each poll, rather than at end
1374      * of run, because that way we don't lose all UIDL information since
1375      * the beginning of time if fetchmail crashes.
1376      */
1377     if (!check_only)
1378         write_saved_lists(querylist, run.idfile);
1379 #endif /* POP3_ENABLE */
1380 }
1381
1382 static RETSIGTYPE terminate_run(int sig)
1383 /* to be executed on normal or signal-induced termination */
1384 {
1385     struct query        *ctl;
1386
1387     terminate_poll(sig);
1388
1389     /*
1390      * Craig Metz, the RFC1938 one-time-password guy, points out:
1391      * "Remember that most kernels don't zero pages before handing them to the
1392      * next process and many kernels share pages between user and kernel space.
1393      * You'd be very surprised what you can find from a short program to do a
1394      * malloc() and then dump the contents of the pages you got. By zeroing
1395      * the secrets at end of run (earlier if you can), you make sure the next
1396      * guy can't get the password/pass phrase."
1397      *
1398      * Right you are, Craig!
1399      */
1400     for (ctl = querylist; ctl; ctl = ctl->next)
1401         if (ctl->password)
1402           memset(ctl->password, '\0', strlen(ctl->password));
1403
1404 #if !defined(HAVE_ATEXIT)
1405     fm_lock_release();
1406 #endif
1407
1408     if (activecount == 0)
1409         exit(PS_NOMAIL);
1410     else
1411         exit(successes ? PS_SUCCESS : querystatus);
1412 }
1413
1414 /*
1415  * Sequence of protocols to try when autoprobing, most capable to least.
1416  */
1417 static const int autoprobe[] =
1418 {
1419 #ifdef IMAP_ENABLE
1420     P_IMAP,
1421 #endif /* IMAP_ENABLE */
1422 #ifdef POP3_ENABLE
1423     P_POP3,
1424 #endif /* POP3_ENABLE */
1425 #ifdef POP2_ENABLE
1426     P_POP2
1427 #endif /* POP2_ENABLE */
1428 };
1429
1430 static int query_host(struct query *ctl)
1431 /* perform fetch transaction with single host */
1432 {
1433     size_t i;
1434     int st = 0;
1435
1436     /*
1437      * If we're syslogging the progress messages are automatically timestamped.
1438      * Force timestamping if we're going to a logfile.
1439      */
1440     if (outlevel >= O_VERBOSE)
1441     {
1442         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll started\n"),
1443                VERSION,
1444                ctl->server.pollname,
1445                showproto(ctl->server.protocol),
1446                timestamp());
1447     }
1448
1449     switch (ctl->server.protocol) {
1450     case P_AUTO:
1451         for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1452         {
1453             ctl->server.protocol = autoprobe[i];
1454             do {
1455                 st = query_host(ctl);
1456             } while
1457                 (st == PS_REPOLL);
1458             if (st == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP || st == PS_MAXFETCH || st == PS_DNS)
1459                 break;
1460         }
1461         ctl->server.protocol = P_AUTO;
1462         break;
1463     case P_POP2:
1464 #ifdef POP2_ENABLE
1465         st = doPOP2(ctl);
1466 #else
1467         report(stderr, GT_("POP2 support is not configured.\n"));
1468         st = PS_PROTOCOL;
1469 #endif /* POP2_ENABLE */
1470         break;
1471     case P_POP3:
1472     case P_APOP:
1473     case P_RPOP:
1474 #ifdef POP3_ENABLE
1475         do {
1476             st = doPOP3(ctl);
1477         } while (st == PS_REPOLL);
1478 #else
1479         report(stderr, GT_("POP3 support is not configured.\n"));
1480         st = PS_PROTOCOL;
1481 #endif /* POP3_ENABLE */
1482         break;
1483     case P_IMAP:
1484 #ifdef IMAP_ENABLE
1485         do {
1486             st = doIMAP(ctl);
1487         } while (st == PS_REPOLL);
1488 #else
1489         report(stderr, GT_("IMAP support is not configured.\n"));
1490         st = PS_PROTOCOL;
1491 #endif /* IMAP_ENABLE */
1492         break;
1493     case P_ETRN:
1494 #ifndef ETRN_ENABLE
1495         report(stderr, GT_("ETRN support is not configured.\n"));
1496         st = PS_PROTOCOL;
1497 #else
1498         st = doETRN(ctl);
1499         break;
1500 #endif /* ETRN_ENABLE */
1501     case P_ODMR:
1502 #ifndef ODMR_ENABLE
1503         report(stderr, GT_("ODMR support is not configured.\n"));
1504         st = PS_PROTOCOL;
1505 #else
1506         st = doODMR(ctl);
1507 #endif /* ODMR_ENABLE */
1508         break;
1509     default:
1510         report(stderr, GT_("unsupported protocol selected.\n"));
1511         st = PS_PROTOCOL;
1512     }
1513
1514     /*
1515      * If we're syslogging the progress messages are automatically timestamped.
1516      * Force timestamping if we're going to a logfile.
1517      */
1518     if (outlevel >= O_VERBOSE)
1519     {
1520         report(stdout, GT_("%s querying %s (protocol %s) at %s: poll completed\n"),
1521                VERSION,
1522                ctl->server.pollname,
1523                showproto(ctl->server.protocol),
1524                timestamp());
1525     }
1526
1527     return(st);
1528 }
1529
1530 static void dump_params (struct runctl *runp,
1531                          struct query *querylist, flag implicit)
1532 /* display query parameters in English */
1533 {
1534     struct query *ctl;
1535
1536     if (runp->poll_interval)
1537         printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1538     if (runp->logfile)
1539         printf(GT_("Logfile is %s\n"), runp->logfile);
1540     if (strcmp(runp->idfile, IDFILE_NAME))
1541         printf(GT_("Idfile is %s\n"), runp->idfile);
1542 #if defined(HAVE_SYSLOG)
1543     if (runp->use_syslog)
1544         printf(GT_("Progress messages will be logged via syslog\n"));
1545 #endif
1546     if (runp->invisible)
1547         printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1548     if (runp->showdots)
1549         printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1550     if (runp->postmaster)
1551         printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1552                runp->postmaster);
1553
1554     if (!runp->bouncemail)
1555         printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1556     else if (outlevel >= O_VERBOSE)
1557         printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1558
1559     if (!runp->softbounce)
1560         printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1561     else if (outlevel >= O_VERBOSE)
1562         printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1563
1564     for (ctl = querylist; ctl; ctl = ctl->next)
1565     {
1566         if (!ctl->active || (implicit && ctl->server.skip))
1567             continue;
1568
1569         printf(GT_("Options for retrieving from %s@%s:\n"),
1570                ctl->remotename, visbuf(ctl->server.pollname));
1571
1572         if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1573             printf(GT_("  Mail will be retrieved via %s\n"), ctl->server.via);
1574
1575         if (ctl->server.interval)
1576             printf(ngettext("  Poll of this server will occur every %d interval.\n",
1577                             "  Poll of this server will occur every %d intervals.\n",
1578                             ctl->server.interval), ctl->server.interval);
1579         if (ctl->server.truename)
1580             printf(GT_("  True name of server is %s.\n"), ctl->server.truename);
1581         if (ctl->server.skip || outlevel >= O_VERBOSE)
1582             printf(ctl->server.skip
1583                    ? GT_("  This host will not be queried when no host is specified.\n")
1584                    : GT_("  This host will be queried when no host is specified.\n"));
1585         if (!NO_PASSWORD(ctl))
1586         {
1587             if (!ctl->password)
1588                 printf(GT_("  Password will be prompted for.\n"));
1589             else if (outlevel >= O_VERBOSE)
1590             {
1591                 if (ctl->server.protocol == P_APOP)
1592                     printf(GT_("  APOP secret = \"%s\".\n"),
1593                            visbuf(ctl->password));
1594                 else if (ctl->server.protocol == P_RPOP)
1595                     printf(GT_("  RPOP id = \"%s\".\n"),
1596                            visbuf(ctl->password));
1597                 else
1598                     printf(GT_("  Password = \"%s\".\n"),
1599                                                         visbuf(ctl->password));
1600             }
1601         }
1602
1603         if (ctl->server.protocol == P_POP3
1604             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1605             && (ctl->server.authenticate == A_KERBEROS_V4 ||
1606                 ctl->server.authenticate == A_KERBEROS_V5))
1607             printf(GT_("  Protocol is KPOP with Kerberos %s authentication"),
1608                    ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1609         else
1610             printf(GT_("  Protocol is %s"), showproto(ctl->server.protocol));
1611         if (ctl->server.service)
1612             printf(GT_(" (using service %s)"), ctl->server.service);
1613         else if (outlevel >= O_VERBOSE)
1614             printf(GT_(" (using default port)"));
1615         if (ctl->server.uidl && MAILBOX_PROTOCOL(ctl))
1616             printf(GT_(" (forcing UIDL use)"));
1617         putchar('.');
1618         putchar('\n');
1619         switch (ctl->server.authenticate)
1620         {
1621         case A_ANY:
1622             printf(GT_("  All available authentication methods will be tried.\n"));
1623             break;
1624         case A_PASSWORD:
1625             printf(GT_("  Password authentication will be forced.\n"));
1626             break;
1627         case A_MSN:
1628             printf(GT_("  MSN authentication will be forced.\n"));
1629             break;
1630         case A_NTLM:
1631             printf(GT_("  NTLM authentication will be forced.\n"));
1632             break;
1633         case A_OTP:
1634             printf(GT_("  OTP authentication will be forced.\n"));
1635             break;
1636         case A_CRAM_MD5:
1637             printf(GT_("  CRAM-Md5 authentication will be forced.\n"));
1638             break;
1639         case A_GSSAPI:
1640             printf(GT_("  GSSAPI authentication will be forced.\n"));
1641             break;
1642         case A_KERBEROS_V4:
1643             printf(GT_("  Kerberos V4 authentication will be forced.\n"));
1644             break;
1645         case A_KERBEROS_V5:
1646             printf(GT_("  Kerberos V5 authentication will be forced.\n"));
1647             break;
1648         case A_SSH:
1649             printf(GT_("  End-to-end encryption assumed.\n"));
1650             break;
1651         }
1652         if (ctl->server.principal != (char *) NULL)
1653             printf(GT_("  Mail service principal is: %s\n"), ctl->server.principal);
1654 #ifdef  SSL_ENABLE
1655         if (ctl->use_ssl)
1656             printf(GT_("  SSL encrypted sessions enabled.\n"));
1657         if (ctl->sslproto)
1658             printf(GT_("  SSL protocol: %s.\n"), ctl->sslproto);
1659         if (ctl->sslcertck) {
1660             printf(GT_("  SSL server certificate checking enabled.\n"));
1661             if (ctl->sslcertpath != NULL)
1662                 printf(GT_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
1663         }
1664         if (ctl->sslcommonname != NULL)
1665                 printf(GT_("  SSL server CommonName: %s\n"), ctl->sslcommonname);
1666         if (ctl->sslfingerprint != NULL)
1667                 printf(GT_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
1668 #endif
1669         if (ctl->server.timeout > 0)
1670             printf(GT_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1671         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
1672             printf(GT_(" (default).\n"));
1673         else
1674             printf(".\n");
1675
1676         if (MAILBOX_PROTOCOL(ctl))
1677         {
1678             if (!ctl->mailboxes->id)
1679                 printf(GT_("  Default mailbox selected.\n"));
1680             else
1681             {
1682                 struct idlist *idp;
1683
1684                 printf(GT_("  Selected mailboxes are:"));
1685                 for (idp = ctl->mailboxes; idp; idp = idp->next)
1686                     printf(" %s", idp->id);
1687                 printf("\n");
1688             }
1689             printf(ctl->fetchall
1690                    ? GT_("  All messages will be retrieved (--all on).\n")
1691                    : GT_("  Only new messages will be retrieved (--all off).\n"));
1692             printf(ctl->keep
1693                    ? GT_("  Fetched messages will be kept on the server (--keep on).\n")
1694                    : GT_("  Fetched messages will not be kept on the server (--keep off).\n"));
1695             printf(ctl->flush
1696                    ? GT_("  Old messages will be flushed before message retrieval (--flush on).\n")
1697                    : GT_("  Old messages will not be flushed before message retrieval (--flush off).\n"));
1698             printf(ctl->limitflush
1699                    ? GT_("  Oversized messages will be flushed before message retrieval (--limitflush on).\n")
1700                    : GT_("  Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
1701             printf(ctl->rewrite
1702                    ? GT_("  Rewrite of server-local addresses is enabled (--norewrite off).\n")
1703                    : GT_("  Rewrite of server-local addresses is disabled (--norewrite on).\n"));
1704             printf(ctl->stripcr
1705                    ? GT_("  Carriage-return stripping is enabled (stripcr on).\n")
1706                    : GT_("  Carriage-return stripping is disabled (stripcr off).\n"));
1707             printf(ctl->forcecr
1708                    ? GT_("  Carriage-return forcing is enabled (forcecr on).\n")
1709                    : GT_("  Carriage-return forcing is disabled (forcecr off).\n"));
1710             printf(ctl->pass8bits
1711                    ? GT_("  Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
1712                    : GT_("  Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
1713             printf(ctl->mimedecode
1714                    ? GT_("  MIME decoding is enabled (mimedecode on).\n")
1715                    : GT_("  MIME decoding is disabled (mimedecode off).\n"));
1716             printf(ctl->idle
1717                    ? GT_("  Idle after poll is enabled (idle on).\n")
1718                    : GT_("  Idle after poll is disabled (idle off).\n"));
1719             printf(ctl->dropstatus
1720                    ? GT_("  Nonempty Status lines will be discarded (dropstatus on)\n")
1721                    : GT_("  Nonempty Status lines will be kept (dropstatus off)\n"));
1722             printf(ctl->dropdelivered
1723                    ? GT_("  Delivered-To lines will be discarded (dropdelivered on)\n")
1724                    : GT_("  Delivered-To lines will be kept (dropdelivered off)\n"));
1725             if (NUM_NONZERO(ctl->limit))
1726             {
1727                 if (NUM_NONZERO(ctl->limit))
1728                     printf(GT_("  Message size limit is %d octets (--limit %d).\n"),
1729                            ctl->limit, ctl->limit);
1730                 else if (outlevel >= O_VERBOSE)
1731                     printf(GT_("  No message size limit (--limit 0).\n"));
1732                 if (run.poll_interval > 0)
1733                     printf(GT_("  Message size warning interval is %d seconds (--warnings %d).\n"),
1734                            ctl->warnings, ctl->warnings);
1735                 else if (outlevel >= O_VERBOSE)
1736                     printf(GT_("  Size warnings on every poll (--warnings 0).\n"));
1737             }
1738             if (NUM_NONZERO(ctl->fetchlimit))
1739                 printf(GT_("  Received-message limit is %d (--fetchlimit %d).\n"),
1740                        ctl->fetchlimit, ctl->fetchlimit);
1741             else if (outlevel >= O_VERBOSE)
1742                 printf(GT_("  No received-message limit (--fetchlimit 0).\n"));
1743             if (NUM_NONZERO(ctl->fetchsizelimit))
1744                 printf(GT_("  Fetch message size limit is %d (--fetchsizelimit %d).\n"),
1745                        ctl->fetchsizelimit, ctl->fetchsizelimit);
1746             else if (outlevel >= O_VERBOSE)
1747                 printf(GT_("  No fetch message size limit (--fetchsizelimit 0).\n"));
1748             if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
1749             {
1750                 if (ctl->fastuidl == 1)
1751                     printf(GT_("  Do binary search of UIDs during each poll (--fastuidl 1).\n"));
1752                 else
1753                     printf(GT_("  Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
1754             }
1755             else if (outlevel >= O_VERBOSE)
1756                 printf(GT_("   Do linear search of UIDs during each poll (--fastuidl 0).\n"));
1757             if (NUM_NONZERO(ctl->batchlimit))
1758                 printf(GT_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
1759             else if (outlevel >= O_VERBOSE)
1760                 printf(GT_("  No SMTP message batch limit (--batchlimit 0).\n"));
1761             if (MAILBOX_PROTOCOL(ctl))
1762             {
1763                 if (NUM_NONZERO(ctl->expunge))
1764                     printf(GT_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1765                 else if (outlevel >= O_VERBOSE)
1766                     printf(GT_("  No forced expunges (--expunge 0).\n"));
1767             }
1768         }
1769         else    /* ODMR or ETRN */
1770         {
1771             struct idlist *idp;
1772
1773             printf(GT_("  Domains for which mail will be fetched are:"));
1774             for (idp = ctl->domainlist; idp; idp = idp->next)
1775             {
1776                 printf(" %s", idp->id);
1777                 if (!idp->val.status.mark)
1778                     printf(GT_(" (default)"));
1779             }
1780             printf("\n");
1781         }
1782         if (ctl->bsmtp)
1783             printf(GT_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1784         else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
1785             printf(GT_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1786         else
1787         {
1788             struct idlist *idp;
1789
1790             if (ctl->smtphunt)
1791             {
1792                 printf(GT_("  Messages will be %cMTP-forwarded to:"),
1793                        ctl->listener);
1794                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1795                 {
1796                     printf(" %s", idp->id);
1797                     if (!idp->val.status.mark)
1798                         printf(GT_(" (default)"));
1799                 }
1800                 printf("\n");
1801             }
1802             if (ctl->smtpaddress)
1803                 printf(GT_("  Host part of MAIL FROM line will be %s\n"),
1804                        ctl->smtpaddress);
1805             if (ctl->smtpname)
1806                 printf(GT_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
1807                        ctl->smtpname);
1808         }
1809         if (MAILBOX_PROTOCOL(ctl))
1810         {
1811                 if (ctl->antispam != (struct idlist *)NULL)
1812                 {
1813                     struct idlist *idp;
1814
1815                     printf(GT_("  Recognized listener spam block responses are:"));
1816                     for (idp = ctl->antispam; idp; idp = idp->next)
1817                         printf(" %d", idp->val.status.num);
1818                     printf("\n");
1819                 }
1820                 else if (outlevel >= O_VERBOSE)
1821                     printf(GT_("  Spam-blocking disabled\n"));
1822         }
1823         if (ctl->preconnect)
1824             printf(GT_("  Server connection will be brought up with \"%s\".\n"),
1825                    visbuf(ctl->preconnect));
1826         else if (outlevel >= O_VERBOSE)
1827             printf(GT_("  No pre-connection command.\n"));
1828         if (ctl->postconnect)
1829             printf(GT_("  Server connection will be taken down with \"%s\".\n"),
1830                    visbuf(ctl->postconnect));
1831         else if (outlevel >= O_VERBOSE)
1832             printf(GT_("  No post-connection command.\n"));
1833         if (MAILBOX_PROTOCOL(ctl)) {
1834                 if (!ctl->localnames)
1835                     printf(GT_("  No localnames declared for this host.\n"));
1836                 else
1837                 {
1838                     struct idlist *idp;
1839                     int count = 0;
1840
1841                     for (idp = ctl->localnames; idp; idp = idp->next)
1842                         ++count;
1843
1844                     if (count > 1 || ctl->wildcard)
1845                         printf(GT_("  Multi-drop mode: "));
1846                     else
1847                         printf(GT_("  Single-drop mode: "));
1848
1849                     printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
1850                     if (outlevel >= O_VERBOSE)
1851                     {
1852                         for (idp = ctl->localnames; idp; idp = idp->next)
1853                             if (idp->val.id2)
1854                                 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1855                             else
1856                                 printf("\t%s\n", idp->id);
1857                         if (ctl->wildcard)
1858                             fputs("\t*\n", stdout);
1859                     }
1860
1861                     if (count > 1 || ctl->wildcard)
1862                     {
1863                         printf(ctl->server.dns
1864                                ? GT_("  DNS lookup for multidrop addresses is enabled.\n")
1865                                : GT_("  DNS lookup for multidrop addresses is disabled.\n"));
1866                         if (ctl->server.dns)
1867                         {
1868                             if (ctl->server.checkalias)
1869                                 printf(GT_("  Server aliases will be compared with multidrop addresses by IP address.\n"));
1870                             else
1871                                 printf(GT_("  Server aliases will be compared with multidrop addresses by name.\n"));
1872                         }
1873                         if (ctl->server.envelope == STRING_DISABLED)
1874                             printf(GT_("  Envelope-address routing is disabled\n"));
1875                         else
1876                         {
1877                             printf(GT_("  Envelope header is assumed to be: %s\n"),
1878                                    ctl->server.envelope ? ctl->server.envelope : "Received");
1879                             if (ctl->server.envskip || outlevel >= O_VERBOSE)
1880                                 printf(GT_("  Number of envelope headers to be skipped over: %d\n"),
1881                                        ctl->server.envskip);
1882                             if (ctl->server.qvirtual)
1883                                 printf(GT_("  Prefix %s will be removed from user id\n"),
1884                                        ctl->server.qvirtual);
1885                             else if (outlevel >= O_VERBOSE)
1886                                 printf(GT_("  No prefix stripping\n"));
1887                         }
1888
1889                         if (ctl->server.akalist)
1890                         {
1891                             struct idlist *idp;
1892
1893                             printf(GT_("  Predeclared mailserver aliases:"));
1894                             for (idp = ctl->server.akalist; idp; idp = idp->next)
1895                                 printf(" %s", idp->id);
1896                             putchar('\n');
1897                         }
1898                         if (ctl->server.localdomains)
1899                         {
1900                             struct idlist *idp;
1901
1902                             printf(GT_("  Local domains:"));
1903                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
1904                                 printf(" %s", idp->id);
1905                             putchar('\n');
1906                         }
1907                     }
1908                 }
1909         }
1910 #ifdef CAN_MONITOR
1911         if (ctl->server.interface)
1912             printf(GT_("  Connection must be through interface %s.\n"), ctl->server.interface);
1913         else if (outlevel >= O_VERBOSE)
1914             printf(GT_("  No interface requirement specified.\n"));
1915         if (ctl->server.monitor)
1916             printf(GT_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
1917         else if (outlevel >= O_VERBOSE)
1918             printf(GT_("  No monitor interface specified.\n"));
1919 #endif
1920
1921         if (ctl->server.plugin)
1922             printf(GT_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1923         else if (outlevel >= O_VERBOSE)
1924             printf(GT_("  No plugin command specified.\n"));
1925         if (ctl->server.plugout)
1926             printf(GT_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1927         else if (outlevel >= O_VERBOSE)
1928             printf(GT_("  No plugout command specified.\n"));
1929
1930         if (ctl->server.protocol > P_POP2 && MAILBOX_PROTOCOL(ctl))
1931         {
1932             if (!ctl->oldsaved)
1933                 printf(GT_("  No UIDs saved from this host.\n"));
1934             else
1935             {
1936                 struct idlist *idp;
1937                 int count = 0;
1938
1939                 for (idp = ctl->oldsaved; idp; idp = idp->next)
1940                     ++count;
1941
1942                 printf(GT_("  %d UIDs saved.\n"), count);
1943                 if (outlevel >= O_VERBOSE)
1944                     for (idp = ctl->oldsaved; idp; idp = idp->next)
1945                         printf("\t%s\n", idp->id);
1946             }
1947         }
1948
1949         if (ctl->server.tracepolls)
1950             printf(GT_("  Poll trace information will be added to the Received header.\n"));
1951         else if (outlevel >= O_VERBOSE)
1952             printf(GT_("  No poll trace information will be added to the Received header.\n"));
1953
1954         switch (ctl->server.badheader) {
1955             case BHREJECT:
1956                 if (outlevel >= O_VERBOSE)
1957                     printf(GT_("  Messages with bad headers will be rejected.\n"));
1958                 break;
1959             case BHPASS:
1960                 printf(GT_("  Messages with bad headers will be passed on.\n"));
1961                 break;
1962         }
1963
1964         if (ctl->properties)
1965             printf(GT_("  Pass-through properties \"%s\".\n"),
1966                    visbuf(ctl->properties));
1967     }
1968 }
1969
1970 /* fetchmail.c ends here */