Checklist.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2025 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_CHECKLIST_H
#define SQUID_SRC_ACL_CHECKLIST_H
 
#include "acl/Acl.h"
#include "acl/InnerNode.h"
#include "cbdata.h"
 
#include <optional>
#include <stack>
#include <vector>
 
class HttpRequest;
 
typedef void ACLCB(Acl::Answer, void *);
 
class ACLChecklist
{
 
public:
 
    using AsyncStarter = void (ACLFilledChecklist &, const Acl::Node &);
 
public:
    ACLChecklist();
    virtual ~ACLChecklist();
 
    Acl::Answer const & fastCheck();
 
    const Acl::Answer &fastCheck(const ACLList *);
 
    bool goAsync(AsyncStarter, const Acl::Node &);
 
    bool matchChild(const Acl::InnerNode *parent, Acl::Nodes::const_iterator pos);
 
    bool keepMatching() const { return !finished() && !asyncInProgress(); }
 
    bool finished() const { return finished_; }
    bool asyncInProgress() const { return asyncStage_ != asyncNone; }
    void markFinished(const Acl::Answer &newAnswer, const char *reason);
 
    const Acl::Answer &currentAnswer() const { return answer_; }
 
    bool bannedAction(const Acl::Answer &action) const;
    void banAction(const Acl::Answer &action);
 
    // XXX: ACLs that need request or reply have to use ACLFilledChecklist and
    // should do their own checks so that we do not have to povide these two
    // for ACL::checklistMatches to use
    virtual bool hasRequest() const = 0;
    virtual bool hasReply() const = 0;
    virtual bool hasAle() const = 0;
    virtual void syncAle(HttpRequest *adaptedRequest, const char *logUri) const = 0;
    virtual void verifyAle() const = 0;
 
    void changeAcl(const acl_access *);
 
    void setLastCheckedName(const SBuf &name) { lastCheckedName_ = name; }
 
protected:
    void nonBlockingCheck(ACLCB * callback, void *callback_data);
 
private:
    void checkCallback(const char *abortReason);
 
    void matchAndFinish();
 
    Acl::TreePointer swapAcl(const acl_access *);
 
    Acl::TreePointer accessList;
 
public:
 
    ACLCB *callback;
    void *callback_data;
 
    void resumeNonBlockingCheck();
 
private: /* internal methods */
    class Breadcrumb
    {
    public:
        Breadcrumb(): parent(nullptr) {}
        Breadcrumb(const Acl::InnerNode *aParent, Acl::Nodes::const_iterator aPos): parent(aParent), position(aPos) {}
        bool operator ==(const Breadcrumb &b) const { return parent == b.parent && (!parent || position == b.position); }
        bool operator !=(const Breadcrumb &b) const { return !this->operator ==(b); }
        void clear() { parent = nullptr; }
        RefCount<const Acl::InnerNode> parent; 
        Acl::Nodes::const_iterator position; 
    };
 
    typedef enum { nmrMatch, nmrMismatch, nmrFinished, nmrNeedsAsync }
    NodeMatchingResult;
 
    void preCheck(const char *what);
    bool prepNonBlocking();
    void completeNonBlocking();
    void calcImplicitAnswer();
 
    bool asyncCaller_; 
    bool occupied_; 
    bool finished_;
    Acl::Answer answer_;
 
    enum AsyncStage { asyncNone, asyncStarting, asyncRunning, asyncFailed };
    AsyncStage asyncStage_;
    Breadcrumb matchLoc_; 
    Breadcrumb asyncLoc_; 
    unsigned asyncLoopDepth_; 
 
    bool callerGone();
 
    std::stack<Breadcrumb> matchPath;
    std::vector<Acl::Answer> bannedActions_;
 
    std::optional<SBuf> lastCheckedName_;
};
 
#endif /* SQUID_SRC_ACL_CHECKLIST_H */