This patch is generated from the modio branch of HEAD in squid
Sun Jan 25 14:36:32 2004 GMT
See http://devel.squid-cache.org/

Index: squid/include/version.h
diff -u squid/include/version.h:1.4 squid/include/version.h:1.2.2.2
--- squid/include/version.h:1.4	Tue Nov 14 05:03:47 2000
+++ squid/include/version.h	Wed Dec 20 07:27:39 2000
@@ -4,7 +4,7 @@
  *  SQUID_VERSION - String for version id of this distribution
  */
 #ifndef SQUID_VERSION
-#define SQUID_VERSION	"2.5.DEVEL"
+#define SQUID_VERSION	"2.5.DEVEL-modio"
 #endif
 
 #ifndef SQUID_RELEASE_TIME
Index: squid/src/HttpHdrRange.c
diff -u squid/src/HttpHdrRange.c:1.6 squid/src/HttpHdrRange.c:1.2.2.4
--- squid/src/HttpHdrRange.c:1.6	Wed Feb  7 11:11:47 2001
+++ squid/src/HttpHdrRange.c	Tue Feb 13 12:54:28 2001
@@ -467,7 +467,7 @@
     assert(http);
     stringAppend(&b, full_appname_string, strlen(full_appname_string));
     stringAppend(&b, ":", 1);
-    key = storeKeyText(http->entry->hash.key);
+    key = storeKeyPublic(storeKeyUrl(http->entry), METHOD_GET);
     stringAppend(&b, key, strlen(key));
     return b;
 }
Index: squid/src/HttpRequest.c
diff -u squid/src/HttpRequest.c:1.6 squid/src/HttpRequest.c:1.2.2.5
--- squid/src/HttpRequest.c:1.6	Fri Jan 12 00:20:32 2001
+++ squid/src/HttpRequest.c	Sun Mar 18 14:51:21 2001
@@ -35,10 +35,24 @@
 
 #include "squid.h"
 
+CBDATA_TYPE(request_t);
+
+static int request_initialised = 0;
+
+void
+requestInit(void)
+{
+	if (request_initialised)
+		return;
+
+	request_initialised = 1;
+	CBDATA_INIT_TYPE(request_t);
+}
+
 request_t *
 requestCreate(method_t method, protocol_t protocol, const char *urlpath)
 {
-    request_t *req = memAllocate(MEM_REQUEST_T);
+    request_t *req = cbdataAlloc(request_t);
     req->method = method;
     req->protocol = protocol;
     if (urlpath)
@@ -51,6 +65,7 @@
     return req;
 }
 
+
 void
 requestDestroy(request_t * req)
 {
@@ -64,9 +79,7 @@
     httpHeaderClean(&req->header);
     if (req->cache_control)
 	httpHdrCcDestroy(req->cache_control);
-    if (req->range)
-	httpHdrRangeDestroy(req->range);
-    memFree(req, MEM_REQUEST_T);
+    cbdataFree(req);
 }
 
 request_t *
Index: squid/src/Makefile.in
diff -u squid/src/Makefile.in:1.7 squid/src/Makefile.in:1.2.2.6
--- squid/src/Makefile.in:1.7	Sat Feb 10 08:49:03 2001
+++ squid/src/Makefile.in	Tue Feb 13 12:54:29 2001
@@ -183,6 +183,8 @@
 		wais.o \
 		wccp.o \
 		whois.o \
+		reply_internal.o \
+		reply_network.o \
 		$(XTRA_OBJS)
 
 SNMP_OBJS	= \
Index: squid/src/asn.c
diff -u squid/src/asn.c:1.10 squid/src/asn.c:1.2.2.12
--- squid/src/asn.c:1.10	Sat Mar  3 02:44:31 2001
+++ squid/src/asn.c	Sun Mar 18 14:33:31 2001
@@ -195,18 +195,19 @@
     assert(NULL != req);
     asState->request = requestLink(req);
     if ((e = storeGetPublic(asres, METHOD_GET)) == NULL) {
-	e = storeCreateEntry(asres, asres, null_request_flags, METHOD_GET);
-	asState->sc = storeClientListAdd(e, asState);
+        /* I'm guessing that this should be private .. */
+	e = storeCreateEntry(asres, asres, null_request_flags, METHOD_GET,
+          REPLY_OBJ_INTERNAL);
+	storeClientRegister(e, asState);
 	fwdStart(-1, e, asState->request);
     } else {
 	storeLockObject(e);
-	asState->sc = storeClientListAdd(e, asState);
+	storeClientRegister(e, asState);
     }
     asState->entry = e;
     asState->seen = 0;
     asState->offset = 0;
