ClientInfo.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__SRC_CLIENTINFO_H
#define SQUID__SRC_CLIENTINFO_H
 
#if USE_DELAY_POOLS
#include "BandwidthBucket.h"
#endif
#include "base/ByteCounter.h"
#include "cbdata.h"
#include "enums.h"
#include "hash.h"
#include "ip/Address.h"
#include "LogTags.h"
#include "mem/forward.h"
#include "typedefs.h"
 
#include <deque>
 
#if USE_DELAY_POOLS
class CommQuotaQueue;
#endif
 
class ClientInfo : public hash_link
#if USE_DELAY_POOLS
    , public BandwidthBucket
#endif
{
    MEMPROXY_CLASS(ClientInfo);
 
public:
    explicit ClientInfo(const Ip::Address &);
#if USE_DELAY_POOLS
    ~ClientInfo() override;
#else
    ~ClientInfo();
#endif
 
    Ip::Address addr;
 
    struct Protocol {
        Protocol() : n_requests(0) {
            memset(result_hist, 0, sizeof(result_hist));
        }
 
        int result_hist[LOG_TYPE_MAX];
        int n_requests;
        ByteCounter kbytes_in;
        ByteCounter kbytes_out;
        ByteCounter hit_kbytes_out;
    } Http, Icp;
 
    struct Cutoff {
        Cutoff() : time(0), n_req(0), n_denied(0) {}
 
        time_t time;
        int n_req;
        int n_denied;
    } cutoff;
    int n_established;          /* number of current established connections */
    time_t last_seen;
#if USE_DELAY_POOLS
    bool writeLimitingActive; 
    bool firstTimeConnection;
 
    CommQuotaQueue *quotaQueue; 
    int rationedQuota; 
    int rationedCount; 
    bool eventWaiting; 
 
    // all those functions access Comm fd_table and are defined in comm.cc
    bool hasQueue() const;  
    bool hasQueue(const CommQuotaQueue*) const;  
    unsigned int quotaEnqueue(int fd); 
    int quotaPeekFd() const; 
    unsigned int quotaPeekReserv() const; 
    void quotaDequeue(); 
    void kickQuotaQueue(); 
    void writeOrDequeue();
 
    /* BandwidthBucket API */
    int quota() override; 
    bool applyQuota(int &nleft, Comm::IoCallback *state) override;
    void scheduleWrite(Comm::IoCallback *state) override;
    void onFdClosed() override;
    void reduceBucket(int len) override;
 
    void quotaDumpQueue(); 
 
    void setWriteLimiter(const int aWriteSpeedLimit, const double anInitialBurst, const double aHighWatermark);
#endif /* USE_DELAY_POOLS */
};
 
#if USE_DELAY_POOLS
// a queue of Comm clients waiting for I/O quota controlled by delay pools
class CommQuotaQueue
{
    CBDATA_CLASS(CommQuotaQueue);
 
public:
    CommQuotaQueue(ClientInfo *info);
    ~CommQuotaQueue();
 
    bool empty() const { return fds.empty(); }
    size_t size() const { return fds.size(); }
    int front() const { return fds.front(); }
    unsigned int enqueue(int fd);
    void dequeue();
 
    ClientInfo *clientInfo; 
 
    // these counters might overflow; that is OK because they are for IDs only
    int ins; 
    int outs; 
 
private:
    // TODO: optimize using a Ring- or List-based store?
    typedef std::deque<int> Store;
    Store fds; 
};
#endif /* USE_DELAY_POOLS */
 
#endif