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