Synced #includes after moving files around.

Use newly added ACLFilledChecklist for fast ACL checks. Its constructor locks
request and accessList, simplifying the caller code.

Use newly added ACLFilledChecklist for state-specific ACL code. Also, the
ACLChecklist::authenticated() method is now an AuthenticateAcl global
function. See ACLFilledChecklist addition log for rationale.

Context: SourceLayout: acl/, take 1

diff --git a/src/ACLCertificate.cc b/src/acl/Certificate.cc
similarity index 93%
rename from src/ACLCertificate.cc
rename to src/acl/Certificate.cc
index c804effd112101cb47048abf8def8b70d4d31289..5d72957bb41d45542b065c0a62e778277eb44f28 100644 (file)
--- a/src/ACLCertificate.cc
+++ b/src/acl/Certificate.cc
@@ -41,9 +41,9 @@
  */
 #if USE_SSL
 
-#include "ACLCertificate.h"
-#include "ACLChecklist.h"
-#include "ACLCertificateData.h"
+#include "acl/Certificate.h"
+#include "acl/Checklist.h"
+#include "acl/CertificateData.h"
 #include "fde.h"
 #include "client_side.h"
 
@@ -53,7 +53,7 @@ ACL::Prototype ACLCertificate::CARegistryProtoype(&ACLCertificate::CARegistryEnt
 ACLStrategised<SSL *> ACLCertificate::CARegistryEntry_(new ACLCertificateData (sslGetCAAttribute), ACLCertificateStrategy::Instance(), "ca_cert");
 
 int
-ACLCertificateStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLCertificateStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     const int fd = checklist->fd();
     const bool goodDescriptor = 0 <= fd && fd <= Biggest_FD;

diff --git a/src/ACLCertificate.h b/src/acl/Certificate.h
similarity index 93%
rename from src/ACLCertificate.h
rename to src/acl/Certificate.h
index bc29eb2a83f6c62eba8de4a91d58ef591477e464..4cea946fb895a51a6757140477a7cc9c82dd5e8c 100644 (file)
--- a/src/ACLCertificate.h
+++ b/src/acl/Certificate.h
@@ -35,18 +35,18 @@
 #ifndef SQUID_ACLCERTIFICATE_H
 #define SQUID_ACLCERTIFICATE_H
 
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLChecklist.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Checklist.h"
 #include "ssl_support.h"
-#include "ACLStrategised.h"
+#include "acl/Strategised.h"
 
 /// \ingroup ACLAPI
 class ACLCertificateStrategy : public ACLStrategy<SSL *>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLCertificateStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLDestinationASN.h b/src/acl/DestinationAsn.h
similarity index 94%
rename from src/ACLDestinationASN.h
rename to src/acl/DestinationAsn.h
index 7586d4c8ad80ac711d78b4c4230a14768e93cbd0..efaaade67043289944f7bf6988161d37d1d11199 100644 (file)
--- a/src/ACLDestinationASN.h
+++ b/src/acl/DestinationAsn.h
@@ -32,8 +32,8 @@
 #ifndef SQUID_ACLDESTINATIONASN_H
 #define SQUID_ACLDESTINATIONASN_H
 
-#include "ACLASN.h"
-#include "ACLStrategy.h"
+#include "acl/Asn.h"
+#include "acl/Strategy.h"
 #include "ip/IpAddress.h"
 
 /// \ingroup ACLAPI
@@ -41,7 +41,7 @@ class ACLDestinationASNStrategy : public ACLStrategy<IpAddress>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLDestinationASNStrategy *Instance();

diff --git a/src/ACLDestinationDomain.h b/src/acl/DestinationDomain.h
similarity index 94%
rename from src/ACLDestinationDomain.h
rename to src/acl/DestinationDomain.h
index d7187a139882a2589d048632cec5851b8b55780c..b4545f3c03431f0711a90388e03c96112aed991f 100644 (file)
--- a/src/ACLDestinationDomain.h
+++ b/src/acl/DestinationDomain.h
@@ -35,17 +35,17 @@
 #ifndef SQUID_ACLSOURCEDOMAIN_H
 #define SQUID_ACLSOURCEDOMAIN_H
 
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLChecklist.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Checklist.h"
+#include "acl/Strategised.h"
 
 /// \ingroup ACLAPI
 class ACLDestinationDomainStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLDestinationDomainStrategy *Instance();
 
     /**

diff --git a/src/ACLExtUser.cc b/src/acl/ExtUser.cc
similarity index 93%
rename from src/ACLExtUser.cc
rename to src/acl/ExtUser.cc
index 54be55173d653d84c2b544e2c17b0d0c126b8a56..a5cf9ffcc6511dc2f348b9560cbcf15e46c23258 100644 (file)
--- a/src/ACLExtUser.cc
+++ b/src/acl/ExtUser.cc
@@ -35,11 +35,10 @@
  */
 
 #include "squid.h"
-#include "ACLExtUser.h"
-#include "authenticate.h"
-#include "ACLChecklist.h"
-#include "ACLRegexData.h"
-#include "ACLUserData.h"
+#include "acl/ExtUser.h"
+#include "acl/FilledChecklist.h"
+#include "acl/RegexData.h"
+#include "acl/UserData.h"
 #include "client_side.h"
 #include "HttpRequest.h"
 
@@ -76,8 +75,9 @@ ACLExtUser::parse()
 }
 
 int
