[u/mdw/catacomb] / noise.c

/* -*-c-*-
 *
 * $Id: noise.c,v 1.5 1999/12/22 15:57:55 mdw Exp $
 *
 * Acquisition of environmental noise (Unix-specific)
 *
 * (c) 1998 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: noise.c,v $
 * Revision 1.5  1999/12/22 15:57:55  mdw
 * Label system-specific parts more clearly.
 *
 * Revision 1.4  1999/12/10 23:25:15  mdw
 * Bug fix: remove old spurious fflush.
 *
 * Revision 1.3  1999/12/10 23:24:11  mdw
 * Bug fix: flush buffers before forking.
 *
 * Revision 1.2  1999/11/11 00:59:08  mdw
 * A bit of reformatting.  Initialize the uid and gid correctly.
 *
 * Revision 1.1  1999/09/03 08:41:12  mdw
 * Initial import.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <stdio.h>
#include <string.h>
#include <signal.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <fcntl.h>
#include <unistd.h>

#ifdef HAVE_SETGROUPS
#  include <grp.h>
#endif

#include <mLib/bits.h>
#include <mLib/tv.h>

#include "noise.h"
#include "paranoia.h"
#include "rand.h"

/*----- Magical numbers ---------------------------------------------------*/

#define NOISE_KIDLIFE 100000		/* @noise_filter@ child lifetime */
#define MILLION 1000000			/* One million */

/*----- Noise source definition -------------------------------------------*/

rand_source noise_source = { noise_acquire, noise_timer };

/*----- Static variables --------------------------------------------------*/

/* --- Timer differences --- */

static unsigned long noise_last;	/* Last time recorded */
static unsigned long noise_diff;	/* Last first order difference */

/* --- Setuid program handling --- */

static uid_t noise_uid = NOISE_NOSETUID; /* Uid to set to spawn processes */
static gid_t noise_gid = NOISE_NOSETGID; /* Gid to set to spawn processes */

/*----- Main code ---------------------------------------------------------*/

/* --- @bitcount@ --- *
 *
 * Arguments:	@unsigned long x@ = a word containing bits
 *
 * Returns:	The number of bits set in the word.
 */

static int bitcount(unsigned long x)
{
  char ctab[] = { 0, 1, 1, 2, 1, 2, 2, 3,
		  1, 2, 2, 3, 2, 3, 3, 4 };
  int count = 0;
  while (x) {
    count += ctab[x & 0xfu];
    x >>= 4;
  }
  return (count);
}

/* --- @timer@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to randomness pool
 *		@struct timeval *tv@ = pointer to time block
 *
 * Returns:	Nonzer if some randomness was contributed.
 *
 * Use:		Low-level timer contributor.
 */

static int timer(rand_pool *r, struct timeval *tv)
{
  unsigned long x, d, dd;
  int de, dde;
  int ret;
  
  x = tv->tv_usec + MILLION * tv->tv_sec;
  d = x ^ noise_last;
  dd = d ^ noise_diff;
  noise_diff = d;
  de = bitcount(d);
  dde = bitcount(dd);
  rand_add(r, tv, sizeof(*tv), de <= dde ? de : dde);
  ret = (de || dde);
  BURN(tv); x = d = dd = de = dde = 0;
  return (ret);
}

/* --- @noise_timer@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Contributes the current time to the randomness pool.
 *		A guess at the number of useful bits contributed is made,
 *		based on first and second order bit differences.  This isn't
 *		ever-so	reliable, but it's better than nothing.
 */

int noise_timer(rand_pool *r)
{
  struct timeval tv;
  gettimeofday(&tv, 0);
  return (timer(r, &tv));
}

/* --- @noise_devrandom@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Attempts to obtain some randomness from the system entropy
 *		pool.  All bits from the device are assumed to be good.
 */

