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