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 Sunil Shetye\n"
 137                    "Copyright (C) 2005 - 2013 Matthias Andree\n"
 138                    ));
 139         fprintf(fp, GT_("Fetchmail comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
 140                    "are welcome to redistribute it under certain conditions. For details,\n"
 141                    "please see the file COPYING in the source or documentation directory.\n"));
 142 #ifdef SSL_ENABLE
 143         /* Do not translate this */
 144         fprintf(fp, "This product includes software developed by the OpenSSL Project\nfor use in the OpenSSL Toolkit. (http://www.openssl.org/)\n");
 145 #endif
 146 }
 147
 148 const char *iana_charset;
 149
 150 #ifdef HAVE_LIBPWMD
 151 static void exit_with_pwmd_error(gpg_error_t error)
 152 {
 153     gpg_err_code_t code = gpg_err_code(error);
 154
 155     report(stderr, GT_("pwmd: error %i: %s\n"), code, pwmd_strerror(error));
 156
 157     if (pwm) {
 158         pwmd_close(pwm);
 159         pwm = NULL;
 160     }
 161
 162     /* Don't exit if daemonized. There may be other active accounts. */
 163     if (isatty(1))
 164         exit(PS_UNDEFINED);
 165 }
 166
 167 static int do_pwmd_connect(const char *socketname, const char *filename)
 168 {
 169     static int init;
 170     gpg_error_t rc;
 171     pwmd_socket_t s;
 172
 173     if (!init) {
 174         pwmd_init();
 175         init = 1;
 176     }
 177
 178     if (!pwm || (pwm && socketname && !pwmd_socket) ||
 179             (pwm && !socketname && pwmd_socket) ||
 180             (pwm && socketname && pwmd_socket && strcmp(socketname, pwmd_socket))) {
 181         if (pwm)
 182             pwmd_close(pwm);
 183
 184         pwm = pwmd_new("Fetchmail");
 185         rc = pwmd_connect_url(pwm, socketname);
 186
 187         if (rc) {
 188             exit_with_pwmd_error(rc);
 189             return 1;
 190         }
 191     }
 192
 193     if (run.pinentry_timeout > 0) {
 194         rc = pwmd_setopt(pwm, PWMD_OPTION_PINENTRY_TIMEOUT,
 195                 run.pinentry_timeout);
 196
 197         if (rc) {
 198             exit_with_pwmd_error(rc);
 199             return 1;
 200         }
 201     }
 202
 203     rc = pwmd_socket_type(pwm, &s);
 204
 205     if (rc) {
 206         exit_with_pwmd_error(rc);
 207         return 1;
 208     }
 209
 210     if (!pwmd_file || strcmp(filename, pwmd_file)) {
 211         if (s == PWMD_SOCKET_SSH)
 212             /* use a local pinentry since X11 forwarding is broken. */
 213             rc = pwmd_open2(pwm, filename);
 214         else
 215             rc = pwmd_open(pwm, filename);
 216
 217         if (rc) {
 218             exit_with_pwmd_error(rc);
 219             return 1;
 220         }
 221     }
 222
 223     /* May be null to use the default of ~/.pwmd/socket. */
 224     pwmd_socket = socketname;
 225     pwmd_file = filename;
 226     return 0;
 227 }
 228
 229 static int get_pwmd_details(const char *pwmd_account, int protocol,
 230         struct query *ctl)
 231 {
 232     const char *prot = showproto(protocol);
 233     gpg_error_t error;
 234     char *result;
 235     char *tmp = xstrdup(pwmd_account);
 236     int i;
 237
 238     for (i = 0; tmp[i]; i++) {
 239         if (i && tmp[i] == '^')
 240             tmp[i] = '\t';
 241     }
 242
 243     /*
 244      * Get the hostname for this protocol. Element path must be
 245      * account->[protocol]->hostname.
 246      */
 247     error = pwmd_command(pwm, &result, "GET %s\t%s\thostname", tmp, prot);
 248
 249     if (error) {
 250         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
 251             report(stderr, GT_("pwmd: %s->%s->hostname: %s\n"), pwmd_account, prot, pwmd_strerror(error));
 252             pwmd_close(pwm);
 253             pwm = NULL;
 254
 255             if (isatty(1))
 256                 exit(PS_SYNTAX);
 257
 258             return 1;
 259         }
 260         else {
 261             exit_with_pwmd_error(error);
 262             return 1;
 263         }
 264     }
 265
 266     if (ctl->server.pollname != ctl->server.via)
 267         xfree(ctl->server.via);
 268
 269     ctl->server.via = xstrdup(result);
 270
 271     if (ctl->server.queryname)
 272         xfree(ctl->server.queryname);
 273
 274     ctl->server.queryname = xstrdup(ctl->server.via);
 275
 276     if (ctl->server.truename)
 277         xfree(ctl->server.truename);
 278
 279     ctl->server.truename = xstrdup(ctl->server.queryname);
 280     pwmd_free(result);
 281
 282     /*
 283      * Server port. Fetchmail tries standard ports for known services so it
 284      * should be alright if this element isn't found. ctl->server.protocol is
 285      * already set. This sets ctl->server.service.
 286      */
 287     error = pwmd_command(pwm, &result, "GET %s\t%s\tport", tmp, prot);
 288
 289     if (error) {
 290         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND)
 291             report(stderr, GT_("pwmd: %s->%s->port: %s\n"), pwmd_account, prot, pwmd_strerror(error));
 292         else {
 293             exit_with_pwmd_error(error);
 294             return 1;
 295         }
 296     }
 297     else {
 298         if (ctl->server.service)
 299             xfree(ctl->server.service);
 300
 301         ctl->server.service = xstrdup(result);
 302         pwmd_free(result);
 303     }
 304
 305     /*
 306      * Get the remote username. Element must be account->username.
 307      */
 308     error = pwmd_command(pwm, &result, "GET %s\tusername", tmp);
 309
 310     if (error) {
 311         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
 312             report(stderr, GT_("pwmd: %s->username: %s\n"), pwmd_account, pwmd_strerror(error));
 313
 314             if (!isatty(1)) {
 315                 pwmd_close(pwm);
 316                 pwm = NULL;
 317                 return 1;
 318             }
 319         }
 320         else {
 321             exit_with_pwmd_error(error);
 322             return 1;
 323         }
 324     }
 325     else {
 326         if (ctl->remotename)
 327             xfree(ctl->remotename);
 328
 329         if (ctl->server.esmtp_name)
 330             xfree(ctl->server.esmtp_name);
 331
 332         ctl->remotename = xstrdup(result);
 333         ctl->server.esmtp_name = xstrdup(result);
 334         pwmd_free(result);
 335     }
 336
 337     /*
 338      * Get the remote password. Element must be account->password.
 339      */
 340     error = pwmd_command(pwm, &result, "GET %s\tpassword", tmp);
 341
 342     if (error) {
 343         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
 344             report(stderr, GT_("pwmd: %s->password: %s\n"), pwmd_account, pwmd_strerror(error));
 345
 346             if (!isatty(1)) {
 347                 pwmd_close(pwm);
 348                 pwm = NULL;
 349                 return 1;
 350             }
 351         }
 352         else {
 353             exit_with_pwmd_error(error);
 354             return 1;
 355         }
 356     }
 357     else {
 358         if (ctl->password)
 359             xfree(ctl->password);
 360
 361         ctl->password= xstrdup(result);
 362         pwmd_free(result);
 363     }
 364
 365 #ifdef SSL_ENABLE
 366     /*
 367      * If there is a ssl element and set to 1, enable ssl for this account.
 368      * Element path must be account->[protocol]->ssl.
 369      */
 370     error = pwmd_command(pwm, &result, "GET %s\t%s\tssl", tmp, prot);
 371
 372     if (error) {
 373         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
 374             report(stderr, GT_("pwmd: %s->%s->ssl: %s\n"), pwmd_account, prot, pwmd_strerror(error));
 375
 376             if (!isatty(1)) {
 377                 pwmd_close(pwm);
 378                 pwm = NULL;
 379                 return 1;
 380             }
 381         }
 382         else {
 383             exit_with_pwmd_error(error);
 384             return 1;
 385         }
 386     }
 387     else {
 388         ctl->use_ssl = atoi(result) >= 1 ? FLAG_TRUE : FLAG_FALSE;
 389         pwmd_free(result);
 390     }
 391
 392     /*
 393      * account->[protocol]->sslfingerprint.
 394      */
 395     error = pwmd_command(pwm, &result, "GET %s\t%s\tsslfingerprint", tmp, prot);
 396
 397     if (error) {
 398         if (gpg_err_code(error) == GPG_ERR_NOT_FOUND) {
 399             report(stderr, GT_("pwmd: %s->%s->sslfingerprint: %s\n"), pwmd_account, prot, pwmd_strerror(error));
 400
 401             if (!isatty(1)) {
 402                 pwmd_close(pwm);
 403                 pwm = NULL;
 404                 return 1;
 405             }
 406         }
 407         else {
 408             exit_with_pwmd_error(error);
 409             return 1;
 410         }
 411     }
 412     else {
 413         if (ctl->sslfingerprint)
 414             xfree(ctl->sslfingerprint);
 415
 416         ctl->sslfingerprint = xstrdup(result);
 417         pwmd_free(result);
 418     }
 419 #endif
 420
 421     xfree(tmp);
 422     return 0;
 423 }
 424 #endif
 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     outlevel = O_NORMAL;
 475
 476     /*
 477      * We used to arrange for the lock to be removed on exit close
 478      * to where the lock was asserted.  Now we need to do it here, because
 479      * we might have re-executed in background with an existing lock
 480      * as the result of a changed rcfile (see the code near the execvp(3)
 481      * call near the beginning of the polling loop for details).  We want
 482      * to be sure the lock gets nuked on any error exit, basically.
 483      */
 484     fm_lock_dispose();
 485
 486 #ifdef HAVE_GETCWD
 487     /* save the current directory */
 488     if (getcwd (currentwd, sizeof (currentwd)) == NULL) {
 489         report(stderr, GT_("could not get current working directory\n"));
 490         currentwd[0] = 0;
 491     }
 492 #endif
 493
 494     {
 495         int i;
 496
 497         i = parsecmdline(argc, argv, &cmd_run, &cmd_opts, &safewithbg);
 498         if (i < 0)
 499             exit(PS_SYNTAX);
 500
 501         if (quitmode && quitind == argc)
 502             quitonly = 1;
 503     }
 504
 505     if (versioninfo)
 506     {
 507         const char *features =
 508 #ifndef POP3_ENABLE
 509         "-POP3"
 510 #endif /* POP3_ENABLE */
 511 #ifndef IMAP_ENABLE
 512         "-IMAP"
 513 #endif /* IMAP_ENABLE */
 514 #ifdef GSSAPI
 515         "+GSS"
 516 #endif /* GSSAPI */
 517 #ifdef RPA_ENABLE
 518         "+RPA"
 519 #endif /* RPA_ENABLE */
 520 #ifdef NTLM_ENABLE
 521         "+NTLM"
 522 #endif /* NTLM_ENABLE */
 523 #ifdef SDPS_ENABLE
 524         "+SDPS"
 525 #endif /* SDPS_ENABLE */
 526 #ifndef ETRN_ENABLE
 527         "-ETRN"
 528 #endif /* ETRN_ENABLE */
 529 #ifndef ODMR_ENABLE
 530         "-ODMR"
 531 #endif /* ODMR_ENABLE */
 532 #ifdef SSL_ENABLE
 533         "+SSL"
 534 #endif
 535 #ifdef OPIE_ENABLE
 536         "+OPIE"
 537 #endif /* OPIE_ENABLE */
 538 #ifdef HAVE_PKG_hesiod
 539         "+HESIOD"
 540 #endif
 541 #ifdef HAVE_SOCKS
 542         "+SOCKS"
 543 #endif /* HAVE_SOCKS */
 544 #ifdef ENABLE_NLS
 545         "+NLS"
 546 #endif /* ENABLE_NLS */
 547 #ifdef KERBEROS_V5
 548         "+KRB5"
 549 #endif /* KERBEROS_V5 */
 550 #ifdef HAVE_LIBPWMD
 551         "+PWMD"
 552 #endif /* HAVE_LIBPWMD */
 553         ".\n";
 554         printf(GT_("This is fetchmail release %s"), VERSION);
 555         fputs(features, stdout);
 556         puts("");
 557         printcopyright(stdout);
 558         puts("");
 559         fputs("Fallback MDA: ", stdout);
 560 #ifdef FALLBACK_MDA
 561         fputs(FALLBACK_MDA, stdout);
 562 #else
 563         fputs("(none)", stdout);
 564 #endif
 565         putchar('\n');
 566         fflush(stdout);
 567
 568         /* this is an attempt to help remote debugging */
 569         if (system("uname -a")) { /* NOOP to quench GCC complaint */ }
 570     }
 571
 572     /* avoid parsing the config file if all we're doing is killing a daemon */
 573     if (!quitonly)
 574         implicitmode = load_params(argc, argv, optind);
 575
 576     if (run.logfile) {
 577         /* nodetach -> turn off logfile option */
 578         if (nodetach) {
 579             if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("The nodetach option is in effect, ignoring logfile option.\n")); }
 580             xfree(run.logfile);
 581         }
 582
 583 #if 0
 584         /* not in daemon mode -> turn off logfile option */
 585         if (0 == run.poll_interval) {
 586             if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Not running in daemon mode, ignoring logfile option.\n")); }
 587             xfree(run.logfile);
 588         }
 589 #endif
 590
 591         /* log file not writable -> turn off logfile option */
 592         if (run.logfile && 0 != access(run.logfile, F_OK)) {
 593             if (outlevel >= O_NORMAL) { fprintf(stderr, GT_("Logfile \"%s\" does not exist, ignoring logfile option.\n"), run.logfile); }
 594             xfree(run.logfile);
 595         }
 596
 597         /* log file not writable -> turn off logfile option */
 598         if (run.logfile && 0 != access(run.logfile, W_OK)) {
 599             fprintf(stderr, GT_("Logfile \"%s\" is not writable, aborting.\n"), run.logfile);
 600             xfree(run.logfile);
 601             exit(PS_UNDEFINED);
 602         }
 603     }
 604
 605     /* logging should be set up early in case we were restarted from exec */
 606     if (run.use_syslog)
 607     {
 608         openlog(program_name, LOG_PID, LOG_MAIL);
 609         /* precedence: logfile (if effective) overrides syslog. */
 610         if (run.logfile) {
 611             syslog(LOG_ERR, GT_("syslog and logfile options are both set, ignoring syslog, and logging to %s"), run.logfile);
 612             run.use_syslog = 0;
 613             report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy below, too */
 614         } else {
 615             report_init(-1);
 616         }
 617     }
 618     else
 619         report_init((run.poll_interval == 0 || nodetach) && !run.logfile); /* when changing this, change copy above, too */
 620
 621 #ifdef POP3_ENABLE
 622     /* initialize UID handling */
 623     {
 624         int st;
 625
 626         if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
 627             exit(st);
 628         else
 629             initialize_saved_lists(querylist, run.idfile);
 630     }
 631 #endif /* POP3_ENABLE */
 632
 633     /* construct the lockfile */
 634     fm_lock_setup(&run);
 635
 636     /*
 637      * Before getting passwords, disable core dumps unless -v -d0 mode is on.
 638      * Core dumps could otherwise contain passwords to be scavenged by a
 639      * cracker.
 640      */
 641     if (outlevel < O_VERBOSE || run.poll_interval > 0)
 642     {
 643         struct rlimit corelimit;
 644         corelimit.rlim_cur = 0;
 645         corelimit.rlim_max = 0;
 646         setrlimit(RLIMIT_CORE, &corelimit);
 647     }
 648
 649 #define NETRC_FILE      ".netrc"
 650     /* parse the ~/.netrc file (if present) for future password lookups. */
 651     netrc_file = prependdir (NETRC_FILE, home);
 652     netrc_list = parse_netrc(netrc_file);
 653     free(netrc_file);
 654 #undef NETRC_FILE
 655
 656     /* pick up passwords where we can */
 657     for (ctl = querylist; ctl; ctl = ctl->next)
 658     {
 659         if (ctl->active && !(implicitmode && ctl->server.skip)&&!ctl->password)
 660         {
 661             if (NO_PASSWORD(ctl))
 662                 /* Server won't care what the password is, but there
 663                    must be some non-null string here.  */
 664                 ctl->password = ctl->remotename;
 665             else
 666             {
 667                 netrc_entry *p;
 668
 669                 /* look up the pollname and account in the .netrc file. */
 670                 p = search_netrc(netrc_list,
 671                                  ctl->server.pollname, ctl->remotename);
 672                 /* if we find a matching entry with a password, use it */
 673                 if (p && p->password)
 674                     ctl->password = xstrdup(p->password);
 675
 676                 /* otherwise try with "via" name if there is one */
 677                 else if (ctl->server.via)
 678                 {
 679                     p = search_netrc(netrc_list,
 680                                      ctl->server.via, ctl->remotename);
 681                     if (p && p->password)
 682                         ctl->password = xstrdup(p->password);
 683                 }
 684             }
 685         }
 686     }
 687
 688     free_netrc(netrc_list);
 689     netrc_list = 0;
 690
 691     /* perhaps we just want to check options? */
 692     if (versioninfo)
 693     {
 694         int havercfile = access(rcfile, 0);
 695
 696         printf(GT_("Taking options from command line%s%s\n"),
 697                                 havercfile ? "" :  GT_(" and "),
 698                                 havercfile ? "" : rcfile);
 699
 700         if (querylist == NULL)
 701             fprintf(stderr,
 702                     GT_("No mailservers set up -- perhaps %s is missing?\n"),
 703                     rcfile);
 704         else
 705             dump_params(&run, querylist, implicitmode);
 706         exit(0);
 707     }
 708
 709     /* dump options as a Python dictionary, for configurator use */
 710     if (configdump)
 711     {
 712         dump_config(&run, querylist);
 713         exit(0);
 714     }
 715
 716     /* check for another fetchmail running concurrently */
 717     pid = fm_lock_state();
 718     bkgd = (pid < 0);
 719     pid = bkgd ? -pid : pid;
 720
 721     /* if no mail servers listed and nothing in background, we're done */
 722     if (!quitonly && pid == 0 && querylist == NULL) {
 723         (void)fputs(GT_("fetchmail: no mailservers have been specified.\n"),stderr);
 724         exit(PS_SYNTAX);
 725     }
 726
 727     /* perhaps user asked us to kill the other fetchmail */
 728     if (quitmode)
 729     {
 730         if (pid == 0 || pid == getpid())
 731             /* this test enables re-execing on a changed rcfile
 732              * for pid == getpid() */
 733         {
 734             if (quitonly) {
 735                 fprintf(stderr,GT_("fetchmail: no other fetchmail is running\n"));
 736                 exit(PS_EXCLUDE);
 737             }
 738         }
 739         else if (kill(pid, SIGTERM) < 0)
 740         {
 741             fprintf(stderr,GT_("fetchmail: error killing %s fetchmail at %ld; bailing out.\n"),
 742                     bkgd ? GT_("background") : GT_("foreground"), (long)pid);
 743             exit(PS_EXCLUDE);
 744         }
 745         else
 746         {
 747             int maxwait;
 748
 749             if (outlevel > O_SILENT)
 750                 fprintf(stderr,GT_("fetchmail: %s fetchmail at %ld killed.\n"),
 751                         bkgd ? GT_("background") : GT_("foreground"), (long)pid);
 752             /* We used to nuke the other process's lock here, with
 753              * fm_lock_release(), which is broken. The other process
 754              * needs to clear its lock by itself. */
 755             if (quitonly)
 756                 exit(0);
 757
 758             /* wait for other process to exit */
 759             maxwait = 10; /* seconds */
 760             while (kill(pid, 0) == 0 && --maxwait >= 0) {
 761                 sleep(1);
 762             }
 763             pid = 0;
 764         }
 765     }
 766
 767     /* another fetchmail is running -- wake it up or die */
 768     if (pid != 0)
 769     {
 770         if (check_only)
 771         {
 772             fprintf(stderr,
 773                  GT_("fetchmail: can't check mail while another fetchmail to same host is running.\n"));
 774             return(PS_EXCLUDE);
 775         }
 776         else if (!implicitmode)
 777         {
 778             fprintf(stderr,
 779                  GT_("fetchmail: can't poll specified hosts with another fetchmail running at %ld.\n"),
 780                  (long)pid);
 781                 return(PS_EXCLUDE);
 782         }
 783         else if (!bkgd)
 784         {
 785             fprintf(stderr,
 786                  GT_("fetchmail: another foreground fetchmail is running at %ld.\n"),
 787                  (long)pid);
 788                 return(PS_EXCLUDE);
 789         }
 790         else if (getpid() == pid)
 791             /* this test enables re-execing on a changed rcfile */
 792             fm_lock_assert();
 793         else if (argc > 1 && !safewithbg)
 794         {
 795             fprintf(stderr,
 796                     GT_("fetchmail: can't accept options while a background fetchmail is running.\n"));
 797             {
 798                 int i;
 799                 fprintf(stderr, "argc = %d, arg list:\n", argc);
 800                 for (i = 1; i < argc; i++) fprintf(stderr, "arg %d = \"%s\"\n", i, argv[i]);
 801             }
 802             return(PS_EXCLUDE);
 803         }
 804         else if (kill(pid, SIGUSR1) == 0)
 805         {
 806             if (outlevel > O_SILENT)
 807                 fprintf(stderr,
 808                         GT_("fetchmail: background fetchmail at %ld awakened.\n"),
 809                         (long)pid);
 810             return(0);
 811         }
 812         else
 813         {
 814             /*
 815              * Should never happen -- possible only if a background fetchmail
 816              * croaks after the first kill probe above but before the
 817              * SIGUSR1/SIGHUP transmission.
 818              */
 819             fprintf(stderr,
 820                     GT_("fetchmail: elder sibling at %ld died mysteriously.\n"),
 821                     (long)pid);
 822             return(PS_UNDEFINED);
 823         }
 824     }
 825
 826     /* pick up interactively any passwords we need but don't have */
 827     for (ctl = querylist; ctl; ctl = ctl->next)
 828     {
 829         if (ctl->active && !(implicitmode && ctl->server.skip)
 830                 && !NO_PASSWORD(ctl) && !ctl->password)
 831         {
 832             if (!isatty(0))
 833             {
 834                 fprintf(stderr,
 835                         GT_("fetchmail: can't find a password for %s@%s.\n"),
 836                         ctl->remotename, ctl->server.pollname);
 837                 return(PS_AUTHFAIL);
 838             } else {
 839                 const char* password_prompt = GT_("Enter password for %s@%s: ");
 840                 size_t pplen = strlen(password_prompt) + strlen(ctl->remotename) + strlen(ctl->server.pollname) + 1;
 841
 842                 tmpbuf = (char *)xmalloc(pplen);
 843                 snprintf(tmpbuf, pplen, password_prompt,
 844                         ctl->remotename, ctl->server.pollname);
 845                 ctl->password = xstrdup((char *)fm_getpassword(tmpbuf));
 846                 free(tmpbuf);
 847             }
 848         }
 849     }
 850
 851     /*
 852      * Time to initiate the SOCKS library (this is not mandatory: it just
 853      * registers the correct application name for logging purpose. If you
 854      * have some problem, comment out these lines).
 855      */
 856 #ifdef HAVE_SOCKS
 857     SOCKSinit("fetchmail");
 858 #endif /* HAVE_SOCKS */
 859
 860     /* avoid zombies from plugins */
 861     deal_with_sigchld();
 862
 863     /* Fix up log destination - if the if() is true, the precedence rule
 864      * above hasn't killed off the syslog option, because the logfile
 865      * option is ineffective (because we're not detached or not in
 866      * deamon mode), so kill it for the benefit of other parts of the
 867      * code. */
 868     if (run.logfile && run.use_syslog)
 869         run.logfile = 0;
 870
 871     /*
 872      * Maybe time to go to demon mode...
 873      */
 874     if (run.poll_interval)
 875     {
 876         if (!nodetach) {
 877             int rc;
 878
 879             rc = daemonize(run.logfile);
 880             if (rc) {
 881                 report(stderr, GT_("fetchmail: Cannot detach into background. Aborting.\n"));
 882                 exit(rc);
 883             }
 884         }
 885         report(stdout, GT_("starting fetchmail %s daemon\n"), VERSION);
 886
 887         /*
 888          * We'll set up a handler for these when we're sleeping,
 889          * but ignore them otherwise so as not to interrupt a poll.
 890          */
 891         set_signal_handler(SIGUSR1, SIG_IGN);
 892         if (run.poll_interval && getuid() == ROOT_UID)
 893             set_signal_handler(SIGHUP, SIG_IGN);
 894     }
 895     else
 896     {
 897         /* not in daemon mode */
 898         if (run.logfile)
 899         {
 900             if (!freopen(run.logfile, "a", stdout))
 901                     report(stderr, GT_("could not open %s to append logs to\n"), run.logfile);
 902             if (!freopen(run.logfile, "a", stderr))
 903                     report(stdout, GT_("could not open %s to append logs to\n"), run.logfile);
 904         }
 905     }
 906
 907     interface_init();
 908
 909     /* beyond here we don't want more than one fetchmail running per user */
 910     umask(0077);
 911     set_signal_handler(SIGABRT, terminate_run);
 912     set_signal_handler(SIGINT, terminate_run);
 913     set_signal_handler(SIGTERM, terminate_run);
 914     set_signal_handler(SIGALRM, terminate_run);
 915     set_signal_handler(SIGPIPE, SIG_IGN);
 916     set_signal_handler(SIGQUIT, terminate_run);
 917
 918     /* here's the exclusion lock */
 919     fm_lock_or_die();
 920
 921     if (check_only && outlevel >= O_VERBOSE) {
 922         report(stdout, GT_("--check mode enabled, not fetching mail\n"));
 923     }
 924
 925     /*
 926      * Query all hosts. If there's only one, the error return will
 927      * reflect the status of that transaction.
 928      */
 929     do {
 930         /*
 931          * Check to see if the rcfile has been touched.  If so,
 932          * re-exec so the file will be reread.  Doing it this way
 933          * avoids all the complications of trying to deallocate the
 934          * in-core control structures -- and the potential memory
 935          * leaks...
 936          */
 937         struct stat     rcstat;
 938 #ifdef HAVE_LIBPWMD
 939         time_t now;
 940
 941         time(&now);
 942 #endif
 943
 944         if (strcmp(rcfile, "-") == 0) {
 945             /* do nothing */
 946         } else if (stat(rcfile, &rcstat) == -1) {
 947             if (errno != ENOENT)
 948                 report(stderr,
 949                        GT_("couldn't time-check %s (error %d)\n"),
 950                        rcfile, errno);
 951         }
 952 #ifdef HAVE_LIBPWMD
 953         /*
 954          * isatty() to make sure this is a background process since the
 955          * lockfile is removed after each invokation.
 956          */
 957         else if (!isatty(1) && rcstat.st_mtime > parsetime)
 958 #else
 959         else if (rcstat.st_mtime > parsetime)
 960 #endif
 961         {
 962             report(stdout, GT_("restarting fetchmail (%s changed)\n"), rcfile);
 963
 964 #ifdef HAVE_GETCWD
 965             /* restore the startup directory */
 966             if (!currentwd[0] || chdir (currentwd) == -1)
 967                 report(stderr, GT_("attempt to re-exec may fail as directory has not been restored\n"));
 968 #endif
 969
 970             /*
 971              * Matthias Andree: Isn't this prone to introduction of
 972              * "false" programs by interfering with PATH? Those
 973              * path-searching execs might not be the best ideas for
 974              * this reason.
 975              *
 976              * Rob Funk: But is there any way for someone to modify
 977              * the PATH variable of a running fetchmail?  I don't know
 978              * of a way.
 979              *
 980              * Dave's change makes fetchmail restart itself in exactly
 981              * the way it was started from the shell (or shell script)
 982              * in the first place.  If you're concerned about PATH
 983              * contamination, call fetchmail initially with a full
 984              * path, and use Dave's patch.
 985              *
 986              * Not using a -p variant of exec means that the restart
 987              * will break if both (a) the user depended on PATH to
 988              * call fetchmail in the first place, and (b) the system
 989              * doesn't save the whole path in argv[0] if the whole
 990              * path wasn't used in the initial call.  (If I recall
 991              * correctly, Linux saves it but many other Unices don't.)
 992              */
 993             execvp(argv[0], argv);
 994             report(stderr, GT_("attempt to re-exec fetchmail failed\n"));
 995         }
 996
 997 #ifdef HAVE_RES_SEARCH
 998         /* Boldly assume that we also have res_init() if we have
 999          * res_search(), and call res_init() to re-read the resolv.conf
1000          * file, so that we can pick up changes to that file that are
1001          * written by dhpccd, dhclient, pppd, openvpn and similar. */
1002
1003         /* NOTE: This assumes that /etc/resolv.conf is written
1004          * atomically (i. e. a temporary file is written, flushed and
1005          * then renamed into place). To fix Debian Bug#389270. */
1006
1007         /* NOTE: If this leaks memory or doesn't re-read
1008          * /etc/resolv.conf, we're in trouble. The res_init() interface
1009          * is only lightly documented :-( */
1010         res_init();
1011 #endif
1012
1013         activecount = 0;
1014         batchcount = 0;
1015         for (ctl = querylist; ctl; ctl = ctl->next)
1016             if (ctl->active)
1017             {
1018                 activecount++;
1019                 if (!(implicitmode && ctl->server.skip))
1020                 {
1021                     if (ctl->wedged)
1022                     {
1023                         report(stderr,
1024                                GT_("poll of %s skipped (failed authentication or too many timeouts)\n"),
1025                                ctl->server.pollname);
1026                         continue;
1027                     }
1028
1029                     /* check skip interval first so that it counts all polls */
1030                     if (run.poll_interval && ctl->server.interval)
1031                     {
1032                         if (ctl->server.poll_count++ % ctl->server.interval)
1033                         {
1034                             if (outlevel >= O_VERBOSE)
1035                                 report(stdout,
1036                                        GT_("interval not reached, not querying %s\n"),
1037                                        ctl->server.pollname);
1038                             continue;
1039                         }
1040                     }
1041
1042 #ifdef CAN_MONITOR
1043                     /*
1044                      * Don't do monitoring if we were woken by a signal.
1045                      * Note that interface_approve() does its own error logging.
1046                      */
1047                     if (!interface_approve(&ctl->server, !lastsig))
1048                         continue;
1049 #endif /* CAN_MONITOR */
1050
1051                     dofastuidl = 0; /* this is reset in the driver if required */
1052
1053 #ifdef HAVE_LIBPWMD
1054                     /*
1055                      * At each poll interval, check the pwmd server for
1056                      * changes in host and auth settings.
1057                      */
1058                     if (ctl->pwmd_file) {
1059                         if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1060                             continue;
1061
1062                         if (get_pwmd_details(ctl->server.pollname, ctl->server.protocol, ctl))
1063                             continue;
1064                     }
1065 #endif
1066                     querystatus = query_host(ctl);
1067
1068                     if (NUM_NONZERO(ctl->fastuidl))
1069                         ctl->fastuidlcount = (ctl->fastuidlcount + 1) % ctl->fastuidl;
1070 #ifdef POP3_ENABLE
1071                     /* leave the UIDL state alone if there have been any errors */
1072                     if (!check_only &&
1073                                 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL) || (querystatus==PS_MAXFETCH)))
1074                         uid_swap_lists(ctl);
1075                     else
1076                         uid_discard_new_list(ctl);
1077                     uid_reset_num(ctl);
1078 #endif  /* POP3_ENABLE */
1079
1080                     if (querystatus == PS_SUCCESS)
1081                         successes++;
1082                     else if (!check_only &&
1083                              ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
1084                         switch(querystatus)
1085                         {
1086                         case PS_SUCCESS:
1087                             report(stdout,GT_("Query status=0 (SUCCESS)\n"));break;
1088                         case PS_NOMAIL:
1089                             report(stdout,GT_("Query status=1 (NOMAIL)\n")); break;
1090                         case PS_SOCKET:
1091                             report(stdout,GT_("Query status=2 (SOCKET)\n")); break;
1092                         case PS_AUTHFAIL:
1093                             report(stdout,GT_("Query status=3 (AUTHFAIL)\n"));break;
1094                         case PS_PROTOCOL:
1095                             report(stdout,GT_("Query status=4 (PROTOCOL)\n"));break;
1096                         case PS_SYNTAX:
1097                             report(stdout,GT_("Query status=5 (SYNTAX)\n")); break;
1098                         case PS_IOERR:
1099                             report(stdout,GT_("Query status=6 (IOERR)\n"));  break;
1100                         case PS_ERROR:
1101                             report(stdout,GT_("Query status=7 (ERROR)\n"));  break;
1102                         case PS_EXCLUDE:
1103                             report(stdout,GT_("Query status=8 (EXCLUDE)\n")); break;
1104                         case PS_LOCKBUSY:
1105                             report(stdout,GT_("Query status=9 (LOCKBUSY)\n"));break;
1106                         case PS_SMTP:
1107                             report(stdout,GT_("Query status=10 (SMTP)\n")); break;
1108                         case PS_DNS:
1109                             report(stdout,GT_("Query status=11 (DNS)\n")); break;
1110                         case PS_BSMTP:
1111                             report(stdout,GT_("Query status=12 (BSMTP)\n")); break;
1112                         case PS_MAXFETCH:
1113                             report(stdout,GT_("Query status=13 (MAXFETCH)\n"));break;
1114                         default:
1115                             report(stdout,GT_("Query status=%d\n"),querystatus);
1116                             break;
1117                         }
1118
1119 #ifdef CAN_MONITOR
1120                     if (ctl->server.monitor)
1121                     {
1122                         /*
1123                          * Allow some time for the link to quiesce.  One
1124                          * second is usually sufficient, three is safe.
1125                          * Note:  this delay is important - don't remove!
1126                          */
1127                         sleep(3);
1128                         interface_note_activity(&ctl->server);
1129                     }
1130 #endif /* CAN_MONITOR */
1131                 }
1132             }
1133
1134 #ifdef HAVE_LIBPWMD
1135         if (pwm) {
1136             pwmd_close(pwm);
1137             pwm = NULL;
1138         }
1139 #endif
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 #ifdef HAVE_LIBPWMD
1436                     if (ctl->pwmd_file) {
1437                         /*
1438                          * Cannot get an element path without a service.
1439                          */
1440                         if (ctl->server.protocol <= 1) {
1441                             report(stderr, GT_("%s configuration invalid, pwmd_file requires a protocol specification\n"),
1442                                    ctl->server.pollname);
1443                             exit(PS_SYNTAX);
1444                         }
1445
1446                         fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1447                         if (do_pwmd_connect(ctl->pwmd_socket, ctl->pwmd_file))
1448                             continue;
1449
1450                         if (get_pwmd_details(ctl->server.pollname,
1451                                     ctl->server.protocol, ctl))
1452                             continue;
1453                     }
1454 #endif
1455                 }
1456
1457             if (!predeclared)
1458             {
1459                 /*
1460                  * Allocate and link record without copying in
1461                  * command-line args; we'll do that with the optmerge
1462                  * call later on.
1463                  */
1464                 ctl = hostalloc((struct query *)NULL);
1465 #ifdef HAVE_LIBPWMD
1466                 if (cmd_opts.pwmd_file) {
1467                     /*
1468                      * Cannot get an element path without a service.
1469                      */
1470                     if (cmd_opts.server.protocol == 0 || cmd_opts.server.protocol == 1) {
1471                         report(stderr, GT_("Option --pwmd-file needs a service (-p) parameter.\n"));
1472                         exit(PS_SYNTAX);
1473                     }
1474
1475                         fprintf(stderr, "%s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
1476                     if (do_pwmd_connect(cmd_opts.pwmd_socket, cmd_opts.pwmd_file))
1477                         continue;
1478
1479                     if (get_pwmd_details(argv[optind], cmd_opts.server.protocol,
1480                             ctl))
1481                         continue;
1482                 }
1483                 else
1484                     ctl->server.via =
1485                         ctl->server.pollname = xstrdup(argv[optind]);
1486 #else
1487                 ctl->server.via =
1488                     ctl->server.pollname = xstrdup(argv[optind]);
1489 #endif
1490                 ctl->active = TRUE;
1491                 ctl->server.lead_server = (struct hostdata *)NULL;
1492             }
1493         }
1494
1495     /*
1496      * If there's a defaults record, merge it and lose it.
1497      * FIXME: we don't currently free all entries that might be in struct query.
1498      */
1499     if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
1500     {
1501         struct query *tmpq;
1502
1503         for (ctl = querylist->next; ctl; ctl = ctl->next)
1504             optmerge(ctl, querylist, FALSE);
1505         tmpq = querylist;
1506         querylist = querylist->next;
1507         free(tmpq->server.pollname);
1508         free(tmpq);
1509     }
1510
1511     /* don't allow a defaults record after the first */
1512     for (ctl = querylist; ctl; ctl = ctl->next) {
1513         if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0) {
1514             fprintf(stderr, GT_("fetchmail: Error: multiple \"defaults\" records in config file.\n"));
1515             exit(PS_SYNTAX);
1516         }
1517     }
1518
1519     /* use localhost if we never fetch the FQDN of this host */
1520     fetchmailhost = "localhost";
1521
1522     /* here's where we override globals */
1523     if (cmd_run.logfile)
1524         run.logfile = cmd_run.logfile;
1525     if (cmd_run.idfile)
1526         run.idfile = cmd_run.idfile;
1527     if (cmd_run.pidfile)
1528         run.pidfile = cmd_run.pidfile;
1529     /* do this before the keep/fetchall test below, otherwise -d0 may fail */
1530     if (cmd_run.poll_interval >= 0)
1531         run.poll_interval = cmd_run.poll_interval;
1532     if (cmd_run.invisible)
1533         run.invisible = (cmd_run.invisible == FLAG_TRUE);
1534     if (cmd_run.showdots)
1535         run.showdots = (cmd_run.showdots == FLAG_TRUE);
1536     if (cmd_run.use_syslog)
1537         run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1538     if (cmd_run.postmaster)
1539         run.postmaster = cmd_run.postmaster;
1540     if (cmd_run.bouncemail)
1541         run.bouncemail = (cmd_run.bouncemail == FLAG_TRUE);
1542     if (cmd_run.softbounce)
1543         run.softbounce = (cmd_run.softbounce == FLAG_TRUE);
1544
1545     /* check and daemon options are not compatible */
1546     if (check_only && run.poll_interval)
1547         run.poll_interval = 0;
1548
1549     /*
1550      * DNS support is required for some protocols.  We used to
1551      * do this unconditionally, but it made fetchmail excessively
1552      * vulnerable to misconfigured DNS setups.
1553      *
1554      * If we're using ETRN or ODMR, the smtp hunt list is the
1555      * list of systems we're polling on behalf of; these have
1556      * to be fully-qualified domain names.  The default for
1557      * this list should be the FQDN of localhost.
1558      *
1559      * If we're using Kerberos for authentication, we need
1560      * the FQDN in order to generate capability keys.
1561      */
1562     for (ctl = querylist; ctl; ctl = ctl->next)
1563         if (ctl->active &&
1564                 (ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR
1565                  || ctl->server.authenticate == A_KERBEROS_V5))
1566         {
1567             fetchmailhost = host_fqdn(1);
1568             break;
1569         }
1570
1571     if (!ctl) /* list exhausted */
1572         fetchmailhost = host_fqdn(0);
1573
1574     /* this code enables flags to be turned off */
1575 #define DEFAULT(flag, dflt)     if (flag == FLAG_TRUE)\
1576                                         flag = TRUE;\
1577                                 else if (flag == FLAG_FALSE)\
1578                                         flag = FALSE;\
1579                                 else\
1580                                         flag = (dflt)
1581
1582     /* merge in wired defaults, do sanity checks and prepare internal fields */
1583     for (ctl = querylist; ctl; ctl = ctl->next)
1584     {
1585         ctl->wedged = FALSE;
1586
1587         /* merge in defaults */
1588         optmerge(ctl, &def_opts, FALSE);
1589
1590         /* force command-line options */
1591         optmerge(ctl, &cmd_opts, TRUE);
1592
1593         /*
1594          * queryname has to be set up for inactive servers too.
1595          * Otherwise the UIDL code core-dumps on startup.
1596          */
1597         if (ctl->server.via)
1598             ctl->server.queryname = xstrdup(ctl->server.via);
1599         else
1600             ctl->server.queryname = xstrdup(ctl->server.pollname);
1601
1602         /*
1603          * We no longer do DNS lookups at startup.
1604          * This is a kluge.  It enables users to edit their
1605          * configurations when DNS isn't available.
1606          */
1607         ctl->server.truename = xstrdup(ctl->server.queryname);
1608
1609         if (configdump || ctl->active )
1610         {
1611             DEFAULT(ctl->keep, FALSE);
1612             DEFAULT(ctl->fetchall, FALSE);
1613             DEFAULT(ctl->flush, FALSE);
1614             DEFAULT(ctl->limitflush, FALSE);
1615             DEFAULT(ctl->rewrite, TRUE);
1616             DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1617             DEFAULT(ctl->forcecr, FALSE);
1618             DEFAULT(ctl->pass8bits, FALSE);
1619             DEFAULT(ctl->dropstatus, FALSE);
1620             DEFAULT(ctl->dropdelivered, FALSE);
1621             DEFAULT(ctl->mimedecode, FALSE);
1622             DEFAULT(ctl->idle, FALSE);
1623             DEFAULT(ctl->server.dns, TRUE);
1624             DEFAULT(ctl->use_ssl, FALSE);
1625             DEFAULT(ctl->sslcertck, FALSE);
1626             DEFAULT(ctl->server.checkalias, FALSE);
1627 #ifndef SSL_ENABLE
1628             /*
1629              * XXX FIXME: do we need this check or can we rely on the .y
1630              * parser handling this?
1631              */
1632             if (ctl->use_ssl)
1633             {
1634                 report(stderr, GT_("SSL support is not compiled in.\n"));
1635                 exit(PS_SYNTAX);
1636             }
1637 #endif /* SSL_ENABLE */
1638 #undef DEFAULT
1639 #ifndef KERBEROS_V5
1640             if (ctl->server.authenticate == A_KERBEROS_V5) {
1641                 report(stderr, GT_("KERBEROS v5 support is configured, but not compiled in.\n"));
1642                 exit(PS_SYNTAX);
1643             }
1644 #endif
1645 #ifndef GSSAPI
1646             if (ctl->server.authenticate == A_GSSAPI) {
1647                 report(stderr, GT_("GSSAPI support is configured, but not compiled in.\n"));
1648                 exit(PS_SYNTAX);
1649             }
1650 #endif
1651
1652             /*
1653              * Make sure we have a nonempty host list to forward to.
1654              */
1655             if (!ctl->smtphunt)
1656                 save_str(&ctl->smtphunt, "localhost", FALSE);
1657
1658             /*
1659              * Make sure we have a nonempty list of domains to fetch from.
1660              */
1661             if ((ctl->server.protocol==P_ETRN || ctl->server.protocol==P_ODMR) && !ctl->domainlist)
1662                 save_str(&ctl->domainlist, fetchmailhost, FALSE);
1663
1664             /* if `user' doesn't name a real local user, try to run as root */
1665             if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1666                 ctl->uid = 0;
1667             else
1668                 ctl->uid = pw->pw_uid;  /* for local delivery via MDA */
1669             if (!ctl->localnames)       /* for local delivery via SMTP */
1670                 save_str_pair(&ctl->localnames, user, NULL);
1671
1672
1673             /*
1674              * can't handle multidrop mailboxes without "envelope"
1675              * option, this causes truckloads full of support complaints
1676              * "all mail forwarded to postmaster"
1677              */
1678             if (MULTIDROP(ctl) && !ctl->server.envelope)
1679             {
1680                 report(stderr, GT_("warning: multidrop for %s requires envelope option!\n"), ctl->server.pollname);
1681                 report(stderr, GT_("warning: Do not ask for support if all mail goes to postmaster!\n"));
1682             }
1683
1684             /* if no folders were specified, set up the null one as default */
1685             if (!ctl->mailboxes)
1686                 save_str(&ctl->mailboxes, (char *)NULL, 0);
1687
1688             /* maybe user overrode timeout on command line? */
1689             if (ctl->server.timeout == -1)
1690                 ctl->server.timeout = CLIENT_TIMEOUT;
1691
1692             /* sanity checks */
1693             if (ctl->server.service) {
1694                 int port = servport(ctl->server.service);
1695                 if (port < 0)
1696                 {
1697                     (void) fprintf(stderr,
1698                                    GT_("fetchmail: %s configuration invalid, specify positive port number for service or port\n"),
1699                                    ctl->server.pollname);
1700                     exit(PS_SYNTAX);
1701                 }
1702             }
1703             if (ctl->listener == LMTP_MODE)
1704             {
1705                 struct idlist   *idp;
1706
1707                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1708                 {
1709                     char        *cp;
1710
1711                     if (!(cp = strrchr(idp->id, '/'))
1712                         || (0 == strcmp(cp + 1, SMTP_PORT))
1713                         || servport(cp + 1) == SMTP_PORT_NUM)
1714                     {
1715                         (void) fprintf(stderr,
1716                                        GT_("%s configuration invalid, LMTP can't use default SMTP port\n"),
1717                                        ctl->server.pollname);
1718                         exit(PS_SYNTAX);
1719                     }
1720                 }
1721             }
1722
1723             /*
1724              * "I beg to you, have mercy on the we[a]k minds like myself."
1725              * wrote Pehr Anderson.  Your petition is granted.
1726              */
1727             if (ctl->fetchall && ctl->keep && (run.poll_interval || ctl->idle) && !nodetach && !configdump)
1728             {
1729                 (void) fprintf(stderr,
1730                                GT_("Both fetchall and keep on in daemon or idle mode is a mistake!\n"));
1731             }
1732         }
1733     }
1734
1735     /*
1736      * If the user didn't set a last-resort user to get misaddressed
1737      * multidrop mail, set an appropriate default here.
1738      */
1739     if (!run.postmaster)
1740     {
1741         if (getuid() != ROOT_UID)               /* ordinary user */
1742             run.postmaster = user;
1743         else                                    /* root */
1744             run.postmaster = "postmaster";
1745     }
1746
1747     return(implicitmode);
1748 }
1749
1750 static void terminate_poll(int sig)
1751 /* to be executed at the end of a poll cycle */
1752 {
1753
1754     if (sig != 0)
1755         report(stdout, GT_("terminated with signal %d\n"), sig);
1756
1757 #ifdef POP3_ENABLE
1758     /*
1759      * Update UID information at end of each poll, rather than at end
1760      * of run, because that way we don't lose all UIDL information since
1761      * the beginning of time if fetchmail crashes.
1762      */
1763     if (!check_only)
1764         write_saved_lists(querylist, run.idfile);
1765 #endif /* POP3_ENABLE */
1766 }
1767
1768 static void terminate_run(int sig)
1769 /* to be executed on normal or signal-induced termination */
1770 {
1771     struct query        *ctl;
1772
1773     terminate_poll(sig);
1774
1775     /*
1776      * Craig Metz, the RFC1938 one-time-password guy, points out:
1777      * "Remember that most kernels don't zero pages before handing them to the
1778      * next process and many kernels share pages between user and kernel space.
1779      * You'd be very surprised what you can find from a short program to do a
1780      * malloc() and then dump the contents of the pages you got. By zeroing
1781      * the secrets at end of run (earlier if you can), you make sure the next
1782      * guy can't get the password/pass phrase."
1783      *
1784      * Right you are, Craig!
1785      */
1786     for (ctl = querylist; ctl; ctl = ctl->next)
1787         if (ctl->password)
1788           memset(ctl->password, '\0', strlen(ctl->password));
1789
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 static void dump_params (struct runctl *runp,
1908                          struct query *querylist, flag implicit)
1909 /* display query parameters in English */
1910 {
1911     struct query *ctl;
1912
1913     if (runp->poll_interval)
1914         printf(GT_("Poll interval is %d seconds\n"), runp->poll_interval);
1915     if (runp->logfile)
1916         printf(GT_("Logfile is %s\n"), runp->logfile);
1917     if (strcmp(runp->idfile, IDFILE_NAME))
1918         printf(GT_("Idfile is %s\n"), runp->idfile);
1919     if (runp->use_syslog)
1920         printf(GT_("Progress messages will be logged via syslog\n"));
1921     if (runp->invisible)
1922         printf(GT_("Fetchmail will masquerade and will not generate Received\n"));
1923     if (runp->showdots)
1924         printf(GT_("Fetchmail will show progress dots even in logfiles.\n"));
1925     if (runp->postmaster)
1926         printf(GT_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1927                runp->postmaster);
1928
1929     if (!runp->bouncemail)
1930         printf(GT_("Fetchmail will direct error mail to the postmaster.\n"));
1931     else if (outlevel >= O_VERBOSE)
1932         printf(GT_("Fetchmail will direct error mail to the sender.\n"));
1933
1934     if (!runp->softbounce)
1935         printf(GT_("Fetchmail will treat permanent errors as permanent (drop messages).\n"));
1936     else if (outlevel >= O_VERBOSE)
1937         printf(GT_("Fetchmail will treat permanent errors as temporary (keep messages).\n"));
1938
1939     for (ctl = querylist; ctl; ctl = ctl->next)
1940     {
1941         if (!ctl->active || (implicit && ctl->server.skip))
1942             continue;
1943
1944         printf(GT_("Options for retrieving from %s@%s:\n"),
1945                ctl->remotename, visbuf(ctl->server.pollname));
1946
1947         if (ctl->server.via && MAILBOX_PROTOCOL(ctl))
1948             printf(GT_("  Mail will be retrieved via %s\n"), ctl->server.via);
1949
1950         if (ctl->server.interval)
1951             printf(ngettext("  Poll of this server will occur every %d interval.\n",
1952                             "  Poll of this server will occur every %d intervals.\n",
1953                             ctl->server.interval), ctl->server.interval);
1954         if (ctl->server.truename)
1955             printf(GT_("  True name of server is %s.\n"), ctl->server.truename);
1956         if (ctl->server.skip || outlevel >= O_VERBOSE)
1957             printf(ctl->server.skip
1958                    ? GT_("  This host will not be queried when no host is specified.\n")
1959                    : GT_("  This host will be queried when no host is specified.\n"));
1960         if (!NO_PASSWORD(ctl))
1961         {
1962             if (!ctl->password)
1963                 printf(GT_("  Password will be prompted for.\n"));
1964             else if (outlevel >= O_VERBOSE)
1965             {
1966                 printf(GT_("  Password = \"%s\".\n"),
1967                                     visbuf(ctl->password));
1968             }
1969         }
1970
1971         if (ctl->server.protocol == P_POP3
1972             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1973             && (ctl->server.authenticate == A_KERBEROS_V5))
1974             printf(GT_("  Protocol is KPOP with Kerberos %s authentication"),
1975                    ctl->server.authenticate == A_KERBEROS_V5 ? "V" : "IV");
1976         else
1977             printf(GT_("  Protocol is %s"), showproto(ctl->server.protocol));
1978         if (ctl->server.service)
1979             printf(GT_(" (using service %s)"), ctl->server.service);
1980         else if (outlevel >= O_VERBOSE)
1981             printf(GT_(" (using default port)"));
1982         putchar('.');
1983         putchar('\n');
1984         switch (ctl->server.authenticate)
1985         {
1986         case A_ANY:
1987             printf(GT_("  All available authentication methods will be tried.\n"));
1988             break;
1989         case A_PASSWORD:
1990             printf(GT_("  Password authentication will be forced.\n"));
1991             break;
1992         case A_MSN:
1993             printf(GT_("  MSN authentication will be forced.\n"));
1994             break;
1995         case A_NTLM:
1996             printf(GT_("  NTLM authentication will be forced.\n"));
1997             break;
1998         case A_OTP:
1999             printf(GT_("  OTP authentication will be forced.\n"));
2000             break;
2001         case A_CRAM_MD5:
2002             printf(GT_("  CRAM-MD5 authentication will be forced.\n"));
2003             break;
2004         case A_GSSAPI:
2005             printf(GT_("  GSSAPI authentication will be forced.\n"));
2006             break;
2007         case A_KERBEROS_V5:
2008             printf(GT_("  Kerberos V5 authentication will be forced.\n"));
2009             break;
2010         case A_SSH:
2011             printf(GT_("  End-to-end encryption assumed.\n"));
2012             break;
2013         case A_APOP:
2014             printf(GT_("  APOP authentication will be forced.\n"));
2015             break;
2016         default:
2017             abort();
2018         }
2019         if (ctl->server.principal != (char *) NULL)
2020             printf(GT_("  Mail service principal is: %s\n"), ctl->server.principal);
2021 #ifdef  SSL_ENABLE
2022         if (ctl->use_ssl)
2023             printf(GT_("  SSL encrypted sessions enabled.\n"));
2024         if (ctl->sslproto)
2025             printf(GT_("  SSL protocol: %s.\n"), ctl->sslproto);
2026         if (ctl->sslcertck) {
2027             printf(GT_("  SSL server certificate checking enabled.\n"));
2028         }
2029         if (ctl->sslcertfile != NULL)
2030                 printf(GT_("  SSL trusted certificate file: %s\n"), ctl->sslcertfile);
2031         if (ctl->sslcertpath != NULL)
2032                 printf(GT_("  SSL trusted certificate directory: %s\n"), ctl->sslcertpath);
2033         if (ctl->sslcommonname != NULL)
2034                 printf(GT_("  SSL server CommonName: %s\n"), ctl->sslcommonname);
2035         if (ctl->sslfingerprint != NULL)
2036                 printf(GT_("  SSL key fingerprint (checked against the server key): %s\n"), ctl->sslfingerprint);
2037 #endif
2038         if (ctl->server.timeout > 0)
2039             printf(GT_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
2040         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
2041             printf(GT_(" (default).\n"));
2042         else
2043             printf(".\n");
2044
2045         if (MAILBOX_PROTOCOL(ctl))
2046         {
2047             if (!ctl->mailboxes->id)
2048                 printf(GT_("  Default mailbox selected.\n"));
2049             else
2050             {
2051                 struct idlist *idp;
2052
2053                 printf(GT_("  Selected mailboxes are:"));
2054                 for (idp = ctl->mailboxes; idp; idp = idp->next)
2055                     printf(" %s", idp->id);
2056                 printf("\n");
2057             }
2058             printf(ctl->fetchall
2059                    ? GT_("  All messages will be retrieved (--all on).\n")
2060                    : GT_("  Only new messages will be retrieved (--all off).\n"));
2061             printf(ctl->keep
2062                    ? GT_("  Fetched messages will be kept on the server (--keep on).\n")
2063                    : GT_("  Fetched messages will not be kept on the server (--keep off).\n"));
2064             printf(ctl->flush
2065                    ? GT_("  Old messages will be flushed before message retrieval (--flush on).\n")
2066                    : GT_("  Old messages will not be flushed before message retrieval (--flush off).\n"));
2067             printf(ctl->limitflush
2068                    ? GT_("  Oversized messages will be flushed before message retrieval (--limitflush on).\n")
2069                    : GT_("  Oversized messages will not be flushed before message retrieval (--limitflush off).\n"));
2070             printf(ctl->rewrite
2071                    ? GT_("  Rewrite of server-local addresses is enabled (--norewrite off).\n")
2072                    : GT_("  Rewrite of server-local addresses is disabled (--norewrite on).\n"));
2073             printf(ctl->stripcr
2074                    ? GT_("  Carriage-return stripping is enabled (stripcr on).\n")
2075                    : GT_("  Carriage-return stripping is disabled (stripcr off).\n"));
2076             printf(ctl->forcecr
2077                    ? GT_("  Carriage-return forcing is enabled (forcecr on).\n")
2078                    : GT_("  Carriage-return forcing is disabled (forcecr off).\n"));
2079             printf(ctl->pass8bits
2080                    ? GT_("  Interpretation of Content-Transfer-Encoding is disabled (pass8bits on).\n")
2081                    : GT_("  Interpretation of Content-Transfer-Encoding is enabled (pass8bits off).\n"));
2082             printf(ctl->mimedecode
2083                    ? GT_("  MIME decoding is enabled (mimedecode on).\n")
2084                    : GT_("  MIME decoding is disabled (mimedecode off).\n"));
2085             printf(ctl->idle
2086                    ? GT_("  Idle after poll is enabled (idle on).\n")
2087                    : GT_("  Idle after poll is disabled (idle off).\n"));
2088             printf(ctl->dropstatus
2089                    ? GT_("  Nonempty Status lines will be discarded (dropstatus on)\n")
2090                    : GT_("  Nonempty Status lines will be kept (dropstatus off)\n"));
2091             printf(ctl->dropdelivered
2092                    ? GT_("  Delivered-To lines will be discarded (dropdelivered on)\n")
2093                    : GT_("  Delivered-To lines will be kept (dropdelivered off)\n"));
2094             if (NUM_NONZERO(ctl->limit))
2095             {
2096                 if (NUM_NONZERO(ctl->limit))
2097                     printf(GT_("  Message size limit is %d octets (--limit %d).\n"),
2098                            ctl->limit, ctl->limit);
2099                 else if (outlevel >= O_VERBOSE)
2100                     printf(GT_("  No message size limit (--limit 0).\n"));
2101                 if (run.poll_interval > 0)
2102                     printf(GT_("  Message size warning interval is %d seconds (--warnings %d).\n"),
2103                            ctl->warnings, ctl->warnings);
2104                 else if (outlevel >= O_VERBOSE)
2105                     printf(GT_("  Size warnings on every poll (--warnings 0).\n"));
2106             }
2107             if (NUM_NONZERO(ctl->fetchlimit))
2108                 printf(GT_("  Received-message limit is %d (--fetchlimit %d).\n"),
2109                        ctl->fetchlimit, ctl->fetchlimit);
2110             else if (outlevel >= O_VERBOSE)
2111                 printf(GT_("  No received-message limit (--fetchlimit 0).\n"));
2112             if (NUM_NONZERO(ctl->fetchsizelimit))
2113                 printf(GT_("  Fetch message size limit is %d (--fetchsizelimit %d).\n"),
2114                        ctl->fetchsizelimit, ctl->fetchsizelimit);
2115             else if (outlevel >= O_VERBOSE)
2116                 printf(GT_("  No fetch message size limit (--fetchsizelimit 0).\n"));
2117             if (NUM_NONZERO(ctl->fastuidl) && MAILBOX_PROTOCOL(ctl))
2118             {
2119                 if (ctl->fastuidl == 1)
2120                     printf(GT_("  Do binary search of UIDs during each poll (--fastuidl 1).\n"));
2121                 else
2122                     printf(GT_("  Do binary search of UIDs during %d out of %d polls (--fastuidl %d).\n"), ctl->fastuidl - 1, ctl->fastuidl, ctl->fastuidl);
2123             }
2124             else if (outlevel >= O_VERBOSE)
2125                 printf(GT_("   Do linear search of UIDs during each poll (--fastuidl 0).\n"));
2126             if (NUM_NONZERO(ctl->batchlimit))
2127                 printf(GT_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
2128             else if (outlevel >= O_VERBOSE)
2129                 printf(GT_("  No SMTP message batch limit (--batchlimit 0).\n"));
2130             if (MAILBOX_PROTOCOL(ctl))
2131             {
2132                 if (NUM_NONZERO(ctl->expunge))
2133                     printf(GT_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
2134                 else if (outlevel >= O_VERBOSE)
2135                     printf(GT_("  No forced expunges (--expunge 0).\n"));
2136             }
2137         }
2138         else    /* ODMR or ETRN */
2139         {
2140             struct idlist *idp;
2141
2142             printf(GT_("  Domains for which mail will be fetched are:"));
2143             for (idp = ctl->domainlist; idp; idp = idp->next)
2144             {
2145                 printf(" %s", idp->id);
2146                 if (!idp->val.status.mark)
2147                     printf(GT_(" (default)"));
2148             }
2149             printf("\n");
2150         }
2151         if (ctl->bsmtp)
2152             printf(GT_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
2153         else if (ctl->mda && MAILBOX_PROTOCOL(ctl))
2154             printf(GT_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
2155         else
2156         {
2157             struct idlist *idp;
2158
2159             if (ctl->smtphunt)
2160             {
2161                 printf(GT_("  Messages will be %cMTP-forwarded to:"),
2162                        ctl->listener);
2163                 for (idp = ctl->smtphunt; idp; idp = idp->next)
2164                 {
2165                     printf(" %s", idp->id);
2166                     if (!idp->val.status.mark)
2167                         printf(GT_(" (default)"));
2168                 }
2169                 printf("\n");
2170             }
2171             if (ctl->smtpaddress)
2172                 printf(GT_("  Host part of MAIL FROM line will be %s\n"),
2173                        ctl->smtpaddress);
2174             if (ctl->smtpname)
2175                 printf(GT_("  Address to be put in RCPT TO lines shipped to SMTP will be %s\n"),
2176                        ctl->smtpname);
2177         }
2178         if (MAILBOX_PROTOCOL(ctl))
2179         {
2180                 if (ctl->antispam != (struct idlist *)NULL)
2181                 {
2182                     struct idlist *idp;
2183
2184                     printf(GT_("  Recognized listener spam block responses are:"));
2185                     for (idp = ctl->antispam; idp; idp = idp->next)
2186                         printf(" %d", idp->val.status.num);
2187                     printf("\n");
2188                 }
2189                 else if (outlevel >= O_VERBOSE)
2190                     printf(GT_("  Spam-blocking disabled\n"));
2191         }
2192         if (ctl->preconnect)
2193             printf(GT_("  Server connection will be brought up with \"%s\".\n"),
2194                    visbuf(ctl->preconnect));
2195         else if (outlevel >= O_VERBOSE)
2196             printf(GT_("  No pre-connection command.\n"));
2197         if (ctl->postconnect)
2198             printf(GT_("  Server connection will be taken down with \"%s\".\n"),
2199                    visbuf(ctl->postconnect));
2200         else if (outlevel >= O_VERBOSE)
2201             printf(GT_("  No post-connection command.\n"));
2202         if (MAILBOX_PROTOCOL(ctl)) {
2203                 if (!ctl->localnames)
2204                     printf(GT_("  No localnames declared for this host.\n"));
2205                 else
2206                 {
2207                     struct idlist *idp;
2208                     int count = 0;
2209
2210                     for (idp = ctl->localnames; idp; idp = idp->next)
2211                         ++count;
2212
2213                     if (count > 1 || ctl->wildcard)
2214                         printf(GT_("  Multi-drop mode: "));
2215                     else
2216                         printf(GT_("  Single-drop mode: "));
2217
2218                     printf(ngettext("%d local name recognized.\n", "%d local names recognized.\n", count), count);
2219                     if (outlevel >= O_VERBOSE)
2220                     {
2221                         for (idp = ctl->localnames; idp; idp = idp->next)
2222                             if (idp->val.id2)
2223                                 printf("\t%s -> %s\n", idp->id, idp->val.id2);
2224                             else
2225                                 printf("\t%s\n", idp->id);
2226                         if (ctl->wildcard)
2227                             fputs("\t*\n", stdout);
2228                     }
2229
2230                     if (count > 1 || ctl->wildcard)
2231                     {
2232                         printf(ctl->server.dns
2233                                ? GT_("  DNS lookup for multidrop addresses is enabled.\n")
2234                                : GT_("  DNS lookup for multidrop addresses is disabled.\n"));
2235                         if (ctl->server.dns)
2236                         {
2237                             if (ctl->server.checkalias)
2238                                 printf(GT_("  Server aliases will be compared with multidrop addresses by IP address.\n"));
2239                             else
2240                                 printf(GT_("  Server aliases will be compared with multidrop addresses by name.\n"));
2241                         }
2242                         if (ctl->server.envelope == STRING_DISABLED)
2243                             printf(GT_("  Envelope-address routing is disabled\n"));
2244                         else
2245                         {
2246                             printf(GT_("  Envelope header is assumed to be: %s\n"),
2247                                    ctl->server.envelope ? ctl->server.envelope : "Received");
2248                             if (ctl->server.envskip || outlevel >= O_VERBOSE)
2249                                 printf(GT_("  Number of envelope headers to be skipped over: %d\n"),
2250                                        ctl->server.envskip);
2251                             if (ctl->server.qvirtual)
2252                                 printf(GT_("  Prefix %s will be removed from user id\n"),
2253                                        ctl->server.qvirtual);
2254                             else if (outlevel >= O_VERBOSE)
2255                                 printf(GT_("  No prefix stripping\n"));
2256                         }
2257
2258                         if (ctl->server.akalist)
2259                         {
2260                             printf(GT_("  Predeclared mailserver aliases:"));
2261                             for (idp = ctl->server.akalist; idp; idp = idp->next)
2262                                 printf(" %s", idp->id);
2263                             putchar('\n');
2264                         }
2265
2266                         if (ctl->server.localdomains)
2267                         {
2268                             printf(GT_("  Local domains:"));
2269                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
2270                                 printf(" %s", idp->id);
2271                             putchar('\n');
2272                         }
2273                     }
2274                 }
2275         }
2276 #ifdef CAN_MONITOR
2277         if (ctl->server.interface)
2278             printf(GT_("  Connection must be through interface %s.\n"), ctl->server.interface);
2279         else if (outlevel >= O_VERBOSE)
2280             printf(GT_("  No interface requirement specified.\n"));
2281         if (ctl->server.monitor)
2282             printf(GT_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
2283         else if (outlevel >= O_VERBOSE)
2284             printf(GT_("  No monitor interface specified.\n"));
2285 #endif
2286
2287         if (ctl->server.plugin)
2288             printf(GT_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
2289         else if (outlevel >= O_VERBOSE)
2290             printf(GT_("  No plugin command specified.\n"));
2291         if (ctl->server.plugout)
2292             printf(GT_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
2293         else if (outlevel >= O_VERBOSE)
2294             printf(GT_("  No plugout command specified.\n"));
2295
2296         if (MAILBOX_PROTOCOL(ctl))
2297         {
2298             int count;
2299
2300             if (!(count = uid_db_n_records(&ctl->oldsaved)))
2301                 printf(GT_("  No UIDs saved from this host.\n"));
2302             else
2303             {
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 */