Checklist.h

Go to the documentation of this file.

/*
 * 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_ACLCHECKLIST_H
#define SQUID_ACLCHECKLIST_H
 
#include "acl/InnerNode.h"
#include <stack>
#include <vector>
 
class HttpRequest;
 
typedef void ACLCB(Acl::Answer, void *);
 
class ACLChecklist
{
 
public:
 
    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;
    };
 
public:
    ACLChecklist();
    virtual ~ACLChecklist();
 
    void nonBlockingCheck(ACLCB * callback, void *callback_data);
 
    Acl::Answer const & fastCheck();
 
    Acl::Answer const & fastCheck(const Acl::Tree *list);
 
    bool goAsync(AsyncState *);
 
    bool matchChild(const Acl::InnerNode *parent, Acl::Nodes::const_iterator pos, const ACL *child);
 
    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;
 
    const Acl::Tree *changeAcl(const Acl::Tree *t) {
        const Acl::Tree *old = accessList;
        if (t != accessList) {
            cbdataReferenceDone(accessList);
            accessList = cbdataReference(t);
        }
        return old;
    }
 
private:
    void checkCallback(Acl::Answer answer);
 
    void matchAndFinish();
 
    void changeState(AsyncState *);
    AsyncState *asyncState() const;
 
    const Acl::Tree *accessList;
public:
 
    ACLCB *callback;
    void *callback_data;
 
    void resumeNonBlockingCheck(AsyncState *state);
 
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; }
        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_;
    AsyncState *state_;
    Breadcrumb matchLoc_; 
    Breadcrumb asyncLoc_; 
    unsigned asyncLoopDepth_; 
 
    bool callerGone();
 
    std::stack<Breadcrumb> matchPath;
    std::vector<Acl::Answer> bannedActions_;
};
 
#endif /* SQUID_ACLCHECKLIST_H */