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