/*
- * $Id: acl.cc,v 1.87 1997/02/27 02:57:04 wessels Exp $
+ * $Id: acl.cc,v 1.88 1997/02/28 21:33:34 wessels Exp $
*
* DEBUG: section 28 Access Control
* AUTHOR: Duane Wessels
{
int allow = 0;
while (A) {
- allow = A->allow;
- if (aclMatchAclList(A->acl_list, checklist))
- return allow;
- A = A->next;
+ allow = A->allow;
+ if (aclMatchAclList(A->acl_list, checklist))
+ return allow;
+ A = A->next;
}
return !allow;
}
debug(28, 3, "aclCheck: checking '%s'\n", A->cfgline);
allow = A->allow;
match = aclMatchAclList(A->acl_list, checklist);
- if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_NEED) {
- checklist->state[ACL_DST_IP] = ACL_LOOKUP_PENDING;
- ipcache_nbgethostbyname(checklist->request->host,
- -1,
- aclLookupDstIPDone,
- checklist);
- return;
- } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NEED) {
- checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_PENDING;
- fqdncache_nbgethostbyaddr(checklist->src_addr,
- -1,
- aclLookupSrcFQDNDone,
- checklist);
- return;
- } else if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NEED) {
- if ((ia = ipcacheCheckNumeric(checklist->request->host)) != NULL) {
- checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_PENDING;
- fqdncache_nbgethostbyaddr(ia->in_addrs[0],
- -1,
- aclLookupDstFQDNDone,
- checklist);
+ if (checklist->state[ACL_DST_IP] == ACL_LOOKUP_NEED) {
+ checklist->state[ACL_DST_IP] = ACL_LOOKUP_PENDING;
+ ipcache_nbgethostbyname(checklist->request->host,
+ -1,
+ aclLookupDstIPDone,
+ checklist);
+ return;
+ } else if (checklist->state[ACL_SRC_DOMAIN] == ACL_LOOKUP_NEED) {
+ checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_PENDING;
+ fqdncache_nbgethostbyaddr(checklist->src_addr,
+ -1,
+ aclLookupSrcFQDNDone,
+ checklist);
+ return;
+ } else if (checklist->state[ACL_DST_DOMAIN] == ACL_LOOKUP_NEED) {
+ if ((ia = ipcacheCheckNumeric(checklist->request->host)) != NULL) {
+ checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_PENDING;
+ fqdncache_nbgethostbyaddr(ia->in_addrs[0],
+ -1,
+ aclLookupDstFQDNDone,
+ checklist);
} else {
- checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
+ checklist->state[ACL_DST_DOMAIN] = ACL_LOOKUP_DONE;
}
- return;
- }
+ return;
+ }
if (match) {
debug(28, 3, "aclCheck: match found, returning %d\n", allow);
- aclCheckCallback(checklist, !allow);
+ aclCheckCallback(checklist, allow);
return;
}
- checklist->access_list = A->next;
+ checklist->access_list = A->next;
}
aclCheckCallback(checklist, !allow);
}
static void
aclCheckCallback(aclCheck_t * checklist, int answer)
{
- checklist->callback(answer, checklist->callback_data);
- requestUnlink(checklist->request);
- xfree(checklist);
+ debug(28, 3, "aclCheckCallback: answer=%d\n", answer);
+ checklist->callback(answer, checklist->callback_data);
+ requestUnlink(checklist->request);
+ xfree(checklist);
}
static void
aclLookupDstIPDone(int fd, const ipcache_addrs * ia, void *data)
{
- aclCheck_t * checklist = data;
- checklist->state[ACL_DST_IP] = ACL_LOOKUP_DONE;
- aclCheck(checklist);
+ aclCheck_t *checklist = data;
+ checklist->state[ACL_DST_IP] = ACL_LOOKUP_DONE;
+ aclCheck(checklist);
}
static void
aclLookupSrcFQDNDone(int fd, const char *fqdn, void *data)
{
- aclCheck_t * checklist = data;
- checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_DONE;
- aclCheck(checklist);
+ aclCheck_t *checklist = data;
+ checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_DONE;
+ aclCheck(checklist);
}
static void
aclLookupDstFQDNDone(int fd, const char *fqdn, void *data)
{
- aclCheck_t * checklist = data;
+ aclCheck_t *checklist = data;
checklist->state[ACL_SRC_DOMAIN] = ACL_LOOKUP_DONE;
aclCheck(checklist);
}
void
aclNBCheck(const struct _acl_access *A,
- request_t *request,
- struct in_addr src_addr,
- char *user_agent,
- char *ident,
- PF callback,
- void *callback_data)
+ request_t * request,
+ struct in_addr src_addr,
+ char *user_agent,
+ char *ident,
+ PF callback,
+ void *callback_data)
{
- aclCheck_t *checklist = xcalloc(1, sizeof(aclCheck_t));;
- checklist->access_list = A;
- checklist->request = requestLink(request);
- checklist->src_addr = src_addr;
- if (user_agent)
- xstrncpy(checklist->browser, user_agent, BROWSERNAMELEN);
- if (ident)
- xstrncpy(checklist->ident, ident, ICP_IDENT_SZ);
- checklist->callback = callback;
- checklist->callback_data = callback_data;
- aclCheck(checklist);
+ aclCheck_t *checklist = xcalloc(1, sizeof(aclCheck_t));;
+ checklist->access_list = A;
+ checklist->request = requestLink(request);
+ checklist->src_addr = src_addr;
+ if (user_agent)
+ xstrncpy(checklist->browser, user_agent, BROWSERNAMELEN);
+ if (ident)
+ xstrncpy(checklist->ident, ident, ICP_IDENT_SZ);
+ checklist->callback = callback;
+ checklist->callback_data = callback_data;
+ aclCheck(checklist);
}
/*
- * $Id: errorpage.cc,v 1.53 1997/01/15 23:01:13 wessels Exp $
+ * $Id: errorpage.cc,v 1.54 1997/02/28 21:33:36 wessels Exp $
*
* DEBUG: section 4 Error Generation
* AUTHOR: Duane Wessels
\n"
char *
-squid_error_request(const char *request, int type, const char *address, int code)
+squid_error_request(const char *request, int type, int code)
{
int error_index;
/*
- * $Id: http.cc,v 1.151 1997/02/27 02:57:09 wessels Exp $
+ * $Id: http.cc,v 1.152 1997/02/28 21:33:37 wessels Exp $
*
* DEBUG: section 11 Hypertext Transfer Protocol (HTTP)
* AUTHOR: Harvest Derived
sock,
httpConnect,
httpState);
- xfree(url);
return;
}
/*
- * $Id: neighbors.cc,v 1.127 1997/02/27 06:29:15 wessels Exp $
+ * $Id: neighbors.cc,v 1.128 1997/02/28 21:33:39 wessels Exp $
*
* DEBUG: section 15 Neighbor Routines
* AUTHOR: Harvest Derived
static peer *whichPeer _PARAMS((const struct sockaddr_in * from));
static void neighborAlive _PARAMS((peer *, const MemObject *, const icp_common_t *));
static void neighborCountIgnored _PARAMS((peer * e, icp_opcode op_unused));
-static neighbor_t parseNeighborType _PARAMS((const char *s));
+static peer_t parseNeighborType _PARAMS((const char *s));
static void peerRefreshDNS _PARAMS((void *));
static void peerDNSConfigure _PARAMS((int fd, const ipcache_addrs * ia, void *data));
}
void
-hierarchyNote(request_t * request, hier_code code, int timeout, const char *cache_host)
+hierarchyNote(request_t * request,
+ hier_code code,
+ icp_ping_data *icpdata,
+ const char *cache_host)
{
if (request) {
request->hierarchy.code = code;
- request->hierarchy.timeout = timeout;
+ request->hierarchy.icp = *icpdata;
request->hierarchy.host = xstrdup(cache_host);
+ request->hierarchy.icp.stop = current_time;
}
}
-static neighbor_t
+static peer_t
neighborType(const peer * e, const request_t * request)
{
const struct _domain_type *d = NULL;
}
int
-neighborsUdpPing(request_t * request, StoreEntry * entry, int *exprep)
+neighborsUdpPing(request_t * request,
+ StoreEntry * entry,
+ IRCB callback,
+ void *callback_data,
+ int *exprep)
{
char *host = request->host;
char *url = entry->url;
+ MemObject *mem = entry->mem_obj;
const ipcache_addrs *ia = NULL;
struct sockaddr_in to_addr;
peer *e = NULL;
int i;
- MemObject *mem = entry->mem_obj;
int reqnum = 0;
int flags;
icp_common_t *query;
}
if (entry->swap_status != NO_SWAP)
fatal_dump("neighborsUdpPing: bad swap_status");
-
+ mem->start_ping = current_time;
+ mem->icp_reply_callback = callback;
+ mem->ircb_data = callback_data;
for (i = 0, e = Peers.first_ping; i++ < Peers.n; e = e->next) {
if (e == NULL)
e = Peers.peers_head;
ICP_mcasts_sent++;
} else if (neighborUp(e)) {
/* its alive, expect a reply from it */
- *exprep++;
+ (*exprep)++;
} else {
/* Neighbor is dead; ping it anyway, but don't expect a reply */
/* log it once at the threshold */
{
peer *e = NULL;
MemObject *mem = entry->mem_obj;
- int w_rtt;
- HttpStateData *httpState = NULL;
- neighbor_t ntype = PEER_NONE;
+ peer_t ntype = PEER_NONE;
char *opcode_d;
icp_opcode opcode = (icp_opcode) header->opcode;
} else if (ntype != PEER_PARENT) {
(void) 0; /* ignore MISS from non-parent */
} else {
- mem->icp_reply_callback(e, ntype, opcode, mem->cb_data);
+ mem->icp_reply_callback(e, ntype, opcode, mem->ircb_data);
}
} else if (opcode == ICP_OP_HIT || opcode == ICP_OP_HIT_OBJ) {
if (e == NULL) {
debug(15, 1, "Ignoring HIT from non-peer %s\n",
inet_ntoa(from->sin_addr));
} else {
- mem->icp_reply_callback(e, ntype, ICP_OP_HIT, mem->cb_data);
+ mem->icp_reply_callback(e, ntype, ICP_OP_HIT, mem->ircb_data);
}
} else if (opcode == ICP_OP_DECHO) {
if (e == NULL) {
debug_trap("neighborsUdpAck: Found non-ICP cache as SIBLING\n");
debug_trap("neighborsUdpAck: non-ICP neighbors must be a PARENT\n");
} else {
- mem->icp_reply_callback(e, ntype, opcode, mem->cb_data);
+ mem->icp_reply_callback(e, ntype, opcode, mem->ircb_data);
}
} else if (opcode == ICP_OP_SECHO) {
if (e) {
debug(15, 1, "Ignoring SECHO from neighbor %s\n", e->host);
neighborCountIgnored(e, opcode);
+ } else if (!Config.sourcePing) {
+ debug(15, 1, "Unsolicited SECHO from %s\n", inet_ntoa(from->sin_addr));
} else {
- mem->icp_reply_callback(NULL, ntype, opcode, mem->cb_data);
+ mem->icp_reply_callback(NULL, ntype, opcode, mem->ircb_data);
}
} else if (opcode == ICP_OP_DENIED) {
if (e == NULL) {
}
}
} else if (opcode == ICP_OP_MISSNOFETCH) {
- mem->icp_reply_callback(e, ntype, opcode, mem->cb_data);
+ mem->icp_reply_callback(e, ntype, opcode, mem->ircb_data);
} else {
debug(15, 0, "neighborsUdpAck: Unexpected ICP reply: %s\n", opcode_d);
}
return e;
}
-static neighbor_t
+static peer_t
parseNeighborType(const char *s)
{
if (!strcasecmp(s, "parent"))
/*
- * $Id: peer_select.cc,v 1.5 1997/02/27 06:29:16 wessels Exp $
+ * $Id: peer_select.cc,v 1.6 1997/02/28 21:33:41 wessels Exp $
*
* DEBUG: section 44 Peer Selection Algorithm
* AUTHOR: Duane Wessels
int timeouts;
} PeerStats;
-typedef struct {
- request_t *request;
- StoreEntry *entry;
- int always_direct;
- int never_direct;
- PSC callback;
- PSC fail_callback;
- void *callback_data;
- struct {
- struct timeval start;
- int n_sent;
- int n_recv;
- int n_replies_expected;
- int timeout;
- peer *best_parent;
- } ping;
-} psctrl_t;
-
-static void peerSelectFoo _PARAMS((psctrl_t *));
+static void peerSelectFoo _PARAMS((ps_state *));
static void peerPingTimeout _PARAMS((void *data));
-void peerPingComplete _PARAMS((void *data));
-static void peerSelectCallbackFail _PARAMS((psctrl_t * ctrl));
+static void peerSelectCallbackFail _PARAMS((ps_state * psstate));
+static void peerHandleIcpReply _PARAMS((peer * p, peer_t type, icp_opcode op, void *data));
int
peerSelectIcpPing(request_t * request, int direct, StoreEntry * entry)
void
peerSelect(request_t * request,
- StoreEntry *entry,
- PSC callback,
- PSC fail_callback,
- void *callback_data)
+ StoreEntry * entry,
+ PSC callback,
+ PSC fail_callback,
+ void *callback_data)
{
- psctrl_t *ctrl = xcalloc(1, sizeof(psctrl_t));
- ctrl->request = requestLink(request);
- ctrl->entry = entry;
- ctrl->callback = callback;
- ctrl->fail_callback = fail_callback;
- ctrl->callback_data = callback_data;
- peerSelectFoo(ctrl);
+ ps_state *psstate = xcalloc(1, sizeof(ps_state));
+ psstate->request = requestLink(request);
+ psstate->entry = entry;
+ psstate->callback = callback;
+ psstate->fail_callback = fail_callback;
+ psstate->callback_data = callback_data;
+ psstate->icp.start = current_time;
+ peerSelectFoo(psstate);
}
static void
peerCheckNeverDirectDone(int answer, void *data)
{
- psctrl_t *ctrl = data;
+ ps_state *psstate = data;
debug(44, 3, "peerCheckNeverDirectDone: %d\n", answer);
- ctrl->never_direct = answer ? 1 : -1;
- peerSelectFoo(ctrl);
+ psstate->never_direct = answer ? 1 : -1;
+ peerSelectFoo(psstate);
}
static void
peerCheckAlwaysDirectDone(int answer, void *data)
{
- psctrl_t *ctrl = data;
+ ps_state *psstate = data;
debug(44, 3, "peerCheckAlwaysDirectDone: %d\n", answer);
- ctrl->always_direct = answer ? 1 : -1;
- peerSelectFoo(ctrl);
+ psstate->always_direct = answer ? 1 : -1;
+ peerSelectFoo(psstate);
}
static void
-peerSelectCallback(psctrl_t * ctrl, peer * p)
+peerSelectCallback(ps_state * psstate, peer * p)
{
- if (!ctrl->ping.timeout)
- eventDelete(peerPingTimeout, ctrl);
- ctrl->callback(p, ctrl->callback_data);
- requestUnlink(ctrl->request);
- xfree(ctrl);
+ StoreEntry *entry = psstate->entry;
+ if (entry) {
+ if (entry->ping_status == PING_WAITING)
+ eventDelete(peerPingTimeout, psstate);
+ entry->ping_status = PING_DONE;
+ }
+ psstate->callback(p, psstate->callback_data);
+ requestUnlink(psstate->request);
+ xfree(psstate);
}
static void
-peerSelectCallbackFail(psctrl_t * ctrl)
+peerSelectCallbackFail(ps_state * psstate)
{
- request_t *request = ctrl->request;
- char *url = ctrl->entry ? ctrl->entry->url : urlCanonical(request, NULL);
+ request_t *request = psstate->request;
+ char *url = psstate->entry ? psstate->entry->url : urlCanonical(request, NULL);
debug(44, 1, "Failed to select source for '%s'\n", url);
- debug(44, 1, " always_direct = %d\n", ctrl->always_direct);
- debug(44, 1, " never_direct = %d\n", ctrl->never_direct);
- debug(44, 1, " timeout = %d\n", ctrl->ping.timeout);
- ctrl->fail_callback(NULL, ctrl->callback_data);
- requestUnlink(ctrl->request);
- xfree(ctrl);
+ debug(44, 1, " always_direct = %d\n", psstate->always_direct);
+ debug(44, 1, " never_direct = %d\n", psstate->never_direct);
+ debug(44, 1, " timeout = %d\n", psstate->icp.timeout);
+ psstate->fail_callback(NULL, psstate->callback_data);
+ requestUnlink(psstate->request);
+ xfree(psstate);
}
static void
-peerSelectFoo(psctrl_t * ctrl)
+peerSelectFoo(ps_state * psstate)
{
peer *p;
hier_code code;
- StoreEntry *entry = ctrl->entry;
- request_t *request = ctrl->request;
+ StoreEntry *entry = psstate->entry;
+ request_t *request = psstate->request;
int direct;
- debug(44, 3, "peerSelect: '%s'\n", entry->url);
- if (ctrl->never_direct == 0) {
+ debug(44, 3, "peerSelect: '%s %s'\n",
+ RequestMethodStr[request->method],
+ request->host);
+ if (psstate->never_direct == 0) {
aclNBCheck(Config.accessList.NeverDirect,
request,
request->client_addr,
NULL, /* user agent */
NULL, /* ident */
peerCheckNeverDirectDone,
- ctrl);
+ psstate);
return;
- } else if (ctrl->never_direct > 0) {
+ } else if (psstate->never_direct > 0) {
direct = DIRECT_NO;
- } else if (ctrl->always_direct == 0) {
+ } else if (psstate->always_direct == 0) {
aclNBCheck(Config.accessList.AlwaysDirect,
request,
request->client_addr,
NULL, /* user agent */
NULL, /* ident */
peerCheckAlwaysDirectDone,
- ctrl);
+ psstate);
return;
- } else if (ctrl->always_direct > 0) {
+ } else if (psstate->always_direct > 0) {
direct = DIRECT_YES;
} else {
direct = DIRECT_MAYBE;
debug(44, 3, "peerSelect: direct = %d\n", direct);
if (direct == DIRECT_YES) {
debug(44, 3, "peerSelect: HIER_DIRECT\n");
- hierarchyNote(request, HIER_DIRECT, ctrl->ping.timeout, request->host);
- peerSelectCallback(ctrl, NULL);
+ hierarchyNote(request, HIER_DIRECT, &psstate->icp, request->host);
+ peerSelectCallback(psstate, NULL);
return;
}
if (peerSelectIcpPing(request, direct, entry)) {
if (entry->ping_status != PING_NONE)
- fatal_dump("peerSelectFoo: bad ping_status");
+ fatal_dump("peerSelectFoo: bad ping_status");
debug(44, 3, "peerSelect: Doing ICP pings\n");
- ctrl->ping.n_sent = neighborsUdpPing(request,
- entry,
- &ctrl->ping.n_replies_expected);
- if (ctrl->ping.n_sent > 0) {
+ psstate->icp.n_sent = neighborsUdpPing(request,
+ entry,
+ peerHandleIcpReply,
+ psstate,
+ &psstate->icp.n_replies_expected);
+ if (psstate->icp.n_sent > 0) {
entry->ping_status = PING_WAITING;
eventAdd("peerPingTimeout",
peerPingTimeout,
- ctrl,
+ psstate,
Config.neighborTimeout);
- ctrl->ping.start = current_time;
return;
}
debug_trap("peerSelect: neighborsUdpPing returned 0");
}
- if ((p = ctrl->ping.best_parent)) {
+ if ((p = psstate->best_parent)) {
code = HIER_BEST_PARENT_MISS;
debug(44, 3, "peerSelect: %s/%s\n", hier_strings[code], p->host);
- hierarchyNote(request, code, ctrl->ping.timeout, p->host);
- peerSelectCallback(ctrl, p);
+ hierarchyNote(request, code, &psstate->icp, p->host);
+ peerSelectCallback(psstate, p);
} else if (direct != DIRECT_NO) {
code = HIER_DIRECT;
debug(44, 3, "peerSelect: %s/%s\n", hier_strings[code], request->host);
- hierarchyNote(request, code, ctrl->ping.timeout, request->host);
- peerSelectCallback(ctrl, NULL);
+ hierarchyNote(request, code, &psstate->icp, request->host);
+ peerSelectCallback(psstate, NULL);
} else if ((p = peerGetSomeParent(request, &code))) {
debug(44, 3, "peerSelect: %s/%s\n", hier_strings[code], p->host);
- hierarchyNote(request, code, ctrl->ping.timeout, p->host);
- peerSelectCallback(ctrl, p);
+ hierarchyNote(request, code, &psstate->icp, p->host);
+ peerSelectCallback(psstate, p);
} else {
code = HIER_NO_DIRECT_FAIL;
- hierarchyNote(request, code, ctrl->ping.timeout, NULL);
- peerSelectCallbackFail(ctrl);
+ hierarchyNote(request, code, &psstate->icp, NULL);
+ peerSelectCallbackFail(psstate);
}
}
void
peerPingTimeout(void *data)
{
- psctrl_t *ctrl = data;
- StoreEntry *entry = ctrl->entry;
+ ps_state *psstate = data;
+ StoreEntry *entry = psstate->entry;
debug(44, 3, "peerPingTimeout: '%s'\n", entry->url);
entry->ping_status = PING_TIMEOUT;
PeerStats.timeouts++;
- ctrl->ping.timeout = 1;
- peerSelectFoo(ctrl);
-}
-
-void
-peerPingComplete(void *data)
-{
- psctrl_t *ctrl = data;
- StoreEntry *entry = ctrl->entry;
- debug(44, 3, "peerPingComplete: '%s'\n", entry->url);
- entry->ping_status = PING_DONE;
- peerSelectFoo(ctrl);
+ psstate->icp.timeout = 1;
+ peerSelectFoo(psstate);
}
void
}
-void
-peerHandleIcpReply(peer * p, neighbor_t type, icp_opcode_t op, void *data)
+static void
+peerHandleIcpReply(peer * p, peer_t type, icp_opcode op, void *data)
{
- psctrl_t *ctrl = data;
+ ps_state *psstate = data;
int w_rtt;
- request_t *reqeust = ctrl->request;
- ctrl->pings->n_recv++;
+ request_t *request = psstate->request;
+ psstate->icp.n_recv++;
if (op == ICP_OP_MISS || op == ICP_OP_DECHO) {
if (type == PEER_PARENT) {
- w_rtt = tvSubMsec(ctrl->ping.start, current_time) / e->weight;
- if (ctrl->ping.w_rtt == 0 || w_rtt < ctrl->ping.w_rtt) {
- ctrl->ping.best_parent = e;
- ctrl->ping.w_rtt = w_rtt;
+ w_rtt = tvSubMsec(psstate->icp.start, current_time) / p->weight;
+ if (psstate->icp.w_rtt == 0 || w_rtt < psstate->icp.w_rtt) {
+ psstate->best_parent = p;
+ psstate->icp.w_rtt = w_rtt;
}
}
} else if (op == ICP_OP_HIT || op == ICP_OP_HIT_OBJ) {
hierarchyNote(request,
type == PEER_PARENT ? HIER_PARENT_HIT : HIER_SIBLING_HIT,
- 0,
+ &psstate->icp,
p->host);
- peerSelectCallback(ctrl, p);
+ peerSelectCallback(psstate, p);
return;
} else if (op == ICP_OP_SECHO) {
hierarchyNote(request,
HIER_SOURCE_FASTEST,
- 0,
- request->host
- peerSelectCallback(ctrl, p);
+ &psstate->icp,
+ request->host);
+ peerSelectCallback(psstate, p);
return;
}
- if (ctrl->ping.n_recv < ping.n_replies_expected)
+ if (psstate->icp.n_recv < psstate->icp.n_replies_expected)
return;
+ peerSelectFoo(psstate);
}
/*
- * $Id: squid.h,v 1.98 1997/02/27 02:57:16 wessels Exp $
+ * $Id: squid.h,v 1.99 1997/02/28 21:33:42 wessels Exp $
*
* AUTHOR: Duane Wessels
*
#include "filemap.h"
#include "hash.h"
#include "proto.h" /* must go before neighbors.h */
+#include "peer_select.h" /* must go before neighbors.h */
#include "neighbors.h" /* must go before url.h */
#include "url.h"
#include "icp.h"
#include "client_db.h"
#include "objcache.h"
#include "refresh.h"
-#include "peer_select.h"
#if !HAVE_TEMPNAM
#include "tempnam.h"
/*
- * $Id: ssl.cc,v 1.40 1997/02/26 19:46:22 wessels Exp $
+ * $Id: ssl.cc,v 1.41 1997/02/28 21:33:42 wessels Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
static void sslClientClosed _PARAMS((int fd, void *));
static void sslConnectDone _PARAMS((int fd, int status, void *data));
static void sslStateFree _PARAMS((int fd, void *data));
-static void sslSelectNeighbor _PARAMS((int fd, const ipcache_addrs *, void *));
+static void sslPeerSelectComplete _PARAMS((peer * p, void *data));
+static void sslPeerSelectFail _PARAMS((peer * p, void *data));
static void
sslClose(SslStateData * sslState)
SslStateData *sslState = NULL;
int sock;
char *buf = NULL;
-
debug(26, 3, "sslStart: '%s %s'\n",
RequestMethodStr[request->method], url);
-
/* Create socket. */
sock = comm_open(SOCK_STREAM,
0,
comm_add_close_handler(sslState->client.fd,
sslClientClosed,
(void *) sslState);
-
- if (Config.sslProxy) {
- ipcache_nbgethostbyname(request->host,
- sslState->server.fd,
- sslSelectNeighbor,
- sslState);
- } else {
- sslState->host = request->host;
- sslState->port = request->port;
- ipcache_nbgethostbyname(request->host,
- sslState->server.fd,
- sslConnect,
- sslState);
- }
+ peerSelect(request,
+ NULL,
+ sslPeerSelectComplete,
+ sslPeerSelectFail,
+ sslState);
return COMM_OK;
}
}
static void
-sslSelectNeighbor(int fd, const ipcache_addrs * ia, void *data)
+sslPeerSelectComplete (peer * p, void *data)
{
SslStateData *sslState = data;
request_t *request = sslState->request;
- peer *e = NULL;
peer *g = NULL;
- hier_code code;
- if (peerSelectDirect(request)) {
- hierarchyNote(request, HIER_DIRECT, 0, request->host);
- } else if ((e = peerGetSomeParent(request, &code))) {
- hierarchyNote(request, code, 0, e->host);
- } else {
- hierarchyNote(request, HIER_DIRECT, 0, request->host);
- }
- sslState->proxying = e ? 1 : 0;
- sslState->host = e ? e->host : request->host;
- if (e == NULL) {
+ sslState->proxying = p ? 1 : 0;
+ sslState->host = p ? p->host : request->host;
+ if (p == NULL) {
sslState->port = request->port;
- } else if (e->http_port != 0) {
- sslState->port = e->http_port;
- } else if ((g = neighborFindByName(e->host))) {
+ } else if (p->http_port != 0) {
+ sslState->port = p->http_port;
+ } else if ((g = neighborFindByName(p->host))) {
sslState->port = g->http_port;
} else {
sslState->port = CACHE_HTTP_PORT;
sslConnect,
sslState);
}
+
+static void
+sslPeerSelectFail (peer * p, void *data)
+{
+ SslStateData *sslState = data;
+ squid_error_request(sslState->url, ERR_CANNOT_FETCH, 400);
+ sslClose(sslState);
+}
/*
- * $Id: stat.cc,v 1.127 1997/02/26 19:46:22 wessels Exp $
+ * $Id: stat.cc,v 1.128 1997/02/28 21:33:43 wessels Exp $
*
* DEBUG: section 18 Cache Manager Statistics
* AUTHOR: Harvest Derived
const char *client = NULL;
hier_code hier_code = HIER_NONE;
const char *hier_host = dash_str;
- int hier_timeout = 0;
+ int ns = 0;
+ int ne = 0;
+ int nr = 0;
+ int tt = 0;
if (obj->logfile_status != LOG_ENABLE)
return;
if (hierData) {
hier_code = hierData->code;
hier_host = hierData->host ? hierData->host : dash_str;
- hier_timeout = hierData->timeout;
+ if (hierData->icp.start.tv_sec && hierData->icp.stop.tv_sec)
+ tt = tvSubMsec(hierData->icp.start, hierData->icp.stop);
+ ns = hierData->icp.n_sent;
+ ne = hierData->icp.n_replies_expected;
+ nr = hierData->icp.n_recv;
}
if (Config.commonLogFormat)
- sprintf(tmp, "%s %s - [%s] \"%s %s\" %s:%s%s %d\n",
+ sprintf(tmp, "%s %s - [%s] \"%s %s\" %s:%s %d\n",
client,
ident,
mkhttpdlogtime(&squid_curtime),
method,
url,
action,
- hier_timeout ? "TIMEOUT_" : null_string,
hier_strings[hier_code],
size);
else
- sprintf(tmp, "%9d.%03d %6d %s %s/%03d %d %s %s %s %s%s/%s %s\n",
+ sprintf(tmp, "%9d.%03d %6d %s %s/%03d %d %s %s %s %s/%s %d/%d/%d/%d %s\n",
(int) current_time.tv_sec,
(int) current_time.tv_usec / 1000,
msec,
method,
url,
ident,
- hier_timeout ? "TIMEOUT_" : null_string,
hier_strings[hier_code],
hier_host,
+ ns,ne,nr,tt,
content_type);
#if LOG_FULL_HEADERS
if (Config.logMimeHdrs) {
/*
- * $Id: tunnel.cc,v 1.40 1997/02/26 19:46:22 wessels Exp $
+ * $Id: tunnel.cc,v 1.41 1997/02/28 21:33:42 wessels Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
static void sslClientClosed _PARAMS((int fd, void *));
static void sslConnectDone _PARAMS((int fd, int status, void *data));
static void sslStateFree _PARAMS((int fd, void *data));
-static void sslSelectNeighbor _PARAMS((int fd, const ipcache_addrs *, void *));
+static void sslPeerSelectComplete _PARAMS((peer * p, void *data));
+static void sslPeerSelectFail _PARAMS((peer * p, void *data));
static void
sslClose(SslStateData * sslState)
SslStateData *sslState = NULL;
int sock;
char *buf = NULL;
-
debug(26, 3, "sslStart: '%s %s'\n",
RequestMethodStr[request->method], url);
-
/* Create socket. */
sock = comm_open(SOCK_STREAM,
0,
comm_add_close_handler(sslState->client.fd,
sslClientClosed,
(void *) sslState);
-
- if (Config.sslProxy) {
- ipcache_nbgethostbyname(request->host,
- sslState->server.fd,
- sslSelectNeighbor,
- sslState);
- } else {
- sslState->host = request->host;
- sslState->port = request->port;
- ipcache_nbgethostbyname(request->host,
- sslState->server.fd,
- sslConnect,
- sslState);
- }
+ peerSelect(request,
+ NULL,
+ sslPeerSelectComplete,
+ sslPeerSelectFail,
+ sslState);
return COMM_OK;
}
}
static void
-sslSelectNeighbor(int fd, const ipcache_addrs * ia, void *data)
+sslPeerSelectComplete (peer * p, void *data)
{
SslStateData *sslState = data;
request_t *request = sslState->request;
- peer *e = NULL;
peer *g = NULL;
- hier_code code;
- if (peerSelectDirect(request)) {
- hierarchyNote(request, HIER_DIRECT, 0, request->host);
- } else if ((e = peerGetSomeParent(request, &code))) {
- hierarchyNote(request, code, 0, e->host);
- } else {
- hierarchyNote(request, HIER_DIRECT, 0, request->host);
- }
- sslState->proxying = e ? 1 : 0;
- sslState->host = e ? e->host : request->host;
- if (e == NULL) {
+ sslState->proxying = p ? 1 : 0;
+ sslState->host = p ? p->host : request->host;
+ if (p == NULL) {
sslState->port = request->port;
- } else if (e->http_port != 0) {
- sslState->port = e->http_port;
- } else if ((g = neighborFindByName(e->host))) {
+ } else if (p->http_port != 0) {
+ sslState->port = p->http_port;
+ } else if ((g = neighborFindByName(p->host))) {
sslState->port = g->http_port;
} else {
sslState->port = CACHE_HTTP_PORT;
sslConnect,
sslState);
}
+
+static void
+sslPeerSelectFail (peer * p, void *data)
+{
+ SslStateData *sslState = data;
+ squid_error_request(sslState->url, ERR_CANNOT_FETCH, 400);
+ sslClose(sslState);
+}
projects / thirdparty / squid.git / commitdiff
