diff -cr squid-1.0.beta6/ChangeLog squid-1.0.beta7/ChangeLog
*** squid-1.0.beta6/ChangeLog	Fri May 03 13:25:36 1996
--- squid-1.0.beta7/ChangeLog	Wed May 08 20:40:48 1996
***************
*** 141,143 ****
--- 141,156 ----
  	- Changed ftpget to only generate BASE HREF if the FTP URL does
  	  not end with '/'.
  
+ 
+ changes to squid-1.0.beta7:
+ 
+ 	- Fixed comm_udp_sendto continuous loop bug
+ 	- Fixed URLs-with-colon-but-no-port-number bug
+ 	- Fixed sending ICP queries for HEAD requests
+ 	- Changed 'server_list' output.  Added RTT, Fetches, Hits, Misses,
+ 	  and percents.
+ 	- Fixed setuid bug causing some logs to be owned by root.
+ 	- Fixed virtual host mode (-V option)
+ 	- Added read(2) instrumentation for HTTP and FTP.
+ 	- Changed neighbor initialization to continue if DNS lookup fails.
+ 	- Lint cleanup
diff -cr squid-1.0.beta6/makefile.in squid-1.0.beta7/makefile.in
*** squid-1.0.beta6/makefile.in	Fri May 03 13:27:57 1996
--- squid-1.0.beta7/makefile.in	Tue May 07 09:51:16 1996
***************
*** 1,4 ****
! # $Id: makefile.in,v 1.6.2.1 1996/05/03 20:27:57 wessels Exp $
  #
  
  srcdir		= @srcdir@
--- 1,4 ----
! # $Id: makefile.in,v 1.6.2.2 1996/05/07 16:51:16 wessels Exp $
  #
  
  srcdir		= @srcdir@
***************
*** 15,20 ****
--- 15,22 ----
  exec_prefix	= @exec_prefix@
  
  SUBDIRS		= lib scripts src
+ 
+ noargs: all
  
  all install clean: 
  	@for dir in $(SUBDIRS); do \
diff -cr squid-1.0.beta6/include/mime_table.h squid-1.0.beta7/include/mime_table.h
*** squid-1.0.beta6/include/mime_table.h	Wed Feb 21 22:23:56 1996
--- squid-1.0.beta7/include/mime_table.h	Wed May 08 19:41:03 1996
***************
*** 1,91 ****
  #define EXT_TABLE_LEN 88
! static ext_table_entry ext_mime_table [] = {
! 	{"Z", "application/x-compressed", "x-compress", "binary"},
! 	{"ai", "application/postscript", "8bit", "text"},
! 	{"aif", "audio/x-aiff", "binary", "sound"},
! 	{"aifc", "audio/x-aiff", "binary", "sound"},
! 	{"aiff", "audio/x-aiff", "binary", "sound"},
! 	{"au", "audio/basic", "binary", "sound"},
! 	{"avi", "video/x-msvideo", "binary", "movie"},
! 	{"bcpio", "application/x-bcpio", "binary", "binary"},
! 	{"bin", "application/macbinary", "macbinary", "binary"},
! 	{"c", "text/plain", "7bit", "text"},
! 	{"cc", "text/plain", "7bit", "text"},
! 	{"cdf", "application/x-netcdf", "binary", "binary"},
! 	{"cpio", "application/x-cpio", "binary", "binary"},
! 	{"csh", "application/x-csh", "7bit", "text"},
! 	{"doc", "application/msword", "binary", "binary"},
! 	{"dvi", "application/x-dvi", "binary", "binary"},
! 	{"eps", "application/postscript", "8bit", "text"},
! 	{"etx", "text/x-setext", "7bit", "text"},
! 	{"exe", "application/octet-stream", "binary", "binary"},
! 	{"f90", "text/plain", "7bit", "text"},
! 	{"gif", "image/gif", "binary", "image"},
! 	{"gtar", "application/x-gtar", "binary", "binary"},
! 	{"gz", "application/x-gzip", "x-gzip", "binary"},
! 	{"h", "text/plain", "7bit", "text"},
! 	{"hdf", "application/x-hdf", "binary", "binary"},
! 	{"hh", "text/plain", "7bit", "text"},
! 	{"hqx", "application/mac-binhex40", "mac-binhex40", "binary"},
! 	{"htm", "text/html", "8bit", "text"},
! 	{"html", "text/html", "8bit", "text"},
! 	{"ief", "image/ief", "binary", "image"},
! 	{"jpe", "image/jpeg", "binary", "image"},
! 	{"jpeg", "image/jpeg", "binary", "image"},
! 	{"jpg", "image/jpeg", "binary", "image"},
! 	{"latex", "application/x-latex", "8bit", "text"},
! 	{"m", "text/plain", "7bit", "text"},
! 	{"man", "application/x-troff-man", "7bit", "text"},
! 	{"me", "application/x-troff-me", "7bit", "text"},
! 	{"mif", "application/x-mif", "binary", "binary"},
! 	{"mime", "www/mime", "8bit", "text"},
! 	{"mov", "video/quicktime", "binary", "movie"},
! 	{"movie", "video/x-sgi-movie", "binary", "movie"},
! 	{"mpe", "video/mpeg", "binary", "movie"},
! 	{"mpeg", "video/mpeg", "binary", "movie"},
! 	{"mpg", "video/mpeg", "binary", "movie"},
! 	{"ms", "application/x-troff-ms", "7bit", "text"},
! 	{"msw", "application/msword", "binary", "binary"},
! 	{"mwrt", "application/macwriteii", "binary", "binary"},
! 	{"nc", "application/x-netcdf", "binary", "binary"},
! 	{"oda", "application/oda", "binary", "binary"},
! 	{"pbm", "image/x-portable-bitmap", "binary", "image"},
! 	{"pdf", "application/pdf", "binary", "binary"},
! 	{"pgm", "image/x-portable-graymap", "binary", "image"},
! 	{"pic", "application/pict", "binary", "image"},
! 	{"pict", "application/pict", "binary", "image"},
! 	{"pnm", "image/x-portable-anymap", "binary", "image"},
! 	{"ppm", "image/x-portable-pixmap", "binary", "image"},
! 	{"ps", "application/postscript", "8bit", "text"},
! 	{"qt", "video/quicktime", "binary", "movie"},
! 	{"ras", "image/cmu-raster", "binary", "image"},
! 	{"rgb", "image/x-rgb", "binary", "image"},
! 	{"roff", "application/x-troff", "7bit", "text"},
! 	{"rtf", "application/x-rtf", "7bit", "binary"},
! 	{"rtx", "text/richtext", "7bit", "text"},
! 	{"sh", "application/x-sh", "7bit", "text"},
! 	{"shar", "application/x-shar", "8bit", "text"},
! 	{"sit", "application/stuffit", "binary", "binary"},
! 	{"snd", "audio/basic", "binary", "sound"},
! 	{"src", "application/x-wais-source", "7bit", "text"},
! 	{"sv4cpio", "application/x-sv4cpio", "binary", "binary"},
! 	{"sv4crc", "application/x-sv4crc", "binary", "binary"},
! 	{"t", "application/x-troff", "7bit", "text"},
! 	{"tar", "application/x-tar", "binary", "binary"},
! 	{"tcl", "application/x-tcl", "7bit", "text"},
! 	{"tex", "application/x-tex", "8bit", "text"},
! 	{"texi", "application/x-texinfo", "7bit", "text"},
! 	{"texinfo", "application/x-texinfo", "7bit", "text"},
! 	{"tgz", "application/x-gzip", "x-gzip", "binary"},
! 	{"tif", "image/tiff", "binary", "image"},
! 	{"tiff", "image/tiff", "binary", "image"},
! 	{"tr", "application/x-troff", "7bit", "text"},
! 	{"tsv", "text/tab-separated-values", "7bit", "text"},
! 	{"txt", "text/plain", "7bit", "text"},
! 	{"ustar", "application/x-ustar", "binary", "binary"},
! 	{"wav", "audio/x-wav", "binary", "sound"},
! 	{"xbm", "image/x-xbitmap", "binary", "image"},
! 	{"xpm", "image/x-xpixmap", "binary", "image"},
! 	{"xwd", "image/x-xwindowdump", "binary", "image"},
! 	{"zip", "application/zip", "zip", "binary"}
  };
--- 1,92 ----
  #define EXT_TABLE_LEN 88
! static ext_table_entry ext_mime_table[] =
! {
!     {"Z", "application/x-compressed", "x-compress", "binary"},
!     {"ai", "application/postscript", "8bit", "text"},
!     {"aif", "audio/x-aiff", "binary", "sound"},
!     {"aifc", "audio/x-aiff", "binary", "sound"},
!     {"aiff", "audio/x-aiff", "binary", "sound"},
!     {"au", "audio/basic", "binary", "sound"},
!     {"avi", "video/x-msvideo", "binary", "movie"},
!     {"bcpio", "application/x-bcpio", "binary", "binary"},
!     {"bin", "application/macbinary", "macbinary", "binary"},
!     {"c", "text/plain", "7bit", "text"},
!     {"cc", "text/plain", "7bit", "text"},
!     {"cdf", "application/x-netcdf", "binary", "binary"},
!     {"cpio", "application/x-cpio", "binary", "binary"},
!     {"csh", "application/x-csh", "7bit", "text"},
!     {"doc", "application/msword", "binary", "binary"},
!     {"dvi", "application/x-dvi", "binary", "binary"},
!     {"eps", "application/postscript", "8bit", "text"},
!     {"etx", "text/x-setext", "7bit", "text"},
!     {"exe", "application/octet-stream", "binary", "binary"},
!     {"f90", "text/plain", "7bit", "text"},
!     {"gif", "image/gif", "binary", "image"},
!     {"gtar", "application/x-gtar", "binary", "binary"},
!     {"gz", "application/x-gzip", "x-gzip", "binary"},
!     {"h", "text/plain", "7bit", "text"},
!     {"hdf", "application/x-hdf", "binary", "binary"},
!     {"hh", "text/plain", "7bit", "text"},
!     {"hqx", "application/mac-binhex40", "mac-binhex40", "binary"},
!     {"htm", "text/html", "8bit", "text"},
!     {"html", "text/html", "8bit", "text"},
!     {"ief", "image/ief", "binary", "image"},
!     {"jpe", "image/jpeg", "binary", "image"},
!     {"jpeg", "image/jpeg", "binary", "image"},
!     {"jpg", "image/jpeg", "binary", "image"},
!     {"latex", "application/x-latex", "8bit", "text"},
!     {"m", "text/plain", "7bit", "text"},
!     {"man", "application/x-troff-man", "7bit", "text"},
!     {"me", "application/x-troff-me", "7bit", "text"},
!     {"mif", "application/x-mif", "binary", "binary"},
!     {"mime", "www/mime", "8bit", "text"},
!     {"mov", "video/quicktime", "binary", "movie"},
!     {"movie", "video/x-sgi-movie", "binary", "movie"},
!     {"mpe", "video/mpeg", "binary", "movie"},
!     {"mpeg", "video/mpeg", "binary", "movie"},
!     {"mpg", "video/mpeg", "binary", "movie"},
!     {"ms", "application/x-troff-ms", "7bit", "text"},
!     {"msw", "application/msword", "binary", "binary"},
!     {"mwrt", "application/macwriteii", "binary", "binary"},
!     {"nc", "application/x-netcdf", "binary", "binary"},
!     {"oda", "application/oda", "binary", "binary"},
!     {"pbm", "image/x-portable-bitmap", "binary", "image"},
!     {"pdf", "application/pdf", "binary", "binary"},
!     {"pgm", "image/x-portable-graymap", "binary", "image"},
!     {"pic", "application/pict", "binary", "image"},
!     {"pict", "application/pict", "binary", "image"},
!     {"pnm", "image/x-portable-anymap", "binary", "image"},
!     {"ppm", "image/x-portable-pixmap", "binary", "image"},
!     {"ps", "application/postscript", "8bit", "text"},
!     {"qt", "video/quicktime", "binary", "movie"},
!     {"ras", "image/cmu-raster", "binary", "image"},
!     {"rgb", "image/x-rgb", "binary", "image"},
!     {"roff", "application/x-troff", "7bit", "text"},
!     {"rtf", "application/x-rtf", "7bit", "binary"},
!     {"rtx", "text/richtext", "7bit", "text"},
!     {"sh", "application/x-sh", "7bit", "text"},
!     {"shar", "application/x-shar", "8bit", "text"},
!     {"sit", "application/stuffit", "binary", "binary"},
!     {"snd", "audio/basic", "binary", "sound"},
!     {"src", "application/x-wais-source", "7bit", "text"},
!     {"sv4cpio", "application/x-sv4cpio", "binary", "binary"},
!     {"sv4crc", "application/x-sv4crc", "binary", "binary"},
!     {"t", "application/x-troff", "7bit", "text"},
!     {"tar", "application/x-tar", "binary", "binary"},
!     {"tcl", "application/x-tcl", "7bit", "text"},
!     {"tex", "application/x-tex", "8bit", "text"},
!     {"texi", "application/x-texinfo", "7bit", "text"},
!     {"texinfo", "application/x-texinfo", "7bit", "text"},
!     {"tgz", "application/x-gzip", "x-gzip", "binary"},
!     {"tif", "image/tiff", "binary", "image"},
!     {"tiff", "image/tiff", "binary", "image"},
!     {"tr", "application/x-troff", "7bit", "text"},
!     {"tsv", "text/tab-separated-values", "7bit", "text"},
!     {"txt", "text/plain", "7bit", "text"},
!     {"ustar", "application/x-ustar", "binary", "binary"},
!     {"wav", "audio/x-wav", "binary", "sound"},
!     {"xbm", "image/x-xbitmap", "binary", "image"},
!     {"xpm", "image/x-xpixmap", "binary", "image"},
!     {"xwd", "image/x-xwindowdump", "binary", "image"},
!     {"zip", "application/zip", "zip", "binary"}
  };
diff -cr squid-1.0.beta6/include/util.h squid-1.0.beta7/include/util.h
*** squid-1.0.beta6/include/util.h	Sat Apr 13 20:34:28 1996
--- squid-1.0.beta7/include/util.h	Wed May 08 19:35:33 1996
***************
*** 1,5 ****
  /*
!  * $Id: util.h,v 1.6 1996/04/14 03:34:28 wessels Exp $
   */
  
  #ifndef _UTIL_H_
--- 1,5 ----
  /*
!  * $Id: util.h,v 1.6.2.1 1996/05/09 02:35:33 wessels Exp $
   */
  
  #ifndef _UTIL_H_
***************
*** 22,48 ****
  #ifndef _PARAMS
  #if defined(__STDC__) || defined(__cplusplus) || defined(__STRICT_ANSI__)
  #define _PARAMS(ARGS) ARGS
! #else /* Traditional C */     
! #define _PARAMS(ARGS) ()      
! #endif /* __STDC__ */              
! #endif /* _PARAMS */   
  
  #ifdef NO_STRDUP
! char *strdup _PARAMS((char *));			/* Duplicate a string */
  #endif
! char *xstrdup _PARAMS((char *));		/* Duplicate a string */
  
  /* from xmalloc.c */
! void *xmalloc _PARAMS((size_t));		/* Wrapper for malloc(3) */
  void *xrealloc _PARAMS((void *, size_t));	/* Wrapper for realloc(3) */
! void *xcalloc _PARAMS((int, size_t));		/* Wrapper for calloc(3) */
! void xfree _PARAMS((void *));			/* Wrapper for free(3) */
! void xxfree _PARAMS((void *));			/* Wrapper for free(3) */
! char *xstrdup _PARAMS ((char *));
! char *xstrerror _PARAMS(());
  
- char *getfullhostname _PARAMS(());
- 
  /* from debug.c */
  #ifndef MAX_DEBUG_LEVELS
  #define MAX_DEBUG_LEVELS 256
--- 22,47 ----
  #ifndef _PARAMS
  #if defined(__STDC__) || defined(__cplusplus) || defined(__STRICT_ANSI__)
  #define _PARAMS(ARGS) ARGS
! #else /* Traditional C */
! #define _PARAMS(ARGS) ()
! #endif /* __STDC__ */
! #endif /* _PARAMS */
  
  #ifdef NO_STRDUP
! char *strdup _PARAMS((char *));	/* Duplicate a string */
  #endif
! char *xstrdup _PARAMS((char *));	/* Duplicate a string */
  
  /* from xmalloc.c */
! void *xmalloc _PARAMS((size_t));	/* Wrapper for malloc(3) */
  void *xrealloc _PARAMS((void *, size_t));	/* Wrapper for realloc(3) */
! void *xcalloc _PARAMS((int, size_t));	/* Wrapper for calloc(3) */
! void xfree _PARAMS((void *));	/* Wrapper for free(3) */
! void xxfree _PARAMS((void *));	/* Wrapper for free(3) */
! char *xstrdup _PARAMS((char *));
! char *xstrerror _PARAMS((void));
! char *getfullhostname _PARAMS((void));
  
  /* from debug.c */
  #ifndef MAX_DEBUG_LEVELS
  #define MAX_DEBUG_LEVELS 256
***************
*** 51,57 ****
  #ifndef MAIN
  extern int Harvest_do_debug;
  extern int Harvest_debug_levels[];
! #endif	/* MAIN */
  
  #undef debug_ok_fast
  #if USE_NO_DEBUGGING
--- 50,56 ----
  #ifndef MAIN
  extern int Harvest_do_debug;
  extern int Harvest_debug_levels[];
! #endif /* MAIN */
  
  #undef debug_ok_fast
  #if USE_NO_DEBUGGING
***************
*** 74,105 ****
          {if (debug_ok_fast((section),(level))) {Log X;}}
  #endif
  
- void debug_reset _PARAMS((void));
  void debug_enable _PARAMS((int, int));
  void debug_disable _PARAMS((int));
  void debug_flag _PARAMS((char *));
! int  debug_ok _PARAMS((int, int));
  
  #define HOST_CACHE_TTL 3600
  
  typedef struct _host {
!     char        key[SQUIDHOSTNAMELEN];    /* www.bar.com */
!     char        fqdn[SQUIDHOSTNAMELEN];   /* real.bar.com */
!     char        dotaddr[16];            /* 128.138.213.10 */
!     char        ipaddr[4];
!     time_t      last_t;                 /* last access of this info */
!     int         n;                      /* # of requests for this host */
!     int         addrlen;                /* length of 'ipaddr', always 4 */
      struct _host *next;
  } Host;
  
! extern Host   *thisHost;
  
! void   host_cache_init _PARAMS((void));
! Host  *get_host _PARAMS((char *hostname));
! int   delete_host _PARAMS((Host *h));
! int   expire_host_cache _PARAMS((time_t timeout));
! void  dump_host_cache _PARAMS((int, int));
  
  
  
--- 73,106 ----
          {if (debug_ok_fast((section),(level))) {Log X;}}
  #endif
  
  void debug_enable _PARAMS((int, int));
  void debug_disable _PARAMS((int));
  void debug_flag _PARAMS((char *));
! #ifdef UNUSED_CODE
! void debug_reset _PARAMS((void));
! int debug_ok _PARAMS((int, int));
! #endif /* UNUSED_CODE */
  
  #define HOST_CACHE_TTL 3600
  
  typedef struct _host {
!     char key[SQUIDHOSTNAMELEN];	/* www.bar.com */
!     char fqdn[SQUIDHOSTNAMELEN];	/* real.bar.com */
!     char dotaddr[16];		/* 128.138.213.10 */
!     char ipaddr[4];
!     time_t last_t;		/* last access of this info */
!     int n;			/* # of requests for this host */
!     int addrlen;		/* length of 'ipaddr', always 4 */
      struct _host *next;
  } Host;
  
! extern Host *thisHost;
  
! void host_cache_init _PARAMS((void));
! Host *get_host _PARAMS((char *hostname));
! int delete_host _PARAMS((Host * h));
! int expire_host_cache _PARAMS((time_t timeout));
! void dump_host_cache _PARAMS((int, int));
  
  
  
***************
*** 106,121 ****
  char *mkhttpdlogtime _PARAMS((time_t *));
  extern char *mkrfc850 _PARAMS((time_t *));
  extern time_t parse_rfc850 _PARAMS((char *str));
! extern void init_log3 _PARAMS((char *pn, FILE *a, FILE *b));
  extern void debug_init();
  extern void log_errno2 _PARAMS((char *, int, char *));
  
  #if defined(__STRICT_ANSI__)
! extern void Log _PARAMS((char *, ...));
! extern void errorlog  _PARAMS((char *, ...));
  #else
! extern void Log ();
! extern void errorlog ();
  #endif /* __STRICT_ANSI__ */
  
  
--- 107,122 ----
  char *mkhttpdlogtime _PARAMS((time_t *));
  extern char *mkrfc850 _PARAMS((time_t *));
  extern time_t parse_rfc850 _PARAMS((char *str));
! extern void init_log3 _PARAMS((char *pn, FILE * a, FILE * b));
  extern void debug_init();
  extern void log_errno2 _PARAMS((char *, int, char *));
  
  #if defined(__STRICT_ANSI__)
! extern void Log _PARAMS((char *,...));
! extern void errorlog _PARAMS((char *,...));
  #else
! extern void Log();
! extern void errorlog();
  #endif /* __STRICT_ANSI__ */
  
  
diff -cr squid-1.0.beta6/include/version.h squid-1.0.beta7/include/version.h
*** squid-1.0.beta6/include/version.h	Wed May 01 15:23:16 1996
--- squid-1.0.beta7/include/version.h	Tue May 07 09:51:38 1996
***************
*** 1,7 ****
! /* $Id: version.h,v 1.19.4.5 1996/05/01 22:23:16 wessels Exp $
   *
   *  SQUID_VERSION - String for version id of this distribution
   */
  #ifndef SQUID_VERSION
! #define SQUID_VERSION	"1.0.beta6"
  #endif
--- 1,7 ----
! /* $Id: version.h,v 1.19.4.6 1996/05/07 16:51:38 wessels Exp $
   *
   *  SQUID_VERSION - String for version id of this distribution
   */
  #ifndef SQUID_VERSION
! #define SQUID_VERSION	"1.0.beta7"
  #endif
diff -cr squid-1.0.beta6/lib/debug.c squid-1.0.beta7/lib/debug.c
*** squid-1.0.beta6/lib/debug.c	Mon Mar 18 17:29:11 1996
--- squid-1.0.beta7/lib/debug.c	Wed May 08 19:33:01 1996
***************
*** 1,5 ****
! /* $Id: debug.c,v 1.3 1996/03/19 01:29:11 wessels Exp $ */
  
  #include <stdlib.h>
  #include <string.h>
  #define MAIN
--- 1,9 ----
! /* $Id: debug.c,v 1.3.2.2 1996/05/09 02:33:01 wessels Exp $ */
  
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
  #include <stdlib.h>
  #include <string.h>
  #define MAIN
***************
*** 8,13 ****
--- 12,18 ----
  int Harvest_debug_levels[MAX_DEBUG_LEVELS];
  int Harvest_do_debug = 0;
  
+ #ifdef UNUSED_CODE
  /*
   *  debug_reset() - Reset debugging routines.
   */
***************
*** 19,24 ****
--- 24,30 ----
  	Harvest_debug_levels[i] = -1;
      Harvest_do_debug = 0;
  }
+ #endif /* UNUSED_CODE */
  
  /*
   *  debug_enable() - Enables debugging output for section s, level l.
***************
*** 48,53 ****
--- 54,60 ----
      Harvest_debug_levels[s] = -1;
  }
  
+ #ifdef UNUSED_CODE
  /*
   *  debug_ok() - Returns non-zero if the caller is debugging the
   *  given section and level.  If level is -2, then all debugging is used.
***************
*** 77,82 ****
--- 84,90 ----
      return 0;
  #endif
  }
+ #endif /* UNUSED_CODE */
  
  /*
   *  debug_flag() - Processes a -D flag and runs debug_enable()
***************
*** 132,137 ****
      u = strtok(t, " \t\n");
      do {
  	debug_flag(u);
!     } while ((u = strtok((char *) 0, " \t\n")) != (char *) NULL);
      xfree(t);
  }
--- 140,145 ----
      u = strtok(t, " \t\n");
      do {
  	debug_flag(u);
!     } while ((u = strtok((char *) 0, " \t\n")) != NULL);
      xfree(t);
  }
diff -cr squid-1.0.beta6/lib/getfullhostname.c squid-1.0.beta7/lib/getfullhostname.c
*** squid-1.0.beta6/lib/getfullhostname.c	Sat Apr 13 20:25:23 1996
--- squid-1.0.beta7/lib/getfullhostname.c	Tue May 07 09:50:39 1996
***************
*** 1,5 ****
  
! /* $Id: getfullhostname.c,v 1.4 1996/04/14 03:25:23 wessels Exp $ */
  
  #include <stdio.h>
  #include <stdlib.h>
--- 1,9 ----
  
! /* $Id: getfullhostname.c,v 1.4.2.1 1996/05/07 16:50:39 wessels Exp $ */
! 
! #include "config.h"
! #include "autoconf.h"
! #include "version.h"
  
  #include <stdio.h>
  #include <stdlib.h>
diff -cr squid-1.0.beta6/lib/host_cache.c squid-1.0.beta7/lib/host_cache.c
*** squid-1.0.beta6/lib/host_cache.c	Sat Apr 13 20:25:24 1996
--- squid-1.0.beta7/lib/host_cache.c	Wed May 08 19:33:02 1996
***************
*** 1,5 ****
- /* $Id: host_cache.c,v 1.5 1996/04/14 03:25:24 wessels Exp $ */
  
  #include <string.h>
  #include <stdlib.h>
  #include <memory.h>
--- 1,10 ----
  
+ /* $Id: host_cache.c,v 1.5.2.2 1996/05/09 02:33:02 wessels Exp $ */
+ 
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
  #include <string.h>
  #include <stdlib.h>
  #include <memory.h>
***************
*** 16,21 ****
--- 21,27 ----
  #define HASHTABLE_M		  9
  
  static Host HostTable[HASHTABLE_N];
+ static int hash_index _PARAMS((char *buf));
  
  static int hash_index(buf)
       char *buf;
