StoreClient.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_STORECLIENT_H
#define SQUID_STORECLIENT_H
 
#include "acl/ChecklistFiller.h"
#include "base/AsyncCall.h"
#include "base/forward.h"
#include "dlink.h"
#include "store/ParsingBuffer.h"
#include "StoreIOBuffer.h"
#include "StoreIOState.h"
 
using STCB = void (void *, StoreIOBuffer);
 
class StoreEntry;
class ACLFilledChecklist;
class LogTags;
 
class StoreClient: public Acl::ChecklistFiller
{
 
public:
    ~StoreClient () override {}
 
    virtual LogTags *loggingTags() const = 0;
 
protected:
    bool startCollapsingOn(const StoreEntry &, const bool doingRevalidation) const;
 
    // These methods only interpret Squid configuration. Their allowances are
    // provisional -- other factors may prevent collapsed forwarding. The first
    // two exist primarily to distinguish two major CF cases in callers code.
    bool mayInitiateCollapsing() const { return onCollapsingPath(); }
    bool onCollapsingPath() const;
};
 
#if USE_DELAY_POOLS
#include "DelayId.h"
#endif
 
/* keep track each client receiving data from that particular StoreEntry */
 
class store_client
{
    CBDATA_CLASS(store_client);
 
public:
    explicit store_client(StoreEntry *);
    ~store_client();
 
    // TODO: Callers do not expect negative offset. Verify that the return
    // value cannot be negative and convert to unsigned in this case.
    int64_t readOffset() const { return copyInto.offset; }
 
    int getType() const;
 
    void noteSwapInDone(bool error);
 
    void doCopy (StoreEntry *e);
    void readHeader(const char *buf, ssize_t len);
    void readBody(const char *buf, ssize_t len);
 
    void copy(StoreEntry *, StoreIOBuffer, STCB *, void *);
 
    void dumpStats(MemBuf * output, int clientNumber) const;
 
    // TODO: When STCB gets a dedicated Answer type, move this info there.
    bool atEof() const { return atEof_; }
 
#if STORE_CLIENT_LIST_DEBUG
 
    void *owner;
#endif
 
    StoreEntry *entry;      /* ptr to the parent StoreEntry, argh! */
    StoreIOState::Pointer swapin_sio;
 
    struct {
        // TODO: a better name reflecting the 'in' scope of the flag
        bool disk_io_pending;
 
        bool store_copying;
    } flags;
 
#if USE_DELAY_POOLS
    DelayId delayId;
 
    int bytesWanted() const;
 
    void setDelayId(DelayId delay_id);
#endif
 
    dlink_node node;
 
private:
    bool moreToRead() const;
    bool canReadFromMemory() const;
    bool answeredOnce() const { return answers >= 1; }
    bool sendingHttpHeaders() const;
    int64_t nextHttpReadOffset() const;
 
    void fileRead();
    void scheduleDiskRead();
    void readFromMemory();
    void scheduleRead();
    bool startSwapin();
    void handleBodyFromDisk();
    void maybeWriteFromDiskToMemory(const StoreIOBuffer &);
 
    bool parseHttpHeadersFromDisk();
    bool tryParsingHttpHeaders();
    void skipHttpHeadersFromDisk();
 
    void fail();
    void callback(ssize_t);
    void noteCopiedBytes(size_t);
    void noteNews();
    void finishCallback();
    static void FinishCallback(store_client *);
 
    int type;
    bool object_ok;
 
    bool atEof_;
 
    StoreIOBuffer copyInto;
 
    uint64_t answers;
 
    std::optional<Store::ParsingBuffer> parsingBuffer;
 
    StoreIOBuffer lastDiskRead; 
 
    /* Until we finish stuffing code into store_client */
 
public:
 
    struct Callback {
        Callback() = default;
 
        Callback (STCB *, void *);
 
        bool pending() const;
 
        STCB *callback_handler = nullptr; 
        CallbackData cbData; 
        CodeContextPointer codeContext; 
 
        AsyncCall::Pointer notifier;
    } _callback;
};
 
void storeClientCopy(store_client *, StoreEntry *, StoreIOBuffer, STCB *, void *);
 
store_client* storeClientListAdd(StoreEntry * e, void *data);
int storeUnregister(store_client * sc, StoreEntry * e, void *data);
int storePendingNClients(const StoreEntry * e);
int storeClientIsThisAClient(store_client * sc, void *someClient);
 
#endif /* SQUID_STORECLIENT_H */