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