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)
1157             {
1158                 if (ctl->server.preauthenticate==A_KERBEROS_V4 ||
1159                       ctl->server.preauthenticate==A_KERBEROS_V5 ||
1160                     (ctl->server.dns && MULTIDROP(ctl)))
1161                 {
1162                     struct hostent      *namerec;
1163
1164                     /* compute the canonical name of the host */
1165                     errno = 0;
1166                     namerec = gethostbyname(ctl->server.queryname);
1167                     if (namerec == (struct hostent *)NULL)
1168                     {
1169                         report(stderr,
1170                                _("couldn't find canonical DNS name of %s\n"),
1171                                ctl->server.pollname);
1172                         ctl->server.truename = xstrdup(ctl->server.queryname);
1173                         ctl->server.trueaddr = NULL;
1174                     }
1175                     else
1176                         ctl->server.truename=xstrdup((char *)namerec->h_name);
1177                 }
1178 #endif /* HAVE_GETHOSTBYNAME */
1179                 else {
1180 #ifdef HAVE_GETHOSTBYNAME
1181                     struct hostent      *namerec;
1182
1183                     /* <fetchmail@mail.julianhaight.com>
1184                        Get the host's IP, so we can report it like this:
1185
1186                        Received: from hostname [10.0.0.1]
1187
1188                        do we actually need to gethostbyname to find the IP?
1189                        it seems like it would be faster to do this later, when
1190                        we are actually resolving the hostname for a connection,
1191                        but I ain't that smart, so I don't know where to make
1192                        the change later..
1193                     */
1194                     errno = 0;
1195                     namerec = gethostbyname(ctl->server.queryname);
1196                     if (namerec == (struct hostent *)NULL)
1197                     {
1198                         report(stderr,
1199                                _("couldn't find canonical DNS name of %s\n"),
1200                                ctl->server.pollname);
1201                         exit(PS_DNS);
1202                     }
1203                     else {
1204                         ctl->server.truename=xstrdup((char *)namerec->h_name);
1205                         ctl->server.trueaddr=xmalloc(namerec->h_length);
1206                         memcpy(ctl->server.trueaddr,
1207                                namerec->h_addr_list[0],
1208                                namerec->h_length);
1209                     }
1210 #else
1211                     ctl->server.truename = xstrdup(ctl->server.queryname);
1212 #endif /* HAVE_GETHOSTBYNAME */
1213                 }
1214             }
1215
1216             /* if no folders were specified, set up the null one as default */
1217             if (!ctl->mailboxes)
1218                 save_str(&ctl->mailboxes, (char *)NULL, 0);
1219
1220             /* maybe user overrode timeout on command line? */
1221             if (ctl->server.timeout == -1)
1222                 ctl->server.timeout = CLIENT_TIMEOUT;
1223
1224 #if !INET6_ENABLE
1225             /* sanity checks */
1226             if (ctl->server.port < 0)
1227             {
1228                 (void) fprintf(stderr,
1229                                _("%s configuration invalid, port number cannot be negative\n"),
1230                                ctl->server.pollname);
1231                 exit(PS_SYNTAX);
1232             }
1233             if (ctl->server.protocol == P_RPOP && ctl->server.port >= 1024)
1234             {
1235                 (void) fprintf(stderr,
1236                                _("%s configuration invalid, RPOP requires a privileged port\n"),
1237                                ctl->server.pollname);
1238                 exit(PS_SYNTAX);
1239             }
1240             if (ctl->listener == LMTP_MODE)
1241             {
1242                 struct idlist   *idp;
1243
1244                 for (idp = ctl->smtphunt; idp; idp = idp->next)
1245                 {
1246                     char        *cp;
1247
1248                     if (!(cp = strrchr(idp->id, '/')) ||
1249                                 (atoi(++cp) == SMTP_PORT))
1250                     {
1251                         (void) fprintf(stderr,
1252                                        _("%s configuration invalid, LMTP can't use default SMTP port\n"),
1253                                        ctl->server.pollname);
1254                         exit(PS_SYNTAX);
1255                     }
1256                 }
1257             }
1258 #endif /* !INET6_ENABLE */
1259
1260             /*
1261              * "I beg to you, have mercy on the week minds like myself."
1262              * wrote Pehr Anderson.  Your petition is granted.
1263              */
1264             if (ctl->fetchall && ctl->keep && run.poll_interval && !nodetach)
1265             {
1266                 (void) fprintf(stderr,
1267                                _("Both fetchall and keep on in daemon mode is a mistake!\n"));
1268                 exit(PS_SYNTAX);
1269             }
1270         }
1271     }
1272
1273 #ifdef POP3_ENABLE
1274     /* initialize UID handling */
1275     if (!versioninfo && (st = prc_filecheck(run.idfile, !versioninfo)) != 0)
1276         exit(st);
1277     else
1278         initialize_saved_lists(querylist, run.idfile);
1279 #endif /* POP3_ENABLE */
1280
1281     /*
1282      * If the user didn't set a last-resort user to get misaddressed
1283      * multidrop mail, set an appropriate default here.
1284      */
1285     if (!run.postmaster)
1286     {
1287         if (getuid())                           /* ordinary user */
1288             run.postmaster = user;
1289         else                                    /* root */
1290             run.postmaster = "postmaster";
1291     }
1292
1293     return(implicitmode);
1294 }
1295
1296 static void terminate_poll(int sig)
1297 /* to be executed at the end of a poll cycle */
1298 {
1299     /*
1300      * Close all SMTP delivery sockets.  For optimum performance
1301      * we'd like to hold them open til end of run, but (1) this
1302      * loses if our poll interval is longer than the MTA's inactivity
1303      * timeout, and (2) some MTAs (like smail) don't deliver after
1304      * each message, but rather queue up mail and wait to actually
1305      * deliver it until the input socket is closed.
1306      *
1307      * Sending SMTP QUIT on signal is theoretically nice, but led to a
1308      * subtle bug.  If fetchmail was terminated by signal while it was
1309      * shipping message text, it would hang forever waiting for a
1310      * command acknowledge.  In theory we could enable the QUIT
1311      * only outside of the message send.  In practice, we don't
1312      * care.  All mailservers hang up on a dropped TCP/IP connection
1313      * anyway.
1314      */
1315
1316     if (sig != 0)
1317         report(stdout, _("terminated with signal %d\n"), sig);
1318     else
1319     {
1320         struct query *ctl;
1321
1322         /* terminate all SMTP connections cleanly */
1323         for (ctl = querylist; ctl; ctl = ctl->next)
1324             if (ctl->smtp_socket != -1)
1325             {
1326                 SMTP_quit(ctl->smtp_socket);
1327                 SockClose(ctl->smtp_socket);
1328                 ctl->smtp_socket = -1;
1329             }
1330     }
1331
1332 #ifdef POP3_ENABLE
1333     /*
1334      * Update UID information at end of each poll, rather than at end
1335      * of run, because that way we don't lose all UIDL information since
1336      * the beginning of time if fetchmail crashes.
1337      */
1338     if (!check_only)
1339         write_saved_lists(querylist, run.idfile);
1340 #endif /* POP3_ENABLE */
1341 }
1342
1343 static void terminate_run(int sig)
1344 /* to be executed on normal or signal-induced termination */
1345 {
1346     struct query        *ctl;
1347
1348     terminate_poll(sig);
1349
1350     /*
1351      * Craig Metz, the RFC1938 one-time-password guy, points out:
1352      * "Remember that most kernels don't zero pages before handing them to the
1353      * next process and many kernels share pages between user and kernel space.
1354      * You'd be very surprised what you can find from a short program to do a
1355      * malloc() and then dump the contents of the pages you got. By zeroing
1356      * the secrets at end of run (earlier if you can), you make sure the next
1357      * guy can't get the password/pass phrase."
1358      *
1359      * Right you are, Craig!
1360      */
1361     for (ctl = querylist; ctl; ctl = ctl->next)
1362         if (ctl->password)
1363           memset(ctl->password, '\0', strlen(ctl->password));
1364
1365 #if !defined(HAVE_ATEXIT) && !defined(HAVE_ON_EXIT)
1366     unlockit();
1367 #endif
1368
1369     if (activecount == 0)
1370         exit(PS_NOMAIL);
1371     else
1372         exit(successes ? PS_SUCCESS : querystatus);
1373 }
1374
1375 /*
1376  * Sequence of protocols to try when autoprobing, most capable to least.
1377  */
1378 static const int autoprobe[] =
1379 {
1380 #ifdef IMAP_ENABLE
1381     P_IMAP,
1382 #endif /* IMAP_ENABLE */
1383 #ifdef POP3_ENABLE
1384     P_POP3,
1385 #endif /* POP3_ENABLE */
1386 #ifdef POP2_ENABLE
1387     P_POP2
1388 #endif /* POP2_ENABLE */
1389 };
1390
1391 static int query_host(struct query *ctl)
1392 /* perform fetch transaction with single host */
1393 {
1394     int i, st;
1395
1396     /*
1397      * If we're syslogging the progress messages are automatically timestamped.
1398      * Force timestamping if we're going to a logfile.
1399      */
1400     if (outlevel >= O_VERBOSE || (run.logfile && outlevel > O_SILENT))
1401     {
1402         report(stdout, _("%s querying %s (protocol %s) at %s\n"),
1403                VERSION,
1404                ctl->server.pollname,
1405                showproto(ctl->server.protocol),
1406                timestamp());
1407     }
1408     switch (ctl->server.protocol) {
1409     case P_AUTO:
1410         for (i = 0; i < sizeof(autoprobe)/sizeof(autoprobe[0]); i++)
1411         {
1412             ctl->server.protocol = autoprobe[i];
1413             if ((st = query_host(ctl)) == PS_SUCCESS || st == PS_NOMAIL || st == PS_AUTHFAIL || st == PS_LOCKBUSY || st == PS_SMTP)
1414                 break;
1415         }
1416         ctl->server.protocol = P_AUTO;
1417         return(st);
1418     case P_POP2:
1419 #ifdef POP2_ENABLE
1420         return(doPOP2(ctl));
1421 #else
1422         report(stderr, _("POP2 support is not configured.\n"));
1423         return(PS_PROTOCOL);
1424 #endif /* POP2_ENABLE */
1425         break;
1426     case P_POP3:
1427     case P_APOP:
1428     case P_RPOP:
1429 #ifdef POP3_ENABLE
1430         return(doPOP3(ctl));
1431 #else
1432         report(stderr, _("POP3 support is not configured.\n"));
1433         return(PS_PROTOCOL);
1434 #endif /* POP3_ENABLE */
1435         break;
1436     case P_IMAP:
1437     case P_IMAP_K4:
1438     case P_IMAP_CRAM_MD5:
1439     case P_IMAP_LOGIN:
1440 #ifdef GSSAPI
1441     case P_IMAP_GSS:
1442 #endif /* GSSAPI */
1443 #ifdef IMAP_ENABLE
1444         return(doIMAP(ctl));
1445 #else
1446         report(stderr, _("IMAP support is not configured.\n"));
1447         return(PS_PROTOCOL);
1448 #endif /* IMAP_ENABLE */
1449     case P_ETRN:
1450 #ifndef ETRN_ENABLE
1451         report(stderr, _("ETRN support is not configured.\n"));
1452         return(PS_PROTOCOL);
1453 #else
1454 #ifdef HAVE_GETHOSTBYNAME
1455         return(doETRN(ctl));
1456 #else
1457         report(stderr, _("Cannot support ETRN without gethostbyname(2).\n"));
1458         return(PS_PROTOCOL);
1459 #endif /* HAVE_GETHOSTBYNAME */
1460 #endif /* ETRN_ENABLE */
1461     default:
1462         report(stderr, _("unsupported protocol selected.\n"));
1463         return(PS_PROTOCOL);
1464     }
1465 }
1466
1467 static void dump_params (struct runctl *runp,
1468                          struct query *querylist, flag implicit)
1469 /* display query parameters in English */
1470 {
1471     struct query *ctl;
1472
1473     if (runp->poll_interval)
1474         printf(_("Poll interval is %d seconds\n"), runp->poll_interval);
1475     if (runp->logfile)
1476         printf(_("Logfile is %s\n"), runp->logfile);
1477     if (strcmp(runp->idfile, IDFILE_NAME))
1478         printf(_("Idfile is %s\n"), runp->idfile);
1479 #if defined(HAVE_SYSLOG)
1480     if (runp->use_syslog)
1481         printf(_("Progress messages will be logged via syslog\n"));
1482 #endif
1483     if (runp->invisible)
1484         printf(_("Fetchmail will masquerade and will not generate Received\n"));
1485     if (runp->showdots)
1486         printf(_("Fetchmail will show progress dots even in logfiles\n"));
1487     if (runp->postmaster)
1488         printf(_("Fetchmail will forward misaddressed multidrop messages to %s.\n"),
1489                runp->postmaster);
1490
1491     if (!runp->bouncemail)
1492         printf(_("Fetchmail will direct error mail to the postmaster.\n"));
1493     else if (outlevel >= O_VERBOSE)
1494         printf(_("Fetchmail will direct error mail to the sender.\n"));
1495
1496     for (ctl = querylist; ctl; ctl = ctl->next)
1497     {
1498         if (!ctl->active || (implicit && ctl->server.skip))
1499             continue;
1500
1501         printf(_("Options for retrieving from %s@%s:\n"),
1502                ctl->remotename, visbuf(ctl->server.pollname));
1503
1504         if (ctl->server.via && (ctl->server.protocol != P_ETRN))
1505             printf(_("  Mail will be retrieved via %s\n"), ctl->server.via);
1506
1507         if (ctl->server.interval)
1508             printf(_("  Poll of this server will occur every %d intervals.\n"),
1509                    ctl->server.interval);
1510         if (ctl->server.truename)
1511             printf(_("  True name of server is %s.\n"), ctl->server.truename);
1512         if (ctl->server.skip || outlevel >= O_VERBOSE)
1513             printf(_("  This host %s be queried when no host is specified.\n"),
1514                    ctl->server.skip ? _("will not") : _("will"));
1515         /*
1516          * Don't poll for password when there is one or when using the ETRN
1517          * or IMAP-GSS protocol
1518          */
1519         /* ETRN, IMAP_GSS, and IMAP_K4 do not need a password, so skip this */
1520         if ( (ctl->server.protocol != P_ETRN)
1521 #ifdef GSSAPI
1522                                 && (ctl->server.protocol != P_IMAP_GSS)
1523 #endif /* GSSAPI */
1524                                 && (ctl->server.protocol != P_IMAP_K4) ) {
1525                 if (!ctl->password)
1526                         printf(_("  Password will be prompted for.\n"));
1527                 else if (outlevel >= O_VERBOSE)
1528                 {
1529                         if (ctl->server.protocol == P_APOP)
1530                                 printf(_("  APOP secret = \"%s\".\n"),
1531                                                         visbuf(ctl->password));
1532                         else if (ctl->server.protocol == P_RPOP)
1533                                 printf(_("  RPOP id = \"%s\".\n"),
1534                                                         visbuf(ctl->password));
1535                         else
1536                                 printf(_("  Password = \"%s\".\n"),
1537                                                         visbuf(ctl->password));
1538                 }
1539         }
1540
1541         if (ctl->server.protocol == P_POP3
1542 #if INET6_ENABLE
1543             && ctl->server.service && !strcmp(ctl->server.service, KPOP_PORT)
1544 #else /* INET6_ENABLE */
1545             && ctl->server.port == KPOP_PORT
1546 #endif /* INET6_ENABLE */
1547             && (ctl->server.preauthenticate == A_KERBEROS_V4 ||
1548                 ctl->server.preauthenticate == A_KERBEROS_V5))
1549             printf(_("  Protocol is KPOP with Kerberos %s authentication"),
1550                    ctl->server.preauthenticate == A_KERBEROS_V5 ? "V" : "IV");
1551         else
1552             printf(_("  Protocol is %s"), showproto(ctl->server.protocol));
1553 #if INET6_ENABLE
1554         if (ctl->server.service)
1555             printf(_(" (using service %s)"), ctl->server.service);
1556         if (ctl->server.netsec)
1557             printf(_(" (using network security options %s)"), ctl->server.netsec);
1558 #else /* INET6_ENABLE */
1559         if (ctl->server.port)
1560             printf(_(" (using port %d)"), ctl->server.port);
1561 #endif /* INET6_ENABLE */
1562         else if (outlevel >= O_VERBOSE)
1563             printf(_(" (using default port)"));
1564         if (ctl->server.uidl && (ctl->server.protocol != P_ETRN))
1565             printf(_(" (forcing UIDL use)"));
1566         putchar('.');
1567         putchar('\n');
1568         if (ctl->server.preauthenticate == A_KERBEROS_V4)
1569             printf(_("  Kerberos V4 preauthentication enabled.\n"));
1570         else if (ctl->server.preauthenticate == A_KERBEROS_V5)
1571             printf(_("  Kerberos V5 preauthentication enabled.\n"));
1572         else if (ctl->server.preauthenticate == A_SSH)
1573             printf(_("  End-to-end encryption assumed.\n"));
1574 #ifdef  SSL_ENABLE
1575         if (ctl->use_ssl)
1576             printf("  SSL encrypted sessions enabled.\n");
1577 #endif
1578         if (ctl->server.timeout > 0)
1579             printf(_("  Server nonresponse timeout is %d seconds"), ctl->server.timeout);
1580         if (ctl->server.timeout ==  CLIENT_TIMEOUT)
1581             printf(_(" (default).\n"));
1582         else
1583             printf(".\n");
1584
1585         if (ctl->server.protocol != P_ETRN) {
1586                 if (!ctl->mailboxes->id)
1587                     printf(_("  Default mailbox selected.\n"));
1588                 else
1589                 {
1590                     struct idlist *idp;
1591
1592                     printf(_("  Selected mailboxes are:"));
1593                     for (idp = ctl->mailboxes; idp; idp = idp->next)
1594                         printf(" %s", idp->id);
1595                     printf("\n");
1596                 }
1597                 printf(_("  %s messages will be retrieved (--all %s).\n"),
1598                        ctl->fetchall ? _("All") : _("Only new"),
1599                        ctl->fetchall ? "on" : "off");
1600                 printf(_("  Fetched messages %s be kept on the server (--keep %s).\n"),
1601                        ctl->keep ? _("will") : _("will not"),
1602                        ctl->keep ? "on" : "off");
1603                 printf(_("  Old messages %s be flushed before message retrieval (--flush %s).\n"),
1604                        ctl->flush ? _("will") : _("will not"),
1605                        ctl->flush ? "on" : "off");
1606                 printf(_("  Rewrite of server-local addresses is %s (--norewrite %s).\n"),
1607                        ctl->rewrite ? _("enabled") : _("disabled"),
1608                        ctl->rewrite ? "off" : "on");
1609                 printf(_("  Carriage-return stripping is %s (stripcr %s).\n"),
1610                        ctl->stripcr ? _("enabled") : _("disabled"),
1611                        ctl->stripcr ? "on" : "off");
1612                 printf(_("  Carriage-return forcing is %s (forcecr %s).\n"),
1613                        ctl->forcecr ? _("enabled") : _("disabled"),
1614                        ctl->forcecr ? "on" : "off");
1615                 printf(_("  Interpretation of Content-Transfer-Encoding is %s (pass8bits %s).\n"),
1616                        ctl->pass8bits ? _("disabled") : _("enabled"),
1617                        ctl->pass8bits ? "on" : "off");
1618                 printf(_("  MIME decoding is %s (mimedecode %s).\n"),
1619                        ctl->mimedecode ? _("enabled") : _("disabled"),
1620                        ctl->mimedecode ? "on" : "off");
1621                 printf(_("  Idle after poll is %s (idle %s).\n"),
1622                        ctl->idle ? _("enabled") : _("disabled"),
1623                        ctl->idle ? "on" : "off");
1624                 printf(_("  Nonempty Status lines will be %s (dropstatus %s)\n"),
1625                        ctl->dropstatus ? _("discarded") : _("kept"),
1626                        ctl->dropstatus ? "on" : "off");
1627                 printf(_("  Delivered-To lines will be %s (dropdelivered %s)\n"),
1628                        ctl->dropdelivered ? _("discarded") : _("kept"),
1629                        ctl->dropdelivered ? "on" : "off");
1630                 if (NUM_NONZERO(ctl->limit))
1631                 {
1632                     if (NUM_NONZERO(ctl->limit))
1633                         printf(_("  Message size limit is %d octets (--limit %d).\n"),
1634                                ctl->limit, ctl->limit);
1635                     else if (outlevel >= O_VERBOSE)
1636                         printf(_("  No message size limit (--limit 0).\n"));
1637                     if (run.poll_interval > 0)
1638                         printf(_("  Message size warning interval is %d seconds (--warnings %d).\n"),
1639                                ctl->warnings, ctl->warnings);
1640                     else if (outlevel >= O_VERBOSE)
1641                         printf(_("  Size warnings on every poll (--warnings 0).\n"));
1642                 }
1643                 if (NUM_NONZERO(ctl->fetchlimit))
1644                     printf(_("  Received-message limit is %d (--fetchlimit %d).\n"),
1645                            ctl->fetchlimit, ctl->fetchlimit);
1646                 else if (outlevel >= O_VERBOSE)
1647                     printf(_("  No received-message limit (--fetchlimit 0).\n"));
1648                 if (NUM_NONZERO(ctl->batchlimit))
1649                     printf(_("  SMTP message batch limit is %d.\n"), ctl->batchlimit);
1650                 else if (outlevel >= O_VERBOSE)
1651                     printf(_("  No SMTP message batch limit (--batchlimit 0).\n"));
1652                 if (ctl->server.protocol != P_ETRN)
1653                 {
1654                     if (NUM_NONZERO(ctl->expunge))
1655                         printf(_("  Deletion interval between expunges forced to %d (--expunge %d).\n"), ctl->expunge, ctl->expunge);
1656                     else if (outlevel >= O_VERBOSE)
1657                         printf(_("  No forced expunges (--expunge 0).\n"));
1658                 }
1659         }
1660         if (ctl->bsmtp)
1661             printf(_("  Messages will be appended to %s as BSMTP\n"), visbuf(ctl->bsmtp));
1662         else if (ctl->mda && (ctl->server.protocol != P_ETRN))
1663             printf(_("  Messages will be delivered with \"%s\".\n"), visbuf(ctl->mda));
1664         else
1665         {
1666             struct idlist *idp;
1667
1668             printf(_("  Messages will be %cMTP-forwarded to:"), ctl->listener);
1669             for (idp = ctl->smtphunt; idp; idp = idp->next)
1670             {
1671                 printf(" %s", idp->id);
1672                 if (!idp->val.status.mark)
1673                     printf(_(" (default)"));
1674             }
1675             printf("\n");
1676             if (ctl->smtpaddress)
1677                 printf(_("  Host part of MAIL FROM line will be %s\n"),
1678                        ctl->smtpaddress);
1679         }
1680         if (ctl->server.protocol != P_ETRN)
1681         {
1682                 if (ctl->antispam != (struct idlist *)NULL)
1683                 {
1684                     struct idlist *idp;
1685
1686                     printf(_("  Recognized listener spam block responses are:"));
1687                     for (idp = ctl->antispam; idp; idp = idp->next)
1688                         printf(" %d", idp->val.status.num);
1689                     printf("\n");
1690                 }
1691                 else if (outlevel >= O_VERBOSE)
1692                     printf(_("  Spam-blocking disabled\n"));
1693         }
1694         if (ctl->preconnect)
1695             printf(_("  Server connection will be brought up with \"%s\".\n"),
1696                    visbuf(ctl->preconnect));
1697         else if (outlevel >= O_VERBOSE)
1698             printf(_("  No pre-connection command.\n"));
1699         if (ctl->postconnect)
1700             printf(_("  Server connection will be taken down with \"%s\".\n"),
1701                    visbuf(ctl->postconnect));
1702         else if (outlevel >= O_VERBOSE)
1703             printf(_("  No post-connection command.\n"));
1704         if (ctl->server.protocol != P_ETRN) {
1705                 if (!ctl->localnames)
1706                     printf(_("  No localnames declared for this host.\n"));
1707                 else
1708                 {
1709                     struct idlist *idp;
1710                     int count = 0;
1711
1712                     for (idp = ctl->localnames; idp; idp = idp->next)
1713                         ++count;
1714
1715                     if (count > 1 || ctl->wildcard)
1716                         printf(_("  Multi-drop mode: "));
1717                     else
1718                         printf(_("  Single-drop mode: "));
1719
1720                     printf(_("%d local name(s) recognized.\n"), count);
1721                     if (outlevel >= O_VERBOSE)
1722                     {
1723                         for (idp = ctl->localnames; idp; idp = idp->next)
1724                             if (idp->val.id2)
1725                                 printf("\t%s -> %s\n", idp->id, idp->val.id2);
1726                             else
1727                                 printf("\t%s\n", idp->id);
1728                         if (ctl->wildcard)
1729                             fputs("\t*\n", stdout);
1730                     }
1731
1732                     if (count > 1 || ctl->wildcard)
1733                     {
1734                         printf(_("  DNS lookup for multidrop addresses is %s.\n"),
1735                                ctl->server.dns ? _("enabled") : _("disabled"));
1736                         if (ctl->server.dns)
1737                         {
1738                             printf(_("  Server aliases will be compared with multidrop addresses by "));
1739                             if (ctl->server.checkalias)
1740                                 printf(_("IP address.\n"));
1741                             else
1742                                 printf(_("name.\n"));
1743                         }
1744                         if (ctl->server.envelope == STRING_DISABLED)
1745                             printf(_("  Envelope-address routing is disabled\n"));
1746                         else
1747                         {
1748                             printf(_("  Envelope header is assumed to be: %s\n"),
1749                                    ctl->server.envelope ? ctl->server.envelope:_("Received"));
1750                             if (ctl->server.envskip > 1 || outlevel >= O_VERBOSE)
1751                                 printf(_("  Number of envelope header to be parsed: %d\n"),
1752                                        ctl->server.envskip);
1753                             if (ctl->server.qvirtual)
1754                                 printf(_("  Prefix %s will be removed from user id\n"),
1755                                        ctl->server.qvirtual);
1756                             else if (outlevel >= O_VERBOSE)
1757                                 printf(_("  No prefix stripping\n"));
1758                         }
1759
1760                         if (ctl->server.akalist)
1761                         {
1762                             struct idlist *idp;
1763
1764                             printf(_("  Predeclared mailserver aliases:"));
1765                             for (idp = ctl->server.akalist; idp; idp = idp->next)
1766                                 printf(" %s", idp->id);
1767                             putchar('\n');
1768                         }
1769                         if (ctl->server.localdomains)
1770                         {
1771                             struct idlist *idp;
1772
1773                             printf(_("  Local domains:"));
1774                             for (idp = ctl->server.localdomains; idp; idp = idp->next)
1775                                 printf(" %s", idp->id);
1776                             putchar('\n');
1777                         }
1778                     }
1779                 }
1780         }
1781 #if defined(linux) || defined(__FreeBSD__)
1782         if (ctl->server.interface)
1783             printf(_("  Connection must be through interface %s.\n"), ctl->server.interface);
1784         else if (outlevel >= O_VERBOSE)
1785             printf(_("  No interface requirement specified.\n"));
1786         if (ctl->server.monitor)
1787             printf(_("  Polling loop will monitor %s.\n"), ctl->server.monitor);
1788         else if (outlevel >= O_VERBOSE)
1789             printf(_("  No monitor interface specified.\n"));
1790 #endif
1791
1792         if (ctl->server.plugin)
1793             printf(_("  Server connections will be made via plugin %s (--plugin %s).\n"), ctl->server.plugin, ctl->server.plugin);
1794         else if (outlevel >= O_VERBOSE)
1795             printf(_("  No plugin command specified.\n"));
1796         if (ctl->server.plugout)
1797             printf(_("  Listener connections will be made via plugout %s (--plugout %s).\n"), ctl->server.plugout, ctl->server.plugout);
1798         else if (outlevel >= O_VERBOSE)
1799             printf(_("  No plugout command specified.\n"));
1800
1801         if (ctl->server.protocol > P_POP2 && (ctl->server.protocol != P_ETRN))
1802         {
1803             if (!ctl->oldsaved)
1804                 printf(_("  No UIDs saved from this host.\n"));
1805             else
1806             {
1807                 struct idlist *idp;
1808                 int count = 0;
1809
1810                 for (idp = ctl->oldsaved; idp; idp = idp->next)
1811                     ++count;
1812
1813                 printf(_("  %d UIDs saved.\n"), count);
1814                 if (outlevel >= O_VERBOSE)
1815                     for (idp = ctl->oldsaved; idp; idp = idp->next)
1816                         printf("\t%s\n", idp->id);
1817             }
1818         }
1819
1820         if (ctl->properties)
1821             printf(_("  Pass-through properties \"%s\".\n"),
1822                    visbuf(ctl->properties));
1823     }
1824 }
1825
1826 /* fetchmail.c ends here */