#include "Generic.h"
#include "globals.h"
#include "HttpReply.h"
-#include "HttpRequest.h"
#include "MemBuf.h"
#include "MemObject.h"
#include "profiler/Profiler.h"
HTTPMSGUNLOCK(_reply);
- HTTPMSGUNLOCK(request);
-
ctx_exit(ctx); /* must exit before we free mem->url */
}
-void
-MemObject::unlinkRequest()
-{
- HTTPMSGUNLOCK(request);
-}
-
void
MemObject::write(const StoreIOBuffer &writeBuffer)
{
#include "dlink.h"
#include "http/RequestMethod.h"
#include "RemovalPolicy.h"
-#include "sbuf/SBuf.h"
#include "SquidString.h"
#include "stmem.h"
#include "StoreIOBuffer.h"
typedef void STABH(void *);
class store_client;
-class HttpRequest;
-class HttpReply;
class MemObject
{
bool hasUris() const;
void write(const StoreIOBuffer &buf);
- void unlinkRequest();
+ void unlinkRequest() { request = nullptr; }
HttpReply const *getReply() const;
void replaceHttpReply(HttpReply *newrep);
void stat (MemBuf * mb) const;
/* Read only - this reply must be preserved by store clients */
/* The original reply. possibly with updated metadata. */
- HttpRequest *request;
+ HttpRequestPointer request;
struct timeval start_ping;
IRCB *ping_reply_callback;
findPreviouslyCachedEntry(StoreEntry *newEntry) {
assert(newEntry->mem_obj);
return newEntry->mem_obj->request ?
- storeGetPublicByRequest(newEntry->mem_obj->request) :
+ storeGetPublicByRequest(newEntry->mem_obj->request.getRaw()) :
storeGetPublic(newEntry->mem_obj->storeId(), newEntry->mem_obj->method);
}
if (pe != NULL) {
assert(e != pe);
#if USE_HTCP
- neighborsHtcpClear(e, NULL, e->mem_obj->request, e->mem_obj->method, HTCP_CLR_INVALIDATION);
+ neighborsHtcpClear(e, nullptr, e->mem_obj->request.getRaw(), e->mem_obj->method, HTCP_CLR_INVALIDATION);
#endif
pe->release();
}
* changed.
*/
if (e->mem_obj->request)
- pe = storeGetPublicByRequestMethod(e->mem_obj->request, Http::METHOD_HEAD);
+ pe = storeGetPublicByRequestMethod(e->mem_obj->request.getRaw(), Http::METHOD_HEAD);
else
pe = storeGetPublic(e->mem_obj->storeId(), Http::METHOD_HEAD);
if (pe != NULL) {
assert(e != pe);
#if USE_HTCP
- neighborsHtcpClear(e, NULL, e->mem_obj->request, HttpRequestMethod(Http::METHOD_HEAD), HTCP_CLR_INVALIDATION);
+ neighborsHtcpClear(e, nullptr, e->mem_obj->request.getRaw(), HttpRequestMethod(Http::METHOD_HEAD), HTCP_CLR_INVALIDATION);
#endif
pe->release();
}
if (!p->options.mcast_responder)
return 0;
- if (peerHTTPOkay(p, mem->request))
+ if (peerHTTPOkay(p, mem->request.getRaw()))
return 0;
return 1;
cbdataReferenceDone(psstate->callback_data);
fake->abort(); // sets ENTRY_ABORTED and initiates releated cleanup
- HTTPMSGUNLOCK(fake->mem_obj->request);
+ fake->mem_obj->request = nullptr;
fake->unlock("peerCountMcastPeersDone");
delete psstate;
}
refreshCheckDigest(const StoreEntry * entry, time_t delta)
{
int reason = refreshCheck(entry,
- entry->mem_obj ? entry->mem_obj->request : NULL,
+ entry->mem_obj ? entry->mem_obj->request.getRaw() : nullptr,
delta);
++ refreshCounts[rcCDigest].total;
++ refreshCounts[rcCDigest].status[reason];
#include "squid.h"
#include "Generic.h"
+#include "HttpRequest.h"
#include "mem_node.h"
#include "MemObject.h"
#include "profiler/Profiler.h"
StoreEntry::calcPublicKey(const KeyScope keyScope)
{
assert(mem_obj);
- return mem_obj->request ? storeKeyPublicByRequest(mem_obj->request, keyScope) :
+ return mem_obj->request ? storeKeyPublicByRequest(mem_obj->request.getRaw(), keyScope) :
storeKeyPublic(mem_obj->storeId(), mem_obj->method, keyScope);
}
if (!mem_obj->request)
return;
- HttpRequest *request = mem_obj->request;
+ HttpRequestPointer request(mem_obj->request);
if (mem_obj->vary_headers.isEmpty()) {
/* First handle the case where the object no longer varies */
/* Make sure the request knows the variance status */
if (request->vary_headers.isEmpty())
- request->vary_headers = httpMakeVaryMark(request, mem_obj->getReply());
+ request->vary_headers = httpMakeVaryMark(request.getRaw(), mem_obj->getReply());
}
// TODO: storeGetPublic() calls below may create unlocked entries.
#define SQUID_STORE_KEY_MD5_H_
#include "hash.h"
+#include "http/forward.h"
#include "store/forward.h"
-class HttpRequestMethod;
-class HttpRequest;
-
typedef enum {
ksDefault = 0,
ksRevalidation
#if USE_DELAY_POOLS
DelayId MemObject::mostBytesAllowed() const STUB_RETVAL(DelayId())
#endif
-void MemObject::unlinkRequest() STUB
void MemObject::write(const StoreIOBuffer &writeBuffer) STUB
void MemObject::replaceHttpReply(HttpReply *newrep) STUB
int64_t MemObject::lowestMemReaderOffset() const STUB_RETVAL(0)
#include "squid.h"
#include "base/CharacterSet.h"
+#include "HttpRequest.h"
#include "sbuf/Algorithms.h"
#include "sbuf/SBuf.h"
#include "sbuf/Stream.h"