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