开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
fetchmail.c
资源名称：fetchmail-5.2.7.tar.gz　[点击查看]
上传用户：xxcykj
上传日期：2007-01-04
资源大小：727k
文件大小：54k
源码类别：

Email客户端

开发平台：

Unix_Linux

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