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

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