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

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