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