/*
- * $Id: ACLChecklist.h,v 1.15 2003/08/04 22:14:38 robertc Exp $
+ * $Id: ACLChecklist.h,v 1.16 2003/08/10 11:00:40 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
struct in_addr my_addr;
unsigned short my_port;
- request_t *request;
+ HttpRequest *request;
/* for acls that look at reply data */
HttpReply *reply;
char rfc931[USER_IDENT_SZ];
};
SQUIDCEXTERN ACLChecklist *aclChecklistCreate(const acl_access *,
- request_t *,
+ HttpRequest *,
const char *ident);
SQUIDCEXTERN int aclCheckFast(const acl_access *A, ACLChecklist *);
/*
- * $Id: DelayId.cc,v 1.12 2003/07/11 01:40:34 robertc Exp $
+ * $Id: DelayId.cc,v 1.13 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 77 Delay Pools
* AUTHOR: Robert Collins <robertc@squid-cache.org>
DelayId
DelayId::DelayClient(clientHttpRequest * http)
{
- request_t *r;
+ HttpRequest *r;
unsigned short pool;
assert(http);
r = http->request;
/*
- * $Id: ESI.cc,v 1.5 2003/08/04 22:14:40 robertc Exp $
+ * $Id: ESI.cc,v 1.6 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 86 ESI processing
* AUTHOR: Robert Collins
/* don't touch incoming, it's a pointer into buffered anyway */
}
-extern ErrorState *clientBuildError (err_type, http_status, char const *, struct in_addr *, request_t *);
+extern ErrorState *clientBuildError (err_type, http_status, char const *, struct in_addr *, HttpRequest *);
/* This can ONLY be used before we have sent *any* data to the client */
/*
- * $Id: HttpHeaderTools.cc,v 1.43 2003/07/23 10:41:20 robertc Exp $
+ * $Id: HttpHeaderTools.cc,v 1.44 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 66 HTTP Header Tools
* AUTHOR: Alex Rousskov
* Returns 1 if the header is allowed.
*/
static int
-httpHdrMangle(HttpHeaderEntry * e, request_t * request)
+httpHdrMangle(HttpHeaderEntry * e, HttpRequest * request)
{
int retval;
/* Mangles headers for a list of headers. */
void
-httpHdrMangleList(HttpHeader * l, request_t * request)
+httpHdrMangleList(HttpHeader * l, HttpRequest * request)
{
HttpHeaderEntry *e;
HttpHeaderPos p = HttpHeaderInitPos;
/*
- * $Id: HttpRequest.cc,v 1.42 2003/08/04 22:14:40 robertc Exp $
+ * $Id: HttpRequest.cc,v 1.43 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 73 HTTP Request
* AUTHOR: Duane Wessels
#include "authenticate.h"
#include "HttpHeaderRange.h"
-static void httpRequestHdrCacheInit(request_t * req);
+static void httpRequestHdrCacheInit(HttpRequest * req);
MemPool (*HttpRequest::Pool)(NULL);
void *
#endif
}
-request_t *
+HttpRequest *
requestCreate(method_t method, protocol_t protocol, const char *aUrlpath)
{
- request_t *req = new HttpRequest;
+ HttpRequest *req = new HttpRequest;
req->method = method;
req->protocol = protocol;
}
void
-requestDestroy(request_t * req)
+requestDestroy(HttpRequest * req)
{
assert(req);
delete req;
}
-request_t *
-requestLink(request_t * request)
+HttpRequest *
+requestLink(HttpRequest * request)
{
assert(request);
request->link_count++;
}
void
-requestUnlink(request_t * request)
+requestUnlink(HttpRequest * request)
{
if (!request)
return;
}
int
-httpRequestParseHeader(request_t * req, const char *parse_start)
+httpRequestParseHeader(HttpRequest * req, const char *parse_start)
{
const char *blk_start, *blk_end;
/* swaps out request using httpRequestPack */
void
-httpRequestSwapOut(const request_t * req, StoreEntry * e)
+httpRequestSwapOut(const HttpRequest * req, StoreEntry * e)
{
Packer p;
assert(req && e);
/* packs request-line and headers, appends <crlf> terminator */
void
-httpRequestPack(const request_t * req, Packer * p)
+httpRequestPack(const HttpRequest * req, Packer * p)
{
assert(req && p);
/* pack request-line */
#if UNUSED_CODE
void
-httpRequestSetHeaders(request_t * req, method_t method, const char *uri, const char *header_str)
+httpRequestSetHeaders(HttpRequest * req, method_t method, const char *uri, const char *header_str)
{
assert(req && uri && header_str);
assert(!req->header.len);
/* returns the length of request line + headers + crlf */
int
-httpRequestPrefixLen(const request_t * req)
+httpRequestPrefixLen(const HttpRequest * req)
{
assert(req);
return strlen(RequestMethodStr[req->method]) + 1 +
return 1;
}
-/* sync this routine when you update request_t struct */
+/* sync this routine when you update HttpRequest struct */
static void
-httpRequestHdrCacheInit(request_t * req)
+httpRequestHdrCacheInit(HttpRequest * req)
{
const HttpHeader *hdr = &req->header;
/* const char *str; */
}
bool
-request_t::multipartRangeRequest() const
+HttpRequest::multipartRangeRequest() const
{
return (range && range->specs.count > 1);
}
/*
- * $Id: HttpRequest.h,v 1.6 2003/08/04 22:14:41 robertc Exp $
+ * $Id: HttpRequest.h,v 1.7 2003/08/10 11:00:40 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
#include "client_side.h"
/* Http Request */
-extern request_t *requestCreate(method_t, protocol_t, const char *urlpath);
-extern void requestDestroy(request_t *);
-extern request_t *requestLink(request_t *);
-extern void requestUnlink(request_t *);
-extern int httpRequestParseHeader(request_t * req, const char *parse_start);
-extern void httpRequestSwapOut(const request_t * req, StoreEntry * e);
-extern void httpRequestPack(const request_t * req, Packer * p);
-extern int httpRequestPrefixLen(const request_t * req);
+extern HttpRequest *requestCreate(method_t, protocol_t, const char *urlpath);
+extern void requestDestroy(HttpRequest *);
+extern HttpRequest *requestLink(HttpRequest *);
+extern void requestUnlink(HttpRequest *);
+extern int httpRequestParseHeader(HttpRequest * req, const char *parse_start);
+extern void httpRequestSwapOut(const HttpRequest * req, StoreEntry * e);
+extern void httpRequestPack(const HttpRequest * req, Packer * p);
+extern int httpRequestPrefixLen(const HttpRequest * req);
extern int httpRequestHdrAllowed(const HttpHeaderEntry * e, String * strConnection);
extern int httpRequestHdrAllowedByName(http_hdr_type id);
static MemPool *Pool;
};
-typedef HttpRequest request_t;
-
#endif /* SQUID_HTTPREQUEST_H */
/*
- * $Id: ICP.h,v 1.5 2003/03/09 12:29:40 robertc Exp $
+ * $Id: ICP.h,v 1.6 2003/08/10 11:00:40 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
ICPState(icp_common_t &);
virtual ~ ICPState();
icp_common_t header;
- request_t *request;
+ HttpRequest *request;
int fd;
struct sockaddr_in from;
};
-request_t *
+HttpRequest *
icpGetRequest(char *url, int reqnum, int fd, struct sockaddr_in *from);
-int icpAccessAllowed(struct sockaddr_in *from, request_t * icp_request);
+int icpAccessAllowed(struct sockaddr_in *from, HttpRequest * icp_request);
SQUIDCEXTERN void icpCreateAndSend(icp_opcode, int flags, char const *url, int reqnum, int pad, int fd, const struct sockaddr_in *from);
extern icp_opcode icpGetCommonOpcode();
SQUIDCEXTERN PF icpUdpSendQueue;
SQUIDCEXTERN void icpHandleIcpV3(int, struct sockaddr_in, char *, int);
-SQUIDCEXTERN int icpCheckUdpHit(StoreEntry *, request_t * request);
+SQUIDCEXTERN int icpCheckUdpHit(StoreEntry *, HttpRequest * request);
SQUIDCEXTERN void icpConnectionsOpen(void);
SQUIDCEXTERN void icpConnectionShutdown(void);
SQUIDCEXTERN void icpConnectionClose(void);
/*
- * $Id: MemObject.h,v 1.7 2003/08/10 05:11:22 robertc Exp $
+ * $Id: MemObject.h,v 1.8 2003/08/10 11:00:40 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
SwapOut swapout;
/* Read only - this reply must be preserved by store clients */
/* The original reply. possibly with updated metadata. */
- request_t *request;
+ HttpRequest *request;
struct timeval start_ping;
IRCB *ping_reply_callback;
/*
- * $Id: Store.h,v 1.11 2003/07/22 15:23:01 robertc Exp $
+ * $Id: Store.h,v 1.12 2003/08/10 11:00:40 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
void delayAwareRead(int fd, char *buf, int len, IOCB *handler, void *data);
void setNoDelay (bool const);
- bool modifiedSince(request_t * request) const;
+ bool modifiedSince(HttpRequest * request) const;
MemObject *mem_obj;
RemovalPolicyNode repl;
public:
static size_t inUseCount();
- static void getPublicByRequestMethod(StoreClient * aClient, request_t * request, const method_t method);
- static void getPublicByRequest(StoreClient * aClient, request_t * request);
+ static void getPublicByRequestMethod(StoreClient * aClient, HttpRequest * request, const method_t method);
+ static void getPublicByRequest(StoreClient * aClient, HttpRequest * request);
static void getPublic(StoreClient * aClient, const char *uri, const method_t method);
virtual bool isNull()
SQUIDCEXTERN StoreEntry *new_StoreEntry(int, const char *, const char *);
SQUIDCEXTERN StoreEntry *storeGet(const cache_key *);
SQUIDCEXTERN StoreEntry *storeGetPublic(const char *uri, const method_t method);
-SQUIDCEXTERN StoreEntry *storeGetPublicByRequest(request_t * request);
-SQUIDCEXTERN StoreEntry *storeGetPublicByRequestMethod(request_t * request, const method_t method);
+SQUIDCEXTERN StoreEntry *storeGetPublicByRequest(HttpRequest * request);
+SQUIDCEXTERN StoreEntry *storeGetPublicByRequestMethod(HttpRequest * request, const method_t method);
SQUIDCEXTERN StoreEntry *storeCreateEntry(const char *, const char *, request_flags, method_t);
SQUIDCEXTERN void storeSetPublicKey(StoreEntry *);
SQUIDCEXTERN void storeCreateMemObject(StoreEntry *, const char *, const char *);
/*
- * $Id: access_log.cc,v 1.91 2003/07/28 08:57:49 adrian Exp $
+ * $Id: access_log.cc,v 1.92 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 46 Access Log
* AUTHOR: Duane Wessels
headersLog(int cs, int pq, method_t m, void *data)
{
HttpReply *rep;
- request_t *req;
+ HttpRequest *req;
unsigned short magic = 0;
unsigned char M = (unsigned char) m;
unsigned short S;
/*
- * $Id: acl.cc,v 1.310 2003/08/04 22:14:41 robertc Exp $
+ * $Id: acl.cc,v 1.311 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 28 Access Control
* AUTHOR: Duane Wessels
ACLChecklist *
-aclChecklistCreate(const acl_access * A, request_t * request, const char *ident)
+aclChecklistCreate(const acl_access * A, HttpRequest * request, const char *ident)
{
ACLChecklist *checklist = new ACLChecklist;
/*
- * $Id: asn.cc,v 1.96 2003/08/04 22:14:41 robertc Exp $
+ * $Id: asn.cc,v 1.97 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 53 AS Number handling
* AUTHOR: Duane Wessels, Kostas Anagnostakis
{
StoreEntry *entry;
store_client *sc;
- request_t *request;
+ HttpRequest *request;
int as_number;
off_t offset;
int reqofs;
{
LOCAL_ARRAY(char, asres, 4096);
StoreEntry *e;
- request_t *req;
+ HttpRequest *req;
ASState *asState;
asState = cbdataAlloc(ASState);
asState->dataRead = 0;
/*
- * $Id: auth_basic.cc,v 1.27 2003/07/14 14:16:21 robertc Exp $
+ * $Id: auth_basic.cc,v 1.28 2003/08/10 11:00:48 robertc Exp $
*
* DEBUG: section 29 Authenticator
* AUTHOR: Duane Wessels
/* log a basic user in
*/
static void
-authenticateBasicAuthenticateUser(auth_user_request_t * auth_user_request, request_t * request, ConnStateData::Pointer conn, http_hdr_type type)
+authenticateBasicAuthenticateUser(auth_user_request_t * auth_user_request, HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type)
{
auth_user_t *auth_user;
basic_data *basic_auth;
}
void
-authenticateBasicFixErrorHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, request_t * request)
+authenticateBasicFixErrorHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, HttpRequest * request)
{
if (basicConfig->authenticate) {
debug(29, 9) ("authenticateFixErrorHeader: Sending type:%d header: 'Basic realm=\"%s\"'\n", type, basicConfig->basicAuthRealm);
/*
- * $Id: auth_digest.cc,v 1.30 2003/08/10 07:27:34 hno Exp $
+ * $Id: auth_digest.cc,v 1.31 2003/08/10 11:00:48 robertc Exp $
*
* DEBUG: section 29 Authenticator
* AUTHOR: Robert Collins
/* log a digest user in
*/
void
-digest_request_h::authenticate(request_t * request, ConnStateData::Pointer conn, http_hdr_type type)
+digest_request_h::authenticate(HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type)
{
auth_user_t *auth_user;
digest_request_h *digest_request;
/* add the [www-|Proxy-]authenticate header on a 407 or 401 reply */
void
-authenticateDigestFixHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, request_t * request)
+authenticateDigestFixHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, HttpRequest * request)
{
if (!digestConfig->authenticate)
return;
~digest_request_h();
int authenticated() const;
- virtual void authenticate(request_t * request, ConnStateData::Pointer conn, http_hdr_type type);
+ virtual void authenticate(HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type);
virtual int direction();
virtual void addHeader(HttpReply * rep, int accel);
/*
- * $Id: auth_ntlm.cc,v 1.36 2003/08/04 22:14:53 robertc Exp $
+ * $Id: auth_ntlm.cc,v 1.37 2003/08/10 11:00:52 robertc Exp $
*
* DEBUG: section 29 NTLM Authenticator
* AUTHOR: Robert Collins
* else.
*/
static void
-authenticateNTLMFixErrorHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, request_t * request)
+authenticateNTLMFixErrorHeader(auth_user_request_t * auth_user_request, HttpReply * rep, http_hdr_type type, HttpRequest * request)
{
ntlm_request_t *ntlm_request;
}
void
-ntlm_request_t::authenticate(request_t * request, ConnStateData::Pointer conn, http_hdr_type type)
+ntlm_request_t::authenticate(HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type)
{
fatal ("unusable");
}
static void
-authenticateNTLMAuthenticateUser(auth_user_request_t * auth_user_request, request_t * request, ConnStateData::Pointer conn, http_hdr_type type)
+authenticateNTLMAuthenticateUser(auth_user_request_t * auth_user_request, HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type)
{
const char *proxy_auth;
~ntlm_request_t();
virtual int authenticated() const;
- virtual void authenticate(request_t * request, ConnStateData::Pointer conn, http_hdr_type type);
+ virtual void authenticate(HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type);
virtual int direction();
/* what negotiate string did the client use? */
char *ntlmnegotiate;
/*
- * $Id: authenticate.cc,v 1.62 2003/08/04 22:14:41 robertc Exp $
+ * $Id: authenticate.cc,v 1.63 2003/08/10 11:00:40 robertc Exp $
*
* DEBUG: section 29 Authenticator
* AUTHOR: Robert Collins
* This is basically a handle approach.
*/
static void
-authenticateAuthenticateUser(auth_user_request_t * auth_user_request, request_t * request, ConnStateData::Pointer &conn, http_hdr_type type)
+authenticateAuthenticateUser(auth_user_request_t * auth_user_request, HttpRequest * request, ConnStateData::Pointer &conn, http_hdr_type type)
{
assert(auth_user_request != NULL);
*/
auth_acl_t
-AuthUserRequest::authenticate(auth_user_request_t ** auth_user_request, http_hdr_type headertype, request_t * request, ConnStateData::Pointer conn, struct in_addr src_addr)
+AuthUserRequest::authenticate(auth_user_request_t ** auth_user_request, http_hdr_type headertype, HttpRequest * request, ConnStateData::Pointer conn, struct in_addr src_addr)
{
const char *proxy_auth;
assert(headertype != 0);
auth_acl_t
-AuthUserRequest::tryToAuthenticateAndSetAuthUser(auth_user_request_t ** auth_user_request, http_hdr_type headertype, request_t * request, ConnStateData::Pointer conn, struct in_addr src_addr)
+AuthUserRequest::tryToAuthenticateAndSetAuthUser(auth_user_request_t ** auth_user_request, http_hdr_type headertype, HttpRequest * request, ConnStateData::Pointer conn, struct in_addr src_addr)
{
/* If we have already been called, return the cached value */
auth_user_request_t *t = authTryGetUser (auth_user_request, conn);
auth_acl_t
-authenticateTryToAuthenticateAndSetAuthUser(auth_user_request_t ** auth_user_request, http_hdr_type headertype, request_t * request, ConnStateData::Pointer conn, struct in_addr src_addr)
+authenticateTryToAuthenticateAndSetAuthUser(auth_user_request_t ** auth_user_request, http_hdr_type headertype, HttpRequest * request, ConnStateData::Pointer conn, struct in_addr src_addr)
{
return AuthUserRequest::tryToAuthenticateAndSetAuthUser (auth_user_request, headertype,request, conn, src_addr);
}
}
void
-AuthUserRequest::addReplyAuthHeader(HttpReply * rep, auth_user_request_t * auth_user_request, request_t * request, int accelerated, int internal)
+AuthUserRequest::addReplyAuthHeader(HttpReply * rep, auth_user_request_t * auth_user_request, HttpRequest * request, int accelerated, int internal)
/* send the auth types we are configured to support (and have compiled in!) */
{
http_hdr_type type;
}
void
-authenticateFixHeader(HttpReply * rep, auth_user_request_t * auth_user_request, request_t * request, int accelerated, int internal)
+authenticateFixHeader(HttpReply * rep, auth_user_request_t * auth_user_request, HttpRequest * request, int accelerated, int internal)
{
AuthUserRequest::addReplyAuthHeader(rep, auth_user_request, request, accelerated, internal);
}
/* call the active auth module and allow it to add a trailer to the request */
void
-authenticateAddTrailer(HttpReply * rep, auth_user_request_t * auth_user_request, request_t * request, int accelerated)
+authenticateAddTrailer(HttpReply * rep, auth_user_request_t * auth_user_request, HttpRequest * request, int accelerated)
{
if ((auth_user_request != NULL) && (auth_user_request->auth_user->auth_module > 0)
&& (authscheme_list[auth_user_request->auth_user->auth_module - 1].AddTrailer))
/*
- * $Id: authenticate.h,v 1.12 2003/08/04 22:14:41 robertc Exp $
+ * $Id: authenticate.h,v 1.13 2003/08/10 11:00:42 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
virtual ~AuthUserRequestState(){}
virtual int authenticated() const = 0;
- virtual void authenticate(request_t * request, ConnStateData::Pointer conn, http_hdr_type type) = 0;
+ virtual void authenticate(HttpRequest * request, ConnStateData::Pointer conn, http_hdr_type type) = 0;
virtual int direction() = 0;
virtual void addHeader(HttpReply * rep, int accel) {}}
public:
- static auth_acl_t tryToAuthenticateAndSetAuthUser(auth_user_request_t **, http_hdr_type, request_t *, ConnStateData::Pointer, struct in_addr);
- static void addReplyAuthHeader(HttpReply * rep, auth_user_request_t * auth_user_request, request_t * request, int accelerated, int internal);
+ static auth_acl_t tryToAuthenticateAndSetAuthUser(auth_user_request_t **, http_hdr_type, HttpRequest *, ConnStateData::Pointer, struct in_addr);
+ static void addReplyAuthHeader(HttpReply * rep, auth_user_request_t * auth_user_request, HttpRequest * request, int accelerated, int internal);
~AuthUserRequest();
void *operator new (size_t byteCount);
private:
- static auth_acl_t authenticate(auth_user_request_t ** auth_user_request, http_hdr_type headertype, request_t * request, ConnStateData::Pointer conn, struct in_addr src_addr);
+ static auth_acl_t authenticate(auth_user_request_t ** auth_user_request, http_hdr_type headertype, HttpRequest * request, ConnStateData::Pointer conn, struct in_addr src_addr);
static auth_user_request_t *createAuthUser (const char *proxy_auth);
/* authenticate.c authenticate scheme routines typedefs */
typedef int AUTHSACTIVE(void);
typedef int AUTHSAUTHED(auth_user_request_t *);
-typedef void AUTHSAUTHUSER(auth_user_request_t *, request_t *, ConnStateData::Pointer, http_hdr_type);
+typedef void AUTHSAUTHUSER(auth_user_request_t *, HttpRequest *, ConnStateData::Pointer, http_hdr_type);
typedef int AUTHSCONFIGURED(void);
typedef void AUTHSDECODE(auth_user_request_t *, const char *);
typedef int AUTHSDIRECTION(auth_user_request_t *);
typedef void AUTHSDUMP(StoreEntry *, const char *, authScheme *);
-typedef void AUTHSFIXERR(auth_user_request_t *, HttpReply *, http_hdr_type, request_t *);
+typedef void AUTHSFIXERR(auth_user_request_t *, HttpReply *, http_hdr_type, HttpRequest *);
typedef void AUTHSADDTRAILER(auth_user_request_t *, HttpReply *, int);
typedef void AUTHSFREE(auth_user_t *);
typedef void AUTHSFREECONFIG(authScheme *);
/* AuthUserRequest */
extern void authenticateStart(auth_user_request_t *, RH *, void *);
-extern auth_acl_t authenticateTryToAuthenticateAndSetAuthUser(auth_user_request_t **, http_hdr_type, request_t *, ConnStateData::Pointer, struct in_addr);
+extern auth_acl_t authenticateTryToAuthenticateAndSetAuthUser(auth_user_request_t **, http_hdr_type, HttpRequest *, ConnStateData::Pointer, struct in_addr);
extern void authenticateSetDenyMessage (auth_user_request_t *, char const *);
extern size_t authenticateRequestRefCount (auth_user_request_t *);
extern char const *authenticateAuthUserRequestMessage(auth_user_request_t *);
extern void authenticateSchemeInit(void);
extern void authenticateInit(authConfig *);
extern void authenticateShutdown(void);
-extern void authenticateFixHeader(HttpReply *, auth_user_request_t *, request_t *, int, int);
-extern void authenticateAddTrailer(HttpReply *, auth_user_request_t *, request_t *, int);
+extern void authenticateFixHeader(HttpReply *, auth_user_request_t *, HttpRequest *, int, int);
+extern void authenticateAddTrailer(HttpReply *, auth_user_request_t *, HttpRequest *, int);
extern void authenticateAuthUserUnlock(auth_user_t * auth_user);
extern void authenticateAuthUserLock(auth_user_t * auth_user);
extern void authenticateAuthUserRequestUnlock(auth_user_request_t *);
/*
- * $Id: cache_manager.cc,v 1.29 2003/02/21 22:50:06 robertc Exp $
+ * $Id: cache_manager.cc,v 1.30 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 16 Cache Manager Objects
* AUTHOR: Duane Wessels
static action_table *cachemgrFindAction(const char *action);
static cachemgrStateData *cachemgrParseUrl(const char *url);
-static void cachemgrParseHeaders(cachemgrStateData * mgr, const request_t * request);
+static void cachemgrParseHeaders(cachemgrStateData * mgr, const HttpRequest * request);
static int cachemgrCheckPassword(cachemgrStateData *);
static void cachemgrStateFree(cachemgrStateData * mgr);
static char *cachemgrPasswdGet(cachemgr_passwd *, const char *);
}
static void
-cachemgrParseHeaders(cachemgrStateData * mgr, const request_t * request)
+cachemgrParseHeaders(cachemgrStateData * mgr, const HttpRequest * request)
{
const char *basic_cookie; /* base 64 _decoded_ user:passwd pair */
const char *passwd_del;
}
void
-cachemgrStart(int fd, request_t * request, StoreEntry * entry)
+cachemgrStart(int fd, HttpRequest * request, StoreEntry * entry)
{
cachemgrStateData *mgr = NULL;
ErrorState *err = NULL;
/*
- * $Id: carp.cc,v 1.23 2003/02/21 22:50:07 robertc Exp $
+ * $Id: carp.cc,v 1.24 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 39 Cache Array Routing Protocol
* AUTHOR: Henrik Nordstrom
}
peer *
-carpSelectParent(request_t * request)
+carpSelectParent(HttpRequest * request)
{
int k;
const char *c;
/*
- * $Id: client_side.cc,v 1.653 2003/08/10 03:59:19 robertc Exp $
+ * $Id: client_side.cc,v 1.654 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 33 Client-side Routines
* AUTHOR: Duane Wessels
static CSCB clientSocketRecipient;
static CSD clientSocketDetach;
static void clientSetKeepaliveFlag(clientHttpRequest *);
-static int clientIsContentLengthValid(request_t * r);
+static int clientIsContentLengthValid(HttpRequest * r);
static bool okToAccept();
static int clientIsRequestBodyValid(int bodyLength);
static int clientIsRequestBodyTooLargeForPolicy(size_t bodyLength);
ConnStateData::Pointer conn;
char *buf;
CBCB *callback;
- request_t *request;
+ HttpRequest *request;
};
static void clientUpdateStatHistCounters(log_type logType, int svc_time);
static void clientUpdateStatCounters(log_type logType);
static void clientUpdateHierCounters(HierarchyLogEntry *);
static bool clientPingHasFinished(ping_data const *aPing);
-static void clientPrepareLogWithRequestDetails(request_t *, AccessLogEntry *);
+static void clientPrepareLogWithRequestDetails(HttpRequest *, AccessLogEntry *);
static int connIsUsable(ConnStateData::Pointer conn);
static int responseFinishedOrFailed(HttpReply * rep, StoreIOBuffer const &recievedData);
static void ClientSocketContextPushDeferredIfNeeded(ClientSocketContext::Pointer deferredRequest, ConnStateData::Pointer & conn);
}
void
-clientPrepareLogWithRequestDetails(request_t * request, AccessLogEntry * aLogEntry)
+clientPrepareLogWithRequestDetails(HttpRequest * request, AccessLogEntry * aLogEntry)
{
assert(request);
assert(aLogEntry);
static void
clientSetKeepaliveFlag(clientHttpRequest * http)
{
- request_t *request = http->request;
+ HttpRequest *request = http->request;
const HttpHeader *req_hdr = &request->header;
debug(33, 3) ("clientSetKeepaliveFlag: http_ver = %d.%d\n",
}
static int
-clientIsContentLengthValid(request_t * r)
+clientIsContentLengthValid(HttpRequest * r)
{
switch (r->method) {
{
HttpHeader *hdr = rep ? &rep->header : 0;
const char *range_err = NULL;
- request_t *request = http->request;
+ HttpRequest *request = http->request;
assert(request->range);
/* check if we still want to do ranges */
clientProcessRequest(ConnStateData::Pointer &conn, ClientSocketContext *context, method_t method, char *prefix, size_t req_line_sz)
{
clientHttpRequest *http = context->http;
- request_t *request = NULL;
+ HttpRequest *request = NULL;
/* We have an initial client stream in place should it be needed */
/* setup our private context */
connNoteUseOfBuffer(conn, http->req_sz);
/* file_read like function, for reading body content */
void
-clientReadBody(request_t * request, char *buf, size_t size, CBCB * callback,
+clientReadBody(HttpRequest * request, char *buf, size_t size, CBCB * callback,
void *cbdata)
{
ConnStateData::Pointer conn = request->body_connection;
/* Abort a body request */
int
-clientAbortBody(request_t * request)
+clientAbortBody(HttpRequest * request)
{
ConnStateData::Pointer conn = request->body_connection;
char *buf;
}
int
-varyEvaluateMatch(StoreEntry * entry, request_t * request)
+varyEvaluateMatch(StoreEntry * entry, HttpRequest * request)
{
const char *vary = request->vary_headers;
int has_vary = httpHeaderHas(&entry->getReply()->header, HDR_VARY);
/*
- * $Id: client_side.h,v 1.7 2003/08/10 03:59:19 robertc Exp $
+ * $Id: client_side.h,v 1.8 2003/08/10 11:00:42 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
struct
{
size_t size_left; /* How much body left to process */
- request_t *request; /* Parameters passed to clientReadBody */
+ HttpRequest *request; /* Parameters passed to clientReadBody */
char *buf;
size_t bufsize;
CBCB *callback;
/*
- * $Id: client_side_reply.cc,v 1.63 2003/08/04 22:14:41 robertc Exp $
+ * $Id: client_side_reply.cc,v 1.64 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 88 Client-side Reply Routines
* AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
extern "C" CSS clientReplyStatus;
extern ErrorState *clientBuildError(err_type, http_status, char const *,
- struct in_addr *, request_t *);
+ struct in_addr *, HttpRequest *);
/* privates */
clientReplyContext::setReplyToError(
err_type err, http_status status, method_t method, char const *uri,
- struct in_addr *addr, request_t * failedrequest, char *unparsedrequest,
+ struct in_addr *addr, HttpRequest * failedrequest, char *unparsedrequest,
auth_user_request_t * auth_user_request)
{
ErrorState *errstate =
StoreEntry *e = http->storeEntry();
- request_t *r = http->request;
+ HttpRequest *r = http->request;
debug(88, 3) ("clientCacheHit: %s, %ud bytes\n", http->uri, (unsigned int)result.length);
clientReplyContext::processMiss()
{
char *url = http->uri;
- request_t *r = http->request;
+ HttpRequest *r = http->request;
ErrorState *err = NULL;
debug(88, 4) ("clientProcessMiss: '%s %s'\n",
RequestMethodStr[r->method], url);
{
HttpHeader *hdr = &holdingReply->header;
int is_hit = logTypeIsATcpHit(http->logType);
- request_t *request = http->request;
+ HttpRequest *request = http->request;
#if DONT_FILTER_THESE
/* but you might want to if you run Squid as an HTTP accelerator */
/* httpHeaderDelById(hdr, HDR_ACCEPT_RANGES); */
void
clientReplyContext::identifyStoreObject()
{
- request_t *r = http->request;
+ HttpRequest *r = http->request;
if (r->flags.cachable || r->flags.internal) {
lookingforstore = 5;
clientReplyContext::identifyFoundObject(StoreEntry *newEntry)
{
StoreEntry *e = newEntry;
- request_t *r = http->request;
+ HttpRequest *r = http->request;
if (e->isNull()) {
http->storeEntry(NULL);
ErrorState *
clientBuildError(err_type page_id, http_status status, char const *url,
- struct in_addr * src_addr, request_t * request)
+ struct in_addr * src_addr, HttpRequest * request)
{
ErrorState *err = errorCon(page_id, status);
err->src_addr = *src_addr;
/*
- * $Id: client_side_reply.h,v 1.5 2003/08/04 22:14:41 robertc Exp $
+ * $Id: client_side_reply.h,v 1.6 2003/08/10 11:00:42 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
int storeOKTransferDone() const;
int storeNotOKTransferDone() const;
- void setReplyToError(err_type, http_status, method_t, char const *, struct in_addr *, request_t *, char *, auth_user_request_t *);
+ void setReplyToError(err_type, http_status, method_t, char const *, struct in_addr *, HttpRequest *, char *, auth_user_request_t *);
void createStoreEntry(method_t m, request_flags flags);
void removeStoreReference(store_client ** scp, StoreEntry ** ep);
void removeClientStoreReference(store_client **scp, ClientHttpRequest *http);
/*
- * $Id: client_side_request.cc,v 1.30 2003/08/04 22:14:41 robertc Exp $
+ * $Id: client_side_request.cc,v 1.31 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 85 Client-side Request Routines
* AUTHOR: Robert Collins (Originally Duane Wessels in client_side.c)
http_version_t http_ver =
{1, 0};
clientHttpRequest *http = new ClientHttpRequest;
- request_t *request;
+ HttpRequest *request;
StoreIOBuffer tempBuffer;
http->http_ver = http_ver;
http->setConn(NULL);
static int
clientCachable(clientHttpRequest * http)
{
- request_t *req = http->request;
+ HttpRequest *req = http->request;
method_t method = req->method;
if (req->protocol == PROTO_HTTP)
clientHierarchical(clientHttpRequest * http)
{
const char *url = http->uri;
- request_t *request = http->request;
+ HttpRequest *request = http->request;
method_t method = request->method;
const wordlist *p = NULL;
static void
clientInterpretRequestHeaders(clientHttpRequest * http)
{
- request_t *request = http->request;
+ HttpRequest *request = http->request;
const HttpHeader *req_hdr = &request->header;
int no_cache = 0;
#if !(ESI) || defined(USE_USERAGENT_LOG) || defined(USE_REFERER_LOG)
}
clientHttpRequest *http = context->http;
- request_t *new_request = NULL;
- request_t *old_request = http->request;
+ HttpRequest *new_request = NULL;
+ HttpRequest *old_request = http->request;
debug(85, 5) ("clientRedirectDone: '%s' result=%s\n", http->uri,
result ? result : "NULL");
assert(context->redirect_state == REDIRECT_PENDING);
/*
- * $Id: client_side_request.h,v 1.16 2003/08/04 22:14:41 robertc Exp $
+ * $Id: client_side_request.h,v 1.17 2003/08/10 11:00:42 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
_SQUID_INLINE_ ConnStateData::Pointer getConn();
_SQUID_INLINE_ ConnStateData::Pointer const getConn() const;
_SQUID_INLINE_ void setConn(ConnStateData::Pointer);
- request_t *request; /* Parsed URL ... */
+ HttpRequest *request; /* Parsed URL ... */
char *uri;
char *log_uri;
/*
- * $Id: errorpage.cc,v 1.189 2003/07/09 14:14:58 hno Exp $
+ * $Id: errorpage.cc,v 1.190 2003/08/10 11:00:42 robertc Exp $
*
* DEBUG: section 4 Error Generation
* AUTHOR: Duane Wessels
return i;
}
- for (size_t i = 0; i < ErrorDynamicPages.size(); i++) {
- if (strcmp(ErrorDynamicPages.items[i]->page_name, page_name) == 0)
- return i + ERR_MAX;
+ for (size_t j = 0; j < ErrorDynamicPages.size(); j++) {
+ if (strcmp(ErrorDynamicPages.items[j]->page_name, page_name) == 0)
+ return j + ERR_MAX;
}
return ERR_NONE;
static int
errorDump(ErrorState * err, MemBuf * mb)
{
- request_t *r = err->request;
+ HttpRequest *r = err->request;
MemBuf str = MemBufNULL;
const char *p = NULL; /* takes priority over mb if set */
memBufReset(&str);
static const char *
errorConvert(char token, ErrorState * err)
{
- request_t *r = err->request;
+ HttpRequest *r = err->request;
static MemBuf mb = MemBufNULL;
const char *p = NULL; /* takes priority over mb if set */
int do_quote = 1;
/*
- * $Id: external_acl.cc,v 1.52 2003/08/04 22:14:42 robertc Exp $
+ * $Id: external_acl.cc,v 1.53 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 82 External ACL
* AUTHOR: Henrik Nordstrom, MARA Systems AB
int first = 1;
wordlist *arg;
external_acl_format *format;
- request_t *request = ch->request;
+ HttpRequest *request = ch->request;
memBufReset(&mb);
for (format = acl_data->def->format; format; format = format->next) {
/*
- * $Id: forward.cc,v 1.108 2003/08/10 05:11:22 robertc Exp $
+ * $Id: forward.cc,v 1.109 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 17 Request Forwarding
* AUTHOR: Duane Wessels
SSL *ssl = fd_table[fd].ssl;
int ret;
ErrorState *err;
- request_t *request = fwdState->request;
+ HttpRequest *request = fwdState->request;
if ((ret = SSL_connect(ssl)) <= 0) {
int ssl_error = SSL_get_error(ssl, ret);
FwdState *fwdState = (FwdState *)data;
FwdServer *fs = fwdState->servers;
ErrorState *err;
- request_t *request = fwdState->request;
+ HttpRequest *request = fwdState->request;
assert(fwdState->server_fd == server_fd);
if (status == COMM_ERR_DNS) {
}
struct in_addr
- getOutgoingAddr(request_t * request)
+ getOutgoingAddr(HttpRequest * request)
{
ACLChecklist ch;
}
unsigned long
-getOutgoingTOS(request_t * request)
+getOutgoingTOS(HttpRequest * request)
{
ACLChecklist ch;
fwdDispatch(FwdState * fwdState)
{
peer *p = NULL;
- request_t *request = fwdState->request;
+ HttpRequest *request = fwdState->request;
StoreEntry *entry = fwdState->entry;
ErrorState *err;
FwdServer *fs = fwdState->servers;
}
void
-fwdStart(int fd, StoreEntry * e, request_t * r)
+fwdStart(int fd, StoreEntry * e, HttpRequest * r)
{
FwdState *fwdState;
int answer;
/*
- * $Id: ftp.cc,v 1.352 2003/08/07 13:16:30 robertc Exp $
+ * $Id: ftp.cc,v 1.353 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 9 File Transfer Protocol (FTP)
* AUTHOR: Harvest Derived
void operator delete (void *);
~FtpStateData();
StoreEntry *entry;
- request_t *request;
+ HttpRequest *request;
char user[MAX_URL];
char password[MAX_URL];
int password_url;
static wordlist *ftpParseControlReply(char *, size_t, int *, int *);
static int ftpRestartable(FtpStateData * ftpState);
static void ftpAppendSuccessHeader(FtpStateData * ftpState);
-static void ftpAuthRequired(HttpReply * reply, request_t * request, const char *realm);
+static void ftpAuthRequired(HttpReply * reply, HttpRequest * request, const char *realm);
static void ftpHackShortcut(FtpStateData * ftpState, FTPSM * nextState);
static void ftpUnhack(FtpStateData * ftpState);
static void ftpScheduleReadControlReply(FtpStateData *, int);
static void
ftpCheckUrlpath(FtpStateData * ftpState)
{
- request_t *request = ftpState->request;
+ HttpRequest *request = ftpState->request;
int l;
const char *t;
static void
ftpBuildTitleUrl(FtpStateData * ftpState)
{
- request_t *request = ftpState->request;
+ HttpRequest *request = ftpState->request;
ftpState->title_url = "ftp://";
void
ftpStart(FwdState * fwd)
{
- request_t *request = fwd->request;
+ HttpRequest *request = fwd->request;
StoreEntry *entry = fwd->entry;
int fd = fwd->server_fd;
LOCAL_ARRAY(char, realm, 8192);
}
static void
-ftpAuthRequired(HttpReply * old_reply, request_t * request, const char *realm)
+ftpAuthRequired(HttpReply * old_reply, HttpRequest * request, const char *realm)
{
ErrorState *err = errorCon(ERR_CACHE_ACCESS_DENIED, HTTP_UNAUTHORIZED);
HttpReply *rep;
}
char *
-ftpUrlWith2f(const request_t * request)
+ftpUrlWith2f(const HttpRequest * request)
{
LOCAL_ARRAY(char, buf, MAX_URL);
LOCAL_ARRAY(char, loginbuf, MAX_LOGIN_SZ + 1);
/*
- * $Id: gopher.cc,v 1.183 2003/06/20 01:01:00 robertc Exp $
+ * $Id: gopher.cc,v 1.184 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 10 Gopher
* AUTHOR: Harvest Derived
int len;
char *buf; /* pts to a 4k page */
int fd;
- request_t *req;
+ HttpRequest *req;
FwdState *fwdState;
char replybuf[BUFSIZ];
}
static PF gopherStateFree;
static void gopher_mime_content(MemBuf * mb, const char *name, const char *def);
static void gopherMimeCreate(GopherStateData *);
-static void gopher_request_parse(const request_t * req,
+static void gopher_request_parse(const HttpRequest * req,
char *type_id,
char *request);
static void gopherEndHTML(GopherStateData *);
/* Parse a gopher request into components. By Anawat. */
static void
-gopher_request_parse(const request_t * req, char *type_id, char *request)
+gopher_request_parse(const HttpRequest * req, char *type_id, char *request)
{
const char *path = req->urlpath.buf();
}
int
-gopherCachable(const request_t * req)
+gopherCachable(const HttpRequest * req)
{
int cachable = 1;
char type_id;
/*
- * $Id: htcp.cc,v 1.55 2003/07/17 22:22:53 wessels Exp $
+ * $Id: htcp.cc,v 1.56 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 31 Hypertext Caching Protocol
* AUTHOR: Duane Wesssels
private:
static MemPool *pool;
- request_t *checkHitRequest;
+ HttpRequest *checkHitRequest;
struct sockaddr_in *from;
htcpDataHeader *dhdr;
}
void
-htcpQuery(StoreEntry * e, request_t * req, peer * p)
+htcpQuery(StoreEntry * e, HttpRequest * req, peer * p)
{
cache_key *save_key;
char *pkt;
/*
- * $Id: htcp.h,v 1.4 2003/07/15 06:50:42 robertc Exp $
+ * $Id: htcp.h,v 1.5 2003/08/10 11:00:43 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
SQUIDCEXTERN void neighborsHtcpReply(const cache_key *, htcpReplyData *, const struct sockaddr_in *);
SQUIDCEXTERN void htcpInit(void);
-SQUIDCEXTERN void htcpQuery(StoreEntry * e, request_t * req, peer * p);
+SQUIDCEXTERN void htcpQuery(StoreEntry * e, HttpRequest * req, peer * p);
SQUIDCEXTERN void htcpSocketShutdown(void);
SQUIDCEXTERN void htcpSocketClose(void);
/*
- * $Id: http.cc,v 1.425 2003/08/04 22:14:42 robertc Exp $
+ * $Id: http.cc,v 1.426 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 11 Hypertext Transfer Protocol (HTTP)
* AUTHOR: Harvest Derived
static void httpMakePrivate(StoreEntry *);
static void httpMakePublic(StoreEntry *);
static void httpMaybeRemovePublic(StoreEntry *, http_status);
-static void copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, request_t * request, request_t * orig_request,
+static void copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, HttpRequest * request, HttpRequest * orig_request,
HttpHeader * hdr_out, int we_do_ranges, http_state_flags);
-static int decideIfWeDoRanges (request_t * orig_request);
+static int decideIfWeDoRanges (HttpRequest * orig_request);
static void
* Returns false if the variance cannot be stored
*/
const char *
-httpMakeVaryMark(request_t * request, HttpReply const * reply)
+httpMakeVaryMark(HttpRequest * request, HttpReply const * reply)
{
String vary, hdr;
const char *pos = NULL;
} else if (entry->isEmpty()) {
ErrorState *err;
err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
- err->request = requestLink((request_t *) request);
+ err->request = requestLink((HttpRequest *) request);
err->xerrno = errno;
fwdFail(fwd, err);
do_next_read = 0;
ErrorState *err;
err = errorCon(ERR_ZERO_SIZE_OBJECT, HTTP_SERVICE_UNAVAILABLE);
err->xerrno = errno;
- err->request = requestLink((request_t *) request);
+ err->request = requestLink((HttpRequest *) request);
fwdFail(fwd, err);
eof = 1;
do_next_read = 0;
* note: initialised the HttpHeader, the caller is responsible for Clean()-ing
*/
void
-httpBuildRequestHeader(request_t * request,
- request_t * orig_request,
+httpBuildRequestHeader(HttpRequest * request,
+ HttpRequest * orig_request,
StoreEntry * entry,
HttpHeader * hdr_out,
http_state_flags flags)
void
-copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, request_t * request, request_t * orig_request, HttpHeader * hdr_out, int we_do_ranges, http_state_flags flags)
+copyOneHeaderFromClientsideRequestToUpstreamRequest(const HttpHeaderEntry *e, String strConnection, HttpRequest * request, HttpRequest * orig_request, HttpHeader * hdr_out, int we_do_ranges, http_state_flags flags)
{
debug(11, 5) ("httpBuildRequestHeader: %s: %s\n",
e->name.buf(), e->value.buf());
}
int
-decideIfWeDoRanges (request_t * orig_request)
+decideIfWeDoRanges (HttpRequest * orig_request)
{
int result = 1;
/* decide if we want to do Ranges ourselves
/* build request prefix and append it to a given MemBuf;
* return the length of the prefix */
mb_size_t
-httpBuildRequestPrefix(request_t * request,
- request_t * orig_request,
+httpBuildRequestPrefix(HttpRequest * request,
+ HttpRequest * orig_request,
StoreEntry * entry,
MemBuf * mb,
http_state_flags flags)
httpSendRequest(HttpStateData * httpState)
{
MemBuf mb;
- request_t *req = httpState->request;
+ HttpRequest *req = httpState->request;
StoreEntry *entry = httpState->entry;
peer *p = httpState->_peer;
CWCB *sendHeaderDone;
{
int fd = fwd->server_fd;
HttpStateData *httpState;
- request_t *proxy_req;
- request_t *orig_req = fwd->request;
+ HttpRequest *proxy_req;
+ HttpRequest *orig_req = fwd->request;
debug(11, 3) ("httpStart: \"%s %s\"\n",
RequestMethodStr[orig_req->method],
storeUrl(fwd->entry));
/*
- * $Id: http.h,v 1.8 2003/07/14 14:16:00 robertc Exp $
+ * $Id: http.h,v 1.9 2003/08/10 11:00:43 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
int cacheableReply();
StoreEntry *entry;
- request_t *request;
+ HttpRequest *request;
char *reply_hdr;
size_t reply_hdr_size;
int reply_hdr_state;
peer *_peer; /* peer request made to */
int eof; /* reached end-of-object? */
- request_t *orig_request;
+ HttpRequest *orig_request;
int fd;
http_state_flags flags;
FwdState *fwd;
/*
- * $Id: icp_v2.cc,v 1.81 2003/07/06 21:50:56 hno Exp $
+ * $Id: icp_v2.cc,v 1.82 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 12 Internet Cache Protocol
* AUTHOR: Duane Wessels
}
int
-icpCheckUdpHit(StoreEntry * e, request_t * request)
+icpCheckUdpHit(StoreEntry * e, HttpRequest * request)
{
if (e == NULL)
return 0;
int
-icpAccessAllowed(struct sockaddr_in *from, request_t * icp_request)
+icpAccessAllowed(struct sockaddr_in *from, HttpRequest * icp_request)
{
ACLChecklist checklist;
checklist.src_addr = from->sin_addr;
return url;
}
-request_t *
+HttpRequest *
icpGetRequest(char *url, int reqnum, int fd, struct sockaddr_in * from)
{
return NULL;
}
- request_t *result;
+ HttpRequest *result;
if ((result = urlParse(METHOD_GET, url)) == NULL)
icpCreateAndSend(ICP_ERR, 0, url, reqnum, 0, fd, from);
u_int32_t flags = 0;
/* We have a valid packet */
char *url = buf + sizeof(icp_common_t) + sizeof(u_int32_t);
- request_t *icp_request = icpGetRequest(url, header.reqnum, fd, &from);
+ HttpRequest *icp_request = icpGetRequest(url, header.reqnum, fd, &from);
if (!icp_request)
return;
/*
- * $Id: icp_v3.cc,v 1.38 2003/02/21 22:50:09 robertc Exp $
+ * $Id: icp_v3.cc,v 1.39 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 12 Internet Cache Protocol
* AUTHOR: Duane Wessels
{
/* We have a valid packet */
char *url = buf + sizeof(icp_common_t) + sizeof(u_int32_t);
- request_t *icp_request = icpGetRequest (url, header.reqnum, fd, &from);
+ HttpRequest *icp_request = icpGetRequest (url, header.reqnum, fd, &from);
if (!icp_request)
return;
/*
- * $Id: internal.cc,v 1.28 2003/02/21 22:50:09 robertc Exp $
+ * $Id: internal.cc,v 1.29 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 76 Internal Squid Object handling
* AUTHOR: Duane, Alex, Henrik
* return HTTP_NOT_FOUND for others
*/
void
-internalStart(request_t * request, StoreEntry * entry)
+internalStart(HttpRequest * request, StoreEntry * entry)
{
ErrorState *err;
const char *upath = request->urlpath.buf();
/*
- * $Id: mime.cc,v 1.112 2003/04/24 06:35:09 hno Exp $
+ * $Id: mime.cc,v 1.113 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 25 MIME Parsing
* AUTHOR: Harvest Derived
EBIT_SET(e->flags, ENTRY_SPECIAL);
storeSetPublicKey(e);
storeBuffer(e);
- request_t *r = urlParse(METHOD_GET, url);
+ HttpRequest *r = urlParse(METHOD_GET, url);
if (NULL == r)
fatal("mimeLoadIcon: cannot parse internal URL");
/*
- * $Id: neighbors.cc,v 1.320 2003/07/14 14:16:00 robertc Exp $
+ * $Id: neighbors.cc,v 1.321 2003/08/10 11:00:43 robertc Exp $
*
* DEBUG: section 15 Neighbor Routines
* AUTHOR: Harvest Derived
/* count mcast group peers every 15 minutes */
#define MCAST_COUNT_RATE 900
-static int peerAllowedToUse(const peer *, request_t *);
-static int peerWouldBePinged(const peer *, request_t *);
+static int peerAllowedToUse(const peer *, HttpRequest *);
+static int peerWouldBePinged(const peer *, HttpRequest *);
static void neighborRemove(peer *);
static void neighborAlive(peer *, const MemObject *, const icp_common_t *);
#if USE_HTCP
}
peer_t
-neighborType(const peer * p, const request_t * request)
+neighborType(const peer * p, const HttpRequest * request)
{
const struct _domain_type *d = NULL;
* from PEER.
*/
static int
-peerAllowedToUse(const peer * p, request_t * request)
+peerAllowedToUse(const peer * p, HttpRequest * request)
{
const struct _domain_ping *d = NULL;
/* Return TRUE if it is okay to send an ICP request to this peer. */
static int
-peerWouldBePinged(const peer * p, request_t * request)
+peerWouldBePinged(const peer * p, HttpRequest * request)
{
if (!peerAllowedToUse(p, request))
return 0;
/* Return TRUE if it is okay to send an HTTP request to this peer. */
int
-peerHTTPOkay(const peer * p, request_t * request)
+peerHTTPOkay(const peer * p, HttpRequest * request)
{
if (!peerAllowedToUse(p, request))
return 0;
}
int
-neighborsCount(request_t * request)
+neighborsCount(HttpRequest * request)
{
peer *p = NULL;
int count = 0;
#if UNUSED_CODE
peer *
-getSingleParent(request_t * request)
+getSingleParent(HttpRequest * request)
{
peer *p = NULL;
peer *q = NULL;
#endif
peer *
-getFirstUpParent(request_t * request)
+getFirstUpParent(HttpRequest * request)
{
peer *p = NULL;
}
peer *
-getRoundRobinParent(request_t * request)
+getRoundRobinParent(HttpRequest * request)
{
peer *p;
peer *q = NULL;
}
peer *
-getWeightedRoundRobinParent(request_t * request)
+getWeightedRoundRobinParent(HttpRequest * request)
{
peer *p;
peer *q = NULL;
}
peer *
-getDefaultParent(request_t * request)
+getDefaultParent(HttpRequest * request)
{
peer *p = NULL;
* DOWN parent.
*/
peer *
-getAnyParent(request_t * request)
+getAnyParent(HttpRequest * request)
{
peer *p = NULL;
}
int
-neighborsUdpPing(request_t * request,
+neighborsUdpPing(HttpRequest * request,
StoreEntry * entry,
IRCB * callback,
void *callback_data,
/* lookup the digest of a given peer */
lookup_t
-peerDigestLookup(peer * p, request_t * request)
+peerDigestLookup(peer * p, HttpRequest * request)
{
#if USE_CACHE_DIGESTS
const cache_key *key = request ? storeKeyPublicByRequest(request) : NULL;
/* select best peer based on cache digests */
peer *
-neighborsDigestSelect(request_t * request)
+neighborsDigestSelect(HttpRequest * request)
{
peer *best_p = NULL;
#if USE_CACHE_DIGESTS
}
void
-peerNoteDigestLookup(request_t * request, peer * p, lookup_t lookup)
+peerNoteDigestLookup(HttpRequest * request, peer * p, lookup_t lookup)
{
#if USE_CACHE_DIGESTS
/*
- * $Id: net_db.cc,v 1.171 2003/04/20 05:28:59 robertc Exp $
+ * $Id: net_db.cc,v 1.172 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 38 Network Measurement Database
* AUTHOR: Duane Wessels
peer *p;
StoreEntry *e;
store_client *sc;
- request_t *r;
+ HttpRequest *r;
off_t used;
size_t buf_sz;
char buf[NETDB_REQBUF_SZ];
}
void
-netdbUpdatePeer(request_t * r, peer * e, int irtt, int ihops)
+netdbUpdatePeer(HttpRequest * r, peer * e, int irtt, int ihops)
{
#if USE_ICMP
netdbEntry *n;
}
peer *
-netdbClosestParent(request_t * request)
+netdbClosestParent(HttpRequest * request)
{
#if USE_ICMP
peer *p = NULL;
/*
- * $Id: peer_digest.cc,v 1.98 2003/08/04 22:14:42 robertc Exp $
+ * $Id: peer_digest.cc,v 1.99 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 72 Peer Digest Routines
* AUTHOR: Alex Rousskov
StoreEntry *e, *old_e;
char *url;
const cache_key *key;
- request_t *req;
+ HttpRequest *req;
DigestFetchState *fetch = NULL;
StoreIOBuffer tempBuffer;
/* this "if" is based on clientHandleIMSReply() */
if (status == HTTP_NOT_MODIFIED) {
- request_t *r = NULL;
+ HttpRequest *r = NULL;
/* our old entry is fine */
assert(fetch->old_entry);
/*
- * $Id: peer_select.cc,v 1.130 2003/07/14 14:16:00 robertc Exp $
+ * $Id: peer_select.cc,v 1.131 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 44 Peer Selection Algorithm
* AUTHOR: Duane Wessels
}
static int
-peerSelectIcpPing(request_t * request, int direct, StoreEntry * entry)
+peerSelectIcpPing(HttpRequest * request, int direct, StoreEntry * entry)
{
int n;
assert(entry);
void
-peerSelect(request_t * request,
+peerSelect(HttpRequest * request,
StoreEntry * entry,
PSC * callback,
void *callback_data)
peerSelectFoo(ps_state * ps)
{
StoreEntry *entry = ps->entry;
- request_t *request = ps->request;
+ HttpRequest *request = ps->request;
debug(44, 3) ("peerSelectFoo: '%s %s'\n",
RequestMethodStr[request->method],
request->host);
peerGetSomeNeighbor(ps_state * ps)
{
StoreEntry *entry = ps->entry;
- request_t *request = ps->request;
+ HttpRequest *request = ps->request;
peer *p;
hier_code code = HIER_NONE;
assert(entry->ping_status == PING_NONE);
static void
peerGetSomeNeighborReplies(ps_state * ps)
{
- request_t *request = ps->request;
+ HttpRequest *request = ps->request;
peer *p = NULL;
hier_code code = HIER_NONE;
assert(ps->entry->ping_status == PING_WAITING);
peerGetSomeParent(ps_state * ps)
{
peer *p;
- request_t *request = ps->request;
+ HttpRequest *request = ps->request;
hier_code code = HIER_NONE;
debug(44, 3) ("peerGetSomeParent: %s %s\n",
RequestMethodStr[request->method],
peerGetAllParents(ps_state * ps)
{
peer *p;
- request_t *request = ps->request;
+ HttpRequest *request = ps->request;
/* Add all alive parents */
for (p = Config.peers; p; p = p->next) {
/*
- * $Id: protos.h,v 1.489 2003/08/10 09:53:49 robertc Exp $
+ * $Id: protos.h,v 1.490 2003/08/10 11:00:44 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
SQUIDCEXTERN int clientdbEstablished(struct in_addr, int);
SQUIDCEXTERN void clientOpenListenSockets(void);
SQUIDCEXTERN void clientHttpConnectionsClose(void);
-SQUIDCEXTERN void clientReadBody(request_t * req, char *buf, size_t size, CBCB * callback, void *data);
-SQUIDCEXTERN int clientAbortBody(request_t * req);
+SQUIDCEXTERN void clientReadBody(HttpRequest * req, char *buf, size_t size, CBCB * callback, void *data);
+SQUIDCEXTERN int clientAbortBody(HttpRequest * req);
SQUIDCEXTERN void httpRequestFree(void *);
extern void clientAccessCheck(void *);
SQUIDCEXTERN void fqdncacheAddEntryFromHosts(char *addr, wordlist * hostnames);
SQUIDCEXTERN void ftpStart(FwdState *);
-SQUIDCEXTERN char *ftpUrlWith2f(const request_t *);
+SQUIDCEXTERN char *ftpUrlWith2f(const HttpRequest *);
SQUIDCEXTERN void gopherStart(FwdState *);
-SQUIDCEXTERN int gopherCachable(const request_t *);
+SQUIDCEXTERN int gopherCachable(const HttpRequest *);
SQUIDCEXTERN void whoisStart(FwdState *);
SQUIDCEXTERN int httpCachable(method_t);
SQUIDCEXTERN void httpStart(FwdState *);
SQUIDCEXTERN void httpParseReplyHeaders(const char *, HttpReply *);
-SQUIDCEXTERN mb_size_t httpBuildRequestPrefix(request_t * request,
- request_t * orig_request,
+SQUIDCEXTERN mb_size_t httpBuildRequestPrefix(HttpRequest * request,
+ HttpRequest * orig_request,
StoreEntry * entry,
MemBuf * mb,
http_state_flags);
SQUIDCEXTERN void httpAnonInitModule(void);
SQUIDCEXTERN int httpAnonHdrAllowed(http_hdr_type hdr_id);
SQUIDCEXTERN int httpAnonHdrDenied(http_hdr_type hdr_id);
-SQUIDCEXTERN void httpBuildRequestHeader(request_t *, request_t *, StoreEntry *, HttpHeader *, http_state_flags);
+SQUIDCEXTERN void httpBuildRequestHeader(HttpRequest *, HttpRequest *, StoreEntry *, HttpHeader *, http_state_flags);
SQUIDCEXTERN void httpBuildVersion(http_version_t * version, unsigned int major, unsigned int minor);
-SQUIDCEXTERN const char *httpMakeVaryMark(request_t * request, HttpReply const * reply);
+SQUIDCEXTERN const char *httpMakeVaryMark(HttpRequest * request, HttpReply const * reply);
/* ETag */
SQUIDCEXTERN int etagParseInit(ETag * etag, const char *str);
SQUIDCEXTERN void httpHeaderEntryPackInto(const HttpHeaderEntry * e, Packer * p);
/* store report about current header usage and other stats */
SQUIDCEXTERN void httpHeaderStoreReport(StoreEntry * e);
-SQUIDCEXTERN void httpHdrMangleList(HttpHeader *, request_t *);
+SQUIDCEXTERN void httpHdrMangleList(HttpHeader *, HttpRequest *);
/* Http Msg (currently in HttpReply.c @?@ ) */
SQUIDCEXTERN int httpMsgIsPersistent(http_version_t http_ver, const HttpHeader * hdr);
SQUIDCEXTERN peer *getFirstPeer(void);
-SQUIDCEXTERN peer *getFirstUpParent(request_t *);
+SQUIDCEXTERN peer *getFirstUpParent(HttpRequest *);
SQUIDCEXTERN peer *getNextPeer(peer *);
-SQUIDCEXTERN peer *getSingleParent(request_t *);
-SQUIDCEXTERN int neighborsCount(request_t *);
-SQUIDCEXTERN int neighborsUdpPing(request_t *,
+SQUIDCEXTERN peer *getSingleParent(HttpRequest *);
+SQUIDCEXTERN int neighborsCount(HttpRequest *);
+SQUIDCEXTERN int neighborsUdpPing(HttpRequest *,
StoreEntry *,
IRCB * callback,
void *data,
SQUIDCEXTERN void neighbors_init(void);
SQUIDCEXTERN peer *peerFindByName(const char *);
SQUIDCEXTERN peer *peerFindByNameAndPort(const char *, unsigned short);
-SQUIDCEXTERN peer *getDefaultParent(request_t * request);
-SQUIDCEXTERN peer *getRoundRobinParent(request_t * request);
-SQUIDCEXTERN peer *getWeightedRoundRobinParent(request_t * request);
+SQUIDCEXTERN peer *getDefaultParent(HttpRequest * request);
+SQUIDCEXTERN peer *getRoundRobinParent(HttpRequest * request);
+SQUIDCEXTERN peer *getWeightedRoundRobinParent(HttpRequest * request);
SQUIDCEXTERN EVH peerClearRR;
-SQUIDCEXTERN peer *getAnyParent(request_t * request);
-SQUIDCEXTERN lookup_t peerDigestLookup(peer * p, request_t * request);
-SQUIDCEXTERN peer *neighborsDigestSelect(request_t * request);
-SQUIDCEXTERN void peerNoteDigestLookup(request_t * request, peer * p, lookup_t lookup);
+SQUIDCEXTERN peer *getAnyParent(HttpRequest * request);
+SQUIDCEXTERN lookup_t peerDigestLookup(peer * p, HttpRequest * request);
+SQUIDCEXTERN peer *neighborsDigestSelect(HttpRequest * request);
+SQUIDCEXTERN void peerNoteDigestLookup(HttpRequest * request, peer * p, lookup_t lookup);
SQUIDCEXTERN void peerNoteDigestGone(peer * p);
SQUIDCEXTERN int neighborUp(const peer * e);
SQUIDCEXTERN CBDUNL peerDestroy;
SQUIDCEXTERN const char *neighborTypeStr(const peer * e);
-SQUIDCEXTERN peer_t neighborType(const peer *, const request_t *);
+SQUIDCEXTERN peer_t neighborType(const peer *, const HttpRequest *);
SQUIDCEXTERN void peerConnectFailed(peer *);
SQUIDCEXTERN void peerConnectSucceded(peer *);
SQUIDCEXTERN void dump_peer_options(StoreEntry *, peer *);
-SQUIDCEXTERN int peerHTTPOkay(const peer *, request_t *);
+SQUIDCEXTERN int peerHTTPOkay(const peer *, HttpRequest *);
SQUIDCEXTERN peer *whichPeer(const struct sockaddr_in *from);
SQUIDCEXTERN void netdbFreeMemory(void);
SQUIDCEXTERN int netdbHostHops(const char *host);
SQUIDCEXTERN int netdbHostRtt(const char *host);
-SQUIDCEXTERN void netdbUpdatePeer(request_t *, peer * e, int rtt, int hops);
+SQUIDCEXTERN void netdbUpdatePeer(HttpRequest *, peer * e, int rtt, int hops);
SQUIDCEXTERN void netdbDeleteAddrNetwork(struct in_addr addr);
SQUIDCEXTERN void netdbBinaryExchange(StoreEntry *);
SQUIDCEXTERN EVH netdbExchangeStart;
SQUIDCEXTERN void netdbExchangeUpdatePeer(struct in_addr, peer *, double, double);
-SQUIDCEXTERN peer *netdbClosestParent(request_t *);
+SQUIDCEXTERN peer *netdbClosestParent(HttpRequest *);
SQUIDCEXTERN void netdbHostData(const char *host, int *samp, int *rtt, int *hops);
-SQUIDCEXTERN void cachemgrStart(int fd, request_t * request, StoreEntry * entry);
+SQUIDCEXTERN void cachemgrStart(int fd, HttpRequest * request, StoreEntry * entry);
SQUIDCEXTERN void cachemgrRegister(const char *, const char *, OBJH *, int, int);
SQUIDCEXTERN void cachemgrInit(void);
-SQUIDCEXTERN void peerSelect(request_t *, StoreEntry *, PSC *, void *data);
+SQUIDCEXTERN void peerSelect(HttpRequest *, StoreEntry *, PSC *, void *data);
SQUIDCEXTERN void peerSelectInit(void);
/* peer_digest.c */
SQUIDCEXTERN void peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e);
/* forward.c */
-SQUIDCEXTERN void fwdStart(int, StoreEntry *, request_t *);
+SQUIDCEXTERN void fwdStart(int, StoreEntry *, HttpRequest *);
SQUIDCEXTERN void fwdFail(FwdState *, ErrorState *);
SQUIDCEXTERN void fwdUnregister(int fd, FwdState *);
SQUIDCEXTERN void fwdComplete(FwdState * fwdState);
SQUIDCEXTERN void fwdStatus(FwdState *, http_status);
#endif
-SQUIDCEXTERN struct in_addr getOutgoingAddr(request_t * request);
-unsigned long getOutgoingTOS(request_t * request);
+SQUIDCEXTERN struct in_addr getOutgoingAddr(HttpRequest * request);
+unsigned long getOutgoingTOS(HttpRequest * request);
-SQUIDCEXTERN void urnStart(request_t *, StoreEntry *);
+SQUIDCEXTERN void urnStart(HttpRequest *, StoreEntry *);
SQUIDCEXTERN void redirectInit(void);
SQUIDCEXTERN void redirectShutdown(void);
extern void refreshAddToList(const char *, int, time_t, int, time_t);
extern int refreshIsCachable(const StoreEntry *);
-extern int refreshCheckHTTP(const StoreEntry *, request_t *);
-extern int refreshCheckICP(const StoreEntry *, request_t *);
-extern int refreshCheckHTCP(const StoreEntry *, request_t *);
+extern int refreshCheckHTTP(const StoreEntry *, HttpRequest *);
+extern int refreshCheckICP(const StoreEntry *, HttpRequest *);
+extern int refreshCheckHTCP(const StoreEntry *, HttpRequest *);
extern int refreshCheckDigest(const StoreEntry *, time_t delta);
extern time_t getMaxAge(const char *url);
extern void refreshInit(void);
SQUIDCEXTERN const cache_key *storeKeyScan(const char *);
SQUIDCEXTERN const char *storeKeyText(const cache_key *);
SQUIDCEXTERN const cache_key *storeKeyPublic(const char *, const method_t);
-SQUIDCEXTERN const cache_key *storeKeyPublicByRequest(request_t *);
-SQUIDCEXTERN const cache_key *storeKeyPublicByRequestMethod(request_t *, const method_t);
+SQUIDCEXTERN const cache_key *storeKeyPublicByRequest(HttpRequest *);
+SQUIDCEXTERN const cache_key *storeKeyPublicByRequestMethod(HttpRequest *, const method_t);
SQUIDCEXTERN const cache_key *storeKeyPrivate(const char *, method_t, int);
SQUIDCEXTERN int storeKeyHashBuckets(int);
SQUIDCEXTERN int storeKeyNull(const cache_key *);
SQUIDCEXTERN protocol_t urlParseProtocol(const char *);
SQUIDCEXTERN method_t urlParseMethod(const char *);
SQUIDCEXTERN void urlInitialize(void);
-SQUIDCEXTERN request_t *urlParse(method_t, char *);
-SQUIDCEXTERN const char *urlCanonical(request_t *);
+SQUIDCEXTERN HttpRequest *urlParse(method_t, char *);
+SQUIDCEXTERN const char *urlCanonical(HttpRequest *);
SQUIDCEXTERN char *urlRInternal(const char *host, u_short port, const char *dir, const char *name);
SQUIDCEXTERN char *urlInternal(const char *dir, const char *name);
SQUIDCEXTERN int matchDomainName(const char *host, const char *domain);
-SQUIDCEXTERN int urlCheckRequest(const request_t *);
+SQUIDCEXTERN int urlCheckRequest(const HttpRequest *);
SQUIDCEXTERN int urlDefaultPort(protocol_t p);
-SQUIDCEXTERN char *urlCanonicalClean(const request_t *);
+SQUIDCEXTERN char *urlCanonicalClean(const HttpRequest *);
SQUIDCEXTERN char *urlHostname(const char *url);
SQUIDCEXTERN void urlExtMethodConfigure(void);
SQUIDCEXTERN void cacheDigestGuessStatsReport(const cd_guess_stats * stats, StoreEntry * sentry, const char *label);
SQUIDCEXTERN void cacheDigestReport(CacheDigest * cd, const char *label, StoreEntry * e);
-SQUIDCEXTERN void internalStart(request_t *, StoreEntry *);
+SQUIDCEXTERN void internalStart(HttpRequest *, StoreEntry *);
SQUIDCEXTERN int internalCheck(const char *urlpath);
SQUIDCEXTERN int internalStaticCheck(const char *urlpath);
SQUIDCEXTERN char *internalLocalUri(const char *dir, const char *name);
#if USE_CARP
SQUIDCEXTERN void carpInit(void);
-SQUIDCEXTERN peer *carpSelectParent(request_t *);
+SQUIDCEXTERN peer *carpSelectParent(HttpRequest *);
#endif
/* helper.c */
SQUIDCEXTERN StatCounters *snmpStatGet(int);
/* Vary support functions */
-SQUIDCEXTERN int varyEvaluateMatch(StoreEntry * entry, request_t * req);
+SQUIDCEXTERN int varyEvaluateMatch(StoreEntry * entry, HttpRequest * req);
/* CygWin & Windows NT Port */
/* win32.c */
/*
- * $Id: refresh.cc,v 1.62 2003/07/14 14:16:02 robertc Exp $
+ * $Id: refresh.cc,v 1.63 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 22 Refresh Calculation
* AUTHOR: Harvest Derived
* note: request maybe null (e.g. for cache digests build)
*/
static int
-refreshCheck(const StoreEntry * entry, request_t * request, time_t delta)
+refreshCheck(const StoreEntry * entry, HttpRequest * request, time_t delta)
{
const refresh_t *R;
const char *uri = NULL;
* refreshCheck() function above */
int
-refreshCheckHTTP(const StoreEntry * entry, request_t * request)
+refreshCheckHTTP(const StoreEntry * entry, HttpRequest * request)
{
int reason = refreshCheck(entry, request, 0);
refreshCounts[rcHTTP].total++;
}
int
-refreshCheckICP(const StoreEntry * entry, request_t * request)
+refreshCheckICP(const StoreEntry * entry, HttpRequest * request)
{
int reason = refreshCheck(entry, request, 30);
refreshCounts[rcICP].total++;
#if USE_HTCP
int
-refreshCheckHTCP(const StoreEntry * entry, request_t * request)
+refreshCheckHTCP(const StoreEntry * entry, HttpRequest * request)
{
int reason = refreshCheck(entry, request, 10);
refreshCounts[rcHTCP].total++;
/*
- * $Id: store.cc,v 1.572 2003/07/22 15:23:02 robertc Exp $
+ * $Id: store.cc,v 1.573 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 20 Storage Manager
* AUTHOR: Harvest Derived
}
void
-StoreEntry::getPublicByRequestMethod (StoreClient *aClient, request_t * request, const method_t method)
+StoreEntry::getPublicByRequestMethod (StoreClient *aClient, HttpRequest * request, const method_t method)
{
assert (aClient);
StoreEntry *result = storeGetPublicByRequestMethod( request, method);
}
void
-StoreEntry::getPublicByRequest (StoreClient *aClient, request_t * request)
+StoreEntry::getPublicByRequest (StoreClient *aClient, HttpRequest * request)
{
assert (aClient);
StoreEntry *result = storeGetPublicByRequest (request);
}
StoreEntry *
-storeGetPublicByRequestMethod(request_t * req, const method_t method)
+storeGetPublicByRequestMethod(HttpRequest * req, const method_t method)
{
return storeGet(storeKeyPublicByRequestMethod(req, method));
}
StoreEntry *
-storeGetPublicByRequest(request_t * req)
+storeGetPublicByRequest(HttpRequest * req)
{
StoreEntry *e = storeGetPublicByRequestMethod(req, req->method);
if (mem->request) {
StoreEntry *pe;
- request_t *request = mem->request;
+ HttpRequest *request = mem->request;
if (!mem->vary_headers) {
/* First handle the case where the object no longer varies */
}
bool
-StoreEntry::modifiedSince(request_t * request) const
+StoreEntry::modifiedSince(HttpRequest * request) const
{
int object_length;
time_t mod_time = lastmod;
/*
- * $Id: store_key_md5.cc,v 1.30 2003/07/11 01:40:37 robertc Exp $
+ * $Id: store_key_md5.cc,v 1.31 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 20 Storage Manager MD5 Cache Keys
* AUTHOR: Duane Wessels
}
const cache_key *
-storeKeyPublicByRequest(request_t * request)
+storeKeyPublicByRequest(HttpRequest * request)
{
return storeKeyPublicByRequestMethod(request, request->method);
}
const cache_key *
-storeKeyPublicByRequestMethod(request_t * request, const method_t method)
+storeKeyPublicByRequestMethod(HttpRequest * request, const method_t method)
{
static cache_key digest[MD5_DIGEST_CHARS];
unsigned char m = (unsigned char) method;
/*
- * $Id: structs.h,v 1.477 2003/08/04 22:14:42 robertc Exp $
+ * $Id: structs.h,v 1.478 2003/08/10 11:00:44 robertc Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
_private;
HierarchyLogEntry hier;
HttpReply *reply;
- request_t *request;
+ HttpRequest *request;
};
struct _ipcache_addrs
StoreEntry *old_entry;
store_client *sc;
store_client *old_sc;
- request_t *request;
+ HttpRequest *request;
int offset;
int mask_offset;
time_t start_time;
struct _ps_state
{
- request_t *request;
+ HttpRequest *request;
StoreEntry *entry;
int always_direct;
int never_direct;
int page_id;
http_status httpStatus;
auth_user_request_t *auth_user_request;
- request_t *request;
+ HttpRequest *request;
char *url;
int xerrno;
char *host;
{
int client_fd;
StoreEntry *entry;
- request_t *request;
+ HttpRequest *request;
FwdServer *servers;
int server_fd;
ErrorState *err;
/*
- * $Id: tunnel.cc,v 1.144 2003/08/04 22:14:42 robertc Exp $
+ * $Id: tunnel.cc,v 1.145 2003/08/10 11:00:44 robertc Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
char *url;
char *host; /* either request->host or proxy host */
u_short port;
- request_t *request;
+ HttpRequest *request;
FwdServer *servers;
class Connection
sslConnectDone(int fdnotused, comm_err_t status, int xerrno, void *data)
{
SslStateData *sslState = (SslStateData *)data;
- request_t *request = sslState->request;
+ HttpRequest *request = sslState->request;
ErrorState *err = NULL;
if (sslState->servers->_peer)
ErrorState *err = NULL;
int answer;
int fd = http->getConn()->fd;
- request_t *request = http->request;
+ HttpRequest *request = http->request;
char *url = http->uri;
/*
* client_addr == no_addr indicates this is an "internal" request
sslPeerSelectComplete(FwdServer * fs, void *data)
{
SslStateData *sslState = (SslStateData *)data;
- request_t *request = sslState->request;
+ HttpRequest *request = sslState->request;
peer *g = NULL;
if (fs == NULL) {
/*
- * $Id: url.cc,v 1.145 2003/06/09 04:41:36 robertc Exp $
+ * $Id: url.cc,v 1.146 2003/08/10 11:00:45 robertc Exp $
*
* DEBUG: section 23 URL Parsing
* AUTHOR: Duane Wessels
"TOTAL"
};
-static request_t *urnParse(method_t method, char *urn);
+static HttpRequest *urnParse(method_t method, char *urn);
#if CHECK_HOSTNAMES
static const char *const valid_hostname_chars =
#if ALLOW_HOSTNAME_UNDERSCORES
}
}
-request_t *
+HttpRequest *
urlParse(method_t method, char *url)
{
LOCAL_ARRAY(char, proto, MAX_URL);
LOCAL_ARRAY(char, login, MAX_URL);
LOCAL_ARRAY(char, host, MAX_URL);
LOCAL_ARRAY(char, urlpath, MAX_URL);
- request_t *request = NULL;
+ HttpRequest *request = NULL;
char *t = NULL;
char *q = NULL;
int port;
return request;
}
-static request_t *
+static HttpRequest *
urnParse(method_t method, char *urn)
{
debug(50, 5) ("urnParse: %s\n", urn);
}
const char *
-urlCanonical(request_t * request)
+urlCanonical(HttpRequest * request)
{
LOCAL_ARRAY(char, portbuf, 32);
LOCAL_ARRAY(char, urlbuf, MAX_URL);
}
char *
-urlCanonicalClean(const request_t * request)
+urlCanonicalClean(const HttpRequest * request)
{
LOCAL_ARRAY(char, buf, MAX_URL);
LOCAL_ARRAY(char, portbuf, 32);
}
int
-urlCheckRequest(const request_t * r)
+urlCheckRequest(const HttpRequest * r)
{
int rc = 0;
/* protocol "independent" methods */
/*
- * $Id: urn.cc,v 1.84 2003/03/09 12:29:41 robertc Exp $
+ * $Id: urn.cc,v 1.85 2003/08/10 11:00:45 robertc Exp $
*
* DEBUG: section 52 URN Parsing
* AUTHOR: Kostas Anagnostakis
void created (StoreEntry *newEntry);
void *operator new (size_t byteCount);
void operator delete (void *address);
- void start (request_t *, StoreEntry *);
+ void start (HttpRequest *, StoreEntry *);
char *getHost (String &urlpath);
- void setUriResFromRequest(request_t *);
- bool RequestNeedsMenu(request_t *r);
- void updateRequestURL(request_t *r, char const *newPath);
+ void setUriResFromRequest(HttpRequest *);
+ bool RequestNeedsMenu(HttpRequest *r);
+ void updateRequestURL(HttpRequest *r, char const *newPath);
void createUriResRequest (String &uri);
virtual ~UrnState();
StoreEntry *entry;
store_client *sc;
StoreEntry *urlres_e;
- request_t *request;
- request_t *urlres_r;
+ HttpRequest *request;
+ HttpRequest *urlres_r;
struct
{
}
bool
-UrnState::RequestNeedsMenu(request_t *r)
+UrnState::RequestNeedsMenu(HttpRequest *r)
{
return strncasecmp(r->urlpath.buf(), "menu.", 5) == 0;
}
void
-UrnState::updateRequestURL(request_t *r, char const *newPath)
+UrnState::updateRequestURL(HttpRequest *r, char const *newPath)
{
char *new_path = xstrdup (newPath);
r->urlpath = new_path;
}
void
-UrnState::setUriResFromRequest(request_t *r)
+UrnState::setUriResFromRequest(HttpRequest *r)
{
if (RequestNeedsMenu(r)) {
updateRequestURL(r, r->urlpath.buf() + 5);
}
void
-UrnState::start(request_t * r, StoreEntry * e)
+UrnState::start(HttpRequest * r, StoreEntry * e)
{
debug(52, 3) ("urnStart: '%s'\n", storeUrl(e));
entry = e;
}
void
-urnStart(request_t * r, StoreEntry * e)
+urnStart(HttpRequest * r, StoreEntry * e)
{
UrnState *anUrn = new UrnState();
anUrn->start (r, e);
/*
- * $Id: wais.cc,v 1.149 2003/06/20 01:01:01 robertc Exp $
+ * $Id: wais.cc,v 1.150 2003/08/10 11:00:45 robertc Exp $
*
* DEBUG: section 24 WAIS Relay
* AUTHOR: Harvest Derived
method_t method;
const HttpHeader *request_hdr;
char url[MAX_URL];
- request_t *request;
+ HttpRequest *request;
FwdState *fwd;
char buf[BUFSIZ];
bool dataWritten;
waisStart(FwdState * fwd)
{
WaisStateData *waisState = NULL;
- request_t *request = fwd->request;
+ HttpRequest *request = fwd->request;
StoreEntry *entry = fwd->entry;
int fd = fwd->server_fd;
const char *url = storeUrl(entry);
/*
- * $Id: whois.cc,v 1.26 2003/07/14 14:16:02 robertc Exp $
+ * $Id: whois.cc,v 1.27 2003/08/10 11:00:45 robertc Exp $
*
* DEBUG: section 75 WHOIS protocol
* AUTHOR: Duane Wessels, Kostas Anagnostakis
void readReply (int fd, char *buf, size_t len, comm_err_t flag, int xerrno);
void setReplyToOK(StoreEntry *entry);
StoreEntry *entry;
- request_t *request;
+ HttpRequest *request;
FwdState *fwd;
char buf[BUFSIZ];
bool dataWritten;
projects / thirdparty / squid.git / commitdiff