-ACLExtUser::match(ACLChecklist *checklist)
+ACLExtUser::match(ACLChecklist *cl)
 {
+       ACLFilledChecklist *checklist = Filled(cl);
     if (checklist->request->extacl_user.size()) {
         return data->match(checklist->request->extacl_user.termedBuf());
     } else {

diff --git a/src/ACLHTTPRepHeader.cc b/src/acl/HttpRepHeader.cc
similarity index 94%
rename from src/ACLHTTPRepHeader.cc
rename to src/acl/HttpRepHeader.cc
index 6b81b59bb90dda60911a0d33a852f93c5d2788ae..d72af9bd70941dc6bac09306f48f94d47f2e658b 100644 (file)
--- a/src/ACLHTTPRepHeader.cc
+++ b/src/acl/HttpRepHeader.cc
@@ -34,9 +34,9 @@
  */
 
 #include "squid.h"
-#include "ACLHTTPRepHeader.h"
-#include "ACLHTTPHeaderData.h"
-#include "ACLChecklist.h"
+#include "acl/HttpRepHeader.h"
+#include "acl/HttpHeaderData.h"
+#include "acl/Checklist.h"
 #include "HttpReply.h"
 
 ACL::Prototype ACLHTTPRepHeader::RegistryProtoype(&ACLHTTPRepHeader::RegistryEntry_, "rep_header");
@@ -44,7 +44,7 @@ ACL::Prototype ACLHTTPRepHeader::RegistryProtoype(&ACLHTTPRepHeader::RegistryEnt
 ACLStrategised<HttpHeader*> ACLHTTPRepHeader::RegistryEntry_(new ACLHTTPHeaderData, ACLHTTPRepHeaderStrategy::Instance(), "rep_header");
 
 int
-ACLHTTPRepHeaderStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLHTTPRepHeaderStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (&checklist->reply->header);
 }

diff --git a/src/ACLHTTPRepHeader.h b/src/acl/HttpRepHeader.h
similarity index 94%
rename from src/ACLHTTPRepHeader.h
rename to src/acl/HttpRepHeader.h
index 07f1109aea6dd0bf9011039cbb2064930bd4bc6a..2c38421e92c725ca56133fa9759cd628fb5cebec 100644 (file)
--- a/src/ACLHTTPRepHeader.h
+++ b/src/acl/HttpRepHeader.h
@@ -35,8 +35,8 @@
 #ifndef SQUID_ACLHTTPREPHEADER_H
 #define SQUID_ACLHTTPREPHEADER_H
 
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 #include "HttpHeader.h"
 
 /// \ingroup ACLAPI
@@ -44,7 +44,7 @@ class ACLHTTPRepHeaderStrategy : public ACLStrategy<HttpHeader*>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresReply() const { return true; }
 
     static ACLHTTPRepHeaderStrategy *Instance();

diff --git a/src/ACLHTTPReqHeader.cc b/src/acl/HttpReqHeader.cc
similarity index 94%
rename from src/ACLHTTPReqHeader.cc
rename to src/acl/HttpReqHeader.cc
index cbe7a5189afb7d49deed06e1046e5db237e46f81..a64b0d546645f9e68d4b864df02aac5fca2f7c3f 100644 (file)
--- a/src/ACLHTTPReqHeader.cc
+++ b/src/acl/HttpReqHeader.cc
@@ -34,9 +34,9 @@
  */
 
 #include "squid.h"
-#include "ACLHTTPReqHeader.h"
-#include "ACLHTTPHeaderData.h"
-#include "ACLChecklist.h"
+#include "acl/HttpReqHeader.h"
+#include "acl/HttpHeaderData.h"
+#include "acl/Checklist.h"
 #include "HttpRequest.h"
 
 ACL::Prototype ACLHTTPReqHeader::RegistryProtoype(&ACLHTTPReqHeader::RegistryEntry_, "req_header");
@@ -44,7 +44,7 @@ ACL::Prototype ACLHTTPReqHeader::RegistryProtoype(&ACLHTTPReqHeader::RegistryEnt
 ACLStrategised<HttpHeader*> ACLHTTPReqHeader::RegistryEntry_(new ACLHTTPHeaderData, ACLHTTPReqHeaderStrategy::Instance(), "req_header");
 
 int
-ACLHTTPReqHeaderStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLHTTPReqHeaderStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (&checklist->request->header);
 }

diff --git a/src/ACLHTTPReqHeader.h b/src/acl/HttpReqHeader.h
similarity index 94%
rename from src/ACLHTTPReqHeader.h
rename to src/acl/HttpReqHeader.h
index bccb40fa946cc6e1b8728cb65e37f5dcc0238505..aab33a2230a77bda46d80e5b28b784d4067fdc28 100644 (file)
--- a/src/ACLHTTPReqHeader.h
+++ b/src/acl/HttpReqHeader.h
@@ -35,8 +35,8 @@
 #ifndef SQUID_ACLHTTPREQHEADER_H
 #define SQUID_ACLHTTPREQHEADER_H
 
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 #include "HttpHeader.h"
 
 /// \ingroup ACLAPI
@@ -44,7 +44,7 @@ class ACLHTTPReqHeaderStrategy : public ACLStrategy<HttpHeader*>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const { return true; }
 
     static ACLHTTPReqHeaderStrategy *Instance();

diff --git a/src/ACLIdent.cc b/src/acl/Ident.cc
similarity index 92%
rename from src/ACLIdent.cc
rename to src/acl/Ident.cc
index 291563bba5d57de1e8042571113a548d74db7a16..7eddb18044560daf5a99290e960d81fa209e6e30 100644 (file)
--- a/src/ACLIdent.cc
+++ b/src/acl/Ident.cc
@@ -35,11 +35,10 @@
  */
 
 #include "squid.h"
-#include "ACLIdent.h"
-#include "authenticate.h"
-#include "ACLChecklist.h"
-#include "ACLRegexData.h"
-#include "ACLUserData.h"
+#include "acl/Ident.h"
+#include "acl/FilledChecklist.h"
+#include "acl/RegexData.h"
+#include "acl/UserData.h"
 #include "client_side.h"
 #include "ident.h"
 
@@ -79,8 +78,9 @@ ACLIdent::parse()
 }
 
 int
-ACLIdent::match(ACLChecklist *checklist)
+ACLIdent::match(ACLChecklist *cl)
 {
+    ACLFilledChecklist *checklist = Filled(cl);
     if (checklist->rfc931[0]) {
         return data->match(checklist->rfc931);
     } else if (checklist->conn() != NULL && checklist->conn()->rfc931[0]) {
@@ -124,8 +124,9 @@ IdentLookup::Instance()
 }
 
 void
-IdentLookup::checkForAsync(ACLChecklist *checklist)const
+IdentLookup::checkForAsync(ACLChecklist *cl)const
 {
+    ACLFilledChecklist *checklist = Filled(cl);
     if (checklist->conn() != NULL) {
         debugs(28, 3, "IdentLookup::checkForAsync: Doing ident lookup" );
         checklist->asyncInProgress(true);
@@ -141,7 +142,7 @@ IdentLookup::checkForAsync(ACLChecklist *checklist)const
 void
 IdentLookup::LookupDone(const char *ident, void *data)
 {
-    ACLChecklist *checklist = (ACLChecklist *)data;
+    ACLFilledChecklist *checklist = Filled(static_cast<ACLChecklist*>(data));
     assert (checklist->asyncState() == IdentLookup::Instance());
 
     if (ident) {

diff --git a/src/ACLMethod.cc b/src/acl/Method.cc
similarity index 92%
rename from src/ACLMethod.cc
rename to src/acl/Method.cc
index 2aea0f709d2a354fba1764135284cd6b610cd364..93a5edb80c5645a99544b042632d506ec9952eaf 100644 (file)
--- a/src/ACLMethod.cc
+++ b/src/acl/Method.cc
@@ -34,9 +34,9 @@
  */
 
 #include "squid.h"
-#include "ACLMethod.h"
-#include "ACLMethodData.h"
-#include "ACLChecklist.h"
+#include "acl/Method.h"
+#include "acl/MethodData.h"
+#include "acl/Checklist.h"
 #include "HttpRequest.h"
 
 /* explicit template instantiation required for some systems */
@@ -48,7 +48,7 @@ ACL::Prototype ACLMethod::RegistryProtoype(&ACLMethod::RegistryEntry_, "method")
 ACLStrategised<HttpRequestMethod> ACLMethod::RegistryEntry_(new ACLMethodData, ACLMethodStrategy::Instance(), "method");
 
 int
-ACLMethodStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLMethodStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (checklist->request->method);
 }

diff --git a/src/ACLMethod.h b/src/acl/Method.h
similarity index 94%
rename from src/ACLMethod.h
rename to src/acl/Method.h
index d69a6360aac006b52d89c1aa1dc42d49e666f042..c5d71ec34a5edf58ae1fbb77ce4d0f89a9928a10 100644 (file)
--- a/src/ACLMethod.h
+++ b/src/acl/Method.h
@@ -35,15 +35,15 @@
 #ifndef SQUID_ACLMETHOD_H
 #define SQUID_ACLMETHOD_H
 
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 /// \ingroup ACLAPI
 class ACLMethodStrategy : public ACLStrategy<HttpRequestMethod>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLMethodStrategy *Instance();

diff --git a/src/ACLMyPort.cc b/src/acl/MyPort.cc
similarity index 92%
rename from src/ACLMyPort.cc
rename to src/acl/MyPort.cc
index 8a72ca258b8c2c974896aeeecfd6084d2e72b9f5..9cd9debfe6bdcf269e7cd9609214d18f1ba1707c 100644 (file)
--- a/src/ACLMyPort.cc
+++ b/src/acl/MyPort.cc
@@ -34,9 +34,9 @@
  */
 
 #include "squid.h"
-#include "ACLMyPort.h"
-#include "ACLIntRange.h"
-#include "ACLChecklist.h"
+#include "acl/MyPort.h"
+#include "acl/IntRange.h"
+#include "acl/Checklist.h"
 
 /* explicit template instantiation required for some systems */
 
@@ -47,7 +47,7 @@ ACL::Prototype ACLMyPort::RegistryProtoype(&ACLMyPort::RegistryEntry_, "myport")
 ACLStrategised<int> ACLMyPort::RegistryEntry_(new ACLIntRange, ACLMyPortStrategy::Instance(), "myport");
 
 int
-ACLMyPortStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLMyPortStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (checklist->my_addr.GetPort());
 }

diff --git a/src/ACLMyPort.h b/src/acl/MyPort.h
similarity index 94%
rename from src/ACLMyPort.h
rename to src/acl/MyPort.h
index 2316fe0dd4c834904a63a309df55a267a7b53542..2ebf30f6453abf605443361d45a70c6639f6a0f0 100644 (file)
--- a/src/ACLMyPort.h
+++ b/src/acl/MyPort.h
@@ -35,15 +35,15 @@
 #ifndef SQUID_ACLMYPORT_H
 #define SQUID_ACLMYPORT_H
 
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 /// \ingroup ACLAPI
 class ACLMyPortStrategy : public ACLStrategy<int>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLMyPortStrategy *Instance();
     /**
      * Not implemented to prevent copies of the instance.

diff --git a/src/ACLMyPortName.cc b/src/acl/MyPortName.cc
similarity index 92%
rename from src/ACLMyPortName.cc
rename to src/acl/MyPortName.cc
index fed20b69218ad993e08bc7a03960ba54079f5ccc..2a394e4a0e6324e7cb771d739da024267a456af2 100644 (file)
--- a/src/ACLMyPortName.cc
+++ b/src/acl/MyPortName.cc
@@ -35,9 +35,9 @@
 
 #include "squid.h"
 #include "ProtoPort.h"
-#include "ACLMyPortName.h"
-#include "ACLStringData.h"
-#include "ACLChecklist.h"
+#include "acl/MyPortName.h"
+#include "acl/StringData.h"
+#include "acl/Checklist.h"
 
 /* for ConnStateData */
 #include "client_side.h"
@@ -48,7 +48,7 @@ ACL::Prototype ACLMyPortName::RegistryProtoype(&ACLMyPortName::RegistryEntry_, "
 ACLStrategised<const char *> ACLMyPortName::RegistryEntry_(new ACLStringData, ACLMyPortNameStrategy::Instance(), "myportname");
 
 int
-ACLMyPortNameStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLMyPortNameStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     if (checklist->conn() != NULL)
         return data->match (checklist->conn()->port->name);

diff --git a/src/ACLMyPortName.h b/src/acl/MyPortName.h
similarity index 94%
rename from src/ACLMyPortName.h
rename to src/acl/MyPortName.h
index 65f92aac64c25e81953c7e558b81694885a4f26d..584aa196160395185eb60b4fab567e93b4aae6ec 100644 (file)
--- a/src/ACLMyPortName.h
+++ b/src/acl/MyPortName.h
@@ -35,14 +35,14 @@
 
 #ifndef SQUID_ACLMYPORTNAME_H
 #define SQUID_ACLMYPORTNAME_H
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLMyPortNameStrategy : public ACLStrategy<const char *>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLMyPortNameStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLPeerName.cc b/src/acl/PeerName.cc
similarity index 75%
rename from src/ACLPeerName.cc
rename to src/acl/PeerName.cc
index 091e1f741c5d2e1438a3987e57cc4b5523a81c32..41284f17d7e69bd3203973b1e7c6b72372578de3 100644 (file)
--- a/src/ACLPeerName.cc
+++ b/src/acl/PeerName.cc
@@ -1,14 +1,14 @@
 #include "squid.h"
-#include "ACLPeerName.h"
-#include "ACLStringData.h"
-#include "ACLChecklist.h"
+#include "acl/PeerName.h"
+#include "acl/StringData.h"
+#include "acl/Checklist.h"
 
 ACL::Prototype ACLPeerName::RegistryProtoype(&ACLPeerName::RegistryEntry_, "peername");
 
 ACLStrategised<const char *> ACLPeerName::RegistryEntry_(new ACLStringData, ACLPeerNameStrategy::Instance(), "peername");
 
 int
-ACLPeerNameStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLPeerNameStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     if (checklist->dst_peer != NULL && checklist->dst_peer->name != NULL)
         return data->match(checklist->dst_peer->name);

diff --git a/src/ACLPeerName.h b/src/acl/PeerName.h
similarity index 85%
rename from src/ACLPeerName.h
rename to src/acl/PeerName.h
index 40ca816af0e8306bc3caae5ad9e598cfd31b520e..cc69e7a025dff08d53c7379831f808420d07319a 100644 (file)
--- a/src/ACLPeerName.h
+++ b/src/acl/PeerName.h
@@ -1,14 +1,14 @@
 #ifndef SQUID_ACLPEERNAME_H
 #define SQUID_ACLPEERNAME_H
 
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLPeerNameStrategy : public ACLStrategy<const char *>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLPeerNameStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLProtocol.cc b/src/acl/Protocol.cc
similarity index 92%
rename from src/ACLProtocol.cc
rename to src/acl/Protocol.cc
index 119801dcb6841428c3a252cc2aa13da9e1c1babc..810d1c167953e41014549a94296ca1bab704fce4 100644 (file)
--- a/src/ACLProtocol.cc
+++ b/src/acl/Protocol.cc
@@ -34,9 +34,9 @@
  */
 
 #include "squid.h"
-#include "ACLProtocol.h"
-#include "ACLProtocolData.h"
-#include "ACLChecklist.h"
+#include "acl/Protocol.h"
+#include "acl/ProtocolData.h"
+#include "acl/Checklist.h"
 #include "HttpRequest.h"
 
 /* explicit template instantiation required for some systems */
@@ -48,7 +48,7 @@ ACL::Prototype ACLProtocol::RegistryProtoype(&ACLProtocol::RegistryEntry_, "prot
 ACLStrategised<protocol_t> ACLProtocol::RegistryEntry_(new ACLProtocolData, ACLProtocolStrategy::Instance(), "proto");
 
 int
-ACLProtocolStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLProtocolStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (checklist->request->protocol);
 }

diff --git a/src/ACLProtocol.h b/src/acl/Protocol.h
similarity index 94%
rename from src/ACLProtocol.h
rename to src/acl/Protocol.h
index 19acc46d061f7d029bcc5b819f2fd2b26813a8a7..e6a935db1b6c95933c4d8fa31ca8188c489947b5 100644 (file)
--- a/src/ACLProtocol.h
+++ b/src/acl/Protocol.h
@@ -35,14 +35,14 @@
 
 #ifndef SQUID_ACLPROTOCOL_H
 #define SQUID_ACLPROTOCOL_H
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLProtocolStrategy : public ACLStrategy<protocol_t>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLProtocolStrategy *Instance();

diff --git a/src/ACLReplyHeaderStrategy.h b/src/acl/ReplyHeaderStrategy.h
similarity index 92%
rename from src/ACLReplyHeaderStrategy.h
rename to src/acl/ReplyHeaderStrategy.h
index e1b55c2ea1f8f04d5733f5fa18632f1336422c48..22455d32081a66e3a0c0a64f39bc9f6561bc89d6 100644 (file)
--- a/src/ACLReplyHeaderStrategy.h
+++ b/src/acl/ReplyHeaderStrategy.h
@@ -36,10 +36,10 @@
 
 class ACLChecklist;
 
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLStrategy.h"
-#include "ACLChecklist.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Strategy.h"
+#include "acl/FilledChecklist.h"
 #include "HttpReply.h"
 
 template <http_hdr_type header>
@@ -47,7 +47,7 @@ class ACLReplyHeaderStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<char const *> * &, ACLChecklist *);
+    virtual int match (ACLData<char const *> * &, ACLFilledChecklist *);
     virtual bool requiresReply() const {return true;}
 
     static ACLReplyHeaderStrategy *Instance();
@@ -65,7 +65,7 @@ private:
 
 template <http_hdr_type header>
 int
-ACLReplyHeaderStrategy<header>::match (ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLReplyHeaderStrategy<header>::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char const *theHeader = checklist->reply->header.getStr(header);
 

diff --git a/src/ACLReplyMIMEType.h b/src/acl/ReplyMimeType.h
similarity index 91%
rename from src/ACLReplyMIMEType.h
rename to src/acl/ReplyMimeType.h
index a316b0c051be4189f5af30b4987d23a6c047b5ec..dbaea63c2a334d6b2f33d682985eeb18d71c1b19 100644 (file)
--- a/src/ACLReplyMIMEType.h
+++ b/src/acl/ReplyMimeType.h
@@ -34,8 +34,8 @@
 #ifndef SQUID_ACLREPLYMIMETYPE_H
 #define SQUID_ACLREPLYMIMETYPE_H
 
-#include "ACL.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Strategised.h"
 
 class ACLReplyMIMEType
 {
@@ -47,13 +47,13 @@ private:
 
 /* partial specialisation */
 
-#include "ACLData.h"
-#include "ACLReplyHeaderStrategy.h"
-#include "ACLChecklist.h"
+#include "acl/Data.h"
+#include "acl/ReplyHeaderStrategy.h"
+#include "acl/Checklist.h"
 
 template <>
 inline int
-ACLReplyHeaderStrategy<HDR_CONTENT_TYPE>::match(ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLReplyHeaderStrategy<HDR_CONTENT_TYPE>::match(ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char const *theHeader = checklist->reply->header.getStr(HDR_CONTENT_TYPE);
 

diff --git a/src/ACLRequestHeaderStrategy.h b/src/acl/RequestHeaderStrategy.h
similarity index 92%
rename from src/ACLRequestHeaderStrategy.h
rename to src/acl/RequestHeaderStrategy.h
index 00667d9a5a89e14b0de12272a20276a94c9c00b1..316696df106d0a988831efad195d3237858aecd0 100644 (file)
--- a/src/ACLRequestHeaderStrategy.h
+++ b/src/acl/RequestHeaderStrategy.h
@@ -35,11 +35,11 @@
 
 #ifndef SQUID_ACLREQUESTHEADERSTRATEGY_H
 #define SQUID_ACLREQUESTHEADERSTRATEGY_H
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLStrategy.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Strategy.h"
 #include "HttpRequest.h"
-#include "ACLChecklist.h"
+#include "acl/FilledChecklist.h"
 
 template <http_hdr_type header>
 
@@ -47,7 +47,7 @@ class ACLRequestHeaderStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<char const *> * &, ACLChecklist *);
+    virtual int match (ACLData<char const *> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLRequestHeaderStrategy *Instance();
@@ -65,7 +65,7 @@ private:
 
 template <http_hdr_type header>
 int
-ACLRequestHeaderStrategy<header>::match (ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLRequestHeaderStrategy<header>::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char const *theHeader = checklist->request->header.getStr(header);
 

diff --git a/src/ACLRequestMIMEType.h b/src/acl/RequestMimeType.h
similarity index 91%
rename from src/ACLRequestMIMEType.h
rename to src/acl/RequestMimeType.h
index 4829360e8bdc79b45c940ff7ce9dc548db2cb060..2366fdac4e9e0ad0690d950c18be3fabe3ce2788 100644 (file)
--- a/src/ACLRequestMIMEType.h
+++ b/src/acl/RequestMimeType.h
@@ -34,8 +34,8 @@
 #ifndef SQUID_ACLREQUESTMIMETYPE_H
 #define SQUID_ACLREQUESTMIMETYPE_H
 
-#include "ACL.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Strategised.h"
 
 class ACLRequestMIMEType
 {
@@ -47,13 +47,13 @@ private:
 
 /* partial specialisation */
 
-#include "ACLData.h"
-#include "ACLRequestHeaderStrategy.h"
-#include "ACLChecklist.h"
+#include "acl/Data.h"
+#include "acl/RequestHeaderStrategy.h"
+#include "acl/Checklist.h"
 
 template <>
 inline int
-ACLRequestHeaderStrategy<HDR_CONTENT_TYPE>::match (ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLRequestHeaderStrategy<HDR_CONTENT_TYPE>::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char const *theHeader = checklist->request->header.getStr(HDR_CONTENT_TYPE);
 

diff --git a/src/ACLSourceASN.h b/src/acl/SourceAsn.h
similarity index 94%
rename from src/ACLSourceASN.h
rename to src/acl/SourceAsn.h
index 486f56b41d70f722b0bedb2109e731eb4527adac..ffd8abcd631c1effc196a537764dfab8cb825fd4 100644 (file)
--- a/src/ACLSourceASN.h
+++ b/src/acl/SourceAsn.h
@@ -32,19 +32,19 @@
 #define SQUID_ACLSOURCEASN_H
 
 #if 0
-#include "ACLASN.h"
+#include "acl/Asn.h"
 #endif
 
 class ACLChecklist;
 
-#include "ACLStrategy.h"
+#include "acl/Strategy.h"
 #include "ip/IpAddress.h"
 
 class ACLSourceASNStrategy : public ACLStrategy<IpAddress>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLSourceASNStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLSourceDomain.h b/src/acl/SourceDomain.h
similarity index 93%
rename from src/ACLSourceDomain.h
rename to src/acl/SourceDomain.h
index 415aabecf7d67893f2abb50e9535da8f52eed0cc..69629cefdcb5d84ea6bbfcd1a4ea802f6f468709 100644 (file)
--- a/src/ACLSourceDomain.h
+++ b/src/acl/SourceDomain.h
@@ -35,16 +35,16 @@
 
 #ifndef SQUID_ACLSOURCEDOMAIN_H
 #define SQUID_ACLSOURCEDOMAIN_H
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLChecklist.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Checklist.h"
+#include "acl/Strategised.h"
 
 class ACLSourceDomainStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLSourceDomainStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLSslError.cc b/src/acl/SslError.cc
similarity index 75%
rename from src/ACLSslError.cc
rename to src/acl/SslError.cc
index 9449b91c95a2e5e83ab2a22bdea70e43825d0e95..59bc499d72ffdb0fa43e87b9f0ad20127bc5354b 100644 (file)
--- a/src/ACLSslError.cc
+++ b/src/acl/SslError.cc
@@ -4,9 +4,9 @@
  */
 
 #include "squid.h"
-#include "ACLSslError.h"
-#include "ACLSslErrorData.h"
-#include "ACLChecklist.h"
+#include "acl/SslError.h"
+#include "acl/SslErrorData.h"
+#include "acl/Checklist.h"
 
 /* explicit template instantiation required for some systems */
 
@@ -17,7 +17,7 @@ ACL::Prototype ACLSslError::RegistryProtoype(&ACLSslError::RegistryEntry_, "ssl_
 ACLStrategised<int> ACLSslError::RegistryEntry_(new ACLSslErrorData, ACLSslErrorStrategy::Instance(), "ssl_error");
 
 int
-ACLSslErrorStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLSslErrorStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (checklist->ssl_error);
 }

diff --git a/src/ACLSslError.h b/src/acl/SslError.h
similarity index 85%
rename from src/ACLSslError.h
rename to src/acl/SslError.h
index 1218827dec52852a77709a965fa4093ce2e1c7b3..e18cf1c7bcaf84dc85d1789fec581f69531de223 100644 (file)
--- a/src/ACLSslError.h
+++ b/src/acl/SslError.h
@@ -5,14 +5,14 @@
 
 #ifndef SQUID_ACLSSL_ERROR_H
 #define SQUID_ACLSSL_ERROR_H
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLSslErrorStrategy : public ACLStrategy<int>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     static ACLSslErrorStrategy *Instance();
     /* Not implemented to prevent copies of the instance. */
     /* Not private to prevent brain dead g+++ warnings about

diff --git a/src/ACLTime.cc b/src/acl/Time.cc
similarity index 93%
rename from src/ACLTime.cc
rename to src/acl/Time.cc
index bccb06ba0df4b02d7831c08999ebfd5f1e9558de..8733128f63b221df002bc8a877e70188fa21cf47 100644 (file)
--- a/src/ACLTime.cc
+++ b/src/acl/Time.cc
@@ -35,15 +35,15 @@
  */
 
 #include "squid.h"
-#include "ACLTime.h"
-#include "ACLTimeData.h"
+#include "acl/Time.h"
+#include "acl/TimeData.h"
 #include "SquidTime.h"
 
 ACL::Prototype ACLTime::RegistryProtoype(&ACLTime::RegistryEntry_, "time");
 ACLStrategised<time_t> ACLTime::RegistryEntry_(new ACLTimeData, ACLTimeStrategy::Instance(), "time");
 
 int
-ACLTimeStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLTimeStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (squid_curtime);
 }

diff --git a/src/ACLUrl.cc b/src/acl/Url.cc
similarity index 92%
rename from src/ACLUrl.cc
rename to src/acl/Url.cc
index 1941a72d1f396cb1201cfce80b9bc92fd270d9e0..1cff64ed394366105d3cdbd5f67bccc464d7c865 100644 (file)
--- a/src/ACLUrl.cc
+++ b/src/acl/Url.cc
@@ -35,15 +35,15 @@
  */
 
 #include "squid.h"
-#include "ACLUrl.h"
-#include "ACLChecklist.h"
-#include "ACLRegexData.h"
+#include "acl/Url.h"
+#include "acl/Checklist.h"
+#include "acl/RegexData.h"
 
 ACL::Prototype ACLUrl::RegistryProtoype(&ACLUrl::RegistryEntry_, "url_regex");
 ACLStrategised<char const *> ACLUrl::RegistryEntry_(new ACLRegexData, ACLUrlStrategy::Instance(), "url_regex");
 
 int
-ACLUrlStrategy::match (ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLUrlStrategy::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char *esc_buf = xstrdup(urlCanonical(checklist->request));
     rfc1738_unescape(esc_buf);

diff --git a/src/ACLUrl.h b/src/acl/Url.h
similarity index 93%
rename from src/ACLUrl.h
rename to src/acl/Url.h
index 639159104e517e814b6123fd74dc970dbe83a3ee..d11e04fb9ec3841f5c7c6601d7cfdfbf8e93e99d 100644 (file)
--- a/src/ACLUrl.h
+++ b/src/acl/Url.h
@@ -35,15 +35,15 @@
 
 #ifndef SQUID_ACLURL_H
 #define SQUID_ACLURL_H
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Strategised.h"
 
 class ACLUrlStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<char const *> * &, ACLChecklist *);
+    virtual int match (ACLData<char const *> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLUrlStrategy *Instance();

diff --git a/src/ACLUrlPath.cc b/src/acl/UrlPath.cc
similarity index 92%
rename from src/ACLUrlPath.cc
rename to src/acl/UrlPath.cc
index 02b8ecfd193607f64d1a12dfa3943996188c7263..71a1671b126d0b4b5b1bf029abd2b412884d01fd 100644 (file)
--- a/src/ACLUrlPath.cc
+++ b/src/acl/UrlPath.cc
@@ -35,9 +35,9 @@
  */
 
 #include "squid.h"
-#include "ACLUrlPath.h"
-#include "ACLChecklist.h"
-#include "ACLRegexData.h"
+#include "acl/UrlPath.h"
+#include "acl/Checklist.h"
+#include "acl/RegexData.h"
 #include "HttpRequest.h"
 
 ACL::Prototype ACLUrlPath::LegacyRegistryProtoype(&ACLUrlPath::RegistryEntry_, "pattern");
@@ -45,7 +45,7 @@ ACL::Prototype ACLUrlPath::RegistryProtoype(&ACLUrlPath::RegistryEntry_, "urlpat
 ACLStrategised<char const *> ACLUrlPath::RegistryEntry_(new ACLRegexData, ACLUrlPathStrategy::Instance(), "urlpath_regex");
 
 int
-ACLUrlPathStrategy::match (ACLData<char const *> * &data, ACLChecklist *checklist)
+ACLUrlPathStrategy::match (ACLData<char const *> * &data, ACLFilledChecklist *checklist)
 {
     char *esc_buf = xstrdup(checklist->request->urlpath.termedBuf());
     rfc1738_unescape(esc_buf);

diff --git a/src/ACLUrlPath.h b/src/acl/UrlPath.h
similarity index 92%
rename from src/ACLUrlPath.h
rename to src/acl/UrlPath.h
index fdd3d6f65b434bf851dedc276b4b0a3ff93b91ab..8a791c2d3d252c54c2e1314b558d29f466d537c8 100644 (file)
--- a/src/ACLUrlPath.h
+++ b/src/acl/UrlPath.h
@@ -35,16 +35,16 @@
 
 #ifndef SQUID_ACLURLPATH_H
 #define SQUID_ACLURLPATH_H
-#include "ACL.h"
-#include "ACLData.h"
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Acl.h"
+#include "acl/Data.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLUrlPathStrategy : public ACLStrategy<char const *>
 {
 
 public:
-    virtual int match (ACLData<char const *> * &, ACLChecklist *);
+    virtual int match (ACLData<char const *> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLUrlPathStrategy *Instance();

diff --git a/src/ACLUrlPort.cc b/src/acl/UrlPort.cc
similarity index 91%
rename from src/ACLUrlPort.cc
rename to src/acl/UrlPort.cc
index ea1c458b613e6c04418b96d01f7bbede34fabdbd..247d7748bac1f5d271f7e64193b5869e30eb9cf4 100644 (file)
--- a/src/ACLUrlPort.cc
+++ b/src/acl/UrlPort.cc
@@ -34,16 +34,16 @@
  */
 
 #include "squid.h"
-#include "ACLUrlPort.h"
-#include "ACLIntRange.h"
-#include "ACLChecklist.h"
+#include "acl/UrlPort.h"
+#include "acl/IntRange.h"
+#include "acl/Checklist.h"
 #include "HttpRequest.h"
 
 ACL::Prototype ACLUrlPort::RegistryProtoype(&ACLUrlPort::RegistryEntry_, "port");
 ACLStrategised<int> ACLUrlPort::RegistryEntry_(new ACLIntRange, ACLUrlPortStrategy::Instance(), "port");
 
 int
-ACLUrlPortStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLUrlPortStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     return data->match (checklist->request->port);
 }

diff --git a/src/ACLUrlPort.h b/src/acl/UrlPort.h
similarity index 94%
rename from src/ACLUrlPort.h
rename to src/acl/UrlPort.h
index c5c3f831dc7139974815ba91dc5629dfaa5fb7b1..8752b91038abd29d6e323cb64e074024fef14bf5 100644 (file)
--- a/src/ACLUrlPort.h
+++ b/src/acl/UrlPort.h
@@ -35,14 +35,14 @@
 
 #ifndef SQUID_ACLURLPORT_H
 #define SQUID_ACLURLPORT_H
-#include "ACLStrategy.h"
-#include "ACLStrategised.h"
+#include "acl/Strategy.h"
+#include "acl/Strategised.h"
 
 class ACLUrlPortStrategy : public ACLStrategy<int>
 {
 
 public:
-    virtual int match (ACLData<MatchType> * &, ACLChecklist *);
+    virtual int match (ACLData<MatchType> * &, ACLFilledChecklist *);
     virtual bool requiresRequest() const {return true;}
 
     static ACLUrlPortStrategy *Instance();

diff --git a/src/adaptation/AccessCheck.cc b/src/adaptation/AccessCheck.cc
index 0ecf67b2cdfb2cef0611b86f61291aeaee74ce9d..d58d9867ca2c89cc7bf9758f044894be5b3314f9 100644 (file)
--- a/src/adaptation/AccessCheck.cc
+++ b/src/adaptation/AccessCheck.cc
@@ -2,10 +2,9 @@
 #include "structs.h"
 
 #include "ConfigParser.h"
-#include "ACL.h"
 #include "HttpRequest.h"
 #include "HttpReply.h"
-#include "ACLChecklist.h"
+#include "acl/FilledChecklist.h"
 #include "adaptation/Service.h"
 #include "adaptation/ServiceGroups.h"
 #include "adaptation/AccessRule.h"
@@ -106,7 +105,7 @@ Adaptation::AccessCheck::checkCandidates()
         if (AccessRule *r = FindRule(topCandidate())) {
             /* BUG 2526: what to do when r->acl is empty?? */
             // XXX: we do not have access to conn->rfc931 here.
-            acl_checklist = aclChecklistCreate(r->acl, req, dash_str);
+            acl_checklist = new ACLFilledChecklist(r->acl, req, dash_str);
             acl_checklist->reply = rep ? HTTPMSGLOCK(rep) : NULL;
             acl_checklist->nonBlockingCheck(AccessCheckCallbackWrapper, this);
             return;

diff --git a/src/adaptation/AccessCheck.h b/src/adaptation/AccessCheck.h
index 0d384be58296e13acec91a249fe9568b9580b0ec..9852e2e6fad38b2ec16c773c7484c0bf5f7fe7c7 100644 (file)
--- a/src/adaptation/AccessCheck.h
+++ b/src/adaptation/AccessCheck.h
@@ -7,6 +7,7 @@
 
 class HttpRequest;
 class HttpReply;
+class ACLFilledChecklist;
 
 namespace Adaptation
 {
@@ -35,7 +36,7 @@ private:
     HttpReply *rep;
     AccessCheckCallback *callback;
     void *callback_data;
-    ACLChecklist *acl_checklist;
+    ACLFilledChecklist *acl_checklist;
 
     typedef int Candidate;
     typedef Vector<Candidate> Candidates;

diff --git a/src/asn.cc b/src/asn.cc
index 89e5ce6cc44518fa4074fa51f50215e5381ef592..747dffe7383da7ff6c9f7af23d1410d6aba7afff 100644 (file)
--- a/src/asn.cc
+++ b/src/asn.cc
@@ -39,11 +39,11 @@
 #include "HttpRequest.h"
 #include "StoreClient.h"
 #include "Store.h"
-#include "ACL.h"
-#include "ACLASN.h"
-#include "ACLSourceASN.h"
-#include "ACLDestinationASN.h"
-#include "ACLDestinationIP.h"
+#include "acl/Acl.h"
+#include "acl/Asn.h"
+#include "acl/SourceAsn.h"
+#include "acl/DestinationAsn.h"
+#include "acl/DestinationIp.h"
 #include "HttpReply.h"
 #include "forward.h"
 #include "wordlist.h"
@@ -605,7 +605,7 @@ ACL::Prototype ACLASN::DestinationRegistryProtoype(&ACLASN::DestinationRegistryE
 ACLStrategised<IpAddress> ACLASN::DestinationRegistryEntry_(new ACLASN, ACLDestinationASNStrategy::Instance(), "dst_as");
 
 int
-ACLSourceASNStrategy::match (ACLData<IpAddress> * &data, ACLChecklist *checklist)
+ACLSourceASNStrategy::match (ACLData<IpAddress> * &data, ACLFilledChecklist *checklist)
 {
     return data->match(checklist->src_addr);
 }
@@ -620,7 +620,7 @@ ACLSourceASNStrategy ACLSourceASNStrategy::Instance_;
 
 
 int
-ACLDestinationASNStrategy::match (ACLData<MatchType> * &data, ACLChecklist *checklist)
+ACLDestinationASNStrategy::match (ACLData<MatchType> * &data, ACLFilledChecklist *checklist)
 {
     const ipcache_addrs *ia = ipcache_gethostbyname(checklist->request->GetHost(), IP_LOOKUP_IF_MISS);
 

diff --git a/src/client_side_reply.cc b/src/client_side_reply.cc
index 277a215ff739f4f884a27bdaead8df74646332b7..1d62ea48f58fe6755954d6e5d38e47c7555cd2c9 100644 (file)
--- a/src/client_side_reply.cc
+++ b/src/client_side_reply.cc
@@ -52,8 +52,8 @@
 #endif
 #include "MemObject.h"
 #include "fde.h"
-#include "ACLChecklist.h"
-#include "ACL.h"
+#include "acl/FilledChecklist.h"
+#include "acl/Gadgets.h"
 #if DELAY_POOLS
 #include "DelayPools.h"
 #endif
@@ -1785,8 +1785,8 @@ clientReplyContext::processReplyAccess ()
     }
 
     /** Process http_reply_access lists */
-    ACLChecklist *replyChecklist;
-    replyChecklist = clientAclChecklistCreate(Config.accessList.reply, http);
+    ACLFilledChecklist *replyChecklist =
+        clientAclChecklistCreate(Config.accessList.reply, http);
     replyChecklist->reply = HTTPMSGLOCK(reply);
     replyChecklist->nonBlockingCheck(ProcessReplyAccessResult, this);
 }

diff --git a/src/peer_select.cc b/src/peer_select.cc
index e9f4a5c3b2b2d9579646188220505264dc8b6589..f0ec099988678a5dd75f93f5b0157b14e316e408 100644 (file)
--- a/src/peer_select.cc
+++ b/src/peer_select.cc
@@ -38,7 +38,7 @@
 #include "Store.h"
 #include "ICP.h"
 #include "HttpRequest.h"
-#include "ACLChecklist.h"
+#include "acl/FilledChecklist.h"
 #include "htcp.h"
 #include "forward.h"
 #include "SquidTime.h"
@@ -294,7 +294,7 @@ peerSelectFoo(ps_state * ps)
     if (ps->direct == DIRECT_UNKNOWN) {
         if (ps->always_direct == 0 && Config.accessList.AlwaysDirect) {
             /** check always_direct; */
-            ps->acl_checklist = aclChecklistCreate(
+            ps->acl_checklist = new ACLFilledChecklist(
                                     Config.accessList.AlwaysDirect,
                                     request,
                                     NULL);             /* ident */
@@ -305,7 +305,7 @@ peerSelectFoo(ps_state * ps)
             ps->direct = DIRECT_YES;
         } else if (ps->never_direct == 0 && Config.accessList.NeverDirect) {
             /** check never_direct; */
-            ps->acl_checklist = aclChecklistCreate(
+            ps->acl_checklist = new ACLFilledChecklist(
                                     Config.accessList.NeverDirect,
                                     request,
                                     NULL);             /* ident */