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

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