#include "acl/MethodData.h"
#include "acl/MyPortName.h"
#include "acl/Note.h"
+#include "acl/Node.h"
#include "acl/NoteData.h"
#include "acl/PeerName.h"
#include "acl/Protocol.h"
template <class Parent>
class FinalizedParameterizedNode: public Parent
{
- MEMPROXY_CLASS(
Acl::FinalizedParameterizedNode<Parent>);
+ MEMPROXY_CLASS(FinalizedParameterizedNode<Parent>);
public:
using Parameters = typename Parent::Parameters;
{
/* the registration order does not matter */
- // The explicit return type (ACL*) for lambdas is needed because the type
- // of the return expression inside lambda is not ACL* but AclFoo* while
- // Acl::Maker is defined to return ACL*.
-
- RegisterMaker("all-of", [](TypeName)->ACL* { return new Acl::AllOf; }); // XXX: Add name parameter to ctor
- RegisterMaker("any-of", [](TypeName)->ACL* { return new Acl::AnyOf; }); // XXX: Add name parameter to ctor
- RegisterMaker("random", [](TypeName name)->ACL* { return new ACLRandom(name); });
- RegisterMaker("time", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::CurrentTimeCheck>(name, new ACLTimeData); });
- RegisterMaker("src_as", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::SourceAsnCheck>(name, new ACLASN); });
- RegisterMaker("dst_as", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::DestinationAsnCheck>(name, new ACLASN); });
- RegisterMaker("browser", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::RequestHeaderCheck<Http::HdrType::USER_AGENT> >(name, new ACLRegexData); });
-
- RegisterMaker("dstdomain", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::DestinationDomainCheck>(name, new ACLDomainData); });
- RegisterMaker("dstdom_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::DestinationDomainCheck>(name, new ACLRegexData); });
- Acl::FinalizedParameterizedNode<Acl::DestinationDomainCheck>::PreferAllocatorLabelPrefix("dstdomain+");
-
- RegisterMaker("dst", [](TypeName)->ACL* { return new ACLDestinationIP; }); // XXX: Add name parameter to ctor
- RegisterMaker("hier_code", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::HierCodeCheck>(name, new ACLHierCodeData); });
- RegisterMaker("rep_header", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::HttpRepHeaderCheck>(name, new ACLHTTPHeaderData); });
- RegisterMaker("req_header", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::HttpReqHeaderCheck>(name, new ACLHTTPHeaderData); });
- RegisterMaker("http_status", [](TypeName name)->ACL* { return new ACLHTTPStatus(name); });
- RegisterMaker("maxconn", [](TypeName name)->ACL* { return new ACLMaxConnection(name); });
- RegisterMaker("method", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::MethodCheck>(name, new ACLMethodData); });
- RegisterMaker("localip", [](TypeName)->ACL* { return new ACLLocalIP; }); // XXX: Add name parameter to ctor
- RegisterMaker("localport", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::LocalPortCheck>(name, new ACLIntRange); });
- RegisterMaker("myportname", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::MyPortNameCheck>(name, new ACLStringData); });
-
- RegisterMaker("peername", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::PeerNameCheck>(name, new ACLStringData); });
- RegisterMaker("peername_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::PeerNameCheck>(name, new ACLRegexData); });
- Acl::FinalizedParameterizedNode<Acl::PeerNameCheck>::PreferAllocatorLabelPrefix("peername+");
-
- RegisterMaker("proto", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ProtocolCheck>(name, new ACLProtocolData); });
- RegisterMaker("referer_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::RequestHeaderCheck<Http::HdrType::REFERER> >(name, new ACLRegexData); });
- RegisterMaker("rep_mime_type", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ReplyHeaderCheck<Http::HdrType::CONTENT_TYPE> >(name, new ACLRegexData); });
- RegisterMaker("req_mime_type", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::RequestHeaderCheck<Http::HdrType::CONTENT_TYPE> >(name, new ACLRegexData); });
-
- RegisterMaker("srcdomain", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::SourceDomainCheck>(name, new ACLDomainData); });
- RegisterMaker("srcdom_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::SourceDomainCheck>(name, new ACLRegexData); });
- Acl::FinalizedParameterizedNode<Acl::SourceDomainCheck>::PreferAllocatorLabelPrefix("srcdomain+");
-
- RegisterMaker("src", [](TypeName)->ACL* { return new ACLSourceIP; }); // XXX: Add name parameter to ctor
- RegisterMaker("url_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::UrlCheck>(name, new ACLRegexData); });
- RegisterMaker("urllogin", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::UrlLoginCheck>(name, new ACLRegexData); });
- RegisterMaker("urlpath_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::UrlPathCheck>(name, new ACLRegexData); });
- RegisterMaker("port", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::UrlPortCheck>(name, new ACLIntRange); });
- RegisterMaker("external", [](TypeName name)->ACL* { return new ACLExternal(name); });
- RegisterMaker("squid_error", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::SquidErrorCheck>(name, new ACLSquidErrorData); });
- RegisterMaker("connections_encrypted", [](TypeName name)->ACL* { return new Acl::ConnectionsEncrypted(name); });
- RegisterMaker("tag", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::TagCheck>(name, new ACLStringData); });
- RegisterMaker("note", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::NoteCheck>(name, new ACLNoteData); });
- RegisterMaker("annotate_client", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::AnnotateClientCheck>(name, new ACLAnnotationData); });
- RegisterMaker("annotate_transaction", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::AnnotateTransactionCheck>(name, new ACLAnnotationData); });
- RegisterMaker("has", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::HasComponentCheck>(name, new ACLHasComponentData); });
- RegisterMaker("transaction_initiator", [](TypeName name)->ACL* {return new TransactionInitiator(name);});
+ // The explicit return type (Acl::Node*) for lambdas is needed because the type
+ // of the return expression inside lambda is not Node* but AclFoo* while
+ // Maker is defined to return Node*.
+
+ RegisterMaker("all-of", [](TypeName)->Node* { return new AllOf; }); // XXX: Add name parameter to ctor
+ RegisterMaker("any-of", [](TypeName)->Node* { return new AnyOf; }); // XXX: Add name parameter to ctor
+ RegisterMaker("random", [](TypeName name)->Node* { return new ACLRandom(name); });
+ RegisterMaker("time", [](TypeName name)->Node* { return new FinalizedParameterizedNode<CurrentTimeCheck>(name, new ACLTimeData); });
+ RegisterMaker("src_as", [](TypeName name)->Node* { return new FinalizedParameterizedNode<SourceAsnCheck>(name, new ACLASN); });
+ RegisterMaker("dst_as", [](TypeName name)->Node* { return new FinalizedParameterizedNode<DestinationAsnCheck>(name, new ACLASN); });
+ RegisterMaker("browser", [](TypeName name)->Node* { return new FinalizedParameterizedNode<RequestHeaderCheck<Http::HdrType::USER_AGENT> >(name, new ACLRegexData); });
+
+ RegisterMaker("dstdomain", [](TypeName name)->Node* { return new FinalizedParameterizedNode<DestinationDomainCheck>(name, new ACLDomainData); });
+ RegisterMaker("dstdom_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<DestinationDomainCheck>(name, new ACLRegexData); });
+ FinalizedParameterizedNode<DestinationDomainCheck>::PreferAllocatorLabelPrefix("dstdomain+");
+
+ RegisterMaker("dst", [](TypeName)->Node* { return new ACLDestinationIP; }); // XXX: Add name parameter to ctor
+ RegisterMaker("hier_code", [](TypeName name)->Node* { return new FinalizedParameterizedNode<HierCodeCheck>(name, new ACLHierCodeData); });
+ RegisterMaker("rep_header", [](TypeName name)->Node* { return new FinalizedParameterizedNode<HttpRepHeaderCheck>(name, new ACLHTTPHeaderData); });
+ RegisterMaker("req_header", [](TypeName name)->Node* { return new FinalizedParameterizedNode<HttpReqHeaderCheck>(name, new ACLHTTPHeaderData); });
+ RegisterMaker("http_status", [](TypeName name)->Node* { return new ACLHTTPStatus(name); });
+ RegisterMaker("maxconn", [](TypeName name)->Node* { return new ACLMaxConnection(name); });
+ RegisterMaker("method", [](TypeName name)->Node* { return new FinalizedParameterizedNode<MethodCheck>(name, new ACLMethodData); });
+ RegisterMaker("localip", [](TypeName)->Node* { return new ACLLocalIP; }); // XXX: Add name parameter to ctor
+ RegisterMaker("localport", [](TypeName name)->Node* { return new FinalizedParameterizedNode<LocalPortCheck>(name, new ACLIntRange); });
+ RegisterMaker("myportname", [](TypeName name)->Node* { return new FinalizedParameterizedNode<MyPortNameCheck>(name, new ACLStringData); });
+
+ RegisterMaker("peername", [](TypeName name)->Node* { return new FinalizedParameterizedNode<PeerNameCheck>(name, new ACLStringData); });
+ RegisterMaker("peername_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<PeerNameCheck>(name, new ACLRegexData); });
+ FinalizedParameterizedNode<PeerNameCheck>::PreferAllocatorLabelPrefix("peername+");
+
+ RegisterMaker("proto", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ProtocolCheck>(name, new ACLProtocolData); });
+ RegisterMaker("referer_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<RequestHeaderCheck<Http::HdrType::REFERER> >(name, new ACLRegexData); });
+ RegisterMaker("rep_mime_type", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ReplyHeaderCheck<Http::HdrType::CONTENT_TYPE> >(name, new ACLRegexData); });
+ RegisterMaker("req_mime_type", [](TypeName name)->Node* { return new FinalizedParameterizedNode<RequestHeaderCheck<Http::HdrType::CONTENT_TYPE> >(name, new ACLRegexData); });
+
+ RegisterMaker("srcdomain", [](TypeName name)->Node* { return new FinalizedParameterizedNode<SourceDomainCheck>(name, new ACLDomainData); });
+ RegisterMaker("srcdom_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<SourceDomainCheck>(name, new ACLRegexData); });
+ FinalizedParameterizedNode<SourceDomainCheck>::PreferAllocatorLabelPrefix("srcdomain+");
+
+ RegisterMaker("src", [](TypeName)->Node* { return new ACLSourceIP; }); // XXX: Add name parameter to ctor
+ RegisterMaker("url_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<UrlCheck>(name, new ACLRegexData); });
+ RegisterMaker("urllogin", [](TypeName name)->Node* { return new FinalizedParameterizedNode<UrlLoginCheck>(name, new ACLRegexData); });
+ RegisterMaker("urlpath_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<UrlPathCheck>(name, new ACLRegexData); });
+ RegisterMaker("port", [](TypeName name)->Node* { return new FinalizedParameterizedNode<UrlPortCheck>(name, new ACLIntRange); });
+ RegisterMaker("external", [](TypeName name)->Node* { return new ACLExternal(name); });
+ RegisterMaker("squid_error", [](TypeName name)->Node* { return new FinalizedParameterizedNode<SquidErrorCheck>(name, new ACLSquidErrorData); });
+ RegisterMaker("connections_encrypted", [](TypeName name)->Node* { return new ConnectionsEncrypted(name); });
+ RegisterMaker("tag", [](TypeName name)->Node* { return new FinalizedParameterizedNode<TagCheck>(name, new ACLStringData); });
+ RegisterMaker("note", [](TypeName name)->Node* { return new FinalizedParameterizedNode<NoteCheck>(name, new ACLNoteData); });
+ RegisterMaker("annotate_client", [](TypeName name)->Node* { return new FinalizedParameterizedNode<AnnotateClientCheck>(name, new ACLAnnotationData); });
+ RegisterMaker("annotate_transaction", [](TypeName name)->Node* { return new FinalizedParameterizedNode<AnnotateTransactionCheck>(name, new ACLAnnotationData); });
+ RegisterMaker("has", [](TypeName name)->Node* { return new FinalizedParameterizedNode<HasComponentCheck>(name, new ACLHasComponentData); });
+ RegisterMaker("transaction_initiator", [](TypeName name)->Node* {return new TransactionInitiator(name);});
#if USE_LIBNETFILTERCONNTRACK
- RegisterMaker("clientside_mark", [](TypeName)->ACL* { return new Acl::ConnMark; }); // XXX: Add name parameter to ctor
- RegisterMaker("client_connection_mark", [](TypeName)->ACL* { return new Acl::ConnMark; }); // XXX: Add name parameter to ctor
+ RegisterMaker("clientside_mark", [](TypeName)->Node* { return new ConnMark; }); // XXX: Add name parameter to ctor
+ RegisterMaker("client_connection_mark", [](TypeName)->Node* { return new ConnMark; }); // XXX: Add name parameter to ctor
#endif
#if USE_OPENSSL
- RegisterMaker("ssl_error", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::CertificateErrorCheck>(name, new ACLSslErrorData); });
+ RegisterMaker("ssl_error", [](TypeName name)->Node* { return new FinalizedParameterizedNode<CertificateErrorCheck>(name, new ACLSslErrorData); });
- RegisterMaker("user_cert", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ClientCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509UserAttribute, "*")); });
- RegisterMaker("ca_cert", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ClientCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509CAAttribute, "*")); });
- Acl::FinalizedParameterizedNode<Acl::ClientCertificateCheck>::PreferAllocatorLabelPrefix("user_cert+");
+ RegisterMaker("user_cert", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ClientCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509UserAttribute, "*")); });
+ RegisterMaker("ca_cert", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ClientCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509CAAttribute, "*")); });
+ FinalizedParameterizedNode<ClientCertificateCheck>::PreferAllocatorLabelPrefix("user_cert+");
- RegisterMaker("server_cert_fingerprint", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ServerCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509Fingerprint, nullptr, true)); });
- RegisterMaker("at_step", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::AtStepCheck>(name, new ACLAtStepData); });
+ RegisterMaker("server_cert_fingerprint", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ServerCertificateCheck>(name, new ACLCertificateData(Ssl::GetX509Fingerprint, nullptr, true)); });
+ RegisterMaker("at_step", [](TypeName name)->Node* { return new FinalizedParameterizedNode<AtStepCheck>(name, new ACLAtStepData); });
- RegisterMaker("ssl::server_name", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ServerNameCheck>(name, new ACLServerNameData); });
- RegisterMaker("ssl::server_name_regex", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::ServerNameCheck>(name, new ACLRegexData); });
- Acl::FinalizedParameterizedNode<Acl::ServerNameCheck>::PreferAllocatorLabelPrefix("ssl::server_name+");
+ RegisterMaker("ssl::server_name", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ServerNameCheck>(name, new ACLServerNameData); });
+ RegisterMaker("ssl::server_name_regex", [](TypeName name)->Node* { return new FinalizedParameterizedNode<ServerNameCheck>(name, new ACLRegexData); });
+ FinalizedParameterizedNode<ServerNameCheck>::PreferAllocatorLabelPrefix("ssl::server_name+");
#endif
#if USE_SQUID_EUI
- RegisterMaker("arp", [](TypeName name)->ACL* { return new ACLARP(name); });
- RegisterMaker("eui64", [](TypeName name)->ACL* { return new ACLEui64(name); });
+ RegisterMaker("arp", [](TypeName name)->Node* { return new ACLARP(name); });
+ RegisterMaker("eui64", [](TypeName name)->Node* { return new ACLEui64(name); });
#endif
#if USE_IDENT
- RegisterMaker("ident", [](TypeName name)->ACL* { return new ACLIdent(new ACLUserData, name); });
- RegisterMaker("ident_regex", [](TypeName name)->ACL* { return new ACLIdent(new ACLRegexData, name); });
+ RegisterMaker("ident", [](TypeName name)->Node* { return new ACLIdent(new ACLUserData, name); });
+ RegisterMaker("ident_regex", [](TypeName name)->Node* { return new ACLIdent(new ACLRegexData, name); });
#endif
#if USE_AUTH
- RegisterMaker("ext_user", [](TypeName name)->ACL* { return new ACLExtUser(new ACLUserData, name); });
- RegisterMaker("ext_user_regex", [](TypeName name)->ACL* { return new ACLExtUser(new ACLRegexData, name); });
- RegisterMaker("proxy_auth", [](TypeName name)->ACL* { return new ACLProxyAuth(new ACLUserData, name); });
- RegisterMaker("proxy_auth_regex", [](TypeName name)->ACL* { return new ACLProxyAuth(new ACLRegexData, name); });
- RegisterMaker("max_user_ip", [](TypeName name)->ACL* { return new ACLMaxUserIP(name); });
+ RegisterMaker("ext_user", [](TypeName name)->Node* { return new ACLExtUser(new ACLUserData, name); });
+ RegisterMaker("ext_user_regex", [](TypeName name)->Node* { return new ACLExtUser(new ACLRegexData, name); });
+ RegisterMaker("proxy_auth", [](TypeName name)->Node* { return new ACLProxyAuth(new ACLUserData, name); });
+ RegisterMaker("proxy_auth_regex", [](TypeName name)->Node* { return new ACLProxyAuth(new ACLRegexData, name); });
+ RegisterMaker("max_user_ip", [](TypeName name)->Node* { return new ACLMaxUserIP(name); });
#endif
#if USE_ADAPTATION
- RegisterMaker("adaptation_service", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::AdaptationServiceCheck>(name, new ACLAdaptationServiceData); });
+ RegisterMaker("adaptation_service", [](TypeName name)->Node* { return new FinalizedParameterizedNode<AdaptationServiceCheck>(name, new ACLAdaptationServiceData); });
#endif
#if SQUID_SNMP
- RegisterMaker("snmp_community", [](TypeName name)->ACL* { return new Acl::FinalizedParameterizedNode<Acl::SnmpCommunityCheck>(name, new ACLStringData); });
+ RegisterMaker("snmp_community", [](TypeName name)->Node* { return new FinalizedParameterizedNode<SnmpCommunityCheck>(name, new ACLStringData); });
#endif
}
class external_acl_data;
class StoreEntry;
-class ACLExternal : public ACL
+class ACLExternal : public Acl::Node
{
MEMPROXY_CLASS(ACLExternal);
bool empty () const override;
private:
- static void StartLookup(ACLFilledChecklist &, const ACL &);
+ static void StartLookup(ACLFilledChecklist &, const Acl::Node &);
static void LookupDone(void *data, const ExternalACLEntryPointer &);
void startLookup(ACLFilledChecklist *, external_acl_data *, bool inBackground) const;
Acl::Answer aclMatchExternal(external_acl_data *, ACLFilledChecklist *) const;
std::chrono::nanoseconds paranoid_hit_validation;
- class ACL *aclList;
+ class Acl::Node *aclList;
struct {
acl_access *http;
namespace Acl {
-/// ACL type name comparison functor
+/// Acl::Node type name comparison functor
class TypeNameCmp {
public:
bool operator()(TypeName a, TypeName b) const { return strcmp(a, b) < 0; }
};
-/// ACL makers indexed by ACL type name
+/// Acl::Node makers indexed by Node type name
typedef std::map<TypeName, Maker, TypeNameCmp> Makers;
-/// registered ACL Makers
+/// registered Acl::Node Makers
static Makers &
TheMakers()
{
return Registry;
}
-/// creates an ACL object of the named (and already registered) ACL child type
+/// creates an Acl::Node object of the named (and already registered) Node child type
static
-ACL *
+Acl::Node *
Make(TypeName typeName)
{
const auto pos = TheMakers().find(typeName);
assert(false); // not reached
}
- ACL *result = (pos->second)(pos->first);
+ auto *result = (pos->second)(pos->first);
debugs(28, 4, typeName << '=' << result);
assert(result);
return result;
}
void *
-ACL::operator new (size_t)
+Acl::Node::operator new (size_t)
{
- fatal ("unusable ACL::new");
+ fatal ("unusable Acl::Node::new");
return (void *)1;
}
-void
-ACL::operator delete (void *)
+void Acl::Node::operator delete(void *)
{
- fatal ("unusable ACL::delete");
+ fatal ("unusable Acl::Node::delete");
}
-ACL *
-ACL::FindByName(const char *name)
+Acl::Node *
+Acl::Node::FindByName(const char *name)
{
- ACL *a;
- debugs(28, 9, "ACL::FindByName '" << name << "'");
+ debugs(28, 9, "name=" << name);
- for (a = Config.aclList; a; a = a->next)
+ for (auto *a = Config.aclList; a; a = a->next)
if (!strcasecmp(a->name, name))
return a;
- debugs(28, 9, "ACL::FindByName found no match");
+ debugs(28, 9, "found no match");
return nullptr;
}
-ACL::ACL() :
+Acl::Node::Node() :
cfgline(nullptr),
next(nullptr),
registered(false)
*name = 0;
}
-bool ACL::valid () const
+bool
+Acl::Node::valid() const
{
return true;
}
bool
-ACL::matches(ACLChecklist *checklist) const
+Acl::Node::matches(ACLChecklist *checklist) const
{
debugs(28, 5, "checking " << name);
checklist->verifyAle();
// have to cast because old match() API is missing const
- result = const_cast<ACL*>(this)->match(checklist);
+ result = const_cast<Node*>(this)->match(checklist);
}
const char *extra = checklist->asyncInProgress() ? " async" : "";
}
void
-ACL::context(const char *aName, const char *aCfgLine)
+Acl::Node::context(const char *aName, const char *aCfgLine)
{
name[0] = '\0';
if (aName)
}
void
-ACL::ParseAclLine(ConfigParser &parser, ACL ** head)
+Acl::Node::ParseAclLine(ConfigParser &parser, Node ** head)
{
/* we're already using strtok() to grok the line */
char *t = nullptr;
- ACL *A = nullptr;
+ Node *A = nullptr;
LOCAL_ARRAY(char, aclname, ACL_NAME_SZ);
int new_acl = 0;
}
bool
-ACL::isProxyAuth() const
+Acl::Node::isProxyAuth() const
{
return false;
}
void
-ACL::parseFlags()
+Acl::Node::parseFlags()
{
Acl::Options allOptions = options();
for (const auto lineOption: lineOptions()) {
}
void
-ACL::dumpWhole(const char * const directiveName, std::ostream &os)
+Acl::Node::dumpWhole(const char * const directiveName, std::ostream &os)
{
// XXX: No lineOptions() call here because we do not remember ACL "line"
// boundaries and associated "line" options; we cannot report them.
/* ACL result caching routines */
int
-ACL::matchForCache(ACLChecklist *)
+Acl::Node::matchForCache(ACLChecklist *)
{
/* This is a fatal to ensure that cacheMatchAcl calls are _only_
* made for supported acl types */
* TODO: does a dlink_list perform well enough? Kinkie
*/
int
-ACL::cacheMatchAcl(dlink_list * cache, ACLChecklist *checklist)
+Acl::Node::cacheMatchAcl(dlink_list * cache, ACLChecklist *checklist)
{
acl_proxy_auth_match_cache *auth_match;
dlink_node *link;
auth_match = (acl_proxy_auth_match_cache *)link->data;
if (auth_match->acl_data == this) {
- debugs(28, 4, "ACL::cacheMatchAcl: cache hit on acl '" << name << "' (" << this << ")");
+ debugs(28, 4, "cache hit on acl '" << name << "' (" << this << ")");
return auth_match->matchrv;
}
auth_match = new acl_proxy_auth_match_cache(matchForCache(checklist), this);
dlinkAddTail(auth_match, &auth_match->link, cache);
- debugs(28, 4, "ACL::cacheMatchAcl: miss for '" << name << "'. Adding result " << auth_match->matchrv);
+ debugs(28, 4, "miss for acl '" << name << "'. Adding result " << auth_match->matchrv);
return auth_match->matchrv;
}
}
bool
-ACL::requiresAle() const
+Acl::Node::requiresAle() const
{
return false;
}
bool
-ACL::requiresReply() const
+Acl::Node::requiresReply() const
{
return false;
}
bool
-ACL::requiresRequest() const
+Acl::Node::requiresRequest() const
{
return false;
}
/* Destroy functions */
/*********************/
-ACL::~ACL()
+Acl::Node::~Node()
{
debugs(28, 3, "freeing ACL " << name);
safe_free(cfgline);
}
void
-ACL::Initialize()
+Acl::Node::Initialize()
{
- ACL *a = Config.aclList;
- debugs(53, 3, "ACL::Initialize");
+ auto *a = Config.aclList;
+ debugs(53, 3, "Acl::Node::Initialize");
while (a) {
a->prepareForUse();
#define SQUID_ACL_H
#include "acl/forward.h"
-#include "acl/Options.h"
-#include "cbdata.h"
#include "defines.h"
#include "dlink.h"
#include "sbuf/forward.h"
#include <algorithm>
#include <ostream>
-class ConfigParser;
-
namespace Acl {
/// the ACL type name known to admins
-typedef const char *TypeName;
-/// a "factory" function for making ACL objects (of some ACL child type)
-typedef ACL *(*Maker)(TypeName typeName);
-/// use the given ACL Maker for all ACLs of the named type
+using TypeName = const char *;
+/// a "factory" function for making Acl::Node objects (of some Node child type)
+using Maker = Node *(*)(TypeName typeName);
+/// use the given Acl::Node Maker for all ACLs of the named type
void RegisterMaker(TypeName typeName, Maker maker);
/// Validate and store the ACL key parameter for ACL types
/// Key comparison is case-insensitive.
void SetKey(SBuf &keyStorage, const char *keyParameterName, const char *newKey);
-} // namespace Acl
-
-/// A configurable condition. A node in the ACL expression tree.
-/// Can evaluate itself in FilledChecklist context.
-/// Does not change during evaluation.
-/// \ingroup ACLAPI
-class ACL
-{
-
-public:
- void *operator new(size_t);
- void operator delete(void *);
-
- static void ParseAclLine(ConfigParser &parser, ACL ** head);
- static void Initialize();
- static ACL *FindByName(const char *name);
-
- ACL();
- ACL(ACL &&) = delete; // no copying of any kind
- virtual ~ACL();
-
- /// sets user-specified ACL name and squid.conf context
- void context(const char *name, const char *configuration);
-
- /// Orchestrates matching checklist against the ACL using match(),
- /// after checking preconditions and while providing debugging.
- /// \return true if and only if there was a successful match.
- /// Updates the checklist state on match, async, and failure.
- bool matches(ACLChecklist *checklist) const;
-
- /// configures ACL options, throwing on configuration errors
- void parseFlags();
-
- /// parses node representation in squid.conf; dies on failures
- virtual void parse() = 0;
- virtual char const *typeString() const = 0;
- virtual bool isProxyAuth() const;
- virtual SBufList dump() const = 0;
- virtual bool empty() const = 0;
- virtual bool valid() const;
-
- int cacheMatchAcl(dlink_list * cache, ACLChecklist *);
- virtual int matchForCache(ACLChecklist *checklist);
-
- virtual void prepareForUse() {}
-
- // TODO: Find a way to make options() and this method constant
- /// Prints aggregated "acl" (or similar) directive configuration, including
- /// the given directive name, ACL name, ACL type, and ACL parameters. The
- /// printed parameters are collected from all same-name "acl" directives.
- void dumpWhole(const char *directiveName, std::ostream &);
-
- char name[ACL_NAME_SZ];
- char *cfgline;
- ACL *next; // XXX: remove or at least use refcounting
- bool registered; ///< added to the global list of ACLs via aclRegister()
-
-private:
- /// Matches the actual data in checklist against this ACL.
- virtual int match(ACLChecklist *checklist) = 0; // XXX: missing const
-
- /// whether our (i.e. shallow) match() requires checklist to have a AccessLogEntry
- virtual bool requiresAle() const;
- /// whether our (i.e. shallow) match() requires checklist to have a request
- virtual bool requiresRequest() const;
- /// whether our (i.e. shallow) match() requires checklist to have a reply
- virtual bool requiresReply() const;
-
- // TODO: Rename to globalOptions(); these are not the only supported options
- /// \returns (linked) 'global' Options supported by this ACL
- virtual const Acl::Options &options() { return Acl::NoOptions(); }
-
- /// \returns (linked) "line" Options supported by this ACL
- /// \see ACL::options()
- virtual const Acl::Options &lineOptions() { return Acl::NoOptions(); }
-};
+} // namespace Acl
/// \ingroup ACLAPI
typedef enum {
ACCESS_ALLOWED,
ACCESS_DUNNO,
- // Authentication ACL result states
+ // Authentication Acl::Node result states
ACCESS_AUTH_REQUIRED, // Missing Credentials
} aclMatchCode;
/// \ingroup ACLAPI
-/// ACL check answer
+/// Acl::Node check answer
namespace Acl {
class Answer
};
/// \ingroup ACLAPI
-/// XXX: find a way to remove or at least use a refcounted ACL pointer
+/// XXX: find a way to remove or at least use a refcounted Acl::Node pointer
extern const char *AclMatchedName; /* NULL */
#endif /* SQUID_ACL_H */
class AdaptationServiceCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
#define _SQUID_SRC_ACL_ADDRESS_H
#include "acl/Acl.h"
+#include "cbdata.h"
#include "ip/Address.h"
namespace Acl
Acl::AllOf::parse()
{
Acl::InnerNode *whole = nullptr;
- ACL *oldNode = empty() ? nullptr : nodes.front();
+ Acl::Node *oldNode = empty() ? nullptr : nodes.front();
// optimization: this logic reduces subtree hight (number of tree levels)
if (Acl::OrNode *oldWhole = dynamic_cast<Acl::OrNode*>(oldNode)) {
MEMPROXY_CLASS(AllOf);
public:
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
SBufList dump() const override;
class AnnotateClientCheck: public Acl::AnnotationCheck
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override { return true; }
};
class AnnotateTransactionCheck: public Acl::AnnotationCheck
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override { return true; }
};
MEMPROXY_CLASS(AnyOf);
public:
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
};
#ifndef SQUID_ACLARP_H
#define SQUID_ACLARP_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include "eui/Eui48.h"
#include <set>
/// \ingroup ACLAPI
-class ACLARP : public ACL
+class ACLARP : public Acl::Node
{
MEMPROXY_CLASS(ACLARP);
}
#endif
-void asnAclInitialize(ACL * acls);
+void asnAclInitialize(Acl::Node * acls);
static void destroyRadixNodeInfo(as_info *);
class AtStepCheck: public ParameterizedNode< ACLData<XactionStep> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
/* Acl::NotNode */
-Acl::NotNode::NotNode(ACL *acl)
+Acl::NotNode::NotNode(Acl::Node *acl)
{
assert(acl);
Must(strlen(acl->name) <= sizeof(name)-2);
MEMPROXY_CLASS(NotNode);
public:
- explicit NotNode(ACL *acl);
+ explicit NotNode(Acl::Node *acl);
private:
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
SBufList dump() const override;
/// on its action
virtual bool bannedAction(ACLChecklist *, Nodes::const_iterator) const;
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
class ClientCertificateCheck: public ParameterizedNode< ACLData<X509 *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
}
bool
-ACLChecklist::matchChild(const Acl::InnerNode *current, Acl::Nodes::const_iterator pos, const ACL *child)
+ACLChecklist::matchChild(const Acl::InnerNode *current, Acl::Nodes::const_iterator pos, const Acl::Node *child)
{
assert(current && child);
}
bool
-ACLChecklist::goAsync(AsyncStarter starter, const ACL &acl)
+ACLChecklist::goAsync(AsyncStarter starter, const Acl::Node &acl)
{
assert(!asyncInProgress());
assert(matchLoc_.parent);
callback_data = cbdataReference(callback_data_);
asyncCaller_ = true;
- /** The ACL List should NEVER be NULL when calling this method.
+ /** The ACL list should NEVER be NULL when calling this method.
* Always caller should check for NULL and handle appropriate to its needs first.
* We cannot select a sensible default for all callers here. */
if (accessList == nullptr) {
#ifndef SQUID_ACLCHECKLIST_H
#define SQUID_ACLCHECKLIST_H
+#include "acl/Acl.h"
#include "acl/InnerNode.h"
+#include "cbdata.h"
#include <stack>
#include <vector>
public:
/// a function that initiates asynchronous ACL checks; see goAsync()
- using AsyncStarter = void (ACLFilledChecklist &, const ACL &);
+ using AsyncStarter = void (ACLFilledChecklist &, const Acl::Node &);
public:
ACLChecklist();
/// If slow lookups are allowed, switches into "async in progress" state.
/// Otherwise, returns false; the caller is expected to handle the failure.
- bool goAsync(AsyncStarter, const ACL &);
+ bool goAsync(AsyncStarter, const Acl::Node &);
/// Matches (or resumes matching of) a child node while maintaning
/// resumption breadcrumbs if a [grand]child node goes async.
- bool matchChild(const Acl::InnerNode *parent, Acl::Nodes::const_iterator pos, const ACL *child);
+ bool matchChild(const Acl::InnerNode *parent, Acl::Nodes::const_iterator pos, const Acl::Node *child);
/// Whether we should continue to match tree nodes or stop/pause.
bool keepMatching() const { return !finished() && !asyncInProgress(); }
void resumeNonBlockingCheck();
private: /* internal methods */
- /// Position of a child node within an ACL tree.
+ /// Position of a child node within an Acl::Node tree.
class Breadcrumb
{
public:
#ifndef SQUID_ACLCONNMARK_H
#define SQUID_ACLCONNMARK_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include "ip/forward.h"
#include "ip/NfMarkConfig.h"
#include "parser/Tokenizer.h"
namespace Acl {
-class ConnMark : public ACL
+class ConnMark : public Acl::Node
{
MEMPROXY_CLASS(ConnMark);
public:
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
int match(ACLChecklist *checklist) override;
namespace Acl
{
-class ConnectionsEncrypted : public ACL
+class ConnectionsEncrypted : public Acl::Node
{
MEMPROXY_CLASS(ConnectionsEncrypted);
class DestinationAsnCheck: public ParameterizedNode< ACLData<Ip::Address> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
static void LookupDone(const char *, const Dns::LookupDetails &, void *data);
static void
-StartLookup(ACLFilledChecklist &cl, const ACL &)
+StartLookup(ACLFilledChecklist &cl, const Acl::Node &)
{
fqdncache_nbgethostbyaddr(cl.dst_addr, LookupDone, &cl);
}
class DestinationDomainCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
const Acl::Options &options() override;
}
void
-ACLDestinationIP::StartLookup(ACLFilledChecklist &cl, const ACL &)
+ACLDestinationIP::StartLookup(ACLFilledChecklist &cl, const Acl::Node &)
{
ipcache_nbgethostbyname(cl.request->url.host(), LookupDone, &cl);
}
MEMPROXY_CLASS(ACLDestinationIP);
public:
- static void StartLookup(ACLFilledChecklist &, const ACL &);
+ static void StartLookup(ACLFilledChecklist &, const Acl::Node &);
char const *typeString() const override;
const Acl::Options &options() override;
#ifndef SQUID_ACLEUI64_H
#define SQUID_ACLEUI64_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include "eui/Eui64.h"
#include <set>
-class ACLEui64 : public ACL
+class ACLEui64 : public Acl::Node
{
MEMPROXY_CLASS(ACLEui64);
#include "acl/Checklist.h"
#include "acl/Data.h"
-class ACLExtUser : public ACL
+class ACLExtUser : public Acl::Node
{
MEMPROXY_CLASS(ACLExtUser);
ACLExtUser(ACLData<char const *> *newData, char const *);
~ACLExtUser() override;
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
int match(ACLChecklist *checklist) override;
bool empty () const override;
private:
- /* ACL API */
+ /* Acl::Node API */
const Acl::Options &lineOptions() override;
ACLData<char const *> *data;
#define SQUID_ACLFILLED_CHECKLIST_H
#include "AccessLogEntry.h"
+#include "acl/Acl.h"
#include "acl/Checklist.h"
#include "acl/forward.h"
#include "base/CbcPointer.h"
* DEBUG: section 28 Access Control
*
* This file contains ACL routines that are not part of the
- * ACL class, nor any other class yet, and that need to be
+ * Acl::Node class, nor any other class yet, and that need to be
* factored into appropriate places. They are here to reduce
- * unneeded dependencies between the ACL class and the rest
+ * unneeded dependencies between the Acl::Node class and the rest
* of squid.
*/
#include <set>
#include <algorithm>
-typedef std::set<ACL*> AclSet;
+using AclSet = std::set<Acl::Node *>;
/// Accumulates all ACLs to facilitate their clean deletion despite reuse.
static AclSet *RegisteredAcls; // TODO: Remove when ACLs are refcounted
debugs(28, 5, "aclIsProxyAuth: called for " << name);
- ACL *a;
-
- if ((a = ACL::FindByName(name))) {
+ if (const auto *a = Acl::Node::FindByName(name)) {
debugs(28, 5, "aclIsProxyAuth: returning " << a->isProxyAuth());
return a->isProxyAuth();
}
}
void
-aclRegister(ACL *acl)
+aclRegister(Acl::Node *acl)
{
if (!acl->registered) {
if (!RegisteredAcls)
/// remove registered acl from the centralized deletion set
static
void
-aclDeregister(ACL *acl)
+aclDeregister(Acl::Node *acl)
{
if (acl->registered) {
if (RegisteredAcls)
/// called to delete ALL Acls.
void
-aclDestroyAcls(ACL ** head)
+aclDestroyAcls(Acl::Node ** head)
{
*head = nullptr; // Config.aclList
if (AclSet *acls = RegisteredAcls) {
debugs(28, 8, "deleting all " << acls->size() << " ACLs");
while (!acls->empty()) {
- ACL *acl = *acls->begin();
- // We use centralized deletion (this function) so ~ACL should not
+ auto *acl = *acls->begin();
+ // We use centralized deletion (this function) so ~Acl::Node should not
// delete other ACLs, but we still deregister first to prevent any
- // accesses to the being-deleted ACL via RegisteredAcls.
+ // accesses to the being-deleted Acl::Node via RegisteredAcls.
assert(acl->registered); // make sure we are making progress
aclDeregister(acl);
delete acl;
class StoreEntry;
class wordlist;
-/// Register an ACL object for future deletion. Repeated registrations are OK.
+/// Register an Acl::Node object for future deletion. Repeated registrations are OK.
/// \ingroup ACLAPI
-void aclRegister(ACL *acl);
+void aclRegister(Acl::Node *acl);
/// \ingroup ACLAPI
void aclDestroyAccessList(acl_access **list);
/// \ingroup ACLAPI
-void aclDestroyAcls(ACL **);
+void aclDestroyAcls(Acl::Node **);
/// \ingroup ACLAPI
void aclDestroyAclList(ACLList **);
/// Parses a single line of a "action followed by acls" directive (e.g., http_access).
/// \ingroup ACLAPI
void aclDestroyDenyInfoList(AclDenyInfoList **);
/// \ingroup ACLAPI
-wordlist *aclDumpGeneric(const ACL *);
+wordlist *aclDumpGeneric(const Acl::Node *);
/// \ingroup ACLAPI
void aclCacheMatchFlush(dlink_list * cache);
/// \ingroup ACLAPI
class HasComponentCheck: public ParameterizedNode< ACLData<ACLChecklist *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class HierCodeCheck: public ParameterizedNode< ACLData<hier_code> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class HttpRepHeaderCheck: public ParameterizedNode< ACLData<HttpHeader*> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresReply() const override { return true; }
};
class HttpReqHeaderCheck: public ParameterizedNode< ACLData<HttpHeader*> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override { return true; }
};
};
/// \ingroup ACLAPI
-class ACLHTTPStatus : public ACL
+class ACLHTTPStatus : public Acl::Node
{
MEMPROXY_CLASS(ACLHTTPStatus);
}
void
-Acl::InnerNode::add(ACL *node)
+Acl::InnerNode::add(Acl::Node *node)
{
assert(node != nullptr);
nodes.push_back(node);
++t;
debugs(28, 3, "looking for ACL " << t);
- ACL *a = ACL::FindByName(t);
+ auto *a = Acl::Node::FindByName(t);
if (a == nullptr) {
debugs(28, DBG_CRITICAL, "ERROR: ACL not found: " << t);
#ifndef SQUID_ACL_INNER_NODE_H
#define SQUID_ACL_INNER_NODE_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include <vector>
namespace Acl
{
-typedef std::vector<ACL*> Nodes; ///< a collection of nodes
+using Nodes = std::vector<Acl::Node*>; ///< a collection of nodes
-/// An intermediate ACL tree node. Manages a collection of child tree nodes.
-class InnerNode: public ACL
+/// An intermediate Acl::Node tree node. Manages a collection of child tree nodes.
+class InnerNode: public Acl::Node
{
public:
// No ~InnerNode() to delete children. They are aclRegister()ed instead.
/// the number of children nodes
Nodes::size_type childrenCount() const { return nodes.size(); }
- /* ACL API */
+ /* Acl::Node API */
void prepareForUse() override;
bool empty() const override;
SBufList dump() const override;
size_t lineParse();
/// appends the node to the collection and takes control over it
- void add(ACL *node);
+ void add(Acl::Node *node);
protected:
/// checks whether the nodes match, starting with the given one
/// kids determine what a match means for their type of intermediate nodes
virtual int doMatch(ACLChecklist *checklist, Nodes::const_iterator start) const = 0;
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *checklist) override;
// XXX: use refcounting instead of raw pointers
- std::vector<ACL*> nodes; ///< children nodes of this intermediate node
+ Nodes nodes; ///< children nodes of this intermediate node
};
} // namespace Acl
#ifndef SQUID_ACLIP_H
#define SQUID_ACLIP_H
-#include "acl/Acl.h"
#include "acl/Data.h"
+#include "acl/Node.h"
#include "ip/Address.h"
#include "splay.h"
static bool DecodeMask(const char *asc, Ip::Address &mask, int string_format_type);
};
-class ACLIP : public ACL
+class ACLIP : public Acl::Node
{
public:
void *operator new(size_t);
class LocalPortCheck: public ParameterizedNode< ACLData<int> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
ChecklistFiller.h \
InnerNode.cc \
InnerNode.h \
+ Node.h \
Options.cc \
Options.h \
SplayInserter.h \
#ifndef SQUID_ACLMAXCONNECTION_H
#define SQUID_ACLMAXCONNECTION_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
/// \ingroup ACLAPI
-class ACLMaxConnection : public ACL
+class ACLMaxConnection : public Acl::Node
{
MEMPROXY_CLASS(ACLMaxConnection);
class MethodCheck: public ParameterizedNode< ACLData<HttpRequestMethod> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class MyPortNameCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
--- /dev/null
+/*
+ * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
+ *
+ * Squid software is distributed under GPLv2+ license and includes
+ * contributions from numerous individuals and organizations.
+ * Please see the COPYING and CONTRIBUTORS files for details.
+ */
+
+#ifndef SQUID_SRC_ACL_NODE_H
+#define SQUID_SRC_ACL_NODE_H
+
+#include "acl/forward.h"
+#include "acl/Options.h"
+#include "dlink.h"
+
+class ConfigParser;
+
+namespace Acl {
+
+/// A configurable condition. A node in the ACL expression tree.
+/// Can evaluate itself in FilledChecklist context.
+/// Does not change during evaluation.
+/// \ingroup ACLAPI
+class Node
+{
+
+public:
+ void *operator new(size_t);
+ void operator delete(void *);
+
+ static void ParseAclLine(ConfigParser &parser, Acl::Node **head);
+ static void Initialize();
+ static Acl::Node *FindByName(const char *name);
+
+ Node();
+ Node(Node &&) = delete; // no copying of any kind
+ virtual ~Node();
+
+ /// sets user-specified ACL name and squid.conf context
+ void context(const char *name, const char *configuration);
+
+ /// Orchestrates matching checklist against the Acl::Node using match(),
+ /// after checking preconditions and while providing debugging.
+ /// \return true if and only if there was a successful match.
+ /// Updates the checklist state on match, async, and failure.
+ bool matches(ACLChecklist *checklist) const;
+
+ /// configures Acl::Node options, throwing on configuration errors
+ void parseFlags();
+
+ /// parses node representation in squid.conf; dies on failures
+ virtual void parse() = 0;
+ virtual char const *typeString() const = 0;
+ virtual bool isProxyAuth() const;
+ virtual SBufList dump() const = 0;
+ virtual bool empty() const = 0;
+ virtual bool valid() const;
+
+ int cacheMatchAcl(dlink_list *cache, ACLChecklist *);
+ virtual int matchForCache(ACLChecklist *checklist);
+
+ virtual void prepareForUse() {}
+
+ // TODO: Find a way to make options() and this method constant
+ /// Prints aggregated "acl" (or similar) directive configuration, including
+ /// the given directive name, ACL name, ACL type, and ACL parameters. The
+ /// printed parameters are collected from all same-name "acl" directives.
+ void dumpWhole(const char *directiveName, std::ostream &);
+
+ char name[ACL_NAME_SZ];
+ char *cfgline;
+ Acl::Node *next; // XXX: remove or at least use refcounting
+ bool registered; ///< added to the global list of ACLs via aclRegister()
+
+private:
+ /// Matches the actual data in checklist against this Acl::Node.
+ virtual int match(ACLChecklist *checklist) = 0; // XXX: missing const
+
+ /// whether our (i.e. shallow) match() requires checklist to have a AccessLogEntry
+ virtual bool requiresAle() const;
+ /// whether our (i.e. shallow) match() requires checklist to have a request
+ virtual bool requiresRequest() const;
+ /// whether our (i.e. shallow) match() requires checklist to have a reply
+ virtual bool requiresReply() const;
+
+ // TODO: Rename to globalOptions(); these are not the only supported options
+ /// \returns (linked) 'global' Options supported by this Acl::Node
+ virtual const Acl::Options &options() { return Acl::NoOptions(); }
+
+ /// \returns (linked) "line" Options supported by this Acl::Node
+ /// \see Acl::Node::options()
+ virtual const Acl::Options &lineOptions() { return Acl::NoOptions(); }
+};
+
+} // namespace Acl
+
+#endif /* SQUID_SRC_ACL_NODE_H */
class NoteCheck: public Acl::AnnotationCheck
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override { return true; }
#include <iosfwd>
#include <vector>
-// After line continuation is handled by the preprocessor, an ACL object
+// After line continuation is handled by the preprocessor, an Acl::Node object
// configuration can be visualized as a sequence of same-name "acl ..." lines:
//
// L1: acl exampleA typeT parameter1 -i parameter2 parameter3
//
// * Global (e.g., "-n"): Applies to all parameters regardless of where the
// option was discovered/parsed (e.g., "-n" on L3 affects parameter2 on L1).
-// Declared by ACL class kids (or equivalent) via ACL::options().
+// Declared by Acl::Node class kids (or equivalent) via Acl::Node::options().
//
// * Line (e.g., "-i"): Applies to the yet unparsed ACL parameters of the
// current "acl ..." line (e.g., "-i" on L1 has no effect on parameter4 on L2)
#ifndef SQUID_SRC_ACL_PARAMETERIZEDNODE_H
#define SQUID_SRC_ACL_PARAMETERIZEDNODE_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include "base/Assure.h"
#include <memory>
/// An ACL that manages squid.conf-configured ACL parameters using a given class
/// P. That P class must support the ACLData<> or equivalent API.
template <class P>
-class ParameterizedNode: public ACL
+class ParameterizedNode: public Acl::Node
{
public:
using Parameters = P;
~ParameterizedNode() override = default;
protected:
- /* ACL API */
+ /* Acl::Node API */
void parse() override { Assure(data); data->parse(); }
void prepareForUse() override { data->prepareForUse(); }
SBufList dump() const override { return data->dump(); }
const Acl::Options &lineOptions() override { return data->lineOptions(); }
/// Points to items this ACL is configured to match. A derived class ensures
- /// that this pointer is never nil after the ACL object construction ends.
+ /// that this pointer is never nil after object construction ends.
std::unique_ptr<Parameters> data;
};
class PeerNameCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class ProtocolCheck: public ParameterizedNode< ACLData<AnyP::ProtocolType> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
#ifndef SQUID_ACL_RANDOM_H
#define SQUID_ACL_RANDOM_H
-#include "acl/Acl.h"
+#include "acl/Node.h"
-class ACLRandom : public ACL
+class ACLRandom : public Acl::Node
{
MEMPROXY_CLASS(ACLRandom);
class ReplyHeaderCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresReply() const override {return true;}
};
class RequestHeaderCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class ServerCertificateCheck: public ParameterizedNode< ACLData<X509 *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class ServerNameCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
const Acl::Options &options() override;
class SourceAsnCheck: public ParameterizedNode< ACLData<Ip::Address> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
static void LookupDone(const char *, const Dns::LookupDetails &, void *data);
static void
-StartLookup(ACLFilledChecklist &checklist, const ACL &)
+StartLookup(ACLFilledChecklist &checklist, const Acl::Node &)
{
fqdncache_nbgethostbyaddr(checklist.src_addr, LookupDone, &checklist);
}
class SourceDomainCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class SquidErrorCheck: public ParameterizedNode< ACLData<err_type> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class CertificateErrorCheck: public ParameterizedNode< ACLData<const Security::CertErrors *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class TagCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
class CurrentTimeCheck: public ParameterizedNode<ACLTimeData>
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
{
/// transaction_initiator ACL
-class TransactionInitiator : public ACL
+class TransactionInitiator : public Acl::Node
{
MEMPROXY_CLASS(TransactionInitiator);
}
void
-Acl::Tree::add(ACL *rule, const Acl::Answer &action)
+Acl::Tree::add(Acl::Node *rule, const Acl::Answer &action)
{
// either all rules have actions or none
assert(nodes.size() == actions.size());
}
void
-Acl::Tree::add(ACL *rule)
+Acl::Tree::add(Acl::Node *rule)
{
// either all rules have actions or none
assert(actions.empty());
#ifndef SQUID_ACL_TREE_H
#define SQUID_ACL_TREE_H
+#include "acl/Acl.h"
#include "acl/BoolOps.h"
+#include "cbdata.h"
#include "sbuf/List.h"
namespace Acl
Answer lastAction() const;
/// appends and takes control over the rule with a given action
- void add(ACL *rule, const Answer &action);
- void add(ACL *rule); ///< same as InnerNode::add()
+ void add(Acl::Node *rule, const Answer &action);
+ void add(Acl::Node *rule); ///< same as InnerNode::add()
protected:
/// Acl::OrNode API
class UrlCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class UrlLoginCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class UrlPathCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
class UrlPortCheck: public ParameterizedNode< ACLData<int> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
bool requiresRequest() const override {return true;}
};
#include "base/RefCount.h"
-class ACL;
class ACLChecklist;
class ACLFilledChecklist;
class ACLList;
namespace Acl
{
+class Node;
class Address;
class AndNode;
class Answer;
* \retval ACCESS_ALLOWED user authenticated and authorized
*/
Acl::Answer
-AuthenticateAcl(ACLChecklist *ch, const ACL &acl)
+AuthenticateAcl(ACLChecklist *ch, const Acl::Node &acl)
{
ACLFilledChecklist *checklist = Filled(ch);
const auto request = checklist->request;
class ACLChecklist;
/// \ingroup AuthAPI
-Acl::Answer AuthenticateAcl(ACLChecklist *, const ACL &);
+Acl::Answer AuthenticateAcl(ACLChecklist *, const Acl::Node &);
#endif /* USE_AUTH */
#endif /* SQUID_AUTH_ACL_H */
#if USE_AUTH
-#include "acl/Acl.h"
+#include "acl/Node.h"
#include "auth/UserRequest.h"
-class ACLMaxUserIP : public ACL
+class ACLMaxUserIP : public Acl::Node
{
MEMPROXY_CLASS(ACLMaxUserIP);
}
void
-ACLProxyAuth::StartLookup(ACLFilledChecklist &cl, const ACL &)
+ACLProxyAuth::StartLookup(ACLFilledChecklist &cl, const Acl::Node &)
{
debugs(28, 3, "checking password via authenticator");
#include "acl/Checklist.h"
#include "acl/Data.h"
-class ACLProxyAuth : public ACL
+class ACLProxyAuth : public Acl::Node
{
MEMPROXY_CLASS(ACLProxyAuth);
public:
- static void StartLookup(ACLFilledChecklist &, const ACL &);
+ static void StartLookup(ACLFilledChecklist &, const Acl::Node &);
~ACLProxyAuth() override;
ACLProxyAuth(ACLData<char const *> *, char const *);
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
bool isProxyAuth() const override {return true;}
private:
static void LookupDone(void *data);
- /* ACL API */
+ /* Acl::Node API */
const Acl::Options &lineOptions() override;
int matchProxyAuth(ACLChecklist *);
#include "acl/Address.h"
#include "acl/Gadgets.h"
#include "acl/MethodData.h"
+#include "acl/Node.h"
#include "acl/Tree.h"
#include "anyp/PortCfg.h"
#include "anyp/UriScheme.h"
static void parse_on_unsupported_protocol(acl_access **access);
static void dump_on_unsupported_protocol(StoreEntry *entry, const char *name, acl_access *access);
static void free_on_unsupported_protocol(acl_access **access);
-static void ParseAclWithAction(acl_access **access, const Acl::Answer &action, const char *desc, ACL *acl = nullptr);
+static void ParseAclWithAction(acl_access **access, const Acl::Answer &action, const char *desc, Acl::Node *acl = nullptr);
static void parse_http_upgrade_request_protocols(HttpUpgradeProtocolAccess **protoGuards);
static void dump_http_upgrade_request_protocols(StoreEntry *entry, const char *name, HttpUpgradeProtocolAccess *protoGuards);
static void free_http_upgrade_request_protocols(HttpUpgradeProtocolAccess **protoGuards);
}
static void
-dump_acl(StoreEntry * entry, const char *name, ACL * ae)
+dump_acl(StoreEntry * entry, const char *name, Acl::Node * ae)
{
PackableStream os(*entry);
while (ae != nullptr) {
}
static void
-parse_acl(ACL ** ae)
+parse_acl(Acl::Node ** ae)
{
- ACL::ParseAclLine(LegacyParser, ae);
+ Acl::Node::ParseAclLine(LegacyParser, ae);
}
static void
-free_acl(ACL ** ae)
+free_acl(Acl::Node ** ae)
{
aclDestroyAcls(ae);
}
#endif /* USE_AUTH */
static void
-ParseAclWithAction(acl_access **access, const Acl::Answer &action, const char *desc, ACL *acl)
+ParseAclWithAction(acl_access **access, const Acl::Answer &action, const char *desc, Acl::Node *acl)
{
assert(access);
SBuf name;
*ftp_epsv = nullptr;
if (ftpEpsvDeprecatedAction == Acl::Answer(ACCESS_DENIED)) {
- if (ACL *a = ACL::FindByName("all"))
+ if (auto *a = Acl::Node::FindByName("all"))
ParseAclWithAction(ftp_epsv, ftpEpsvDeprecatedAction, "ftp_epsv", a);
else {
self_destruct();
/// Asks the helper (if needed) or returns the [cached] result (otherwise).
/// Does not support "background" lookups. See also: ACLExternal::Start().
void
-ACLExternal::StartLookup(ACLFilledChecklist &checklist, const ACL &acl)
+ACLExternal::StartLookup(ACLFilledChecklist &checklist, const Acl::Node &acl)
{
const auto &me = dynamic_cast<const ACLExternal&>(acl);
me.startLookup(&checklist, me.data, false);
}
void
-ACLIdent::StartLookup(ACLFilledChecklist &cl, const ACL &)
+ACLIdent::StartLookup(ACLFilledChecklist &cl, const Acl::Node &)
{
const ConnStateData *conn = cl.conn();
// check that ACLIdent::match() tested this lookup precondition
#include "acl/Data.h"
/// \ingroup ACLAPI
-class ACLIdent : public ACL
+class ACLIdent : public Acl::Node
{
MEMPROXY_CLASS(ACLIdent);
public:
- static void StartLookup(ACLFilledChecklist &, const ACL &);
+ static void StartLookup(ACLFilledChecklist &, const Acl::Node &);
ACLIdent(ACLData<char const *> *newData, char const *);
~ACLIdent() override;
- /* ACL API */
+ /* Acl::Node API */
char const *typeString() const override;
void parse() override;
bool isProxyAuth() const override {return true;}
private:
static void LookupDone(const char *ident, void *data);
- /* ACL API */
+ /* Acl::Node API */
const Acl::Options &lineOptions() override;
ACLData<char const *> *data;
class fde;
-// TODO: move to new ACL framework
+// TODO: move to new Acl::Node framework
class acl_tos
{
CBDATA_CLASS(acl_tos);
tos_t tos;
};
-// TODO: move to new ACL framework
+// TODO: move to new Acl::Node framework
class acl_nfmark
{
CBDATA_CLASS(acl_nfmark);
icmpEngine.Open();
netdbInit();
asnInit();
- ACL::Initialize();
+ Acl::Node::Initialize();
peerSelectInit();
carpInit();
class SnmpCommunityCheck: public ParameterizedNode< ACLData<const char *> >
{
public:
- /* ACL API */
+ /* Acl::Node API */
int match(ACLChecklist *) override;
};
#include "acl/Acl.h" /* for Acl::Answer */
#include "auth/Acl.h"
-Acl::Answer AuthenticateAcl(ACLChecklist *, const ACL &) STUB_RETVAL(ACCESS_DENIED)
+Acl::Answer AuthenticateAcl(ACLChecklist *, const Acl::Node &) STUB_RETVAL(ACCESS_DENIED)
#include "auth/AclMaxUserIp.h"
ACLMaxUserIP::ACLMaxUserIP (char const *) STUB
void
MyTestProgram::startup()
{
- Acl::RegisterMaker("max_user_ip", [](Acl::TypeName name)->ACL* { return new ACLMaxUserIP(name); });
+ Acl::RegisterMaker("max_user_ip", [](Acl::TypeName name)->Acl::Node* { return new ACLMaxUserIP(name); });
}
void
char * line = xstrdup("test max_user_ip -s 1");
/* seed the parser */
ConfigParser::SetCfgLine(line);
- ACL *anACL = nullptr;
+ Acl::Node *anACL = nullptr;
ConfigParser LegacyParser;
- ACL::ParseAclLine(LegacyParser, &anACL);
+ Acl::Node::ParseAclLine(LegacyParser, &anACL);
ACLMaxUserIP *maxUserIpACL = dynamic_cast<ACLMaxUserIP *>(anACL);
CPPUNIT_ASSERT(maxUserIpACL);
if (maxUserIpACL) {
projects / thirdparty / squid.git / commitdiff
