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

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