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
 590     /*
 591      * Query all hosts. If there's only one, the error return will
 592      * reflect the status of that transaction.
 593      */
 594     do {
 595         /*
 596          * Check to see if the rcfile has been touched.  If so,
 597          * re-exec so the file will be reread.  Doing it this way
 598          * avoids all the complications of trying to deallocate the
 599          * in-core control structures -- and the potential memory
 600          * leaks...
 601          */
 602         struct stat     rcstat;
 603
 604         if (stat(rcfile, &rcstat) == -1)
 605         {
 606             if (errno != ENOENT)
 607                 report(stderr,
 608                        _("couldn't time-check %s (error %d)\n"),
 609                        rcfile, errno);
 610         }
 611         else if (rcstat.st_mtime > parsetime)
 612         {
 613             report(stdout, _("restarting fetchmail (%s changed)\n"), rcfile);
 614             execvp("fetchmail", argv);
 615             report(stderr, _("attempt to re-exec fetchmail failed\n"));
 616         }
 617
 618 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
 619         /*
 620          * This was an efficiency hack that backfired.  The theory
 621          * was that using TCP/IP for DNS queries would get us better
 622          * reliability and shave off some per-UDP-packet costs.
 623          * Unfortunately it interacted badly with diald, which effectively
 624          * filters out DNS queries over TCP/IP for reasons having to do
 625          * with some obscure kernel problem involving bootstrapping of
 626          * dynamically-addressed links.  I don't understand this mess
 627          * and don't want to, so it's "See ya!" to this hack.
 628          */
 629         sethostent(TRUE);       /* use TCP/IP for mailserver queries */
 630 #endif /* HAVE_RES_SEARCH */
 631
 632         activecount = 0;
 633         batchcount = 0;
 634         for (ctl = querylist; ctl; ctl = ctl->next)
 635             if (ctl->active)
 636             {
 637                 activecount++;
 638                 if (!(implicitmode && ctl->server.skip))
 639                 {
 640                     if (ctl->wedged)
 641                     {
 642                         report(stderr,
 643                                _("poll of %s skipped (failed authentication or too many timeouts)\n"),
 644                                ctl->server.pollname);
 645                         continue;
 646                     }
 647
 648                     /* check skip interval first so that it counts all polls */
 649                     if (run.poll_interval && ctl->server.interval)
 650                     {
 651                         if (ctl->server.poll_count++ % ctl->server.interval)
 652                         {
 653                             if (outlevel >= O_VERBOSE)
 654                                 report(stdout,
 655                                        _("interval not reached, not querying %s\n"),
 656                                        ctl->server.pollname);
 657                             continue;
 658                         }
 659                     }
 660
 661 #if (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__)
 662                     /*
 663                      * Don't do monitoring if we were woken by a signal.
 664                      * Note that interface_approve() does its own error logging.
 665                      */
 666                     if (!interface_approve(&ctl->server, !lastsig))
 667                         continue;
 668 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
 669
 670                     querystatus = query_host(ctl);
 671
 672 #ifdef POP3_ENABLE
 673                     /* leave the UIDL state alone if there have been any errors */
 674                     if (!check_only &&
 675                                 ((querystatus==PS_SUCCESS) || (querystatus==PS_NOMAIL)))
 676                         uid_swap_lists(ctl);
 677 #endif  /* POP3_ENABLE */
 678
 679                     if (querystatus == PS_SUCCESS)
 680                         successes++;
 681                     else if (!check_only &&
 682                              ((querystatus!=PS_NOMAIL) || (outlevel==O_DEBUG)))
 683                         switch(querystatus)
 684                         {
 685                         case PS_SUCCESS:
 686                             report(stdout,_("Query status=0 (SUCCESS)\n"));break;
 687                         case PS_NOMAIL:
 688                             report(stdout,_("Query status=1 (NOMAIL)\n")); break;
 689                         case PS_SOCKET:
 690                             report(stdout,_("Query status=2 (SOCKET)\n")); break;
 691                         case PS_AUTHFAIL:
 692                             report(stdout,_("Query status=3 (AUTHFAIL)\n"));break;
 693                         case PS_PROTOCOL:
 694                             report(stdout,_("Query status=4 (PROTOCOL)\n"));break;
 695                         case PS_SYNTAX:
 696                             report(stdout,_("Query status=5 (SYNTAX)\n")); break;
 697                         case PS_IOERR:
 698                             report(stdout,_("Query status=6 (IOERR)\n"));  break;
 699                         case PS_ERROR:
 700                             report(stdout,_("Query status=7 (ERROR)\n"));  break;
 701                         case PS_EXCLUDE:
 702                             report(stdout,_("Query status=8 (EXCLUDE)\n")); break;
 703                         case PS_LOCKBUSY:
 704                             report(stdout,_("Query status=9 (LOCKBUSY)\n"));break;
 705                         case PS_SMTP:
 706                             report(stdout,_("Query status=10 (SMTP)\n")); break;
 707                         case PS_DNS:
 708                             report(stdout,_("Query status=11 (DNS)\n")); break;
 709                         case PS_BSMTP:
 710                             report(stdout,_("Query status=12 (BSMTP)\n")); break;
 711                         case PS_MAXFETCH:
 712                             report(stdout,_("Query status=13 (MAXFETCH)\n"));break;
 713                         default:
 714                             report(stdout,_("Query status=%d\n"),querystatus);
 715                             break;
 716                         }
 717
 718 #if (defined(linux) && !INET6_ENABLE) || defined (__FreeBSD__)
 719                     if (ctl->server.monitor)
 720                     {
 721                         /*
 722                          * Allow some time for the link to quiesce.  One
 723                          * second is usually sufficient, three is safe.
 724                          * Note:  this delay is important - don't remove!
 725                          */
 726                         sleep(3);
 727                         interface_note_activity(&ctl->server);
 728                     }
 729 #endif /* (defined(linux) && !INET6_ENABLE) || defined(__FreeBSD__) */
 730                 }
 731             }
 732
 733 #if defined(HAVE_RES_SEARCH) && defined(USE_TCPIP_FOR_DNS)
 734         endhostent();           /* release TCP/IP connection to nameserver */
 735 #endif /* HAVE_RES_SEARCH */
 736
 737         /* close connections cleanly */
 738         terminate_poll(0);
 739
 740         /*
 741          * OK, we've polled.  Now sleep.
 742          */
 743         if (run.poll_interval)
 744         {
 745             /*
 746              * Because passwords can expire, it may happen that *all*
 747              * hosts are now out of the loop due to authfail
 748              * conditions.  If this happens daemon-mode fetchmail
 749              * should softly and silently vanish away, rather than
 750              * spinning uselessly.
 751              */
 752             int unwedged = 0;
 753
 754             for (ctl = querylist; ctl; ctl = ctl->next)
 755                 if (ctl->active && !(implicitmode && ctl->server.skip))
 756                     if (!ctl->wedged)
 757                         unwedged++;
 758             if (!unwedged)
 759             {
 760                 report(stderr, _("All connections are wedged.  Exiting.\n"));
 761                 /* FIXME: someday, send notification mail */
 762                 exit(PS_AUTHFAIL);
 763             }
 764
 765             if (outlevel >= O_VERBOSE)
 766                 report(stdout,
 767                        _("fetchmail: sleeping at %s\n"), timestamp());
 768
 769             /*
 770              * OK, now pause util it's time for the next poll cycle.
 771              * A nonzero return indicates we received a wakeup signal;
 772              * unwedge all servers in case the problem has been
 773              * manually repaired.
 774              */
 775             if ((lastsig = interruptible_idle(run.poll_interval)))
 776             {
 777 #ifdef SYS_SIGLIST_DECLARED
 778                 report(stdout,
 779                        _("awakened by %s\n"), sys_siglist[lastsig]);
 780 #else
 781                 report(stdout,
 782                        _("awakened by signal %d\n"), lastsig);
 783 #endif
 784                 for (ctl = querylist; ctl; ctl = ctl->next)
 785                     ctl->wedged = FALSE;
 786             }
 787
 788             if (outlevel >= O_VERBOSE)
 789                 report(stdout, _("awakened at %s\n"), timestamp());
 790         }
 791     } while
 792         (run.poll_interval);
 793
 794     if (outlevel >= O_VERBOSE)
 795         report(stdout, _("normal termination, status %d\n"),
 796                 successes ? PS_SUCCESS : querystatus);
 797
 798     terminate_run(0);
 799     exit(successes ? PS_SUCCESS : querystatus);
 800 }
 801
 802 static void list_merge(struct idlist **dstl, struct idlist **srcl, int force)
 803 {
 804     /*
 805      * If force is off, modify dstl fields only when they're empty (treat srcl
 806      * as defaults).  If force is on, modify each dstl field whenever scrcl
 807      * is nonempty (treat srcl as an override).
 808      */
 809     if (force ? !!*srcl : !*dstl)
 810     {
 811         struct idlist *cpl = copy_str_list(*srcl);
 812
 813         append_str_list(dstl, &cpl);
 814     }
 815 }
 816
 817 static void optmerge(struct query *h2, struct query *h1, int force)
 818 /* merge two options records */
 819 {
 820     list_merge(&h2->server.localdomains, &h1->server.localdomains, force);
 821     list_merge(&h2->localnames, &h1->localnames, force);
 822     list_merge(&h2->mailboxes, &h1->mailboxes, force);
 823     list_merge(&h2->smtphunt, &h1->smtphunt, force);
 824     list_merge(&h2->antispam, &h1->antispam, force);
 825
 826 #define FLAG_MERGE(fld) if (force ? !!h1->fld : !h2->fld) h2->fld = h1->fld
 827     FLAG_MERGE(server.via);
 828     FLAG_MERGE(server.protocol);
 829 #if INET6_ENABLE
 830     FLAG_MERGE(server.service);
 831     FLAG_MERGE(server.netsec);
 832 #else /* INET6_ENABLE */
 833     FLAG_MERGE(server.port);
 834 #endif /* INET6_ENABLE */
 835     FLAG_MERGE(server.interval);
 836     FLAG_MERGE(server.preauthenticate);
 837     FLAG_MERGE(server.timeout);
 838     FLAG_MERGE(server.envelope);
 839     FLAG_MERGE(server.envskip);
 840     FLAG_MERGE(server.qvirtual);
 841     FLAG_MERGE(server.skip);
 842     FLAG_MERGE(server.dns);
 843     FLAG_MERGE(server.checkalias);
 844     FLAG_MERGE(server.uidl);
 845
 846 #if defined(linux) || defined(__FreeBSD__)
 847     FLAG_MERGE(server.interface);
 848     FLAG_MERGE(server.monitor);
 849     FLAG_MERGE(server.interface_pair);
 850 #endif /* linux || defined(__FreeBSD__) */
 851
 852     FLAG_MERGE(server.plugin);
 853     FLAG_MERGE(server.plugout);
 854
 855     FLAG_MERGE(wildcard);
 856     FLAG_MERGE(remotename);
 857     FLAG_MERGE(password);
 858     FLAG_MERGE(mda);
 859     FLAG_MERGE(bsmtp);
 860     FLAG_MERGE(listener);
 861     FLAG_MERGE(smtpaddress);
 862     FLAG_MERGE(smtpname);
 863     FLAG_MERGE(preconnect);
 864     FLAG_MERGE(postconnect);
 865
 866     FLAG_MERGE(keep);
 867     FLAG_MERGE(flush);
 868     FLAG_MERGE(fetchall);
 869     FLAG_MERGE(rewrite);
 870     FLAG_MERGE(forcecr);
 871     FLAG_MERGE(stripcr);
 872     FLAG_MERGE(pass8bits);
 873     FLAG_MERGE(dropstatus);
 874     FLAG_MERGE(dropdelivered);
 875     FLAG_MERGE(mimedecode);
 876     FLAG_MERGE(idle);
 877     FLAG_MERGE(limit);
 878     FLAG_MERGE(warnings);
 879     FLAG_MERGE(fetchlimit);
 880     FLAG_MERGE(batchlimit);
 881 #ifdef  SSL_ENABLE
 882     FLAG_MERGE(use_ssl);
 883     FLAG_MERGE(sslkey);
 884     FLAG_MERGE(sslcert);
 885 #endif
 886     FLAG_MERGE(expunge);
 887
 888     FLAG_MERGE(properties);
 889 #undef FLAG_MERGE
 890 }
 891
 892 static int load_params(int argc, char **argv, int optind)
 893 {
 894     int implicitmode, st;
 895     struct passwd *pw;
 896     struct query def_opts, *ctl;
 897     struct stat rcstat;
 898
 899     run.bouncemail = TRUE;
 900
 901     memset(&def_opts, '\0', sizeof(struct query));
 902     def_opts.smtp_socket = -1;
 903     def_opts.smtpaddress = (char *)0;
 904 #define ANTISPAM(n)     save_str(&def_opts.antispam, STRING_DUMMY, 0)->val.status.num = (n)
 905     ANTISPAM(571);      /* sendmail */
 906     ANTISPAM(550);      /* old exim */
 907     ANTISPAM(501);      /* new exim */
 908     ANTISPAM(554);      /* Postfix */
 909 #undef ANTISPAM
 910
 911     def_opts.server.protocol = P_AUTO;
 912     def_opts.server.timeout = CLIENT_TIMEOUT;
 913     def_opts.warnings = WARNING_INTERVAL;
 914     def_opts.remotename = user;
 915     def_opts.listener = SMTP_MODE;
 916
 917     /* note the parse time, so we can pick up on modifications */
 918     parsetime = 0;      /* foil compiler warnings */
 919     if (stat(rcfile, &rcstat) != -1)
 920         parsetime = rcstat.st_mtime;
 921     else if (errno != ENOENT)
 922         report(stderr, _("couldn't time-check the run-control file\n"));
 923
 924     /* this builds the host list */
 925     if ((st = prc_parse_file(rcfile, !versioninfo)) != 0)
 926         /*
 927          * FIXME: someday, send notification mail here if backgrounded.
 928          * Right now, that can happen if the user changes the rcfile
 929          * while the fetchmail is running in background.  Do similarly
 930          * for the other exit() calls in this function.
 931          */
 932         exit(st);
 933
 934     if ((implicitmode = (optind >= argc)))
 935     {
 936         for (ctl = querylist; ctl; ctl = ctl->next)
 937             ctl->active = TRUE;
 938     }
 939     else
 940         for (; optind < argc; optind++)
 941         {
 942             flag        predeclared =  FALSE;
 943
 944             /*
 945              * If hostname corresponds to a host known from the rc file,
 946              * simply declare it active.  Otherwise synthesize a host
 947              * record from command line and defaults
 948              */
 949             for (ctl = querylist; ctl; ctl = ctl->next)
 950                 if (!strcmp(ctl->server.pollname, argv[optind])
 951                         || str_in_list(&ctl->server.akalist, argv[optind], TRUE))
 952                 {
 953                     /* Is this correct? */
 954                     if (predeclared && outlevel == O_VERBOSE)
 955                         fprintf(stderr,_("Warning: multiple mentions of host %s in config file\n"),argv[optind]);
 956                     ctl->active = TRUE;
 957                     predeclared = TRUE;
 958                 }
 959
 960             if (!predeclared)
 961             {
 962                 /*
 963                  * Allocate and link record without copying in
 964                  * command-line args; we'll do that with the optmerge
 965                  * call later on.
 966                  */
 967                 ctl = hostalloc((struct query *)NULL);
 968                 ctl->server.via =
 969                     ctl->server.pollname = xstrdup(argv[optind]);
 970                 ctl->active = TRUE;
 971                 ctl->server.lead_server = (struct hostdata *)NULL;
 972             }
 973         }
 974
 975     /*
 976      * If there's a defaults record, merge it and lose it.
 977      */
 978     if (querylist && strcmp(querylist->server.pollname, "defaults") == 0)
 979     {
 980         for (ctl = querylist->next; ctl; ctl = ctl->next)
 981             optmerge(ctl, querylist, FALSE);
 982         querylist = querylist->next;
 983     }
 984
 985     /* don't allow a defaults record after the first */
 986     for (ctl = querylist; ctl; ctl = ctl->next)
 987         if (ctl != querylist && strcmp(ctl->server.pollname, "defaults") == 0)
 988             exit(PS_SYNTAX);
 989
 990     /* use localhost if we never fetch the FQDN of this host */
 991     fetchmailhost = "localhost";
 992
 993     /* here's where we override globals */
 994     if (cmd_run.logfile)
 995         run.logfile = cmd_run.logfile;
 996     if (cmd_run.idfile)
 997         run.idfile = cmd_run.idfile;
 998     /* do this before the keep/fetchall test below, otherwise -d0 may fail */
 999     if (cmd_run.poll_interval >= 0)
1000         run.poll_interval = cmd_run.poll_interval;
1001     if (cmd_run.invisible)
1002         run.invisible = cmd_run.invisible;
1003     if (cmd_run.use_syslog)
1004         run.use_syslog = (cmd_run.use_syslog == FLAG_TRUE);
1005     if (cmd_run.postmaster)
1006         run.postmaster = cmd_run.postmaster;
1007     if (cmd_run.bouncemail)
1008         run.bouncemail = cmd_run.bouncemail;
1009
1010     /* check and daemon options are not compatible */
1011     if (check_only && run.poll_interval)
1012         run.poll_interval = 0;
1013
1014     /* merge in wired defaults, do sanity checks and prepare internal fields */
1015     for (ctl = querylist; ctl; ctl = ctl->next)
1016     {
1017         ctl->wedged = FALSE;
1018
1019         if (configdump || (ctl->active && !(implicitmode && ctl->server.skip)))
1020         {
1021             /* merge in defaults */
1022             optmerge(ctl, &def_opts, FALSE);
1023
1024             /* force command-line options */
1025             optmerge(ctl, &cmd_opts, TRUE);
1026
1027             /* this code enables flags to be turned off */
1028 #define DEFAULT(flag, dflt)     if (flag == FLAG_TRUE)\
1029                                         flag = TRUE;\
1030                                 else if (flag == FLAG_FALSE)\
1031                                         flag = FALSE;\
1032                                 else\
1033                                         flag = (dflt)
1034             DEFAULT(ctl->keep, FALSE);
1035             DEFAULT(ctl->fetchall, FALSE);
1036             DEFAULT(ctl->flush, FALSE);
1037             DEFAULT(ctl->rewrite, TRUE);
1038             DEFAULT(ctl->stripcr, (ctl->mda != (char *)NULL));
1039             DEFAULT(ctl->forcecr, FALSE);
1040             DEFAULT(ctl->pass8bits, FALSE);
1041             DEFAULT(ctl->dropstatus, FALSE);
1042             DEFAULT(ctl->dropdelivered, FALSE);
1043             DEFAULT(ctl->mimedecode, FALSE);
1044             DEFAULT(ctl->idle, FALSE);
1045             DEFAULT(ctl->server.dns, TRUE);
1046             DEFAULT(ctl->server.uidl, FALSE);
1047 #ifdef  SSL_ENABLE
1048             DEFAULT(ctl->use_ssl, FALSE);
1049 #endif
1050             DEFAULT(ctl->server.checkalias, FALSE);
1051 #undef DEFAULT
1052
1053             /*
1054              * DNS support is required for some protocols.  We used to
1055              * do this unconditionally, but it made fetchmail excessively
1056              * vulnerable to misconfigured DNS setups.
1057              *
1058              * If we're using ETRN, the smtp hunt list is the list of
1059              * systems we're polling on behalf of; these have to be
1060              * fully-qualified domain names.  The default for this list
1061              * should be the FQDN of localhost.
1062              *
1063              * If we're using Kerberos for authentication, we need
1064              * the FQDN in order to generate capability keys.
1065              */
1066             if (ctl->server.protocol == P_ETRN
1067                          || ctl->server.preauthenticate == A_KERBEROS_V4
1068                          || ctl->server.preauthenticate == A_KERBEROS_V5)
1069                 if (strcmp(fetchmailhost, "localhost") == 0)
1070                         fetchmailhost = host_fqdn();
1071
1072             /*
1073              * Make sure we have a nonempty host list to forward to.
1074              */
1075             if (!ctl->smtphunt)
1076                 save_str(&ctl->smtphunt, fetchmailhost, FALSE);
1077
1078             /* if `user' doesn't name a real local user, try to run as root */
1079             if ((pw = getpwnam(user)) == (struct passwd *)NULL)
1080                 ctl->uid = 0;
1081             else
1082                 ctl->uid = pw->pw_uid;  /* for local delivery via MDA */
1083             if (!ctl->localnames)       /* for local delivery via SMTP */
1084                 save_str_pair(&ctl->localnames, user, NULL);
1085
1086 #if !defined(HAVE_GETHOSTBYNAME) || !defined(HAVE_RES_SEARCH)
1087             /* can't handle multidrop mailboxes unless we can do DNS lookups */
1088             if (ctl->localnames && ctl->localnames->next && ctl->server.dns)
1089             {
1090                 ctl->server.dns = FALSE;
1091                 report(stderr, _("fetchmail: warning: no DNS available to check multidrop fetches from %s\n"), ctl->server.pollname);
1092             }
1093 #endif /* !HAVE_GETHOSTBYNAME || !HAVE_RES_SEARCH */
1094
1095             /*
1096              *
1097              * Compute the true name of the mailserver host.
1098              * There are two clashing cases here:
1099              *
1100              * (1) The poll name is a label, possibly on one of several
1101              *     poll configurations for the same host.  In this case
1102              *     the `via' option will be present and give the true name.
1103              *
1104              * (2) The poll name is the true one, the via name is
1105              *     localhost.   This is going to be typical for ssh-using
1106              *     configurations.
1107              *
1108              * We're going to assume the via name is true unless it's
1109              * localhost.
1110              */
1111             if (ctl->server.via && strcmp(ctl->server.via, "localhost"))
1112                 ctl->server.queryname = xstrdup(ctl->server.via);
1113             else
1114                 ctl->server.queryname = xstrdup(ctl->server.pollname);
1115
1116 #ifdef HESIOD
1117         /* If either the pollname or vianame are "hesiod" we want to
1118            lookup the user's hesiod pobox host */
1119
1120         if (!strcasecmp(ctl->server.queryname, "hesiod")) {
1121             struct hes_postoffice *hes_p;
1122             hes_p = hes_getmailhost(ctl->remotename);
1123             if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
1124                  free(ctl->server.queryname);
1125                  ctl->server.queryname = xstrdup(hes_p->po_host);
1126                  if (ctl->server.via)
1127                      free(ctl->server.via);
1128                  ctl->server.via = xstrdup(hes_p->po_host);
1129             } else {
1130                  report(stderr,
1131                         _("couldn't find HESIOD pobox for %s\n"),
1132                         ctl->remotename);
1133             }
1134         }
1135 #endif /* HESIOD */
1136
1137             /*
1138              * We may have to canonicalize the server truename for later use.
1139              * Do this just once for each lead server, if necessary, in order
1140              * to minimize DNS round trips.
1141              */
1142             if (ctl->server.lead_server)
1143             {
1144                 char    *leadname = ctl->server.lead_server->truename;
1145
1146                 /* prevent core dump from ill-formed or duplicate entry */
1147                 if (!leadname)
1148                 {
1149                     report(stderr, _("Lead server has no name.\n"));
1150                     exit(PS_SYNTAX);
1151                 }
1152
1153                 ctl->server.truename = xstrdup(leadname);
1154             }
1155 #ifdef HAVE_GETHOSTBYNAME
1156             else if (!configdump && (ctl->server.preauthenticate==A_KERBEROS_V4 ||
1157                 ctl->server.preauthenticate==A_KERBEROS_V5 ||
1158                       (ctl->server.dns && MULTIDROP(ctl))))
1159             {
1160                 struct hostent  *namerec;
1161
1162                 /* compute the canonical name of the host */
1163                 errno = 0;
1164                 namerec = gethostbyname(ctl->server.queryname);
1165                 if (namerec == (struct hostent *)NULL)
1166                 {
1167                     report(stderr,
1168                           _("couldn't find canonical DNS name of %s\n"),
1169                           ctl->server.pollname);
1170                     ctl->server.truename = xstrdup(ctl->server.queryname);
1171                     ctl->server.trueaddr = NULL;
1172                 }
1173                 else
1174                     ctl->server.truename=xstrdup((char *)namerec->h_name);
1175             }
1176 #endif /* HAVE_GETHOSTBYNAME */
1177             else {
1178 #ifdef HAVE_GETHOSTBYNAME
1179               struct hostent    *namerec;
1180
1181               /* <fetchmail@mail.julianhaight.com>
1182                  Get the host's IP, so we can report it like this:
1183
1184                  Received: from hostname [10.0.0.1]
1185
1186                  do we actually need to gethostbyname to find the IP?
1187                  it seems like it would be faster to do this later, when
1188                  we are actually resolving the hostname for a connection,
1189                  but I ain't that smart, so I don't know where to make
1190                  the change later..
1191               */
1192               errno = 0;
1193               namerec = gethostbyname(ctl->server.queryname);
1194               if (namerec == (struct hostent *)NULL)
1195                 {
1196                   report(stderr,
1197                          _("couldn't find canonical DNS name of %s\n"),
1198                          ctl->server.pollname);
1199                   exit(PS_DNS);
1200                 }
1201               else {
1202                 ctl->server.truename=xstrdup((char *)namerec->h_name);
1203                 ctl->server.trueaddr=xmalloc(namerec->h_length);
1204                 memcpy(ctl->server.trueaddr,
1205                        namerec->h_addr_list[0],
1206                        namerec->h_length);
1207               }
1208 #else
1209               ctl->server.truename = xstrdup(ctl->server.queryname);
1210 #endif /* HAVE_GETHOSTBYNAME */
1211             }
1212
1213             /* if no folders were specified, set up the null one as default */
1214             if (!ctl->mailboxes)
1215                 save_str(&ctl->mailboxes, (char *)NULL, 0);
1216
1217             /* maybe user overrode timeout on command line? */
1218             if (ctl->server.timeout == -1)
1219                 ctl->server.timeout = CLIENT_TIMEOUT;
1220
1221 #if !INET6_ENABLE
1222             /* sanity checks */
1223             if (ctl->server.port < 0)
1224             {
1225                 (void) fprintf(stderr,
1226                                _("%s configuration invalid, port number cannot be negative\n"),
1227                                ctl->server.pollname);
1228                 exit(PS_SYNTAX);
1229             }
1230             if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
1231             {
1232                 (void) fprintf(stderr,
1233                                _("%s configuration invalid, RPOP requires a privileged port\n"),
1234                                ctl->server.pollname);
1235                 exit(PS_SYNTAX);
1236             }
1237             if (ctl->listener == LMTP_MODE)
1238             {
1239                 struct idlist   *idp;
1240
1241                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1242                 {
1243                     char        *cp;
1244
1245                     if (!(cp = strrchr(idp->id, '/')) ||
1246                                 (atoi(++cp) == SMTP_PORT))
1247                     {
1248                         (void) fprintf(stderr,
1249                                        _("%s configuration invalid, LMTP can't use default SMTP port\n"),
1250                                        ctl->server.pollname);
1251                         exit(PS_SYNTAX);
1252                     }
1253                 }
1254             }
1255 #endif /* !INET6_ENABLE */
1256
1257             /*
1258              * "I beg to you, have mercy on the week minds like myself."
1259              * wrote Pehr Anderson.  Your petition is granted.
1260              */
1261             if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
1262             {
1263                 (void) fprintf(stderr,
1264                                _("Both fetchall and keep on in daemon mode is a mistake!\n"));
1265                 exit(PS_SYNTAX);
1266             }
1267         }
1268     }
1269
1270 #ifdef POP3_ENABLE
1271     /* initialize UID handling */
1272     if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
1273         exit(st);
1274     else
1275         initialize_saved_lists(querylist, run.idfile);
1276 #endif /* POP3_ENABLE */
1277
1278     /*
1279      * If the user didn't set a last-resort user to get misaddressed
1280      * multidrop mail, set an appropriate default here.
1281      */
1282     if (!run.postmaster)
1283     {
1284         if (getuid())                           /* ordinary user */
1285             run.postmaster = user;
1286         else                                    /* root */
1287             run.postmaster = "postmaster";
1288     }
1289
1290     return(implicitmode);
1291 }
1292
1293 static void terminate_poll(int sig)
1294 /* to be executed at the end of a poll cycle */
1295 {
1296     /*
1297      * Close all SMTP delivery sockets.  For optimum performance
1298      * we'd like to hold them open til end of run, but (1) this
1299      * loses if our poll interval is longer than the MTA's inactivity
1300      * timeout, and (2) some MTAs (like smail) don't deliver after
1301      * each message, but rather queue up mail and wait to actually
1302      * deliver it until the input socket is closed.
1303      *
1304      * Sending SMTP QUIT on signal is theoretically nice, but led to a
1305      * subtle bug.  If fetchmail was terminated by signal while it was
1306      * shipping message text, it would hang forever waiting for a
1307      * command acknowledge.  In theory we could enable the QUIT
1308      * only outside of the message send.  In practice, we don't
1309      * care.  All mailservers hang up on a dropped TCP/IP connection
1310      * anyway.
1311      */
1312
1313     if (sig != 0)
1314         report(stdout, _("terminated with signal %d\n"), sig);
1315     else
1316     {
1317         struct query *ctl;
1318
1319         /* terminate all SMTP connections cleanly */
1320         for (ctl = querylist; ctl; ctl = ctl->next)
1321             if (ctl->smtp_socket != -1)
1322             {
1323                 SMTP_quit(ctl->smtp_socket);
1324                 SockClose(ctl->smtp_socket);
1325                 ctl->smtp_socket = -1;
1326             }
1327     }
1328
1329 #ifdef POP3_ENABLE
1330     /*
1331      * Update UID information at end of each poll, rather than at end
1332      * of run, because that way we don't lose all UIDL information since
1333      * the beginning of time if fetchmail crashes.
1334      */
1335     if (!check_only)
1336         write_saved_lists(querylist, run.idfile);
1337 #endif /* POP3_ENABLE */
1338 }
1339
1340 static void terminate_run(int sig)
1341 /* to be executed on normal or signal-induced termination */
1342 {
1343     struct query        *ctl;
1344
1345     terminate_poll(sig);
1346
1347     /*
1348      * Craig Metz, the RFC1938 one-time-password guy, points out:
1349      * "Remember that most kernels don't zero pages before handing them to the
1350      * next process and many kernels share pages between user and kernel space.
1351      * You'd be very surprised what you can find from a short program to do a
1352      * malloc() and then dump the contents of the pages you got. By zeroing
1353      * the secrets at end of run (earlier if you can), you make sure the next
1354      * guy can't get the password/pass phrase."
1355      *
1356      * Right you are, Craig!
1357      */
1358     for (ctl = querylist; ctl; ctl = ctl->next)
1359         if (ctl->password)
1360           memset(ctl->password, '\0', strlen(ctl->password));
1361
1362 #if !defined(HAVE_ATEXIT) && !defined(HAVE_ON_EXIT)
1363     unlockit();
1364 #endif
1365
1366     if (activecount == 0)
1367         exit(PS_NOMAIL);
1368     else
1369         exit(successes ? PS_SUCCESS : querystatus);
1370 }
1371
1372 /*
1373  * Sequence of protocols to try when autoprobing, most capable to least.
1374  */
1375 static const int autoprobe[] =
1376 {
1377 #ifdef IMAP_ENABLE
1378     P_IMAP,
1379 #endif /* IMAP_ENABLE */
1380 #ifdef POP3_ENABLE
1381     P_POP3,
1382 #endif /* POP3_ENABLE */
1383 #ifdef POP2_ENABLE
1384     P_POP2
1385 #endif /* POP2_ENABLE */
1386 };
1387
1388 static int query_host(struct query *ctl)
1389 /* perform fetch transaction with single host */
1390 {
1391     int i, st;
1392
1393     /*
1394      * If we're syslogging the progress messages are automatically timestamped.
1395      * Force timestamping if we're going to a logfile.
1396      */
1397     if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
1398     {
1399         report(stdout, _("%s querying %s (protocol %s) at %s\n"),
1400                VERSION,
1401                ctl->server.pollname,
1402                showproto(ctl->server.protocol),
1403                timestamp());
1404     }
1405     switch (ctl->server.protocol) {
1406     case P_AUTO:
1407         for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1408         {
1409             ctl->server.protocol = autoprobe[i];
1410             if ((st = query_host(ctl)) == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP)
1411                 break;
1412         }
1413         ctl->server.protocol = P_AUTO;
1414         return(st);
1415     case P_POP2:
1416 #ifdef POP2_ENABLE
1417         return(doPOP2(ctl));
1418 #else
1419         report(stderr, _("POP2 support is not configured.\n"));
1420         return(PS_PROTOCOL);
1421 #endif /* POP2_ENABLE */
1422         break;
1423     case P_POP3:
1424     case P_APOP:
1425     case P_RPOP:
1426 #ifdef POP3_ENABLE
1427         return(doPOP3(ctl));
1428 #else
1429         report(stderr, _("POP3 support is not configured.\n"));
1430         return(PS_PROTOCOL);
1431 #endif /* POP3_ENABLE */
1432         break;
1433     case P_IMAP:
1434     case P_IMAP_K4:
1435     case P_IMAP_CRAM_MD5:
1436     case P_IMAP_LOGIN:
1437 #ifdef GSSAPI
1438     case P_IMAP_GSS:
1439 #endif /* GSSAPI */
1440 #ifdef IMAP_ENABLE
1441         return(doIMAP(ctl));
1442 #else
1443         report(stderr, _("IMAP support is not configured.\n"));
1444         return(PS_PROTOCOL);
1445 #endif /* IMAP_ENABLE */
1446     case P_ETRN:
1447 #ifndef ETRN_ENABLE
1448         report(stderr, _("ETRN support is not configured.\n"));
1449         return(PS_PROTOCOL);
1450 #else
1451 #ifdef HAVE_GETHOSTBYNAME
1452         return(doETRN(ctl));
1453 #else
1454         report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
1455         return(PS_PROTOCOL);
1456 #endif /* HAVE_GETHOSTBYNAME */
1457 #endif /* ETRN_ENABLE */
1458     default:
1459         report(stderr, _("unsupported protocol selected.\n"));
1460         return(PS_PROTOCOL);
1461     }
1462 }
1463
1464 static void dump_params (struct runctl *runp,
1465                          struct query *querylist, flag implicit)
1466 /* display query parameters in English */
1467 {
1468     struct query *ctl;
1469
1470     if (runp->poll_interval)
1471         printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
1472     if (runp->logfile)
1473         printf(_("Logfile is %s\n"), runp->logfile);
1474     if (strcmp(runp->idfile, IDFILE_NAME))
1475         printf(_("Idfile is %s\n"), runp->idfile);
1476 #if defined(HAVE_SYSLOG)
1477     if (runp->use_syslog)
1478         printf(_("Progress messages will be logged via syslog\n"));
1479 #endif
1480     if (runp->invisible)
1481         printf(_("Fetchmail will masquerade and will not generate Received\n"));
1482     if (runp->postmaster)
1483         printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1484                runp->postmaster);
1485
1486     if (!runp->bouncemail)
1487         printf(_("Fetchmail will direct error mail to the postmaster.\n"));
1488     else if (outlevel >= O_VERBOSE)
1489         printf(_("Fetchmail will direct error mail to the sender.\n"));
1490
1491     for (ctl = querylist; ctl; ctl = ctl->next)
1492     {
1493         if (!ctl->active || (implicit && ctl->server.skip))
1494             continue;
1495
1496         printf(_("Options for retrieving from %s@%s:\n"),
1497                ctl->remotename, visbuf(ctl->server.pollname));
1498
1499         if (ctl->server.via && (ctl->server.protocol != P_ETRN))
1500             printf(_("  Mail will be retrieved via %s\n"), ctl->server.via);
1501
1502         if (ctl->server.interval)
1503             printf(_("  Poll of this server will occur every %d intervals.\n"),
1504                    ctl->server.interval);
1505         if (ctl->server.truename)
1506             printf(_("  True name of server is %s.\n"), ctl->server.truename);
1507         if (ctl->server.skip || outlevel >= O_VERBOSE)
1508             printf(_("  This host %s be queried when no host is specified.\n"),
1509                    ctl->server.skip ? _("will not") : _("will"));
1510         /*
1511          * Don't poll for password when there is one or when using the ETRN
1512          * or IMAP-GSS protocol
1513          */
1514         /* ETRN, IMAP_GSS, and IMAP_K4 do not need a password, so skip this */
1515         if ( (ctl->server.protocol != P_ETRN)
1516 #ifdef GSSAPI
1517                                 && (ctl->server.protocol != P_IMAP_GSS)
1518 #endif /* GSSAPI */
1519                                 && (ctl->server.protocol != P_IMAP_K4) ) {
1520                 if (!ctl->password)
1521                         printf(_("  Password will be prompted for.\n"));
1522                 else if (outlevel >= O_VERBOSE)
1523                 {
1524                         if (ctl->server.protocol == P_APOP)
1525                                 printf(_("  APOP secret = \"%s\".\n"),
1526                                                         visbuf(ctl->password));
1527                         else if (ctl->server.protocol == P_RPOP)
1528                                 printf(_("  RPOP id = \"%s\".\n"),
1529                                                         visbuf(ctl->password));
1530                         else
1531                                 printf(_("  Password = \"%s\".\n"),
1532                                                         visbuf(ctl->password));
1533                 }
1534         }
1535
1536         if (ctl->server.protocol == P_POP3
1537 #if INET6_ENABLE
1538             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1539 #else /* INET6_ENABLE */
1540             && ctl->server.port == KPOP_PORT
1541 #endif /* INET6_ENABLE */
1542             && (ctl->server.preauthenticate == A_KERBEROS_V4 ||
1543                 ctl->server.preauthenticate == A_KERBEROS_V5))
1544             printf(_("  Protocol is KPOP with Kerberos %s authentication"),
1545                    ctl->server.preauthenticate == A_KERBEROS_V5 ? "V" : "IV");
1546         else
1547             printf(_("  Protocol is %s"), showproto(ctl->server.protocol));
1548 #if INET6_ENABLE
1549         if (ctl->server.service)
1550             printf(_(" (using service %s)"), ctl->server.service);
1551         if (ctl->server.netsec)
1552             printf(_(" (using network security options %s)"), ctl->server.netsec);
1553 #else /* INET6_ENABLE */
1554         if (ctl->server.port)
1555             printf(_(" (using port %d)"), ctl->server.port);
1556 #endif /* INET6_ENABLE */
1557         else if (outlevel >= O_VERBOSE)
1558             printf(_(" (using default port)"));
1559         if (ctl->server.uidl && (ctl->server.protocol != P_ETRN))
1560             printf(_(" (forcing UIDL use)"));
1561         putchar('.');
1562         putchar('\n');
1563         if (ctl->server.preauthenticate == A_KERBEROS_V4)
1564             printf(_("  Kerberos V4 preauthentication enabled.\n"));
1565         else if (ctl->server.preauthenticate == A_KERBEROS_V5)
1566             printf(_("  Kerberos V5 preauthentication enabled.\n"));
1567         else if (ctl->server.preauthenticate == A_SSH)
1568             printf(_("  End-to-end encryption assumed.\n"));
1569 #ifdef  SSL_ENABLE
1570         if (ctl->use_ssl)
1571             printf("  SSL encrypted sessions enabled.\n");
1572 #endif
1573         if (ctl->server.timeout > 0)
1574             printf(_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1575         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
1576             printf(_(" (default).\n"));
1577         else
1578             printf(".\n");
1579
1580         if (ctl->server.protocol != P_ETRN) {
1581                 if (!ctl->mailboxes->id)
1582                     printf(_("  Default mailbox selected.\n"));
1583                 else
1584                 {
1585                     struct idlist *idp;
1586
1587                     printf(_("  Selected mailboxes are:"));
1588                     for (idp = ctl->mailboxes; idp; idp = idp->next)
1589                         printf(" %s", idp->id);
1590                     printf("\n");
1591                 }
1592                 printf(_("  %s messages will be retrieved (--all %s).\n"),
1593                        ctl->fetchall ? _("All") : _("Only new"),
1594                        ctl->fetchall ? "on" : "off");
1595                 printf(_("  Fetched messages %s be kept on the server (--keep %s).\n"),
1596                        ctl->keep ? _("will") : _("will not"),
1597                        ctl->keep ? "on" : "off");
1598                 printf(_("  Old messages %s be flushed before message retrieval (--flush %s).\n"),
1599                        ctl->flush ? _("will") : _("will not"),
1600                        ctl->flush ? "on" : "off");
1601                 printf(_("  Rewrite of server-local addresses is %s (--norewrite %s).\n"),
1602                        ctl->rewrite ? _("enabled") : _("disabled"),
1603                        ctl->rewrite ? "off" : "on");
1604                 printf(_("  Carriage-return stripping is %s (stripcr %s).\n"),
1605                        ctl->stripcr ? _("enabled") : _("disabled"),
1606                        ctl->stripcr ? "on" : "off");
1607                 printf(_("  Carriage-return forcing is %s (forcecr %s).\n"),
1608                        ctl->forcecr ? _("enabled") : _("disabled"),
1609                        ctl->forcecr ? "on" : "off");
1610                 printf(_("  Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
1611                        ctl->pass8bits ? _("disabled") : _("enabled"),
1612                        ctl->pass8bits ? "on" : "off");
1613                 printf(_("  MIME decoding is %s (mimedecode %s).\n"),
1614                        ctl->mimedecode ? _("enabled") : _("disabled"),
1615                        ctl->mimedecode ? "on" : "off");
1616                 printf(_("  Idle after poll is %s (idle %s).\n"),
1617                        ctl->idle ? _("enabled") : _("disabled"),
1618                        ctl->idle ? "on" : "off");
1619                 printf(_("  Nonempty Status lines will be %s (dropstatus %s)\n"),
1620                        ctl->dropstatus ? _("discarded") : _("kept"),
1621                        ctl->dropstatus ? "on" : "off");
1622                 printf(_("  Delivered-To lines will be %s (dropdelivered %s)\n"),
1623                        ctl->dropdelivered ? _("discarded") : _("kept"),
1624                        ctl->dropdelivered ? "on" : "off");
1625                 if (NUM_NONZERO(ctl->limit))
1626                 {
1627                     if (NUM_NONZERO(ctl->limit))
1628                         printf(_("  Message size limit is %d octets (--limit %d).\n"),
1629                                ctl->limit, ctl->limit);
1630                     else if (outlevel >= O_VERBOSE)
1631                         printf(_("  No message size limit (--limit 0).\n"));
1632                     if (run.poll_interval > 0)
1633                         printf(_("  Message size warning interval is %d seconds (--warnings %d).\n"),
1634                                ctl->warnings, ctl->warnings);
1635                     else if (outlevel >= O_VERBOSE)
1636                         printf(_("  Size warnings on every poll (--warnings 0).\n"));
1637                 }
1638                 if (NUM_NONZERO(ctl->fetchlimit))
1639                     printf(_("  Received-message limit is %d (--fetchlimit %d).\n"),
1640                            ctl->fetchlimit, ctl->fetchlimit);
1641                 else if (outlevel >= O_VERBOSE)
1642                     printf(_("  No received-message limit (--fetchlimit 0).\n"));
1643                 if (NUM_NONZERO(ctl->batchlimit))
1644                     printf(_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
1645                 else if (outlevel >= O_VERBOSE)
1646                     printf(_("  No SMTP message batch limit (--batchlimit 0).\n"));
1647                 if (ctl->server.protocol != P_ETRN)
1648                 {
1649                     if (NUM_NONZERO(ctl->expunge))
1650                         printf(_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1651                     else if (outlevel >= O_VERBOSE)
1652                         printf(_("  No forced expunges (--expunge 0).\n"));
1653                 }
1654         }
1655         if (ctl->bsmtp)
1656             printf(_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1657         else if (ctl->mda && (ctl->server.protocol != P_ETRN))
1658             printf(_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1659         else
1660         {
1661             struct idlist *idp;
1662
1663             printf(_("  Messages will be %cMTP-forwarded to:"), ctl->listener);
1664             for (idp = ctl->smtphunt; idp; idp = idp->next)
1665             {
1666                 printf(" %s", idp->id);
1667                 if (!idp->val.status.mark)
1668                     printf(_(" (default)"));
1669             }
1670             printf("\n");
1671             if (ctl->smtpaddress)
1672                 printf(_("  Host part of MAIL FROM line will be %s\n"),
1673                        ctl->smtpaddress);
1674         }
1675         if (ctl->server.protocol != P_ETRN)
1676         {
1677                 if (ctl->antispam != (struct idlist *)NULL)
1678                 {
1679                     struct idlist *idp;
1680
1681                     printf(_("  Recognized listener spam block responses are:"));
1682                     for (idp = ctl->antispam; idp; idp = idp->next)
1683                         printf(" %d", idp->val.status.num);
1684                     printf("\n");
1685                 }
1686                 else if (outlevel >= O_VERBOSE)
1687                     printf(_("  Spam-blocking disabled\n"));
1688         }
1689         if (ctl->preconnect)
1690             printf(_("  Server connection will be brought up with \"%s\".\n"),
1691                    visbuf(ctl->preconnect));
1692         else if (outlevel >= O_VERBOSE)
1693             printf(_("  No pre-connection command.\n"));
1694         if (ctl->postconnect)
1695             printf(_("  Server connection will be taken down with \"%s\".\n"),
1696                    visbuf(ctl->postconnect));
1697         else if (outlevel >= O_VERBOSE)
1698             printf(_("  No post-connection command.\n"));
1699         if (ctl->server.protocol != P_ETRN) {
1700                 if (!ctl->localnames)
1701                     printf(_("  No localnames declared for this host.\n"));
1702                 else
1703                 {
1704                     struct idlist *idp;
1705                     int count = 0;
1706
1707                     for (idp = ctl->localnames; idp; idp = idp->next)
1708                         ++count;
1709
1710                     if (count > 1 || ctl->wildcard)
1711                         printf(_("  Multi-drop mode: "));
1712                     else
1713                         printf(_("  Single-drop mode: "));
1714
1715                     printf(_("%d local name(s) recognized.\n"), count);
1716                     if (outlevel >= O_VERBOSE)
1717                     {
1718                         for (idp = ctl->localnames; idp; idp = idp->next)
1719                             if (idp->val.id2)
1720                                 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1721                             else
1722                                 printf("\t%s\n", idp->id);
1723                         if (ctl->wildcard)
1724                             fputs("\t*\n", stdout);
1725                     }
1726
1727                     if (count > 1 || ctl->wildcard)
1728                     {
1729                         printf(_("  DNS lookup for multidrop addresses is %s.\n"),
1730                                ctl->server.dns ? _("enabled") : _("disabled"));
1731                         if (ctl->server.dns)
1732                         {
1733                             printf(_("  Server aliases will be compared with multidrop addresses by "));
1734                             if (ctl->server.checkalias)
1735                                 printf(_("IP address.\n"));
1736                             else
1737                                 printf(_("name.\n"));
1738                         }
1739                         if (ctl->server.envelope == STRING_DISABLED)
1740                             printf(_("  Envelope-address routing is disabled\n"));
1741                         else
1742                         {
1743                             printf(_("  Envelope header is assumed to be: %s\n"),
1744                                    ctl->server.envelope ? ctl->server.envelope:_("Received"));
1745                             if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
1746                                 printf(_("  Number of envelope header to be parsed: %d\n"),
1747                                        ctl->server.envskip);
1748                             if (ctl->server.qvirtual)
1749                                 printf(_("  Prefix %s will be removed from user id\n"),
1750                                        ctl->server.qvirtual);
1751                             else if (outlevel >= O_VERBOSE)
1752                                 printf(_("  No prefix stripping\n"));
1753                         }
1754
1755                         if (ctl->server.akalist)
1756                         {
1757                             struct idlist *idp;
1758
1759                             printf(_("  Predeclared mailserver aliases:"));
1760                             for (idp = ctl->server.akalist; idp; idp = idp->next)
1761                                 printf(" %s", idp->id);
1762                             putchar('\n');
1763                         }
1764                         if (ctl->server.localdomains)
1765                         {
1766                             struct idlist *idp;
1767
1768                             printf(_("  Local domains:"));
1769                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
1770                                 printf(" %s", idp->id);
1771                             putchar('\n');
1772                         }
1773                     }
1774                 }
1775         }
1776 #if defined(linux) || defined(__FreeBSD__)
1777         if (ctl->server.interface)
1778             printf(_("  Connection must be through interface %s.\n"), ctl->server.interface);
1779         else if (outlevel >= O_VERBOSE)
1780             printf(_("  No interface requirement specified.\n"));
1781         if (ctl->server.monitor)
1782             printf(_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
1783         else if (outlevel >= O_VERBOSE)
1784             printf(_("  No monitor interface specified.\n"));
1785 #endif
1786
1787         if (ctl->server.plugin)
1788             printf(_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1789         else if (outlevel >= O_VERBOSE)
1790             printf(_("  No plugin command specified.\n"));
1791         if (ctl->server.plugout)
1792             printf(_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1793         else if (outlevel >= O_VERBOSE)
1794             printf(_("  No plugout command specified.\n"));
1795
1796         if (ctl->server.protocol > P_POP2 && (ctl->server.protocol != P_ETRN))
1797         {
1798             if (!ctl->oldsaved)
1799                 printf(_("  No UIDs saved from this host.\n"));
1800             else
1801             {
1802                 struct idlist *idp;
1803                 int count = 0;
1804
1805                 for (idp = ctl->oldsaved; idp; idp = idp->next)
1806                     ++count;
1807
1808                 printf(_("  %d UIDs saved.\n"), count);
1809                 if (outlevel >= O_VERBOSE)
1810                     for (idp = ctl->oldsaved; idp; idp = idp->next)
1811                         printf("\t%s\n", idp->id);
1812             }
1813         }
1814
1815         if (ctl->properties)
1816             printf(_("  Pass-through properties \"%s\".\n"),
1817                    visbuf(ctl->properties));
1818     }
1819 }
1820
1821 /* fetchmail.c ends here */