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

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