***************
*** 22,29 ****
  {
      static int n = HASHTABLE_N;
      static int m = HASHTABLE_M;
!     register int val = 0;
!     register char *s;
  
      for (s = buf; *s; s++)
  	val += (int) (*s * m);
--- 28,35 ----
  {
      static int n = HASHTABLE_N;
      static int m = HASHTABLE_M;
!     int val = 0;
!     char *s = NULL;
  
      for (s = buf; *s; s++)
  	val += (int) (*s * m);
***************
*** 127,137 ****
  	}
      } else {
  	H = gethostbyname(hn);
! 	if (H == (struct hostent *) NULL)
  	    Debug(86, 1, ("new_host: gethostbyname(%s) failed.\n", hn));
      }
  
!     if (H == (struct hostent *) NULL) {
  	Debug(86, 1, ("new_host: %s: unknown host\n", hn));
  	xfree(hn);
  	return 0;
--- 133,143 ----
  	}
      } else {
  	H = gethostbyname(hn);
! 	if (H == NULL)
  	    Debug(86, 1, ("new_host: gethostbyname(%s) failed.\n", hn));
      }
  
!     if (H == NULL) {
  	Debug(86, 1, ("new_host: %s: unknown host\n", hn));
  	xfree(hn);
  	return 0;
***************
*** 152,157 ****
--- 158,164 ----
      return h;
  }
  
+ #ifdef UNUSED_CODE
  void dump_host_cache(d_sec, d_lvl)
       int d_sec;
       int d_lvl;
***************
*** 168,173 ****
--- 175,181 ----
  	}
      }
  }
+ #endif /* UNUSED_CODE */
  
  
  /* ========== MISC UTIL FUNCS ============================================== */
diff -cr squid-1.0.beta6/lib/log.c squid-1.0.beta7/lib/log.c
*** squid-1.0.beta6/lib/log.c	Sat Apr 13 20:25:16 1996
--- squid-1.0.beta7/lib/log.c	Wed May 08 19:33:02 1996
***************
*** 1,6 ****
  
! /* $Id: log.c,v 1.3 1996/04/14 03:25:16 wessels Exp $ */
  
  #include <stdio.h>
  #include <string.h>
  #include <unistd.h>
--- 1,10 ----
  
! /* $Id: log.c,v 1.3.2.2 1996/05/09 02:33:02 wessels Exp $ */
  
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
  #include <stdio.h>
  #include <string.h>
  #include <unistd.h>
***************
*** 17,23 ****
  #include "util.h"
  
  /* Local functions */
! static char *standard_msg();
  
  /* Local variables */
  static FILE *fp_log = NULL;
--- 21,27 ----
  #include "util.h"
  
  /* Local functions */
! static char *standard_msg _PARAMS((void));
  
  /* Local variables */
  static FILE *fp_log = NULL;
***************
*** 26,31 ****
--- 30,36 ----
  static char *pname = NULL;
  static char lbuf[2048];
  
+ #ifdef UNUSED_CODE
  /*
   *  init_log() - Initializes the logging routines.  Log() prints to 
   *  FILE *a, and errorlog() prints to FILE *b;
***************
*** 42,47 ****
--- 47,53 ----
      if (fp_errs)
  	setbuf(fp_errs, NULL);
  }
+ #endif
  
  void init_log3(pn, a, b)
       char *pn;
***************
*** 164,169 ****
--- 170,176 ----
      exit(1);
  }
  
+ #ifdef UNUSED_CODE
  /*
   *  log_errno() - Same as perror(); doesn't print when errno == 0
   */
***************
*** 173,178 ****
--- 180,186 ----
      if (errno != 0)
  	errorlog("%s: %s\n", s, strerror(errno));
  }
+ #endif
  
  /*
   *  log_errno2() - Same as perror(); doesn't print when errno == 0
***************
*** 187,192 ****
--- 195,201 ----
  }
  
  
+ #ifdef UNUSED_CODE
  /*
   *  fatal_errno() - Same as perror()
   */
***************
*** 195,200 ****
--- 204,211 ----
  {
      fatal("%s: %s\n", s, strerror(errno));
  }
+ 
+ #endif
  
  /*
   *  standard_msg() - Prints the standard pid and timestamp
diff -cr squid-1.0.beta6/lib/rfc1738.c squid-1.0.beta7/lib/rfc1738.c
*** squid-1.0.beta6/lib/rfc1738.c	Thu Feb 29 00:15:23 1996
--- squid-1.0.beta7/lib/rfc1738.c	Wed May 08 19:33:03 1996
***************
*** 1,5 ****
! /* $Id: rfc1738.c,v 1.2 1996/02/29 08:15:23 wessels Exp $ */
  
  #include <stdio.h>
  #include <string.h>
  #include "util.h"
--- 1,9 ----
! /* $Id: rfc1738.c,v 1.2.2.2 1996/05/09 02:33:03 wessels Exp $ */
  
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
  #include <stdio.h>
  #include <string.h>
  #include "util.h"
***************
*** 51,57 ****
  	    }
  	}
  	/* RFC 1738 says any control chars (0x00-0x1F) are encoded */
! 	if ((*p >= (char) 0x00) && (*p <= (char) 0x1F)) {
  	    do_escape = 1;
  	}
  	/* RFC 1738 says 0x7f is encoded */
--- 55,61 ----
  	    }
  	}
  	/* RFC 1738 says any control chars (0x00-0x1F) are encoded */
! 	if (*p <= (char) 0x1F) {
  	    do_escape = 1;
  	}
  	/* RFC 1738 says 0x7f is encoded */
diff -cr squid-1.0.beta6/lib/rfc850.c squid-1.0.beta7/lib/rfc850.c
*** squid-1.0.beta6/lib/rfc850.c	Sun Apr 14 20:50:49 1996
--- squid-1.0.beta7/lib/rfc850.c	Wed May 08 19:33:03 1996
***************
*** 1,5 ****
! /* $Id: rfc850.c,v 1.4 1996/04/15 03:50:49 wessels Exp $ */
  
  /*
   *  Adapted from HTSUtils.c in CERN httpd 3.0 (http://info.cern.ch/httpd/)
   *  by Darren Hardy <hardy@cs.colorado.edu>, November 1994.
--- 1,10 ----
! /* $Id: rfc850.c,v 1.4.2.2 1996/05/09 02:33:03 wessels Exp $ */
  
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
+ 
  /*
   *  Adapted from HTSUtils.c in CERN httpd 3.0 (http://info.cern.ch/httpd/)
   *  by Darren Hardy <hardy@cs.colorado.edu>, November 1994.
***************
*** 11,16 ****
--- 16,25 ----
  #include <time.h>
  #include <sys/time.h>
  #include "config.h"
+ #include "util.h"
+ 
+ static int make_month _PARAMS((char *s));
+ static int make_num _PARAMS((char *s));
  
  static char *month_names[12] =
  {
diff -cr squid-1.0.beta6/lib/util.c squid-1.0.beta7/lib/util.c
*** squid-1.0.beta6/lib/util.c	Wed May 01 16:46:42 1996
--- squid-1.0.beta7/lib/util.c	Wed May 08 19:33:04 1996
***************
*** 1,5 ****
! /* $Id: util.c,v 1.6.2.1 1996/05/01 23:46:42 wessels Exp $ */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
--- 1,9 ----
! /* $Id: util.c,v 1.6.2.3 1996/05/09 02:33:04 wessels Exp $ */
  
+ #include "config.h"
+ #include "autoconf.h"
+ #include "version.h"
+ 
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
***************
*** 9,15 ****
  #endif
  #include <errno.h>
  
! void (*failure_notify) () = NULL;
  static char msg[128];
  
  extern int sys_nerr;
--- 13,21 ----
  #endif
  #include <errno.h>
  
! #include "util.h"
! 
! void (*failure_notify) _PARAMS((char *)) = NULL;
  static char msg[128];
  
  extern int sys_nerr;
***************
*** 17,25 ****
  extern char *sys_errlist[];
  #endif
  
- #include "autoconf.h"
  
- 
  #if XMALLOC_DEBUG
  #define DBG_ARRY_SZ (2<<8)
  #define DBG_ARRY_BKTS (2<<8)
--- 23,29 ----
***************
*** 34,43 ****
  static void check_init()
  {
      for (B = 0; B < DBG_ARRY_SZ; B++) {
!       for (I = 0; I < DBG_ARRY_SZ; I++) {
! 	malloc_ptrs[B][I] = NULL;
! 	malloc_size[B][I] = 0;
!       }
      }
      dbg_initd = 1;
  }
--- 38,47 ----
  static void check_init()
  {
      for (B = 0; B < DBG_ARRY_SZ; B++) {
! 	for (I = 0; I < DBG_ARRY_SZ; I++) {
! 	    malloc_ptrs[B][I] = NULL;
! 	    malloc_size[B][I] = 0;
! 	}
      }
      dbg_initd = 1;
  }
***************
*** 204,210 ****
       char *s;
  {
      static char *p = NULL;
!     int sz;
  
      if (s == NULL) {
  	if (failure_notify) {
--- 208,214 ----
       char *s;
  {
      static char *p = NULL;
!     size_t sz;
  
      if (s == NULL) {
  	if (failure_notify) {
***************
*** 215,221 ****
  	exit(1);
      }
      sz = strlen(s);
!     p = (char *) xmalloc((size_t) sz + 1);
      memcpy(p, s, sz);		/* copy string */
      p[sz] = '\0';		/* terminate string */
      return (p);
--- 219,225 ----
  	exit(1);
      }
      sz = strlen(s);
!     p = xmalloc((size_t) sz + 1);
      memcpy(p, s, sz);		/* copy string */
      p[sz] = '\0';		/* terminate string */
      return (p);
***************
*** 246,252 ****
  
  #if !HAVE_STRERROR
  char *strerror(n)
! int n;
  {
      return (xstrerror(n));
  }
--- 250,256 ----
  
  #if !HAVE_STRERROR
  char *strerror(n)
!      int n;
  {
      return (xstrerror(n));
  }
diff -cr squid-1.0.beta6/scripts/RunCache.in squid-1.0.beta7/scripts/RunCache.in
*** squid-1.0.beta6/scripts/RunCache.in	Wed May 01 16:46:45 1996
--- squid-1.0.beta7/scripts/RunCache.in	Mon May 06 07:57:20 1996
***************
*** 1,10 ****
  #!/bin/sh
  #
! #  $Id: RunCache.in,v 1.3.2.2 1996/05/01 23:46:45 wessels Exp $
  
  prefix=@prefix@
  exec_prefix=@exec_prefix@
! PATH=@bindir@:/bin
  export PATH
  
  conf=""
--- 1,10 ----
  #!/bin/sh
  #
! #  $Id: RunCache.in,v 1.3.2.3 1996/05/06 14:57:20 wessels Exp $
  
  prefix=@prefix@
  exec_prefix=@exec_prefix@
! PATH=@bindir@:/bin:/usr/bin
  export PATH
  
  conf=""
diff -cr squid-1.0.beta6/src/acl.c squid-1.0.beta7/src/acl.c
*** squid-1.0.beta6/src/acl.c	Wed May 01 16:46:48 1996
--- squid-1.0.beta7/src/acl.c	Wed May 08 19:31:50 1996
***************
*** 1,4 ****
! /* "$Id: acl.c,v 1.12.2.4 1996/05/01 23:46:48 wessels Exp $" */
  
  /*
   * DEBUG: Section 28          acl
--- 1,4 ----
! /* "$Id: acl.c,v 1.12.2.5 1996/05/09 02:31:50 wessels Exp $" */
  
  /*
   * DEBUG: Section 28          acl
***************
*** 13,20 ****
--- 13,38 ----
  static struct _acl *AclList = NULL;
  static struct _acl **AclListTail = &AclList;
  
+ static void aclDestroyAclList _PARAMS((struct _acl_list * list));
+ static void aclDestroyIpList _PARAMS((struct _acl_ip_data * data));
+ static void aclDestroyRegexList _PARAMS((struct _relist * data));
+ static void aclDestroyTimeList _PARAMS((struct _acl_time_data * data));
+ static struct _acl *aclFindByName _PARAMS((char *name));
  static int aclMatchAcl _PARAMS((struct _acl *, struct in_addr, method_t, protocol_t, char *host, int port, char *request));
  static int aclMatchAclList _PARAMS((struct _acl_list *, struct in_addr, method_t, protocol_t, char *host, int port, char *request));
+ static int aclMatchInteger _PARAMS((intlist * data, int i));
+ static int aclMatchIp _PARAMS((struct _acl_ip_data * data, struct in_addr c));
+ static int aclMatchRegex _PARAMS((relist * data, char *word));
+ static int aclMatchTime _PARAMS((struct _acl_time_data * data, time_t when));
+ static int aclMatchWord _PARAMS((wordlist * data, char *word));
+ static intlist *aclParseIntlist _PARAMS((void));
+ static struct _acl_ip_data *aclParseIpList _PARAMS((void));
+ static intlist *aclParseMethodList _PARAMS((void));
+ static intlist *aclParseProtoList _PARAMS((void));
+ static struct _relist *aclParseRegexList _PARAMS((void));
+ static struct _acl_time_data *aclParseTimeSpec _PARAMS((void));
+ static wordlist *aclParseWordList _PARAMS((void));
+ static acl_t aclType _PARAMS((char *s));
  
  static acl_t aclType(s)
       char *s;
***************
*** 38,44 ****
      return ACL_NONE;
  }
  
! struct _acl *aclFindByName(name)
       char *name;
  {
      struct _acl *a;
--- 56,62 ----
      return ACL_NONE;
  }
  
! static struct _acl *aclFindByName(name)
       char *name;
  {
      struct _acl *a;
***************
*** 49,55 ****
  }
  
  
! intlist *aclParseIntlist()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
--- 67,73 ----
  }
  
  
! static intlist *aclParseIntlist()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
***************
*** 56,62 ****
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = (intlist *) xcalloc(1, sizeof(intlist));
  	q->i = atoi(t);
  	*(Tail) = q;
  	Tail = &q->next;
--- 74,80 ----
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = xcalloc(1, sizeof(intlist));
  	q->i = atoi(t);
  	*(Tail) = q;
  	Tail = &q->next;
***************
*** 64,70 ****
      return head;
  }
  
! intlist *aclParseProtoList()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
--- 82,88 ----
      return head;
  }
  
! static intlist *aclParseProtoList()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
***************
*** 71,77 ****
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = (intlist *) xcalloc(1, sizeof(intlist));
  	q->i = (int) urlParseProtocol(t);
  	*(Tail) = q;
  	Tail = &q->next;
--- 89,95 ----
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = xcalloc(1, sizeof(intlist));
  	q->i = (int) urlParseProtocol(t);
  	*(Tail) = q;
  	Tail = &q->next;
***************
*** 79,85 ****
      return head;
  }
  
! intlist *aclParseMethodList()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
--- 97,103 ----
      return head;
  }
  
! static intlist *aclParseMethodList()
  {
      intlist *head = NULL;
      intlist **Tail = &head;
***************
*** 86,92 ****
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = (intlist *) xcalloc(1, sizeof(intlist));
  	q->i = (int) urlParseMethod(t);
  	*(Tail) = q;
  	Tail = &q->next;
--- 104,110 ----
      intlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = xcalloc(1, sizeof(intlist));
  	q->i = (int) urlParseMethod(t);
  	*(Tail) = q;
  	Tail = &q->next;
***************
*** 94,100 ****
      return head;
  }
  
! struct _acl_ip_data *aclParseIpList()
  {
      char *t = NULL;
      struct _acl_ip_data *head = NULL;
--- 112,118 ----
      return head;
  }
  
! static struct _acl_ip_data *aclParseIpList()
  {
      char *t = NULL;
      struct _acl_ip_data *head = NULL;
***************
*** 106,112 ****
      int c;
  
      while ((t = strtok(NULL, w_space))) {
! 	q = (struct _acl_ip_data *) xcalloc(1, sizeof(struct _acl_ip_data));
  	a1 = a2 = a3 = a4 = 0;
  	if (!strcasecmp(t, "all")) {
  	    lmask.s_addr = 0;
--- 124,130 ----
      int c;
  
      while ((t = strtok(NULL, w_space))) {
! 	q = xcalloc(1, sizeof(struct _acl_ip_data));
  	a1 = a2 = a3 = a4 = 0;
  	if (!strcasecmp(t, "all")) {
  	    lmask.s_addr = 0;
***************
*** 156,168 ****
      return head;
  }
  
! struct _acl_time_data *aclParseTimeSpec()
  {
      struct _acl_time_data *data = NULL;
      int h1, m1, h2, m2;
      char *t = NULL;
  
!     data = (struct _acl_time_data *) xcalloc(1, sizeof(struct _acl_time_data));
      while ((t = strtok(NULL, w_space))) {
  	if (*t < '0' || *t > '9') {
  	    /* assume its day-of-week spec */
--- 174,186 ----
      return head;
  }
  
! static struct _acl_time_data *aclParseTimeSpec()
  {
      struct _acl_time_data *data = NULL;
      int h1, m1, h2, m2;
      char *t = NULL;
  
!     data = xcalloc(1, sizeof(struct _acl_time_data));
      while ((t = strtok(NULL, w_space))) {
  	if (*t < '0' || *t > '9') {
  	    /* assume its day-of-week spec */
***************
*** 226,232 ****
      return data;
  }
  
! struct _relist *aclParseRegexList()
  {
      relist *head = NULL;
      relist **Tail = &head;
--- 244,250 ----
      return data;
  }
  
! static struct _relist *aclParseRegexList()
  {
      relist *head = NULL;
      relist **Tail = &head;
***************
*** 240,246 ****
  	    debug(28, 0, "aclParseRegexList: Invalid regular expression: '%s'\n", t);
  	    continue;
  	}
! 	q = (relist *) xcalloc(1, sizeof(relist));
  	q->pattern = xstrdup(t);
  	q->regex = comp;
  	*(Tail) = q;
--- 258,264 ----
  	    debug(28, 0, "aclParseRegexList: Invalid regular expression: '%s'\n", t);
  	    continue;
  	}
! 	q = xcalloc(1, sizeof(relist));
  	q->pattern = xstrdup(t);
  	q->regex = comp;
  	*(Tail) = q;
***************
*** 249,255 ****
      return head;
  }
  
! wordlist *aclParseWordList()
  {
      wordlist *head = NULL;
      wordlist **Tail = &head;
--- 267,273 ----
      return head;
  }
  
! static wordlist *aclParseWordList()
  {
      wordlist *head = NULL;
      wordlist **Tail = &head;
***************
*** 256,262 ****
      wordlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = (wordlist *) xcalloc(1, sizeof(wordlist));
  	q->key = xstrdup(t);
  	*(Tail) = q;
  	Tail = &q->next;
--- 274,280 ----
      wordlist *q = NULL;
      char *t = NULL;
      while ((t = strtok(NULL, w_space))) {
! 	q = xcalloc(1, sizeof(wordlist));
  	q->key = xstrdup(t);
  	*(Tail) = q;
  	Tail = &q->next;
***************
*** 272,278 ****
      char *t = NULL;
      struct _acl *A = NULL;
  
!     A = (struct _acl *) xcalloc(1, sizeof(struct _acl));
      /* snarf the ACL name */
      if ((t = strtok(NULL, w_space)) == NULL) {
  	debug(28, 0, "%s line %d: %s\n",
--- 290,296 ----
      char *t = NULL;
      struct _acl *A = NULL;
  
!     A = xcalloc(1, sizeof(struct _acl));
      /* snarf the ACL name */
      if ((t = strtok(NULL, w_space)) == NULL) {
  	debug(28, 0, "%s line %d: %s\n",
***************
*** 330,336 ****
  	xfree(A);
  	return;
  	/* NOTREACHED */
- 	break;
      }
      A->cfgline = xstrdup(config_input_line);
      *AclListTail = A;
--- 348,353 ----
***************
*** 355,361 ****
  	debug(28, 0, "aclParseAccessLine: missing 'allow' or 'deny'.\n");
  	return;
      }
!     A = (struct _acl_access *) xcalloc(1, sizeof(struct _acl_access));
      if (!strcmp(t, "allow"))
  	A->allow = 1;
      else if (!strcmp(t, "deny"))
--- 372,378 ----
  	debug(28, 0, "aclParseAccessLine: missing 'allow' or 'deny'.\n");
  	return;
      }
!     A = xcalloc(1, sizeof(struct _acl_access));
      if (!strcmp(t, "allow"))
  	A->allow = 1;
      else if (!strcmp(t, "deny"))
***************
*** 372,378 ****
       * by '!' for negation */
      Tail = &A->acl_list;
      while ((t = strtok(NULL, w_space))) {
! 	L = (struct _acl_list *) xcalloc(1, sizeof(struct _acl_list));
  	L->op = 1;		/* defaults to non-negated */
  	if (*t == '!') {
  	    /* negated ACL */
--- 389,395 ----
       * by '!' for negation */
      Tail = &A->acl_list;
      while ((t = strtok(NULL, w_space))) {
! 	L = xcalloc(1, sizeof(struct _acl_list));
  	L->op = 1;		/* defaults to non-negated */
  	if (*t == '!') {
  	    /* negated ACL */
***************
*** 404,410 ****
      *T = A;
  }
  
! int aclMatchIp(data, c)
       struct _acl_ip_data *data;
       struct in_addr c;
  {
--- 421,427 ----
      *T = A;
  }
  
! static int aclMatchIp(data, c)
       struct _acl_ip_data *data;
       struct in_addr c;
  {
***************
*** 423,429 ****
      return 0;
  }
  
! int aclMatchWord(data, word)
       wordlist *data;
       char *word;
  {
--- 440,446 ----
      return 0;
  }
  
! static int aclMatchWord(data, word)
       wordlist *data;
       char *word;
  {
***************
*** 438,444 ****
      }
      return 0;
  }
! int aclMatchRegex(data, word)
       relist *data;
       char *word;
  {
--- 455,462 ----
      }
      return 0;
  }
! 
! static int aclMatchRegex(data, word)
       relist *data;
       char *word;
  {
***************
*** 453,459 ****
      }
      return 0;
  }
! int aclMatchInteger(data, i)
       intlist *data;
       int i;
  {
--- 471,478 ----
      }
      return 0;
  }
! 
! static int aclMatchInteger(data, i)
       intlist *data;
       int i;
  {
***************
*** 465,471 ****
      return 0;
  }
  
! int aclMatchTime(data, when)
       struct _acl_time_data *data;
       time_t when;
  {
--- 484,490 ----
      return 0;
  }
  
! static int aclMatchTime(data, when)
       struct _acl_time_data *data;
       time_t when;
  {
***************
*** 502,537 ****
      case ACL_SRC_IP:
  	return aclMatchIp(acl->data, c);
  	/* NOTREACHED */
- 	break;
      case ACL_DST_DOMAIN:
  	return aclMatchWord(acl->data, h);
  	/* NOTREACHED */
- 	break;
      case ACL_TIME:
  	return aclMatchTime(acl->data, squid_curtime);
  	/* NOTREACHED */
- 	break;
      case ACL_URL_REGEX:
  	return aclMatchRegex(acl->data, r);
  	/* NOTREACHED */
- 	break;
      case ACL_URL_PORT:
  	return aclMatchInteger(acl->data, po);
  	/* NOTREACHED */
- 	break;
      case ACL_USER:
  	debug(28, 0, "aclMatchAcl: ACL_USER unimplemented\n");
  	return 0;
  	/* NOTREACHED */
- 	break;
      case ACL_PROTO:
  	return aclMatchInteger(acl->data, pr);
  	/* NOTREACHED */
- 	break;
      case ACL_METHOD:
  	return aclMatchInteger(acl->data, m);
  	/* NOTREACHED */
- 	break;
      case ACL_NONE:
      default:
  	debug(28, 0, "aclMatchAcl: '%s' has bad type %d\n",
--- 521,548 ----
***************
*** 538,545 ****
  	    acl->name, acl->type);
  	return 0;
      }
!     fatal_dump("aclMatchAcl: This should never happen.");
!     return 0;
  }
  
  static int aclMatchAclList(list, c, m, pr, h, po, r)
--- 549,555 ----
  	    acl->name, acl->type);
  	return 0;
      }
!     /* NOTREACHED */
  }
  
  static int aclMatchAclList(list, c, m, pr, h, po, r)
diff -cr squid-1.0.beta6/src/acl.h squid-1.0.beta7/src/acl.h
*** squid-1.0.beta6/src/acl.h	Mon Apr 15 18:51:16 1996
--- squid-1.0.beta7/src/acl.h	Wed May 08 19:31:51 1996
***************
*** 70,77 ****
  extern void aclDestroyAcls _PARAMS((void));
  extern void aclParseAccessLine _PARAMS((struct _acl_access **));
  extern void aclParseAclLine _PARAMS((void));
- extern int aclMatchInteger _PARAMS((intlist *, int));
- 
  
  extern struct _acl_access *HTTPAccessList;
  extern struct _acl_access *ICPAccessList;
--- 70,75 ----
diff -cr squid-1.0.beta6/src/cache_cf.c squid-1.0.beta7/src/cache_cf.c
*** squid-1.0.beta6/src/cache_cf.c	Thu May 02 17:11:58 1996
--- squid-1.0.beta7/src/cache_cf.c	Wed May 08 20:40:11 1996
***************
*** 1,4 ****
! /* $Id: cache_cf.c,v 1.53.4.11 1996/05/03 00:11:58 wessels Exp $ */
  
  /* DEBUG: Section 3             cache_cf: Configuration file parsing */
  
--- 1,4 ----
! /* $Id: cache_cf.c,v 1.53.4.14 1996/05/09 03:40:11 wessels Exp $ */
  
  /* DEBUG: Section 3             cache_cf: Configuration file parsing */
  
***************
*** 171,176 ****
--- 171,177 ----
  static void configSetFactoryDefaults _PARAMS((void));
  static void configFreeMemory _PARAMS((void));
  static void configDoConfigure _PARAMS((void));
+ static char *safe_xstrdup _PARAMS((char *p));
  static char fatal_str[BUFSIZ];
  
  void self_destruct()
***************
*** 364,370 ****
  
  #define GetInteger(var) \
  	token = strtok(NULL, w_space); \
! 	if( token == (char *) NULL) \
  		self_destruct(); \
  	if (sscanf(token, "%d", &var) != 1) \
  		self_destruct();
--- 365,371 ----
  
  #define GetInteger(var) \
  	token = strtok(NULL, w_space); \
! 	if( token == NULL) \
  		self_destruct(); \
  	if (sscanf(token, "%d", &var) != 1) \
  		self_destruct();
***************
*** 410,419 ****
  
      if (!(host = strtok(NULL, w_space)))
  	self_destruct();
!     while ((domain = strtok(NULL, ", \t\n"))) {
! 	if (neighbors_cf_domain(host, domain) == 0)
! 	    self_destruct();
!     }
  }
  
  
