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