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