int noise_devrandom(rand_pool *r)
{
  int fd;
  octet buf[RAND_POOLSZ];
  ssize_t len;
  int ret = 0;

  /* --- Be nice to other clients of the random device --- *
   *
   * Attempt to open the device nonblockingly.  If that works, take up to
   * one bufferful and then close again.  If there's no data to be read,
   * then that's tough and we go away again, on the grounds that the device
   * needs to get some more entropy from somewhere.
   */

  if ((fd = open("/dev/random", O_RDONLY | O_NONBLOCK)) >= 0) {
    if ((len = read(fd, buf, sizeof(buf))) > 0) {
      rand_add(r, buf, len, len * 8);
      BURN(buf);
      ret = 1;
    }
    close(fd);
  }
  noise_timer(r);
  return (ret);
}

/* --- @noise_setid@ --- *
 *
 * Arguments:	@uid_t uid@ = uid to set
 *		@gid_t gid@ = gid to set
 *
 * Returns:	---
 *
 * Use:		Sets the user and group ids to be used by @noise_filter@
 *		when running child processes.  This is useful to avoid
 *		giving shell commands (even carefully written ones) undue
 *		privileges.  This interface is Unix-specific
 */

void noise_setid(uid_t uid, gid_t gid)
{
  noise_uid = uid;
  noise_gid = gid;
}

/* --- @noise_filter@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *		@int good@ = number of good bits per 1024 bits
 *		@const char *c@ = shell command to run
 *
 * Returns:	Nonzero if some randomness was contributed.
 *
 * Use:		Attempts to execute a shell command, and dump it into the
 *		randomness pool.  A very rough estimate of the number of
 *		good bits is made, based on the size of the command's output.
 *		This function calls @waitpid@, so be careful.  Before execing
 *		the command, the process uid and gid are set to the values
 *		given to @noise_setid@, and an attempt is made to reset the
 *		list of supplementary groups.  The environment passed to
 *		the command has been severly lobotimized.  If the command
 *		fails to complete within a short time period, it is killed.
 *		Paranoid use of close-on-exec flags for file descriptors is
 *		recommended.
 *
 *		This interface is Unix-specific.
 */

int noise_filter(rand_pool *r, int good, const char *c)
{
  char buf[4096];
  pid_t kid;
  int fd[2];
  struct timeval dead;
  int ret = 0;
  const char *env[] = {
    "PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc",
    0
  };

  /* --- Remember when this business started --- */

  gettimeofday(&dead, 0);
  timer(r, &dead);

  /* --- Create a pipe --- */

  if (pipe(fd))
    return (ret);

  /* --- Fork a child off --- */

  fflush(0);
  kid = fork();
  if (kid < 0) {
    close(fd[0]);
    close(fd[1]);
    return (ret);
  }

  /* --- Handle the child end of the deal --- */

  if (kid == 0) {
    int f;

    /* --- Set the pipe as standard output, close standard input --- */

    close(0); close(1); close(2);

    if (fd[1] != 1) {
      if (dup2(fd[1], 1) < 0) _exit(127);
      close(fd[1]);
    }

    if ((f = open("/dev/null", O_RDONLY)) != 0 ||
	(f = open("/dev/null", O_WRONLY)) != 2)
      _exit(127);

    /* --- Play games with uids --- */

    if (noise_gid != NOISE_NOSETGID) {
      setgid(noise_gid);
      setegid(noise_gid);
#ifdef HAVE_SETGROUPS
      setgroups(1, &noise_gid);
#endif
    }

    if (noise_uid != NOISE_NOSETUID) {
      setuid(noise_uid);
      seteuid(noise_uid);
    }

    /* --- Start the process up --- */

    execle("/bin/sh", "-c", c, (char *)0, env);
    _exit(127);
  }

  /* --- Sort out my end of the deal --- */

  close(fd[1]);

  /* --- Decide on the deadline --- */

  TV_ADDL(&dead, &dead, 0, NOISE_KIDLIFE);

  /* --- Now read, and think --- */

  for (;;) {
    struct timeval now, diff;
    fd_set rd;

    gettimeofday(&now, 0);
    timer(r, &now);
    if (TV_CMP(&now, >, &dead))
      break;
    TV_SUB(&diff, &dead, &now);

    FD_ZERO(&rd);
    FD_SET(fd[0], &rd);

    if (select(fd[0] + 1, &rd, 0, 0, &diff) < 0)
      break;
    if (FD_ISSET(fd[0], &rd)) {
      ssize_t sz;
      int goodbits;

      if ((sz = read(fd[0], buf, sizeof(buf))) <= 0)
	break;
      goodbits = (sz * good) / 128;
      rand_add(r, buf, sz, goodbits);
      ret = 1;
    }
  }

  /* --- We've finished with it: kill the child process --- *
   *
   * This is morally questionable.  On the other hand, I don't want to be
   * held up in the @waitpid@ call if I can possibly help it.  Maybe a
   * double-fork is worth doing here.
   */

  close(fd[0]);
  BURN(buf);
  noise_timer(r);
  kill(kid, SIGKILL);
  waitpid(kid, 0, 0);
  return (ret);
}