--- 411,418 ----
  
      if (!(host = strtok(NULL, w_space)))
  	self_destruct();
!     while ((domain = strtok(NULL, ", \t\n")))
! 	neighbors_cf_domain(host, domain);
  }
  
  
***************
*** 422,428 ****
      char *srcping;
  
      srcping = strtok(NULL, w_space);
!     if (srcping == (char *) NULL)
  	self_destruct();
  
      /* set source_ping, default is off. */
--- 421,427 ----
      char *srcping;
  
      srcping = strtok(NULL, w_space);
!     if (srcping == NULL)
  	self_destruct();
  
      /* set source_ping, default is off. */
***************
*** 440,446 ****
      char *abort;
  
      abort = strtok(NULL, w_space);
!     if (abort == (char *) NULL)
  	self_destruct();
  
      if (!strcasecmp(abort, "on") || !strcasecmp(abort, "quick"))
--- 439,445 ----
      char *abort;
  
      abort = strtok(NULL, w_space);
!     if (abort == NULL)
  	self_destruct();
  
      if (!strcasecmp(abort, "on") || !strcasecmp(abort, "quick"))
***************
*** 482,488 ****
      double d;
  
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      if (sscanf(token, "%lf", &d) != 1)
  	self_destruct();
--- 481,487 ----
      double d;
  
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      if (sscanf(token, "%lf", &d) != 1)
  	self_destruct();
***************
*** 555,561 ****
      int i;
  
      token = strtok(NULL, w_space);	/* token: regex pattern */
!     if (token == (char *) NULL)
  	self_destruct();
      pattern = xstrdup(token);
  
--- 554,560 ----
      int i;
  
      token = strtok(NULL, w_space);	/* token: regex pattern */
!     if (token == NULL)
  	self_destruct();
      pattern = xstrdup(token);
  
***************
*** 662,668 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.adminEmail);
      Config.adminEmail = xstrdup(token);
--- 661,667 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.adminEmail);
      Config.adminEmail = xstrdup(token);
***************
*** 673,679 ****
      char *token;
  
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      wordlistAdd(&Config.cache_dirs, token);
  }
--- 672,678 ----
      char *token;
  
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      wordlistAdd(&Config.cache_dirs, token);
  }
***************
*** 685,691 ****
      int i;
  
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Accel.host);
      Config.Accel.host = xstrdup(token);
--- 684,690 ----
      int i;
  
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Accel.host);
      Config.Accel.host = xstrdup(token);
***************
*** 702,708 ****
      char *proxy;
  
      proxy = strtok(NULL, w_space);
!     if (proxy == (char *) NULL)
  	self_destruct();
  
      /* set httpd_accel_with_proxy, default is off. */
--- 701,707 ----
      char *proxy;
  
      proxy = strtok(NULL, w_space);
!     if (proxy == NULL)
  	self_destruct();
  
      /* set httpd_accel_with_proxy, default is off. */
***************
*** 719,725 ****
      char *token;
  
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.effectiveUser);
      safe_free(Config.effectiveGroup);
--- 718,724 ----
      char *token;
  
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.effectiveUser);
      safe_free(Config.effectiveGroup);
***************
*** 726,732 ****
      Config.effectiveUser = xstrdup(token);
  
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	return;			/* group is optional */
      Config.effectiveGroup = xstrdup(token);
  }
--- 725,731 ----
      Config.effectiveUser = xstrdup(token);
  
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	return;			/* group is optional */
      Config.effectiveGroup = xstrdup(token);
  }
***************
*** 735,741 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Log.log);
      Config.Log.log = xstrdup(token);
--- 734,740 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Log.log);
      Config.Log.log = xstrdup(token);
***************
*** 745,751 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Log.access);
      Config.Log.access = xstrdup(token);
--- 744,750 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Log.access);
      Config.Log.access = xstrdup(token);
***************
*** 755,761 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Log.hierarchy);
      Config.Log.hierarchy = xstrdup(token);
--- 754,760 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Log.hierarchy);
      Config.Log.hierarchy = xstrdup(token);
***************
*** 765,771 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Log.store);
      Config.Log.store = xstrdup(token);
--- 764,770 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Log.store);
      Config.Log.store = xstrdup(token);
***************
*** 783,789 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Program.ftpget);
      Config.Program.ftpget = xstrdup(token);
--- 782,788 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Program.ftpget);
      Config.Program.ftpget = xstrdup(token);
***************
*** 793,799 ****
  {
      char *token;
      token = strtok(NULL, "");	/* Note "", don't separate these */
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Program.ftpget_opts);
      Config.Program.ftpget_opts = xstrdup(token);
--- 792,798 ----
  {
      char *token;
      token = strtok(NULL, "");	/* Note "", don't separate these */
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Program.ftpget_opts);
      Config.Program.ftpget_opts = xstrdup(token);
***************
*** 803,809 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Program.dnsserver);
      Config.Program.dnsserver = xstrdup(token);
--- 802,808 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Program.dnsserver);
      Config.Program.dnsserver = xstrdup(token);
***************
*** 813,819 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      if (!strcasecmp(token, "on") || !strcasecmp(token, "enable"))
  	Config.commonLogFormat = 1;
--- 812,818 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      if (!strcasecmp(token, "on") || !strcasecmp(token, "enable"))
  	Config.commonLogFormat = 1;
***************
*** 826,832 ****
      char *token;
      int i;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Wais.relayHost);
      Config.Wais.relayHost = xstrdup(token);
--- 825,831 ----
      char *token;
      int i;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Wais.relayHost);
      Config.Wais.relayHost = xstrdup(token);
***************
*** 848,854 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	return;
      wordlistAdd(&Config.http_stoplist, token);
  }
--- 847,853 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	return;
      wordlistAdd(&Config.http_stoplist, token);
  }
***************
*** 857,863 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	return;
      wordlistAdd(&Config.gopher_stoplist, token);
  }
--- 856,862 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	return;
      wordlistAdd(&Config.gopher_stoplist, token);
  }
***************
*** 865,871 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	return;
      wordlistAdd(&Config.ftp_stoplist, token);
  }
--- 864,870 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	return;
      wordlistAdd(&Config.ftp_stoplist, token);
  }
***************
*** 874,880 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      if (*token != '.')
  	self_destruct();
--- 873,879 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      if (*token != '.')
  	self_destruct();
***************
*** 886,892 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      debug(3, 1, "parseBindAddressLine: adding %s\n", token);
      wordlistAdd(&Config.bind_addr_list, token);
--- 885,891 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      debug(3, 1, "parseBindAddressLine: adding %s\n", token);
      wordlistAdd(&Config.bind_addr_list, token);
***************
*** 977,983 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      if (!strcasecmp(token, "on"))
  	Config.singleParentBypass = 1;
--- 976,982 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      if (!strcasecmp(token, "on"))
  	Config.singleParentBypass = 1;
***************
*** 988,994 ****
      char *token;
      token = strtok(NULL, "");	/* Note "", don't separate these */
      safe_free(Config.debugOptions);
!     if (token == (char *) NULL) {
  	Config.debugOptions = NULL;
  	return;
      }
--- 987,993 ----
      char *token;
      token = strtok(NULL, "");	/* Note "", don't separate these */
      safe_free(Config.debugOptions);
!     if (token == NULL) {
  	Config.debugOptions = NULL;
  	return;
      }
***************
*** 1000,1006 ****
      char *token;
      token = strtok(NULL, w_space);
      safe_free(Config.pidFilename);
!     if (token == (char *) NULL)
  	self_destruct();
      Config.pidFilename = xstrdup(token);
  }
--- 999,1005 ----
      char *token;
      token = strtok(NULL, w_space);
      safe_free(Config.pidFilename);
!     if (token == NULL)
  	self_destruct();
      Config.pidFilename = xstrdup(token);
  }
***************
*** 1010,1016 ****
      char *token;
      token = strtok(NULL, w_space);
      safe_free(Config.visibleHostname);
!     if (token == (char *) NULL)
  	self_destruct();
      Config.visibleHostname = xstrdup(token);
  }
--- 1009,1015 ----
      char *token;
      token = strtok(NULL, w_space);
      safe_free(Config.visibleHostname);
!     if (token == NULL)
  	self_destruct();
      Config.visibleHostname = xstrdup(token);
  }
***************
*** 1019,1025 ****
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.ftpUser);
      Config.ftpUser = xstrdup(token);
--- 1018,1024 ----
  {
      char *token;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.ftpUser);
      Config.ftpUser = xstrdup(token);
***************
*** 1038,1044 ****
      char *token;
      int i;
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	self_destruct();
      safe_free(Config.Announce.host);
      Config.Announce.host = xstrdup(token);
--- 1037,1043 ----
      char *token;
      int i;
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	self_destruct();
      safe_free(Config.Announce.host);
      Config.Announce.host = xstrdup(token);
***************
*** 1048,1054 ****
  	    Config.Announce.port = i;
      }
      token = strtok(NULL, w_space);
!     if (token == (char *) NULL)
  	return;
      safe_free(Config.Announce.file);
      Config.Announce.file = xstrdup(token);
--- 1047,1053 ----
  	    Config.Announce.port = i;
      }
      token = strtok(NULL, w_space);
!     if (token == NULL)
  	return;
      safe_free(Config.Announce.file);
      Config.Announce.file = xstrdup(token);
***************
*** 1502,1507 ****
--- 1501,1510 ----
  {
      return Config.Accel.prefix;
  }
+ int getAccelPort()
+ {
+     return Config.Accel.port;
+ }
  int getAccelWithProxy()
  {
      return Config.Accel.withProxy;
***************
*** 1643,1658 ****
  }
  
  
! char *safe_xstrdup(p)
       char *p;
  {
      return p ? xstrdup(p) : p;
- }
- 
- int safe_strlen(p)
-      char *p;
- {
-     return p ? strlen(p) : -1;
  }
  
  static void configFreeMemory()
--- 1646,1655 ----
  }
  
  
! static char *safe_xstrdup(p)
       char *p;
  {
      return p ? xstrdup(p) : p;
  }
  
  static void configFreeMemory()
diff -cr squid-1.0.beta6/src/cache_cf.h squid-1.0.beta7/src/cache_cf.h
*** squid-1.0.beta6/src/cache_cf.h	Wed May 01 12:43:49 1996
--- squid-1.0.beta7/src/cache_cf.h	Wed May 08 16:21:54 1996
***************
*** 1,5 ****
  
! /*  $Id: cache_cf.h,v 1.31.4.1 1996/05/01 19:43:49 wessels Exp $ */
  
  #ifndef _CACHE_CONFIG_H_
  #define _CACHE_CONFIG_H_
--- 1,5 ----
  
! /*  $Id: cache_cf.h,v 1.31.4.2 1996/05/08 23:21:54 wessels Exp $ */
  
  #ifndef _CACHE_CONFIG_H_
  #define _CACHE_CONFIG_H_
***************
*** 54,59 ****
--- 54,60 ----
  
  /* Global Functions */
  extern char *getAccelPrefix _PARAMS((void));
+ extern int getAccelPort _PARAMS((void));
  extern char *getAccessLogFile _PARAMS((void));
  extern char *getAdminEmail _PARAMS((void));
  extern char *getAnnounceFile _PARAMS((void));
diff -cr squid-1.0.beta6/src/cachemgr.c squid-1.0.beta7/src/cachemgr.c
*** squid-1.0.beta6/src/cachemgr.c	Thu May 02 18:12:50 1996
--- squid-1.0.beta7/src/cachemgr.c	Wed May 08 19:31:52 1996
***************
*** 1,4 ****
! /* $Id: cachemgr.c,v 1.7.2.6 1996/05/03 01:12:50 wessels Exp $ */
  
  #include "config.h"
  #include "autoconf.h"
--- 1,4 ----
! /* $Id: cachemgr.c,v 1.7.2.8 1996/05/09 02:31:52 wessels Exp $ */
  
  #include "config.h"
  #include "autoconf.h"
***************
*** 74,79 ****
--- 74,80 ----
      STATS_O,
      STATS_VM,
      STATS_U,
+     STATS_IO,
      SHUTDOWN,
      REFRESH,
  #ifdef REMOVE_OBJECT
***************
*** 93,98 ****
--- 94,100 ----
      "stats/objects",
      "stats/vm_objects",
      "stats/utilization",
+     "stats/io",
      "shutdown",
      "<refresh>",
  #ifdef REMOVE_OBJECT
***************
*** 158,163 ****
--- 160,166 ----
      printf("<OPTION VALUE=\"log\">Cache Log\n");
  #endif
      printf("<OPTION VALUE=\"stats/utilization\">Utilization\n");
+     printf("<OPTION VALUE=\"stats/io\">I/O\n");
      printf("<OPTION VALUE=\"stats/objects\">Objects\n");
      printf("<OPTION VALUE=\"stats/vm_objects\">VM_Objects\n");
      printf("<OPTION VALUE=\"server_list\">Cache Server List\n");
