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