-    storeClientCopy(asState->sc,
-	e,
+    storeClientCopy(e,
 	asState->seen,
 	asState->offset,
 	4096,
@@ -228,7 +229,7 @@
 	asStateFree(asState);
 	return;
     }
-    if (size == 0 && e->mem_obj->inmem_hi > 0) {
+    if (size == 0 && storeMemHiOffset(e) > 0) {
 	memFree(buf, MEM_4K_BUF);
 	asStateFree(asState);
 	return;
@@ -267,18 +268,16 @@
 	asState->seen, asState->offset);
     if (e->store_status == STORE_PENDING) {
 	debug(53, 3) ("asHandleReply: store_status == STORE_PENDING: %s\n", storeUrl(e));
-	storeClientCopy(asState->sc,
-	    e,
+	storeClientCopy(e,
 	    asState->seen,
 	    asState->offset,
 	    4096,
 	    buf,
 	    asHandleReply,
 	    asState);
-    } else if (asState->seen < e->mem_obj->inmem_hi) {
-	debug(53, 3) ("asHandleReply: asState->seen < e->mem_obj->inmem_hi %s\n", storeUrl(e));
-	storeClientCopy(asState->sc,
-	    e,
+    } else if (asState->seen < storeMemHiOffset(e)) {
+	debug(53, 3) ("asHandleReply: asState->seen < storeMemHiOffset(e) %s\n", storeUrl(e));
+	storeClientCopy(e,
 	    asState->seen,
 	    asState->offset,
 	    4096,
@@ -297,7 +296,7 @@
 {
     ASState *asState = data;
     debug(53, 3) ("asnStateFree: %s\n", storeUrl(asState->entry));
-    storeUnregister(asState->sc, asState->entry, asState);
+    storeClientUnregister(asState->entry, asState);
     storeUnlockObject(asState->entry);
     requestUnlink(asState->request);
     cbdataFree(asState);
Index: squid/src/cbdata.c
diff -u squid/src/cbdata.c:1.10 squid/src/cbdata.c:1.2.2.6
--- squid/src/cbdata.c:1.10	Sat Mar  3 02:44:31 2001
+++ squid/src/cbdata.c	Sun Mar 18 14:51:21 2001
@@ -134,7 +134,6 @@
 #define CREATE_CBDATA_FREE(type, free_func) cbdataInitType(CBDATA_##type, #type, sizeof(type), free_func)
     CREATE_CBDATA(acl_access);
     CREATE_CBDATA(aclCheck_t);
-    CREATE_CBDATA(clientHttpRequest);
     CREATE_CBDATA(ConnStateData);
     CREATE_CBDATA(ErrorState);
     CREATE_CBDATA(FwdState);
Index: squid/src/client_side.c
diff -u squid/src/client_side.c:1.24 squid/src/client_side.c:1.2.2.25
--- squid/src/client_side.c:1.24	Sun Mar  4 05:45:04 2001
+++ squid/src/client_side.c	Sun Mar 18 14:51:21 2001
@@ -78,7 +78,6 @@
 /* Local functions */
 
 static CWCB clientWriteComplete;
-static CWCB clientWriteBodyComplete;
 static PF clientReadRequest;
 static PF connStateFree;
 static PF requestTimeout;
@@ -103,8 +102,6 @@
 static STCB clientSendMoreData;
 static STCB clientCacheHit;
 static void clientSetKeepaliveFlag(clientHttpRequest *);
-static void clientPackRangeHdr(const HttpReply * rep, const HttpHdrRangeSpec * spec, String boundary, MemBuf * mb);
-static void clientPackTermBound(String boundary, MemBuf * mb);
 static void clientInterpretRequestHeaders(clientHttpRequest *);
 static void clientProcessRequest(clientHttpRequest *);
 static void clientProcessExpired(void *data);
@@ -113,11 +110,27 @@
 static int clientHierarchical(clientHttpRequest * http);
 static int clientCheckContentLength(request_t * r);
 static DEFER httpAcceptDefer;
-static log_type clientProcessRequest2(clientHttpRequest * http);
+static log_type clientProcessRequest2(clientHttpRequest * http, StoreEntry *e);
 static int clientReplyBodyTooLarge(int clen);
 static int clientRequestBodyTooLarge(int clen);
+static void httpMemFree(void *);
+static STGETDONE clientPurgeRequest;
+static STGETDONE clientLookupDone;
+static STGETDONE clientLookupHeadDone;
+static void clientProcessRequestDone(clientHttpRequest *http);
 static void clientProcessBody(ConnStateData * conn);
 
+
+CBDATA_TYPE(clientHttpRequest);
+
+static void httpMemFree(void *data)
+{
+    clientHttpRequest *h = data;
+
+    memFree(h->buf, MEM_CLIENT_SOCK_BUF);
+}
+
+
 static int
 checkAccelOnly(clientHttpRequest * http)
 {
@@ -192,7 +205,8 @@
 }
 
 StoreEntry *
-clientCreateStoreEntry(clientHttpRequest * h, method_t m, request_flags flags)
+clientCreateStoreEntry(clientHttpRequest * h, method_t m, request_flags flags,
+  reply_obj_t reply_obj)
 {
     StoreEntry *e;
     /*
@@ -201,13 +215,13 @@
      */
     if (h->request == NULL)
 	h->request = requestLink(requestCreate(m, PROTO_NONE, null_string));
-    e = storeCreateEntry(h->uri, h->log_uri, flags, m);
-    h->sc = storeClientListAdd(e, h);
+    e = storeCreateEntry(h->uri, h->log_uri, flags, m, reply_obj);
+    storeClientRegister(e, h);
 #if DELAY_POOLS
     delaySetStoreClient(h->sc, delayClient(h->request));
 #endif
-    storeClientCopy(h->sc, e, 0, 0, CLIENT_SOCK_SZ,
-	memAllocate(MEM_CLIENT_SOCK_BUF), clientSendMoreData, h);
+    h->bufofs = 0;
+    storeClientCopy(e, 0, 0, CLIENT_SOCK_SZ, h->buf, clientSendMoreData, h);
     return e;
 }
 
@@ -246,7 +260,7 @@
 	page_id = aclGetDenyInfoPage(&Config.denyInfoList, AclMatchedName);
 	http->log_type = LOG_TCP_DENIED;
 	http->entry = clientCreateStoreEntry(http, http->request->method,
-	    null_request_flags);
+	    null_request_flags, REPLY_OBJ_INTERNAL);
 	if (answer == ACCESS_REQ_PROXY_AUTH || aclIsProxyAuth(AclMatchedName)) {
 	    if (!http->flags.accel) {
 		/* Proxy authorisation needed */
@@ -367,19 +381,19 @@
     }
     http->request->flags.refresh = 1;
     http->old_entry = http->entry;
-    http->old_sc = http->sc;
     /*
      * Assert that 'http' is already a client of old_entry.  If 
      * it is not, then the beginning of the object data might get
      * freed from memory before we need to access it.
      */
-    assert(http->sc->callback_data == http);
+    assert(http->entry->sc.callback_data == http);
     entry = storeCreateEntry(url,
 	http->log_uri,
 	http->request->flags,
-	http->request->method);
+	http->request->method,
+        REPLY_OBJ_NETWORK);
     /* NOTE, don't call storeLockObject(), storeCreateEntry() does it */
-    http->sc = storeClientListAdd(entry, http);
+    storeClientRegister(entry, http);
 #if DELAY_POOLS
     /* delay_id is already set on original store client */
     delaySetStoreClient(http->sc, delayClient(http->request));
@@ -392,11 +406,12 @@
     /* Register with storage manager to receive updates when data comes in. */
     if (EBIT_TEST(entry->flags, ENTRY_ABORTED))
 	debug(33, 0) ("clientProcessExpired: found ENTRY_ABORTED object\n");
-    storeClientCopy(http->sc, entry,
+    http->bufofs = 0;
+    storeClientCopy(entry,
 	http->out.offset,
 	http->out.offset,
 	CLIENT_SOCK_SZ,
-	memAllocate(MEM_CLIENT_SOCK_BUF),
+	http->buf,
 	clientHandleIMSReply,
 	http);
 }
@@ -452,11 +467,9 @@
     http_status status;
     debug(33, 3) ("clientHandleIMSReply: %s, %d bytes\n", url, (int) size);
     if (entry == NULL) {
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     }
     if (size < 0 && !EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     }
     mem = entry->mem_obj;
@@ -466,10 +479,9 @@
 	/* We have an existing entry, but failed to validate it */
 	/* Its okay to send the old one anyway */
 	http->log_type = LOG_TCP_REFRESH_FAIL_HIT;
-	storeUnregister(http->sc, entry, http);
+	storeClientUnregister(entry, http);
 	storeUnlockObject(entry);
 	entry = http->entry = http->old_entry;
-	http->sc = http->old_sc;
     } else if (STORE_PENDING == entry->store_status && 0 == status) {
 	debug(33, 3) ("clientHandleIMSReply: Incomplete headers for '%s'\n", url);
 	if (size >= CLIENT_SOCK_SZ) {
@@ -477,17 +489,18 @@
 	    debug(33, 3) ("clientHandleIMSReply: Reply is too large '%s', using old entry\n", url);
 	    /* use old entry, this repeats the code abovez */
 	    http->log_type = LOG_TCP_REFRESH_FAIL_HIT;
-	    storeUnregister(http->sc, entry, http);
+	    storeClientUnregister(entry, http);
 	    storeUnlockObject(entry);
 	    entry = http->entry = http->old_entry;
-	    http->sc = http->old_sc;
 	    /* continue */
 	} else {
-	    storeClientCopy(http->sc, entry,
-		http->out.offset + size,
-		http->out.offset,
-		CLIENT_SOCK_SZ,
-		buf,
+            http->bufofs += size;
+            assert(http->bufofs <= CLIENT_SOCK_SZ);
+	    storeClientCopy(entry,
+		http->out.offset + http->bufofs,
+		http->out.offset + http->bufofs,
+		CLIENT_SOCK_SZ - http->bufofs,
+		buf + http->bufofs,
 		clientHandleIMSReply,
 		http);
 	    return;
@@ -508,8 +521,7 @@
 	 * not the body they refer to.  */
 	httpReplyUpdateOnNotModified(oldentry->mem_obj->reply, mem->reply);
 	storeTimestampsSet(oldentry);
-	storeUnregister(http->sc, entry, http);
-	http->sc = http->old_sc;
+	storeClientUnregister(entry, http);
 	storeUnlockObject(entry);
 	entry = http->entry = oldentry;
 	entry->timestamp = squid_curtime;
@@ -526,15 +538,15 @@
 	    storeTimestampsSet(http->old_entry);
 	    http->log_type = LOG_TCP_REFRESH_HIT;
 	}
-	storeUnregister(http->old_sc, http->old_entry, http);
+	storeClientUnregister(http->old_entry, http);
 	storeUnlockObject(http->old_entry);
 	recopy = 0;
     }
     http->old_entry = NULL;	/* done with old_entry */
-    http->old_sc = NULL;
     assert(!EBIT_TEST(entry->flags, ENTRY_ABORTED));
     if (recopy) {
-	storeClientCopy(http->sc, entry,
+        http->bufofs = 0;
+	storeClientCopy(entry,
 	    http->out.offset,
 	    http->out.offset,
 	    CLIENT_SOCK_SZ,
@@ -581,27 +593,38 @@
 }
 
 void
-clientPurgeRequest(clientHttpRequest * http)
+clientStartPurgeRequest(clientHttpRequest * http)
 {
-    StoreEntry *entry;
     ErrorState *err = NULL;
-    HttpReply *r;
-    http_status status;
-    http_version_t version;
+
     debug(33, 3) ("Config2.onoff.enable_purge = %d\n", Config2.onoff.enable_purge);
     if (!Config2.onoff.enable_purge) {
 	http->log_type = LOG_TCP_DENIED;
 	err = errorCon(ERR_ACCESS_DENIED, HTTP_FORBIDDEN);
 	err->request = requestLink(http->request);
 	err->src_addr = http->conn->peer.sin_addr;
-	http->entry = clientCreateStoreEntry(http, http->request->method, null_request_flags);
+	http->entry = clientCreateStoreEntry(http, http->request->method,
+          null_request_flags, REPLY_OBJ_INTERNAL);
 	errorAppendEntry(http->entry, err);
 	return;
     }
     http->log_type = LOG_TCP_MISS;
     /* Release both IP and object cache entries */
     ipcacheInvalidate(http->request->host);
-    if ((entry = storeGetPublic(http->uri, METHOD_GET)) == NULL) {
+    /* Initiate a lookup to try and get said object */
+    storeDoubleCheckRequest(http->request, http->uri, METHOD_GET);
+    storeLookup(http->request, clientPurgeRequest, http);
+}
+
+static void
+clientPurgeRequest(void *data, StoreEntry *entry)
+{
+    clientHttpRequest *http = data;
+    HttpReply *r;
+    http_status status;
+    http_version_t version;
+
+    if (entry == NULL) {
 	status = HTTP_NOT_FOUND;
     } else {
 	storeRelease(entry);
@@ -613,7 +636,8 @@
      * Make a new entry to hold the reply to be written
      * to the client.
      */
-    http->entry = clientCreateStoreEntry(http, http->request->method, null_request_flags);
+    http->entry = clientCreateStoreEntry(http, http->request->method,
+      null_request_flags, REPLY_OBJ_INTERNAL);
     httpReplyReset(r = http->entry->mem_obj->reply);
     httpBuildVersion(&version, 1, 0);
     httpReplySetHeaders(r, version, status, NULL, NULL, 0, 0, -1);
@@ -718,7 +742,7 @@
 	 */
 	if ((e = http->entry)) {
 	    http->entry = NULL;
-	    storeUnregister(http->sc, e, http);
+	    storeClientUnregister(e, http);
 	    storeUnlockObject(e);
 	}
 #endif
@@ -773,19 +797,16 @@
     safe_free(http->al.headers.request);
     safe_free(http->al.headers.reply);
     safe_free(http->redirect.location);
-    stringClean(&http->range_iter.boundary);
     if ((e = http->entry)) {
 	http->entry = NULL;
-	storeUnregister(http->sc, e, http);
-	http->sc = NULL;
+	storeClientUnregister(e, http);
 	storeUnlockObject(e);
     }
     /* old_entry might still be set if we didn't yet get the reply
      * code in clientHandleIMSReply() */
     if ((e = http->old_entry)) {
 	http->old_entry = NULL;
-	storeUnregister(http->old_sc, e, http);
-	http->old_sc = NULL;
+	storeClientUnregister(e, http);
 	storeUnlockObject(e);
     }
     requestUnlink(http->request);
@@ -888,12 +909,15 @@
 #endif
 	    request->flags.nocache = 1;
     }
+
     /* ignore range header in non-GETs */
     if (request->method == METHOD_GET) {
-	request->range = httpHeaderGetRange(req_hdr);
-	if (request->range)
-	    request->flags.range = 1;
+        if (httpHeaderHas(req_hdr, HDR_RANGE))
+           request->flags.range = 1; 
+        if (httpHeaderHas(req_hdr, HDR_REQUEST_RANGE))
+           request->flags.range = 1;
     }
+
     if (httpHeaderHas(req_hdr, HDR_AUTHORIZATION))
 	request->flags.auth = 1;
     if (request->login[0] != '\0')
@@ -1069,149 +1093,6 @@
     return 0;
 }
 
-/*
- * returns true if If-Range specs match reply, false otherwise
- */
-static int
-clientIfRangeMatch(clientHttpRequest * http, HttpReply * rep)
-{
-    const TimeOrTag spec = httpHeaderGetTimeOrTag(&http->request->header, HDR_IF_RANGE);
-    /* check for parsing falure */
-    if (!spec.valid)
-	return 0;
-    /* got an ETag? */
-    if (spec.tag.str) {
-	ETag rep_tag = httpHeaderGetETag(&rep->header, HDR_ETAG);
-	debug(33, 3) ("clientIfRangeMatch: ETags: %s and %s\n",
-	    spec.tag.str, rep_tag.str ? rep_tag.str : "<none>");
-	if (!rep_tag.str)
-	    return 0;		/* entity has no etag to compare with! */
-	if (spec.tag.weak || rep_tag.weak) {
-	    debug(33, 1) ("clientIfRangeMatch: Weak ETags are not allowed in If-Range: %s ? %s\n",
-		spec.tag.str, rep_tag.str);
-	    return 0;		/* must use strong validator for sub-range requests */
-	}
-	return etagIsEqual(&rep_tag, &spec.tag);
-    }
-    /* got modification time? */
-    if (spec.time >= 0) {
-	return http->entry->lastmod <= spec.time;
-    }
-    assert(0);			/* should not happen */
-    return 0;
-}
-
-/* returns expected content length for multi-range replies
- * note: assumes that httpHdrRangeCanonize has already been called
- * warning: assumes that HTTP headers for individual ranges at the
- *          time of the actuall assembly will be exactly the same as
- *          the headers when clientMRangeCLen() is called */
-static int
-clientMRangeCLen(clientHttpRequest * http)
-{
-    int clen = 0;
-    HttpHdrRangePos pos = HttpHdrRangeInitPos;
-    const HttpHdrRangeSpec *spec;
-    MemBuf mb;
-
-    assert(http->entry->mem_obj);
-
-    memBufDefInit(&mb);
-    while ((spec = httpHdrRangeGetSpec(http->request->range, &pos))) {
-
-	/* account for headers for this range */
-	memBufReset(&mb);
-	clientPackRangeHdr(http->entry->mem_obj->reply,
-	    spec, http->range_iter.boundary, &mb);
-	clen += mb.size;
-
-	/* account for range content */
-	clen += spec->length;
-
-	debug(33, 6) ("clientMRangeCLen: (clen += %d + %d) == %d\n",
-	    mb.size, spec->length, clen);
-    }
-    /* account for the terminating boundary */
-    memBufReset(&mb);
-    clientPackTermBound(http->range_iter.boundary, &mb);
-    clen += mb.size;
-
-    memBufClean(&mb);
-    return clen;
-}
-
-/* adds appropriate Range headers if needed */
-static void
-clientBuildRangeHeader(clientHttpRequest * http, HttpReply * rep)
-{
-    HttpHeader *hdr = rep ? &rep->header : 0;
-    const char *range_err = NULL;
-    request_t *request = http->request;
-    assert(request->range);
-    /* check if we still want to do ranges */
-    if (!rep)
-	range_err = "no [parse-able] reply";
-    else if (rep->sline.status != HTTP_OK)
-	range_err = "wrong status code";
-    else if (httpHeaderHas(hdr, HDR_CONTENT_RANGE))
-	range_err = "origin server does ranges";
-    else if (rep->content_length < 0)
-	range_err = "unknown length";
-    else if (rep->content_length != http->entry->mem_obj->reply->content_length)
-	range_err = "INCONSISTENT length";	/* a bug? */
-    else if (httpHeaderHas(&http->request->header, HDR_IF_RANGE) && !clientIfRangeMatch(http, rep))
-	range_err = "If-Range match failed";
-    else if (!httpHdrRangeCanonize(http->request->range, rep->content_length))
-	range_err = "canonization failed";
-    else if (httpHdrRangeIsComplex(http->request->range))
-	range_err = "too complex range header";
-    else if (!request->flags.cachable)	/* from we_do_ranges in http.c */
-	range_err = "non-cachable request";
-    /* get rid of our range specs on error */
-    if (range_err) {
-	debug(33, 3) ("clientBuildRangeHeader: will not do ranges: %s.\n", range_err);
-	httpHdrRangeDestroy(http->request->range);
-	http->request->range = NULL;
-    } else {
-	const int spec_count = http->request->range->specs.count;
-	int actual_clen = -1;
-
-	debug(33, 3) ("clientBuildRangeHeader: range spec count: %d virgin clen: %d\n",
-	    spec_count, rep->content_length);
-	assert(spec_count > 0);
-	/* ETags should not be returned with Partial Content replies? */
-	httpHeaderDelById(hdr, HDR_ETAG);
-	/* append appropriate header(s) */
-	if (spec_count == 1) {
-	    HttpHdrRangePos pos = HttpHdrRangeInitPos;
-	    const HttpHdrRangeSpec *spec = httpHdrRangeGetSpec(http->request->range, &pos);
-	    assert(spec);
-	    /* append Content-Range */
-	    httpHeaderAddContRange(hdr, *spec, rep->content_length);
-	    /* set new Content-Length to the actual number of bytes
-	     * transmitted in the message-body */
-	    actual_clen = spec->length;
-	} else {
-	    /* multipart! */
-	    /* generate boundary string */
-	    http->range_iter.boundary = httpHdrRangeBoundaryStr(http);
-	    /* delete old Content-Type, add ours */
-	    httpHeaderDelById(hdr, HDR_CONTENT_TYPE);
-	    httpHeaderPutStrf(hdr, HDR_CONTENT_TYPE,
-		"multipart/byteranges; boundary=\"%s\"",
-		strBuf(http->range_iter.boundary));
-	    /* Content-Length is not required in multipart responses
-	     * but it is always nice to have one */
-	    actual_clen = clientMRangeCLen(http);
-	}
-
-	/* replace Content-Length header */
-	assert(actual_clen >= 0);
-	httpHeaderDelById(hdr, HDR_CONTENT_LENGTH);
-	httpHeaderPutInt(hdr, HDR_CONTENT_LENGTH, actual_clen);
-	debug(33, 3) ("clientBuildRangeHeader: actual content length: %d\n", actual_clen);
-    }
-}
 
 /*
  * filters out unwanted entries from original reply header
@@ -1256,9 +1137,6 @@
 	httpHeaderDelById(hdr, HDR_CONNECTION);
 	stringClean(&strConnection);
     }
-    /* Handle Ranges */
-    if (request->range)
-	clientBuildRangeHeader(http, rep);
     /*
      * Add a estimated Age header on cache hits.
      */
@@ -1331,19 +1209,15 @@
 	httpBuildVersion(&rep->sline.version, 1, 0);
 	/* do header conversions */
 	clientBuildReplyHeader(http, rep);
+
 	/* if we do ranges, change status to "Partial Content" */
-	if (http->request->range)
+	if (http->request->flags.range)
 	    httpStatusLineSet(&rep->sline, rep->sline.version,
 		HTTP_PARTIAL_CONTENT, NULL);
     } else {
 	/* parsing failure, get rid of the invalid reply */
 	httpReplyDestroy(rep);
 	rep = NULL;
-	/* if we were going to do ranges, backoff */
-	if (http->request->range) {
-	    /* this will fail and destroy request->range */
-	    clientBuildRangeHeader(http, rep);
-	}
     }
     return rep;
 }
@@ -1364,18 +1238,15 @@
     request_t *r = http->request;
     debug(33, 3) ("clientCacheHit: %s, %d bytes\n", http->uri, (int) size);
     if (http->entry == NULL) {
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	debug(33, 3) ("clientCacheHit: request aborted\n");
 	return;
     } else if (size < 0) {
 	/* swap in failure */
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	debug(33, 3) ("clientCacheHit: swapin failure for %s\n", http->uri);
 	http->log_type = LOG_TCP_SWAPFAIL_MISS;
 	if ((e = http->entry)) {
 	    http->entry = NULL;
-	    storeUnregister(http->sc, e, http);
-	    http->sc = NULL;
+	    storeClientUnregister(e, http);
 	    storeUnlockObject(e);
 	}
 	clientProcessMiss(http);
@@ -1390,18 +1261,18 @@
 	 * punt to clientProcessMiss.
 	 */
 	if (e->mem_status == IN_MEMORY || e->store_status == STORE_OK) {
-	    memFree(buf, MEM_CLIENT_SOCK_BUF);
 	    clientProcessMiss(http);
 	} else if (size == CLIENT_SOCK_SZ && http->out.offset == 0) {
-	    memFree(buf, MEM_CLIENT_SOCK_BUF);
 	    clientProcessMiss(http);
 	} else {
 	    debug(33, 3) ("clientCacheHit: waiting for HTTP reply headers\n");
-	    storeClientCopy(http->sc, e,
-		http->out.offset + size,
-		http->out.offset,
-		CLIENT_SOCK_SZ,
-		buf,
+            http->bufofs += size;
+            assert(http->bufofs <= CLIENT_SOCK_SZ);
+	    storeClientCopy(e,
+		http->out.offset + http->bufofs,
+		http->out.offset + http->bufofs,
+		CLIENT_SOCK_SZ - http->bufofs,
+		buf + http->bufofs,
 		clientCacheHit,
 		http);
 	}
@@ -1465,7 +1336,6 @@
 	    http->log_type = LOG_TCP_MISS;
 	    clientProcessMiss(http);
 	}
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
     } else if (r->flags.ims) {
 	/*
 	 * Handle If-Modified-Since requests from the client
@@ -1473,7 +1343,6 @@
 	if (mem->reply->sline.status != HTTP_OK) {
 	    debug(33, 4) ("clientCacheHit: Reply code %d != 200\n",
 		mem->reply->sline.status);
-	    memFree(buf, MEM_CLIENT_SOCK_BUF);
 	    http->log_type = LOG_TCP_MISS;
 	    clientProcessMiss(http);
 	} else if (modifiedSince(e, http->request)) {
@@ -1483,11 +1352,10 @@
 	    time_t timestamp = e->timestamp;
 	    MemBuf mb = httpPacked304Reply(e->mem_obj->reply);
 	    http->log_type = LOG_TCP_IMS_HIT;
-	    memFree(buf, MEM_CLIENT_SOCK_BUF);
-	    storeUnregister(http->sc, e, http);
-	    http->sc = NULL;
+	    storeClientUnregister(e, http);
 	    storeUnlockObject(e);
-	    e = clientCreateStoreEntry(http, http->request->method, null_request_flags);
+	    e = clientCreateStoreEntry(http, http->request->method,
+              null_request_flags, REPLY_OBJ_INTERNAL);
 	    /*
 	     * Copy timestamp from the original entry so the 304
 	     * reply has a meaningful Age: header.
@@ -1511,168 +1379,6 @@
     }
 }
 
-/* put terminating boundary for multiparts */
-static void
-clientPackTermBound(String boundary, MemBuf * mb)
-{
-    memBufPrintf(mb, "\r\n--%s--\r\n", strBuf(boundary));
-    debug(33, 6) ("clientPackTermBound: buf offset: %d\n", mb->size);
-}
-
-/* appends a "part" HTTP header (as in a multi-part/range reply) to the buffer */
-static void
-clientPackRangeHdr(const HttpReply * rep, const HttpHdrRangeSpec * spec, String boundary, MemBuf * mb)
-{
-    HttpHeader hdr;
-    Packer p;
-    assert(rep);
-    assert(spec);
-
-    /* put boundary */
-    debug(33, 5) ("clientPackRangeHdr: appending boundary: %s\n", strBuf(boundary));
-    /* rfc2046 requires to _prepend_ boundary with <crlf>! */
-    memBufPrintf(mb, "\r\n--%s\r\n", strBuf(boundary));
-
-    /* stuff the header with required entries and pack it */
-    httpHeaderInit(&hdr, hoReply);
-    if (httpHeaderHas(&rep->header, HDR_CONTENT_TYPE))
-	httpHeaderPutStr(&hdr, HDR_CONTENT_TYPE, httpHeaderGetStr(&rep->header, HDR_CONTENT_TYPE));
-    httpHeaderAddContRange(&hdr, *spec, rep->content_length);
-    packerToMemInit(&p, mb);
-    httpHeaderPackInto(&hdr, &p);
-    packerClean(&p);
-    httpHeaderClean(&hdr);
-
-    /* append <crlf> (we packed a header, not a reply) */
-    memBufPrintf(mb, crlf);
-}
-
-/*
- * extracts a "range" from *buf and appends them to mb, updating
- * all offsets and such.
- */
-static void
-clientPackRange(clientHttpRequest * http,
-    HttpHdrRangeIter * i,
-    const char **buf,
-    ssize_t * size,
-    MemBuf * mb)
-{
-    const ssize_t copy_sz = i->debt_size <= *size ? i->debt_size : *size;
-    off_t body_off = http->out.offset - i->prefix_size;
-    assert(*size > 0);
-    assert(i->spec);
-    /*
-     * intersection of "have" and "need" ranges must not be empty
-     */
-    assert(body_off < i->spec->offset + i->spec->length);
-    assert(body_off + *size > i->spec->offset);
-    /*
-     * put boundary and headers at the beginning of a range in a
-     * multi-range
-     */
-    if (http->request->range->specs.count > 1 && i->debt_size == i->spec->length) {
-	assert(http->entry->mem_obj);
-	clientPackRangeHdr(
-	    http->entry->mem_obj->reply,	/* original reply */
-	    i->spec,		/* current range */
-	    i->boundary,	/* boundary, the same for all */
-	    mb
-	    );
-    }
-    /*
-     * append content
-     */
-    debug(33, 3) ("clientPackRange: appending %d bytes\n", copy_sz);
-    memBufAppend(mb, *buf, copy_sz);
-    /*
-     * update offsets
-     */
-    *size -= copy_sz;
-    i->debt_size -= copy_sz;
-    body_off += copy_sz;
-    *buf += copy_sz;
-    http->out.offset = body_off + i->prefix_size;	/* sync */
-    /*
-     * paranoid check
-     */
-    assert(*size >= 0 && i->debt_size >= 0);
-}
-
-/* returns true if there is still data available to pack more ranges
- * increments iterator "i"
- * used by clientPackMoreRanges */
-static int
-clientCanPackMoreRanges(const clientHttpRequest * http, HttpHdrRangeIter * i, ssize_t size)
-{
-    /* first update "i" if needed */
-    if (!i->debt_size) {
-	if ((i->spec = httpHdrRangeGetSpec(http->request->range, &i->pos)))
-	    i->debt_size = i->spec->length;
-    }
-    assert(!i->debt_size == !i->spec);	/* paranoid sync condition */
-    /* continue condition: need_more_data && have_more_data */
-    return i->spec && size > 0;
-}
-
-/* extracts "ranges" from buf and appends them to mb, updating all offsets and such */
-/* returns true if we need more data */
-static int
-clientPackMoreRanges(clientHttpRequest * http, const char *buf, ssize_t size, MemBuf * mb)
-{
-    HttpHdrRangeIter *i = &http->range_iter;
-    /* offset in range specs does not count the prefix of an http msg */
-    off_t body_off = http->out.offset - i->prefix_size;
-    assert(size >= 0);
-    /* check: reply was parsed and range iterator was initialized */
-    assert(i->prefix_size > 0);
-    /* filter out data according to range specs */
-    while (clientCanPackMoreRanges(http, i, size)) {
-	off_t start;		/* offset of still missing data */
-	assert(i->spec);
-	start = i->spec->offset + i->spec->length - i->debt_size;
-	debug(33, 3) ("clientPackMoreRanges: in:  offset: %d size: %d\n",
-	    (int) body_off, size);
-	debug(33, 3) ("clientPackMoreRanges: out: start: %d spec[%d]: [%d, %d), len: %d debt: %d\n",
-	    (int) start, (int) i->pos, i->spec->offset, (int) (i->spec->offset + i->spec->length), i->spec->length, i->debt_size);
-	assert(body_off <= start);	/* we did not miss it */
-	/* skip up to start */
-	if (body_off + size > start) {
-	    const size_t skip_size = start - body_off;
-	    body_off = start;
-	    size -= skip_size;
-	    buf += skip_size;
-	} else {
-	    /* has not reached start yet */
-	    body_off += size;
-	    size = 0;
-	    buf = NULL;
-	}
-	/* put next chunk if any */
-	if (size) {
-	    http->out.offset = body_off + i->prefix_size;	/* sync */
-	    clientPackRange(http, i, &buf, &size, mb);
-	    body_off = http->out.offset - i->prefix_size;	/* sync */
-	}
-    }
-    assert(!i->debt_size == !i->spec);	/* paranoid sync condition */
-    debug(33, 3) ("clientPackMoreRanges: buf exhausted: in:  offset: %d size: %d need_more: %d\n",
-	(int) body_off, size, i->debt_size);
-    if (i->debt_size) {
-	debug(33, 3) ("clientPackMoreRanges: need more: spec[%d]: [%d, %d), len: %d\n",
-	    (int) i->pos, i->spec->offset, (int) (i->spec->offset + i->spec->length), i->spec->length);
-	/* skip the data we do not need if possible */
-	if (i->debt_size == i->spec->length)	/* at the start of the cur. spec */
-	    body_off = i->spec->offset;
-	else
-	    assert(body_off == i->spec->offset + i->spec->length - i->debt_size);
-    } else if (http->request->range->specs.count > 1) {
-	/* put terminating boundary for multiparts */
-	clientPackTermBound(i->boundary, mb);
-    }
-    http->out.offset = body_off + i->prefix_size;	/* sync */
-    return i->debt_size > 0;
-}
 
 static int
 clientReplyBodyTooLarge(int clen)
@@ -1752,22 +1458,18 @@
     if (conn->chr != http) {
 	/* there is another object in progress, defer this one */
 	debug(33, 1) ("clientSendMoreData: Deferring %s\n", storeUrl(entry));
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     } else if (entry && EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
 	/* call clientWriteComplete so the client socket gets closed */
 	clientWriteComplete(fd, NULL, 0, COMM_OK, http);
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     } else if (size < 0) {
 	/* call clientWriteComplete so the client socket gets closed */
 	clientWriteComplete(fd, NULL, 0, COMM_OK, http);
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     } else if (size == 0) {
 	/* call clientWriteComplete so the client socket gets closed */
 	clientWriteComplete(fd, NULL, 0, COMM_OK, http);
-	memFree(buf, MEM_CLIENT_SOCK_BUF);
 	return;
     }
     if (http->out.offset == 0) {
@@ -1783,11 +1485,10 @@
 	if (rep && clientReplyBodyTooLarge(rep->content_length)) {
 	    ErrorState *err = errorCon(ERR_TOO_BIG, HTTP_FORBIDDEN);
 	    err->request = requestLink(http->request);
-	    storeUnregister(http->sc, http->entry, http);
-	    http->sc = NULL;
+	    storeClientUnregister(http->entry, http);
 	    storeUnlockObject(http->entry);
 	    http->entry = clientCreateStoreEntry(http, http->request->method,
-		null_request_flags);
+		null_request_flags, REPLY_OBJ_INTERNAL);
 	    errorAppendEntry(http->entry, err);
 	    httpReplyDestroy(rep);
 	    return;
@@ -1815,11 +1516,11 @@
 		ErrorState *err;
 		err = errorCon(ERR_ACCESS_DENIED, HTTP_FORBIDDEN);
 		err->request = requestLink(http->request);
-		storeUnregister(http->sc, http->entry, http);
-		http->sc = NULL;
+		storeClientUnregister(http->entry, http);
 		storeUnlockObject(http->entry);
-		http->entry = clientCreateStoreEntry(http, http->request->method,
-		    null_request_flags);
+		http->entry =
+                  clientCreateStoreEntry(http, http->request->method,
+                    null_request_flags, REPLY_OBJ_INTERNAL);
 		errorAppendEntry(http->entry, err);
 		httpReplyDestroy(rep);
 		return;
@@ -1827,24 +1528,17 @@
 	    aclChecklistFree(ch);
 	} else if (size < CLIENT_SOCK_SZ && entry->store_status == STORE_PENDING) {
 	    /* wait for more to arrive */
-	    storeClientCopy(http->sc, entry,
-		http->out.offset + size,
-		http->out.offset,
-		CLIENT_SOCK_SZ,
-		buf,
+            http->bufofs += size;
+            assert(http->bufofs <= CLIENT_SOCK_SZ);
+	    storeClientCopy(entry,
+		http->out.offset + http->bufofs,
+		http->out.offset + http->bufofs,
+		CLIENT_SOCK_SZ - http->bufofs,
+		buf + http->bufofs,
 		clientSendMoreData,
 		http);
 	    return;
 	}
-	/* reset range iterator */
-	http->range_iter.pos = HttpHdrRangeInitPos;
-    } else if (!http->request->range) {
-	/* Avoid copying to MemBuf for non-range requests */
-	/* Note, if we're here, then 'rep' is known to be NULL */
-	http->out.offset += body_size;
-	comm_write(fd, buf, size, clientWriteBodyComplete, http, NULL);
-	/* NULL because clientWriteBodyComplete frees it */
-	return;
     }
     if (http->request->method == METHOD_HEAD) {
 	if (rep) {
@@ -1879,42 +1573,18 @@
 	memBufDefInit(&mb);
     }
     /* append body if any */
-    if (http->request->range) {
-	/* Only GET requests should have ranges */
-	assert(http->request->method == METHOD_GET);
-	/* clientPackMoreRanges() updates http->out.offset */
-	/* force the end of the transfer if we are done */
-	if (!clientPackMoreRanges(http, body_buf, body_size, &mb))
-	    http->flags.done_copying = 1;
-    } else if (body_buf && body_size) {
+    if (body_buf && body_size) {
 	http->out.offset += body_size;
 	check_size += body_size;
 	memBufAppend(&mb, body_buf, body_size);
     }
-    if (!http->request->range && http->request->method == METHOD_GET)
+    if (http->request->method == METHOD_GET)
 	assert(check_size == size);
     /* write */
     comm_write_mbuf(fd, mb, clientWriteComplete, http);
     /* if we don't do it, who will? */
-    memFree(buf, MEM_CLIENT_SOCK_BUF);
 }
 
-/*
- * clientWriteBodyComplete is called for MEM_CLIENT_SOCK_BUF's
- * written directly to the client socket, versus copying to a MemBuf
- * and going through comm_write_mbuf.  Most non-range responses after
- * the headers probably go through here.
- */
-static void
-clientWriteBodyComplete(int fd, char *buf, size_t size, int errflag, void *data)
-{
-    /*
-     * NOTE: clientWriteComplete doesn't currently use its "buf"
-     * (second) argument, so we pass in NULL.
-     */
-    clientWriteComplete(fd, NULL, size, errflag, data);
-    memFree(buf, MEM_CLIENT_SOCK_BUF);
-}
 
 static void
 clientKeepaliveNextRequest(clientHttpRequest * http)
@@ -1955,14 +1625,15 @@
 	debug(33, 1) ("clientKeepaliveNextRequest: FD %d Sending next\n",
 	    conn->fd);
 	assert(entry);
-	if (0 == storeClientCopyPending(http->sc, entry, http)) {
+	if (0 == storeClientCopyPending(entry, http)) {
 	    if (EBIT_TEST(entry->flags, ENTRY_ABORTED))
 		debug(33, 0) ("clientKeepaliveNextRequest: ENTRY_ABORTED\n");
-	    storeClientCopy(http->sc, entry,
+            http->bufofs = 0;
+	    storeClientCopy(entry,
 		http->out.offset,
 		http->out.offset,
 		CLIENT_SOCK_SZ,
-		memAllocate(MEM_CLIENT_SOCK_BUF),
+		http->buf,
 		clientSendMoreData,
 		http);
 	}
@@ -2017,11 +1688,12 @@
 	 * storage manager. */
 	if (EBIT_TEST(entry->flags, ENTRY_ABORTED))
 	    debug(33, 0) ("clientWriteComplete 2: ENTRY_ABORTED\n");
-	storeClientCopy(http->sc, entry,
+        http->bufofs = 0;
+	storeClientCopy(entry,
 	    http->out.offset,
 	    http->out.offset,
 	    CLIENT_SOCK_SZ,
-	    memAllocate(MEM_CLIENT_SOCK_BUF),
+	    http->buf,
 	    clientSendMoreData,
 	    http);
     }
@@ -2046,60 +1718,68 @@
     err->request = requestLink(r);
     err->src_addr = http->conn->peer.sin_addr;
     if (http->entry) {
-	storeUnregister(http->sc, http->entry, http);
-	http->sc = NULL;
+	storeClientUnregister(http->entry, http);
 	storeUnlockObject(http->entry);
     }
-    http->entry = clientCreateStoreEntry(http, r->method, null_request_flags);
+    http->entry = clientCreateStoreEntry(http, r->method, null_request_flags,
+      REPLY_OBJ_INTERNAL);
     errorAppendEntry(http->entry, err);
 }
 
-/* 
- * Return true if we should force a cache miss on this range request.
- * entry must be non-NULL.
+
+/*
+ * clientLookupDone - handle the result of the first lookup
+ *
+ * If the result of the first lookup is a MISS and the method is METHOD_HEAD,
+ * we can generate a HEAD reply from a cached GET object, so initiate a
+ * second lookup. Otherwise, call clientProcessRequest2() to get the
+ * cache hit/miss information, and punt to clientProcessRequestDone().
  */
-static int
-clientCheckRangeForceMiss(StoreEntry * entry, HttpHdrRange * range)
+static void
+clientLookupDone(void *data, StoreEntry *e)
 {
-    /*
-     * If the range_offset_limit is NOT in effect, there
-     * is no reason to force a miss.
-     */
-    if (0 == httpHdrRangeOffsetLimit(range))
-	return 0;
-    /*
-     * Here, we know it's possibly a hit.  If we already have the
-     * whole object cached, we won't force a miss.
-     */
-    if (STORE_OK == entry->store_status)
-	return 0;		/* we have the whole object */
-    /*
-     * Now we have a hit on a PENDING object.  We need to see
-     * if the part we want is already cached.  If so, we don't
-     * force a miss.
-     */
-    assert(NULL != entry->mem_obj);
-    if (httpHdrRangeFirstOffset(range) <= entry->mem_obj->inmem_hi)
-	return 0;
-    /*
-     * Even though we have a PENDING copy of the object, we
-     * don't want to wait to reach the first range offset,
-     * so we force a miss for a new range request to the
-     * origin.
-     */
-    return 1;
+    clientHttpRequest *http = data;
+
+    if (http->request->method == METHOD_HEAD && e == NULL) {
+        /*
+         * Start off the GET lookup, and change the request to be a
+         * HEAD afterwards
+         */
+        http->request->method = METHOD_GET;
+        storeDoubleCheckRequest(http->request, http->uri, METHOD_GET);
+        storeLookup(http->request, clientLookupHeadDone, http);
+        http->request->method = METHOD_HEAD;
+    } else {
+        /* We have to continue with our result, NULL or not */
+        http->log_type = clientProcessRequest2(http, e);
+        clientProcessRequestDone(http);
+    }
+    /* NOTREACHED */
 }
 
+/*
+ * clientLookupHeadDone - handle the HEAD -> GET request
+ *
+ * Similar to clientLookupDone(), we simply call clientProcessRequest2
+ */
+static void
+clientLookupHeadDone(void *data, StoreEntry *e)
+{
+    clientHttpRequest *http = data;
+
+    http->log_type = clientProcessRequest2(http, e);
+    clientProcessRequestDone(http);
+}
+
+/*
+ * decide whether we've got a cache HIT or MISS, and then punt across
+ * to clientProcessRequestDone()
+ */
 static log_type
-clientProcessRequest2(clientHttpRequest * http)
+clientProcessRequest2(clientHttpRequest * http, StoreEntry *e)
 {
     request_t *r = http->request;
-    StoreEntry *e;
-    e = http->entry = storeGetPublic(http->uri, r->method);
-    if (r->method == METHOD_HEAD && e == NULL) {
-	/* We can generate a HEAD reply from a cached GET object */
-	e = http->entry = storeGetPublic(http->uri, METHOD_GET);
-    }
+
     /* Release negatively cached IP-cache entries on reload */
     if (r->flags.nocache)
 	ipcacheInvalidate(r->host);
@@ -2112,7 +1792,7 @@
 #endif
     if (NULL == e) {
 	/* this object isn't in the cache */
-	debug(33, 3) ("clientProcessRequest2: storeGet() MISS\n");
+	debug(33, 3) ("clientProcessRequest2: storeLookup() MISS\n");
 	return LOG_TCP_MISS;
     }
     if (Config.onoff.offline) {
@@ -2151,21 +1831,14 @@
 	http->entry = NULL;
 	ipcacheInvalidate(r->host);
 	return LOG_TCP_CLIENT_REFRESH_MISS;
-    }
-    if (NULL == r->range) {
-	(void) 0;
-    } else if (httpHdrRangeWillBeComplex(r->range)) {
+    } else if (r->flags.range) {
 	/*
 	 * Some clients break if we return "200 OK" for a Range
 	 * request.  We would have to return "200 OK" for a _complex_
 	 * Range request that is also a HIT. Thus, let's prevent HITs
 	 * on complex Range requests
 	 */
-	debug(33, 3) ("clientProcessRequest2: complex range MISS\n");
-	http->entry = NULL;
-	return LOG_TCP_MISS;
-    } else if (clientCheckRangeForceMiss(e, r->range)) {
-	debug(33, 3) ("clientProcessRequest2: forcing miss due to range_offset_limit\n");
+	debug(33, 3) ("clientProcessRequest2: range MISS\n");
 	http->entry = NULL;
 	return LOG_TCP_MISS;
     }
@@ -2190,11 +1863,12 @@
 	sslStart(fd, url, r, &http->out.size, &http->al.http.code);
 	return;
     } else if (r->method == METHOD_PURGE) {
-	clientPurgeRequest(http);
+	clientStartPurgeRequest(http);
 	return;
     } else if (r->method == METHOD_TRACE) {
 	if (r->max_forwards == 0) {
-	    http->entry = clientCreateStoreEntry(http, r->method, null_request_flags);
+	    http->entry = clientCreateStoreEntry(http, r->method,
+              null_request_flags, REPLY_OBJ_INTERNAL);
 	    storeReleaseRequest(http->entry);
 	    storeBuffer(http->entry);
 	    rep = httpReplyCreate();
@@ -2210,25 +1884,44 @@
 	/* yes, continue */
 	http->log_type = LOG_TCP_MISS;
     } else {
-	http->log_type = clientProcessRequest2(http);
+        /* We need to initiate a lookup, so defer completing the request */
+        debug(33, 3) ("clientProcessRequest: looking up %s\n", http->uri);
+        storeDoubleCheckRequest(r, http->uri, r->method);
+        storeLookup(r, clientLookupDone, http);
+        return;
     }
-    debug(33, 4) ("clientProcessRequest: %s for '%s'\n",
+    /* Continue processing */
+    clientProcessRequestDone(http);
+}
+
+
+/*
+ * clientProcessRequestDone - the completion of the request chain
+ *
+ * Either start getting data from a cached object, or punt across
+ * to clientProcessMiss().
+ */
+static void
+clientProcessRequestDone(clientHttpRequest *http)
+{
+    debug(33, 4) ("clientProcessRequestDone: %s for '%s'\n",
 	log_tags[http->log_type],
 	http->uri);
     http->out.offset = 0;
     if (NULL != http->entry) {
 	storeLockObject(http->entry);
 	storeCreateMemObject(http->entry, http->uri, http->log_uri);
-	http->entry->mem_obj->method = r->method;
-	http->sc = storeClientListAdd(http->entry, http);
+	http->entry->mem_obj->method = http->request->method;
+	storeClientRegister(http->entry, http);
 #if DELAY_POOLS
-	delaySetStoreClient(http->sc, delayClient(r));
+	delaySetStoreClient(http->sc, delayClient(http->request));
 #endif
-	storeClientCopy(http->sc, http->entry,
+        http->bufofs = 0;
+	storeClientCopy(http->entry,
 	    http->out.offset,
 	    http->out.offset,
 	    CLIENT_SOCK_SZ,
-	    memAllocate(MEM_CLIENT_SOCK_BUF),
+	    http->buf,
 	    clientCacheHit,
 	    http);
     } else {
@@ -2258,8 +1951,7 @@
 	    debug(33, 0) ("\tlog_type = %s\n", log_tags[http->log_type]);
 	    storeEntryDump(http->entry, 1);
 	}
-	storeUnregister(http->sc, http->entry, http);
-	http->sc = NULL;
+	storeClientUnregister(http->entry, http);
 	storeUnlockObject(http->entry);
 	http->entry = NULL;
     }
@@ -2275,12 +1967,14 @@
 	err = errorCon(ERR_ACCESS_DENIED, HTTP_FORBIDDEN);
 	err->request = requestLink(r);
 	err->src_addr = http->conn->peer.sin_addr;
-	http->entry = clientCreateStoreEntry(http, r->method, null_request_flags);
+	http->entry = clientCreateStoreEntry(http, r->method,
+          null_request_flags, REPLY_OBJ_INTERNAL);
 	errorAppendEntry(http->entry, err);
 	return;
     }
     assert(http->out.offset == 0);
-    http->entry = clientCreateStoreEntry(http, r->method, r->flags);
+    http->entry = clientCreateStoreEntry(http, r->method, r->flags,
+      REPLY_OBJ_NETWORK);
     if (http->redirect.status) {
 	HttpReply *rep = httpReplyCreate();
 #if LOG_TCP_REDIRECTS
@@ -2302,6 +1996,7 @@
 parseHttpRequestAbort(ConnStateData * conn, const char *uri)
 {
     clientHttpRequest *http;
+    CBDATA_INIT_TYPE_FREECB(clientHttpRequest, httpMemFree);
     http = cbdataAlloc(clientHttpRequest);
     http->conn = conn;
     http->start = current_time;
@@ -2309,6 +2004,7 @@
     http->uri = xstrdup(uri);
     http->log_uri = xstrndup(uri, MAX_URL);
     http->range_iter.boundary = StringNull;
+    http->buf = memAllocate(MEM_CLIENT_SOCK_BUF);
     dlinkAdd(http, &http->active, &ClientActiveRequests);
     return http;
 }
@@ -2441,12 +2137,14 @@
     assert(prefix_sz <= conn->in.offset);
 
     /* Ok, all headers are received */
+    CBDATA_INIT_TYPE_FREECB(clientHttpRequest, httpMemFree);
     http = cbdataAlloc(clientHttpRequest);
     http->http_ver = http_ver;
     http->conn = conn;
     http->start = current_time;
     http->req_sz = prefix_sz;
     http->range_iter.boundary = StringNull;
+    http->buf = memAllocate(MEM_CLIENT_SOCK_BUF);
     *prefix_p = xmalloc(prefix_sz + 1);
     xmemcpy(*prefix_p, conn->in.buf, prefix_sz);
     *(*prefix_p + prefix_sz) = '\0';
@@ -2719,7 +2417,8 @@
 		debug(33, 1) ("clientReadRequest: FD %d Invalid Request\n", fd);
 		err = errorCon(ERR_INVALID_REQ, HTTP_BAD_REQUEST);
 		err->request_hdrs = xstrdup(conn->in.buf);
-		http->entry = clientCreateStoreEntry(http, method, null_request_flags);
+		http->entry = clientCreateStoreEntry(http, method,
+                  null_request_flags, REPLY_OBJ_INTERNAL);
 		errorAppendEntry(http->entry, err);
 		safe_free(prefix);
 		break;
@@ -2730,7 +2429,8 @@
 		err->src_addr = conn->peer.sin_addr;
 		err->url = xstrdup(http->uri);
 		http->al.http.code = err->http_status;
-		http->entry = clientCreateStoreEntry(http, method, null_request_flags);
+		http->entry = clientCreateStoreEntry(http, method,
+                  null_request_flags, REPLY_OBJ_INTERNAL);
 		errorAppendEntry(http->entry, err);
 		safe_free(prefix);
 		break;
@@ -2774,7 +2474,8 @@
 		err->request = requestLink(request);
 		request->flags.proxy_keepalive = 0;
 		http->al.http.code = err->http_status;
-		http->entry = clientCreateStoreEntry(http, request->method, null_request_flags);
+		http->entry = clientCreateStoreEntry(http, request->method,
+                  null_request_flags, REPLY_OBJ_INTERNAL);
 		errorAppendEntry(http->entry, err);
 		break;
 	    }
@@ -2783,7 +2484,8 @@
 		err->src_addr = conn->peer.sin_addr;
 		err->request = requestLink(request);
 		http->al.http.code = err->http_status;
-		http->entry = clientCreateStoreEntry(http, request->method, null_request_flags);
+		http->entry = clientCreateStoreEntry(http, request->method,
+                  null_request_flags, REPLY_OBJ_INTERNAL);
 		errorAppendEntry(http->entry, err);
 		break;
 	    }
@@ -2798,7 +2500,7 @@
 		    err = errorCon(ERR_TOO_BIG, HTTP_REQUEST_ENTITY_TOO_LARGE);
 		    err->request = requestLink(request);
 		    http->entry = clientCreateStoreEntry(http,
-			METHOD_NONE, null_request_flags);
+			METHOD_NONE, null_request_flags, REPLY_OBJ_INTERNAL);
 		    errorAppendEntry(http->entry, err);
 		    break;
 		}
@@ -2823,7 +2525,8 @@
 		    /* add to the client request queue */
 		    for (H = &conn->chr; *H; H = &(*H)->next);
 		    *H = http;
-		    http->entry = clientCreateStoreEntry(http, METHOD_NONE, null_request_flags);
+		    http->entry = clientCreateStoreEntry(http, METHOD_NONE,
+                      null_request_flags, REPLY_OBJ_INTERNAL);
 		    errorAppendEntry(http->entry, err);
 		    return;
 		}
Index: squid/src/enums.h
diff -u squid/src/enums.h:1.17 squid/src/enums.h:1.2.2.13
--- squid/src/enums.h:1.17	Sat Mar  3 02:44:32 2001
+++ squid/src/enums.h	Sun Mar 18 14:51:21 2001
@@ -487,7 +487,6 @@
     KEY_PRIVATE,
     ENTRY_FWD_HDR_WAIT,
     ENTRY_NEGCACHED,
-    ENTRY_VALIDATED,
     ENTRY_BAD_LENGTH,
     ENTRY_ABORTED
 #if UNUSED_CODE
@@ -634,7 +633,6 @@
     MEM_PS_STATE,
     MEM_REFRESH_T,
     MEM_RELIST,
-    MEM_REQUEST_T,
     MEM_SQUIDCONFIG,
     MEM_SQUIDCONFIG2,
     MEM_STATCOUNTERS,
@@ -726,6 +724,15 @@
 };
 
 /*
+ * reply object types
+ */
+typedef enum {
+    REPLY_OBJ_NONE,
+    REPLY_OBJ_INTERNAL,
+    REPLY_OBJ_NETWORK
+} reply_obj_t;
+
+/*
  * cbdata types. similar to the MEM_* types above, but managed
  * in cbdata.c. A big difference is that these types are dynamically
  * allocated. This list is only a list of predefined types. Other types
@@ -736,7 +743,6 @@
     CBDATA_UNDEF = 0,
     CBDATA_acl_access,
     CBDATA_aclCheck_t,
-    CBDATA_clientHttpRequest,
     CBDATA_ConnStateData,
     CBDATA_DigestFetchState,
     CBDATA_ErrorState,
Index: squid/src/errorpage.c
diff -u squid/src/errorpage.c:1.11 squid/src/errorpage.c:1.2.2.9
--- squid/src/errorpage.c:1.11	Sat Mar  3 02:44:32 2001
+++ squid/src/errorpage.c	Sun Mar 18 14:33:31 2001
@@ -262,7 +262,7 @@
     HttpReply *rep;
     MemObject *mem = entry->mem_obj;
     assert(mem != NULL);
-    assert(mem->inmem_hi == 0);
+    assert(storeMemHiOffset(entry) == 0);
     if (entry->store_status != STORE_PENDING) {
 	/*
 	 * If the entry is not STORE_PENDING, then no clients
@@ -270,7 +270,7 @@
 	 * error message
 	 */
 	assert(EBIT_TEST(entry->flags, ENTRY_ABORTED));
-	assert(mem->nclients == 0);
+	assert(storePendingNClients(entry) == 0);
 	errorStateFree(err);
 	return;
     }
Index: squid/src/forward.c
diff -u squid/src/forward.c:1.10 squid/src/forward.c:1.2.2.7
--- squid/src/forward.c:1.10	Sat Mar  3 02:44:32 2001
+++ squid/src/forward.c	Sun Mar 18 14:33:31 2001
@@ -92,7 +92,7 @@
     fwdLog(fwdState);
 #endif
     if (e->store_status == STORE_PENDING) {
-	if (e->mem_obj->inmem_hi == 0) {
+	if (storeMemHiOffset(e) == 0) {
 	    assert(fwdState->err);
 	    errorAppendEntry(e, fwdState->err);
 	    fwdState->err = NULL;
@@ -130,7 +130,7 @@
 {
     if (fwdState->entry->store_status != STORE_PENDING)
 	return 0;
-    if (fwdState->entry->mem_obj->inmem_hi > 0)
+    if (storeMemHiOffset(fwdState->entry) > 0)
 	return 0;
     if (fwdState->n_tries > 10)
 	return 0;
@@ -249,7 +249,7 @@
     peer *p = fwdStateServerPeer(fwdState);
     debug(17, 2) ("fwdConnectTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
     assert(fd == fwdState->server_fd);
-    if (entry->mem_obj->inmem_hi == 0) {
+    if (storeMemHiOffset(entry) == 0) {
 	err = errorCon(ERR_CONNECT_FAIL, HTTP_GATEWAY_TIMEOUT);
 	err->request = requestLink(fwdState->request);
 	err->xerrno = ETIMEDOUT;
@@ -585,7 +585,7 @@
 #endif
     if (EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT))
 	return rc;
-    if (mem->inmem_hi - storeLowestMemReaderOffset(e) < READ_AHEAD_GAP)
+    if (storeMemHiOffset(e) - storeLowestMemReaderOffset(e) < READ_AHEAD_GAP)
 	return rc;
     return 1;
 }
Index: squid/src/ftp.c
diff -u squid/src/ftp.c:1.12 squid/src/ftp.c:1.2.2.8
--- squid/src/ftp.c:1.12	Sat Mar  3 02:44:32 2001
+++ squid/src/ftp.c	Sun Mar 18 14:33:31 2001
@@ -925,11 +925,11 @@
 	    storeAppend(entry, ftpState->data.buf, len);
 	    ftpState->data.offset = 0;
 	}
-	commSetSelect(fd,
-	    COMM_SELECT_READ,
-	    ftpDataRead,
-	    data,
-	    Config.Timeout.read);
+        commSetSelect(fd,
+             COMM_SELECT_READ,
+             ftpDataRead,
+             data,
+             Config.Timeout.read);
     }
 }
 
@@ -1045,7 +1045,6 @@
     const char *url = storeUrl(entry);
     FtpStateData *ftpState;
     HttpReply *reply;
-
     CBDATA_INIT_TYPE(FtpStateData);
     ftpState = cbdataAlloc(FtpStateData);
     debug(9, 3) ("ftpStart: '%s'\n", url);
@@ -2002,6 +2001,11 @@
 static int
 ftpRestartable(FtpStateData * ftpState)
 {
+
+    /* With the advent of the range header in the request_range going away.. */
+    return 0;
+
+#if 0
     if (ftpState->restart_offset > 0)
 	return 1;
     if (!ftpState->request->range)
@@ -2015,6 +2019,7 @@
     if (ftpState->restart_offset <= 0)
 	return 0;
     return 1;
+#endif
 }
 
 static void
@@ -2364,7 +2369,7 @@
 ftpFailed(FtpStateData * ftpState, err_type error)
 {
     StoreEntry *entry = ftpState->entry;
-    if (entry->mem_obj->inmem_hi == 0)
+    if (storeMemHiOffset(entry) == 0)
 	ftpFailedErrorMessage(ftpState, error);
     if (ftpState->data.fd > -1) {
 	comm_close(ftpState->data.fd);
@@ -2480,7 +2485,7 @@
     if (ftpState->flags.http_header_sent)
 	return;
     ftpState->flags.http_header_sent = 1;
-    assert(e->mem_obj->inmem_hi == 0);
+    assert(storeMemHiOffset(e) == 0);
     EBIT_CLR(e->flags, ENTRY_FWD_HDR_WAIT);
     filename = (t = strRChr(urlpath, '/')) ? t + 1 : strBuf(urlpath);
     if (ftpState->flags.isdir) {
@@ -2523,7 +2528,7 @@
 	httpHeaderPutStr(&reply->header, HDR_CONTENT_ENCODING, mime_enc);
     httpReplySwapOut(reply, e);
     storeBufferFlush(e);
-    reply->hdr_sz = e->mem_obj->inmem_hi;
+    reply->hdr_sz = storeMemHiOffset(e);
     storeTimestampsSet(e);
     if (ftpState->flags.authenticated) {
 	/*
Index: squid/src/globals.h
diff -u squid/src/globals.h:1.7 squid/src/globals.h:1.2.2.5
--- squid/src/globals.h:1.7	Fri Jan 12 00:20:33 2001
+++ squid/src/globals.h	Fri Jan 12 00:46:07 2001
@@ -125,6 +125,7 @@
 extern double current_dtime;
 extern int store_hash_buckets;	/* 0 */
 extern hash_table *store_table;	/* NULL */
+extern dlink_list store_list; /* { NULL, NULL } */
 extern dlink_list ClientActiveRequests;
 extern const String StringNull;	/* { 0, 0, NULL } */
 extern const MemBuf MemBufNull;	/* MemBufNULL */
Index: squid/src/gopher.c
diff -u squid/src/gopher.c:1.8 squid/src/gopher.c:1.2.2.6
--- squid/src/gopher.c:1.8	Sat Mar  3 02:44:32 2001
+++ squid/src/gopher.c	Sun Mar 18 14:33:31 2001
@@ -577,7 +577,7 @@
     StoreEntry *entry = gopherState->entry;
     debug(10, 4) ("gopherTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
     if (entry->store_status == STORE_PENDING) {
-	if (entry->mem_obj->inmem_hi == 0) {
+	if (storeMemHiOffset(entry) == 0) {
 	    fwdFail(gopherState->fwdState,
 		errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 	}
@@ -633,7 +633,7 @@
 	debug(50, 1) ("gopherReadReply: error reading: %s\n", xstrerror());
 	if (ignoreErrno(errno)) {
 	    commSetSelect(fd, COMM_SELECT_READ, gopherReadReply, data, 0);
-	} else if (entry->mem_obj->inmem_hi == 0) {
+	} else if (storeMemHiOffset(entry) == 0) {
 	    ErrorState *err;
 	    err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 	    err->xerrno = errno;
@@ -643,7 +643,7 @@
 	} else {
 	    comm_close(fd);
 	}
-    } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
+    } else if (len == 0 && storeMemHiOffset(entry) == 0) {
 	ErrorState *err;
 	err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
 	err->xerrno = errno;
Index: squid/src/http.c
diff -u squid/src/http.c:1.12 squid/src/http.c:1.2.2.8
--- squid/src/http.c:1.12	Sat Mar  3 02:44:32 2001
+++ squid/src/http.c	Sun Mar 18 14:33:31 2001
@@ -93,7 +93,7 @@
     StoreEntry *entry = httpState->entry;
     debug(11, 4) ("httpTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
     if (entry->store_status == STORE_PENDING) {
-	if (entry->mem_obj->inmem_hi == 0) {
+	if (storeMemHiOffset(entry) == 0) {
 	    fwdFail(httpState->fwd,
 		errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 	}
@@ -229,6 +229,13 @@
      */
     if (httpHeaderHas(hdr, HDR_VARY))
 	return 0;
+
+    /* We also don't deal with range requests */
+    if (httpHeaderHas(hdr, HDR_RANGE))
+        return 0;
+    if (httpHeaderHas(hdr, HDR_REQUEST_RANGE))
+        return 0;
+
     /* Pragma: no-cache in _replies_ is not documented in HTTP,
      * but servers like "Active Imaging Webcast/2.0" sure do use it */
     if (httpHeaderHas(hdr, HDR_PRAGMA)) {
@@ -324,7 +331,7 @@
     HttpReply *reply = entry->mem_obj->reply;
     Ctx ctx;
     debug(11, 3) ("httpProcessReplyHeader: key '%s'\n",
-	storeKeyText(entry->hash.key));
+	storeKeyUrl(entry));
     if (httpState->reply_hdr == NULL)
 	httpState->reply_hdr = memAllocate(MEM_8K_BUF);
     assert(httpState->reply_hdr_state == 0);
@@ -405,8 +412,8 @@
 httpPconnTransferDone(HttpStateData * httpState)
 {
     /* return 1 if we got the last of the data on a persistent connection */
-    MemObject *mem = httpState->entry->mem_obj;
-    HttpReply *reply = mem->reply;
+    StoreEntry *entry = httpState->entry;
+    HttpReply *reply = entry->mem_obj->reply;
     int clen;
     debug(11, 3) ("httpPconnTransferDone: FD %d\n", httpState->fd);
     /*
@@ -442,7 +449,7 @@
     if (clen < 0)
 	return 0;
     /* If the body size is known, we must wait until we've gotten all of it.  */
-    if (mem->inmem_hi < reply->content_length + reply->hdr_sz)
+    if (storeMemHiOffset(entry) < reply->content_length + reply->hdr_sz)
 	return 0;
     /* We got it all */
     return 1;
@@ -512,7 +519,7 @@
 	    fd, xstrerror());
 	if (ignoreErrno(errno)) {
 	    commSetSelect(fd, COMM_SELECT_READ, httpReadReply, httpState, 0);
-	} else if (entry->mem_obj->inmem_hi == 0) {
+	} else if (storeMemHiOffset(entry) == 0) {
 	    ErrorState *err;
 	    err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 	    err->xerrno = errno;
@@ -521,7 +528,7 @@
 	} else {
 	    comm_close(fd);
 	}
-    } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
+    } else if (len == 0 && storeMemHiOffset(entry) == 0) {
 	ErrorState *err;
 	err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
 	err->xerrno = errno;
@@ -647,7 +654,6 @@
     LOCAL_ARRAY(char, bbuf, BBUF_SZ);
     String strConnection = StringNull;
     const HttpHeader *hdr_in = &orig_request->header;
-    int we_do_ranges;
     const HttpHeaderEntry *e;
     String strVia;
     String strFwd;
@@ -657,26 +663,8 @@
     if (request->lastmod > -1 && request->method == METHOD_GET)
 	httpHeaderPutTime(hdr_out, HDR_IF_MODIFIED_SINCE, request->lastmod);
 
-    /* decide if we want to do Ranges ourselves 
-     * (and fetch the whole object now)
-     * We want to handle Ranges ourselves iff
-     *    - we can actually parse client Range specs
-     *    - the specs are expected to be simple enough (e.g. no out-of-order ranges)
-     *    - reply will be cachable
-     * (If the reply will be uncachable we have to throw it away after 
-     *  serving this request, so it is better to forward ranges to 
-     *  the server and fetch only the requested content) 
-     */
-    if (NULL == orig_request->range)
-	we_do_ranges = 0;
-    else if (!orig_request->flags.cachable)
-	we_do_ranges = 0;
-    else if (httpHdrRangeOffsetLimit(orig_request->range))
-	we_do_ranges = 0;
-    else
-	we_do_ranges = 1;
-    debug(11, 8) ("httpBuildRequestHeader: range specs: %p, cachable: %d; we_do_ranges: %d\n",
-	orig_request->range, orig_request->flags.cachable, we_do_ranges);
+    /* We are not doing ranges at all now - we're just passing them through */
+    debug(11, 8) ("httpBuildRequestHeader: cachable: %d\n", orig_request->flags.cachable);
 
     strConnection = httpHeaderGetList(hdr_in, HDR_CONNECTION);
     while ((e = httpHeaderGetEntry(hdr_in, &pos))) {
@@ -737,12 +725,6 @@
 		    httpHeaderPutInt(hdr_out, HDR_MAX_FORWARDS, hops - 1);
 	    }
 	    break;
-	case HDR_RANGE:
-	case HDR_IF_RANGE:
-	case HDR_REQUEST_RANGE:
-	    if (!we_do_ranges)
-		httpHeaderAddEntry(hdr_out, httpHeaderEntryClone(e));
-	    break;
 	case HDR_PROXY_CONNECTION:
 	case HDR_CONNECTION:
 	case HDR_VIA:
Index: squid/src/main.c
diff -u squid/src/main.c:1.19 squid/src/main.c:1.2.2.10
--- squid/src/main.c:1.19	Tue Jan 30 16:27:46 2001
+++ squid/src/main.c	Tue Feb  6 02:08:04 2001
@@ -479,6 +479,7 @@
 #else
     idnsInit();
 #endif
+    requestInit();
     redirectInit();
     authenticateInit(&Config.authConfig);
     useragentOpenLog();
@@ -501,6 +502,9 @@
 #if USE_UNLINKD
 	unlinkdInit();
 #endif
+        reply_internal_init();
+        reply_network_init();
+
 	urlInitialize();
 	cachemgrInit();
 	statInit();
Index: squid/src/mem.c
diff -u squid/src/mem.c:1.9 squid/src/mem.c:1.2.2.4
--- squid/src/mem.c:1.9	Sat Feb 17 12:56:22 2001
+++ squid/src/mem.c	Tue Feb 20 07:39:42 2001
@@ -275,8 +275,6 @@
     memDataInit(MEM_PS_STATE, "ps_state", sizeof(ps_state), 0);
     memDataInit(MEM_REFRESH_T, "refresh_t", sizeof(refresh_t), 0);
     memDataInit(MEM_RELIST, "relist", sizeof(relist), 0);
-    memDataInit(MEM_REQUEST_T, "request_t", sizeof(request_t),
-	Squid_MaxFD >> 3);
     memDataInit(MEM_SQUIDCONFIG, "SquidConfig", sizeof(SquidConfig), 0);
     memDataInit(MEM_SQUIDCONFIG2, "SquidConfig2", sizeof(SquidConfig2), 0);
     memDataInit(MEM_STATCOUNTERS, "StatCounters", sizeof(StatCounters), 0);
Index: squid/src/mime.c
diff -u squid/src/mime.c:1.8 squid/src/mime.c:1.2.2.9
--- squid/src/mime.c:1.8	Fri Jan 12 00:20:33 2001
+++ squid/src/mime.c	Wed Feb  7 05:54:38 2001
@@ -364,12 +364,18 @@
 	debug(25, 5) ("mimeInit: added '%s'\n", buf);
     }
     fclose(fp);
+
     /*
      * Create Icon StoreEntry's
      */
+
+    /* Remember, we're not doing icons in this fashion.. -- adrian */
+#if 0
     for (m = MimeTable; m != NULL; m = m->next)
 	mimeLoadIconFile(m->icon);
     debug(25, 1) ("Loaded Icons.\n");
+#endif
+    debug(25, 1) ("Not loading icons.\n");
 }
 
 void
@@ -391,62 +397,5 @@
 static void
 mimeLoadIconFile(const char *icon)
 {
-    int fd;
-    int n;
-    request_flags flags;
-    struct stat sb;
-    StoreEntry *e;
-    LOCAL_ARRAY(char, path, MAXPATHLEN);
-    LOCAL_ARRAY(char, url, MAX_URL);
-    char *buf;
-    const char *type = mimeGetContentType(icon);
-    HttpReply *reply;
-    http_version_t version;
-    if (type == NULL)
-	fatal("Unknown icon format while reading mime.conf\n");
-    buf = internalLocalUri("/squid-internal-static/icons/", icon);
-    xstrncpy(url, buf, MAX_URL);
-    if (storeGetPublic(url, METHOD_GET))
-	return;
-    snprintf(path, MAXPATHLEN, "%s/%s", Config.icons.directory, icon);
-    fd = file_open(path, O_RDONLY | O_BINARY);
-    if (fd < 0) {
-	debug(25, 0) ("mimeLoadIconFile: %s: %s\n", path, xstrerror());
-	return;
-    }
-    if (fstat(fd, &sb) < 0) {
-	debug(50, 0) ("mimeLoadIconFile: FD %d: fstat: %s\n", fd, xstrerror());
-	return;
-    }
-    flags = null_request_flags;
-    flags.cachable = 1;
-    e = storeCreateEntry(url,
-	url,
-	flags,
-	METHOD_GET);
-    assert(e != NULL);
-    storeSetPublicKey(e);
-    storeBuffer(e);
-    e->mem_obj->request = requestLink(urlParse(METHOD_GET, url));
-    httpReplyReset(reply = e->mem_obj->reply);
-    httpBuildVersion(&version, 1, 0);
-    httpReplySetHeaders(reply, version, HTTP_OK, NULL,
-	type, (int) sb.st_size, sb.st_mtime, -1);
-    reply->cache_control = httpHdrCcCreate();
-    httpHdrCcSetMaxAge(reply->cache_control, 86400);
-    httpHeaderPutCc(&reply->header, reply->cache_control);
-    httpReplySwapOut(reply, e);
-    reply->hdr_sz = e->mem_obj->inmem_hi;	/* yuk */
-    /* read the file into the buffer and append it to store */
-    buf = memAllocate(MEM_4K_BUF);
-    while ((n = read(fd, buf, 4096)) > 0)
-	storeAppend(e, buf, n);
-    file_close(fd);
-    EBIT_SET(e->flags, ENTRY_SPECIAL);
-    storeBufferFlush(e);
-    storeComplete(e);
-    storeTimestampsSet(e);
-    debug(25, 3) ("Loaded icon %s\n", url);
-    storeUnlockObject(e);
-    memFree(buf, MEM_4K_BUF);
+	fatal("I shouldn't get here yet!\n");
 }
Index: squid/src/neighbors.c
diff -u squid/src/neighbors.c:1.9 squid/src/neighbors.c:1.2.2.7
--- squid/src/neighbors.c:1.9	Sat Mar  3 02:44:32 2001
+++ squid/src/neighbors.c	Sun Mar 18 14:51:21 2001
@@ -1122,7 +1122,8 @@
     assert(p->type == PEER_MULTICAST);
     p->mcast.flags.count_event_pending = 0;
     snprintf(url, MAX_URL, "http://%s/", inet_ntoa(p->in_addr.sin_addr));
-    fake = storeCreateEntry(url, url, null_request_flags, METHOD_GET);
+    fake = storeCreateEntry(url, url, null_request_flags, METHOD_GET,
+      REPLY_OBJ_INTERNAL);
     psstate = cbdataAlloc(ps_state);
     psstate->request = requestLink(urlParse(METHOD_GET, url));
     psstate->entry = fake;
Index: squid/src/net_db.c
diff -u squid/src/net_db.c:1.10 squid/src/net_db.c:1.2.2.8
--- squid/src/net_db.c:1.10	Sat Mar  3 02:44:32 2001
+++ squid/src/net_db.c	Sun Mar 18 14:33:32 2001
@@ -627,8 +627,8 @@
 	debug(38, 3) ("netdbExchangeHandleReply: STORE_PENDING\n");
 	storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
 	    ex->buf, netdbExchangeHandleReply, ex);
-    } else if (ex->seen < ex->e->mem_obj->inmem_hi) {
-	debug(38, 3) ("netdbExchangeHandleReply: ex->e->mem_obj->inmem_hi\n");
+    } else if (ex->seen < storeMemHiOffset(ex->e)) {
+	debug(38, 3) ("netdbExchangeHandleReply: storeMemHiOffset(ex->e)\n");
 	storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
 	    ex->buf, netdbExchangeHandleReply, ex);
     } else {
@@ -644,7 +644,7 @@
     debug(38, 3) ("netdbExchangeDone: %s\n", storeUrl(ex->e));
     memFree(ex->buf, MEM_4K_BUF);
     requestUnlink(ex->r);
-    storeUnregister(ex->sc, ex->e, ex);
+    storeClientUnregister(ex->sc, ex->e, ex);
     storeUnlockObject(ex->e);
     cbdataUnlock(ex->p);
     cbdataFree(ex);
@@ -1005,11 +1005,12 @@
     requestLink(ex->r);
     assert(NULL != ex->r);
     httpBuildVersion(&ex->r->http_ver, 1, 0);
-    ex->e = storeCreateEntry(uri, uri, null_request_flags, METHOD_GET);
+    ex->e = storeCreateEntry(uri, uri, null_request_flags, METHOD_GET,
+      REPLY_OBJ_INTERNAL);
     ex->buf_sz = 4096;
     ex->buf = memAllocate(MEM_4K_BUF);
     assert(NULL != ex->e);
-    ex->sc = storeClientListAdd(ex->e, ex);
+    ex->sc = storeClientRegister(ex->e, ex);
     storeClientCopy(ex->sc, ex->e, ex->seen, ex->used, ex->buf_sz,
 	ex->buf, netdbExchangeHandleReply, ex);
     ex->r->flags.loopdetect = 1;	/* cheat! -- force direct */
Index: squid/src/peer_digest.c
diff -u squid/src/peer_digest.c:1.7 squid/src/peer_digest.c:1.2.2.8
--- squid/src/peer_digest.c:1.7	Sat Mar  3 02:44:32 2001
+++ squid/src/peer_digest.c	Sun Mar 18 14:33:32 2001
@@ -269,7 +269,6 @@
     peer *p = pd->peer;
     StoreEntry *e, *old_e;
     char *url;
-    const cache_key *key;
     request_t *req;
     DigestFetchState *fetch = NULL;
 
@@ -283,8 +282,7 @@
 	url = internalRemoteUri(p->host, p->http_port,
 	    "/squid-internal-periodic/", StoreDigestFileName);
 
-    key = storeKeyPublic(url, METHOD_GET);
-    debug(72, 2) ("peerDigestRequest: %s key: %s\n", url, storeKeyText(key));
+    debug(72, 2) ("peerDigestRequest: %s\n", url);
     req = urlParse(METHOD_GET, url);
     assert(req);
 
@@ -308,16 +306,17 @@
     req->flags.cachable = 1;
     /* the rest is based on clientProcessExpired() */
     req->flags.refresh = 1;
-    old_e = fetch->old_entry = storeGet(key);
+    old_e = fetch->old_entry = storeGetPublic(url, METHOD_GET);
     if (old_e) {
 	debug(72, 5) ("peerDigestRequest: found old entry\n");
 	storeLockObject(old_e);
 	storeCreateMemObject(old_e, url, url);
-	fetch->old_sc = storeClientListAdd(old_e, fetch);
+	fetch->old_sc = storeClientRegister(old_e, fetch);
     }
-    e = fetch->entry = storeCreateEntry(url, url, req->flags, req->method);
+    e = fetch->entry = storeCreateEntry(url, url, req->flags, req->method,
+      REPLY_OBJ_NETWORK);
     assert(EBIT_TEST(e->flags, KEY_PRIVATE));
-    fetch->sc = storeClientListAdd(e, fetch);
+    fetch->sc = storeClientRegister(e, fetch);
     /* set lastmod to trigger IMS request if possible */
     if (old_e)
 	e->lastmod = old_e->lastmod;
@@ -366,7 +365,7 @@
 	    httpReplyUpdateOnNotModified(fetch->old_entry->mem_obj->reply, reply);
 	    storeTimestampsSet(fetch->old_entry);
 	    /* get rid of 304 reply */
-	    storeUnregister(fetch->sc, fetch->entry, fetch);
+	    storeClientUnregister(fetch->sc, fetch->entry, fetch);
 	    storeUnlockObject(fetch->entry);
 	    fetch->entry = fetch->old_entry;
 	    fetch->old_entry = NULL;
@@ -377,7 +376,7 @@
 	    /* get rid of old entry if any */
 	    if (fetch->old_entry) {
 		debug(72, 3) ("peerDigestFetchReply: got new digest, releasing old one\n");
-		storeUnregister(fetch->old_sc, fetch->old_entry, fetch);
+		storeClientUnregister(fetch->old_sc, fetch->old_entry, fetch);
 		storeReleaseRequest(fetch->old_entry);
 		storeUnlockObject(fetch->old_entry);
 		fetch->old_entry = NULL;
@@ -685,7 +684,7 @@
 
     if (fetch->old_entry) {
 	debug(72, 2) ("peerDigestFetchFinish: deleting old entry\n");
-	storeUnregister(fetch->sc, fetch->old_entry, fetch);
+	storeClientUnregister(fetch->sc, fetch->old_entry, fetch);
 	storeReleaseRequest(fetch->old_entry);
 	storeUnlockObject(fetch->old_entry);
 	fetch->old_entry = NULL;
@@ -697,7 +696,7 @@
     statCounter.cd.msgs_recv += fetch->recv.msg;
 
     /* unlock everything */
-    storeUnregister(fetch->sc, fetch->entry, fetch);
+    storeClientUnregister(fetch->sc, fetch->entry, fetch);
     storeUnlockObject(fetch->entry);
     requestUnlink(fetch->request);
     fetch->entry = NULL;
@@ -721,7 +720,7 @@
     /* XXX: we must distinguish between 304 hits and misses here */
     fetch->sent.bytes = httpRequestPrefixLen(fetch->request);
     fetch->recv.bytes = fetch->entry->store_status == STORE_PENDING ?
-	mem->inmem_hi : mem->object_sz;
+	storeMemHiOffset(fetch->entry) : mem->object_sz;
     fetch->sent.msg = fetch->recv.msg = 1;
     fetch->expires = fetch->entry->expires;
     fetch->resp_time = squid_curtime - fetch->start_time;
Index: squid/src/protos.h
diff -u squid/src/protos.h:1.20 squid/src/protos.h:1.2.2.19
--- squid/src/protos.h:1.20	Sat Mar  3 02:44:32 2001
+++ squid/src/protos.h	Sun Mar 18 14:33:32 2001
@@ -127,11 +127,12 @@
 extern void clientAccessCheckDone(int, void *);
 extern int modifiedSince(StoreEntry *, request_t *);
 extern char *clientConstructTraceEcho(clientHttpRequest *);
-extern void clientPurgeRequest(clientHttpRequest *);
+extern void clientStartPurgeRequest(clientHttpRequest *);
 extern int checkNegativeHit(StoreEntry *);
 extern void clientHttpConnectionsOpen(void);
 extern void clientHttpConnectionsClose(void);
-extern StoreEntry *clientCreateStoreEntry(clientHttpRequest *, method_t, request_flags);
+extern StoreEntry *clientCreateStoreEntry(clientHttpRequest *, method_t,
+  request_flags, reply_obj_t);
 extern int isTcpHit(log_type);
 extern void clientReadBody(request_t * req, char *buf, size_t size, CBCB * callback, void *data);
 extern int clientAbortBody(request_t * req);
@@ -493,6 +494,7 @@
 extern int httpReplyBodySize(method_t, HttpReply *);
 
 /* Http Request */
+extern void requestInit(void);
 extern request_t *requestCreate(method_t, protocol_t, const char *urlpath);
 extern void requestDestroy(request_t *);
 extern request_t *requestLink(request_t *);
@@ -866,7 +868,8 @@
 extern StoreEntry *new_StoreEntry(int, const char *, const char *);
 extern StoreEntry *storeGet(const cache_key *);
 extern StoreEntry *storeGetPublic(const char *uri, const method_t method);
-extern StoreEntry *storeCreateEntry(const char *, const char *, request_flags, method_t);
+extern StoreEntry *storeCreateEntry(const char *, const char *, request_flags,
+  method_t, reply_obj_t);
 extern void storeSetPublicKey(StoreEntry *);
 extern void storeComplete(StoreEntry *);
 extern void storeInit(void);
@@ -893,6 +896,7 @@
 extern void storeMemObjectDump(MemObject * mem);
 extern void storeEntryDump(const StoreEntry * e, int debug_lvl);
 extern const char *storeUrl(const StoreEntry *);
+extern const char *storeKeyUrl(const StoreEntry *);
 extern void storeCreateMemObject(StoreEntry *, const char *, const char *);
 extern void storeCopyNotModifiedReplyHeaders(MemObject * O, MemObject * N);
 extern void storeBuffer(StoreEntry *);
@@ -918,6 +922,10 @@
 extern void storeFsDone(void);
 extern void storeFsAdd(char *, STSETUP *);
 extern void storeReplAdd(char *, REMOVALPOLICYCREATE *);
+extern off_t storeMemHiOffset(const StoreEntry *); 
+extern off_t storeMemLoOffset(const StoreEntry *);
+extern void storeDetachReply(StoreEntry *);
+extern void storeDoubleCheckRequest(request_t *, char *, method_t);
 
 /* store_modules.c */
 extern void storeFsSetup(void);
@@ -926,6 +934,9 @@
 extern void storeReplSetup(void);
 
 /* store_io.c */
+extern void storeLookup(request_t * , STGETDONE *, void *);
+extern void storeLookupComplete(request_t *, STGETDONE *, void *,
+   StoreEntry *);
 extern storeIOState *storeCreate(StoreEntry *, STFNCB *, STIOCB *, void *);
 extern storeIOState *storeOpen(StoreEntry *, STFNCB *, STIOCB *, void *);
 extern void storeClose(storeIOState *);
@@ -1029,10 +1040,10 @@
 #if STORE_CLIENT_LIST_DEBUG
 extern store_client *storeClientListSearch(const MemObject * mem, void *data);
 #endif
-extern store_client *storeClientListAdd(StoreEntry * e, void *data);
-extern void storeClientCopy(store_client *, StoreEntry *, off_t, off_t, size_t, char *, STCB *, void *);
-extern int storeClientCopyPending(store_client *, StoreEntry * e, void *data);
-extern int storeUnregister(store_client * sc, StoreEntry * e, void *data);
+extern void storeClientRegister(StoreEntry * e, void *data);
+extern void storeClientCopy(StoreEntry *, off_t, off_t, size_t, char *, STCB *, void *);
+extern int storeClientCopyPending(StoreEntry * e, void *data);
+extern int storeClientUnregister(StoreEntry * e, void *data);
 extern off_t storeLowestMemReaderOffset(const StoreEntry * entry);
 extern void InvokeHandlers(StoreEntry * e);
 extern int storePendingNClients(const StoreEntry * e);
@@ -1289,6 +1300,16 @@
 extern unsigned int url_checksum(const char *url);
 #endif
 
+
+/*
+ * reply objects
+ */
+extern void reply_internal_init(void);
+extern void reply_internal_create(StoreEntry *);
+
+extern void reply_network_init(void);
+extern void reply_network_create(StoreEntry *);
+
 /*
  * hack to allow snmp access to the statistics counters
  */
Index: squid/src/reply_internal.c
diff -u /dev/null squid/src/reply_internal.c:1.1.2.6
--- /dev/null	Sun Jan 25 06:36:42 2004
+++ squid/src/reply_internal.c	Wed Jan  3 04:11:33 2001
@@ -0,0 +1,290 @@
+/*
+ * reply_internal.c
+ *
+ * Handles "internal" replies, such as error pages, internal gifs, etc..
+ *
+ * Adrian Chadd <adrian@creative.net.au>
+ */
+
+
+#include "squid.h"
+
+struct _reply_internal_state {
+    mem_hdr data_hdr;
+    off_t inmem_hi;
+    off_t inmem_lo;
+};
+
+
+
+typedef struct _reply_internal_state reply_internal_state_t;
+
+MemPool *reply_internal_state_pool = NULL;
+
+/* Prototypes */
+static void reply_internal_clientcopy(StoreEntry * e);
+static void reply_internal_clientcopy3(StoreEntry * e);
+
+
+
+void
+reply_internal_init(void)
+{
+    reply_internal_state_pool = memPoolCreate("Internal reply pool",
+      sizeof(reply_internal_state_t));
+}
+
+
+/*
+ * reply_internal_done
+ */
+static void
+reply_internal_done(StoreEntry *e)
+{
+    reply_internal_state_t *state = e->stdata;
+
+    /* Make sure noone is left ! */
+
+    /* Kill the state struct */
+    stmemFree(&state->data_hdr);
+    memPoolFree(reply_internal_state_pool, state);
+
+    /* Done! */
+}
+
+
+/*
+ * reply_internal_memhi
+ */
+static off_t
+reply_internal_memhi(const StoreEntry *e)
+{
+    reply_internal_state_t *state = e->stdata;
+
+    return state->inmem_hi;
+}
+
+
+/*
+ * reply_internal_memlo
+ */
+static off_t
+reply_internal_memlo(const StoreEntry *e)
+{
+    reply_internal_state_t *state = e->stdata;
+
+    return state->inmem_lo;
+}
+
+
+/*
+ * reply_internal_append
+ */
+static void
+reply_internal_append(StoreEntry *e, const char *buf, int len)
+{
+    MemObject *mem = e->mem_obj;
+    reply_internal_state_t *state = e->stdata;
+    assert(mem != NULL);
+    assert(len >= 0);
+    assert(e->store_status == STORE_PENDING);
+    if (len) {
+        debug(20, 5) ("storeAppend: appending %d bytes for '%s'\n",
+            len,
+            storeKeyUrl(e));
+        /* Used to call storeGetMemSpace here .. */
+        /* storeGetMemSpace(len); */
+        stmemAppend(&state->data_hdr, buf, len);
+        state->inmem_hi += len;
+    }
+    if (EBIT_TEST(e->flags, DELAY_SENDING))
+        return;
+    e->stflush(e);
+}
+
+
+/*
+ * reply_internal_flush
+ */
+static void
+reply_internal_flush(StoreEntry *e)
+{
+    debug(20, 3) ("reply_internal_flush: %s\n", storeKeyUrl(e));
+    /* walk the entire list looking for valid callbacks */
+    if (e->sc.callback_data == NULL)
+        return;
+    if (e->sc.callback == NULL)
+        return;
+    if (e->sc.flags.disk_io_pending)
+        return;
+    reply_internal_clientcopy3(e);
+}
+
+
+/* store client copy evilness */
+
+static void
+reply_internal_clientcallback(store_client * sc, ssize_t sz)
+{
+    STCB *callback = sc->callback;
+    char *buf = sc->copy_buf;
+    assert(sc->callback);
+    sc->callback = NULL;
+    sc->copy_buf = NULL;
+    if (cbdataValid(sc->callback_data))
+	callback(sc->callback_data, buf, sz);
+}
+
+static void
+reply_internal_clientcopyevent(void *data)
+{
+    StoreEntry *e = data;
+    debug(20, 3) ("reply_internal_clientcopyevent: Running\n");
+    e->sc.flags.copy_event_pending = 0;
+    if (!e->sc.valid)
+	return;
+    reply_internal_clientcopy3(e);
+}
+
+
+/*
+ * This function is used below to decide if we have any more data to
+ * send to the client.  If the store_status is STORE_PENDING, then we
+ * do have more data to send.  If its STORE_OK, then
+ * we continue checking. 
+ * If the length is >= 0, then we compare it to the requested copy
+ * offset.
+ */
+static int
+reply_internal_clientnomoretosend(StoreEntry * e, store_client * sc)
+{
+    if (e->store_status == STORE_PENDING)
+	return 0;
+    assert(objectLen(e) > -1); /* Internal objects will never be swap backed */
+    if (sc->copy_offset < objectLen(e))
+	return 0;
+    return 1;
+}
+
+/* copy bytes requested by the client */
+static void
+reply_internal_clientcopy(StoreEntry * e)
+{
+    store_client *sc = &e->sc;
+    if (EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT)) {
+	debug(20, 5) ("reply_internal_clientcopy: returning because ENTRY_FWD_HDR_WAIT set\n");
+	return;
+    }
+    debug(20, 3) ("reply_internal_clientcopy: %s\n", storeKeyUrl(e));
+    assert(sc->callback != NULL);
+    /*
+     * We used to check for ENTRY_ABORTED here.  But there were some
+     * problems.  For example, we might have a slow client (or two) and
+     * the server-side is reading far ahead and swapping to disk.  Even
+     * if the server-side aborts, we want to give the client(s)
+     * everything we got before the abort condition occurred.
+     */
+    reply_internal_clientcopy3(e);
+}
+
+static void
+reply_internal_clientcopy3(StoreEntry * e)
+{
+    store_client *sc = &e->sc;
+    reply_internal_state_t *state = e->stdata;
+    size_t sz;
+
+    sc->flags.store_copying = 1;
+    if (reply_internal_clientnomoretosend(e, sc)) {
+	/* There is no more to send! */
+	reply_internal_clientcallback(sc, 0);
+        goto finish;
+    }
+    if ((e->store_status == STORE_PENDING) &&
+        (sc->copy_offset >= state->inmem_hi)) {
+	/* client has already seen this, wait for more */
+	debug(20, 3) ("reply_internal_clientcopy3: Waiting for more\n");
+        goto finish;
+    }
+
+    if ((sc->copy_offset >= state->inmem_lo) &&
+        (sc->copy_offset < state->inmem_hi)) {
+	/* What the client wants is in memory */
+	debug(20, 3) ("reply_internal_clientcopy3: Copying from memory\n");
+	sz = stmemCopy(&state->data_hdr,
+	    sc->copy_offset, sc->copy_buf, sc->copy_size);
+	reply_internal_clientcallback(sc, sz);
+        goto finish;
+    }
+    /* We shouldn't ever get here! */
+    assert(1 == 0);
+
+finish:
+    sc->flags.store_copying = 0;
+}
+
+
+/*
+ * reply_makepublic - make this object public
+ */
+static void
+reply_internal_makepublic(StoreEntry *e)
+{
+    /* Do nothing */
+}
+
+
+/*
+ * reply_makeprivate - make this object private
+ */
+static void
+reply_internal_makeprivate(StoreEntry *e)
+{
+    /* Do nothing */
+}
+
+
+/*
+ * reply_internal_release - object is being deleted
+ *
+ * Yes, its a no-op for us because all objects are private
+ */
+static void
+reply_internal_release(StoreEntry *e)
+{
+}
+
+
+/*
+ * reply_internal_create - create an internal reply ..
+ */
+void
+reply_internal_create(StoreEntry *e)
+{
+    reply_internal_state_t *state;
+    MemObject *mem;
+
+    assert(e != NULL);
+    assert(e->mem_obj != NULL);
+
+    mem = e->mem_obj;
+
+    /* Create a new state struct */
+    state = memPoolAlloc(reply_internal_state_pool);
+
+    /* Initialise it */
+    e->stdata = state;
+
+    /* Assign our functions .. */
+    e->stappend = reply_internal_append;
+    e->stflush = reply_internal_flush;
+    e->stmemhi = reply_internal_memhi; 
+    e->stmemlo = reply_internal_memlo; 
+    e->stclientcopy = reply_internal_clientcopy;
+    e->stmakeprivate = reply_internal_makeprivate;
+    e->stmakepublic = reply_internal_makepublic;
+    e->strelease = reply_internal_release;
+    e->stdone = reply_internal_done;
+    
+    /* Done! */
+}
Index: squid/src/reply_network.c
diff -u /dev/null squid/src/reply_network.c:1.1.2.2
--- /dev/null	Sun Jan 25 06:36:42 2004
+++ squid/src/reply_network.c	Sun Jan  7 15:22:47 2001
@@ -0,0 +1,296 @@
+/*
+ * reply_network.c
+ *
+ * Handles replies which have a network as a data server.
+ * This module handles limiting the amount of data which is requested
+ * from a server so as to not flood the client, and also writing incoming
+ * data to a backing object if needed.
+ *
+ * Adrian Chadd <adrian@creative.net.au>
+ */
+
+
+#include "squid.h"
+
+struct _reply_network_state {
+    mem_hdr data_hdr;
+    off_t inmem_hi;
+    off_t inmem_lo;
+};
+
+
+
+typedef struct _reply_network_state reply_network_state_t;
+
+MemPool *reply_network_state_pool = NULL;
+
+/* Prototypes */
+static void reply_network_clientcopy(StoreEntry * e);
+static void reply_network_clientcopy3(StoreEntry * e);
+
+
+
+void
+reply_network_init(void)
+{
+    reply_network_state_pool = memPoolCreate("Internal reply pool",
+      sizeof(reply_network_state_t));
+}
+
+
+/*
+ * reply_network_done
+ */
+static void
+reply_network_done(StoreEntry *e)
+{
+    reply_network_state_t *state = e->stdata;
+
+    /* Make sure noone is left ! */
+
+    /* Kill the state struct */
+    stmemFree(&state->data_hdr);
+    memPoolFree(reply_network_state_pool, state);
+
+    /* Done! */
+}
+
+
+/*
+ * reply_network_memhi
+ */
+static off_t
+reply_network_memhi(const StoreEntry *e)
+{
+    reply_network_state_t *state = e->stdata;
+
+    return state->inmem_hi;
+}
+
+
+/*
+ * reply_network_memlo
+ */
+static off_t
+reply_network_memlo(const StoreEntry *e)
+{
+    reply_network_state_t *state = e->stdata;
+
+    return state->inmem_lo;
+}
+
+
+/*
+ * reply_network_append
+ */
+static void
+reply_network_append(StoreEntry *e, const char *buf, int len)
+{
+    MemObject *mem = e->mem_obj;
+    reply_network_state_t *state = e->stdata;
+    assert(mem != NULL);
+    assert(len >= 0);
+    assert(e->store_status == STORE_PENDING);
+    if (len) {
+        debug(20, 5) ("storeAppend: appending %d bytes for '%s'\n",
+            len,
+            storeKeyUrl(e));
+        /* Used to call storeGetMemSpace here .. */
+        /* storeGetMemSpace(len); */
+        stmemAppend(&state->data_hdr, buf, len);
+        state->inmem_hi += len;
+    }
+    if (EBIT_TEST(e->flags, DELAY_SENDING))
+        return;
+    e->stflush(e);
+}
+
+
+/*
+ * reply_network_flush
+ */
+static void
+reply_network_flush(StoreEntry *e)
+{
+    debug(20, 3) ("reply_network_flush: %s\n", storeKeyUrl(e));
+    /* walk the entire list looking for valid callbacks */
+    if (e->sc.callback_data == NULL)
+        return;
+    if (e->sc.callback == NULL)
+        return;
+    if (e->sc.flags.disk_io_pending)
+        return;
+    reply_network_clientcopy3(e);
+}
+
+
+/* store client copy evilness */
+
+static void
+reply_network_clientcallback(store_client * sc, ssize_t sz)
+{
+    STCB *callback = sc->callback;
+    char *buf = sc->copy_buf;
+    assert(sc->callback);
+    sc->callback = NULL;
+    sc->copy_buf = NULL;
+    if (cbdataValid(sc->callback_data))
+	callback(sc->callback_data, buf, sz);
+}
+
+static void
+reply_network_clientcopyevent(void *data)
+{
+    StoreEntry *e = data;
+    debug(20, 3) ("reply_network_clientcopyevent: Running\n");
+    e->sc.flags.copy_event_pending = 0;
+    if (!e->sc.valid)
+	return;
+    reply_network_clientcopy3(e);
+}
+
+
+/*
+ * This function is used below to decide if we have any more data to
+ * send to the client.  If the store_status is STORE_PENDING, then we
+ * do have more data to send.  If its STORE_OK, then
+ * we continue checking. 
+ * If the length is >= 0, then we compare it to the requested copy
+ * offset.
+ */
+static int
+reply_network_clientnomoretosend(StoreEntry * e, store_client * sc)
+{
+    if (e->store_status == STORE_PENDING)
+	return 0;
+    assert(objectLen(e) > -1); /* Internal objects will never be swap backed */
+    if (sc->copy_offset < objectLen(e))
+	return 0;
+    return 1;
+}
+
+/* copy bytes requested by the client */
+static void
+reply_network_clientcopy(StoreEntry * e)
+{
+    store_client *sc = &e->sc;
+    if (EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT)) {
+	debug(20, 5) ("reply_network_clientcopy: returning because ENTRY_FWD_HDR_WAIT set\n");
+	return;
+    }
+    debug(20, 3) ("reply_network_clientcopy: %s\n", storeKeyUrl(e));
+    assert(sc->callback != NULL);
+    /*
+     * We used to check for ENTRY_ABORTED here.  But there were some
+     * problems.  For example, we might have a slow client (or two) and
+     * the server-side is reading far ahead and swapping to disk.  Even
+     * if the server-side aborts, we want to give the client(s)
+     * everything we got before the abort condition occurred.
+     */
+    reply_network_clientcopy3(e);
+}
+
+static void
+reply_network_clientcopy3(StoreEntry * e)
+{
+    store_client *sc = &e->sc;
+    reply_network_state_t *state = e->stdata;
+    size_t sz;
+
+    sc->flags.store_copying = 1;
+    if (reply_network_clientnomoretosend(e, sc)) {
+	/* There is no more to send! */
+	reply_network_clientcallback(sc, 0);
+        goto finish;
+    }
+    if ((e->store_status == STORE_PENDING) &&
+        (sc->copy_offset >= state->inmem_hi)) {
+	/* client has already seen this, wait for more */
+	debug(20, 3) ("reply_network_clientcopy3: Waiting for more\n");
+        goto finish;
+    }
+
+    if ((sc->copy_offset >= state->inmem_lo) &&
+        (sc->copy_offset < state->inmem_hi)) {
+	/* What the client wants is in memory */
+	debug(20, 3) ("reply_network_clientcopy3: Copying from memory\n");
+	sz = stmemCopy(&state->data_hdr,
+	    sc->copy_offset, sc->copy_buf, sc->copy_size);
+        state->inmem_lo = sc->copy_offset + sz;
+        assert(state->inmem_lo <= state->inmem_hi);
+        stmemFreeDataUpto(&state->data_hdr, state->inmem_lo - 1); 
+	reply_network_clientcallback(sc, sz);
+        goto finish;
+    }
+    /* We shouldn't ever get here! */
+    assert(1 == 0);
+
+finish:
+    sc->flags.store_copying = 0;
+}
+
+
+/*
+ * reply_makepublic - make this object public
+ */
+static void
+reply_network_makepublic(StoreEntry *e)
+{
+    /* Do nothing */
+}
+
+
+/*
+ * reply_makeprivate - make this object private
+ */
+static void
+reply_network_makeprivate(StoreEntry *e)
+{
+    /* Do nothing */
+}
+
+
+/*
+ * reply_network_release - object is being deleted
+ *
+ * Yes, its a no-op for us because all objects are private
+ */
+static void
+reply_network_release(StoreEntry *e)
+{
+}
+
+
+/*
+ * reply_network_create - create an internal reply ..
+ */
+void
+reply_network_create(StoreEntry *e)
+{
+    reply_network_state_t *state;
+    MemObject *mem;
+
+    assert(e != NULL);
+    assert(e->mem_obj != NULL);
+
+    mem = e->mem_obj;
+
+    /* Create a new state struct */
+    state = memPoolAlloc(reply_network_state_pool);
+
+    /* Initialise it */
+    e->stdata = state;
+
+    /* Assign our functions .. */
+    e->stappend = reply_network_append;
+    e->stflush = reply_network_flush;
+    e->stmemhi = reply_network_memhi; 
+    e->stmemlo = reply_network_memlo; 
+    e->stclientcopy = reply_network_clientcopy;
+    e->stmakeprivate = reply_network_makeprivate;
+    e->stmakepublic = reply_network_makepublic;
+    e->strelease = reply_network_release;
+    e->stdone = reply_network_done;
+    
+    /* Done! */
+}
Index: squid/src/stat.c
diff -u squid/src/stat.c:1.9 squid/src/stat.c:1.2.2.10
--- squid/src/stat.c:1.9	Sat Mar  3 02:44:32 2001
+++ squid/src/stat.c	Sun Mar 18 14:33:32 2001
@@ -40,9 +40,9 @@
 
 typedef int STOBJFLT(const StoreEntry *);
 typedef struct {
-    StoreEntry *sentry;
-    int bucket;
-    STOBJFLT *filter;
+    StoreEntry *sentry;		/* Where we're outputting to */
+    STOBJFLT *filter;		/* Filter function for output */
+    StoreEntry *cur_entry;	/* Current StoreEntry being checked .. */
 } StatObjectsState;
 
 /* LOCALS */
@@ -230,8 +230,6 @@
 	strcat(buf, "FWD_HDR_WAIT,");
     if (EBIT_TEST(flags, ENTRY_NEGCACHED))
 	strcat(buf, "NEGCACHED,");
-    if (EBIT_TEST(flags, ENTRY_VALIDATED))
-	strcat(buf, "VALIDATED,");
     if (EBIT_TEST(flags, ENTRY_BAD_LENGTH))
 	strcat(buf, "BAD_LENGTH,");
     if (EBIT_TEST(flags, ENTRY_ABORTED))
@@ -257,10 +255,8 @@
 statStoreEntry(StoreEntry * s, StoreEntry * e)
 {
     MemObject *mem = e->mem_obj;
-    int i;
     struct _store_client *sc;
-    dlink_node *node;
-    storeAppendPrintf(s, "KEY %s\n", storeKeyText(e->hash.key));
+    storeAppendPrintf(s, "KEY %s\n", storeKeyUrl(e));
     if (mem)
 	storeAppendPrintf(s, "\t%s %s\n",
 	    RequestMethodStr[mem->method], mem->log_url);
@@ -274,18 +270,12 @@
     storeAppendPrintf(s, "\tSwap Dir %d, File %#08X\n",
 	e->swap_dirn, e->swap_filen);
     if (mem != NULL) {
-	storeAppendPrintf(s, "\tinmem_lo: %d\n", (int) mem->inmem_lo);
-	storeAppendPrintf(s, "\tinmem_hi: %d\n", (int) mem->inmem_hi);
-	storeAppendPrintf(s, "\tswapout: %d bytes queued\n",
-	    (int) mem->swapout.queue_offset);
-	if (mem->swapout.sio)
-	    storeAppendPrintf(s, "\tswapout: %d bytes written\n",
-		(int) storeOffset(mem->swapout.sio));
-	for (i = 0, node = mem->clients.head; node; node = node->next, i++) {
-	    sc = (store_client *) node->data;
-	    if (sc->callback_data == NULL)
-		continue;
-	    storeAppendPrintf(s, "\tClient #%d, %p\n", i, sc->callback_data);
+	storeAppendPrintf(s, "\tInMem_LoOffset: %d\n", (int) storeMemLoOffset(e));
+	storeAppendPrintf(s, "\tInMem_HiOffset: %d\n", (int) storeMemHiOffset(e));
+
+        sc = &e->sc;
+        if (sc->valid) {
+	    storeAppendPrintf(s, "\tClient #%d, %p\n", 1, sc->callback_data);
 	    storeAppendPrintf(s, "\t\tcopy_offset: %d\n",
 		(int) sc->copy_offset);
 	    storeAppendPrintf(s, "\t\tseen_offset: %d\n",
@@ -305,20 +295,18 @@
     storeAppendPrintf(s, "\n");
 }
 
+#define MAX_NUMOBJECTS_TO_SCAN		1000
+
 /* process objects list */
 static void
 statObjects(void *data)
 {
     StatObjectsState *state = data;
     StoreEntry *e;
-    hash_link *link_ptr = NULL;
-    hash_link *link_next = NULL;
-    if (state->bucket >= store_hash_buckets) {
-	storeComplete(state->sentry);
-	storeUnlockObject(state->sentry);
-	cbdataFree(state);
-	return;
-    } else if (EBIT_TEST(state->sentry->flags, ENTRY_ABORTED)) {
+    int i;
+
+
+    if (EBIT_TEST(state->sentry->flags, ENTRY_ABORTED)) {
 	storeUnlockObject(state->sentry);
 	cbdataFree(state);
 	return;
@@ -326,17 +314,33 @@
 	eventAdd("statObjects", statObjects, state, 0.1, 1);
 	return;
     }
+
+    /* Don't return the data to the client immediately */
     storeBuffer(state->sentry);
-    debug(49, 3) ("statObjects: Bucket #%d\n", state->bucket);
-    link_next = hash_get_bucket(store_table, state->bucket);
-    while (NULL != (link_ptr = link_next)) {
-	link_next = link_ptr->next;
-	e = (StoreEntry *) link_ptr;
-	if (state->filter && 0 == state->filter(e))
-	    continue;
-	statStoreEntry(state->sentry, e);
+
+    for (i = 0; i < MAX_NUMOBJECTS_TO_SCAN; i++) {
+        /* Assume we were given a non-NULL object .. */
+        e = state->cur_entry;
+        assert(e != NULL);
+        if (state->filter) {
+            if (state->filter(e))
+                statStoreEntry(state->sentry, e);
+        } else
+            statStoreEntry(state->sentry, e);
+        storeUnlockObject(e);
+
+        /* Make sure we have a next object .. */
+        if (e->node.next == NULL) {
+            storeComplete(state->sentry);
+            storeUnlockObject(state->sentry);
+            cbdataFree(state);
+            return;
+        }
+        /* e becomes this if we get to the top of the loop again! */
+        state->cur_entry = (StoreEntry *) e->node.next->data;
+        storeLockObject(state->cur_entry);
     }
-    state->bucket++;
+
     eventAdd("statObjects", statObjects, state, 0.0, 1);
     storeBufferFlush(state->sentry);
 }
@@ -348,6 +352,9 @@
     state = cbdataAlloc(StatObjectsState);
     state->sentry = sentry;
     state->filter = filter;
+    state->cur_entry = (StoreEntry *) store_list.head->data;
+    /* This is so it doesn't get riped out from beneath us! */
+    storeLockObject(state->cur_entry);
     storeLockObject(sentry);
     eventAdd("statObjects", statObjects, state, 0.0, 1);
 }
@@ -376,8 +383,10 @@
 {
     if (e->mem_obj == NULL)
 	return 0;
+#if 0
     if (e->mem_obj->swapout.sio == NULL)
 	return 0;
+#endif
     return 1;
 }
 
Index: squid/src/store.c
diff -u squid/src/store.c:1.10 squid/src/store.c:1.2.2.21
--- squid/src/store.c:1.10	Thu Feb 22 21:51:08 2001
+++ squid/src/store.c	Sun Mar 18 14:33:32 2001
@@ -77,23 +77,20 @@
  * local function prototypes
  */
 static int storeEntryValidLength(const StoreEntry *);
+#if 0
 static void storeGetMemSpace(int);
-static void storeHashDelete(StoreEntry *);
+#endif
 static MemObject *new_MemObject(const char *, const char *);
 static void destroy_MemObject(StoreEntry *);
 static FREE destroy_StoreEntry;
+#if 0
 static void storePurgeMem(StoreEntry *);
-static void storeEntryReferenced(StoreEntry *);
-static void storeEntryDereferenced(StoreEntry *);
-static int getKeyCounter(void);
-static int storeKeepInMemory(const StoreEntry *);
+#endif
 static OBJH storeCheckCachableStats;
-static EVH storeLateRelease;
 
 /*
  * local variables
  */
-static Stack LateReleaseStack;
 
 #if URL_CHECKSUM_DEBUG
 unsigned int
@@ -132,8 +129,8 @@
 {
     StoreEntry *e = NULL;
     e = memAllocate(MEM_STOREENTRY);
-    if (mem_obj_flag)
-	e->mem_obj = new_MemObject(url, log_url);
+    /* We're always creating MemObjects now! */
+    e->mem_obj = new_MemObject(url, log_url);
     debug(20, 3) ("new_StoreEntry: returning %p\n", e);
     e->expires = e->lastmod = e->lastref = e->timestamp = -1;
     e->swap_filen = -1;
@@ -150,16 +147,15 @@
 #if URL_CHECKSUM_DEBUG
     assert(mem->chksum == url_checksum(mem->url));
 #endif
+    
+
     e->mem_obj = NULL;
-    if (!shutting_down)
-	assert(mem->swapout.sio == NULL);
-    stmemFree(&mem->data_hdr);
-    mem->inmem_hi = 0;
+
     /*
      * There is no way to abort FD-less clients, so they might
      * still have mem->clients set if mem->fd == -1
      */
-    assert(mem->fd == -1 || mem->clients.head == NULL);
+    assert(mem->fd == -1 || e->sc.valid == 0);
     httpReplyDestroy(mem->reply);
     requestUnlink(mem->request);
     mem->request = NULL;
@@ -175,102 +171,55 @@
     StoreEntry *e = data;
     debug(20, 3) ("destroy_StoreEntry: destroying %p\n", e);
     assert(e != NULL);
-    if (e->mem_obj)
-	destroy_MemObject(e);
-    storeHashDelete(e);
-    assert(e->hash.key == NULL);
-    memFree(e, MEM_STOREENTRY);
-}
+    assert(e->mem_obj != NULL);
 
-/* ----- INTERFACE BETWEEN STORAGE MANAGER AND HASH TABLE FUNCTIONS --------- */
+    dlinkDelete(&e->node, &store_list);
 
-void
-storeHashInsert(StoreEntry * e, const cache_key * key)
-{
-    debug(20, 3) ("storeHashInsert: Inserting Entry %p key '%s'\n",
-	e, storeKeyText(key));
-    e->hash.key = storeKeyDup(key);
-    hash_join(store_table, &e->hash);
-}
+    /* Free the reply .. */
+    storeDetachReply(e);
 
-static void
-storeHashDelete(StoreEntry * e)
-{
-    hash_remove_link(store_table, &e->hash);
-    storeKeyFree(e->hash.key);
-    e->hash.key = NULL;
+    /* Scrape it clean .. */
+    destroy_MemObject(e);
+
+    memFree(e, MEM_STOREENTRY);
 }
 
 /* -------------------------------------------------------------------------- */
 
 
+#if 0
 /* get rid of memory copy of the object */
 /* Only call this if storeCheckPurgeMem(e) returns 1 */
 static void
 storePurgeMem(StoreEntry * e)
 {
-    if (e->mem_obj == NULL)
-	return;
+    assert(e->mem_obj != NULL);
     debug(20, 3) ("storePurgeMem: Freeing memory-copy of %s\n",
-	storeKeyText(e->hash.key));
-    storeSetMemStatus(e, NOT_IN_MEMORY);
+	storeKeyUrl(e));
     destroy_MemObject(e);
     if (e->swap_status != SWAPOUT_DONE)
 	storeRelease(e);
 }
+#endif
 
-static void
-storeEntryReferenced(StoreEntry * e)
-{
-    SwapDir *SD;
-
-    /* Notify the fs that we're referencing this object again */
-    if (e->swap_dirn > -1) {
-	SD = INDEXSD(e->swap_dirn);
-	if (SD->refobj)
-	    SD->refobj(SD, e);
-    }
-    /* Notify the memory cache that we're referencing this object again */
-    if (e->mem_obj) {
-	if (mem_policy->Referenced)
-	    mem_policy->Referenced(mem_policy, e, &e->mem_obj->repl);
-    }
-}
-
-static void
-storeEntryDereferenced(StoreEntry * e)
-{
-    SwapDir *SD;
-
-    /* Notify the fs that we're not referencing this object any more */
-    if (e->swap_filen > -1) {
-	SD = INDEXSD(e->swap_dirn);
-	if (SD->unrefobj != NULL)
-	    SD->unrefobj(SD, e);
-    }
-    /* Notify the memory cache that we're not referencing this object any more */
-    if (e->mem_obj) {
-	if (mem_policy->Dereferenced)
-	    mem_policy->Dereferenced(mem_policy, e, &e->mem_obj->repl);
-    }
-}
 
 void
 storeLockObject(StoreEntry * e)
 {
+    assert(e->mem_obj != NULL);
     e->lock_count++;
     debug(20, 3) ("storeLockObject: key '%s' count=%d\n",
-	storeKeyText(e->hash.key), (int) e->lock_count);
+	storeKeyUrl(e), (int) e->lock_count);
     e->lastref = squid_curtime;
-    storeEntryReferenced(e);
 }
 
 void
 storeReleaseRequest(StoreEntry * e)
 {
+    assert(e->mem_obj != NULL);
     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
 	return;
-    debug(20, 3) ("storeReleaseRequest: '%s'\n", storeKeyText(e->hash.key));
+    debug(20, 3) ("storeReleaseRequest: '%s'\n", storeKeyUrl(e));
     EBIT_SET(e->flags, RELEASE_REQUEST);
     /*
      * Clear cachable flag here because we might get called before
@@ -278,6 +227,15 @@
      * prevents httpMakePublic from really setting a public key.
      */
     EBIT_CLR(e->flags, ENTRY_CACHABLE);
+    /*
+     * Notify the reply layer that we want this object released..
+     * XXX an evil hack - this can be called before the reply object
+     * is attached. If this happens, don't try to notify the reply
+     * object. When the reply object is created by createNewStoreEntry
+     * we'll be ok. -- adrian
+     */
+    if (e->strelease != NULL)
+        e->strelease(e);
     storeSetPrivateKey(e);
 }
 
@@ -286,28 +244,30 @@
 int
 storeUnlockObject(StoreEntry * e)
 {
+    assert(e->mem_obj != NULL);
     e->lock_count--;
     debug(20, 3) ("storeUnlockObject: key '%s' count=%d\n",
-	storeKeyText(e->hash.key), e->lock_count);
+	storeKeyUrl(e), e->lock_count);
     if (e->lock_count)
 	return (int) e->lock_count;
-    if (e->store_status == STORE_PENDING)
+
+    /* If the object is still pending data, we set RELEASE_REQUEST and wait */
+    if (e->store_status == STORE_PENDING) {
 	EBIT_SET(e->flags, RELEASE_REQUEST);
+        return 0;
+    }
+
+    /* The object is not pending data, so kill it .. */
     assert(storePendingNClients(e) == 0);
+    assert(e->store_status == STORE_OK);
+
+    /* Only release an object if we've been requested to.. */
     if (EBIT_TEST(e->flags, RELEASE_REQUEST))
-	storeRelease(e);
-    else if (storeKeepInMemory(e)) {
-	storeEntryDereferenced(e);
-	storeSetMemStatus(e, IN_MEMORY);
-	requestUnlink(e->mem_obj->request);
-	e->mem_obj->request = NULL;
-    } else {
-	storePurgeMem(e);
-	storeEntryDereferenced(e);
-	if (EBIT_TEST(e->flags, KEY_PRIVATE))
-	    debug(20, 1) ("WARNING: %s:%d: found KEY_PRIVATE\n", __FILE__, __LINE__);
-    }
-    return 0;
+        storeRelease(e);
+    else
+        destroy_StoreEntry(e);
+
+    return -1;
 }
 
 /* Lookup an object in the cache.
@@ -316,7 +276,12 @@
 storeGet(const cache_key * key)
 {
     debug(20, 3) ("storeGet: looking up %s\n", storeKeyText(key));
+    return NULL;
+
+    /* XXX we will perform a FS lookup here .. */
+#if 0
     return (StoreEntry *) hash_lookup(store_table, key);
+#endif
 }
 
 StoreEntry *
@@ -325,43 +290,23 @@
     return storeGet(storeKeyPublic(uri, method));
 }
 
-static int
-getKeyCounter(void)
-{
-    static int key_counter = 0;
-    if (++key_counter < 0)
-	key_counter = 1;
-    return key_counter;
-}
-
 void
 storeSetPrivateKey(StoreEntry * e)
 {
-    const cache_key *newkey;
-    MemObject *mem = e->mem_obj;
-    if (e->hash.key && EBIT_TEST(e->flags, KEY_PRIVATE))
+    if (EBIT_TEST(e->flags, KEY_PRIVATE))
 	return;			/* is already private */
-    if (e->hash.key) {
-	if (e->swap_filen > -1)
-	    storeDirSwapLog(e, SWAP_LOG_DEL);
-	storeHashDelete(e);
-    }
-    if (mem != NULL) {
-	mem->id = getKeyCounter();
-	newkey = storeKeyPrivate(mem->url, mem->method, mem->id);
-    } else {
-	newkey = storeKeyPrivate("JUNK", METHOD_NONE, getKeyCounter());
-    }
-    assert(hash_lookup(store_table, newkey) == NULL);
     EBIT_SET(e->flags, KEY_PRIVATE);
-    storeHashInsert(e, newkey);
+    /* XXX this lame check can go !!! -- adrian */
+    if (e->stmakeprivate)
+        e->stmakeprivate(e);
 }
 
 void
 storeSetPublicKey(StoreEntry * e)
 {
+#if 0
     StoreEntry *e2 = NULL;
-    const cache_key *newkey;
+#endif
     MemObject *mem = e->mem_obj;
     if (e->hash.key && !EBIT_TEST(e->flags, KEY_PRIVATE))
 	return;			/* is already public */
@@ -382,7 +327,12 @@
 	    e->hash.key, mem->url);
 #endif
     assert(!EBIT_TEST(e->flags, RELEASE_REQUEST));
-    newkey = storeKeyPublic(mem->url, mem->method);
+#if 0
+    /*
+     * We don't need this anymore, key collisions should be handled in
+     * the object store(s)
+     *   -- adrian
+     */
     if ((e2 = (StoreEntry *) hash_lookup(store_table, newkey))) {
 	debug(20, 3) ("storeSetPublicKey: Making old '%s' private.\n", mem->url);
 	storeSetPrivateKey(e2);
@@ -391,14 +341,18 @@
     }
     if (e->hash.key)
 	storeHashDelete(e);
+#endif
     EBIT_CLR(e->flags, KEY_PRIVATE);
-    storeHashInsert(e, newkey);
+    /* XXX this lame check can go !!! -- adrian */
+    if (e->stmakepublic)
+        e->stmakepublic(e);
     if (e->swap_filen > -1)
 	storeDirSwapLog(e, SWAP_LOG_ADD);
 }
 
 StoreEntry *
-storeCreateEntry(const char *url, const char *log_url, request_flags flags, method_t method)
+storeCreateEntry(const char *url, const char *log_url, request_flags flags,
+  method_t method, reply_obj_t reply_obj)
 {
     StoreEntry *e = NULL;
     MemObject *mem = NULL;
@@ -408,6 +362,20 @@
     e->lock_count = 1;		/* Note lock here w/o calling storeLock() */
     mem = e->mem_obj;
     mem->method = method;
+    dlinkAdd(e, &e->node, &store_list);
+
+    switch (reply_obj) {
+      case REPLY_OBJ_INTERNAL:
+        reply_internal_create(e);
+        break;
+      case REPLY_OBJ_NETWORK:
+        reply_network_create(e);
+        break;
+      default:
+        fatal("No valid reply_obj given to storeCreateEntry!\n");
+        /* NOTREACHED */
+    } 
+
     if (neighbors_do_private_keys || !flags.hierarchical)
 	storeSetPrivateKey(e);
     else
@@ -419,8 +387,8 @@
 	EBIT_CLR(e->flags, ENTRY_CACHABLE);
 	storeReleaseRequest(e);
     }
+
     e->store_status = STORE_PENDING;
-    storeSetMemStatus(e, NOT_IN_MEMORY);
     e->swap_status = SWAPOUT_NONE;
     e->swap_filen = -1;
     e->swap_dirn = -1;
@@ -428,7 +396,6 @@
     e->lastref = squid_curtime;
     e->timestamp = -1;		/* set in storeTimestampsSet() */
     e->ping_status = PING_NONE;
-    EBIT_SET(e->flags, ENTRY_VALIDATED);
     return e;
 }
 
@@ -436,7 +403,7 @@
 void
 storeExpireNow(StoreEntry * e)
 {
-    debug(20, 3) ("storeExpireNow: '%s'\n", storeKeyText(e->hash.key));
+    debug(20, 3) ("storeExpireNow: '%s'\n", storeKeyUrl(e));
     e->expires = squid_curtime;
 }
 
@@ -444,22 +411,7 @@
 void
 storeAppend(StoreEntry * e, const char *buf, int len)
 {
-    MemObject *mem = e->mem_obj;
-    assert(mem != NULL);
-    assert(len >= 0);
-    assert(e->store_status == STORE_PENDING);
-    if (len) {
-	debug(20, 5) ("storeAppend: appending %d bytes for '%s'\n",
-	    len,
-	    storeKeyText(e->hash.key));
-	storeGetMemSpace(len);
-	stmemAppend(&mem->data_hdr, buf, len);
-	mem->inmem_hi += len;
-    }
-    if (EBIT_TEST(e->flags, DELAY_SENDING))
-	return;
-    InvokeHandlers(e);
-    storeSwapOut(e);
+    e->stappend(e, buf, len);
 }
 
 void
@@ -562,7 +514,7 @@
 	return 0;		/* avoid release call below */
     } else if ((e->mem_obj->reply->content_length > 0 &&
 		e->mem_obj->reply->content_length > Config.Store.maxObjectSize) ||
-	e->mem_obj->inmem_hi > Config.Store.maxObjectSize) {
+	storeMemHiOffset(e) > Config.Store.maxObjectSize) {
 	debug(20, 2) ("storeCheckCachable: NO: too big\n");
 	store_check_cachable_hist.no.too_big++;
     } else if (e->mem_obj->reply->content_length > (int) Config.Store.maxObjectSize) {
@@ -629,17 +581,17 @@
 void
 storeComplete(StoreEntry * e)
 {
-    debug(20, 3) ("storeComplete: '%s'\n", storeKeyText(e->hash.key));
+    debug(20, 3) ("storeComplete: '%s'\n", storeKeyUrl(e));
     if (e->store_status != STORE_PENDING) {
 	/*
 	 * if we're not STORE_PENDING, then probably we got aborted
 	 * and there should be NO clients on this entry
 	 */
 	assert(EBIT_TEST(e->flags, ENTRY_ABORTED));
-	assert(e->mem_obj->nclients == 0);
+	assert(e->sc.valid == 0);
 	return;
     }
-    e->mem_obj->object_sz = e->mem_obj->inmem_hi;
+    e->mem_obj->object_sz = storeMemHiOffset(e);
     e->store_status = STORE_OK;
     assert(e->mem_status == NOT_IN_MEMORY);
     if (!storeEntryValidLength(e)) {
@@ -656,7 +608,6 @@
      * responses without content length would sometimes get released
      * in client_side, thinking that the response is incomplete.
      */
-    storeSwapOut(e);
     InvokeHandlers(e);
 }
 
@@ -671,18 +622,17 @@
     MemObject *mem = e->mem_obj;
     assert(e->store_status == STORE_PENDING);
     assert(mem != NULL);
-    debug(20, 6) ("storeAbort: %s\n", storeKeyText(e->hash.key));
+    debug(20, 6) ("storeAbort: %s\n", storeKeyUrl(e));
     storeLockObject(e);		/* lock while aborting */
     storeNegativeCache(e);
     storeReleaseRequest(e);
     EBIT_SET(e->flags, ENTRY_ABORTED);
-    storeSetMemStatus(e, NOT_IN_MEMORY);
     e->store_status = STORE_OK;
     /*
      * We assign an object length here.  The only other place we assign
      * the object length is in storeComplete()
      */
-    mem->object_sz = mem->inmem_hi;
+    mem->object_sz = storeMemHiOffset(e);
     /* Notify the server side */
     if (mem->abort.callback) {
 	eventAdd("mem->abort.callback",
@@ -696,10 +646,11 @@
     /* Notify the client side */
     InvokeHandlers(e);
     /* Close any swapout file */
-    storeSwapOutFileClose(e);
     storeUnlockObject(e);	/* unlock */
 }
 
+/* This function isn't used right now .. -- adrian */
+#if 0
 /* Clear Memory storage to accommodate the given object len */
 static void
 storeGetMemSpace(int size)
@@ -729,10 +680,8 @@
     debug(20, 3) ("  %6d HOT objects\n", hot_obj_count);
     debug(20, 3) ("  %6d were released\n", released);
 }
+#endif
 
-/* The maximum objects to scan for maintain storage space */
-#define MAINTAIN_MAX_SCAN	1024
-#define MAINTAIN_MAX_REMOVE	64
 
 /*
  * This routine is to be called by main loop in main.c.
@@ -774,7 +723,8 @@
 void
 storeRelease(StoreEntry * e)
 {
-    debug(20, 3) ("storeRelease: Releasing: '%s'\n", storeKeyText(e->hash.key));
+    debug(20, 3) ("storeRelease: Releasing: '%s'\n", storeKeyUrl(e));
+
     /* If, for any reason we can't discard this object because of an
      * outstanding request, mark it for pending release */
     if (storeEntryLocked(e)) {
@@ -783,81 +733,24 @@
 	storeReleaseRequest(e);
 	return;
     }
-    if (store_dirs_rebuilding && e->swap_filen > -1) {
-	storeSetPrivateKey(e);
-	if (e->mem_obj) {
-	    storeSetMemStatus(e, NOT_IN_MEMORY);
-	    destroy_MemObject(e);
-	}
-	if (e->swap_filen > -1) {
-	    /*
-	     * Fake a call to storeLockObject().  When rebuilding is done,
-	     * we'll just call storeUnlockObject() on these.
-	     */
-	    e->lock_count++;
-	    EBIT_SET(e->flags, RELEASE_REQUEST);
-	    stackPush(&LateReleaseStack, e);
-	    return;
-	} else {
-	    destroy_StoreEntry(e);
-	}
-    }
+
+    /* Notify the reply layer to release this object */
+    if (!EBIT_TEST(e->flags, RELEASE_REQUEST))
+        e->strelease(e);
+
+    /* Time to deallocate the storeentry .. */
     storeLog(STORE_LOG_RELEASE, e);
-    if (e->swap_filen > -1) {
-	storeUnlink(e);
-	if (e->swap_status == SWAPOUT_DONE)
-	    if (EBIT_TEST(e->flags, ENTRY_VALIDATED))
-		storeDirUpdateSwapSize(&Config.cacheSwap.swapDirs[e->swap_dirn], e->swap_file_sz, -1);
-	if (!EBIT_TEST(e->flags, KEY_PRIVATE))
-	    storeDirSwapLog(e, SWAP_LOG_DEL);
-#if 0
-	/* From 2.4. I think we do this in storeUnlink? */
-	storeSwapFileNumberSet(e, -1);
-#endif
-    }
-    storeSetMemStatus(e, NOT_IN_MEMORY);
+ 
+    /* Here we'd log a swap log delete, but thats done at the FS layer .. */
     destroy_StoreEntry(e);
 }
 
-static void
-storeLateRelease(void *unused)
-{
-    StoreEntry *e;
-    int i;
-    static int n = 0;
-    if (store_dirs_rebuilding) {
-	eventAdd("storeLateRelease", storeLateRelease, NULL, 1.0, 1);
-	return;
-    }
-    for (i = 0; i < 10; i++) {
-	e = stackPop(&LateReleaseStack);
-	if (e == NULL) {
-	    /* done! */
-	    debug(20, 1) ("storeLateRelease: released %d objects\n", n);
-	    return;
-	}
-	storeUnlockObject(e);
-	n++;
-    }
-    eventAdd("storeLateRelease", storeLateRelease, NULL, 0.0, 1);
-}
-
 /* return 1 if a store entry is locked */
 int
 storeEntryLocked(const StoreEntry * e)
 {
     if (e->lock_count)
 	return 1;
-    if (e->swap_status == SWAPOUT_WRITING)
-	return 1;
-    if (e->store_status == STORE_PENDING)
-	return 1;
-    /*
-     * SPECIAL, PUBLIC entries should be "locked"
-     */
-    if (EBIT_TEST(e->flags, ENTRY_SPECIAL))
-	if (!EBIT_TEST(e->flags, KEY_PRIVATE))
-	    return 1;
     return 0;
 }
 
@@ -868,7 +761,7 @@
     const HttpReply *reply;
     assert(e->mem_obj != NULL);
     reply = e->mem_obj->reply;
-    debug(20, 3) ("storeEntryValidLength: Checking '%s'\n", storeKeyText(e->hash.key));
+    debug(20, 3) ("storeEntryValidLength: Checking '%s'\n", storeKeyUrl(e));
     debug(20, 5) ("storeEntryValidLength:     object_len = %d\n",
 	objectLen(e));
     debug(20, 5) ("storeEntryValidLength:         hdr_sz = %d\n",
@@ -877,17 +770,17 @@
 	reply->content_length);
     if (reply->content_length < 0) {
 	debug(20, 5) ("storeEntryValidLength: Unspecified content length: %s\n",
-	    storeKeyText(e->hash.key));
+	    storeKeyUrl(e));
 	return 1;
     }
     if (reply->hdr_sz == 0) {
 	debug(20, 5) ("storeEntryValidLength: Zero header size: %s\n",
-	    storeKeyText(e->hash.key));
+	    storeKeyUrl(e));
 	return 1;
     }
     if (e->mem_obj->method == METHOD_HEAD) {
 	debug(20, 5) ("storeEntryValidLength: HEAD request: %s\n",
-	    storeKeyText(e->hash.key));
+	    storeKeyUrl(e));
 	return 1;
     }
     if (reply->sline.status == HTTP_NOT_MODIFIED)
@@ -900,7 +793,7 @@
     debug(20, 3) ("storeEntryValidLength: %d bytes too %s; '%s'\n",
 	diff < 0 ? -diff : diff,
 	diff < 0 ? "big" : "small",
-	storeKeyText(e->hash.key));
+	storeKeyUrl(e));
     return 0;
 }
 
@@ -925,15 +818,13 @@
 void
 storeInit(void)
 {
+    store_list.head = NULL;
+    store_list.tail = NULL;
     storeKeyInit();
     storeInitHashValues();
-    store_table = hash_create(storeKeyHashCmp,
-	store_hash_buckets, storeKeyHashHash);
     mem_policy = createRemovalPolicy(Config.memPolicy);
     storeDigestInit();
     storeLogOpen();
-    stackInit(&LateReleaseStack);
-    eventAdd("storeLateRelease", storeLateRelease, NULL, 1.0, 1);
     storeDirInit();
     storeRebuildStart();
     cachemgrRegister("storedir",
@@ -957,17 +848,6 @@
     store_pages_max = Config.memMaxSize / SM_PAGE_SIZE;
 }
 
-static int
-storeKeepInMemory(const StoreEntry * e)
-{
-    MemObject *mem = e->mem_obj;
-    if (mem == NULL)
-	return 0;
-    if (mem->data_hdr.head == NULL)
-	return 0;
-    return mem->inmem_lo == 0;
-}
-
 void
 storeNegativeCache(StoreEntry * e)
 {
@@ -978,8 +858,6 @@
 void
 storeFreeMemory(void)
 {
-    hashFreeItems(store_table, destroy_StoreEntry);
-    hashFreeMemory(store_table);
     store_table = NULL;
 #if USE_CACHE_DIGESTS
     if (store_digest)
@@ -1061,23 +939,9 @@
 void
 storeMemObjectDump(MemObject * mem)
 {
-    debug(20, 1) ("MemObject->data.head: %p\n",
-	mem->data_hdr.head);
-    debug(20, 1) ("MemObject->data.tail: %p\n",
-	mem->data_hdr.tail);
-    debug(20, 1) ("MemObject->data.origin_offset: %d\n",
-	mem->data_hdr.origin_offset);
     debug(20, 1) ("MemObject->start_ping: %d.%06d\n",
 	(int) mem->start_ping.tv_sec,
 	(int) mem->start_ping.tv_usec);
-    debug(20, 1) ("MemObject->inmem_hi: %d\n",
-	(int) mem->inmem_hi);
-    debug(20, 1) ("MemObject->inmem_lo: %d\n",
-	(int) mem->inmem_lo);
-    debug(20, 1) ("MemObject->clients: %p\n",
-	mem->clients);
-    debug(20, 1) ("MemObject->nclients: %d\n",
-	mem->nclients);
     debug(20, 1) ("MemObject->reply: %p\n",
 	mem->reply);
     debug(20, 1) ("MemObject->request: %p\n",
@@ -1090,8 +954,7 @@
 void
 storeEntryDump(const StoreEntry * e, int l)
 {
-    debug(20, l) ("StoreEntry->key: %s\n", storeKeyText(e->hash.key));
-    debug(20, l) ("StoreEntry->next: %p\n", e->hash.next);
+    debug(20, l) ("StoreEntry->key: %s\n", storeKeyUrl(e));
     debug(20, l) ("StoreEntry->mem_obj: %p\n", e->mem_obj);
     debug(20, l) ("StoreEntry->timestamp: %d\n", (int) e->timestamp);
     debug(20, l) ("StoreEntry->lastref: %d\n", (int) e->lastref);
@@ -1109,40 +972,6 @@
     debug(20, l) ("StoreEntry->swap_status: %d\n", (int) e->swap_status);
 }
 
-/*
- * NOTE, this function assumes only two mem states
- */
-void
-storeSetMemStatus(StoreEntry * e, int new_status)
-{
-    MemObject *mem = e->mem_obj;
-    if (new_status == e->mem_status)
-	return;
-    assert(mem != NULL);
-    if (new_status == IN_MEMORY) {
-	assert(mem->inmem_lo == 0);
-	if (EBIT_TEST(e->flags, ENTRY_SPECIAL)) {
-	    debug(20, 4) ("storeSetMemStatus: not inserting special %s into policy\n",
-		mem->url);
-	} else {
-	    mem_policy->Add(mem_policy, e, &mem->repl);
-	    debug(20, 4) ("storeSetMemStatus: inserted mem node %s\n",
-		mem->url);
-	}
-	hot_obj_count++;
-    } else {
-	if (EBIT_TEST(e->flags, ENTRY_SPECIAL)) {
-	    debug(20, 4) ("storeSetMemStatus: special entry %s\n",
-		mem->url);
-	} else {
-	    mem_policy->Remove(mem_policy, e, &mem->repl);
-	    debug(20, 4) ("storeSetMemStatus: removed mem node %s\n",
-		mem->url);
-	}
-	hot_obj_count--;
-    }
-    e->mem_status = new_status;
-}
 
 const char *
 storeUrl(const StoreEntry * e)
@@ -1155,6 +984,13 @@
 	return e->mem_obj->url;
 }
 
+
+const char *
+storeKeyUrl(const StoreEntry *e)
+{
+    return storeUrl(e);
+}
+
 void
 storeCreateMemObject(StoreEntry * e, const char *url, const char *log_url)
 {
@@ -1176,7 +1012,6 @@
 {
     EBIT_CLR(e->flags, DELAY_SENDING);
     InvokeHandlers(e);
-    storeSwapOut(e);
 }
 
 int
@@ -1209,9 +1044,7 @@
 {
     MemObject *mem = e->mem_obj;
     debug(20, 3) ("storeEntryReset: %s\n", storeUrl(e));
-    assert(mem->swapout.sio == NULL);
-    stmemFree(&mem->data_hdr);
-    mem->inmem_hi = mem->inmem_lo = 0;
+    /* XXX hrm, we have to reset the reply object? -- adrian */
     httpReplyDestroy(mem->reply);
     mem->reply = httpReplyCreate();
     e->expires = e->lastmod = e->timestamp = -1;
@@ -1299,7 +1132,24 @@
     debug(20, 1) ("ERROR: Be sure to have set cache_replacement_policy\n");
     debug(20, 1) ("ERROR:   and memory_replacement_policy in squid.conf!\n");
     fatalf("ERROR: Unknown policy %s\n", settings->type);
-    return NULL;		/* NOTREACHED */
+    return NULL; /* NOTREACHED */
+}
+
+/*
+ * Peek into the amount of an object that is in memory
+ */
+off_t
+storeMemHiOffset(const StoreEntry *e)
+{
+    assert(e->mem_obj != NULL);
+    return e->stmemhi(e);
+}
+
+off_t
+storeMemLoOffset(const StoreEntry *e)
+{
+    assert(e->mem_obj != NULL);
+    return e->stmemlo(e);
 }
 
 #if 0
@@ -1320,3 +1170,49 @@
     }
 }
 #endif
+
+
+
+/*
+ * storeDetachReply() - detach a reply from a MemObject
+ */
+void
+storeDetachReply(StoreEntry *e)
+{
+    STRDONE *stdone;
+
+    assert (e != NULL);
+
+    stdone = e->stdone;
+    if (stdone == NULL)
+        return;
+
+    stdone(e);
+
+    e->stappend = NULL;
+    e->stflush = NULL;
+    e->stmemhi = NULL;
+    e->stmemlo = NULL;
+    e->stclientcopy = NULL;
+    e->strelease = NULL;
+    e->stdone = NULL;
+    e->stmakeprivate = NULL;
+    e->stmakepublic = NULL;
+    e->stdata = NULL;
+}
+
+
+/*
+ * double check the request matches what we are after
+ * this should be used *before* calling storeLookup to make sure I
+ * have things 'right'.
+ */
+void
+storeDoubleCheckRequest(request_t *request, char *uri, method_t method)
+{
+    assert(request->method == method);
+    /*
+     * ignore the URI for the time being, as it kinda has to be set
+     */
+    /* assert(strncmp(request->urlpath.buf, uri, request->urlpath.len) == 0); */
+}
Index: squid/src/store_client.c
diff -u squid/src/store_client.c:1.7 squid/src/store_client.c:1.2.2.13
--- squid/src/store_client.c:1.7	Sat Mar  3 02:44:32 2001
+++ squid/src/store_client.c	Sun Mar 18 14:33:32 2001
@@ -40,13 +40,11 @@
  *       'Body' refers to the swapfile body, which is the full
  *        HTTP reply (including HTTP headers and body).
  */
+#if 0
 static STRCB storeClientReadBody;
 static STRCB storeClientReadHeader;
-static void storeClientCopy2(StoreEntry * e, store_client * sc);
-static void storeClientCopy3(StoreEntry * e, store_client * sc);
 static void storeClientFileRead(store_client * sc);
-static EVH storeClientCopyEvent;
-static store_client_t storeClientType(StoreEntry *);
+#endif
 static int CheckQuickAbort2(StoreEntry * entry);
 static void CheckQuickAbort(StoreEntry * entry);
 
@@ -55,278 +53,92 @@
 int
 storeClientWaiting(const StoreEntry * e)
 {
-    MemObject *mem = e->mem_obj;
-    dlink_node *node;
-    store_client *sc;
-    for (node = mem->clients.head; node; node = node->next) {
-	sc = node->data;
-	if (sc->callback_data != NULL)
+    if (e->sc.callback_data != NULL)
 	    return 1;
-    }
     return 0;
 }
 
-#if STORE_CLIENT_LIST_DEBUG
-store_client *
-storeClientListSearch(const MemObject * mem, void *data)
-{
-    dlink_node *node;
-    store_client *sc = NULL;
-    for (node = mem->clients.head; node; node = node->next) {
-	sc = node->data;
-	if (sc->callback_data == data)
-	    return sc;
-    }
-    return NULL;
-}
-#endif
-
-static store_client_t
-storeClientType(StoreEntry * e)
-{
-    MemObject *mem = e->mem_obj;
-    if (mem->inmem_lo)
-	return STORE_DISK_CLIENT;
-    if (EBIT_TEST(e->flags, ENTRY_ABORTED)) {
-	/* I don't think we should be adding clients to aborted entries */
-	debug(20, 1) ("storeClientType: adding to ENTRY_ABORTED entry\n");
-	return STORE_MEM_CLIENT;
-    }
-    if (e->store_status == STORE_OK) {
-	if (mem->inmem_lo == 0 && mem->inmem_hi > 0)
-	    return STORE_MEM_CLIENT;
-	else
-	    return STORE_DISK_CLIENT;
-    }
-    /* here and past, entry is STORE_PENDING */
-    /*
-     * If this is the first client, let it be the mem client
-     */
-    else if (mem->nclients == 1)
-	return STORE_MEM_CLIENT;
-    /*
-     * If there is no disk file to open yet, we must make this a
-     * mem client.  If we can't open the swapin file before writing
-     * to the client, there is no guarantee that we will be able
-     * to open it later when we really need it.
-     */
-    else if (e->swap_status == SWAPOUT_NONE)
-	return STORE_MEM_CLIENT;
-    /*
-     * otherwise, make subsequent clients read from disk so they
-     * can not delay the first, and vice-versa.
-     */
-    else
-	return STORE_DISK_CLIENT;
-}
 
 /* add client with fd to client list */
-store_client *
-storeClientListAdd(StoreEntry * e, void *data)
+void
+storeClientRegister(StoreEntry * e, void *data)
 {
-    MemObject *mem = e->mem_obj;
-    store_client *sc;
-    assert(mem);
-#if STORE_CLIENT_LIST_DEBUG
-    if (storeClientListSearch(mem, data) != NULL)
-	assert(1 == 0);		/* XXX die! */
-#endif
     e->refcount++;
-    mem->nclients++;
-    sc = cbdataAlloc(store_client);
-    cbdataLock(data);		/* locked while we point to it */
-    sc->callback_data = data;
-    sc->seen_offset = 0;
-    sc->copy_offset = 0;
-    sc->flags.disk_io_pending = 0;
-    sc->entry = e;
-    sc->type = storeClientType(e);
-    if (sc->type == STORE_DISK_CLIENT)
-	/* assert we'll be able to get the data we want */
-	/* maybe we should open swapin_fd here */
-	assert(e->swap_filen > -1 || storeSwapOutAble(e));
-    dlinkAdd(sc, &sc->node, &mem->clients);
+
+    assert(e->sc.valid == 0);
+    e->sc.valid = 1;
+    e->sc.callback_data = data;
+    e->sc.seen_offset = 0;
+    e->sc.copy_offset = 0;
+    e->sc.flags.disk_io_pending = 0;
+    e->sc.entry = e;
+
+    /* Lock the data that we're using .. */
+    cbdataLock(data);
 #if DELAY_POOLS
-    sc->delay_id = 0;
+    e->sc.delay_id = 0;
 #endif
-    return sc;
 }
 
 static void
-storeClientCallback(store_client * sc, ssize_t sz)
+storeClientCallback(StoreEntry *e, ssize_t sz)
 {
-    STCB *callback = sc->callback;
-    char *buf = sc->copy_buf;
-    assert(sc->callback);
-    sc->callback = NULL;
-    sc->copy_buf = NULL;
-    if (cbdataValid(sc->callback_data))
-	callback(sc->callback_data, buf, sz);
-}
-
-static void
-storeClientCopyEvent(void *data)
-{
-    store_client *sc = data;
-    debug(20, 3) ("storeClientCopyEvent: Running\n");
-    sc->flags.copy_event_pending = 0;
-    if (!sc->callback)
-	return;
-    storeClientCopy2(sc->entry, sc);
+    STCB *callback = e->sc.callback;
+    char *buf = e->sc.copy_buf;
+    assert(e->sc.valid == 1);
+    assert(e->sc.callback);
+    e->sc.callback = NULL;
+    e->sc.copy_buf = NULL;
+    if (cbdataValid(e->sc.callback_data))
+	callback(e->sc.callback_data, buf, sz);
 }
 
 /* copy bytes requested by the client */
 void
-storeClientCopy(store_client * sc,
-    StoreEntry * e,
+storeClientCopy(StoreEntry * e,
     off_t seen_offset,
     off_t copy_offset,
     size_t size,
     char *buf,
     STCB * callback,
     void *data)
-{
+{   
+    store_client *sc = &e->sc;
     assert(!EBIT_TEST(e->flags, ENTRY_ABORTED));
-    debug(20, 3) ("storeClientCopy: %s, seen %d, want %d, size %d, cb %p, cbdata %p\n",
-	storeKeyText(e->hash.key),
-	(int) seen_offset,
-	(int) copy_offset,
-	(int) size,
-	callback,
-	data);
-    assert(sc != NULL);
-#if STORE_CLIENT_LIST_DEBUG
-    assert(sc == storeClientListSearch(e->mem_obj, data));
-#endif
+
+    assert(!EBIT_TEST(e->flags, ENTRY_ABORTED));
+    assert(sc->valid == 1);
+    debug(20, 3) ("storeClientCopy: %s, seen %d, want %d, size %d, cb %p, cbdata %p\n", storeKeyUrl(e),
+        (int) seen_offset,
+        (int) copy_offset,
+        (int) size,
+        callback,
+        data);
+
     assert(sc->callback == NULL);
     assert(sc->entry == e);
+    assert(sc->copy_offset == sc->seen_offset); /* Just until everything has been changed */
     sc->copy_offset = copy_offset;
     sc->seen_offset = seen_offset;
     sc->callback = callback;
     sc->copy_buf = buf;
     sc->copy_size = size;
     sc->copy_offset = copy_offset;
-    storeClientCopy2(e, sc);
-}
 
-/*
- * This function is used below to decide if we have any more data to
- * send to the client.  If the store_status is STORE_PENDING, then we
- * do have more data to send.  If its STORE_OK, then
- * we continue checking.  If the object length is negative, then we
- * don't know the real length and must open the swap file to find out.
- * If the length is >= 0, then we compare it to the requested copy
- * offset.
- */
-static int
-storeClientNoMoreToSend(StoreEntry * e, store_client * sc)
-{
-    ssize_t len;
-    if (e->store_status == STORE_PENDING)
-	return 0;
-    if ((len = objectLen(e)) < 0)
-	return 0;
-    if (sc->copy_offset < len)
-	return 0;
-    return 1;
+    e->stclientcopy(e);
 }
 
-static void
-storeClientCopy2(StoreEntry * e, store_client * sc)
-{
-    if (sc->flags.copy_event_pending)
-	return;
-    if (EBIT_TEST(e->flags, ENTRY_FWD_HDR_WAIT)) {
-	debug(20, 5) ("storeClientCopy2: returning because ENTRY_FWD_HDR_WAIT set\n");
-	return;
-    }
-    if (sc->flags.store_copying) {
-	sc->flags.copy_event_pending = 1;
-	debug(20, 3) ("storeClientCopy2: Queueing storeClientCopyEvent()\n");
-	eventAdd("storeClientCopyEvent", storeClientCopyEvent, sc, 0.0, 0);
-	return;
-    }
-    cbdataLock(sc);		/* ick, prevent sc from getting freed */
-    sc->flags.store_copying = 1;
-    debug(20, 3) ("storeClientCopy2: %s\n", storeKeyText(e->hash.key));
-    assert(sc->callback != NULL);
-    /*
-     * We used to check for ENTRY_ABORTED here.  But there were some
-     * problems.  For example, we might have a slow client (or two) and
-     * the server-side is reading far ahead and swapping to disk.  Even
-     * if the server-side aborts, we want to give the client(s)
-     * everything we got before the abort condition occurred.
-     */
-    storeClientCopy3(e, sc);
-    sc->flags.store_copying = 0;
-    cbdataUnlock(sc);		/* ick, allow sc to be freed */
-}
 
-static void
-storeClientCopy3(StoreEntry * e, store_client * sc)
+int
+storeClientCopyPending(StoreEntry * e, void *data)
 {
-    MemObject *mem = e->mem_obj;
-    size_t sz;
-
-    if (storeClientNoMoreToSend(e, sc)) {
-	/* There is no more to send! */
-	storeClientCallback(sc, 0);
-	return;
-    }
-    if (e->store_status == STORE_PENDING && sc->seen_offset >= mem->inmem_hi) {
-	/* client has already seen this, wait for more */
-	debug(20, 3) ("storeClientCopy3: Waiting for more\n");
-	return;
-    }
-    /*
-     * Slight weirdness here.  We open a swapin file for any
-     * STORE_DISK_CLIENT, even if we can copy the requested chunk
-     * from memory in the next block.  We must try to open the
-     * swapin file before sending any data to the client side.  If
-     * we postpone the open, and then can not open the file later
-     * on, the client loses big time.  Its transfer just gets cut
-     * off.  Better to open it early (while the client side handler
-     * is clientCacheHit) so that we can fall back to a cache miss
-     * if needed.
-     */
-    if (STORE_DISK_CLIENT == sc->type && NULL == sc->swapin_sio) {
-	debug(20, 3) ("storeClientCopy3: Need to open swap in file\n");
-	/* gotta open the swapin file */
-	if (storeTooManyDiskFilesOpen()) {
-	    /* yuck -- this causes a TCP_SWAPFAIL_MISS on the client side */
-	    storeClientCallback(sc, -1);
-	    return;
-	} else if (!sc->flags.disk_io_pending) {
-	    /* Don't set store_io_pending here */
-	    storeSwapInStart(sc);
-	    if (NULL == sc->swapin_sio) {
-		storeClientCallback(sc, -1);
-		return;
-	    }
-	    /*
-	     * If the open succeeds we either copy from memory, or
-	     * schedule a disk read in the next block.
-	     */
-	} else {
-	    debug(20, 1) ("WARNING: Averted multiple fd operation (1)\n");
-	    return;
-	}
-    }
-    if (sc->copy_offset >= mem->inmem_lo && sc->copy_offset < mem->inmem_hi) {
-	/* What the client wants is in memory */
-	debug(20, 3) ("storeClientCopy3: Copying from memory\n");
-	sz = stmemCopy(&mem->data_hdr,
-	    sc->copy_offset, sc->copy_buf, sc->copy_size);
-	storeClientCallback(sc, sz);
-	return;
-    }
-    /* What the client wants is not in memory. Schedule a disk read */
-    assert(STORE_DISK_CLIENT == sc->type);
-    assert(!sc->flags.disk_io_pending);
-    debug(20, 3) ("storeClientCopy3: reading from STORE\n");
-    storeClientFileRead(sc);
+    if (e->sc.callback == NULL)
+        return 0;
+    return 1;
 }
 
+
+#if 0
 static void
 storeClientFileRead(store_client * sc)
 {
@@ -343,7 +155,9 @@
 	    sc);
     } else {
 	if (sc->entry->swap_status == SWAPOUT_WRITING)
+#if 0
 	    assert(storeOffset(mem->swapout.sio) > sc->copy_offset + mem->swap_hdr_sz);
+#endif
 	storeRead(sc->swapin_sio,
 	    sc->copy_buf,
 	    sc->copy_size,
@@ -471,129 +285,68 @@
     storeClientFileRead(sc);
 }
 
-int
-storeClientCopyPending(store_client * sc, StoreEntry * e, void *data)
-{
-#if STORE_CLIENT_LIST_DEBUG
-    assert(sc == storeClientListSearch(e->mem_obj, data));
 #endif
-    assert(sc->entry == e);
-    if (sc == NULL)
-	return 0;
-    if (sc->callback == NULL)
-	return 0;
-    return 1;
-}
+
 
 /*
- * This routine hasn't been optimised to take advantage of the
- * passed sc. Yet.
+ * Disassociate a client from a storeentry
  */
 int
-storeUnregister(store_client * sc, StoreEntry * e, void *data)
+storeClientUnregister(StoreEntry * e, void *data)
 {
+    store_client *sc = &e->sc;
     MemObject *mem = e->mem_obj;
-#if STORE_CLIENT_LIST_DEBUG
-    assert(sc == storeClientListSearch(e->mem_obj, data));
-#endif
-    if (mem == NULL)
-	return 0;
-    debug(20, 3) ("storeUnregister: called for '%s'\n", storeKeyText(e->hash.key));
+
+    debug(20, 3) ("storeUnregister: called for '%s'\n", storeKeyUrl(e));
+
     if (sc == NULL)
 	return 0;
-    if (mem->clients.head == NULL)
-	return 0;
-    if (sc == mem->clients.head->data) {
-	/*
-	 * If we are unregistering the _first_ client for this
-	 * entry, then we have to reset the client FD to -1.
-	 */
-	mem->fd = -1;
-    }
-    dlinkDelete(&sc->node, &mem->clients);
-    mem->nclients--;
-    if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
-	storeSwapOut(e);
-    if (sc->swapin_sio) {
-	storeClose(sc->swapin_sio);
-	cbdataUnlock(sc->swapin_sio);
-	sc->swapin_sio = NULL;
-	statCounter.swap.ins++;
-    }
+
+    assert(sc == &e->sc);
+    assert(mem != NULL);
+    assert(e->sc.valid == 1);
+
+    mem->fd = -1;
+
     if (NULL != sc->callback) {
 	/* callback with ssize = -1 to indicate unexpected termination */
 	debug(20, 3) ("storeUnregister: store_client for %s has a callback\n",
 	    mem->url);
-	storeClientCallback(sc, -1);
+	storeClientCallback(e, -1);
     }
 #if DELAY_POOLS
     delayUnregisterDelayIdPtr(&sc->delay_id);
 #endif
+    e->sc.valid = 0;
     cbdataUnlock(sc->callback_data);	/* we're done with it now */
-    /*assert(!sc->flags.disk_io_pending); */
-    cbdataFree(sc);
     assert(e->lock_count > 0);
-    if (mem->nclients == 0)
-	CheckQuickAbort(e);
+    CheckQuickAbort(e);
     return 1;
 }
 
+
+/* .. and this routine becomes meaningless.. :) */
 off_t
 storeLowestMemReaderOffset(const StoreEntry * entry)
 {
-    const MemObject *mem = entry->mem_obj;
-    off_t lowest = mem->inmem_hi + 1;
-    store_client *sc;
-    dlink_node *nx = NULL;
-    dlink_node *node;
-
-    for (node = mem->clients.head; node; node = nx) {
-	sc = node->data;
-	nx = node->next;
-	if (sc->callback_data == NULL)	/* open slot */
-	    continue;
-	if (sc->type != STORE_MEM_CLIENT)
-	    continue;
-	if (sc->type == STORE_DISK_CLIENT)
-	    if (NULL != sc->swapin_sio)
-		continue;
-	if (sc->copy_offset < lowest)
-	    lowest = sc->copy_offset;
-    }
-    return lowest;
+    return entry->sc.copy_offset;
 }
 
 /* Call handlers waiting for  data to be appended to E. */
 void
 InvokeHandlers(StoreEntry * e)
 {
-    int i = 0;
-    MemObject *mem = e->mem_obj;
-    store_client *sc;
-    dlink_node *nx = NULL;
-    dlink_node *node;
-
-    debug(20, 3) ("InvokeHandlers: %s\n", storeKeyText(e->hash.key));
-    /* walk the entire list looking for valid callbacks */
-    for (node = mem->clients.head; node; node = nx) {
-	sc = node->data;
-	nx = node->next;
-	debug(20, 3) ("InvokeHandlers: checking client #%d\n", i++);
-	if (sc->callback_data == NULL)
-	    continue;
-	if (sc->callback == NULL)
-	    continue;
-	if (sc->flags.disk_io_pending)
-	    continue;
-	storeClientCopy2(e, sc);
-    }
+    assert(e->mem_obj != NULL);
+    debug(20, 3) ("InvokeHandlers: %s\n", storeKeyUrl(e));
+    e->stflush(e);
 }
 
 int
 storePendingNClients(const StoreEntry * e)
 {
-    MemObject *mem = e->mem_obj;
-    int npend = NULL == mem ? 0 : mem->nclients;
+    int npend = 0;
+    if (e->sc.valid)
+        npend = 1;
     debug(20, 3) ("storePendingNClients: returning %d\n", npend);
     return npend;
 }
@@ -617,7 +370,7 @@
 	return 1;
     }
     expectlen = mem->reply->content_length + mem->reply->hdr_sz;
-    curlen = (int) mem->inmem_hi;
+    curlen = (int) storeMemHiOffset(entry);
     minlen = (int) Config.quickAbort.min << 10;
     if (minlen < 0) {
 	debug(20, 3) ("CheckQuickAbort2: NO disabled\n");
Index: squid/src/store_digest.c
diff -u squid/src/store_digest.c:1.9 squid/src/store_digest.c:1.2.2.7
--- squid/src/store_digest.c:1.9	Sat Mar  3 02:44:32 2001
+++ squid/src/store_digest.c	Sun Mar 18 14:33:32 2001
@@ -350,10 +350,14 @@
     url = internalLocalUri("/squid-internal-periodic/", StoreDigestFileName);
     flags = null_request_flags;
     flags.cachable = 1;
-    e = storeCreateEntry(url, url, flags, METHOD_GET);
+    sd_state.rewrite_lock = CBDATA_ALLOC(generic_cbdata, NULL);
     assert(e);
     sd_state.rewrite_lock = cbdataAlloc(generic_cbdata);
     sd_state.rewrite_lock->data = e;
+    e = storeCreateEntry(url, url, flags, METHOD_GET,
+      REPLY_OBJ_NETWORK);
+    assert(sd_state.rewrite_lock);
+    cbdataAdd(sd_state.rewrite_lock, NULL, 0);
     debug(71, 3) ("storeDigestRewrite: url: %s key: %s\n", url, storeKeyText(e->hash.key));
     e->mem_obj->request = requestLink(urlParse(METHOD_GET, url));
     /* wait for rebuild (if any) to finish */
Index: squid/src/store_dir.c
diff -u squid/src/store_dir.c:1.14 squid/src/store_dir.c:1.2.2.7
--- squid/src/store_dir.c:1.14	Tue Mar 13 14:49:49 2001
+++ squid/src/store_dir.c	Sun Mar 18 14:33:32 2001
@@ -197,6 +197,7 @@
 	    continue;
 	if (load > least_load)
 	    continue;
+	/* Only use leastsize if the load is equal */
 	cur_free = SD->max_size - SD->cur_size;
 	/* If the load is equal, then look in more details */
 	if (load == least_load) {
@@ -252,7 +253,7 @@
     assert(op > SWAP_LOG_NOP && op < SWAP_LOG_MAX);
     debug(20, 3) ("storeDirSwapLog: %s %s %d %08X\n",
 	swap_log_op_str[op],
-	storeKeyText(e->hash.key),
+	storeKeyUrl(e),
 	e->swap_dirn,
 	e->swap_filen);
     sd = &Config.cacheSwap.swapDirs[e->swap_dirn];
@@ -371,11 +372,11 @@
     SwapDir *sd;
     int dirn;
     int notdone = 1;
-    if (store_dirs_rebuilding) {
-	debug(20, 1) ("Not currently OK to rewrite swap log.\n");
-	debug(20, 1) ("storeDirWriteCleanLogs: Operation aborted.\n");
-	return 0;
-    }
+    /*
+     * We used to check here whether we were rebuilding the store dirs.
+     * If we were, we didn't attempt to write clean logs. Now, we let the
+     * filesystems decide that for themselves in sd->log.clean.start().
+     */
     debug(20, 1) ("storeDirWriteCleanLogs: Starting...\n");
     getCurrentTime();
     start = current_time;
Index: squid/src/store_io.c
diff -u squid/src/store_io.c:1.2 squid/src/store_io.c:1.2.2.2
--- squid/src/store_io.c:1.2	Sat Oct 21 08:16:13 2000
+++ squid/src/store_io.c	Tue Feb  6 02:08:04 2001
@@ -18,7 +18,8 @@
  * to select different polices depending on object size or type.
  */
 storeIOState *
-storeCreate(StoreEntry * e, STIOCB * file_callback, STIOCB * close_callback, void *callback_data)
+storeCreate(StoreEntry * e, STIOCB * file_callback, STIOCB * close_callback,
+  void *callback_data)
 {
     size_t objsize;
     sdirno dirn;
@@ -29,7 +30,7 @@
     /* This is just done for logging purposes */
     objsize = objectLen(e);
     if (objsize != -1)
-	objsize += e->mem_obj->swap_hdr_sz;
+       objsize += e->mem_obj->swap_hdr_sz;
 
     /*
      * Pick the swapdir
@@ -37,32 +38,65 @@
      */
     dirn = storeDirSelectSwapDir(e);
     if (dirn == -1) {
-	debug(20, 2) ("storeCreate: no valid swapdirs for this object\n");
-	store_io_stats.create.select_fail++;
-	return NULL;
+       debug(20, 2) ("storeCreate: no valid swapdirs for this object\n");
+       store_io_stats.create.select_fail++;
+       return NULL;
     }
-    debug(20, 2) ("storeCreate: Selected dir '%d' for obj size '%d'\n", dirn, objsize);
+    debug(20, 2) ("storeCreate: Selected dir '%d' for obj size '%d'\n", dirn,
+      objsize);
     SD = &Config.cacheSwap.swapDirs[dirn];
 
     /* Now that we have a fs to use, call its storeCreate function */
     sio = SD->obj.create(SD, e, file_callback, close_callback, callback_data);
     if (NULL == sio)
-	store_io_stats.create.create_fail++;
+       store_io_stats.create.create_fail++;
     else
-	store_io_stats.create.success++;
+       store_io_stats.create.success++;
     return sio;
 }
 
 
+
+/*
+ * storeLookup - the eventual replacement for storeGet()/storeGetPublic()
+ * 
+ * This function handles issuing lookups to each of the object stores.
+ * A callback/data pair will be called with the StoreEntry referencing
+ * the object if one is found, or NULL is returned.
+ *
+ * Yes, its inefficient right now, but there isn't much we can do about
+ * it until we've got *something* that works..
+ */
+void
+storeLookup(request_t *request, STGETDONE *callback, void *callback_data)
+{
+    /* Only begin a lookup in StoreDir 0 for now */
+    SwapDir *sd = INDEXSD(0);
+
+    /* Lock the request and callback */
+    cbdataLock(request);
+    cbdataLock(callback_data);
+
+    sd->obj.get(sd, request, callback, callback_data);
+}
+
 /*
- * storeOpen() is purely for reading ..
+ * storeLookupComplete - called at the completion (sucess/failure!) of
+ * a given lookup.
+ *
+ * This function unlocks the request and then issues the callback.
  */
-storeIOState *
-storeOpen(StoreEntry * e, STFNCB * file_callback, STIOCB * callback,
-    void *callback_data)
+void
+storeLookupComplete(request_t *request, STGETDONE *callback,
+    void *callback_data, StoreEntry *e)
 {
-    SwapDir *SD = &Config.cacheSwap.swapDirs[e->swap_dirn];
-    return SD->obj.open(SD, e, file_callback, callback, callback_data);
+    /* Only callback if the request_t and the callback are valid! */
+    if (cbdataValid(request) && cbdataValid(callback_data))
+        callback(callback_data, e);
+
+    /* Unlock, which can possibly free these two entries now */
+    cbdataUnlock(request);
+    cbdataUnlock(callback_data);
 }
 
 void
Index: squid/src/store_log.c
diff -u squid/src/store_log.c:1.6 squid/src/store_log.c:1.2.2.5
--- squid/src/store_log.c:1.6	Sat Feb 17 12:56:22 2001
+++ squid/src/store_log.c	Tue Feb 20 07:39:42 2001
@@ -75,14 +75,14 @@
 	    storeLogTags[tag],
 	    e->swap_dirn,
 	    e->swap_filen,
-	    storeKeyText(e->hash.key),
+	    storeKeyUrl(e),
 	    reply->sline.status,
 	    (int) reply->date,
 	    (int) reply->last_modified,
 	    (int) reply->expires,
 	    strLen(reply->content_type) ? strBuf(reply->content_type) : "unknown",
 	    reply->content_length,
-	    (int) (mem->inmem_hi - mem->reply->hdr_sz),
+	    (int) (storeMemHiOffset(e) - mem->reply->hdr_sz),
 	    RequestMethodStr[mem->method],
 	    mem->log_url);
     } else {
@@ -93,7 +93,7 @@
 	    storeLogTags[tag],
 	    e->swap_dirn,
 	    e->swap_filen,
-	    storeKeyText(e->hash.key));
+	    storeKeyUrl(e));
     }
 }
 
Index: squid/src/store_rebuild.c
diff -u squid/src/store_rebuild.c:1.7 squid/src/store_rebuild.c:1.2.2.6
--- squid/src/store_rebuild.c:1.7	Fri Jan 12 00:20:33 2001
+++ squid/src/store_rebuild.c	Fri Jan 12 00:46:08 2001
@@ -37,7 +37,6 @@
 
 static struct _store_rebuild_data counts;
 static struct timeval rebuild_start;
-static void storeCleanup(void *);
 
 typedef struct {
     /* total number of "swap.state" entries that will be read */
@@ -55,58 +54,6 @@
     return (SD->dblcheck(SD, e));
 }
 
-static void
-storeCleanup(void *datanotused)
-{
-    static int bucketnum = -1;
-    static int validnum = 0;
-    static int store_errors = 0;
-    int validnum_start;
-    StoreEntry *e;
-    hash_link *link_ptr = NULL;
-    hash_link *link_next = NULL;
-    validnum_start = validnum;
-    while (validnum - validnum_start < 500) {
-	if (++bucketnum >= store_hash_buckets) {
-	    debug(20, 1) ("  Completed Validation Procedure\n");
-	    debug(20, 1) ("  Validated %d Entries\n", validnum);
-	    debug(20, 1) ("  store_swap_size = %dk\n", store_swap_size);
-	    store_dirs_rebuilding--;
-	    assert(0 == store_dirs_rebuilding);
-	    if (opt_store_doublecheck)
-		assert(store_errors == 0);
-	    if (store_digest)
-		storeDigestNoteStoreReady();
-	    return;
-	}
-	link_next = hash_get_bucket(store_table, bucketnum);
-	while (NULL != (link_ptr = link_next)) {
-	    link_next = link_ptr->next;
-	    e = (StoreEntry *) link_ptr;
-	    if (EBIT_TEST(e->flags, ENTRY_VALIDATED))
-		continue;
-	    /*
-	     * Calling storeRelease() has no effect because we're
-	     * still in 'store_rebuilding' state
-	     */
-	    if (e->swap_filen < 0)
-		continue;
-	    if (opt_store_doublecheck)
-		if (storeCleanupDoubleCheck(e))
-		    store_errors++;
-	    EBIT_SET(e->flags, ENTRY_VALIDATED);
-	    /*
-	     * Only set the file bit if we know its a valid entry
-	     * otherwise, set it in the validation procedure
-	     */
-	    storeDirUpdateSwapSize(&Config.cacheSwap.swapDirs[e->swap_dirn], e->swap_file_sz, 1);
-	    if ((++validnum & 0x3FFFF) == 0)
-		debug(20, 1) ("  %7d Entries Validated so far.\n", validnum);
-	}
-    }
-    eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
-}
-
 /* meta data recreated from disk image in swap directory */
 void
 storeRebuildComplete(struct _store_rebuild_data *dc)
@@ -122,6 +69,8 @@
     counts.badflags += dc->badflags;
     counts.bad_log_op += dc->bad_log_op;
     counts.zero_object_sz += dc->zero_object_sz;
+    store_dirs_rebuilding--;
+
     /*
      * When store_dirs_rebuilding == 1, it means we are done reading
      * or scanning all cache_dirs.  Now report the stats and start
@@ -141,9 +90,8 @@
     debug(20, 1) ("  %7d Swapfile clashes avoided.\n", counts.clashcount);
     debug(20, 1) ("  Took %3.1f seconds (%6.1f objects/sec).\n", dt,
 	(double) counts.objcount / (dt > 0.0 ? dt : 1.0));
-    debug(20, 1) ("Beginning Validation Procedure\n");
-    eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
     xfree(RebuildProgress);
+    store_dirs_rebuilding = 0;
     RebuildProgress = NULL;
 }
 
Index: squid/src/store_swapin.c
diff -u squid/src/store_swapin.c:1.5 squid/src/store_swapin.c:1.2.2.3
--- squid/src/store_swapin.c:1.5	Fri Jan 12 00:20:33 2001
+++ squid/src/store_swapin.c	Fri Jan 12 00:46:08 2001
@@ -38,6 +38,7 @@
 static STIOCB storeSwapInFileClosed;
 static STFNCB storeSwapInFileNotify;
 
+#if 0
 void
 storeSwapInStart(store_client * sc)
 {
@@ -94,3 +95,4 @@
     e->swap_filen = sio->swap_filen;
     e->swap_dirn = sio->swap_dirn;
 }
+#endif
Index: squid/src/store_swapout.c
diff -u squid/src/store_swapout.c:1.7 squid/src/store_swapout.c:1.2.2.6
--- squid/src/store_swapout.c:1.7	Sat Mar  3 02:44:32 2001
+++ squid/src/store_swapout.c	Sun Mar 18 14:33:32 2001
@@ -40,6 +40,12 @@
 static STIOCB storeSwapOutFileClosed;
 static STIOCB storeSwapOutFileNotify;
 
+
+
+#if 0
+
+
+
 /* start swapping object to disk */
 static void
 storeSwapOutStart(StoreEntry * e)
@@ -115,16 +121,16 @@
 	storeSwapOutFileClose(e);
 	return;
     }
-    debug(20, 7) ("storeSwapOut: mem->inmem_lo = %d\n",
-	(int) mem->inmem_lo);
-    debug(20, 7) ("storeSwapOut: mem->inmem_hi = %d\n",
-	(int) mem->inmem_hi);
+    debug(20, 7) ("storeSwapOut: storeMemLoOffset = %d\n",
+	(int) storeMemLoOffset(e));
+    debug(20, 7) ("storeSwapOut: storeMemHiOffset = %d\n",
+	(int) storeMemHiOffset(e));
     debug(20, 7) ("storeSwapOut: swapout.queue_offset = %d\n",
 	(int) mem->swapout.queue_offset);
     if (mem->swapout.sio)
 	debug(20, 7) ("storeSwapOut: storeOffset() = %d\n",
 	    (int) storeOffset(mem->swapout.sio));
-    assert(mem->inmem_hi >= mem->swapout.queue_offset);
+    assert(storeMemHiOffset(e) >= mem->swapout.queue_offset);
     lowest_offset = storeLowestMemReaderOffset(e);
     debug(20, 7) ("storeSwapOut: lowest_offset = %d\n",
 	(int) lowest_offset);
@@ -132,22 +138,22 @@
      * Grab the swapout_size and check to see whether we're going to defer
      * the swapout based upon size
      */
-    swapout_size = (ssize_t) (mem->inmem_hi - mem->swapout.queue_offset);
+    swapout_size = (ssize_t) (storeMemHiOffset(e) - mem->swapout.queue_offset);
     if ((e->store_status != STORE_OK) && (swapout_size < store_maxobjsize)) {
 	debug(20, 5) ("storeSwapOut: Deferring starting swapping out\n");
 	return;
     }
     /*
-     * Careful.  lowest_offset can be greater than inmem_hi, such
+     * Careful.  lowest_offset can be greater than storeMemHiOffset, such
      * as in the case of a range request.
      */
-    if (mem->inmem_hi < lowest_offset)
+    if (storeMemHiOffset(e) < lowest_offset)
 	new_mem_lo = lowest_offset;
-    else if (mem->inmem_hi - lowest_offset > Config.Store.maxInMemObjSize)
+    else if (storeMemHiOffset(e) - lowest_offset > Config.Store.maxInMemObjSize)
 	new_mem_lo = lowest_offset;
     else
-	new_mem_lo = mem->inmem_lo;
-    assert(new_mem_lo >= mem->inmem_lo);
+	new_mem_lo = storeMemLoOffset(e);
+    assert(new_mem_lo >= storeMemLoOffset(e));
     if (storeSwapOutAble(e)) {
 	/*
 	 * We should only free up to what we know has been written
@@ -172,7 +178,7 @@
     stmemFreeDataUpto(&mem->data_hdr, new_mem_lo);
     mem->inmem_lo = new_mem_lo;
     if (e->swap_status == SWAPOUT_WRITING)
-	assert(mem->inmem_lo <= on_disk);
+	assert(storeMemLoOffset(e) <= on_disk);
     if (!storeSwapOutAble(e))
 	return;
     debug(20, 7) ("storeSwapOut: swapout_size = %d\n",
@@ -196,7 +202,7 @@
     /* Ok, we have stuff to swap out.  Is there a swapout.sio open? */
     if (e->swap_status == SWAPOUT_NONE) {
 	assert(mem->swapout.sio == NULL);
-	assert(mem->inmem_lo == 0);
+	assert(storeMemLoOffset(e) == 0);
 	if (storeCheckCachable(e))
 	    storeSwapOutStart(e);
 	else
@@ -239,7 +245,7 @@
 	/* the storeWrite() call might generate an error */
 	if (e->swap_status != SWAPOUT_WRITING)
 	    break;
-	swapout_size = (ssize_t) (mem->inmem_hi - mem->swapout.queue_offset);
+	swapout_size = (ssize_t) (storeMemHiOffset(e) - mem->swapout.queue_offset);
 	if (e->store_status == STORE_PENDING)
 	    if (swapout_size < SM_PAGE_SIZE)
 		break;
@@ -253,7 +259,7 @@
 	 * to the filesystem at this point because storeSwapOut() is
 	 * not going to be called again for this entry.
 	 */
-	assert(mem->inmem_hi == mem->swapout.queue_offset);
+	assert(storeMemHiOffset(e) == mem->swapout.queue_offset);
 	storeSwapOutFileClose(e);
     }
 }
@@ -346,7 +352,7 @@
     dlink_node *node;
     if (e->mem_obj->swapout.sio != NULL)
 	return 1;
-    if (e->mem_obj->inmem_lo > 0)
+    if (storeMemLoOffset(e) > 0)
 	return 0;
     /*
      * If there are DISK clients, we must write to disk
@@ -361,3 +367,7 @@
 	    return 0;
     return EBIT_TEST(e->flags, ENTRY_CACHABLE);
 }
+
+
+
+#endif
Index: squid/src/structs.h
diff -u squid/src/structs.h:1.26 squid/src/structs.h:1.2.2.20
--- squid/src/structs.h:1.26	Tue Feb 20 16:10:13 2001
+++ squid/src/structs.h	Sun Mar 18 14:33:32 2001
@@ -981,8 +981,6 @@
 struct _clientHttpRequest {
     ConnStateData *conn;
     request_t *request;		/* Parsed URL ... */
-    store_client *sc;		/* The store_client we're using */
-    store_client *old_sc;	/* ... for entry to be validated */
     char *uri;
     char *log_uri;
     struct {
@@ -1013,6 +1011,8 @@
 	char *location;
     } redirect;
     dlink_node active;
+    char *buf;			/* transient buffer... eeeew! */
+    int bufofs;			/* offset in the current buffer .. */
 };
 
 struct _ConnStateData {
@@ -1090,8 +1090,6 @@
     PeerDigest *pd;
     StoreEntry *entry;
     StoreEntry *old_entry;
-    store_client *sc;
-    store_client *old_sc;
     request_t *request;
     int offset;
     int mask_offset;
@@ -1348,6 +1346,7 @@
 
 /* keep track each client receiving data from that particular StoreEntry */
 struct _store_client {
+    int valid;
     int type;
     off_t copy_offset;
     off_t seen_offset;
@@ -1406,16 +1405,6 @@
 struct _MemObject {
     method_t method;
     char *url;
-    mem_hdr data_hdr;
-    off_t inmem_hi;
-    off_t inmem_lo;
-    dlink_list clients;
-    int nclients;
-    struct {
-	off_t queue_offset;	/* relative to in-mem data */
-	mem_node *memnode;	/* which node we're currently paging out */
-	storeIOState *sio;
-    } swapout;
     HttpReply *reply;
     request_t *request;
     struct timeval start_ping;
@@ -1438,6 +1427,7 @@
 
 struct _StoreEntry {
     hash_link hash;		/* must be first */
+    dlink_node node;		/* to track current objects .. */
     MemObject *mem_obj;
     RemovalPolicyNode repl;
     time_t timestamp;
@@ -1454,6 +1444,21 @@
     ping_status_t ping_status:3;
     store_status_t store_status:3;
     swap_status_t swap_status:3;
+
+    /* The request callback information */
+    store_client sc;
+
+    /* The reply callback functions */
+    STRAPPEND *stappend;
+    STRFLUSH *stflush;
+    STRMEMHI *stmemhi;
+    STRMEMLO *stmemlo;
+    STRCLIENTCOPY *stclientcopy;
+    STRPRIVATE *stmakeprivate;
+    STRPUBLIC *stmakepublic;
+    STRDONE *stdone;
+    STRRELEASE *strelease;
+    void *stdata;
 };
 
 struct _SwapDir {
@@ -1486,8 +1491,8 @@
     STCALLBACK *callback;	/* Handle pending callbacks */
     STSYNC *sync;		/* Sync the directory */
     struct {
-	STOBJCREATE *create;
-	STOBJOPEN *open;
+        STOBJCREATE *create;
+        STOBJGET *get;
 	STOBJCLOSE *close;
 	STOBJREAD *read;
 	STOBJWRITE *write;
@@ -1570,7 +1575,6 @@
     int link_count;		/* free when zero */
     request_flags flags;
     HttpHdrCc *cache_control;
-    HttpHdrRange *range;
     http_version_t http_ver;
     time_t ims;
     int imslen;
Index: squid/src/tools.c
diff -u squid/src/tools.c:1.11 squid/src/tools.c:1.2.2.7
--- squid/src/tools.c:1.11	Thu Feb 15 13:09:17 2001
+++ squid/src/tools.c	Tue Feb 20 07:39:42 2001
@@ -348,11 +348,11 @@
 fatal(const char *message)
 {
     releaseServerSockets();
-    /* check for store_dirs_rebuilding because fatal() is often
-     * used in early initialization phases, long before we ever
-     * get to the store log. */
-    if (0 == store_dirs_rebuilding)
-	storeDirWriteCleanLogs(0);
+    /*
+     * Attempt to write clean store log information. If any of the filestores
+     * are rebuilding, they will fail in their own time.
+     */
+    storeDirWriteCleanLogs(0);
     fatal_common(message);
     exit(shutting_down ? 0 : 1);
 }
Index: squid/src/typedefs.h
diff -u squid/src/typedefs.h:1.17 squid/src/typedefs.h:1.2.2.13
--- squid/src/typedefs.h:1.17	Wed Feb 28 20:04:19 2001
+++ squid/src/typedefs.h	Sun Mar 18 14:33:32 2001
@@ -263,13 +263,19 @@
 typedef int STCALLBACK(SwapDir *);
 typedef void STSYNC(SwapDir *);
 
-typedef storeIOState *STOBJCREATE(SwapDir *, StoreEntry *, STFNCB *, STIOCB *, void *);
-typedef storeIOState *STOBJOPEN(SwapDir *, StoreEntry *, STFNCB *, STIOCB *, void *);
+/* store lookup callback */
+typedef void STGETDONE(void *, StoreEntry *);
+
+/* store IO functions */
+typedef storeIOState *STOBJCREATE(SwapDir *, StoreEntry *, STFNCB *, STIOCB *,
+  void *);
 typedef void STOBJCLOSE(SwapDir *, storeIOState *);
 typedef void STOBJREAD(SwapDir *, storeIOState *, char *, size_t, off_t, STRCB *, void *);
 typedef void STOBJWRITE(SwapDir *, storeIOState *, char *, size_t, off_t, FREE *);
 typedef void STOBJUNLINK(SwapDir *, StoreEntry *);
 
+typedef void STOBJGET(SwapDir *, request_t *, STGETDONE *, void *);
+
 typedef void STLOGOPEN(SwapDir *);
 typedef void STLOGCLOSE(SwapDir *);
 typedef void STLOGWRITE(const SwapDir *, const StoreEntry *, int);
@@ -285,6 +291,18 @@
 typedef void STFSSTARTUP(void);
 typedef void STFSSHUTDOWN(void);
 
+/* store reply routines */
+typedef void STRAPPEND(StoreEntry *, const char *, int);
+typedef void STRFLUSH(StoreEntry *);
+typedef off_t STRMEMHI(const StoreEntry *);
+typedef off_t STRMEMLO(const StoreEntry *);
+typedef void STRCLIENTCOPY(StoreEntry *);
+typedef void STRRELEASE(StoreEntry *);
+typedef void STRDONE(StoreEntry *);
+typedef void STRPUBLIC(StoreEntry *);
+typedef void STRPRIVATE(StoreEntry *);
+
+
 typedef double hbase_f(double);
 typedef void StatHistBinDumper(StoreEntry *, int idx, double val, double size, int count);
 
Index: squid/src/urn.c
diff -u squid/src/urn.c:1.10 squid/src/urn.c:1.2.2.9
--- squid/src/urn.c:1.10	Sat Mar  3 02:44:32 2001
+++ squid/src/urn.c	Sun Mar 18 14:33:32 2001
@@ -137,16 +137,17 @@
     }
     httpHeaderPutStr(&urlres_r->header, HDR_ACCEPT, "text/plain");
     if ((urlres_e = storeGetPublic(urlres, METHOD_GET)) == NULL) {
-	urlres_e = storeCreateEntry(urlres, urlres, null_request_flags, METHOD_GET);
-	urnState->sc = storeClientListAdd(urlres_e, urnState);
+	urlres_e = storeCreateEntry(urlres, urlres, null_request_flags,
+          METHOD_GET, REPLY_OBJ_INTERNAL);
+	storeClientRegister(urlres_e, urnState);
 	fwdStart(-1, urlres_e, urlres_r);
     } else {
 	storeLockObject(urlres_e);
-	urnState->sc = storeClientListAdd(urlres_e, urnState);
+	storeClientRegister(urlres_e, urnState);
     }
     urnState->urlres_e = urlres_e;
     urnState->urlres_r = requestLink(urlres_r);
-    storeClientCopy(urnState->sc, urlres_e,
+    storeClientCopy(urlres_e,
 	0,
 	0,
 	4096,
@@ -201,7 +202,7 @@
 	return;
     }
     if (urlres_e->store_status == STORE_PENDING && size < SM_PAGE_SIZE) {
-	storeClientCopy(urnState->sc, urlres_e,
+	storeClientCopy(urlres_e,
 	    size,
 	    0,
 	    SM_PAGE_SIZE,
@@ -292,7 +293,7 @@
     }
     safe_free(urls);
     /* mb was absorbed in httpBodySet call, so we must not clean it */
-    storeUnregister(urnState->sc, urlres_e, urnState);
+    storeClientUnregister(urlres_e, urnState);
     storeUnlockObject(urlres_e);
     storeUnlockObject(urnState->entry);
     requestUnlink(urnState->request);
Index: squid/src/wais.c
diff -u squid/src/wais.c:1.6 squid/src/wais.c:1.2.2.4
--- squid/src/wais.c:1.6	Sat Mar  3 02:44:32 2001
+++ squid/src/wais.c	Sun Mar 18 14:33:32 2001
@@ -70,7 +70,7 @@
     StoreEntry *entry = waisState->entry;
     debug(24, 4) ("waisTimeout: FD %d: '%s'\n", fd, storeUrl(entry));
     if (entry->store_status == STORE_PENDING) {
-	if (entry->mem_obj->inmem_hi == 0) {
+	if (storeMemHiOffset(entry) == 0) {
 	    fwdFail(waisState->fwd,
 		errorCon(ERR_READ_TIMEOUT, HTTP_GATEWAY_TIMEOUT));
 	}
@@ -138,7 +138,7 @@
 	    errorAppendEntry(entry, err);
 	    comm_close(fd);
 	}
-    } else if (len == 0 && entry->mem_obj->inmem_hi == 0) {
+    } else if (len == 0 && storeMemHiOffset(entry) == 0) {
 	ErrorState *err;
 	err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
 	err->xerrno = errno;
Index: squid/src/whois.c
diff -u squid/src/whois.c:1.6 squid/src/whois.c:1.2.2.6
--- squid/src/whois.c:1.6	Sat Mar  3 02:44:32 2001
+++ squid/src/whois.c	Sun Mar 18 14:33:32 2001
@@ -97,7 +97,7 @@
     debug(75, 3) ("whoisReadReply: FD %d read %d bytes\n", fd, len);
     debug(75, 5) ("{%s}\n", buf);
     if (len > 0) {
-	if (0 == mem->inmem_hi)
+	if (0 == storeMemHiOffset(entry))
 	    mem->reply->sline.status = HTTP_OK;
 	fd_bytes(fd, len, FD_READ);
 	kb_incr(&statCounter.server.all.kbytes_in, len);
@@ -109,7 +109,7 @@
 	    fd, xstrerror());
 	if (ignoreErrno(errno)) {
 	    commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
-	} else if (mem->inmem_hi == 0) {
+	} else if (storeMemHiOffset(entry) == 0) {
 	    ErrorState *err;
 	    err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
 	    err->xerrno = errno;
Index: squid/src/fs/hash/Makefile.in
diff -u /dev/null squid/src/fs/hash/Makefile.in:1.1.2.1
--- /dev/null	Sun Jan 25 06:37:04 2004
+++ squid/src/fs/hash/Makefile.in	Sat Dec 16 01:29:03 2000
@@ -0,0 +1,56 @@
+#
+#  Makefile for the hash storage driver for the Squid Object Cache server
+#
+#  $Id: squid-modio-HEAD,v 1.1 2004/08/17 20:55:12 hno Exp $
+#
+
+FS		= hash 
+
+top_srcdir	= @top_srcdir@
+VPATH		= @srcdir@
+
+CC		= @CC@
+MAKEDEPEND	= @MAKEDEPEND@
+AR_R		= @AR_R@
+RANLIB		= @RANLIB@
+AC_CFLAGS	= @CFLAGS@
+SHELL		= /bin/sh
+
+INCLUDE		= -I../../../include -I$(top_srcdir)/include -I$(top_srcdir)/src/
+CFLAGS 		= $(AC_CFLAGS) $(INCLUDE) $(DEFINES)
+
+OUT		= ../$(FS).a
+
+OBJS	 	= \
+		store_dir_hash.o \
+		store_io_hash.o
+
+
+all: $(OUT)
+
+$(OUT): $(OBJS)
+	@rm -f ../stamp
+	$(AR_R) $(OUT) $(OBJS)
+	$(RANLIB) $(OUT)
+
+$(OBJS): $(top_srcdir)/include/version.h ../../../include/autoconf.h
+
+.c.o:
+	@rm -f ../stamp
+	$(CC) $(CFLAGS) -c $<
+
+clean: 
+	-rm -rf *.o *pure_* core ../$(FS).a
+
+distclean:	clean
+	-rm -f Makefile
+	-rm -f Makefile.bak
+	-rm -f tags
+
+install:
+
+tags:
+	ctags *.[ch] $(top_srcdir)/src/*.[ch] $(top_srcdir)/include/*.h $(top_srcdir)/lib/*.[ch]
+
+depend:
+	$(MAKEDEPEND) $(INCLUDE) -fMakefile *.c
Index: squid/src/fs/hash/store_dir_hash.c
diff -u /dev/null squid/src/fs/hash/store_dir_hash.c:1.1.2.5
--- /dev/null	Sun Jan 25 06:37:04 2004
+++ squid/src/fs/hash/store_dir_hash.c	Wed Jan 10 12:41:14 2001
@@ -0,0 +1,621 @@
+
+/*
+ * $Id: squid-modio-HEAD,v 1.1 2004/08/17 20:55:12 hno Exp $
+ *
+ * DEBUG: section 47    Store Directory Routines
+ * AUTHOR: Duane Wessels
+ *
+ * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
+ * ----------------------------------------------------------
+ *
+ *  Squid is the result of efforts by numerous individuals from the
+ *  Internet community.  Development is led by Duane Wessels of the
+ *  National Laboratory for Applied Network Research and funded by the
+ *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
+ *  Duane Wessels and the University of California San Diego.  Please
+ *  see the COPYRIGHT file for full details.  Squid incorporates
+ *  software developed and/or copyrighted by other sources.  Please see
+ *  the CREDITS file for full details.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
+ *
+ */
+
+#include "squid.h"
+#if HAVE_STATVFS
+#if HAVE_SYS_STATVFS_H
+#include <sys/statvfs.h>
+#endif
+#endif
+
+#include "store_hash.h"
+
+#define DefaultLevelOneDirs     16
+#define DefaultLevelTwoDirs     256
+#define STORE_META_BHASHZ 4096
+
+static int n_hash_dirs = 0;
+static int *hash_dir_index = NULL;
+MemPool *hash_state_pool = NULL;
+static int hash_initialised = 0;
+
+static int storeHashDirCreateDirectory(const char *path, int);
+static int storeHashDirVerifyDirectory(const char *path);
+static char *storeHashDirSwapLogFile(SwapDir *, const char *);
+static STLOGOPEN storeHashDirOpenSwapLog;
+static STINIT storeHashDirInit;
+static STFREE storeHashDirFree;
+static STNEWFS storeHashDirNewfs;
+static STDUMP storeHashDirDump;
+static STMAINTAINFS storeHashDirMaintain;
+static STCHECKOBJ storeHashDirCheckObj;
+static STREFOBJ storeHashDirRefObj;
+static STUNREFOBJ storeHashDirUnrefObj;
+static EVH storeHashDirCleanEvent;
+static EVH storeHashDirRebuildEvent;
+static int storeHashCleanupDoubleCheck(SwapDir *, StoreEntry *);
+static void storeHashDirStats(SwapDir *, StoreEntry *);
+static void storeHashDirInitBitmap(SwapDir *);
+
+/*
+ * These functions were ripped straight out of the heart of store_dir.c.
+ * They assume that the given filenum is on a hash partiton, which may or
+ * may not be true.. 
+ * XXX this evilness should be tidied up at a later date!
+ */
+
+int
+storeHashDirMapBitTest(SwapDir * SD, int fn)
+{
+    sfileno filn = fn;
+    hashinfo_t *hashinfo;
+    hashinfo = (hashinfo_t *) SD->fsdata;
+    return file_map_bit_test(hashinfo->map, filn);
+}
+
+void
+storeHashDirMapBitSet(SwapDir * SD, int fn)
+{
+    sfileno filn = fn;
+    hashinfo_t *hashinfo;
+    hashinfo = (hashinfo_t *) SD->fsdata;
+    file_map_bit_set(hashinfo->map, filn);
+}
+
+void
+storeHashDirMapBitReset(SwapDir * SD, int fn)
+{
+    sfileno filn = fn;
+    hashinfo_t *hashinfo;
+    hashinfo = (hashinfo_t *) SD->fsdata;
+    /*
+     * We have to test the bit before calling file_map_bit_reset.
+     * file_map_bit_reset doesn't do bounds checking.  It assumes
+     * filn is a valid file number, but it might not be because
+     * the map is dynamic in size.  Also clearing an already clear
+     * bit puts the map counter of-of-whack.
+     */
+    if (file_map_bit_test(hashinfo->map, filn))
+	file_map_bit_reset(hashinfo->map, filn);
+}
+
+int
+storeHashDirMapBitAllocate(SwapDir * SD)
+{
+    hashinfo_t *hashinfo = (hashinfo_t *) SD->fsdata;
+    int fn;
+    fn = file_map_allocate(hashinfo->map, hashinfo->suggest);
+    file_map_bit_set(hashinfo->map, fn);
+    hashinfo->suggest = fn + 1;
+    return fn;
+}
+
+/*
+ * Initialise the hash bitmap
+ *
+ * If there already is a bitmap, and the numobjects is larger than currently
+ * configured, we allocate a new bitmap and 'grow' the old one into it.
+ */
+static void
+storeHashDirInitBitmap(SwapDir * sd)
+{
+    hashinfo_t *hashinfo = (hashinfo_t *) sd->fsdata;
+
+    if (hashinfo->map == NULL) {
+	/* First time */
+	hashinfo->map = file_map_create();
+    } else if (hashinfo->map->max_n_files) {
+	/* it grew, need to expand */
+	/* XXX We don't need it anymore .. */
+    }
+    /* else it shrunk, and we leave the old one in place */
+}
+
+static int
+storeHashDirCreateDirectory(const char *path, int should_exist)
+{
+    int created = 0;
+    struct stat st;
+    getCurrentTime();
+    if (0 == stat(path, &st)) {
+	if (S_ISDIR(st.st_mode)) {
+	    debug(20, should_exist ? 3 : 1) ("%s exists\n", path);
+	} else {
+	    fatalf("Swap directory %s is not a directory.", path);
+	}
+    } else if (0 == mkdir(path, 0755)) {
+	debug(20, should_exist ? 1 : 3) ("%s created\n", path);
+	created = 1;
+    } else {
+	fatalf("Failed to make swap directory %s: %s",
+	    path, xstrerror());
+    }
+    return created;
+}
+
+static int
+storeHashDirVerifyDirectory(const char *path)
+{
+    struct stat sb;
+    if (stat(path, &sb) < 0) {
+	debug(20, 0) ("%s: %s\n", path, xstrerror());
+	return -1;
+    }
+    if (S_ISDIR(sb.st_mode) == 0) {
+	debug(20, 0) ("%s is not a directory\n", path);
+	return -1;
+    }
+    return 0;
+}
+
+static char *
+storeHashDirSwapLogFile(SwapDir * sd, const char *ext)
+{
+    LOCAL_ARRAY(char, path, SQUID_MAXPATHLEN);
+    LOCAL_ARRAY(char, pathtmp, SQUID_MAXPATHLEN);
+    LOCAL_ARRAY(char, digit, 32);
+    char *pathtmp2;
+    if (Config.Log.swap) {
+	xstrncpy(pathtmp, sd->path, SQUID_MAXPATHLEN - 64);
+	while (index(pathtmp, '/'))
+	    *index(pathtmp, '/') = '.';
+	while (strlen(pathtmp) && pathtmp[strlen(pathtmp) - 1] == '.')
+	    pathtmp[strlen(pathtmp) - 1] = '\0';
+	for (pathtmp2 = pathtmp; *pathtmp2 == '.'; pathtmp2++);
+	snprintf(path, SQUID_MAXPATHLEN - 64, Config.Log.swap, pathtmp2);
+	if (strncmp(path, Config.Log.swap, SQUID_MAXPATHLEN - 64) == 0) {
+	    strcat(path, ".");
+	    snprintf(digit, 32, "%02d", sd->index);
+	    strncat(path, digit, 3);
+	}
+    } else {
+	xstrncpy(path, sd->path, SQUID_MAXPATHLEN - 64);
+	strcat(path, "/swap.state");
+    }
+    if (ext)
+	strncat(path, ext, 16);
+    return path;
+}
+
+static void
+storeHashDirOpenSwapLog(SwapDir * sd)
+{
+    hashinfo_t *hashinfo = (hashinfo_t *) sd->fsdata;
+    char *path;
+    int fd;
+    path = storeHashDirSwapLogFile(sd, NULL);
+    fd = file_open(path, O_WRONLY | O_CREAT);
+    if (fd < 0) {
+	debug(50, 1) ("%s: %s\n", path, xstrerror());
+	fatal("storeHashDirOpenSwapLog: Failed to open swap log.");
+    }
+    debug(47, 3) ("Cache Dir #%d log opened on FD %d\n", sd->index, fd);
+    hashinfo->swaplog_fd = fd;
+    if (0 == n_hash_dirs)
+	assert(NULL == hash_dir_index);
+    n_hash_dirs++;
+    assert(n_hash_dirs <= Config.cacheSwap.n_configured);
+}
+
+static void
+storeHashDirInit(SwapDir * sd)
+{
+    static int started_clean_event = 0;
+    storeHashDirInitBitmap(sd);
+    storeHashDirOpenSwapLog(sd);
+    if (!started_clean_event) {
+	eventAdd("storeHashDirClean", storeHashDirCleanEvent, NULL, 15.0, 1);
+        /* we can't call the rebuild completion routine until the next loop */
+        eventAdd("storeHashRebuild", storeHashDirRebuildEvent, NULL, 0.0, 1);
+	started_clean_event = 1;
+    }
+}
+
+
+struct _clean_state {
+    char *cur;
+    char *new;
+    char *cln;
+    char *outbuf;
+    off_t outbuf_offset;
+    int fd;
+    RemovalPolicyWalker *walker;
+};
+
+static void
+storeHashDirNewfs(SwapDir * sd)
+{
+    debug(47, 3) ("Creating swap space in %s\n", sd->path);
+    storeHashDirCreateDirectory(sd->path, 0);
+}
+
+static void
+storeHashDirCleanEvent(void *unused)
+{
+    /* Empty for now */
+#if 0
+    eventAdd("storeDirClean", storeHashDirCleanEvent, NULL,
+	15.0 * exp(-0.25 * n), 1);
+#endif
+}
+
+static void
+storeHashDirRebuildEvent(void *data)
+{
+    SwapDir *sd = data;
+
+    struct _store_rebuild_data sr;
+
+    /* feed it an empty rebuild, cause we're empty! */
+    bzero(&sr, sizeof(struct _store_rebuild_data));
+    storeRebuildComplete(&sr);
+}
+
+void
+storeHashDirMaintain(SwapDir * SD)
+{
+    /* Do nothing for now */
+    return;
+}
+
+/*
+ * storeHashDirCheckObj
+ *
+ * This routine is called by storeDirSelectSwapDir to see if the given
+ * object is able to be stored on this filesystem. HASH filesystems will
+ * happily store anything as long as the LRU time isn't too small.
+ */
+int
+storeHashDirCheckObj(SwapDir * SD, const StoreEntry * e)
+{
+#if OLD_UNUSED_CODE
+    if (storeHashDirExpiredReferenceAge(SD) < 300) {
+	debug(20, 3) ("storeHashDirCheckObj: NO: LRU Age = %d\n",
+	    storeHashDirExpiredReferenceAge(SD));
+	/* store_check_cachable_hist.no.lru_age_too_low++; */
+	return -1;
+    }
+#endif
+    /* Return 999 (99.9%) constant load */
+    return 999;
+}
+
+/*
+ * storeHashDirRefObj
+ *
+ * This routine is called whenever an object is referenced, so we can
+ * maintain replacement information within the storage fs.
+ */
+void
+storeHashDirRefObj(SwapDir * SD, StoreEntry * e)
+{
+    debug(1, 3) ("storeHashDirRefObj: referencing %p %d/%d\n", e, e->swap_dirn,
+	e->swap_filen);
+    if (SD->repl->Referenced)
+	SD->repl->Referenced(SD->repl, e, &e->repl);
+}
+
+/*
+ * storeHashDirUnrefObj
+ * This routine is called whenever the last reference to an object is
+ * removed, to maintain replacement information within the storage fs.
+ */
+void
+storeHashDirUnrefObj(SwapDir * SD, StoreEntry * e)
+{
+    debug(1, 3) ("storeHashDirUnrefObj: referencing %p %d/%d\n", e, e->swap_dirn,
+	e->swap_filen);
+    if (SD->repl->Dereferenced)
+	SD->repl->Dereferenced(SD->repl, e, &e->repl);
+}
+
+/*
+ * storeHashDirUnlinkFile
+ *
+ * This routine unlinks a file and pulls it out of the bitmap.
+ * It used to be in storeHashUnlink(), however an interface change
+ * forced this bit of code here. Eeek.
+ */
+void
+storeHashDirUnlinkFile(SwapDir * SD, sfileno f)
+{
+    debug(79, 3) ("storeHashDirUnlinkFile: unlinking fileno %08X\n", f);
+    /* storeHashDirMapBitReset(SD, f); */
+#if 0
+    unlinkdUnlink(storeHashDirFullPath(SD, f, NULL));
+#endif
+}
+
+/*
+ * Add and remove the given StoreEntry from the replacement policy in
+ * use.
+ */
+
+void
+storeHashDirReplAdd(SwapDir * SD, StoreEntry * e)
+{
+    debug(20, 4) ("storeHashDirReplAdd: added node %p to dir %d\n", e,
+	SD->index);
+    SD->repl->Add(SD->repl, e, &e->repl);
+}
+
+
+void
+storeHashDirReplRemove(StoreEntry * e)
+{
+    SwapDir *SD = INDEXSD(e->swap_dirn);
+    debug(20, 4) ("storeHashDirReplRemove: remove node %p from dir %d\n", e,
+	SD->index);
+    SD->repl->Remove(SD->repl, e, &e->repl);
+}
+
+
+
+/* ========== LOCAL FUNCTIONS ABOVE, GLOBAL FUNCTIONS BELOW ========== */
+
+void
+storeHashDirStats(SwapDir * SD, StoreEntry * sentry)
+{
+    hashinfo_t *hashinfo;
+#if HAVE_STATVFS
+    struct statvfs sfs;
+#endif
+    hashinfo = (hashinfo_t *) SD->fsdata;
+    storeAppendPrintf(sentry, "Maximum Size: %d KB\n", SD->max_size);
+    storeAppendPrintf(sentry, "Current Size: %d KB\n", SD->cur_size);
+    storeAppendPrintf(sentry, "Percent Used: %0.2f%%\n",
+	100.0 * SD->cur_size / SD->max_size);
+    storeAppendPrintf(sentry, "Filemap bits in use: %d of %d (%d%%)\n",
+	hashinfo->map->n_files_in_map, hashinfo->map->max_n_files,
+	percent(hashinfo->map->n_files_in_map, hashinfo->map->max_n_files));
+#if HAVE_STATVFS
+#define fsbtoblk(num, fsbs, bs) \
+    (((fsbs) != 0 && (fsbs) < (bs)) ? \
+            (num) / ((bs) / (fsbs)) : (num) * ((fsbs) / (bs)))
+    if (!statvfs(SD->path, &sfs)) {
+	storeAppendPrintf(sentry, "Filesystem Space in use: %d/%d KB (%d%%)\n",
+	    fsbtoblk((sfs.f_blocks - sfs.f_bfree), sfs.f_frsize, 1024),
+	    fsbtoblk(sfs.f_blocks, sfs.f_frsize, 1024),
+	    percent(sfs.f_blocks - sfs.f_bfree, sfs.f_blocks));
+	storeAppendPrintf(sentry, "Filesystem Inodes in use: %d/%d (%d%%)\n",
+	    sfs.f_files - sfs.f_ffree, sfs.f_files,
+	    percent(sfs.f_files - sfs.f_ffree, sfs.f_files));
+    }
+#endif
+    storeAppendPrintf(sentry, "Flags:");
+    if (SD->flags.selected)
+	storeAppendPrintf(sentry, " SELECTED");
+    if (SD->flags.read_only)
+	storeAppendPrintf(sentry, " READ-ONLY");
+    storeAppendPrintf(sentry, "\n");
+#if OLD_UNUSED_CODE
+#if !HEAP_REPLACEMENT
+    storeAppendPrintf(sentry, "LRU Expiration Age: %6.2f days\n",
+	(double) storeHashDirExpiredReferenceAge(SD) / 86400.0);
+#else
+    storeAppendPrintf(sentry, "Storage Replacement Threshold:\t%f\n",
+	heap_peepminkey(sd.repl.heap.heap));
+#endif
+#endif /* OLD_UNUSED_CODE */
+}
+
+/*
+ * storeHashDirReconfigure
+ *
+ * This routine is called when the given swapdir needs reconfiguring 
+ */
+void
+storeHashDirReconfigure(SwapDir * sd, int index, char *path)
+{
+    char *token;
+    int i;
+    int size;
+    int l1;
+    int l2;
+    unsigned int read_only = 0;
+
+    i = GetInteger();
+    size = i << 10;		/* Mbytes to kbytes */
+    if (size <= 0)
+	fatal("storeHashDirReconfigure: invalid size value");
+    i = GetInteger();
+    l1 = i;
+    if (l1 <= 0)
+	fatal("storeHashDirReconfigure: invalid level 1 directories value");
+    i = GetInteger();
+    l2 = i;
+    if (l2 <= 0)
+	fatal("storeHashDirReconfigure: invalid level 2 directories value");
+    if ((token = strtok(NULL, w_space)))
+	if (!strcasecmp(token, "read-only"))
+	    read_only = 1;
+
+    /* just reconfigure it */
+    if (size == sd->max_size)
+	debug(3, 1) ("Cache dir '%s' size remains unchanged at %d KB\n",
+	    path, size);
+    else
+	debug(3, 1) ("Cache dir '%s' size changed to %d KB\n",
+	    path, size);
+    sd->max_size = size;
+    if (sd->flags.read_only != read_only)
+	debug(3, 1) ("Cache dir '%s' now %s\n",
+	    path, read_only ? "Read-Only" : "Read-Write");
+    sd->flags.read_only = read_only;
+    return;
+}
+
+void
+storeHashDirDump(StoreEntry * entry, const char *name, SwapDir * s)
+{
+    storeAppendPrintf(entry, "%s %s %s %d\n",
+	name,
+	"hash",
+	s->path,
+	s->max_size >> 10);
+}
+
+/*
+ * Only "free" the filesystem specific stuff here
+ */
+static void
+storeHashDirFree(SwapDir * s)
+{
+    hashinfo_t *hashinfo = (hashinfo_t *) s->fsdata;
+    if (hashinfo->swaplog_fd > -1) {
+	file_close(hashinfo->swaplog_fd);
+	hashinfo->swaplog_fd = -1;
+    }
+    filemapFreeMemory(hashinfo->map);
+    xfree(hashinfo);
+    s->fsdata = NULL;		/* Will aid debugging... */
+
+}
+
+/*
+ * storeHashCleanupDoubleCheck
+ *
+ * This is called by storeCleanup() if -S was given on the command line.
+ */
+static int
+storeHashCleanupDoubleCheck(SwapDir * sd, StoreEntry * e)
+{
+    struct stat sb;
+#if 0
+    if (stat(storeHashDirFullPath(sd, e->swap_filen, NULL), &sb) < 0) {
+	debug(20, 0) ("storeHashCleanupDoubleCheck: MISSING SWAP FILE\n");
+	debug(20, 0) ("storeHashCleanupDoubleCheck: FILENO %08X\n", e->swap_filen);
+	debug(20, 0) ("storeHashCleanupDoubleCheck: PATH %s\n",
+	    storeHashDirFullPath(sd, e->swap_filen, NULL));
+	storeEntryDump(e, 0);
+	return -1;
+    }
+    if (e->swap_file_sz != sb.st_size) {
+	debug(20, 0) ("storeHashCleanupDoubleCheck: SIZE MISMATCH\n");
+	debug(20, 0) ("storeHashCleanupDoubleCheck: FILENO %08X\n", e->swap_filen);
+	debug(20, 0) ("storeHashCleanupDoubleCheck: PATH %s\n",
+	    storeHashDirFullPath(sd, e->swap_filen, NULL));
+	debug(20, 0) ("storeHashCleanupDoubleCheck: ENTRY SIZE: %d, FILE SIZE: %d\n",
+	    e->swap_file_sz, (int) sb.st_size);
+	storeEntryDump(e, 0);
+	return -1;
+    }
+#endif
+    return 0;
+}
+
+/*
+ * storeHashDirParse
+ *
+ * Called when a *new* fs is being setup.
+ */
+void
+storeHashDirParse(SwapDir * sd, int index, char *path)
+{
+    char *token;
+    int i;
+    int size;
+    unsigned int read_only = 0;
+    hashinfo_t *hashinfo;
+
+    i = GetInteger();
+    size = i << 10;		/* Mbytes to kbytes */
+    if (size <= 0)
+	fatal("storeHashDirParse: invalid size value");
+    if ((token = strtok(NULL, w_space)))
+	if (!strcasecmp(token, "read-only"))
+	    read_only = 1;
+
+    hashinfo = xmalloc(sizeof(hashinfo_t));
+    if (hashinfo == NULL)
+	fatal("storeHashDirParse: couldn't xmalloc() hashinfo_t!\n");
+
+    sd->index = index;
+    sd->path = xstrdup(path);
+    sd->max_size = size;
+    sd->fsdata = hashinfo;
+    hashinfo->swaplog_fd = -1;
+    hashinfo->map = NULL;	/* Debugging purposes */
+    hashinfo->suggest = 0;
+    sd->flags.read_only = read_only;
+    sd->init = storeHashDirInit;
+    sd->newfs = storeHashDirNewfs;
+    sd->dump = storeHashDirDump;
+    sd->freefs = storeHashDirFree;
+    sd->dblcheck = storeHashCleanupDoubleCheck;
+    sd->statfs = storeHashDirStats;
+    sd->maintainfs = storeHashDirMaintain;
+    sd->checkobj = storeHashDirCheckObj;
+    sd->refobj = storeHashDirRefObj;
+    sd->unrefobj = storeHashDirUnrefObj;
+    sd->callback = NULL;
+    sd->sync = NULL;
+
+    sd->obj.get = storeHashGet;
+    sd->obj.close = storeHashClose;
+    sd->obj.read = storeHashRead;
+    sd->obj.write = storeHashWrite;
+    sd->obj.unlink = storeHashUnlink;
+    sd->log.open = NULL;
+    sd->log.close = NULL;
+    sd->log.write = NULL;
+    sd->log.clean.start = NULL;
+    sd->log.clean.nextentry = NULL;
+    sd->log.clean.done = NULL;
+
+    /* Initialise replacement policy stuff */
+    sd->repl = createRemovalPolicy(Config.replPolicy);
+}
+
+/*
+ * Initial setup / end destruction
+ */
+void
+storeHashDirDone(void)
+{
+    memPoolDestroy(hash_state_pool);
+    hash_initialised = 0;
+}
+
+void
+storeFsSetup_hash(storefs_entry_t * storefs)
+{
+    assert(!hash_initialised);
+    storefs->parsefunc = storeHashDirParse;
+    storefs->reconfigurefunc = storeHashDirReconfigure;
+    storefs->donefunc = storeHashDirDone;
+    hash_state_pool = memPoolCreate("HASH IO State data", sizeof(hashstate_t));
+    hash_initialised = 1;
+}
Index: squid/src/fs/hash/store_hash.h
diff -u /dev/null squid/src/fs/hash/store_hash.h:1.1.2.4
--- /dev/null	Sun Jan 25 06:37:04 2004
+++ squid/src/fs/hash/store_hash.h	Sat Jan  6 06:35:57 2001
@@ -0,0 +1,48 @@
+/*
+ * store_hash.h
+ *
+ * Internal declarations for the hash routines
+ */
+
+#ifndef __STORE_HASH_H__
+#define __STORE_HASH_H__
+
+struct _hashinfo_t {
+    int swaplog_fd;
+    fileMap *map;
+    int suggest;
+};
+
+struct _hashstate_t {
+    int fd;
+    struct {
+	unsigned int close_request:1;
+	unsigned int reading:1;
+	unsigned int writing:1;
+    } flags;
+};
+
+typedef struct _hashinfo_t hashinfo_t;
+typedef struct _hashstate_t hashstate_t;
+
+/* The hash_state memory pool */
+extern MemPool *hash_state_pool;
+
+extern void storeHashDirMapBitReset(SwapDir *, sfileno);
+extern int storeHashDirMapBitAllocate(SwapDir *);
+extern char *storeHashDirFullPath(SwapDir * SD, const char *uri, 
+  const method_t method, char *fullpath);
+extern void storeHashDirUnlinkFile(SwapDir *, sfileno);
+extern void storeHashDirReplAdd(SwapDir * SD, StoreEntry *);
+extern void storeHashDirReplRemove(StoreEntry *);
+
+/*
+ * Store IO stuff
+ */
+extern STOBJGET storeHashGet;
+extern STOBJCLOSE storeHashClose;
+extern STOBJREAD storeHashRead;
+extern STOBJWRITE storeHashWrite;
+extern STOBJUNLINK storeHashUnlink;
+
+#endif
Index: squid/src/fs/hash/store_io_hash.c
diff -u /dev/null squid/src/fs/hash/store_io_hash.c:1.1.2.6
--- /dev/null	Sun Jan 25 06:37:04 2004
+++ squid/src/fs/hash/store_io_hash.c	Sun Mar 18 14:51:22 2001
@@ -0,0 +1,283 @@
+
+/*
+ * $Id: squid-modio-HEAD,v 1.1 2004/08/17 20:55:12 hno Exp $
+ *
+ * DEBUG: section 79    Storage Manager HASH Interface
+ * AUTHOR: Duane Wessels
+ *
+ * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
+ * ----------------------------------------------------------
+ *
+ *  Squid is the result of efforts by numerous individuals from the
+ *  Internet community.  Development is led by Duane Wessels of the
+ *  National Laboratory for Applied Network Research and funded by the
+ *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
+ *  Duane Wessels and the University of California San Diego.  Please
+ *  see the COPYRIGHT file for full details.  Squid incorporates
+ *  software developed and/or copyrighted by other sources.  Please see
+ *  the CREDITS file for full details.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
+ *
+ */
+
+#include "squid.h"
+#include "store_hash.h"
+
+
+static DRCB storeHashReadDone;
+static DWCB storeHashWriteDone;
+static void storeHashIOCallback(storeIOState * sio, int errflag);
+static void storeHashIOFreeEntry(void *);
+
+CBDATA_TYPE(storeIOState);
+
+/* === PUBLIC =========================================================== */
+
+void
+storeHashGet(SwapDir *sd, request_t *request, STGETDONE *callback,
+    void *callback_data)
+{
+    /* Empty for now , return NULL */
+    storeLookupComplete(request, callback, callback_data, NULL);
+}
+
+storeIOState *
+storeHashOpen(SwapDir * SD, StoreEntry * e, STFNCB * file_callback,
+    STIOCB * callback, void *callback_data)
+{
+    sfileno f = e->swap_filen;
+#if 0
+    char *path = storeHashDirFullPath(SD, f, NULL);
+#endif
+    char *path;
+    storeIOState *sio;
+    struct stat sb;
+    int fd;
+    debug(79, 3) ("storeHashOpen: fileno %08X\n", f);
+    fd = file_open(path, O_RDONLY);
+    if (fd < 0) {
+	debug(79, 3) ("storeHashOpen: got failure (%d)\n", errno);
+	return NULL;
+    }
+    debug(79, 3) ("storeHashOpen: opened FD %d\n", fd);
+    CBDATA_INIT_TYPE_FREECB(storeIOState, storeHashIOFreeEntry);
+    sio = cbdataAlloc(storeIOState);
+    sio->fsstate = memPoolAlloc(hash_state_pool);
+
+    sio->swap_filen = f;
+    sio->swap_dirn = SD->index;
+    sio->mode = O_RDONLY;
+    sio->callback = callback;
+    sio->callback_data = callback_data;
+    cbdataLock(callback_data);
+    sio->e = e;
+    ((hashstate_t *) (sio->fsstate))->fd = fd;
+    ((hashstate_t *) (sio->fsstate))->flags.writing = 0;
+    ((hashstate_t *) (sio->fsstate))->flags.reading = 0;
+    ((hashstate_t *) (sio->fsstate))->flags.close_request = 0;
+    if (fstat(fd, &sb) == 0)
+	sio->st_size = sb.st_size;
+    store_open_disk_fd++;
+
+    /* We should update the heap/dlink position here ! */
+    return sio;
+}
+
+storeIOState *
+storeHashCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data)
+{
+    storeIOState *sio;
+    int fd;
+    int mode = (O_WRONLY | O_CREAT | O_TRUNC);
+    char *path;
+    hashinfo_t *hashinfo = (hashinfo_t *) SD->fsdata;
+    sfileno filn;
+    sdirno dirn;
+
+    /* Allocate a number */
+    dirn = SD->index;
+    filn = storeHashDirMapBitAllocate(SD);
+    hashinfo->suggest = filn + 1;
+    /* Shouldn't we handle a 'bitmap full' error here? */
+#if 0
+    path = storeHashDirFullPath(SD, filn, NULL);
+#endif
+
+    debug(79, 3) ("storeHashCreate: fileno %08X\n", filn);
+    fd = file_open(path, mode);
+    if (fd < 0) {
+	debug(79, 3) ("storeHashCreate: got failure (%d)\n", errno);
+	return NULL;
+    }
+    debug(79, 3) ("storeHashCreate: opened FD %d\n", fd);
+    CBDATA_INIT_TYPE_FREECB(storeIOState, storeHashIOFreeEntry);
+    sio = cbdataAlloc(storeIOState);
+    sio->fsstate = memPoolAlloc(hash_state_pool);
+
+    sio->swap_filen = filn;
+    sio->swap_dirn = dirn;
+    sio->mode = mode;
+    sio->callback = callback;
+    sio->callback_data = callback_data;
+    cbdataLock(callback_data);
+    sio->e = (StoreEntry *) e;
+    ((hashstate_t *) (sio->fsstate))->fd = fd;
+    ((hashstate_t *) (sio->fsstate))->flags.writing = 0;
+    ((hashstate_t *) (sio->fsstate))->flags.reading = 0;
+    ((hashstate_t *) (sio->fsstate))->flags.close_request = 0;
+    store_open_disk_fd++;
+
+    /* now insert into the replacement policy */
+    storeHashDirReplAdd(SD, e);
+    return sio;
+}
+
+void
+storeHashClose(SwapDir * SD, storeIOState * sio)
+{
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+
+    debug(79, 3) ("storeHashClose: dirno %d, fileno %08X, FD %d\n",
+	sio->swap_dirn, sio->swap_filen, hashstate->fd);
+    if (hashstate->flags.reading || hashstate->flags.writing) {
+	hashstate->flags.close_request = 1;
+	return;
+    }
+    storeHashIOCallback(sio, 0);
+}
+
+void
+storeHashRead(SwapDir * SD, storeIOState * sio, char *buf, size_t size, off_t offset, STRCB * callback, void *callback_data)
+{
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+
+    assert(sio->read.callback == NULL);
+    assert(sio->read.callback_data == NULL);
+    sio->read.callback = callback;
+    sio->read.callback_data = callback_data;
+    cbdataLock(callback_data);
+    debug(79, 3) ("storeHashRead: dirno %d, fileno %08X, FD %d\n",
+	sio->swap_dirn, sio->swap_filen, hashstate->fd);
+    sio->offset = offset;
+    hashstate->flags.reading = 1;
+    file_read(hashstate->fd,
+	buf,
+	size,
+	offset,
+	storeHashReadDone,
+	sio);
+}
+
+void
+storeHashWrite(SwapDir * SD, storeIOState * sio, char *buf, size_t size, off_t offset, FREE * free_func)
+{
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+    debug(79, 3) ("storeHashWrite: dirn %d, fileno %08X, FD %d\n", sio->swap_dirn, sio->swap_filen, hashstate->fd);
+    hashstate->flags.writing = 1;
+    file_write(hashstate->fd,
+	offset,
+	buf,
+	size,
+	storeHashWriteDone,
+	sio,
+	free_func);
+}
+
+void
+storeHashUnlink(SwapDir * SD, StoreEntry * e)
+{
+    debug(79, 3) ("storeHashUnlink: fileno %08X\n", e->swap_filen);
+    storeHashDirReplRemove(e);
+    storeHashDirMapBitReset(SD, e->swap_filen);
+    storeHashDirUnlinkFile(SD, e->swap_filen);
+}
+
+/*  === STATIC =========================================================== */
+
+static void
+storeHashReadDone(int fd, const char *buf, int len, int errflag, void *my_data)
+{
+    storeIOState *sio = my_data;
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+    STRCB *callback = sio->read.callback;
+    void *their_data = sio->read.callback_data;
+    ssize_t rlen;
+
+    debug(79, 3) ("storeHashReadDone: dirno %d, fileno %08X, FD %d, len %d\n",
+	sio->swap_dirn, sio->swap_filen, fd, len);
+    hashstate->flags.reading = 0;
+    if (errflag) {
+	debug(79, 3) ("storeHashReadDone: got failure (%d)\n", errflag);
+	rlen = -1;
+    } else {
+	rlen = (ssize_t) len;
+	sio->offset += len;
+    }
+    assert(callback);
+    assert(their_data);
+    sio->read.callback = NULL;
+    sio->read.callback_data = NULL;
+    if (cbdataValid(their_data))
+	callback(their_data, buf, (size_t) rlen);
+    cbdataUnlock(their_data);
+}
+
+static void
+storeHashWriteDone(int fd, int errflag, size_t len, void *my_data)
+{
+    storeIOState *sio = my_data;
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+    debug(79, 3) ("storeHashWriteDone: dirno %d, fileno %08X, FD %d, len %d\n",
+	sio->swap_dirn, sio->swap_filen, fd, len);
+    hashstate->flags.writing = 0;
+    if (errflag) {
+	debug(79, 0) ("storeHashWriteDone: got failure (%d)\n", errflag);
+	storeHashIOCallback(sio, errflag);
+	return;
+    }
+    sio->offset += len;
+    if (hashstate->flags.close_request)
+	storeHashIOCallback(sio, errflag);
+}
+
+static void
+storeHashIOCallback(storeIOState * sio, int errflag)
+{
+    hashstate_t *hashstate = (hashstate_t *) sio->fsstate;
+    debug(79, 3) ("storeHashIOCallback: errflag=%d\n", errflag);
+    if (hashstate->fd > -1) {
+	file_close(hashstate->fd);
+	store_open_disk_fd--;
+    }
+    if (cbdataValid(sio->callback_data))
+	sio->callback(sio->callback_data, errflag, sio);
+    cbdataUnlock(sio->callback_data);
+    sio->callback_data = NULL;
+    sio->callback = NULL;
+    cbdataFree(sio);
+}
+
+
+/*
+ * We can't pass memFree() as a free function here, because we need to free
+ * the fsstate variable ..
+ */
+static void
+storeHashIOFreeEntry(void *sio)
+{
+    memPoolFree(hash_state_pool, ((storeIOState *) sio)->fsstate);
+    memFree(sio, MEM_STORE_IO);
+}
squid-modio-HEAD.new squid-modio-HEAD differ: char 65, line 2
