#ifndef SQUID_EXTERNALACL_H
#define SQUID_EXTERNALACL_H
+#include "acl/Acl.h"
#include "acl/Checklist.h"
#include "base/RefCount.h"
class external_acl_data;
class StoreEntry;
-class ExternalACLLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static ExternalACLLookup *Instance();
- void checkForAsync(ACLChecklist *)const override;
-
- // If possible, starts an asynchronous lookup of an external ACL.
- // Otherwise, asserts (or bails if background refresh is requested).
- static void Start(ACLChecklist *checklist, external_acl_data *acl, bool bg);
-
-private:
- static ExternalACLLookup instance_;
- static void LookupDone(void *data, const ExternalACLEntryPointer &result);
-};
-
-#include "acl/Acl.h"
-
class ACLExternal : public ACL
{
MEMPROXY_CLASS(ACLExternal);
public:
- static void ExternalAclLookup(ACLChecklist * ch, ACLExternal *);
-
ACLExternal(char const *);
~ACLExternal() override;
bool valid () const override;
bool empty () const override;
-protected:
+private:
+ static void StartLookup(ACLFilledChecklist &, const ACL &);
+ static void LookupDone(void *data, const ExternalACLEntryPointer &);
+ void startLookup(ACLFilledChecklist *, external_acl_data *, bool inBackground) const;
+ Acl::Answer aclMatchExternal(external_acl_data *, ACLFilledChecklist *) const;
+ char *makeExternalAclKey(ACLFilledChecklist *, external_acl_data *) const;
+
external_acl_data *data;
char const *class_;
};
} else if (!checklist->request->flags.destinationIpLookedUp) {
/* No entry in cache, lookup not attempted */
debugs(28, 3, "can't yet compare '" << AclMatchedName << "' ACL for " << checklist->request->url.host());
- if (checklist->goAsync(DestinationIPLookup::Instance()))
+ if (checklist->goAsync(ACLDestinationIP::StartLookup, *this))
return -1;
// else fall through to noaddr match, hiding the lookup failure (XXX)
}
#include "squid.h"
#include "acl/Checklist.h"
+#include "acl/FilledChecklist.h"
#include "acl/Tree.h"
#include "debug/Stream.h"
}
bool
-ACLChecklist::goAsync(AsyncState *state)
+ACLChecklist::goAsync(AsyncStarter starter, const ACL &acl)
{
- assert(state);
assert(!asyncInProgress());
assert(matchLoc_.parent);
++asyncLoopDepth_;
asyncStage_ = asyncStarting;
- changeState(state);
- state->checkForAsync(this); // this is supposed to go async
+ starter(*Filled(this), acl); // this is supposed to go async
- // Did AsyncState object actually go async? If not, tell the caller.
+ // Did starter() actually go async? If not, tell the caller.
if (asyncStage_ != asyncStarting) {
assert(asyncStage_ == asyncFailed);
asyncStage_ = asyncNone; // sanity restored
finished_(false),
answer_(ACCESS_DENIED),
asyncStage_(asyncNone),
- state_(NullState::Instance()),
asyncLoopDepth_(0)
{
}
debugs(28, 4, "ACLChecklist::~ACLChecklist: destroyed " << this);
}
-ACLChecklist::NullState *
-ACLChecklist::NullState::Instance()
-{
- return &_instance;
-}
-
-void
-ACLChecklist::NullState::checkForAsync(ACLChecklist *) const
-{
- assert(false); // or the Checklist will never get out of the async state
-}
-
-ACLChecklist::NullState ACLChecklist::NullState::_instance;
-
-void
-ACLChecklist::changeState (AsyncState *newState)
-{
- /* only change from null to active and back again,
- * not active to active.
- * relax this once conversion to states is complete
- * RBC 02 2003
- */
- assert (state_ == NullState::Instance() || newState == NullState::Instance());
- state_ = newState;
-}
-
-ACLChecklist::AsyncState *
-ACLChecklist::asyncState() const
-{
- return state_;
-}
-
/**
* Kick off a non-blocking (slow) ACL access list test
*
}
void
-ACLChecklist::resumeNonBlockingCheck(AsyncState *state)
+ACLChecklist::resumeNonBlockingCheck()
{
- assert(asyncState() == state);
- changeState(NullState::Instance());
-
if (asyncStage_ == asyncStarting) { // oops, we did not really go async
asyncStage_ = asyncFailed; // goAsync() checks for that
// Do not fall through to resume checks from the async callback. Let
public:
- /**
- * State class.
- * This abstract class defines the behaviour of
- * async lookups - which can vary for different ACL types.
- * Today, every state object must be a singleton.
- * See NULLState for an example.
- *
- \note *no* state should be stored in the state object,
- * they are used to change the behaviour of the checklist, not
- * to hold information. If you need to store information in the
- * state object, consider subclassing ACLChecklist, converting it
- * to a composite, or changing the state objects from singletons to
- * refcounted objects.
- */
-
- class AsyncState
- {
-
- public:
- virtual void checkForAsync(ACLChecklist *) const = 0;
- virtual ~AsyncState() {}
- };
-
- class NullState : public AsyncState
- {
-
- public:
- static NullState *Instance();
- void checkForAsync(ACLChecklist *) const override;
- ~NullState() override {}
-
- private:
- static NullState _instance;
- };
+ /// a function that initiates asynchronous ACL checks; see goAsync()
+ using AsyncStarter = void (ACLFilledChecklist &, const ACL &);
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(AsyncState *);
+ bool goAsync(AsyncStarter, const ACL &);
/// Matches (or resumes matching of) a child node while maintaning
/// resumption breadcrumbs if a [grand]child node goes async.
void matchAndFinish();
- void changeState(AsyncState *);
- AsyncState *asyncState() const;
-
const Acl::Tree *accessList;
public:
/// Resumes non-blocking check started by nonBlockingCheck() and
/// suspended until some async operation updated Squid state.
- void resumeNonBlockingCheck(AsyncState *state);
+ void resumeNonBlockingCheck();
private: /* internal methods */
/// Position of a child node within an ACL tree.
enum AsyncStage { asyncNone, asyncStarting, asyncRunning, asyncFailed };
AsyncStage asyncStage_;
- AsyncState *state_;
Breadcrumb matchLoc_; ///< location of the node running matches() now
Breadcrumb asyncLoc_; ///< currentNode_ that called goAsync()
unsigned asyncLoopDepth_; ///< how many times the current async state has resumed
#include "fqdncache.h"
#include "HttpRequest.h"
-DestinationDomainLookup DestinationDomainLookup::instance_;
+static void LookupDone(const char *, const Dns::LookupDetails &, void *data);
-DestinationDomainLookup *
-DestinationDomainLookup::Instance()
+static void
+StartLookup(ACLFilledChecklist &cl, const ACL &)
{
- return &instance_;
+ fqdncache_nbgethostbyaddr(cl.dst_addr, LookupDone, &cl);
}
-void
-DestinationDomainLookup::checkForAsync(ACLChecklist *cl) const
-{
- ACLFilledChecklist *checklist = Filled(cl);
- fqdncache_nbgethostbyaddr(checklist->dst_addr, LookupDone, checklist);
-}
-
-void
-DestinationDomainLookup::LookupDone(const char *, const Dns::LookupDetails &details, void *data)
+static void
+LookupDone(const char *, const Dns::LookupDetails &details, void *data)
{
ACLFilledChecklist *checklist = Filled((ACLChecklist*)data);
checklist->markDestinationDomainChecked();
checklist->request->recordLookup(details);
- checklist->resumeNonBlockingCheck(DestinationDomainLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
/* Acl::DestinationDomainCheck */
} else if (!checklist->destinationDomainChecked()) {
// TODO: Using AclMatchedName here is not OO correct. Should find a way to the current acl
debugs(28, 3, "Can't yet compare '" << AclMatchedName << "' ACL for " << checklist->request->url.host());
- if (checklist->goAsync(DestinationDomainLookup::Instance()))
+ if (checklist->goAsync(StartLookup, *this))
return -1;
// else fall through to "none" match, hiding the lookup failure (XXX)
}
} // namespace Acl
-/// \ingroup ACLAPI
-class DestinationDomainLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static DestinationDomainLookup *Instance();
- void checkForAsync(ACLChecklist *)const override;
-
-private:
- static DestinationDomainLookup instance_;
- static void LookupDone(const char *, const Dns::LookupDetails &, void *);
-};
-
#endif /* SQUID_ACLDESTINATIONDOMAIN_H */
} else if (!checklist->request->flags.destinationIpLookedUp) {
/* No entry in cache, lookup not attempted */
debugs(28, 3, "can't yet compare '" << name << "' ACL for " << checklist->request->url.host());
- if (checklist->goAsync(DestinationIPLookup::Instance()))
+ if (checklist->goAsync(StartLookup, *this))
return -1;
// else fall through to mismatch, hiding the lookup failure (XXX)
}
return 0;
}
-DestinationIPLookup DestinationIPLookup::instance_;
-
-DestinationIPLookup *
-DestinationIPLookup::Instance()
-{
- return &instance_;
-}
-
void
-DestinationIPLookup::checkForAsync(ACLChecklist *cl)const
+ACLDestinationIP::StartLookup(ACLFilledChecklist &cl, const ACL &)
{
- ACLFilledChecklist *checklist = Filled(cl);
- ipcache_nbgethostbyname(checklist->request->url.host(), LookupDone, checklist);
+ ipcache_nbgethostbyname(cl.request->url.host(), LookupDone, &cl);
}
void
-DestinationIPLookup::LookupDone(const ipcache_addrs *, const Dns::LookupDetails &details, void *data)
+ACLDestinationIP::LookupDone(const ipcache_addrs *, const Dns::LookupDetails &details, void *data)
{
ACLFilledChecklist *checklist = Filled((ACLChecklist*)data);
checklist->request->flags.destinationIpLookedUp = true;
checklist->request->recordLookup(details);
- checklist->resumeNonBlockingCheck(DestinationIPLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
#include "acl/Ip.h"
#include "ipcache.h"
-class DestinationIPLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static DestinationIPLookup *Instance();
- void checkForAsync(ACLChecklist *)const override;
-
-private:
- static DestinationIPLookup instance_;
- static IPH LookupDone;
-};
-
class ACLDestinationIP : public ACLIP
{
MEMPROXY_CLASS(ACLDestinationIP);
public:
+ static void StartLookup(ACLFilledChecklist &, const ACL &);
+
char const *typeString() const override;
const Acl::Options &options() override;
int match(ACLChecklist *checklist) override;
private:
+ static void LookupDone(const ipcache_addrs *, const Dns::LookupDetails &, void *data);
+
Acl::BooleanOptionValue lookupBanned; ///< are DNS lookups allowed?
};
#include "fqdncache.h"
#include "HttpRequest.h"
-SourceDomainLookup SourceDomainLookup::instance_;
+static void LookupDone(const char *, const Dns::LookupDetails &, void *data);
-SourceDomainLookup *
-SourceDomainLookup::Instance()
+static void
+StartLookup(ACLFilledChecklist &checklist, const ACL &)
{
- return &instance_;
+ fqdncache_nbgethostbyaddr(checklist.src_addr, LookupDone, &checklist);
}
-void
-SourceDomainLookup::checkForAsync(ACLChecklist *checklist) const
-{
- fqdncache_nbgethostbyaddr(Filled(checklist)->src_addr, LookupDone, checklist);
-}
-
-void
-SourceDomainLookup::LookupDone(const char *, const Dns::LookupDetails &details, void *data)
+static void
+LookupDone(const char *, const Dns::LookupDetails &details, void *data)
{
ACLFilledChecklist *checklist = Filled((ACLChecklist*)data);
checklist->markSourceDomainChecked();
checklist->request->recordLookup(details);
- checklist->resumeNonBlockingCheck(SourceDomainLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
int
} else if (!checklist->sourceDomainChecked()) {
// TODO: Using AclMatchedName here is not OO correct. Should find a way to the current acl
debugs(28, 3, "aclMatchAcl: Can't yet compare '" << AclMatchedName << "' ACL for '" << checklist->src_addr << "'");
- if (checklist->goAsync(SourceDomainLookup::Instance()))
+ if (checklist->goAsync(StartLookup, *this))
return -1;
// else fall through to "none" match, hiding the lookup failure (XXX)
}
} // namespace Acl
-class SourceDomainLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static SourceDomainLookup *Instance();
- void checkForAsync(ACLChecklist *)const override;
-
-private:
- static SourceDomainLookup instance_;
- static void LookupDone(const char *, const Dns::LookupDetails &, void *);
-};
-
#endif /* SQUID_ACLSOURCEDOMAIN_H */
* \retval ACCESS_ALLOWED user authenticated and authorized
*/
Acl::Answer
-AuthenticateAcl(ACLChecklist *ch)
+AuthenticateAcl(ACLChecklist *ch, const ACL &acl)
{
ACLFilledChecklist *checklist = Filled(ch);
const auto request = checklist->request;
break;
case AUTH_ACL_HELPER:
- if (checklist->goAsync(ProxyAuthLookup::Instance()))
+ if (checklist->goAsync(ACLProxyAuth::StartLookup, acl))
debugs(28, 4, "returning " << ACCESS_DUNNO << " sending credentials to helper.");
else
debugs(28, 2, "cannot go async; returning " << ACCESS_DUNNO);
class ACLChecklist;
/// \ingroup AuthAPI
-Acl::Answer AuthenticateAcl(ACLChecklist *ch);
+Acl::Answer AuthenticateAcl(ACLChecklist *, const ACL &);
#endif /* USE_AUTH */
#endif /* SQUID_AUTH_ACL_H */
ACLMaxUserIP::match(ACLChecklist *cl)
{
ACLFilledChecklist *checklist = Filled(cl);
- auto answer = AuthenticateAcl(checklist);
+ auto answer = AuthenticateAcl(checklist, *this);
int ti;
// convert to tri-state ACL match 1,0,-1
int
ACLProxyAuth::match(ACLChecklist *checklist)
{
- auto answer = AuthenticateAcl(checklist);
+ auto answer = AuthenticateAcl(checklist, *this);
// convert to tri-state ACL match 1,0,-1
switch (answer) {
return true;
}
-ProxyAuthLookup ProxyAuthLookup::instance_;
-
-ProxyAuthLookup *
-ProxyAuthLookup::Instance()
-{
- return &instance_;
-}
-
void
-ProxyAuthLookup::checkForAsync(ACLChecklist *cl) const
+ACLProxyAuth::StartLookup(ACLFilledChecklist &cl, const ACL &)
{
- ACLFilledChecklist *checklist = Filled(cl);
-
debugs(28, 3, "checking password via authenticator");
/* make sure someone created auth_user_request for us */
- assert(checklist->auth_user_request != nullptr);
- assert(checklist->auth_user_request->valid());
- checklist->auth_user_request->start(checklist->request.getRaw(), checklist->al, LookupDone, checklist);
+ assert(cl.auth_user_request != nullptr);
+ assert(cl.auth_user_request->valid());
+ cl.auth_user_request->start(cl.request.getRaw(), cl.al, LookupDone, &cl);
}
void
-ProxyAuthLookup::LookupDone(void *data)
+ACLProxyAuth::LookupDone(void *data)
{
ACLFilledChecklist *checklist = Filled(static_cast<ACLChecklist*>(data));
}
}
- checklist->resumeNonBlockingCheck(ProxyAuthLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
int
#include "acl/Checklist.h"
#include "acl/Data.h"
-class ProxyAuthLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static ProxyAuthLookup *Instance();
- void checkForAsync(ACLChecklist *) const override;
-
-private:
- static ProxyAuthLookup instance_;
- static void LookupDone(void *data);
-};
-
class ACLProxyAuth : public ACL
{
MEMPROXY_CLASS(ACLProxyAuth);
public:
+ static void StartLookup(ACLFilledChecklist &, const ACL &);
+
~ACLProxyAuth() override;
ACLProxyAuth(ACLData<char const *> *, char const *);
int matchForCache(ACLChecklist *checklist) override;
private:
+ static void LookupDone(void *data);
+
/* ACL API */
const Acl::Options &lineOptions() override;
#define DEFAULT_EXTERNAL_ACL_CHILDREN 5
#endif
-static char *makeExternalAclKey(ACLFilledChecklist * ch, external_acl_data * acl_data);
static void external_acl_cache_delete(external_acl * def, const ExternalACLEntryPointer &entry);
static int external_acl_entry_expired(external_acl * def, const ExternalACLEntryPointer &entry);
static int external_acl_grace_expired(external_acl * def, const ExternalACLEntryPointer &entry);
}
}
-static Acl::Answer
-aclMatchExternal(external_acl_data *acl, ACLFilledChecklist *ch)
+// TODO: Diff reduction. Rename this helper method to match_() or similar.
+Acl::Answer
+ACLExternal::aclMatchExternal(external_acl_data *acl, ACLFilledChecklist *ch) const
{
debugs(82, 9, "acl=\"" << acl->def->name << "\"");
ExternalACLEntryPointer entry = ch->extacl_entry;
if (acl->def->require_auth) {
/* Make sure the user is authenticated */
debugs(82, 3, acl->def->name << " check user authenticated.");
- const auto ti = AuthenticateAcl(ch);
+ const auto ti = AuthenticateAcl(ch, *this);
if (!ti.allowed()) {
debugs(82, 2, acl->def->name << " user not authenticated (" << ti << ")");
return ti;
if (entry != nullptr && external_acl_grace_expired(acl->def, entry)) {
// refresh in the background
- ExternalACLLookup::Start(ch, acl, true);
+ startLookup(ch, acl, true);
debugs(82, 4, "no need to wait for the refresh of '" <<
key << "' in '" << acl->def->name << "' (ch=" << ch << ").");
}
// TODO: All other helpers allow temporary overload. Should not we?
if (!acl->def->theHelper->willOverload()) {
debugs(82, 2, "\"" << key << "\": queueing a call.");
- if (!ch->goAsync(ExternalACLLookup::Instance()))
+ if (!ch->goAsync(StartLookup, *this))
debugs(82, 2, "\"" << key << "\": no async support!");
debugs(82, 2, "\"" << key << "\": return -1.");
return ACCESS_DUNNO; // expired cached or simply absent entry
dlinkAdd(e, &entry->lru, &def->lru_list);
}
-static char *
-makeExternalAclKey(ACLFilledChecklist * ch, external_acl_data * acl_data)
+char *
+ACLExternal::makeExternalAclKey(ACLFilledChecklist * ch, external_acl_data * acl_data) const
{
static MemBuf mb;
mb.reset();
if (!*ch->rfc931) {
// if we fail to go async, we still return NULL and the caller
// will detect the failure in ACLExternal::match().
- (void)ch->goAsync(IdentLookup::Instance());
+ (void)ch->goAsync(ACLIdent::StartLookup, *this);
return nullptr;
}
}
} while (state);
}
+/// Asks the helper (if needed) or returns the [cached] result (otherwise).
+/// Does not support "background" lookups. See also: ACLExternal::Start().
void
-ACLExternal::ExternalAclLookup(ACLChecklist *checklist, ACLExternal * me)
+ACLExternal::StartLookup(ACLFilledChecklist &checklist, const ACL &acl)
{
- ExternalACLLookup::Start(checklist, me->data, false);
+ const auto &me = dynamic_cast<const ACLExternal&>(acl);
+ me.startLookup(&checklist, me.data, false);
}
+// If possible, starts an asynchronous lookup of an external ACL.
+// Otherwise, asserts (or bails if background refresh is requested).
void
-ExternalACLLookup::Start(ACLChecklist *checklist, external_acl_data *acl, bool inBackground)
+ACLExternal::startLookup(ACLFilledChecklist *ch, external_acl_data *acl, bool inBackground) const
{
external_acl *def = acl->def;
- ACLFilledChecklist *ch = Filled(checklist);
const char *key = makeExternalAclKey(ch, acl);
assert(key); // XXX: will fail if EXT_ACL_IDENT case needs an async lookup
externalAclState *state = new externalAclState(def, key);
if (!inBackground) {
- state->callback = &ExternalACLLookup::LookupDone;
- state->callback_data = cbdataReference(checklist);
+ state->callback = &LookupDone;
+ state->callback_data = cbdataReference(ch);
}
if (oldstate) {
}
}
-ExternalACLLookup ExternalACLLookup::instance_;
-ExternalACLLookup *
-ExternalACLLookup::Instance()
-{
- return &instance_;
-}
-
-void
-ExternalACLLookup::checkForAsync(ACLChecklist *checklist)const
-{
- /* TODO: optimise this - we probably have a pointer to this
- * around somewhere */
- ACL *acl = ACL::FindByName(AclMatchedName);
- assert(acl);
- ACLExternal *me = dynamic_cast<ACLExternal *> (acl);
- assert (me);
- ACLExternal::ExternalAclLookup(checklist, me);
-}
-
/// Called when an async lookup returns
void
-ExternalACLLookup::LookupDone(void *data, const ExternalACLEntryPointer &result)
+ACLExternal::LookupDone(void *data, const ExternalACLEntryPointer &result)
{
ACLFilledChecklist *checklist = Filled(static_cast<ACLChecklist*>(data));
checklist->extacl_entry = result;
- checklist->resumeNonBlockingCheck(ExternalACLLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
ACLExternal::ACLExternal(char const *theClass) : data(nullptr), class_(xstrdup(theClass))
int
ACLIdent::match(ACLChecklist *cl)
{
- ACLFilledChecklist *checklist = Filled(cl);
+ const auto checklist = Filled(cl);
if (checklist->rfc931[0]) {
return data->match(checklist->rfc931);
} else if (checklist->conn() != nullptr && checklist->conn()->clientConnection != nullptr && checklist->conn()->clientConnection->rfc931[0]) {
return data->match(checklist->conn()->clientConnection->rfc931);
} else if (checklist->conn() != nullptr && Comm::IsConnOpen(checklist->conn()->clientConnection)) {
- if (checklist->goAsync(IdentLookup::Instance())) {
+ if (checklist->goAsync(StartLookup, *this)) {
debugs(28, 3, "switching to ident lookup state");
return -1;
}
return data->empty();
}
-IdentLookup IdentLookup::instance_;
-
-IdentLookup *
-IdentLookup::Instance()
-{
- return &instance_;
-}
-
void
-IdentLookup::checkForAsync(ACLChecklist *cl)const
+ACLIdent::StartLookup(ACLFilledChecklist &cl, const ACL &)
{
- ACLFilledChecklist *checklist = Filled(cl);
- const ConnStateData *conn = checklist->conn();
+ const ConnStateData *conn = cl.conn();
// check that ACLIdent::match() tested this lookup precondition
assert(conn && Comm::IsConnOpen(conn->clientConnection));
debugs(28, 3, "Doing ident lookup" );
- Ident::Start(checklist->conn()->clientConnection, LookupDone, checklist);
+ Ident::Start(cl.conn()->clientConnection, LookupDone, &cl);
}
void
-IdentLookup::LookupDone(const char *ident, void *data)
+ACLIdent::LookupDone(const char *ident, void *data)
{
ACLFilledChecklist *checklist = Filled(static_cast<ACLChecklist*>(data));
if (checklist->conn() != nullptr && checklist->conn()->clientConnection != nullptr && !checklist->conn()->clientConnection->rfc931[0])
xstrncpy(checklist->conn()->clientConnection->rfc931, checklist->rfc931, USER_IDENT_SZ);
- checklist->resumeNonBlockingCheck(IdentLookup::Instance());
+ checklist->resumeNonBlockingCheck();
}
#endif /* USE_IDENT */
#if USE_IDENT
-#include "acl/Checklist.h"
-
-/// \ingroup ACLAPI
-class IdentLookup : public ACLChecklist::AsyncState
-{
-
-public:
- static IdentLookup *Instance();
- void checkForAsync(ACLChecklist *)const override;
-
-private:
- static IdentLookup instance_;
- static void LookupDone(const char *ident, void *data);
-};
-
#include "acl/Acl.h"
+#include "acl/Checklist.h"
#include "acl/Data.h"
/// \ingroup ACLAPI
MEMPROXY_CLASS(ACLIdent);
public:
+ static void StartLookup(ACLFilledChecklist &, const ACL &);
+
ACLIdent(ACLData<char const *> *newData, char const *);
~ACLIdent() override;
bool empty () const override;
private:
+ static void LookupDone(const char *ident, void *data);
+
/* ACL API */
const Acl::Options &lineOptions() override;
bool ACLExternal::empty () const STUB_RETVAL(false)
int ACLExternal::match(ACLChecklist *) STUB_RETVAL(0)
SBufList ACLExternal::dump() const STUB_RETVAL(SBufList())
-void ACLExternal::ExternalAclLookup(ACLChecklist *, ACLExternal *) STUB
-void ExternalACLLookup::Start(ACLChecklist *, external_acl_data *, bool) STUB
void externalAclInit(void) STUB_NOP
void externalAclShutdown(void) STUB_NOP
-ExternalACLLookup * ExternalACLLookup::Instance() STUB_RETVAL(nullptr)
-void ExternalACLLookup::checkForAsync(ACLChecklist *) const STUB
-void ExternalACLLookup::LookupDone(void *, const ExternalACLEntryPointer &) STUB
#include "acl/Acl.h" /* for Acl::Answer */
#include "auth/Acl.h"
-Acl::Answer AuthenticateAcl(ACLChecklist *) STUB_RETVAL(ACCESS_DENIED)
+Acl::Answer AuthenticateAcl(ACLChecklist *, const ACL &) STUB_RETVAL(ACCESS_DENIED)
#include "auth/AclMaxUserIp.h"
ACLMaxUserIP::ACLMaxUserIP (char const *) STUB
SBufList ACLProxyAuth::dump() const STUB_RETVAL(SBufList())
bool ACLProxyAuth::empty () const STUB_RETVAL(false)
bool ACLProxyAuth::valid () const STUB_RETVAL(false)
-ProxyAuthLookup * ProxyAuthLookup::Instance() STUB_RETVAL(nullptr)
-void ProxyAuthLookup::checkForAsync(ACLChecklist *) const STUB
-void ProxyAuthLookup::LookupDone(void *) STUB
int ACLProxyAuth::matchForCache(ACLChecklist *) STUB_RETVAL(0)
int ACLProxyAuth::matchProxyAuth(ACLChecklist *) STUB_RETVAL(0)
const Acl::Options &ACLProxyAuth::lineOptions() STUB_RETVAL(Acl::NoOptions())
projects / thirdparty / squid.git / commitdiff
