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

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