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