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