***************
*** 179,185 ****
  char *makeword(char *line, char stop)
  {
      int x = 0, y;
!     char *word = (char *) malloc(sizeof(char) * (strlen(line) + 1));
  
      for (x = 0; ((line[x]) && (line[x] != stop)); x++)
  	word[x] = line[x];
--- 182,188 ----
  char *makeword(char *line, char stop)
  {
      int x = 0, y;
!     char *word = xmalloc(sizeof(char) * (strlen(line) + 1));
  
      for (x = 0; ((line[x]) && (line[x] != stop)); x++)
  	word[x] = line[x];
***************
*** 196,209 ****
  /* A utility function from the NCSA httpd cgi-src utils.c */
  char *fmakeword(FILE * f, char stop, int *cl)
  {
!     int wsize;
!     char *word;
!     int ll;
  
!     wsize = 102400;
!     ll = 0;
!     word = (char *) malloc(sizeof(char) * (wsize + 1));
! 
      for (;;) {
  	word[ll] = (char) fgetc(f);
  	if (ll == wsize) {
--- 199,209 ----
  /* A utility function from the NCSA httpd cgi-src utils.c */
  char *fmakeword(FILE * f, char stop, int *cl)
  {
!     int wsize = 102400;
!     char *word = NULL;
!     int ll = 0;
  
!     word = xmalloc(sizeof(char) * (wsize + 1));
      for (;;) {
  	word[ll] = (char) fgetc(f);
  	if (ll == wsize) {
***************
*** 226,232 ****
  /* A utility function from the NCSA httpd cgi-src utils.c */
  char x2c(char *what)
  {
!     register char digit;
  
      digit = (what[0] >= 'A' ? ((what[0] & 0xdf) - 'A') + 10 : (what[0] - '0'));
      digit *= 16;
--- 226,232 ----
  /* A utility function from the NCSA httpd cgi-src utils.c */
  char x2c(char *what)
  {
!     char digit;
  
      digit = (what[0] >= 'A' ? ((what[0] & 0xdf) - 'A') + 10 : (what[0] - '0'));
      digit *= 16;
***************
*** 237,243 ****
  /* A utility function from the NCSA httpd cgi-src utils.c */
  void unescape_url(char *url)
  {
!     register int x, y;
  
      for (x = 0, y = 0; url[y]; ++x, ++y) {
  	if ((url[x] = url[y]) == '%') {
--- 237,243 ----
  /* A utility function from the NCSA httpd cgi-src utils.c */
  void unescape_url(char *url)
  {
!     int x, y;
  
      for (x = 0, y = 0; url[y]; ++x, ++y) {
  	if ((url[x] = url[y]) == '%') {
***************
*** 251,257 ****
  /* A utility function from the NCSA httpd cgi-src utils.c */
  void plustospace(char *str)
  {
!     register int x;
  
      for (x = 0; str[x]; x++)
  	if (str[x] == '+')
--- 251,257 ----
  /* A utility function from the NCSA httpd cgi-src utils.c */
  void plustospace(char *str)
  {
!     int x;
  
      for (x = 0; str[x]; x++)
  	if (str[x] == '+')
***************
*** 454,459 ****
--- 454,462 ----
      } else if (!strcmp(operation, "stats/utilization") ||
  	!strcmp(operation, "Utilization")) {
  	op = STATS_U;
+     } else if (!strcmp(operation, "stats/io") ||
+ 	!strcmp(operation, "I/O")) {
+ 	op = STATS_IO;
      } else if (!strcmp(operation, "shutdown")) {
  	op = SHUTDOWN;
      } else if (!strcmp(operation, "refresh")) {
***************
*** 477,482 ****
--- 480,486 ----
      case STATS_O:
      case STATS_VM:
      case STATS_U:
+     case STATS_IO:
  	sprintf(msg, "GET cache_object://%s/%s HTTP/1.0\r\n\r\n",
  	    hostname, op_cmds[op]);
  	break;
***************
*** 515,520 ****
--- 519,525 ----
      printf("<OPTION VALUE=\"log\">Cache Log\n");
  #endif
      printf("<OPTION VALUE=\"stats/utilization\">Utilization\n");
+     printf("<OPTION VALUE=\"stats/io\">I/O\n");
      printf("<OPTION VALUE=\"stats/objects\">Objects\n");
      printf("<OPTION VALUE=\"stats/vm_objects\">VM_Objects\n");
      printf("<OPTION VALUE=\"server_list\">Cache Server List\n");
***************
*** 559,564 ****
--- 564,570 ----
      case STATS_G:
      case STATS_O:
      case STATS_VM:
+     case STATS_IO:
      case SHUTDOWN:
      case REFRESH:
  	break;
***************
*** 621,626 ****
--- 627,633 ----
  		case SERVER:
  		case LOG:
  		case STATS_G:
+ 		case STATS_IO:
  		case SHUTDOWN:
  		    p_state = 1;
  		    printf("%s", reserve);
diff -cr squid-1.0.beta6/src/comm.c squid-1.0.beta7/src/comm.c
*** squid-1.0.beta6/src/comm.c	Thu May 02 13:52:29 1996
--- squid-1.0.beta7/src/comm.c	Wed May 08 19:31:53 1996
***************
*** 1,5 ****
  
! /* $Id: comm.c,v 1.30.4.5 1996/05/02 20:52:29 wessels Exp $ */
  
  /* DEBUG: Section 5             comm: socket level functions */
  
--- 1,5 ----
  
! /* $Id: comm.c,v 1.30.4.7 1996/05/09 02:31:53 wessels Exp $ */
  
  /* DEBUG: Section 5             comm: socket level functions */
  
***************
*** 65,71 ****
      struct in_addr *addr = NULL;
  
      addr = getAddress(host);
!     if (addr == (struct in_addr *) NULL) {
  	debug(5, 0, "do_bind: Unknown host: %s\n", host);
  	return COMM_ERROR;
      }
--- 65,71 ----
      struct in_addr *addr = NULL;
  
      addr = getAddress(host);
!     if (addr == NULL) {
  	debug(5, 0, "do_bind: Unknown host: %s\n", host);
  	return COMM_ERROR;
      }
***************
*** 138,144 ****
  	for (p = getBindAddrList(); p; p = p->next) {
  	    if (do_bind(new_socket, p->key, port) == COMM_OK)
  		break;
! 	    if (p->next == (wordlist *) NULL)
  		return COMM_ERROR;
  	}
      }
--- 138,144 ----
  	for (p = getBindAddrList(); p; p = p->next) {
  	    if (do_bind(new_socket, p->key, port) == COMM_OK)
  		break;
! 	    if (p->next == NULL)
  		return COMM_ERROR;
  	}
      }
***************
*** 586,597 ****
  		xstrerror(), errno);
  	    examine_select(&readfds, &writefds, &exceptfds);
  	    return COMM_ERROR;
  	}
  	if (num < 0)
  	    continue;
  
  	debug(5, num ? 5 : 8, "comm_select: %d sockets ready at %d\n",
! 	    num, squid_curtime);
  
  	/* Check lifetime and timeout handlers ONCE each second.
  	 * Replaces brain-dead check every time through the loop! */
--- 586,598 ----
  		xstrerror(), errno);
  	    examine_select(&readfds, &writefds, &exceptfds);
  	    return COMM_ERROR;
+ 	    /* NOTREACHED */
  	}
  	if (num < 0)
  	    continue;
  
  	debug(5, num ? 5 : 8, "comm_select: %d sockets ready at %d\n",
! 	    num, (int) squid_curtime);
  
  	/* Check lifetime and timeout handlers ONCE each second.
  	 * Replaces brain-dead check every time through the loop! */
***************
*** 664,669 ****
--- 665,671 ----
  }
  
  
+ #ifdef UNUSED_CODE
  /* Select on fd to see if any io pending. */
  int comm_pending(fd, sec, usec)
       int fd;
***************
*** 704,709 ****
--- 706,712 ----
      }
      return COMM_TIMEOUT;
  }
+ #endif /* UNUSED_CODE */
  
  void comm_set_select_handler(fd, type, handler, client_data)
       int fd;
***************
*** 880,886 ****
       * Since getMaxFD can be as high as several thousand, don't waste them */
      RESERVED_FD = min(100, getMaxFD() / 4);
      /* hardwired lifetimes */
!     fd_lifetime = (int *) xmalloc(sizeof(int) * max_fd);
      for (i = 0; i < max_fd; i++)
  	comm_set_fd_lifetime(i, -1);	/* denotes invalid */
      zero_tv.tv_sec = 0;
--- 883,889 ----
       * Since getMaxFD can be as high as several thousand, don't waste them */
      RESERVED_FD = min(100, getMaxFD() / 4);
      /* hardwired lifetimes */
!     fd_lifetime = xmalloc(sizeof(int) * max_fd);
      for (i = 0; i < max_fd; i++)
  	comm_set_fd_lifetime(i, -1);	/* denotes invalid */
      zero_tv.tv_sec = 0;
diff -cr squid-1.0.beta6/src/comm.h squid-1.0.beta7/src/comm.h
*** squid-1.0.beta6/src/comm.h	Fri Apr 19 09:37:17 1996
--- squid-1.0.beta7/src/comm.h	Wed May 08 19:31:53 1996
***************
*** 1,5 ****
  
! /* $Id: comm.h,v 1.11.4.1 1996/04/19 16:37:17 wessels Exp $ */
  
  #ifndef COMM_H
  #define COMM_H
--- 1,5 ----
  
! /* $Id: comm.h,v 1.11.4.2 1996/05/09 02:31:53 wessels Exp $ */
  
  #ifndef COMM_H
  #define COMM_H
***************
*** 71,77 ****
--- 71,79 ----
  extern int comm_init _PARAMS((void));
  extern int comm_listen _PARAMS((int sock));
  extern int comm_open _PARAMS((unsigned int io_type, int port, PF, char *note));
+ #ifdef UNUSED_CODE
  extern int comm_pending _PARAMS((int fd, long sec, long usec));
+ #endif
  extern int comm_port _PARAMS((int fd));
  extern int comm_read _PARAMS((int fd, char *buf, int size));
  extern int comm_select _PARAMS((time_t sec, time_t));
diff -cr squid-1.0.beta6/src/debug.h squid-1.0.beta7/src/debug.h
*** squid-1.0.beta6/src/debug.h	Sat Apr 13 20:26:29 1996
--- squid-1.0.beta7/src/debug.h	Wed May 08 19:31:54 1996
***************
*** 1,4 ****
! /*  $Id: debug.h,v 1.10 1996/04/14 03:26:29 wessels Exp $ */
  
  #ifndef _DEBUG_H_
  #define _DEBUG_H_
--- 1,4 ----
! /*  $Id: debug.h,v 1.10.2.1 1996/05/09 02:31:54 wessels Exp $ */
  
  #ifndef _DEBUG_H_
  #define _DEBUG_H_
***************
*** 19,26 ****
  /* always define debug, but DEBUG not define set the db_level to 0 */
  
  #define debug \
! 	if ((_db_file = __FILE__) && \
! 	    (_db_line = __LINE__)) \
          _db_print
  
  #define safe_free(x)	if (x) { xxfree(x); x = NULL; }
--- 19,26 ----
  /* always define debug, but DEBUG not define set the db_level to 0 */
  
  #define debug \
! 	if (((_db_file = __FILE__)) && \
! 	    ((_db_line = __LINE__))) \
          _db_print
  
  #define safe_free(x)	if (x) { xxfree(x); x = NULL; }
diff -cr squid-1.0.beta6/src/disk.c squid-1.0.beta7/src/disk.c
*** squid-1.0.beta6/src/disk.c	Thu Apr 25 15:09:19 1996
--- squid-1.0.beta7/src/disk.c	Wed May 08 19:31:54 1996
***************
*** 1,4 ****
! /* $Id: disk.c,v 1.11.4.1 1996/04/25 22:09:19 wessels Exp $ */
  
  /* DEBUG: Section 6             disk: disk I/O routines */
  
--- 1,4 ----
! /* $Id: disk.c,v 1.11.4.2 1996/05/09 02:31:54 wessels Exp $ */
  
  /* DEBUG: Section 6             disk: disk I/O routines */
  
***************
*** 74,84 ****
  /* initialize table */
  int disk_init()
  {
!     int fd, max_fd = getMaxFD();
  
!     file_table = (FileEntry *) xmalloc(sizeof(FileEntry) * max_fd);
!     memset(file_table, '\0', sizeof(FileEntry) * max_fd);
! 
      for (fd = 0; fd < max_fd; fd++) {
  	file_table[fd].filename[0] = '\0';
  	file_table[fd].at_eof = NO;
--- 74,83 ----
  /* initialize table */
  int disk_init()
  {
!     int fd;
!     int max_fd = getMaxFD();
  
!     file_table = xcalloc(1, sizeof(FileEntry) * max_fd);
      for (fd = 0; fd < max_fd; fd++) {
  	file_table[fd].filename[0] = '\0';
  	file_table[fd].at_eof = NO;
***************
*** 221,226 ****
--- 220,226 ----
  }
  
  
+ #ifdef NOTUSED_CODE
  /* return a opened fd associate with given path name. */
  /* return DISK_FILE_NOT_FOUND if not found. */
  int file_get_fd(filename)
***************
*** 236,241 ****
--- 236,242 ----
      }
      return DISK_FILE_NOT_FOUND;
  }
+ #endif /* NOTUSED_CODE */
  
  /* grab a writing lock for file */
  int file_write_lock(fd)
***************
*** 504,511 ****
  {
      dread_ctrl *ctrl_dat;
  
!     ctrl_dat = (dread_ctrl *) xmalloc(sizeof(dread_ctrl));
!     memset(ctrl_dat, '\0', sizeof(dread_ctrl));
      ctrl_dat->fd = fd;
      ctrl_dat->offset = offset;
      ctrl_dat->req_len = req_len;
--- 505,511 ----
  {
      dread_ctrl *ctrl_dat;
  
!     ctrl_dat = xcalloc(1, sizeof(dread_ctrl));
      ctrl_dat->fd = fd;
      ctrl_dat->offset = offset;
      ctrl_dat->req_len = req_len;
***************
*** 604,614 ****
  {
      dwalk_ctrl *walk_dat;
  
!     walk_dat = (dwalk_ctrl *) xmalloc(sizeof(dwalk_ctrl));
!     memset(walk_dat, '\0', sizeof(dwalk_ctrl));
      walk_dat->fd = fd;
      walk_dat->offset = 0;
!     walk_dat->buf = (void *) xcalloc(1, DISK_LINE_LEN);
      walk_dat->cur_len = 0;
      walk_dat->handler = handler;
      walk_dat->client_data = client_data;
--- 604,613 ----
  {
      dwalk_ctrl *walk_dat;
  
!     walk_dat = xcalloc(1, sizeof(dwalk_ctrl));
      walk_dat->fd = fd;
      walk_dat->offset = 0;
!     walk_dat->buf = xcalloc(1, DISK_LINE_LEN);
      walk_dat->cur_len = 0;
      walk_dat->handler = handler;
      walk_dat->client_data = client_data;
diff -cr squid-1.0.beta6/src/disk.h squid-1.0.beta7/src/disk.h
*** squid-1.0.beta6/src/disk.h	Fri Apr 05 09:48:29 1996
--- squid-1.0.beta7/src/disk.h	Wed May 08 19:31:55 1996
***************
*** 1,4 ****
! /*  $Id: disk.h,v 1.5 1996/04/05 17:48:29 wessels Exp $ */
  
  #ifndef DISK_H
  #define DISK_H
--- 1,4 ----
! /*  $Id: disk.h,v 1.5.2.1 1996/05/09 02:31:55 wessels Exp $ */
  
  #ifndef DISK_H
  #define DISK_H
***************
*** 35,41 ****
--- 35,43 ----
  	int       (*line_handler)
  	          (int fd, char *buf, int size, void *line_data),
  	void *line_data));
+ #ifdef NOTUSED_CODE
  extern int file_get_fd _PARAMS((char *filename));
+ #endif
  extern int file_update_open _PARAMS((int fd, char *path));
  extern int file_write_lock _PARAMS((int fd));
  extern int disk_init _PARAMS((void));
diff -cr squid-1.0.beta6/src/dnsserver.c squid-1.0.beta7/src/dnsserver.c
*** squid-1.0.beta6/src/dnsserver.c	Wed May 01 16:46:50 1996
--- squid-1.0.beta7/src/dnsserver.c	Wed May 08 19:31:55 1996
***************
*** 1,4 ****
! /* $Id: dnsserver.c,v 1.5.2.1 1996/05/01 23:46:50 wessels Exp $ */
  
  #include "squid.h"
  
--- 1,4 ----
! /* $Id: dnsserver.c,v 1.5.2.2 1996/05/09 02:31:55 wessels Exp $ */
  
  #include "squid.h"
  
***************
*** 109,115 ****
  	memset(request, '\0', 256);
  
  	/* read from ipcache */
! 	if (fgets(request, 255, stdin) == (char *) NULL)
  	    exit(1);
  	if ((t = strrchr(request, '\n')) != NULL)
  	    *t = '\0';		/* strip NL */
--- 109,115 ----
  	memset(request, '\0', 256);
  
  	/* read from ipcache */
! 	if (fgets(request, 255, stdin) == NULL)
  	    exit(1);
  	if ((t = strrchr(request, '\n')) != NULL)
  	    *t = '\0';		/* strip NL */
diff -cr squid-1.0.beta6/src/errorpage.c squid-1.0.beta7/src/errorpage.c
*** squid-1.0.beta6/src/errorpage.c	Fri Apr 19 14:38:40 1996
--- squid-1.0.beta7/src/errorpage.c	Wed May 08 19:31:56 1996
***************
*** 1,4 ****
! /* $Id: errorpage.c,v 1.20.2.1 1996/04/19 21:38:40 wessels Exp $ */
  
  /* DEBUG: Section 4             errorpage: Error printing routines */
  
--- 1,4 ----
! /* $Id: errorpage.c,v 1.20.2.2 1996/05/09 02:31:56 wessels Exp $ */
  
  /* DEBUG: Section 4             errorpage: Error printing routines */
  
***************
*** 101,108 ****
  
  void errorInitialize()
  {
!     tmp_error_buf = (char *) xmalloc(MAX_URL * 4);
!     tbuf = (char *) xmalloc(MAX_URL * 3);
  }
  
  
--- 101,108 ----
  
  void errorInitialize()
  {
!     tmp_error_buf = xmalloc(MAX_URL * 4);
!     tbuf = xmalloc(MAX_URL * 3);
  }
  
  
***************
*** 191,202 ****
       char *address;
       int code;
  {
-     int index;
- 
      *tmp_error_buf = '\0';
      if (type < ERR_MIN || type > ERR_MAX)
  	fatal_dump("squid_error_url: type out of range.");
-     index = (int) (type - ERR_MIN);
  
      sprintf(tmp_error_buf, "HTTP/1.0 %d Cache Detected Error\r\nContent-type: text/html\r\n\r\n", code);
      sprintf(tbuf, SQUID_REQUEST_ERROR_MSG,
--- 191,199 ----
diff -cr squid-1.0.beta6/src/fdstat.c squid-1.0.beta7/src/fdstat.c
*** squid-1.0.beta6/src/fdstat.c	Thu Apr 25 15:08:30 1996
--- squid-1.0.beta7/src/fdstat.c	Wed May 08 19:31:56 1996
***************
*** 1,5 ****
  
! /* $Id: fdstat.c,v 1.13.4.1 1996/04/25 22:08:30 wessels Exp $ */
  
  /* DEBUG: Section 7             fdstat: */
  
--- 1,5 ----
  
! /* $Id: fdstat.c,v 1.13.4.2 1996/05/09 02:31:56 wessels Exp $ */
  
  /* DEBUG: Section 7             fdstat: */
  
***************
*** 50,59 ****
  int fdstat_init(preopen)
       int preopen;
  {
!     int i, max_fd = getMaxFD();
  
!     fd_stat_tab = (FDENTRY *) xmalloc(sizeof(FDENTRY) * max_fd);
!     memset(fd_stat_tab, '\0', sizeof(FDENTRY) * max_fd);
      for (i = 0; i < preopen; ++i) {
  	fd_stat_tab[i].status = OPEN;
  	fd_stat_tab[i].type = File;
--- 50,59 ----
  int fdstat_init(preopen)
       int preopen;
  {
!     int i;
!     int max_fd = getMaxFD();
  
!     fd_stat_tab = xcalloc(1, sizeof(FDENTRY) * max_fd);
      for (i = 0; i < preopen; ++i) {
  	fd_stat_tab[i].status = OPEN;
  	fd_stat_tab[i].type = File;
***************
*** 150,155 ****
--- 150,156 ----
  }
  
  
+ #ifdef UNUSED_CODE
  char *fd_describe(fd)
       int fd;
  {
***************
*** 166,171 ****
--- 167,173 ----
  	return ("File");
      }
  }
+ #endif /* UNUSED_CODE */
  
  int fdstat_are_n_free_fd(n)
       int n;
diff -cr squid-1.0.beta6/src/fdstat.h squid-1.0.beta7/src/fdstat.h
*** squid-1.0.beta6/src/fdstat.h	Wed Apr 24 20:43:55 1996
--- squid-1.0.beta7/src/fdstat.h	Wed May 08 19:31:57 1996
***************
*** 1,4 ****
! /* $Id: fdstat.h,v 1.3.2.1 1996/04/25 03:43:55 wessels Exp $ */
  
  #ifndef FDSTAT_H
  #define FDSTAT_H
--- 1,4 ----
! /* $Id: fdstat.h,v 1.3.2.2 1996/05/09 02:31:57 wessels Exp $ */
  
  #ifndef FDSTAT_H
  #define FDSTAT_H
***************
*** 14,20 ****
--- 14,22 ----
  } File_Desc_Type;
  
  extern File_Desc_Type fdstat_type _PARAMS((int fd));
+ #ifdef UNUSED_CODE
  extern char *fd_describe _PARAMS((int fd));
+ #endif
  extern int fdstat_biggest_fd _PARAMS((void));
  extern int fdstat_init _PARAMS((int preopen));
  extern int fdstat_isopen _PARAMS((int fd));
diff -cr squid-1.0.beta6/src/ftp.c squid-1.0.beta7/src/ftp.c
*** squid-1.0.beta6/src/ftp.c	Thu May 02 19:33:50 1996
--- squid-1.0.beta7/src/ftp.c	Wed May 08 16:23:24 1996
***************
*** 1,4 ****
! /* $Id: ftp.c,v 1.37.2.14 1996/05/03 02:33:50 wessels Exp $ */
  
  /*
   * DEBUG: Section 9           ftp: FTP
--- 1,4 ----
! /* $Id: ftp.c,v 1.37.2.16 1996/05/08 23:23:24 wessels Exp $ */
  
  /*
   * DEBUG: Section 9           ftp: FTP
***************
*** 6,13 ****
  
  #include "squid.h"
  
! #define FTP_DELETE_GAP  (64*1024)
! #define READBUFSIZ	4096
  #define MAGIC_MARKER    "\004\004\004"	/* No doubt this should be more configurable */
  #define MAGIC_MARKER_SZ 3
  
--- 6,13 ----
  
  #include "squid.h"
  
! #define FTP_DELETE_GAP  (1<<18)
! #define READBUFSIZ	(1<<14)
  #define MAGIC_MARKER    "\004\004\004"	/* No doubt this should be more configurable */
  #define MAGIC_MARKER_SZ 3
  
***************
*** 258,296 ****
      int len;
      int clen;
      int off;
      StoreEntry *entry = NULL;
  
      entry = data->entry;
!     if (entry->flag & DELETE_BEHIND) {
! 	if (storeClientWaiting(entry)) {
! 	    /* check if we want to defer reading */
! 	    clen = entry->mem_obj->e_current_len;
! 	    off = entry->mem_obj->e_lowest_offset;
! 	    if ((clen - off) > FTP_DELETE_GAP) {
! 		debug(9, 3, "ftpReadReply: Read deferred for Object: %s\n",
! 		    entry->url);
! 		debug(9, 3, "--> Current Gap: %d bytes\n", clen - off);
! 		/* reschedule, so it will automatically be reactivated when
! 		 * Gap is big enough. */
! 		comm_set_select_handler(fd,
! 		    COMM_SELECT_READ,
! 		    (PF) ftpReadReply,
! 		    (void *) data);
! 		/* dont try reading again for a while */
! 		comm_set_stall(fd, getStallDelay());
! 		return 0;
! 	    }
! 	} else {
! 	    /* we can terminate connection right now */
! 	    squid_error_entry(entry, ERR_NO_CLIENTS_BIG_OBJ, NULL);
! 	    comm_close(fd);
! 	    return 0;
! 	}
      }
      errno = 0;
      len = read(fd, buf, READBUFSIZ);
      debug(9, 5, "ftpReadReply: FD %d, Read %d bytes\n", fd, len);
! 
      if (len < 0) {
  	debug(9, 1, "ftpReadReply: read error: %s\n", xstrerror());
  	if (errno == EAGAIN || errno == EWOULDBLOCK) {
--- 258,301 ----
      int len;
      int clen;
      int off;
+     int bin;
      StoreEntry *entry = NULL;
  
      entry = data->entry;
!     if (entry->flag & DELETE_BEHIND && !storeClientWaiting(entry)) {
! 	/* we can terminate connection right now */
! 	squid_error_entry(entry, ERR_NO_CLIENTS_BIG_OBJ, NULL);
! 	comm_close(fd);
! 	return 0;
      }
+     /* check if we want to defer reading */
+     clen = entry->mem_obj->e_current_len;
+     off = storeGetLowestReaderOffset(entry);
+     if ((clen - off) > FTP_DELETE_GAP) {
+ 	IOStats.Ftp.reads_deferred++;
+ 	debug(11, 3, "ftpReadReply: Read deferred for Object: %s\n",
+ 	    entry->url);
+ 	debug(11, 3, "                Current Gap: %d bytes\n", clen - off);
+ 	/* reschedule, so it will be automatically reactivated
+ 	 * when Gap is big enough. */
+ 	comm_set_select_handler(fd,
+ 	    COMM_SELECT_READ,
+ 	    (PF) ftpReadReply,
+ 	    (void *) data);
+ 	/* NOTE there is no read timeout handler to disable */
+ 	/* dont try reading again for a while */
+ 	comm_set_stall(fd, getStallDelay());
+ 	return 0;
+     }
      errno = 0;
+     IOStats.Ftp.reads++;
      len = read(fd, buf, READBUFSIZ);
      debug(9, 5, "ftpReadReply: FD %d, Read %d bytes\n", fd, len);
!     if (len > 0) {
! 	for (clen = len - 1, bin = 0; clen; bin++)
! 	    clen >>= 1;
! 	IOStats.Ftp.read_hist[bin]++;
!     }
      if (len < 0) {
  	debug(9, 1, "ftpReadReply: read error: %s\n", xstrerror());
  	if (errno == EAGAIN || errno == EWOULDBLOCK) {
***************
*** 317,323 ****
  	    /* If we didn't see the magic marker, assume the transfer
  	     * failed and arrange so the object gets ejected and
  	     * never gets to disk. */
! 	    debug(9, 1, "ftpReadReply: Didn't see magic marker, purging <URL:%s>.\n", entry->url);
  	    entry->expires = squid_curtime + getNegativeTTL();
  	    BIT_RESET(entry->flag, CACHABLE);
  	    storeReleaseRequest(entry);
--- 322,328 ----
  	    /* If we didn't see the magic marker, assume the transfer
  	     * failed and arrange so the object gets ejected and
  	     * never gets to disk. */
! 	    debug(9, 1, "ftpReadReply: Purging '%s'\n", entry->url);
  	    entry->expires = squid_curtime + getNegativeTTL();
  	    BIT_RESET(entry->flag, CACHABLE);
  	    storeReleaseRequest(entry);
diff -cr squid-1.0.beta6/src/ftpget.c squid-1.0.beta7/src/ftpget.c
*** squid-1.0.beta6/src/ftpget.c	Fri May 03 13:30:30 1996
--- squid-1.0.beta7/src/ftpget.c	Wed May 08 19:31:58 1996
***************
*** 1,4 ****
! /* $Id: ftpget.c,v 1.23.2.24 1996/05/03 20:30:30 wessels Exp $ */
  
  /*
   *    NOTES
--- 1,4 ----
! /* $Id: ftpget.c,v 1.23.2.26 1996/05/09 02:31:58 wessels Exp $ */
  
  /*
   *    NOTES
***************
*** 164,173 ****
      FAIL_HARD			/* do cache these */
  } state_t;
  
- #define DFD_TYPE_NONE 0
- #define DFD_TYPE_PASV 1
- #define DFD_TYPE_PORT 2
- 
  typedef struct _request {
      char *host;
      int port;
--- 164,169 ----
***************
*** 181,187 ****
      int cfd;
      int sfd;
      int dfd;
-     int dfd_type;
      int conn_att;
      int login_att;
      state_t state;
--- 177,182 ----
***************
*** 867,873 ****
  	else
  	    quit = (buf[2] >= '0' && buf[2] <= '9' && buf[3] == ' ');
  	if (!quit) {
! 	    l = (list_t *) xmalloc(sizeof(list_t));
  	    l->ptr = xstrdup(&buf[4]);
  	    l->next = NULL;
  	    *Tail = l;
--- 862,868 ----
  	else
  	    quit = (buf[2] >= '0' && buf[2] <= '9' && buf[3] == ' ');
  	if (!quit) {
! 	    l = xmalloc(sizeof(list_t));
  	    l->ptr = xstrdup(&buf[4]);
  	    l->next = NULL;
  	    *Tail = l;
***************
*** 900,906 ****
      int x;
  
      len = strlen(buf) + 2;
!     xbuf = (char *) xmalloc(len + 1);
      sprintf(xbuf, "%s\r\n", buf);
      Debug(26, 1, ("send_cmd: %s\n", buf));
      x = write_with_timeout(fd, xbuf, len);
--- 895,901 ----
      int x;
  
      len = strlen(buf) + 2;
!     xbuf = xmalloc(len + 1);
      sprintf(xbuf, "%s\r\n", buf);
      Debug(26, 1, ("send_cmd: %s\n", buf));
      x = write_with_timeout(fd, xbuf, len);
***************
*** 944,950 ****
  
  #define SEND_CBUF \
          if (send_cmd(r->sfd, cbuf) < 0) { \
!                 r->errmsg = (char *) xmalloc (SMALLBUFSIZ); \
                  sprintf(r->errmsg, "Failed to send '%s'", cbuf); \
                  r->rc = 4; \
                  return FAIL_SOFT; \
--- 939,945 ----
  
  #define SEND_CBUF \
          if (send_cmd(r->sfd, cbuf) < 0) { \
!                 r->errmsg = xmalloc (SMALLBUFSIZ); \
                  sprintf(r->errmsg, "Failed to send '%s'", cbuf); \
                  r->rc = 4; \
                  return FAIL_SOFT; \
***************
*** 951,956 ****
--- 946,991 ----
          }
  
  /*
+  *  close_dfd()
+  *  Close any open data channel
+  */
+ void close_dfd(r)
+      request_t *r;
+ {
+     if (r->dfd >= 0)
+ 	close(r->dfd);
+     r->flags &= ~F_NEEDACCEPT;
+     r->dfd = -1;
+ }
+ 
+ /*
+  *  is_dfd_open()
+  *  Check if a data channel is already open
+  */
+ int is_dfd_open(r)
+      request_t *r;
+ {
+     if (r->dfd >= 0 && !(r->flags & F_NEEDACCEPT)) {
+ 	fd_set R;
+ 	struct timeval tv;
+ 	FD_ZERO(&R);
+ 	FD_SET(r->dfd, &R);
+ 	tv.tv_sec = 0;
+ 	tv.tv_usec = 0;
+ 	if (select(r->dfd + 1, &R, NULL, NULL, &tv) == 0) {
+ 	    Debug(26, 3, ("Data channel already connected (FD=%d)\n", r->dfd));
+ 	    return 1;
+ 	} else {
+ 	    Debug(26, 2, ("Data channel closed by server (%s)\n", xstrerror()));
+ 	}
+     } else if (r->dfd >= 0) {
+ 	Debug(26, 2, ("Data socket not connected, closing\n"));
+     }
+     close_dfd(r);
+     return 0;
+ }
+ 
+ /*
   *  parse_request()
   *  Perform validity checks on request parameters.
   *    - lookup hostname
***************
*** 964,970 ****
  {
      Debug(26, 1, ("parse_request: looking up '%s'\n", r->host));
      if (get_host(r->host) == (Host *) NULL) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "Unknown host: %s", r->host);
  	r->rc = 10;
  	return FAIL_HARD;
--- 999,1005 ----
  {
      Debug(26, 1, ("parse_request: looking up '%s'\n", r->host));
      if (get_host(r->host) == (Host *) NULL) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "Unknown host: %s", r->host);
  	r->rc = 10;
  	return FAIL_HARD;
***************
*** 993,999 ****
      Debug(26, 1, ("do_connect: connect attempt #%d to '%s'\n",
  	    r->conn_att, r->host));
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_CONNECT;
--- 1028,1034 ----
      Debug(26, 1, ("do_connect: connect attempt #%d to '%s'\n",
  	    r->conn_att, r->host));
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_CONNECT;
***************
*** 1009,1015 ****
  	return FAIL_CONNECT;
      }
      if (x < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "%s (port %d): %s",
  	    r->host, r->port, xstrerror());
  	r->rc = 3;
--- 1044,1050 ----
  	return FAIL_CONNECT;
      }
      if (x < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "%s (port %d): %s",
  	    r->host, r->port, xstrerror());
  	r->rc = 3;
***************
*** 1178,1203 ****
      int port = 0;
      static int init = 0;
  
!     if (r->dfd >= 0 && r->dfd_type == DFD_TYPE_PORT) {
! 	fd_set R;
! 	struct timeval tv;
! 	FD_ZERO(&R);
! 	FD_SET(r->dfd, &R);
! 	tv.tv_sec = 0;
! 	tv.tv_usec = 0;
! 	if (select(r->dfd + 1, &R, NULL, NULL, &tv) == 0) {
! 	    Debug(26, 3, ("do_port: FD %d Already connected\n", r->dfd));
! 	    r->flags |= F_NEEDACCEPT;
! 	    return PORT_OK;
! 	} else {
! 	    Debug(26, 2, ("Data connection closed by server (%s)\n", xstrerror()));
! 	    close(r->dfd);
! 	    r->dfd = -1;
! 	    r->dfd_type = DFD_TYPE_NONE;
! 	}
!     }
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
--- 1213,1223 ----
      int port = 0;
      static int init = 0;
  
!     if (is_dfd_open(r))
! 	return PORT_OK;
! 
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
***************
*** 1224,1230 ****
  	    break;
  	if (++tries < 10)
  	    continue;
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "bind: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
--- 1244,1250 ----
  	    break;
  	if (++tries < 10)
  	    continue;
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "bind: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
***************
*** 1231,1237 ****
      }
  
      if (listen(sock, 1) < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "listen: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
--- 1251,1257 ----
      }
  
      if (listen(sock, 1) < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "listen: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
***************
*** 1250,1256 ****
      if ((code = read_reply(r->sfd)) > 0) {
  	if (code == 200) {
  	    r->dfd = sock;
- 	    r->dfd_type = DFD_TYPE_PORT;
  	    r->flags |= F_NEEDACCEPT;
  	    return PORT_OK;
  	}
--- 1270,1275 ----
***************
*** 1278,1304 ****
      if (!pasv_supported)
  	return PASV_FAIL;
  
!     if (r->dfd >= 0 && r->dfd_type == DFD_TYPE_PASV) {
! 	fd_set R;
! 	struct timeval tv;
! 	FD_ZERO(&R);
! 	FD_SET(r->dfd, &R);
! 	tv.tv_sec = 0;
! 	tv.tv_usec = 0;
! 	if (select(r->dfd + 1, &R, NULL, NULL, &tv) == 0) {
! 	    Debug(26, 3, ("do_pasv: FD %d Already connected\n", r->dfd));
! 	    return PORT_OK;
! 	} else {
! 	    Debug(26, 2, ("Data connection closed by server (%s)\n", xstrerror()));
! 	    close(r->dfd);
! 	    r->dfd = -1;
! 	    r->dfd_type = DFD_TYPE_NONE;
! 	}
!     }
!     r->flags &= ~F_NEEDACCEPT;
  
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
--- 1297,1308 ----
      if (!pasv_supported)
  	return PASV_FAIL;
  
!     /* If there already are a open data connection, use that */
!     if (is_dfd_open(r))
! 	return PORT_OK;
  
      if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "socket: %s", xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
***************
*** 1329,1341 ****
      S.sin_port = htons(port = ((p1 << 8) + p2));
  
      if (connect_with_timeout(sock, &S, sizeof(S)) < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "%s, port %d: %s", junk, port, xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
      }
      r->dfd = sock;
-     r->dfd_type = DFD_TYPE_PASV;
      return PORT_OK;
  }
  
--- 1333,1344 ----
      S.sin_port = htons(port = ((p1 << 8) + p2));
  
      if (connect_with_timeout(sock, &S, sizeof(S)) < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "%s, port %d: %s", junk, port, xstrerror());
  	r->rc = 2;
  	return FAIL_SOFT;
      }
      r->dfd = sock;
      return PORT_OK;
  }
  
***************
*** 1356,1362 ****
  	if (code >= 200 && code < 300)
  	    return CWD_OK;
  #ifdef TRY_CWD_FIRST
! 	if (!r->flags & F_ISDIR)
  	    return CWD_FAIL;
  #endif
  	r->errmsg = xstrdup(server_reply_msg);
--- 1359,1365 ----
  	if (code >= 200 && code < 300)
  	    return CWD_OK;
  #ifdef TRY_CWD_FIRST
! 	if (!(r->flags & F_ISDIR))
  	    return CWD_FAIL;
  #endif
  	r->errmsg = xstrdup(server_reply_msg);
***************
*** 1473,1488 ****
      if (sock == READ_TIMEOUT)
  	return request_timeout(r);
      if (sock < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "accept: %s", xstrerror());
  	r->rc = 3;
  	return FAIL_SOFT;
      }
!     r->flags &= ~F_NEEDACCEPT;
!     if (r->dfd >= 0)
! 	close(r->dfd);
      r->dfd = sock;
-     r->dfd_type = DFD_TYPE_PORT;
      return DATA_TRANSFER;
  }
  
--- 1476,1488 ----
      if (sock == READ_TIMEOUT)
  	return request_timeout(r);
      if (sock < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "accept: %s", xstrerror());
  	r->rc = 3;
  	return FAIL_SOFT;
      }
!     close_dfd(r);
      r->dfd = sock;
      return DATA_TRANSFER;
  }
  
***************
*** 1498,1518 ****
      if (n == READ_TIMEOUT) {
  	return request_timeout(r);
      } else if (n < 0) {
! 	if (r->dfd >= 0) {
! 	    close(r->dfd);
! 	    r->dfd = -1;
! 	    r->dfd_type = DFD_TYPE_NONE;
! 	}
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "read: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
      } else if (n == 0) {
! 	if (r->dfd >= 0) {
! 	    close(r->dfd);
! 	    r->dfd = -1;
! 	    r->dfd_type = DFD_TYPE_NONE;
! 	}
  	if ((code = read_reply(r->sfd)) > 0) {
  	    if (code == 226)
  		return TRANSFER_DONE;
--- 1498,1510 ----
      if (n == READ_TIMEOUT) {
  	return request_timeout(r);
      } else if (n < 0) {
! 	close_dfd(r);
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "read: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
      } else if (n == 0) {
! 	close_dfd(r);
  	if ((code = read_reply(r->sfd)) > 0) {
  	    if (code == 226)
  		return TRANSFER_DONE;
***************
*** 1525,1531 ****
      if (x == READ_TIMEOUT)
  	return request_timeout(r);
      if (x < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "write: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
--- 1517,1523 ----
      if (x == READ_TIMEOUT)
  	return request_timeout(r);
      if (x < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "write: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
***************
*** 1571,1578 ****
      if (*buf == '\0')
  	return NULL;
  
!     p = (parts_t *) xmalloc(sizeof(parts_t));
!     memset(p, '\0', sizeof(parts_t));
  
      n_tokens = 0;
      for (i = 0; i < MAX_TOKENS; i++)
--- 1563,1569 ----
      if (*buf == '\0')
  	return NULL;
  
!     p = xcalloc(1, sizeof(parts_t));
  
      n_tokens = 0;
      for (i = 0; i < MAX_TOKENS; i++)
***************
*** 1668,1676 ****
      char *ename = NULL;
      parts_t *parts = NULL;
  
!     link = (char *) xmalloc(MIDBUFSIZ);
!     icon = (char *) xmalloc(MIDBUFSIZ);
!     html = (char *) xmalloc(BIGBUFSIZ);
  
      /* check .. as special case */
      if (!strcmp(line, "..")) {
--- 1659,1667 ----
      char *ename = NULL;
      parts_t *parts = NULL;
  
!     link = xmalloc(MIDBUFSIZ);
!     icon = xmalloc(MIDBUFSIZ);
!     html = xmalloc(BIGBUFSIZ);
  
      /* check .. as special case */
      if (!strcmp(line, "..")) {
***************
*** 1772,1786 ****
  	xfree(tfname);
  	return;
      }
!     readme = (request_t *) xmalloc(sizeof(request_t));
!     memset(readme, '\0', sizeof(request_t));
! 
      readme->path = xstrdup("README");
      readme->cfd = fd;
      readme->sfd = r->sfd;
!     readme->dfd = r->dfd;
!     r->dfd = -1;
!     r->dfd_type = DFD_TYPE_NONE;
  #ifdef TRY_CWD_FIRST
      readme->state = CWD_FAIL;
  #else
--- 1763,1778 ----
  	xfree(tfname);
  	return;
      }
!     readme = xcalloc(1, sizeof(request_t));
      readme->path = xstrdup("README");
      readme->cfd = fd;
      readme->sfd = r->sfd;
!     if (is_dfd_open(r)) {
! 	readme->dfd = r->dfd;
! 	r->dfd = -1;
!     } else {
! 	readme->dfd = -1;
!     }
  #ifdef TRY_CWD_FIRST
      readme->state = CWD_FAIL;
  #else
***************
*** 1793,1805 ****
  	close(readme->cfd);
  	readme->cfd = -1;
      }
!     if (readme->dfd >= 0) {
! 	if (r->dfd == -1)
! 	    r->dfd = readme->dfd;
! 	else
! 	    close(readme->dfd);
  	readme->dfd = -1;
- 	readme->dfd_type = DFD_TYPE_NONE;
      }
      fp = fopen(tfname, "r");
      unlink(tfname);
--- 1785,1794 ----
  	close(readme->cfd);
  	readme->cfd = -1;
      }
!     if (is_dfd_open(readme)) {
! 	close_dfd(r);
! 	r->dfd = readme->dfd;
  	readme->dfd = -1;
      }
      fp = fopen(tfname, "r");
      unlink(tfname);
***************
*** 1881,1895 ****
  	    xfree(t);
  	}
      }
!     if (r->dfd >= 0) {
! 	close(r->dfd);
! 	r->dfd = -1;
! 	r->dfd_type = DFD_TYPE_NONE;
!     }
      if (n == READ_TIMEOUT) {
  	return request_timeout(r);
      } else if (n < 0) {
! 	r->errmsg = (char *) xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "read: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
--- 1870,1880 ----
  	    xfree(t);
  	}
      }
!     close_dfd(r);
      if (n == READ_TIMEOUT) {
  	return request_timeout(r);
      } else if (n < 0) {
! 	r->errmsg = xmalloc(SMALLBUFSIZ);
  	sprintf(r->errmsg, "read: %s", xstrerror());
  	r->rc = 4;
  	return FAIL_SOFT;
***************
*** 2061,2069 ****
  	    }
  	    break;
  	case FAIL_SOFT:
- 	    fail(r);
- 	    return (r->rc);
- 	    /* NOTREACHED */
  	case FAIL_HARD:
  	    fail(r);
  	    return (r->rc);
--- 2046,2051 ----
***************
*** 2236,2242 ****
  	log_errno2(__FILE__, __LINE__, fullprogname);
  	_exit(1);
      }
!     return 1;
  }
  
  void usage(argcount)
--- 2218,2224 ----
  	log_errno2(__FILE__, __LINE__, fullprogname);
  	_exit(1);
      }
!     /* NOTREACHED */
  }
  
  void usage(argcount)
***************
*** 2404,2410 ****
  	    continue;
  	} else if (!strcmp(*argv, "-C")) {
  	    if (--argc < 1)
! 		usage();
  	    argv++;
  	    j = k = 0;
  	    sscanf(*argv, "%d:%d", &j, &k);
--- 2386,2392 ----
  	    continue;
  	} else if (!strcmp(*argv, "-C")) {
  	    if (--argc < 1)
! 		usage(argc);
  	    argv++;
  	    j = k = 0;
  	    sscanf(*argv, "%d:%d", &j, &k);
***************
*** 2438,2445 ****
  	fprintf(stderr, "Wrong number of arguments left (%d)\n", argc);
  	usage(argc);
      }
!     r = (request_t *) xmalloc(sizeof(request_t));
!     memset(r, '\0', sizeof(request_t));
  
      if (strcmp(argv[0], "-") == 0) {
  	r->cfd = 1;
--- 2420,2426 ----
  	fprintf(stderr, "Wrong number of arguments left (%d)\n", argc);
  	usage(argc);
      }
!     r = xcalloc(1, sizeof(request_t));
  
      if (strcmp(argv[0], "-") == 0) {
  	r->cfd = 1;
***************
*** 2455,2461 ****
      r->port = port;
      r->sfd = -1;
      r->dfd = -1;
-     r->dfd_type = DFD_TYPE_NONE;
      r->size = -1;
      r->state = BEGIN;
      r->flags |= o_httpify ? F_HTTPIFY : 0;
--- 2436,2441 ----
***************
*** 2471,2478 ****
  
      len = 15 + strlen(r->user) + strlen(r->pass) + strlen(r->host)
  	+ strlen(r->path);
!     r->url = (char *) xmalloc(len);
!     r->title_url = (char *) xmalloc(len);
  
      *r->url = '\0';
      strcat(r->url, "ftp://");
--- 2451,2458 ----
  
      len = 15 + strlen(r->user) + strlen(r->pass) + strlen(r->host)
  	+ strlen(r->path);
!     r->url = xmalloc(len);
!     r->title_url = xmalloc(len);
  
      *r->url = '\0';
      strcat(r->url, "ftp://");
***************
*** 2500,2506 ****
  
      /* Make a copy of the escaped URL with some room to grow at the end */
      t = rfc1738_escape(r->url);
!     r->url_escaped = (char *) xmalloc(strlen(t) + 10);
      strcpy(r->url_escaped, t);
  
      rc = process_request(MainRequest = r);
--- 2480,2486 ----
  
      /* Make a copy of the escaped URL with some room to grow at the end */
      t = rfc1738_escape(r->url);
!     r->url_escaped = xmalloc(strlen(t) + 10);
      strcpy(r->url_escaped, t);
  
      rc = process_request(MainRequest = r);
***************
*** 2510,2517 ****
  	close(r->sfd);
      if (r->cfd >= 0)
  	close(r->cfd);
!     if (r->dfd >= 0)
! 	close(r->dfd);
      close(0);
      close(1);
      exit(rc);
--- 2490,2496 ----
  	close(r->sfd);
      if (r->cfd >= 0)
  	close(r->cfd);
!     close_dfd(r);
      close(0);
      close(1);
      exit(rc);
diff -cr squid-1.0.beta6/src/http.c squid-1.0.beta7/src/http.c
*** squid-1.0.beta6/src/http.c	Thu May 02 09:53:58 1996
--- squid-1.0.beta7/src/http.c	Wed May 08 16:23:25 1996
***************
*** 1,4 ****
! /* $Id: http.c,v 1.56.2.6 1996/05/02 16:53:58 wessels Exp $ */
  
  /*
   * DEBUG: Section 11          http: HTTP
--- 1,4 ----
! /* $Id: http.c,v 1.56.2.8 1996/05/08 23:23:25 wessels Exp $ */
  
  /*
   * DEBUG: Section 11          http: HTTP
***************
*** 232,237 ****
--- 232,238 ----
  {
      static char buf[READBUFSIZ];
      int len;
+     int bin;
      int clen;
      int off;
      StoreEntry *entry = NULL;
***************
*** 247,252 ****
--- 248,254 ----
      clen = entry->mem_obj->e_current_len;
      off = storeGetLowestReaderOffset(entry);
      if ((clen - off) > HTTP_DELETE_GAP) {
+ 	IOStats.Http.reads_deferred++;
  	debug(11, 3, "httpReadReply: Read deferred for Object: %s\n",
  	    entry->url);
  	debug(11, 3, "                Current Gap: %d bytes\n", clen - off);
***************
*** 256,262 ****
  	    COMM_SELECT_READ,
  	    (PF) httpReadReply,
  	    (void *) data);
! 	/* don't install read timeout until we are below the GAP */
  	comm_set_select_handler_plus_timeout(fd,
  	    COMM_SELECT_TIMEOUT,
  	    (PF) NULL,
--- 258,264 ----
  	    COMM_SELECT_READ,
  	    (PF) httpReadReply,
  	    (void *) data);
! 	/* disable read timeout until we are below the GAP */
  	comm_set_select_handler_plus_timeout(fd,
  	    COMM_SELECT_TIMEOUT,
  	    (PF) NULL,
***************
*** 267,275 ****
  	return;
      }
      errno = 0;
      len = read(fd, buf, READBUFSIZ);
      debug(11, 5, "httpReadReply: FD %d: len %d.\n", fd, len);
! 
      if (len < 0) {
  	debug(11, 2, "httpReadReply: FD %d: read failure: %s.\n",
  	    fd, xstrerror());
--- 269,282 ----
  	return;
      }
      errno = 0;
+     IOStats.Http.reads++;
      len = read(fd, buf, READBUFSIZ);
      debug(11, 5, "httpReadReply: FD %d: len %d.\n", fd, len);
!     if (len > 0) {
! 	for (clen = len - 1, bin = 0; clen; bin++)
! 	    clen >>= 1;
! 	IOStats.Http.read_hist[bin]++;
!     }
      if (len < 0) {
  	debug(11, 2, "httpReadReply: FD %d: read failure: %s.\n",
  	    fd, xstrerror());
diff -cr squid-1.0.beta6/src/icp.c squid-1.0.beta7/src/icp.c
*** squid-1.0.beta6/src/icp.c	Thu May 02 17:11:13 1996
--- squid-1.0.beta7/src/icp.c	Wed May 08 19:31:58 1996
***************
*** 1,6 ****
  
  
! /* $Id: icp.c,v 1.61.2.19 1996/05/03 00:11:13 wessels Exp $ */
  
  /*
   * DEBUG: Section 12          icp:
--- 1,6 ----
  
  
! /* $Id: icp.c,v 1.61.2.25 1996/05/09 02:31:58 wessels Exp $ */
  
  /*
   * DEBUG: Section 12          icp:
***************
*** 46,52 ****
      char *url;
      char *inbuf;
      int inbufsize;
!     int method;			/* GET, POST, ... */
      request_t *request;		/* Parsed URL ... */
      char *request_hdr;		/* Mime header */
      StoreEntry *entry;
--- 46,52 ----
      char *url;
      char *inbuf;
      int inbufsize;
!     method_t method;		/* GET, POST, ... */
      request_t *request;		/* Parsed URL ... */
      char *request_hdr;		/* Mime header */
      StoreEntry *entry;
***************
*** 161,167 ****
  {
      char *request = icpState->url;
      request_t *req = icpState->request;
!     int method = req->method;
      if (BIT_TEST(icpState->flags, REQ_AUTH))
  	return 0;
      if (req->protocol == PROTO_HTTP)
--- 161,167 ----
  {
      char *request = icpState->url;
      request_t *req = icpState->request;
!     method_t method = req->method;
      if (BIT_TEST(icpState->flags, REQ_AUTH))
  	return 0;
      if (req->protocol == PROTO_HTTP)
***************
*** 185,195 ****
  {
      char *request = icpState->url;
      request_t *req = icpState->request;
!     int method = req->method;
      if (BIT_TEST(icpState->flags, REQ_IMS))
  	return 0;
      if (BIT_TEST(icpState->flags, REQ_AUTH))
  	return 0;
      if (req->protocol == PROTO_HTTP)
  	return httpCachable(request, method);
      if (req->protocol == PROTO_FTP)
--- 185,197 ----
  {
      char *request = icpState->url;
      request_t *req = icpState->request;
!     method_t method = req->method;
      if (BIT_TEST(icpState->flags, REQ_IMS))
  	return 0;
      if (BIT_TEST(icpState->flags, REQ_AUTH))
  	return 0;
+     if (method != METHOD_GET)
+ 	return 0;
      if (req->protocol == PROTO_HTTP)
  	return httpCachable(request, method);
      if (req->protocol == PROTO_FTP)
***************
*** 198,205 ****
  	return gopherCachable(request);
      if (req->protocol == PROTO_WAIS)
  	return 0;
-     if (method == METHOD_CONNECT)
- 	return 0;
      if (req->protocol == PROTO_CACHEOBJ)
  	return 0;
      return 1;
--- 200,205 ----
***************
*** 439,445 ****
  	 * It probably timed out. */
  	debug(12, 2, "icpSendERROR: COMM_ERROR msg: %80.80s\n", msg);
  	/* comm_close(fd); */
! 	icpSendERRORComplete(fd, NULL, 0, 1, state);
  	return COMM_ERROR;
      }
      if (port != getAsciiPortNum()) {
--- 439,445 ----
  	 * It probably timed out. */
  	debug(12, 2, "icpSendERROR: COMM_ERROR msg: %80.80s\n", msg);
  	/* comm_close(fd); */
! 	icpSendERRORComplete(fd, (char *) NULL, 0, 1, state);
  	return COMM_ERROR;
      }
      if (port != getAsciiPortNum()) {
***************
*** 629,635 ****
      char *url = usm->url;
      char *pubkey = NULL;
      StoreEntry *entry = NULL;
-     int lock = 0;
  
      debug(12, 4, "icp_hit_or_miss: %s <URL:%s>\n",
  	RequestMethodStr[usm->method],
--- 629,634 ----
***************
*** 652,659 ****
      debug(12, 5, "icp_hit_or_miss: REQ_HIERARCHICAL = %s\n",
  	BIT_TEST(usm->flags, REQ_HIERARCHICAL) ? "SET" : "NOT SET");
  
-     /* XXX we should not even look here for CONNECT etc */
- 
      /* XXX hmm, should we check for IFMODSINCE and USER_REFRESH before
       * TCP_MISS?  It is possible to get IMS header for objects
       * not in the cache */
--- 651,656 ----
***************
*** 678,684 ****
      } else if (BIT_TEST(usm->flags, REQ_NOCACHE)) {
  	storeRelease(entry);
  	usm->log_type = LOG_TCP_USER_REFRESH;
!     } else if ((lock = storeLockObject(entry)) < 0) {
  	storeRelease(entry);
  	usm->log_type = LOG_TCP_SWAPIN_FAIL;
      } else {
--- 675,681 ----
      } else if (BIT_TEST(usm->flags, REQ_NOCACHE)) {
  	storeRelease(entry);
  	usm->log_type = LOG_TCP_USER_REFRESH;
!     } else if (storeLockObject(entry) < 0) {
  	storeRelease(entry);
  	usm->log_type = LOG_TCP_SWAPIN_FAIL;
      } else {
***************
*** 793,801 ****
  	    queue->msg,
  	    queue->len);
  	if (x < 0) {
! 	    if (errno != EWOULDBLOCK && errno != EAGAIN)
  		result = COMM_ERROR;
- 	    break;
  	}
  	UdpQueueHead = queue->next;
  	safe_free(queue->msg);
--- 790,799 ----
  	    queue->msg,
  	    queue->len);
  	if (x < 0) {
! 	    if (errno == EWOULDBLOCK || errno == EAGAIN)
! 		break;		/* don't de-queue */
! 	    else
  		result = COMM_ERROR;
  	}
  	UdpQueueHead = queue->next;
  	safe_free(queue->msg);
***************
*** 821,831 ****
      char *buf = NULL;
      int buf_len = sizeof(icp_common_t) + strlen(url) + 1;
      icp_common_t *headerp = NULL;
!     icpUdpData *data = (icpUdpData *) xmalloc(sizeof(icpUdpData));
      struct sockaddr_in our_socket_name;
      int sock_name_length = sizeof(our_socket_name);
      char *urloffset = NULL;
  
      if (getsockname(fd, (struct sockaddr *) &our_socket_name,
  	    &sock_name_length) == -1) {
  	debug(12, 1, "icpUdpSend: FD %d: getsockname failure: %s\n",
--- 819,836 ----
      char *buf = NULL;
      int buf_len = sizeof(icp_common_t) + strlen(url) + 1;
      icp_common_t *headerp = NULL;
!     icpUdpData *data = xmalloc(sizeof(icpUdpData));
      struct sockaddr_in our_socket_name;
      int sock_name_length = sizeof(our_socket_name);
      char *urloffset = NULL;
  
+ #ifdef CHECK_BAD_ADDRS
+     if (to->sin_addr.s_addr == 0xFFFFFFFF) {
+ 	debug(12, 0, "icpUdpSend: URL '%s'\n", url);
+ 	fatal_dump("icpUdpSend: BAD ADDRESS: 255.255.255.255");
+     }
+ #endif
+ 
      if (getsockname(fd, (struct sockaddr *) &our_socket_name,
  	    &sock_name_length) == -1) {
  	debug(12, 1, "icpUdpSend: FD %d: getsockname failure: %s\n",
***************
*** 1098,1109 ****
      int post_sz;
      int len;
  
      /* Use xmalloc/memcpy instead of xstrdup because inbuf might
       * contain NULL bytes; especially for POST data  */
!     inbuf = (char *) xmalloc(icpState->offset + 1);
      memcpy(inbuf, icpState->inbuf, icpState->offset);
      *(inbuf + icpState->offset) = '\0';
  
      if ((method = strtok(inbuf, "\t ")) == NULL) {
  	debug(12, 1, "parseHttpRequest: Can't get request method\n");
  	xfree(inbuf);
--- 1103,1120 ----
      int post_sz;
      int len;
  
+     /* Make sure a complete line has been received */
+     if (strchr(icpState->inbuf, '\n') == NULL) {
+ 	debug(12, 5, "Incomplete request line, waiting for more data");
+ 	return 0;
+     }
      /* Use xmalloc/memcpy instead of xstrdup because inbuf might
       * contain NULL bytes; especially for POST data  */
!     inbuf = xmalloc(icpState->offset + 1);
      memcpy(inbuf, icpState->inbuf, icpState->offset);
      *(inbuf + icpState->offset) = '\0';
  
+     /* Look for request method */
      if ((method = strtok(inbuf, "\t ")) == NULL) {
  	debug(12, 1, "parseHttpRequest: Can't get request method\n");
  	xfree(inbuf);
***************
*** 1116,1124 ****
  	return -1;
      }
      debug(12, 5, "parseHttpRequest: Method is '%s'\n", method);
- 
      BIT_SET(icpState->flags, REQ_HTML);
  
      if ((request = strtok(NULL, "\r\n\t ")) == NULL) {
  	debug(12, 1, "parseHttpRequest: Missing URL\n");
  	xfree(inbuf);
--- 1127,1135 ----
  	return -1;
      }
      debug(12, 5, "parseHttpRequest: Method is '%s'\n", method);
      BIT_SET(icpState->flags, REQ_HTML);
  
+     /* look for URL */
      if ((request = strtok(NULL, "\r\n\t ")) == NULL) {
  	debug(12, 1, "parseHttpRequest: Missing URL\n");
  	xfree(inbuf);
***************
*** 1139,1160 ****
  
      req_hdr = t;
      req_hdr_sz = icpState->offset - (req_hdr - inbuf);
!     icpState->request_hdr = (char *) xmalloc(req_hdr_sz + 1);
      memcpy(icpState->request_hdr, req_hdr, req_hdr_sz);
      *(icpState->request_hdr + req_hdr_sz) = '\0';
  
!     if (icpState->request_hdr) {
! 	debug(12, 5, "parseHttpRequest: Request Header is\n---\n%s\n---\n",
! 	    icpState->request_hdr);
!     } else {
! 	debug(12, 5, "parseHttpRequest: No Request Header present\n");
!     }
  
      if (icpState->method == METHOD_POST) {
  	/* Expect Content-Length: and POST data after the headers */
  	if ((t = mime_get_header(req_hdr, "Content-Length")) == NULL) {
  	    xfree(inbuf);
! 	    return 0;		/* not a complete request */
  	}
  	content_length = atoi(t);
  	debug(12, 3, "parseHttpRequest: Expecting POST Content-Length of %d\n",
--- 1150,1175 ----
  
      req_hdr = t;
      req_hdr_sz = icpState->offset - (req_hdr - inbuf);
! 
!     /* The request is received when a empty header line is receied */
!     if (!strstr(req_hdr, "\r\n\r\n") && !strstr(req_hdr, "\n\n")) {
! 	xfree(inbuf);
! 	return 0;		/* not a complete request */
!     }
!     /* Ok, all headers are received */
!     icpState->request_hdr = xmalloc(req_hdr_sz + 1);
      memcpy(icpState->request_hdr, req_hdr, req_hdr_sz);
      *(icpState->request_hdr + req_hdr_sz) = '\0';
  
!     debug(12, 5, "parseHttpRequest: Request Header is\n---\n%s\n---\n",
! 	icpState->request_hdr);
  
      if (icpState->method == METHOD_POST) {
  	/* Expect Content-Length: and POST data after the headers */
  	if ((t = mime_get_header(req_hdr, "Content-Length")) == NULL) {
  	    xfree(inbuf);
! 	    debug(12, 2, "POST without Content-Length\n");
! 	    return -1;
  	}
  	content_length = atoi(t);
  	debug(12, 3, "parseHttpRequest: Expecting POST Content-Length of %d\n",
***************
*** 1164,1169 ****
--- 1179,1185 ----
  	} else if ((t = strstr(req_hdr, "\n\n"))) {
  	    post_data = t + 2;
  	} else {
+ 	    debug(12, 1, "parseHttpRequest: Can't find end of headers in POST request?\n");
  	    xfree(inbuf);
  	    return 0;		/* not a complete request */
  	}
***************
*** 1174,1182 ****
  	    xfree(inbuf);
  	    return 0;
  	}
-     } else if (!strstr(req_hdr, "\r\n\r\n") && !strstr(req_hdr, "\n\n")) {
- 	xfree(inbuf);
- 	return 0;		/* not a complete request */
      }
      /* Assign icpState->url */
      if ((t = strchr(request, '\n')))	/* remove NL */
--- 1190,1195 ----
***************
*** 1193,1200 ****
  	    request = t;
  	    free_request = 1;
  	    /* NOTE: We don't have to free the old request pointer
! 	     * because it points to inside xbuf. But
! 	     * do_append_domain() allocates memory so set a flag
  	     * if the request should be freed later. */
  	}
      }
--- 1206,1213 ----
  	    request = t;
  	    free_request = 1;
  	    /* NOTE: We don't have to free the old request pointer
! 	     * because it points to inside inbuf. But
! 	     * do_append_domain() allocates new memory so set a flag
  	     * if the request should be freed later. */
  	}
      }
***************
*** 1209,1216 ****
  	} else {
  	    /* Put the local socket IP address as the hostname */
  	    icpState->url = xcalloc(strlen(request) + 24, 1);
! 	    sprintf(icpState->url, "http://%s%s",
! 		inet_ntoa(icpState->me.sin_addr), request);
  	}
  	BIT_SET(icpState->flags, REQ_ACCEL);
      } else {
--- 1222,1231 ----
  	} else {
  	    /* Put the local socket IP address as the hostname */
  	    icpState->url = xcalloc(strlen(request) + 24, 1);
! 	    sprintf(icpState->url, "http://%s:%d%s",
! 		inet_ntoa(icpState->me.sin_addr),
! 		getAccelPort(),
! 		request);
  	}
  	BIT_SET(icpState->flags, REQ_ACCEL);
      } else {
***************
*** 1229,1234 ****
--- 1244,1254 ----
       icpStateData *icpState;
  {
      request_t *r = icpState->request;
+     if (httpd_accel_mode && !getAccelWithProxy()) {
+ 	/* this cache is an httpd accelerator ONLY */
+ 	if (!BIT_TEST(icpState->flags, REQ_ACCEL))
+ 	    return 0;
+     }
      return aclCheck(HTTPAccessList,
  	icpState->peer.sin_addr,
  	r->method,
diff -cr squid-1.0.beta6/src/ipcache.c squid-1.0.beta7/src/ipcache.c
*** squid-1.0.beta6/src/ipcache.c	Thu May 02 18:52:32 1996
--- squid-1.0.beta7/src/ipcache.c	Wed May 08 19:31:59 1996
***************
*** 1,4 ****
! /* $Id: ipcache.c,v 1.26.2.7 1996/05/03 01:52:32 wessels Exp $ */
  
  /*
   * DEBUG: Section 14          ipcache: IP Cache
--- 1,4 ----
! /* $Id: ipcache.c,v 1.26.2.9 1996/05/09 02:31:59 wessels Exp $ */
  
  /*
   * DEBUG: Section 14          ipcache: IP Cache
***************
*** 6,15 ****
  
  #include "squid.h"
  
- 
  #define MAX_LINELEN (4096)
- char ipcache_status_char _PARAMS((ipcache_entry *));
- int ipcache_hash_entry_count();
  
  #define MAX_IP		 1024	/* Maximum cached IP */
  #define IP_LOW_WATER       70
--- 6,12 ----
***************
*** 59,74 ****
  static int last_dns_dispatched = 2;
  static struct hostent *static_result = NULL;
  static int dns_child_alive = 0;
  
- char *dns_error_message = NULL;	/* possible error message */
- HashID ip_table = 0;
- 
  extern int do_dns_test;
- extern int getMaxFD();
- extern int getDnsChildren();
- extern void fatal_dump _PARAMS((char *));
- extern int file_update_open _PARAMS((int, char *));
  
  void update_dns_child_alive()
  {
      int i;
--- 56,69 ----
  static int last_dns_dispatched = 2;
  static struct hostent *static_result = NULL;
  static int dns_child_alive = 0;
+ static char ipcache_status_char _PARAMS((ipcache_entry *));
+ static int ipcache_hash_entry_count _PARAMS((void));
  
  extern int do_dns_test;
  
+ HashID ip_table = 0;
+ char *dns_error_message = NULL;	/* possible error message */
+ 
  void update_dns_child_alive()
  {
      int i;
***************
*** 170,182 ****
      /* setup filedescriptors */
      dup2(cfd, 3);
      for (fd = getMaxFD(); fd > 3; fd--) {
! 	(void) close(fd);
      }
  
      execlp(command, "(dnsserver)", "-p", socketname, NULL);
      debug(14, 0, "ipcache_create_dnsserver: %s: %s\n", command, xstrerror());
      _exit(1);
!     return (0);			/* NOTREACHED */
  }
  
  
--- 165,177 ----
      /* setup filedescriptors */
      dup2(cfd, 3);
      for (fd = getMaxFD(); fd > 3; fd--) {
! 	close(fd);
      }
  
      execlp(command, "(dnsserver)", "-p", socketname, NULL);
      debug(14, 0, "ipcache_create_dnsserver: %s: %s\n", command, xstrerror());
      _exit(1);
!     return (0);
  }
  
  
***************
*** 306,312 ****
      int LRU_list_count = 0;
      int LRU_cur_size = meta_data.ipcache_count;
  
!     LRU_list = (ipcache_entry **) xcalloc(LRU_cur_size, sizeof(ipcache_entry *));
  
      e = NULL;
  
--- 301,307 ----
      int LRU_list_count = 0;
      int LRU_cur_size = meta_data.ipcache_count;
  
!     LRU_list = xcalloc(LRU_cur_size, sizeof(ipcache_entry *));
  
      e = NULL;
  
***************
*** 332,338 ****
      debug(14, 3, "                  high W mark  : %5d\n", ipcache_high);
      debug(14, 3, "                  low  W mark  : %5d\n", ipcache_low);
      debug(14, 3, "                  not pending  : %5d\n", local_ip_notpending_count);
!     debug(14, 3, "              LRU candidated   : %5d\n", LRU_list_count);
  
      /* sort LRU candidate list */
      qsort((char *) LRU_list, LRU_list_count, sizeof(e), (int (*)(const void *, const void *)) ipcache_compareLastRef);
--- 327,333 ----
      debug(14, 3, "                  high W mark  : %5d\n", ipcache_high);
      debug(14, 3, "                  low  W mark  : %5d\n", ipcache_low);
      debug(14, 3, "                  not pending  : %5d\n", local_ip_notpending_count);
!     debug(14, 3, "              LRU candidates   : %5d\n", LRU_list_count);
  
      /* sort LRU candidate list */
      qsort((char *) LRU_list, LRU_list_count, sizeof(e), (int (*)(const void *, const void *)) ipcache_compareLastRef);
***************
*** 374,380 ****
      }
      meta_data.ipcache_count++;
      debug(14, 5, "ipcache_create: before return. ipcache_count == %d\n", meta_data.ipcache_count);
!     new = (ipcache_entry *) xcalloc(1, sizeof(ipcache_entry));
      /* set default to 4, in case parser fail to get token $h_length from
       * dnsserver. */
      new->entry.h_length = 4;
--- 369,375 ----
      }
      meta_data.ipcache_count++;
      debug(14, 5, "ipcache_create: before return. ipcache_count == %d\n", meta_data.ipcache_count);
!     new = xcalloc(1, sizeof(ipcache_entry));
      /* set default to 4, in case parser fail to get token $h_length from
       * dnsserver. */
      new->entry.h_length = 4;
***************
*** 424,440 ****
  	e->alias_count = alias_count;
  
  	/* copy ip addresses information */
! 	e->entry.h_addr_list = (char **) xcalloc(addr_count + 1, sizeof(char *));
  	for (i = 0; i < addr_count; i++) {
! 	    e->entry.h_addr_list[i] = (char *) xcalloc(1, data->h_length);
  	    memcpy(e->entry.h_addr_list[i], data->h_addr_list[i], data->h_length);
  	}
  
  	if (alias_count) {
  	    /* copy aliases information */
! 	    e->entry.h_aliases = (char **) xcalloc(alias_count + 1, sizeof(char *));
  	    for (i = 0; i < alias_count; i++) {
! 		e->entry.h_aliases[i] = (char *) xcalloc(1, strlen(data->h_aliases[i]) + 1);
  		strcpy(e->entry.h_aliases[i], data->h_aliases[i]);
  	    }
  	}
--- 419,435 ----
  	e->alias_count = alias_count;
  
  	/* copy ip addresses information */
! 	e->entry.h_addr_list = xcalloc(addr_count + 1, sizeof(char *));
  	for (i = 0; i < addr_count; i++) {
! 	    e->entry.h_addr_list[i] = xcalloc(1, data->h_length);
  	    memcpy(e->entry.h_addr_list[i], data->h_addr_list[i], data->h_length);
  	}
  
  	if (alias_count) {
  	    /* copy aliases information */
! 	    e->entry.h_aliases = xcalloc(alias_count + 1, sizeof(char *));
  	    for (i = 0; i < alias_count; i++) {
! 		e->entry.h_aliases[i] = xcalloc(1, strlen(data->h_aliases[i]) + 1);
  		strcpy(e->entry.h_aliases[i], data->h_aliases[i]);
  	    }
  	}
***************
*** 488,503 ****
  	e->alias_count = alias_count;
  
  	/* copy ip addresses information */
! 	e->entry.h_addr_list = (char **) xcalloc(addr_count + 1, sizeof(char *));
  	for (i = 0; i < addr_count; i++) {
! 	    e->entry.h_addr_list[i] = (char *) xcalloc(1, data->h_length);
  	    memcpy(e->entry.h_addr_list[i], data->h_addr_list[i], data->h_length);
  	}
  
  	/* copy aliases information */
! 	e->entry.h_aliases = (char **) xcalloc(alias_count + 1, sizeof(char *));
  	for (i = 0; i < alias_count; i++) {
! 	    e->entry.h_aliases[i] = (char *) xcalloc(1, strlen(data->h_aliases[i]) + 1);
  	    strcpy(e->entry.h_aliases[i], data->h_aliases[i]);
  	}
  
--- 483,498 ----
  	e->alias_count = alias_count;
  
  	/* copy ip addresses information */
! 	e->entry.h_addr_list = xcalloc(addr_count + 1, sizeof(char *));
  	for (i = 0; i < addr_count; i++) {
! 	    e->entry.h_addr_list[i] = xcalloc(1, data->h_length);
  	    memcpy(e->entry.h_addr_list[i], data->h_addr_list[i], data->h_length);
  	}
  
  	/* copy aliases information */
! 	e->entry.h_aliases = xcalloc(alias_count + 1, sizeof(char *));
  	for (i = 0; i < alias_count; i++) {
! 	    e->entry.h_aliases[i] = xcalloc(1, strlen(data->h_aliases[i]) + 1);
  	    strcpy(e->entry.h_aliases[i], data->h_aliases[i]);
  	}
  
***************
*** 685,691 ****
  
  	while (pos < endpos) {
  	    /* add the next line to the end of the list */
! 	    line_cur = (line_entry *) xcalloc(1, sizeof(line_entry));
  
  	    if ((tpos = memchr(pos, '\n', 4096)) == NULL) {
  		debug(14, 2, "ipcache_parsebuffer: DNS response incomplete.\n");
--- 680,686 ----
  
  	while (pos < endpos) {
  	    /* add the next line to the end of the list */
! 	    line_cur = xcalloc(1, sizeof(line_entry));
  
  	    if ((tpos = memchr(pos, '\n', 4096)) == NULL) {
  		debug(14, 2, "ipcache_parsebuffer: DNS response incomplete.\n");
***************
*** 818,824 ****
  			if (ipcount == 0) {
  			    e->entry.h_addr_list = NULL;
  			} else {
! 			    e->entry.h_addr_list = (char **) xcalloc(ipcount, sizeof(char *));
  			}
  
  			/* get ip addresses */
--- 813,819 ----
  			if (ipcount == 0) {
  			    e->entry.h_addr_list = NULL;
  			} else {
! 			    e->entry.h_addr_list = xcalloc(ipcount, sizeof(char *));
  			}
  
  			/* get ip addresses */
***************
*** 830,836 ****
  				    debug(14, 1, "ipcache_parsebuffer: DNS record in invalid format? No $ipcount data.\n");
  				    break;
  				}
! 				e->entry.h_addr_list[i] = (char *) xcalloc(1, e->entry.h_length);
  				*((unsigned long *) (void *) e->entry.h_addr_list[i]) = inet_addr(line_cur->line);
  				line_cur = line_cur->next;
  				i++;
--- 825,831 ----
  				    debug(14, 1, "ipcache_parsebuffer: DNS record in invalid format? No $ipcount data.\n");
  				    break;
  				}
! 				e->entry.h_addr_list[i] = xcalloc(1, e->entry.h_length);
  				*((unsigned long *) (void *) e->entry.h_addr_list[i]) = inet_addr(line_cur->line);
  				line_cur = line_cur->next;
  				i++;
***************
*** 854,860 ****
  			if (aliascount == 0) {
  			    e->entry.h_aliases = NULL;
  			} else {
! 			    e->entry.h_aliases = (char **) xcalloc(aliascount, sizeof(char *));
  			}
  
  			/* get aliases */
--- 849,855 ----
  			if (aliascount == 0) {
  			    e->entry.h_aliases = NULL;
  			} else {
! 			    e->entry.h_aliases = xcalloc(aliascount, sizeof(char *));
  			}
  
  			/* get aliases */
***************
*** 949,955 ****
      if ((e = ipcache_get(name)) != NULL && (e->status != PENDING)) {
  	/* hit here */
  	debug(14, 4, "ipcache_nbgethostbyname: Hit for name '%s'.\n", name);
! 	pending = (IpPending *) xcalloc(1, sizeof(IpPending));
  	pending->fd = fd;
  	pending->handler = handler;
  	pending->data = data;
--- 944,950 ----
      if ((e = ipcache_get(name)) != NULL && (e->status != PENDING)) {
  	/* hit here */
  	debug(14, 4, "ipcache_nbgethostbyname: Hit for name '%s'.\n", name);
! 	pending = xcalloc(1, sizeof(IpPending));
  	pending->fd = fd;
  	pending->handler = handler;
  	pending->data = data;
***************
*** 965,971 ****
      }
      debug(14, 4, "ipcache_nbgethostbyname: Name '%s': MISS or PENDING.\n", name);
  
!     pending = (IpPending *) xcalloc(1, sizeof(IpPending));
      pending->fd = fd;
      pending->handler = handler;
      pending->data = data;
--- 960,966 ----
      }
      debug(14, 4, "ipcache_nbgethostbyname: Name '%s': MISS or PENDING.\n", name);
  
!     pending = xcalloc(1, sizeof(IpPending));
      pending->fd = fd;
      pending->handler = handler;
      pending->data = data;
***************
*** 1023,1034 ****
  
      /* add to global pending list */
      if (dns->global_pending == NULL) {	/* new list */
! 	dns->global_pending = (ipcache_list *) xcalloc(1, sizeof(ipcache_list));
  	dns->global_pending->entry = e;
  	dns->global_pending->next = NULL;
  	dns->global_pending_tail = dns->global_pending;
      } else {			/* add to end of list */
! 	ipcache_list *p = (ipcache_list *) xcalloc(1, sizeof(ipcache_list));
  	p->entry = e;
  	p->next = NULL;
  	dns->global_pending_tail->next = p;
--- 1018,1029 ----
  
      /* add to global pending list */
      if (dns->global_pending == NULL) {	/* new list */
! 	dns->global_pending = xcalloc(1, sizeof(ipcache_list));
  	dns->global_pending->entry = e;
  	dns->global_pending->next = NULL;
  	dns->global_pending_tail = dns->global_pending;
      } else {			/* add to end of list */
! 	ipcache_list *p = xcalloc(1, sizeof(ipcache_list));
  	p->entry = e;
  	p->next = NULL;
  	dns->global_pending_tail->next = p;
***************
*** 1036,1042 ****
      }
  
      if (dns_child_alive) {
! 	char *buf = (char *) xcalloc(1, 256);
  	strncpy(buf, name, 254);
  	strcat(buf, "\n");
  	dns->pending_count++;
--- 1031,1037 ----
      }
  
      if (dns_child_alive) {
! 	char *buf = xcalloc(1, 256);
  	strncpy(buf, name, 254);
  	strcat(buf, "\n");
  	dns->pending_count++;
***************
*** 1072,1083 ****
  	    safe_free(dns_child_table[i]->ip_inbuf);
  	safe_free(dns_child_table);
      }
!     dns_child_table = (dnsserver_entry **) xcalloc(N, sizeof(dnsserver_entry));
      NChildrenAlloc = N;
      dns_child_alive = 0;
      debug(14, 1, "ipcacheOpenServers: Starting %d 'dns_server' processes\n", N);
      for (i = 0; i < N; i++) {
! 	dns_child_table[i] = (dnsserver_entry *) xcalloc(1, sizeof(dnsserver_entry));
  	if ((dnssocket = ipcache_create_dnsserver(prg)) < 0) {
  	    debug(14, 1, "ipcacheOpenServers: WARNING: Cannot run 'dnsserver' process.\n");
  	    debug(14, 1, "              Fallling back to the blocking version.\n");
--- 1067,1078 ----
  	    safe_free(dns_child_table[i]->ip_inbuf);
  	safe_free(dns_child_table);
      }
!     dns_child_table = xcalloc(N, sizeof(dnsserver_entry));
      NChildrenAlloc = N;
      dns_child_alive = 0;
      debug(14, 1, "ipcacheOpenServers: Starting %d 'dns_server' processes\n", N);
      for (i = 0; i < N; i++) {
! 	dns_child_table[i] = xcalloc(1, sizeof(dnsserver_entry));
  	if ((dnssocket = ipcache_create_dnsserver(prg)) < 0) {
  	    debug(14, 1, "ipcacheOpenServers: WARNING: Cannot run 'dnsserver' process.\n");
  	    debug(14, 1, "              Fallling back to the blocking version.\n");
***************
*** 1092,1098 ****
  	    dns_child_table[i]->size = IP_INBUF - 1;	/* spare one for \0 */
  	    dns_child_table[i]->offset = 0;
  	    dns_child_table[i]->alive = 1;
! 	    dns_child_table[i]->ip_inbuf = (char *) xcalloc(1, IP_INBUF);
  
  	    /* update fd_stat */
  
--- 1087,1093 ----
  	    dns_child_table[i]->size = IP_INBUF - 1;	/* spare one for \0 */
  	    dns_child_table[i]->offset = 0;
  	    dns_child_table[i]->alive = 1;
! 	    dns_child_table[i]->ip_inbuf = xcalloc(1, IP_INBUF);
  
  	    /* update fd_stat */
  
***************
*** 1148,1159 ****
  
      ip_table = hash_create(urlcmp, 229);	/* small hash table */
      /* init static area */
!     static_result = (struct hostent *) xcalloc(1, sizeof(struct hostent));
      static_result->h_length = 4;
      /* Need a terminating NULL address (h_addr_list[1]) */
!     static_result->h_addr_list = (char **) xcalloc(2, sizeof(char *));
!     static_result->h_addr_list[0] = (char *) xcalloc(1, 4);
!     static_result->h_name = (char *) xcalloc(1, MAX_HOST_NAME + 1);
  
      ipcacheOpenServers();
  
--- 1143,1154 ----
  
      ip_table = hash_create(urlcmp, 229);	/* small hash table */
      /* init static area */
!     static_result = xcalloc(1, sizeof(struct hostent));
      static_result->h_length = 4;
      /* Need a terminating NULL address (h_addr_list[1]) */
!     static_result->h_addr_list = xcalloc(2, sizeof(char *));
!     static_result->h_addr_list[0] = xcalloc(1, 4);
!     static_result->h_name = xcalloc(1, MAX_HOST_NAME + 1);
  
      ipcacheOpenServers();
  
diff -cr squid-1.0.beta6/src/main.c squid-1.0.beta7/src/main.c
*** squid-1.0.beta6/src/main.c	Wed May 01 16:46:55 1996
--- squid-1.0.beta7/src/main.c	Wed May 08 19:32:00 1996
***************
*** 1,4 ****
! /* $Id: main.c,v 1.44.4.11 1996/05/01 23:46:55 wessels Exp $ */
  
  /* DEBUG: Section 1             main: startup and main loop */
  
--- 1,4 ----
! /* $Id: main.c,v 1.44.4.13 1996/05/09 02:32:00 wessels Exp $ */
  
  /* DEBUG: Section 1             main: startup and main loop */
  
***************
*** 19,29 ****
  char *version_string = SQUID_VERSION;
  char *appname = "squid";
  
! extern void (*failure_notify) ();	/* for error reporting from xmalloc */
  
  static int asciiPortNumOverride = 0;
  static int udpPortNumOverride = 0;
  static int malloc_debug_level = 0;
  
  static void usage()
  {
--- 19,31 ----
  char *version_string = SQUID_VERSION;
  char *appname = "squid";
  
! extern void (*failure_notify) _PARAMS((char *));	/* for error reporting from xmalloc */
  
  static int asciiPortNumOverride = 0;
  static int udpPortNumOverride = 0;
+ #if defined(MALLOC_DBG)
  static int malloc_debug_level = 0;
+ #endif
  
  static void usage()
  {
***************
*** 89,97 ****
--- 91,101 ----
  	case 'u':
  	    udpPortNumOverride = atoi(optarg);
  	    break;
+ #if defined(MALLOC_DBG)
  	case 'm':
  	    malloc_debug_level = atoi(optarg);
  	    break;
+ #endif
  	case 'z':
  	    zap_disk_store = 1;
  	    break;
***************
*** 194,199 ****
--- 198,204 ----
  {
      static int first_time = 1;
  
+ 
      if (catch_signals) {
  	signal(SIGSEGV, death);
  	signal(SIGBUS, death);
***************
*** 204,209 ****
--- 209,215 ----
      if (ConfigFile == NULL)
  	ConfigFile = xstrdup(DefaultConfigFile);
      parseConfigFile(ConfigFile);
+     check_suid();
  
      if (asciiPortNumOverride > 0)
  	setAsciiPortNum(asciiPortNumOverride);
***************
*** 228,236 ****
  #if defined(MALLOC_DBG)
      malloc_debug(0, malloc_debug_level);
  #endif
- 
-     /* do suid checking */
-     check_suid();
  
      if (first_time) {
  	first_time = 0;
--- 234,239 ----
diff -cr squid-1.0.beta6/src/mime.c squid-1.0.beta7/src/mime.c
*** squid-1.0.beta6/src/mime.c	Mon Apr 15 22:05:25 1996
--- squid-1.0.beta7/src/mime.c	Wed May 08 19:32:00 1996
***************
*** 1,5 ****
  
! /* $Id: mime.c,v 1.12 1996/04/16 05:05:25 wessels Exp $ */
  
  /*
   * DEBUG: Section 25          mime
--- 1,5 ----
  
! /* $Id: mime.c,v 1.12.2.1 1996/05/09 02:32:00 wessels Exp $ */
  
  /*
   * DEBUG: Section 25          mime
***************
*** 48,68 ****
  	}
      }
      return NULL;
- }
- 
- int mime_refresh_request(mime)
-      char *mime;
- {
-     char *pr = NULL;
-     if (mime == NULL)
- 	return 0;
-     if (mime_get_header(mime, "If-Modified-Since"))
- 	return 1;
-     if ((pr = mime_get_header(mime, "pragma"))) {
- 	if (strcasecmp(pr, "no-cache"))
- 	    return 1;
-     }
-     return 0;
  }
  
  ext_table_entry *mime_ext_to_type(extension)
--- 48,53 ----
diff -cr squid-1.0.beta6/src/mime.h squid-1.0.beta7/src/mime.h
*** squid-1.0.beta6/src/mime.h	Sun Mar 31 20:15:06 1996
--- squid-1.0.beta7/src/mime.h	Wed May 08 19:32:01 1996
***************
*** 1,4 ****
! /*  $Id: mime.h,v 1.3 1996/04/01 04:15:06 wessels Exp $ */
  
  #ifndef MIME_H
  #define MIME_H
--- 1,4 ----
! /*  $Id: mime.h,v 1.3.2.1 1996/05/09 02:32:01 wessels Exp $ */
  
  #ifndef MIME_H
  #define MIME_H
***************
*** 14,20 ****
  
  extern char *mime_get_header _PARAMS((char *mime, char *header));
  extern void mime_process _PARAMS((char *mime));
- extern int mime_refresh_request _PARAMS((char *mime));
  extern ext_table_entry *mime_ext_to_type _PARAMS((char *extension));
  extern int mk_mime_hdr _PARAMS((char *, time_t, int, time_t, char *));
  
--- 14,19 ----
diff -cr squid-1.0.beta6/src/neighbors.c squid-1.0.beta7/src/neighbors.c
*** squid-1.0.beta6/src/neighbors.c	Wed May 01 12:18:29 1996
--- squid-1.0.beta7/src/neighbors.c	Wed May 08 20:40:36 1996
***************
*** 1,4 ****
! /* $Id: neighbors.c,v 1.22.2.2 1996/05/01 19:18:29 wessels Exp $ */
  
  /* TODO:
   * - change 'neighbor' to 'sibling'
--- 1,4 ----
! /* $Id: neighbors.c,v 1.22.2.6 1996/05/09 03:40:36 wessels Exp $ */
  
  /* TODO:
   * - change 'neighbor' to 'sibling'
***************
*** 226,231 ****
--- 226,232 ----
      for (e = friends->edges_head; e; e = next) {
  	next = e->next;
  	safe_free(e->host);
+ 	/* XXX I think we need to free e->domains too -DW */
  	safe_free(e);
      }
      safe_free(friends);
***************
*** 260,286 ****
       int fd;
  {
      int j;
!     struct sockaddr_in our_socket_name;
      struct sockaddr_in *ap;
!     int sock_name_length = sizeof(our_socket_name);
      char **list = NULL;
      edge *e = NULL;
      struct in_addr *ina = NULL;
  
!     if (getsockname(fd, (struct sockaddr *) &our_socket_name,
! 	    &sock_name_length) == -1) {
! 	debug(15, 1, "getsockname(%d,%p,%p) failed.\n",
! 	    fd, &our_socket_name, &sock_name_length);
!     }
      friends->fd = fd;
  
      /* Prepare neighbor connections, one at a time */
!     for (e = friends->edges_head; e; e = e->next) {
  	debug(15, 2, "Finding IP addresses for '%s'\n", e->host);
  	if ((list = getAddressList(e->host)) == NULL) {
! 	    sprintf(tmp_error_buf, "DNS lookup for '%s' failed! Cannot continue.\n",
! 		e->host);
! 	    fatal(tmp_error_buf);
  	}
  	e->n_addresses = 0;
  	for (j = 0; *list && j < EDGE_MAX_ADDRESSES; j++) {
--- 261,292 ----
       int fd;
  {
      int j;
!     struct sockaddr_in name;
      struct sockaddr_in *ap;
!     int len = sizeof(struct sockaddr_in);
      char **list = NULL;
      edge *e = NULL;
+     edge *next = NULL;
+     edge **E = NULL;
      struct in_addr *ina = NULL;
+     struct servent *sep = NULL;
  
!     if (getsockname(fd, (struct sockaddr *) &name, &len) < 0)
! 	debug(15, 1, "getsockname(%d,%p,%p) failed.\n", fd, &name, &len);
      friends->fd = fd;
  
      /* Prepare neighbor connections, one at a time */
!     E = &friends->edges_head;
!     next = friends->edges_head;
!     while ((e = next)) {
! 	next = e->next;
  	debug(15, 2, "Finding IP addresses for '%s'\n", e->host);
  	if ((list = getAddressList(e->host)) == NULL) {
! 	    debug(0, 0, "WARNING!!: DNS lookup for '%s' failed!\n", e->host);
! 	    debug(0, 0, "THIS NEIGHBOR WILL BE IGNORED.\n");
! 	    *E = next;		/* skip */
! 	    safe_free(e);
! 	    continue;
  	}
  	e->n_addresses = 0;
  	for (j = 0; *list && j < EDGE_MAX_ADDRESSES; j++) {
***************
*** 290,302 ****
  	    e->n_addresses++;
  	}
  	if (e->n_addresses < 1) {
! 	    sprintf(tmp_error_buf, "No IP addresses found for '%s'; Cannot continue.\n", e->host);
! 	    fatal(tmp_error_buf);
  	}
  	for (j = 0; j < e->n_addresses; j++) {
! 	    debug(15, 2, "--> IP address #%d: %s\n", j, inet_ntoa(e->addresses[j]));
  	}
! 	e->rtt = 1000;
  
  	/* Prepare query packet for future use */
  	e->header.opcode = ICP_OP_QUERY;
--- 296,312 ----
  	    e->n_addresses++;
  	}
  	if (e->n_addresses < 1) {
! 	    debug(0, 0, "WARNING!!: No IP address found for '%s'!\n", e->host);
! 	    debug(0, 0, "THIS NEIGHBOR WILL BE IGNORED.\n");
! 	    *E = next;		/* skip */
! 	    safe_free(e);
! 	    continue;
  	}
  	for (j = 0; j < e->n_addresses; j++) {
! 	    debug(15, 2, "--> IP address #%d: %s\n",
! 		j, inet_ntoa(e->addresses[j]));
  	}
! 	e->stats.rtt = 0;
  
  	/* Prepare query packet for future use */
  	e->header.opcode = ICP_OP_QUERY;
***************
*** 304,310 ****
  	e->header.length = 0;
  	e->header.reqnum = 0;
  	memset(e->header.auth, '\0', sizeof(u_num32) * ICP_AUTH_SIZE);
! 	e->header.shostid = our_socket_name.sin_addr.s_addr;
  
  	ap = &e->in_addr;
  	memset(ap, '\0', sizeof(struct sockaddr_in));
--- 314,320 ----
  	e->header.length = 0;
  	e->header.reqnum = 0;
  	memset(e->header.auth, '\0', sizeof(u_num32) * ICP_AUTH_SIZE);
! 	e->header.shostid = name.sin_addr.s_addr;
  
  	ap = &e->in_addr;
  	memset(ap, '\0', sizeof(struct sockaddr_in));
***************
*** 323,343 ****
  		e->udp_port);
  	    e->neighbor_up = 1;
  	}
  
! 	/* do this only the first time thru */
! 	if (0 == echo_hdr.opcode) {
! 	    struct servent *sep;
! 
! 	    echo_hdr.opcode = ICP_OP_SECHO;
! 	    echo_hdr.version = ICP_VERSION_CURRENT;
! 	    echo_hdr.length = 0;
! 	    echo_hdr.reqnum = 0;
! 	    memset(echo_hdr.auth, '\0', sizeof(u_num32) * ICP_AUTH_SIZE);
! 	    echo_hdr.shostid = our_socket_name.sin_addr.s_addr;
! 
! 	    sep = getservbyname("echo", "udp");
! 	    echo_port = sep ? ntohs((u_short) sep->s_port) : 7;
! 	}
      }
  }
  
--- 333,350 ----
  		e->udp_port);
  	    e->neighbor_up = 1;
  	}
+ 	E = &e->next;
+     }
  
!     if (0 == echo_hdr.opcode) {
! 	echo_hdr.opcode = ICP_OP_SECHO;
! 	echo_hdr.version = ICP_VERSION_CURRENT;
! 	echo_hdr.length = 0;
! 	echo_hdr.reqnum = 0;
! 	memset(echo_hdr.auth, '\0', sizeof(u_num32) * ICP_AUTH_SIZE);
! 	echo_hdr.shostid = name.sin_addr.s_addr;
! 	sep = getservbyname("echo", "udp");
! 	echo_port = sep ? ntohs((u_short) sep->s_port) : 7;
      }
  }
  
***************
*** 400,410 ****
  	    icpUdpSend(friends->fd, url, &e->header, &e->in_addr, ICP_OP_QUERY);
  	}
  
! 	e->ack_deficit++;
! 	e->num_pings++;
! 	e->pings_sent++;
  
! 	if (e->ack_deficit < HIER_MAX_DEFICIT) {
  	    /* consider it's alive. count it */
  	    e->neighbor_up = 1;
  	    m->e_pings_n_pings++;
--- 407,417 ----
  	    icpUdpSend(friends->fd, url, &e->header, &e->in_addr, ICP_OP_QUERY);
  	}
  
! 	e->stats.ack_deficit++;
! 	e->stats.num_pings++;
! 	e->stats.pings_sent++;
  
! 	if (e->stats.ack_deficit < HIER_MAX_DEFICIT) {
  	    /* consider it's alive. count it */
  	    e->neighbor_up = 1;
  	    m->e_pings_n_pings++;
***************
*** 411,424 ****
  	} else {
  	    /* consider it's dead. send a ping but don't count it. */
  	    e->neighbor_up = 0;
! 	    if (e->ack_deficit > (HIER_MAX_DEFICIT << 1))
  		/* do this to prevent wrap around but we still want it
  		 * to move a bit so we can debug it easier. */
! 		e->ack_deficit = HIER_MAX_DEFICIT + 1;
  	    debug(15, 6, "cache %s is considered dead but send PING anyway, hope it comes up soon.\n",
  		inet_ntoa(e->in_addr.sin_addr));
  	    /* log it once at the threshold */
! 	    if ((e->ack_deficit == HIER_MAX_DEFICIT)) {
  		if (e->type == EDGE_SIBLING) {
  		    hierarchy_log_append("Detect: ",
  			HIER_DEAD_NEIGHBOR, 0,
--- 418,431 ----
  	} else {
  	    /* consider it's dead. send a ping but don't count it. */
  	    e->neighbor_up = 0;
! 	    if (e->stats.ack_deficit > (HIER_MAX_DEFICIT << 1))
  		/* do this to prevent wrap around but we still want it
  		 * to move a bit so we can debug it easier. */
! 		e->stats.ack_deficit = HIER_MAX_DEFICIT + 1;
  	    debug(15, 6, "cache %s is considered dead but send PING anyway, hope it comes up soon.\n",
  		inet_ntoa(e->in_addr.sin_addr));
  	    /* log it once at the threshold */
! 	    if ((e->stats.ack_deficit == HIER_MAX_DEFICIT)) {
  		if (e->type == EDGE_SIBLING) {
  		    hierarchy_log_append("Detect: ",
  			HIER_DEAD_NEIGHBOR, 0,
***************
*** 471,476 ****
--- 478,484 ----
      edge *e = NULL;
      MemObject *m = entry->mem_obj;
      int w_rtt;
+     int rtt;
  
      debug(15, 6, "neighborsUdpAck: url=%s (%d chars), header=0x%x, from=0x%x, ent=0x%x\n",
  	url, strlen(url), header, from, entry);
***************
*** 488,494 ****
      if (e) {
  	/* reset the deficit. It's alive now. */
  	/* Don't care about exact count. */
! 	if ((e->ack_deficit >= HIER_MAX_DEFICIT)) {
  	    if (e->type == EDGE_SIBLING) {
  		hierarchy_log_append("Detect: ",
  		    HIER_REVIVE_NEIGHBOR, 0, e->host);
--- 496,502 ----
      if (e) {
  	/* reset the deficit. It's alive now. */
  	/* Don't care about exact count. */
! 	if ((e->stats.ack_deficit >= HIER_MAX_DEFICIT)) {
  	    if (e->type == EDGE_SIBLING) {
  		hierarchy_log_append("Detect: ",
  		    HIER_REVIVE_NEIGHBOR, 0, e->host);
***************
*** 497,505 ****
  		    HIER_REVIVE_PARENT, 0, e->host);
  	    }
  	}
- 	e->ack_deficit = 0;
  	e->neighbor_up = 1;
! 	e->pings_acked++;
      }
      /* check if someone is already fetching it */
      if (BIT_TEST(entry->flag, ENTRY_DISPATCHED) || (entry->ping_status != WAITING)) {
--- 505,519 ----
  		    HIER_REVIVE_PARENT, 0, e->host);
  	    }
  	}
  	e->neighbor_up = 1;
! 	e->stats.ack_deficit = 0;
! 	e->stats.pings_acked++;
! 	header->opcode == ICP_OP_HIT ? e->stats.hits++ : e->stats.misses++;
! 
! 	if (m) {
! 	    rtt = tvSubMsec(m->start_ping, current_time);
! 	    e->stats.rtt = (e->stats.rtt * (RTT_AV_FACTOR - 1) + rtt) / RTT_AV_FACTOR;
! 	}
      }
      /* check if someone is already fetching it */
      if (BIT_TEST(entry->flag, ENTRY_DISPATCHED) || (entry->ping_status != WAITING)) {
***************
*** 558,570 ****
  	BIT_SET(entry->flag, ENTRY_DISPATCHED);
  	entry->ping_status = DONE;
  	getFromCache(0, entry, e, entry->mem_obj->request);
- 	e->hits++;
  	return;
      } else if ((header->opcode == ICP_OP_MISS) || (header->opcode == ICP_OP_DECHO)) {
  	/* everytime we get here, count it as a miss */
  	m->e_pings_n_acks++;
- 	if (e)
- 	    e->misses++;
  
  	if (header->opcode == ICP_OP_DECHO) {
  	    /* receive ping back from non-ICP cache */
--- 572,581 ----
***************
*** 623,629 ****
  {
      struct neighbor_cf *t, *u;
  
!     t = (struct neighbor_cf *) xcalloc(sizeof(struct neighbor_cf), 1);
      t->host = xstrdup(host);
      t->type = xstrdup(type);
      t->ascii_port = ascii_port;
--- 634,640 ----
  {
      struct neighbor_cf *t, *u;
  
!     t = xcalloc(sizeof(struct neighbor_cf), 1);
      t->host = xstrdup(host);
      t->type = xstrdup(type);
      t->ascii_port = ascii_port;
***************
*** 640,646 ****
      }
  }
  
! int neighbors_cf_domain(host, domain)
       char *host;
       char *domain;
  {
--- 651,657 ----
      }
  }
  
! void neighbors_cf_domain(host, domain)
       char *host;
       char *domain;
  {
***************
*** 652,662 ****
  	if (strcmp(t->host, host) == 0)
  	    break;
      }
! 
!     if (t == NULL)
! 	return 0;
! 
!     l = (dom_list *) xmalloc(sizeof(dom_list));
      l->do_ping = 1;
      if (*domain == '!') {	/* check for !.edu */
  	l->do_ping = 0;
--- 663,674 ----
  	if (strcmp(t->host, host) == 0)
  	    break;
      }
!     if (t == NULL) {
! 	debug(15, 0, "%s, line %d: No cache_host '%s'\n",
! 	    cfg_filename, config_lineno, host);
! 	return;
!     }
!     l = xmalloc(sizeof(dom_list));
      l->do_ping = 1;
      if (*domain == '!') {	/* check for !.edu */
  	l->do_ping = 0;
***************
*** 666,673 ****
      l->next = NULL;
      for (L = &(t->domains); *L; L = &((*L)->next));
      *L = l;
- 
-     return 1;
  }
  
  void neighbors_init()
--- 678,683 ----
***************
*** 681,687 ****
      debug(15, 1, "neighbors_init: Initializing Neighbors...\n");
  
      if (friends == NULL)
! 	friends = (neighbors *) xcalloc(1, sizeof(neighbors));
  
      if ((fname = getHierarchyLogFile()))
  	neighborsOpenLog(fname);
--- 691,697 ----
      debug(15, 1, "neighbors_init: Initializing Neighbors...\n");
  
      if (friends == NULL)
! 	friends = xcalloc(1, sizeof(neighbors));
  
      if ((fname = getHierarchyLogFile()))
  	neighborsOpenLog(fname);
***************
*** 695,701 ****
  	}
  	debug(15, 1, "Adding a %s: %s\n", t->type, t->host);
  
! 	e = (edge *) xcalloc(1, sizeof(edge));
  	e->ascii_port = t->ascii_port;
  	e->udp_port = t->udp_port;
  	e->proxy_only = t->proxy_only;
--- 705,711 ----
  	}
  	debug(15, 1, "Adding a %s: %s\n", t->type, t->host);
  
! 	e = xcalloc(1, sizeof(edge));
  	e->ascii_port = t->ascii_port;
  	e->udp_port = t->udp_port;
  	e->proxy_only = t->proxy_only;
diff -cr squid-1.0.beta6/src/neighbors.h squid-1.0.beta7/src/neighbors.h
*** squid-1.0.beta6/src/neighbors.h	Mon Apr 15 12:20:26 1996
--- squid-1.0.beta7/src/neighbors.h	Wed May 08 20:40:12 1996
***************
*** 1,5 ****
  
! /*  $Id: neighbors.h,v 1.6 1996/04/15 19:20:26 wessels Exp $ */
  
  #ifndef NEIGHBORS_H
  #define NEIGHBORS_H
--- 1,5 ----
  
! /*  $Id: neighbors.h,v 1.6.2.2 1996/05/09 03:40:12 wessels Exp $ */
  
  #ifndef NEIGHBORS_H
  #define NEIGHBORS_H
***************
*** 39,60 ****
  } dom_list;
  
  #define EDGE_MAX_ADDRESSES 10
  struct _edge {
      char *host;
      struct sockaddr_in in_addr;
-     int rtt;
-     int ack_deficit;
      enum {
  	EDGE_SIBLING,
  	EDGE_PARENT
      } type;			/* 0 if neighbor, 1 if parent */
- 
-     int num_pings;
-     int pings_sent;
-     int pings_acked;
      int neighbor_up;		/* 0 if no, 1 if yes */
!     int hits;
!     int misses;
  
      int udp_port;
      int ascii_port;
--- 39,63 ----
  } dom_list;
  
  #define EDGE_MAX_ADDRESSES 10
+ #define RTT_AV_FACTOR      20
  struct _edge {
      char *host;
      struct sockaddr_in in_addr;
      enum {
  	EDGE_SIBLING,
  	EDGE_PARENT
      } type;			/* 0 if neighbor, 1 if parent */
      int neighbor_up;		/* 0 if no, 1 if yes */
!     struct {
! 	int num_pings;
! 	int pings_sent;
! 	int pings_acked;
! 	int ack_deficit;
! 	int hits;
! 	int misses;
! 	int fetches;
! 	int rtt;
!     } stats;
  
      int udp_port;
      int ascii_port;
***************
*** 94,100 ****
  extern edge *getNextEdge _PARAMS((edge *));
  extern edge *getSingleParent _PARAMS((char *host, int *n));
  extern int neighborsUdpPing _PARAMS((protodispatch_data *));
! extern int neighbors_cf_domain _PARAMS((char *, char *));
  extern neighbors *neighbors_create _PARAMS(());
  extern void hierarchy_log_append _PARAMS((char *, hier_code, int, char *));
  extern void neighborsUdpAck _PARAMS((int, char *, icp_common_t *, struct sockaddr_in *, StoreEntry *));
--- 97,103 ----
  extern edge *getNextEdge _PARAMS((edge *));
  extern edge *getSingleParent _PARAMS((char *host, int *n));
  extern int neighborsUdpPing _PARAMS((protodispatch_data *));
! extern void neighbors_cf_domain _PARAMS((char *, char *));
  extern neighbors *neighbors_create _PARAMS(());
  extern void hierarchy_log_append _PARAMS((char *, hier_code, int, char *));
  extern void neighborsUdpAck _PARAMS((int, char *, icp_common_t *, struct sockaddr_in *, StoreEntry *));
diff -cr squid-1.0.beta6/src/objcache.c squid-1.0.beta7/src/objcache.c
*** squid-1.0.beta6/src/objcache.c	Tue Apr 16 16:09:51 1996
--- squid-1.0.beta7/src/objcache.c	Wed May 08 16:22:52 1996
***************
*** 1,4 ****
! /* $Id: objcache.c,v 1.8 1996/04/16 23:09:51 wessels Exp $ */
  
  /*
   * DEBUG: Section 16          objcache
--- 1,4 ----
! /* $Id: objcache.c,v 1.8.2.1 1996/05/08 23:22:52 wessels Exp $ */
  
  /*
   * DEBUG: Section 16          objcache
***************
*** 101,107 ****
  	debug(16, 1, "getpeername failed??\n");
      }
      /* retrieve object requested */
!     if (strncmp(data->request, "shutdown", strlen("shutdown")) == 0) {
  	if (objcache_CheckPassword(password, username) != 0) {
  	    buf = xstrdup(BADPassword);
  	    storeAppend(data->entry, buf, strlen(buf));
--- 101,107 ----
  	debug(16, 1, "getpeername failed??\n");
      }
      /* retrieve object requested */
!     if (strcmp(data->request, "shutdown") == 0) {
  	if (objcache_CheckPassword(password, username) != 0) {
  	    buf = xstrdup(BADPassword);
  	    storeAppend(data->entry, buf, strlen(buf));
***************
*** 117,171 ****
  	    shut_down(0);
  	}
  
!     } else if (strncmp(data->request, "info", strlen("info")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->info_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "stats/objects", strlen("stats/objects")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "objects", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "stats/vm_objects", strlen("stats/vm_objects")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "vm_objects", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "stats/utilization", strlen("stats/utilization")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "utilization", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "stats/general", strlen("stats/general")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "general", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "log/status", strlen("log/status")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_status_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "log/enable", strlen("log/enable")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_enable(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "log/disable", strlen("log/disable")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_disable(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "log/clear", strlen("log/clear")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_clear(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
--- 117,177 ----
  	    shut_down(0);
  	}
  
!     } else if (strcmp(data->request, "info") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->info_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "stats/objects") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "objects", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "stats/vm_objects") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "vm_objects", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "stats/utilization") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "utilization", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "stats/general") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->stat_get(CacheInfo, "general", data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "stats/io") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
+ 	CacheInfo->stat_get(CacheInfo, "io", data->entry);
+ 	BIT_RESET(data->entry->flag, DELAY_SENDING);
+ 	storeComplete(data->entry);
+ 
+     } else if (strcmp(data->request, "log/status") == 0) {
+ 	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_status_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "log/enable") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_enable(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "log/disable") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_disable(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "log/clear") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_clear(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
***************
*** 172,196 ****
  	storeComplete(data->entry);
  
  #ifdef MENU_SHOW_LOG
!     } else if (strncmp(data->request, "log", strlen("log")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_get_start(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  #endif
  
!     } else if (strncmp(data->request, "parameter", strlen("parameter")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->parameter_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "server_list", strlen("server_list")) == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->server_list(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strncmp(data->request, "squid.conf", strlen("squid.conf")) == 0) {
  	CacheInfo->squid_get_start(CacheInfo, data->entry);
  
      } else {
--- 178,202 ----
  	storeComplete(data->entry);
  
  #ifdef MENU_SHOW_LOG
!     } else if (strcmp(data->request, "log") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->log_get_start(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  #endif
  
!     } else if (strcmp(data->request, "parameter") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->parameter_get(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "server_list") == 0) {
  	BIT_SET(data->entry->flag, DELAY_SENDING);
  	CacheInfo->server_list(CacheInfo, data->entry);
  	BIT_RESET(data->entry->flag, DELAY_SENDING);
  	storeComplete(data->entry);
  
!     } else if (strcmp(data->request, "squid.conf") == 0) {
  	CacheInfo->squid_get_start(CacheInfo, data->entry);
  
      } else {
diff -cr squid-1.0.beta6/src/proto.c squid-1.0.beta7/src/proto.c
*** squid-1.0.beta6/src/proto.c	Thu May 02 18:58:39 1996
--- squid-1.0.beta7/src/proto.c	Wed May 08 16:23:26 1996
***************
*** 1,4 ****
! /* $Id: proto.c,v 1.27.2.7 1996/05/03 01:58:39 wessels Exp $ */
  
  /*
   * DEBUG: Section 17          proto:
--- 1,4 ----
! /* $Id: proto.c,v 1.27.2.10 1996/05/08 23:23:26 wessels Exp $ */
  
  /*
   * DEBUG: Section 17          proto:
***************
*** 195,205 ****
--- 195,207 ----
      if (strncasecmp(url, "cache_object:", 13) == 0)
  	return objcacheStart(fd, url, entry);
  
+ #ifdef OLD_CODE			/* now in icpAccessCheck() */
      /* Check for Proxy request in Accel mode */
      if (httpd_accel_mode &&
  	strncmp(url, getAccelPrefix(), strlen(getAccelPrefix())) &&
  	!getAccelWithProxy())
  	return protoNotImplemented(fd, url, entry);
+ #endif
  
      data = (protodispatch_data *) xcalloc(1, sizeof(protodispatch_data));
  
***************
*** 406,411 ****
--- 408,414 ----
      protoCancelTimeout(fd, entry);
  
      if (e) {
+ 	e->stats.fetches++;
  	return proxyhttpStart(e, url, entry);
      } else if (request->protocol == PROTO_HTTP) {
  	return httpStart(fd, url, request, request_hdr, entry);
diff -cr squid-1.0.beta6/src/proto.h squid-1.0.beta7/src/proto.h
*** squid-1.0.beta6/src/proto.h	Tue Apr 23 22:52:52 1996
--- squid-1.0.beta7/src/proto.h	Wed May 08 19:32:02 1996
***************
*** 1,4 ****
! /*  $Id: proto.h,v 1.7.2.1 1996/04/24 05:52:52 wessels Exp $ */
  
  #ifndef PROTO_H
  #define PROTO_H
--- 1,4 ----
! /*  $Id: proto.h,v 1.7.2.2 1996/05/09 02:32:02 wessels Exp $ */
  
  #ifndef PROTO_H
  #define PROTO_H
***************
*** 146,156 ****
  #define ICP_VERSION_CURRENT	ICP_VERSION_2	/* current version */
  
  extern int icp_proto_errno;	/* operation errors */
- extern int icp_query _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, struct in_addr rid, char *url, char *hostname, int port));
  extern int icp_hit _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, u_num32 size));
  extern int icp_miss _PARAMS((int sock, u_num32 reqnum, u_num32 * auth));
  extern int icp_error _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, unsigned short errcode, char *errstr));
- extern int icp_send _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, struct in_addr rid, char *url));
  extern int icp_databegin _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, u_num32 ttl, u_num32 timestamp, char *data));
  extern int icp_data _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, char *data));
  extern int icp_dataend _PARAMS((int sock, u_num32 reqnum, u_num32 * auth, char *data));
--- 146,154 ----
diff -cr squid-1.0.beta6/src/recv-announce.c squid-1.0.beta7/src/recv-announce.c
*** squid-1.0.beta6/src/recv-announce.c	Tue Apr 16 09:35:29 1996
--- squid-1.0.beta7/src/recv-announce.c	Wed May 08 19:32:02 1996
***************
*** 1,4 ****
! /* $Id: recv-announce.c,v 1.4 1996/04/16 16:35:29 wessels Exp $ */
  
  #include <stdio.h>
  #include <fcntl.h>
--- 1,4 ----
! /* $Id: recv-announce.c,v 1.4.2.1 1996/05/09 02:32:02 wessels Exp $ */
  
  #include <stdio.h>
  #include <fcntl.h>
***************
*** 7,13 ****
--- 7,16 ----
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
+ #include <arpa/inet.h>
  #include <netdb.h>
+ #include <unistd.h>
+ #include <signal.h>
  
  #define RECV_BUF_SIZE 8192
  
***************
*** 51,57 ****
      int len;
      struct hostent *hp = NULL;
      char logfile[BUFSIZ];
-     char *t = NULL;
      char ip[4];
  
      for (len = 0; len < 32; len++) {
--- 54,59 ----
***************
*** 90,93 ****
--- 92,96 ----
  	fputs(buf, stdout);
  	fflush(stdout);
      }
+     return 0;
  }
diff -cr squid-1.0.beta6/src/squid.conf.pre.in squid-1.0.beta7/src/squid.conf.pre.in
*** squid-1.0.beta6/src/squid.conf.pre.in	Wed May 01 16:46:56 1996
--- squid-1.0.beta7/src/squid.conf.pre.in	Tue May 07 09:49:08 1996
***************
*** 1,6 ****
  # @configure_input@
  #
! # $Id: squid.conf.pre.in,v 1.18.4.3 1996/05/01 23:46:56 wessels Exp $
  #
  
  #  TAG: ascii_port
--- 1,6 ----
  # @configure_input@
  #
! # $Id: squid.conf.pre.in,v 1.18.4.4 1996/05/07 16:49:08 wessels Exp $
  #
  
  #  TAG: ascii_port
***************
*** 530,535 ****
--- 530,538 ----
  acl localhost src 127.0.0.1/255.255.255.255
  acl all src 0.0.0.0/0.0.0.0
  
+ acl SSL_ports port 443 563
+ acl CONNECT method CONNECT
+ 
  # Allowing or Denying access based on defined access lists
  #
  # Access to the HTTP port:
***************
*** 540,545 ****
--- 543,549 ----
  
  # Only allow access to the cache manager functions from the local host.
  http_access deny manager !localhost
+ http_access deny CONNECT !SSL_ports
  
  # Allow everything else
  http_access allow  all
diff -cr squid-1.0.beta6/src/stat.c squid-1.0.beta7/src/stat.c
*** squid-1.0.beta6/src/stat.c	Wed May 01 12:15:34 1996
--- squid-1.0.beta7/src/stat.c	Wed May 08 19:32:03 1996
***************
*** 1,4 ****
! /* $Id: stat.c,v 1.28.4.11 1996/05/01 19:15:34 wessels Exp $ */
  
  /*
   * DEBUG: Section 18          stat
--- 1,4 ----
! /* $Id: stat.c,v 1.28.4.16 1996/05/09 02:32:03 wessels Exp $ */
  
  /*
   * DEBUG: Section 18          stat
***************
*** 31,36 ****
--- 31,37 ----
  Meta_data meta_data;
  unsigned long ntcpconn = 0;
  unsigned long nudpconn = 0;
+ struct _iostats IOStats;
  
  char *stat_describe();
  char *mem_describe();
***************
*** 71,77 ****
  
  
      /* find the total */
!     for (proto_id = 0; proto_id < PROTO_MAX; ++proto_id) {
  	q = &obj->proto_stat_data[proto_id];
  
  	p->object_count += q->object_count;
--- 72,78 ----
  
  
      /* find the total */
!     for (proto_id = PROTO_NONE; proto_id < PROTO_MAX; ++proto_id) {
  	q = &obj->proto_stat_data[proto_id];
  
  	p->object_count += q->object_count;
***************
*** 86,92 ****
      }
  
      /* dump it */
!     for (proto_id = 0; proto_id <= PROTO_MAX; ++proto_id) {
  	p = &obj->proto_stat_data[proto_id];
  	if (p->hit != 0) {
  	    p->hitratio =
--- 87,93 ----
      }
  
      /* dump it */
!     for (proto_id = PROTO_NONE; proto_id <= PROTO_MAX; ++proto_id) {
  	p = &obj->proto_stat_data[proto_id];
  	if (p->hit != 0) {
  	    p->hitratio =
***************
*** 110,116 ****
--- 111,163 ----
      storeAppend(sentry, close_bracket, strlen(close_bracket));
  }
  
+ void stat_io_get(obj, sentry)
+      cacheinfo *obj;
+      StoreEntry *sentry;
+ {
+     int i;
+     static char tempbuf[MAX_LINELEN];
  
+     storeAppend(sentry, open_bracket, (int) strlen(open_bracket));
+ 
+     sprintf(tempbuf, "{HTTP I/O}\n");
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{number of reads: %d}\n", IOStats.Http.reads);
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{deferred reads: %d}\n", IOStats.Http.reads_deferred);
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{Read Histogram:}\n");
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     for (i = 0; i < 16; i++) {
+ 	sprintf(tempbuf, "{%5d-%5d: %9d}\n",
+ 	    i ? (1 << (i - 1)) + 1 : 1,
+ 	    1 << i,
+ 	    IOStats.Http.read_hist[i]);
+ 	storeAppend(sentry, tempbuf, strlen(tempbuf));
+     }
+ 
+     sprintf(tempbuf, "{}\n");
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{FTP I/O}\n");
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{number of reads: %d}\n", IOStats.Ftp.reads);
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{deferred reads: %d}\n", IOStats.Ftp.reads_deferred);
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     sprintf(tempbuf, "{Read Histogram:}\n");
+     storeAppend(sentry, tempbuf, strlen(tempbuf));
+     for (i = 0; i < 16; i++) {
+ 	sprintf(tempbuf, "{%5d-%5d: %9d}\n",
+ 	    i ? (1 << (i - 1)) + 1 : 1,
+ 	    1 << i,
+ 	    IOStats.Ftp.read_hist[i]);
+ 	storeAppend(sentry, tempbuf, strlen(tempbuf));
+     }
+ 
+     storeAppend(sentry, close_bracket, strlen(close_bracket));
+ }
+ 
+ 
  /* return total bytes of all registered and known objects.
   * may not reflect the retrieving object....
   * something need to be done here to get more accurate cache size */
***************
*** 120,126 ****
      int size = 0;
      protocol_t proto_id;
      /* sum all size, exclude total */
!     for (proto_id = 0; proto_id < PROTO_MAX; proto_id++)
  	size += obj->proto_stat_data[proto_id].kb.now;
      return size;
  }
--- 167,173 ----
      int size = 0;
      protocol_t proto_id;
      /* sum all size, exclude total */
!     for (proto_id = PROTO_NONE; proto_id < PROTO_MAX; proto_id++)
  	size += obj->proto_stat_data[proto_id].kb.now;
      return size;
  }
***************
*** 199,204 ****
--- 246,253 ----
  	stat_general_get(obj, sentry);
      } else if (strncmp(req, "utilization", strlen("utilization")) == 0) {
  	stat_utilization_get(obj, sentry);
+     } else if (strcmp(req, "io") == 0) {
+ 	stat_io_get(obj, sentry);
      }
  }
  
***************
*** 266,273 ****
  	storeComplete(sentry);
  	return;
      }
!     data = (log_read_data_t *) xmalloc(sizeof(log_read_data_t));
!     memset(data, '\0', sizeof(log_read_data_t));
      data->sentry = sentry;
      strcpy(tmp, open_bracket);
      storeAppend(sentry, tmp, 2);
--- 315,321 ----
  	storeComplete(sentry);
  	return;
      }
!     data = xcalloc(1, sizeof(log_read_data_t));
      data->sentry = sentry;
      strcpy(tmp, open_bracket);
      storeAppend(sentry, tmp, 2);
***************
*** 315,322 ****
  {
      squid_read_data_t *data;
  
!     data = (squid_read_data_t *) xmalloc(sizeof(squid_read_data_t));
!     memset(data, '\0', sizeof(squid_read_data_t));
      data->sentry = sentry;
      data->fd = file_open((char *) ConfigFile, NULL, O_RDONLY);
      storeAppend(sentry, open_bracket, (int) strlen(open_bracket));
--- 363,369 ----
  {
      squid_read_data_t *data;
  
!     data = xcalloc(1, sizeof(squid_read_data_t));
      data->sentry = sentry;
      data->fd = file_open((char *) ConfigFile, NULL, O_RDONLY);
      storeAppend(sentry, open_bracket, (int) strlen(open_bracket));
***************
*** 333,338 ****
--- 380,392 ----
      storeAppend(sentry, msg, strlen(msg));
  }
  
+ static int percent(a, b)
+      int a;
+      int b;
+ {
+     return b ? ((int) (100.0 * a / b + 0.5)) : 0;
+ }
+ 
  void server_list(obj, sentry)
       cacheinfo *obj;
       StoreEntry *sentry;
***************
*** 343,349 ****
  
      storeAppend(sentry, open_bracket, (int) strlen(open_bracket));
  
!     if (getFirstEdge() == (edge *) NULL) {
  	sprintf(tempbuf, "{There are no neighbors installed.}\n");
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
      }
--- 397,403 ----
  
      storeAppend(sentry, open_bracket, (int) strlen(open_bracket));
  
!     if (getFirstEdge() == NULL) {
  	sprintf(tempbuf, "{There are no neighbors installed.}\n");
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
      }
***************
*** 350,373 ****
      for (e = getFirstEdge(); e; e = getNextEdge(e)) {
  	if (e->host == NULL)
  	    fatal_dump("Found an edge without a hostname!");
! 	sprintf(tempbuf, "\n{Hostname:    %s}\n", e->host);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{Edge type:   %s}\n",
! 	    e->type == EDGE_PARENT ? "parent" : "neighbor");
! 	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{Status:      %s}\n",
  	    e->neighbor_up ? "Up" : "Down");
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{UDP PORT:    %d}\n", e->udp_port);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{ASCII PORT:  %d}\n", e->ascii_port);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{ACK DEFICIT: %d}\n", e->ack_deficit);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{PINGS SENT:  %d}\n", e->num_pings);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{PINGS ACKED: %d}\n", e->pings_acked);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
  	if (e->last_fail_time) {
  	    sprintf(tempbuf, "{Last failed connect() at: %s}\n",
  		mkhttpdlogtime(&(e->last_fail_time)));
--- 404,442 ----
      for (e = getFirstEdge(); e; e = getNextEdge(e)) {
  	if (e->host == NULL)
  	    fatal_dump("Found an edge without a hostname!");
! 	sprintf(tempbuf, "\n{%-11.11s: %s/%d/%d}\n",
! 	    e->type == EDGE_PARENT ? "Parent" : "Sibling",
! 	    e->host,
! 	    e->ascii_port,
! 	    e->udp_port);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{Status     : %s}\n",
  	    e->neighbor_up ? "Up" : "Down");
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{AVG RTT    : %d msec}\n", e->stats.rtt);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 
! 	sprintf(tempbuf, "{ACK DEFICIT: %8d}\n", e->stats.ack_deficit);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{PINGS SENT : %8d}\n", e->stats.num_pings);
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{PINGS ACKED: %8d %3d%%}\n",
! 	    e->stats.pings_acked,
! 	    percent(e->stats.pings_acked, e->stats.num_pings));
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
! 	sprintf(tempbuf, "{MISSES     : %8d %3d%%}\n",
! 	    e->stats.misses,
! 	    percent(e->stats.misses, e->stats.pings_acked));
  	storeAppend(sentry, tempbuf, strlen(tempbuf));
+ 	sprintf(tempbuf, "{HITS       : %8d %3d%%}\n",
+ 	    e->stats.hits,
+ 	    percent(e->stats.hits, e->stats.pings_acked));
+ 	storeAppend(sentry, tempbuf, strlen(tempbuf));
+ 	sprintf(tempbuf, "{FETCHES    : %8d %3d%%}\n",
+ 	    e->stats.fetches,
+ 	    percent(e->stats.fetches, e->stats.pings_acked));
+ 	storeAppend(sentry, tempbuf, strlen(tempbuf));
+ 
  	if (e->last_fail_time) {
  	    sprintf(tempbuf, "{Last failed connect() at: %s}\n",
  		mkhttpdlogtime(&(e->last_fail_time)));
***************
*** 960,972 ****
      cacheinfo *obj = NULL;
      int i;
  
!     obj = (cacheinfo *) xmalloc(sizeof(cacheinfo));
!     memset(obj, '\0', sizeof(cacheinfo));
! 
      obj->stat_get = stat_get;
      obj->info_get = info_get;
      obj->cache_size_get = cache_size_get;
- 
      obj->log_get_start = log_get_start;
      obj->log_status_get = log_status_get;
      obj->log_append = log_append;
--- 1029,1038 ----
      cacheinfo *obj = NULL;
      int i;
  
!     obj = xcalloc(1, sizeof(cacheinfo));
      obj->stat_get = stat_get;
      obj->info_get = info_get;
      obj->cache_size_get = cache_size_get;
      obj->log_get_start = log_get_start;
      obj->log_status_get = log_status_get;
      obj->log_append = log_append;
***************
*** 974,982 ****
      obj->log_enable = log_enable;
      obj->log_disable = log_disable;
      obj->logfile_status = LOG_ENABLE;
- 
      obj->squid_get_start = squid_get_start;
- 
      obj->parameter_get = parameter_get;
      obj->server_list = server_list;
  
--- 1040,1046 ----
***************
*** 996,1002 ****
      obj->proto_miss = proto_miss;
      obj->NotImplement = dummyhandler;
  
!     for (i = 0; i <= PROTO_MAX; i++) {
  	switch (i) {
  	case PROTO_HTTP:
  	    strcpy(obj->proto_stat_data[i].protoname, "HTTP");
--- 1060,1066 ----
      obj->proto_miss = proto_miss;
      obj->NotImplement = dummyhandler;
  
!     for (i = PROTO_NONE; i <= PROTO_MAX; i++) {
  	switch (i) {
  	case PROTO_HTTP:
  	    strcpy(obj->proto_stat_data[i].protoname, "HTTP");
diff -cr squid-1.0.beta6/src/stat.h squid-1.0.beta7/src/stat.h
*** squid-1.0.beta6/src/stat.h	Thu Apr 18 13:45:11 1996
--- squid-1.0.beta7/src/stat.h	Wed May 08 16:23:28 1996
***************
*** 1,4 ****
! /* $Id: stat.h,v 1.10.2.1 1996/04/18 20:45:11 wessels Exp $ */
  
  #ifndef STAT_H
  #define STAT_H
--- 1,4 ----
! /* $Id: stat.h,v 1.10.2.3 1996/05/08 23:23:28 wessels Exp $ */
  
  #ifndef STAT_H
  #define STAT_H
***************
*** 125,130 ****
--- 125,142 ----
      proto_stat proto_stat_data[PROTO_MAX + 1];
  
  };
+ 
+ struct _iostats {
+     struct {
+ 	int reads;
+ 	int reads_deferred;
+ 	int read_hist[16];
+ 	int writes;
+ 	int write_hist[16];
+     } Http, Ftp;
+ };
+ 
+ extern struct _iostats IOStats;
  
  extern cacheinfo *CacheInfo;
  extern unsigned long ntcpconn;
diff -cr squid-1.0.beta6/src/stmem.c squid-1.0.beta7/src/stmem.c
*** squid-1.0.beta6/src/stmem.c	Fri Apr 12 14:41:40 1996
--- squid-1.0.beta7/src/stmem.c	Wed May 08 19:32:03 1996
***************
*** 1,4 ****
! /* $Id: stmem.c,v 1.9 1996/04/12 21:41:40 wessels Exp $ */
  
  /* 
   * DEBUG: Section 19          stmem:
--- 1,4 ----
! /* $Id: stmem.c,v 1.9.2.1 1996/05/09 02:32:03 wessels Exp $ */
  
  /* 
   * DEBUG: Section 19          stmem:
***************
*** 281,291 ****
  	page = pop(&sm_stats.free_page_stack);
      } else {
  #if USE_MEMALIGN
! 	page = (char *) memalign(SM_PAGE_SIZE, SM_PAGE_SIZE);
  	if (!page)
  	    fatal_dump(NULL);
  #else
! 	page = (char *) xmalloc(SM_PAGE_SIZE);
  #endif
  	sm_stats.total_pages_allocated++;
      }
--- 281,291 ----
  	page = pop(&sm_stats.free_page_stack);
      } else {
  #if USE_MEMALIGN
! 	page = memalign(SM_PAGE_SIZE, SM_PAGE_SIZE);
  	if (!page)
  	    fatal_dump(NULL);
  #else
! 	page = xmalloc(SM_PAGE_SIZE);
  #endif
  	sm_stats.total_pages_allocated++;
      }
***************
*** 325,335 ****
  	page = pop(&disk_stats.free_page_stack);
      } else {
  #if USE_MEMALIGN
! 	page = (char *) memalign(DISK_PAGE_SIZE, DISK_PAGE_SIZE);
  	if (!page)
  	    fatal_dump(NULL);
  #else
! 	page = (char *) xmalloc(DISK_PAGE_SIZE);
  #endif
  	disk_stats.total_pages_allocated++;
      }
--- 325,335 ----
  	page = pop(&disk_stats.free_page_stack);
      } else {
  #if USE_MEMALIGN
! 	page = memalign(DISK_PAGE_SIZE, DISK_PAGE_SIZE);
  	if (!page)
  	    fatal_dump(NULL);
  #else
! 	page = xmalloc(DISK_PAGE_SIZE);
  #endif
  	disk_stats.total_pages_allocated++;
      }
diff -cr squid-1.0.beta6/src/store.c squid-1.0.beta7/src/store.c
*** squid-1.0.beta6/src/store.c	Thu May 02 09:55:51 1996
--- squid-1.0.beta7/src/store.c	Wed May 08 19:32:04 1996
***************
*** 1,5 ****
  
! /* $Id: store.c,v 1.61.4.12 1996/05/02 16:55:51 wessels Exp $ */
  
  /*
   * DEBUG: Section 20          store
--- 1,5 ----
  
! /* $Id: store.c,v 1.61.4.13 1996/05/09 02:32:04 wessels Exp $ */
  
  /*
   * DEBUG: Section 20          store
***************
*** 233,239 ****
  
  void storeSetMemStatus(e, status)
       StoreEntry *e;
!      int status;
  {
      hash_link *ptr = NULL;
  
--- 233,239 ----
  
  void storeSetMemStatus(e, status)
       StoreEntry *e;
!      mem_status_t status;
  {
      hash_link *ptr = NULL;
  
***************
*** 491,497 ****
  
  char *storeGeneratePrivateKey(url, method, num)
       char *url;
!      int method;
       int num;
  {
      if (num == 0)
--- 491,497 ----
  
  char *storeGeneratePrivateKey(url, method, num)
       char *url;
!      method_t method;
       int num;
  {
      if (num == 0)
***************
*** 507,513 ****
  
  char *storeGeneratePublicKey(url, method)
       char *url;
!      int method;
  {
      debug(20, 3, "storeGeneratePublicKey: type=%d %s\n", method, url);
      switch (method) {
--- 507,513 ----
  
  char *storeGeneratePublicKey(url, method)
       char *url;
!      method_t method;
  {
      debug(20, 3, "storeGeneratePublicKey: type=%d %s\n", method, url);
      switch (method) {
***************
*** 608,614 ****
       char *url;
       char *req_hdr;
       int flags;
!      int method;
  {
      StoreEntry *e = NULL;
      MemObject *m = NULL;
--- 608,614 ----
       char *url;
       char *req_hdr;
       int flags;
!      method_t method;
  {
      StoreEntry *e = NULL;
      MemObject *m = NULL;
***************
*** 2542,2562 ****
      if (!url1 || !url2)
  	fatal_dump("urlcmp: Got a NULL url pointer.");
      return (strcmp(url1, url2));
- }
- 
- int parse_file_number(s)
-      char *s;
- {
-     int len;
- 
- 
-     for (len = strlen(s); (len >= 0); --len) {
- 	if (s[len] == '/') {
- 	    return (atoi(&s[len + 1]));
- 	}
-     }
-     debug(20, 1, "parse_file_number: Could not determine the swap file number from %s.\n", s);
-     return (0);
  }
  
  /* 
--- 2542,2547 ----
diff -cr squid-1.0.beta6/src/store.h squid-1.0.beta7/src/store.h
*** squid-1.0.beta6/src/store.h	Thu Apr 25 15:06:13 1996
--- squid-1.0.beta7/src/store.h	Wed May 08 19:32:05 1996
***************
*** 1,5 ****
  
! /*  $Id: store.h,v 1.26.2.3 1996/04/25 22:06:13 wessels Exp $ */
  
  #ifndef _STORE_H_
  #define _STORE_H_
--- 1,5 ----
  
! /*  $Id: store.h,v 1.26.2.4 1996/05/09 02:32:05 wessels Exp $ */
  
  #ifndef _STORE_H_
  #define _STORE_H_
***************
*** 154,160 ****
  } PendingEntry;
  
  extern StoreEntry *storeGet _PARAMS((char *));
! extern StoreEntry *storeCreateEntry _PARAMS((char *, char *, int, int));
  extern void storeSetPublicKey _PARAMS((StoreEntry *));
  extern void storeSetPrivateKey _PARAMS((StoreEntry *));
  extern StoreEntry *storeGetFirst _PARAMS((void));
--- 154,160 ----
  } PendingEntry;
  
  extern StoreEntry *storeGet _PARAMS((char *));
! extern StoreEntry *storeCreateEntry _PARAMS((char *, char *, int, method_t));
  extern void storeSetPublicKey _PARAMS((StoreEntry *));
  extern void storeSetPrivateKey _PARAMS((StoreEntry *));
  extern StoreEntry *storeGetFirst _PARAMS((void));
***************
*** 184,191 ****
  #ifdef NOT_USED_CODE
  extern int storeGrep _PARAMS((StoreEntry *, char *, int));
  #endif
! extern char *storeGeneratePublicKey _PARAMS((char *, int));
! extern char *storeGeneratePrivateKey _PARAMS((char *, int, int));
  extern char *storeMatchMime _PARAMS((StoreEntry *, char *, char *, int));
  extern int storeAddSwapDisk _PARAMS((char *));
  extern char *swappath _PARAMS((int));
--- 184,191 ----
  #ifdef NOT_USED_CODE
  extern int storeGrep _PARAMS((StoreEntry *, char *, int));
  #endif
! extern char *storeGeneratePublicKey _PARAMS((char *, method_t));
! extern char *storeGeneratePrivateKey _PARAMS((char *, method_t, int));
  extern char *storeMatchMime _PARAMS((StoreEntry *, char *, char *, int));
  extern int storeAddSwapDisk _PARAMS((char *));
  extern char *swappath _PARAMS((int));
diff -cr squid-1.0.beta6/src/tools.c squid-1.0.beta7/src/tools.c
*** squid-1.0.beta6/src/tools.c	Thu Apr 25 15:06:07 1996
--- squid-1.0.beta7/src/tools.c	Wed May 08 19:32:06 1996
***************
*** 1,5 ****
  
! /* $Id: tools.c,v 1.40.2.11 1996/04/25 22:06:07 wessels Exp $ */
  
  /*
   * DEBUG: Section 21          tools
--- 1,5 ----
  
! /* $Id: tools.c,v 1.40.2.12 1996/05/09 02:32:06 wessels Exp $ */
  
  /*
   * DEBUG: Section 21          tools
***************
*** 219,238 ****
      abort();
  }
  
- 
- int getHeapSize()
- {
- #if HAVE_MALLINFO
-     struct mallinfo mp;
- 
-     mp = mallinfo();
- 
-     return (mp.arena);
- #else
-     return (0);
- #endif
- }
- 
  void sig_child(sig)
       int sig;
  {
--- 219,224 ----
***************
*** 318,344 ****
  	if (!quiet)
  	    debug(21, 1, "safeunlink: Couldn't delete %s. %s\n", s, xstrerror());
      return (err);
- }
- 
- /* 
-  * Daemonize a process according to guidlines in "Advanced Programming
-  * For The UNIX Environment", W.R. Stevens ( Addison Wesley, 1992) - Ch. 13
-  */
- int daemonize()
- {
-     int n_openf, i;
-     pid_t pid;
-     if ((pid = fork()) < 0)
- 	return -1;
-     else if (pid != 0)
- 	exit(0);
-     /* Child continues */
-     setsid();			/* Become session leader */
-     n_openf = getMaxFD();	/* Close any inherited files */
-     for (i = 0; i < n_openf; i++)
- 	close(i);
-     umask(0);			/* Clear file mode creation mask */
-     return 0;
  }
  
  void check_suid()
--- 304,309 ----
diff -cr squid-1.0.beta6/src/tools.h squid-1.0.beta7/src/tools.h
*** squid-1.0.beta6/src/tools.h	Tue Apr 23 12:54:39 1996
--- squid-1.0.beta7/src/tools.h	Wed May 08 19:32:06 1996
***************
*** 1,5 ****
  
! /* $Id: tools.h,v 1.12.2.1 1996/04/23 19:54:39 wessels Exp $ */
  
  extern char *getMyHostname _PARAMS((void));
  extern int getMaxFD _PARAMS((void));
--- 1,5 ----
  
! /* $Id: tools.h,v 1.12.2.2 1996/05/09 02:32:06 wessels Exp $ */
  
  extern char *getMyHostname _PARAMS((void));
  extern int getMaxFD _PARAMS((void));
***************
*** 13,19 ****
  extern void check_suid _PARAMS((void));
  extern void get_suid _PARAMS((void));
  extern void no_suid _PARAMS((void));
- extern int daemonize _PARAMS((void));
  extern void writePidFile _PARAMS((void));
  extern void setMaxFD _PARAMS((void));
  extern time_t getCurrentTime _PARAMS((void));
--- 13,18 ----
diff -cr squid-1.0.beta6/src/ttl.c squid-1.0.beta7/src/ttl.c
*** squid-1.0.beta6/src/ttl.c	Mon Apr 15 22:05:34 1996
--- squid-1.0.beta7/src/ttl.c	Wed May 08 19:32:07 1996
***************
*** 1,5 ****
  
! /* $Id: ttl.c,v 1.9 1996/04/16 05:05:34 wessels Exp $ */
  
  /*
   * DEBUG: Section 22          ttl
--- 1,5 ----
  
! /* $Id: ttl.c,v 1.9.2.1 1996/05/09 02:32:07 wessels Exp $ */
  
  /*
   * DEBUG: Section 22          ttl
***************
*** 50,64 ****
      pct_age = pct_age < 0 ? 0 : pct_age > 100 ? 100 : pct_age;
      age_max = age_max < 0 ? 0 : age_max;
  
!     t = (ttl_t *) xmalloc(sizeof(ttl_t));
!     memset((char *) t, '\0', sizeof(ttl_t));
! 
      t->pattern = (char *) xstrdup(pattern);
      t->compiled_pattern = comp;
      t->abs_ttl = abs_ttl;
      t->pct_age = pct_age;
      t->age_max = age_max;
!     t->next = (ttl_t *) NULL;
  
      if (!TTL_tbl)
  	TTL_tbl = t;
--- 50,62 ----
      pct_age = pct_age < 0 ? 0 : pct_age > 100 ? 100 : pct_age;
      age_max = age_max < 0 ? 0 : age_max;
  
!     t = xcalloc(1, sizeof(ttl_t));
      t->pattern = (char *) xstrdup(pattern);
      t->compiled_pattern = comp;
      t->abs_ttl = abs_ttl;
      t->pct_age = pct_age;
      t->age_max = age_max;
!     t->next = NULL;
  
      if (!TTL_tbl)
  	TTL_tbl = t;
***************
*** 145,151 ****
      else if (!strncmp(entry->url, "gopher:", 7))
  	default_ttl = getGopherTTL();
  
!     match = (ttl_t *) NULL;
      for (t = TTL_tbl; t; t = t->next) {
  	if (regexec(&(t->compiled_pattern), entry->url, 0, 0, 0) == 0) {
  	    match = t;
--- 143,149 ----
      else if (!strncmp(entry->url, "gopher:", 7))
  	default_ttl = getGopherTTL();
  
!     match = NULL;
      for (t = TTL_tbl; t; t = t->next) {
  	if (regexec(&(t->compiled_pattern), entry->url, 0, 0, 0) == 0) {
  	    match = t;
diff -cr squid-1.0.beta6/src/url.c squid-1.0.beta7/src/url.c
*** squid-1.0.beta6/src/url.c	Thu May 02 18:58:39 1996
--- squid-1.0.beta7/src/url.c	Wed May 08 19:32:07 1996
***************
*** 1,4 ****
! /* $Id: url.c,v 1.19.2.6 1996/05/03 01:58:39 wessels Exp $ */
  
  /* 
   * DEBUG: Section 23          url
--- 1,4 ----
! /* $Id: url.c,v 1.19.2.8 1996/05/09 02:32:07 wessels Exp $ */
  
  /* 
   * DEBUG: Section 23          url
***************
*** 43,49 ****
  
      url = allocate ? (char *) xstrdup(org_url) : org_url;
  
!     if (strlen(url) < 3 || !strchr(url, '%'))
  	return url;
  
      for (s = t = url; *(s + 2); s++) {
--- 43,49 ----
  
      url = allocate ? (char *) xstrdup(org_url) : org_url;
  
!     if ((int) strlen(url) < 3 || !strchr(url, '%'))
  	return url;
  
      for (s = t = url; *(s + 2); s++) {
***************
*** 186,194 ****
  	    *t = 0;
  	    strcpy(host, t + 1);
  	}
! 	if ((t = strrchr(host, ':')) && *(t + 1) != '\0') {
! 	    *t = '\0';
! 	    port = atoi(t + 1);
  	}
      }
      for (t = host; *t; t++)
--- 186,195 ----
  	    *t = 0;
  	    strcpy(host, t + 1);
  	}
! 	if ((t = strrchr(host, ':'))) {
! 	    *t++ = '\0';
! 	    if (*t != '\0')
! 		port = atoi(t);
  	}
      }
      for (t = host; *t; t++)