/* --- @noise_acquire@ --- *
 *
 * Arguments:	@rand_pool *r@ = pointer to a randomness pool
 *
 * Returns:	---
 *
 * Use:		Acquires some randomness from somewhere.
 */

void noise_acquire(rand_pool *r)
{
  if (!noise_devrandom(r)) {

    /* --- Output of `ps' --- *
     *
     * This is a hopefully cheap way of getting a bit of noise.  I'm guessing
     * the good bit ratio based on about 90 bytes per line of output, and
     * each line containing maybe 12 bits worth of interesting data.  (Some
     * quick experiments with gzip seem to bear this idea out.)  So, 12 good
     * bits per 90 bytes of output gives slightly more than 17 good bits per
     * 1024 bits of output.  So I'll be a pessimist and say 16 bits.
     */

    (void)
      (noise_filter(r, 16, "ps alxww") ||
       noise_filter(r, 16, "ps -elf"));

    /* --- Output of `netstat' --- *
     *
     * Another possibly cheap way of getting noise.  My output has about
     * 72 bytes per line of output.  My wild guesses are telling me that
     * there are probably only about four good bits per line (gzip tells
     * me there's six, but I want to underestimate).  Four bits per 72 bytes
     * is 7 good bits per 1024 bits of output.  Pessimist that I am, I'll
     * call it six.
     */

    noise_filter(r, 6, "netstat -n");
  }
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
d03ab969	1	/* --c--
d03ab969	2	*
099355bc	3	* $Id: noise.c,v 1.5 1999/12/22 15:57:55 mdw Exp $
d03ab969	4	*
099355bc	5	* Acquisition of environmental noise (Unix-specific)
d03ab969	6	*
	7	* (c) 1998 Straylight/Edgeware
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of Catacomb.
	13	*
	14	* Catacomb is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU Library General Public License as
	16	* published by the Free Software Foundation; either version 2 of the
	17	* License, or (at your option) any later version.
	18	*
	19	* Catacomb is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU Library General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU Library General Public
	25	* License along with Catacomb; if not, write to the Free
	26	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	27	* MA 02111-1307, USA.
	28	*/
	29
	30	/----- Revision history --------------------------------------------------
	31	*
	32	* $Log: noise.c,v $
099355bc	33	* Revision 1.5 1999/12/22 15:57:55 mdw
	34	* Label system-specific parts more clearly.
	35	*
c141f4b6	36	* Revision 1.4 1999/12/10 23:25:15 mdw
	37	* Bug fix: remove old spurious fflush.
	38	*
028b34c6	39	* Revision 1.3 1999/12/10 23:24:11 mdw
	40	* Bug fix: flush buffers before forking.
	41	*
178220b3	42	* Revision 1.2 1999/11/11 00:59:08 mdw
	43	* A bit of reformatting. Initialize the uid and gid correctly.
	44	*
d03ab969	45	* Revision 1.1 1999/09/03 08:41:12 mdw
	46	* Initial import.
	47	*
	48	*/
	49
	50	/----- Header files ------------------------------------------------------/
	51
178220b3	52	#include "config.h"
d03ab969	53
	54	#include <stdio.h>
	55	#include <string.h>
	56	#include <signal.h>
	57
	58	#include <sys/types.h>
	59	#include <sys/time.h>
	60	#include <sys/wait.h>
	61
	62	#include <fcntl.h>
	63	#include <unistd.h>
	64
	65	#ifdef HAVE_SETGROUPS
	66	# include <grp.h>
	67	#endif
	68
	69	#include <mLib/bits.h>
	70	#include <mLib/tv.h>
	71
	72	#include "noise.h"
	73	#include "paranoia.h"
	74	#include "rand.h"
	75
	76	/----- Magical numbers ---------------------------------------------------/
	77
	78	#define NOISE_KIDLIFE 100000 /* @noise_filter@ child lifetime */
	79	#define MILLION 1000000 /* One million */
	80
	81	/----- Noise source definition -------------------------------------------/
	82
	83	rand_source noise_source = { noise_acquire, noise_timer };
	84
	85	/----- Static variables --------------------------------------------------/
	86
	87	/* --- Timer differences --- */
	88
	89	static unsigned long noise_last; /* Last time recorded */
	90	static unsigned long noise_diff; /* Last first order difference */
	91
	92	/* --- Setuid program handling --- */
	93
178220b3	94	static uid_t noise_uid = NOISE_NOSETUID; /* Uid to set to spawn processes */
178220b3	95	static gid_t noise_gid = NOISE_NOSETGID; /* Gid to set to spawn processes */
d03ab969	96
	97	/----- Main code ---------------------------------------------------------/
	98
	99	/* --- @bitcount@ --- *
	100	*
	101	* Arguments: @unsigned long x@ = a word containing bits
	102	*
	103	* Returns: The number of bits set in the word.
	104	*/
	105
	106	static int bitcount(unsigned long x)
	107	{
	108	char ctab[] = { 0, 1, 1, 2, 1, 2, 2, 3,
	109	1, 2, 2, 3, 2, 3, 3, 4 };
	110	int count = 0;
	111	while (x) {
	112	count += ctab[x & 0xfu];
	113	x >>= 4;
	114	}
	115	return (count);
	116	}
	117
	118	/* --- @timer@ --- *
	119	*
	120	* Arguments: @rand_pool *r@ = pointer to randomness pool
	121	* @struct timeval *tv@ = pointer to time block
	122	*
	123	* Returns: Nonzer if some randomness was contributed.
	124	*
	125	* Use: Low-level timer contributor.
	126	*/
	127
	128	static int timer(rand_pool r, struct timeval tv)
	129	{
	130	unsigned long x, d, dd;
	131	int de, dde;
	132	int ret;
	133
	134	x = tv->tv_usec + MILLION * tv->tv_sec;
	135	d = x ^ noise_last;
	136	dd = d ^ noise_diff;
	137	noise_diff = d;
	138	de = bitcount(d);
	139	dde = bitcount(dd);
	140	rand_add(r, tv, sizeof(*tv), de <= dde ? de : dde);
	141	ret = (de \|\| dde);
	142	BURN(tv); x = d = dd = de = dde = 0;
	143	return (ret);
	144	}
	145
	146	/* --- @noise_timer@ --- *
	147	*
	148	* Arguments: @rand_pool *r@ = pointer to a randomness pool
	149	*
	150	* Returns: Nonzero if some randomness was contributed.
	151	*
	152	* Use: Contributes the current time to the randomness pool.
	153	* A guess at the number of useful bits contributed is made,
	154	* based on first and second order bit differences. This isn't
	155	* ever-so reliable, but it's better than nothing.
	156	*/
	157
	158	int noise_timer(rand_pool *r)
	159	{
160	struct timeval tv;
161	gettimeofday(&tv, 0);
162	return (timer(r, &tv));
163	}
164
165	/* --- @noise_devrandom@ --- *
166	*
167	* Arguments: @rand_pool *r@ = pointer to a randomness pool
168	*
169	* Returns: Nonzero if some randomness was contributed.
170	*
171	* Use: Attempts to obtain some randomness from the system entropy
172	* pool. All bits from the device are assumed to be good.
173	*/
174
175	int noise_devrandom(rand_pool *r)
176	{
177	int fd;
178	octet buf[RAND_POOLSZ];
179	ssize_t len;
180	int ret = 0;
181
182	/* --- Be nice to other clients of the random device --- *
183	*
184	* Attempt to open the device nonblockingly. If that works, take up to
185	* one bufferful and then close again. If there's no data to be read,
186	* then that's tough and we go away again, on the grounds that the device
187	* needs to get some more entropy from somewhere.
188	*/
189
190	if ((fd = open("/dev/random", O_RDONLY \| O_NONBLOCK)) >= 0) {
191	if ((len = read(fd, buf, sizeof(buf))) > 0) {
192	rand_add(r, buf, len, len * 8);
193	BURN(buf);
194	ret = 1;
195	}
196	close(fd);
197	}
198	noise_timer(r);
199	return (ret);
200	}
201
202	/* --- @noise_setid@ --- *
203	*
204	* Arguments: @uid_t uid@ = uid to set
205	* @gid_t gid@ = gid to set
206	*
207	* Returns: ---
208	*
209	* Use: Sets the user and group ids to be used by @noise_filter@
210	* when running child processes. This is useful to avoid
211	* giving shell commands (even carefully written ones) undue
099355bc	212	* privileges. This interface is Unix-specific
d03ab969	213	*/
	214
	215	void noise_setid(uid_t uid, gid_t gid)
	216	{
	217	noise_uid = uid;
	218	noise_gid = gid;
	219	}
	220
	221	/* --- @noise_filter@ --- *
	222	*
	223	* Arguments: @rand_pool *r@ = pointer to a randomness pool
	224	* @int good@ = number of good bits per 1024 bits
	225	* @const char *c@ = shell command to run
	226	*
	227	* Returns: Nonzero if some randomness was contributed.
	228	*
	229	* Use: Attempts to execute a shell command, and dump it into the
	230	* randomness pool. A very rough estimate of the number of
	231	* good bits is made, based on the size of the command's output.
	232	* This function calls @waitpid@, so be careful. Before execing
	233	* the command, the process uid and gid are set to the values
	234	* given to @noise_setid@, and an attempt is made to reset the
	235	* list of supplementary groups. The environment passed to
	236	* the command has been severly lobotimized. If the command
	237	* fails to complete within a short time period, it is killed.
	238	* Paranoid use of close-on-exec flags for file descriptors is
	239	* recommended.
099355bc	240	*
099355bc	241	* This interface is Unix-specific.
d03ab969	242	*/
	243
	244	int noise_filter(rand_pool r, int good, const char c)
	245	{
	246	char buf[4096];
	247	pid_t kid;
	248	int fd[2];
	249	struct timeval dead;
	250	int ret = 0;
	251	const char *env[] = {
	252	"PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc",
	253	0
	254	};
	255
	256	/* --- Remember when this business started --- */
	257
	258	gettimeofday(&dead, 0);
	259	timer(r, &dead);
	260
	261	/* --- Create a pipe --- */
	262
	263	if (pipe(fd))
	264	return (ret);
	265
	266	/* --- Fork a child off --- */
	267
028b34c6	268	fflush(0);
d03ab969	269	kid = fork();
	270	if (kid < 0) {
	271	close(fd[0]);
	272	close(fd[1]);
	273	return (ret);
	274	}
	275
	276	/* --- Handle the child end of the deal --- */
	277
d03ab969	278	if (kid == 0) {
	279	int f;
	280
	281	/* --- Set the pipe as standard output, close standard input --- */
	282
	283	close(0); close(1); close(2);
	284
	285	if (fd[1] != 1) {
	286	if (dup2(fd[1], 1) < 0) _exit(127);
	287	close(fd[1]);
	288	}
	289
	290	if ((f = open("/dev/null", O_RDONLY)) != 0 \|\|
	291	(f = open("/dev/null", O_WRONLY)) != 2)
	292	_exit(127);
	293
	294	/* --- Play games with uids --- */
	295
	296	if (noise_gid != NOISE_NOSETGID) {
	297	setgid(noise_gid);
	298	setegid(noise_gid);
	299	#ifdef HAVE_SETGROUPS
	300	setgroups(1, &noise_gid);
	301	#endif
	302	}
	303
	304	if (noise_uid != NOISE_NOSETUID) {
	305	setuid(noise_uid);
	306	seteuid(noise_uid);
	307	}
	308
	309	/* --- Start the process up --- */
	310
	311	execle("/bin/sh", "-c", c, (char *)0, env);
	312	_exit(127);
	313	}
	314
	315	/* --- Sort out my end of the deal --- */
	316
	317	close(fd[1]);
	318
	319	/* --- Decide on the deadline --- */
	320
	321	TV_ADDL(&dead, &dead, 0, NOISE_KIDLIFE);
	322
	323	/* --- Now read, and think --- */
	324
	325	for (;;) {
	326	struct timeval now, diff;
	327	fd_set rd;
	328
	329	gettimeofday(&now, 0);
	330	timer(r, &now);
	331	if (TV_CMP(&now, >, &dead))
	332	break;
	333	TV_SUB(&diff, &dead, &now);
	334
	335	FD_ZERO(&rd);
	336	FD_SET(fd[0], &rd);
	337
	338	if (select(fd[0] + 1, &rd, 0, 0, &diff) < 0)
	339	break;
	340	if (FD_ISSET(fd[0], &rd)) {
	341	ssize_t sz;
342	int goodbits;
343
344	if ((sz = read(fd[0], buf, sizeof(buf))) <= 0)
345	break;
346	goodbits = (sz * good) / 128;
347	rand_add(r, buf, sz, goodbits);
348	ret = 1;
349	}
350	}
351
352	/* --- We've finished with it: kill the child process --- *
353	*
354	* This is morally questionable. On the other hand, I don't want to be
355	* held up in the @waitpid@ call if I can possibly help it. Maybe a
356	* double-fork is worth doing here.
357	*/
358
359	close(fd[0]);
360	BURN(buf);
361	noise_timer(r);
362	kill(kid, SIGKILL);
363	waitpid(kid, 0, 0);
364	return (ret);
365	}
366
367	/* --- @noise_acquire@ --- *
368	*
369	* Arguments: @rand_pool *r@ = pointer to a randomness pool
370	*
371	* Returns: ---
372	*
373	* Use: Acquires some randomness from somewhere.
374	*/
375
376	void noise_acquire(rand_pool *r)
377	{
378	if (!noise_devrandom(r)) {
379
380	/* --- Output of `ps' --- *
381	*
382	* This is a hopefully cheap way of getting a bit of noise. I'm guessing
383	* the good bit ratio based on about 90 bytes per line of output, and
384	* each line containing maybe 12 bits worth of interesting data. (Some
385	* quick experiments with gzip seem to bear this idea out.) So, 12 good
386	* bits per 90 bytes of output gives slightly more than 17 good bits per
387	* 1024 bits of output. So I'll be a pessimist and say 16 bits.
388	*/
389
390	(void)
391	(noise_filter(r, 16, "ps alxww") \|\|
392	noise_filter(r, 16, "ps -elf"));
393
394	/* --- Output of `netstat' --- *
395	*
396	* Another possibly cheap way of getting noise. My output has about
397	* 72 bytes per line of output. My wild guesses are telling me that
398	* there are probably only about four good bits per line (gzip tells
399	* me there's six, but I want to underestimate). Four bits per 72 bytes
400	* is 7 good bits per 1024 bits of output. Pessimist that I am, I'll
401	* call it six.
402	*/
403
404	noise_filter(r, 6, "netstat -n");
405	}
406	}
407
408	/----- That's all, folks -------------------------------------------------/