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