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