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