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

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