Connection.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.
 */
 
/* DEBUG: section 05    Socket Functions */
 
#ifndef SQUID_SRC_COMM_CONNECTION_H
#define SQUID_SRC_COMM_CONNECTION_H
 
#include "base/CodeContext.h"
#include "base/InstanceId.h"
#include "comm/forward.h"
#include "defines.h"
#if USE_SQUID_EUI
#include "eui/Eui48.h"
#include "eui/Eui64.h"
#endif
#include "hier_code.h"
#include "ip/Address.h"
#include "ip/forward.h"
#include "mem/forward.h"
#include "time/gadgets.h"
 
#include <iosfwd>
#include <ostream>
 
class CachePeer;
 
namespace Security
{
class NegotiationHistory;
};
 
namespace Comm
{
 
/* TODO: make these a struct of boolean flags members in the connection instead of a bitmap.
 * we can't do that until all non-comm code uses Commm::Connection objects to create FD
 * currently there is code still using comm_open() and comm_openex() synchronously!!
 */
#define COMM_UNSET              0x00
#define COMM_NONBLOCKING        0x01  // default flag.
#define COMM_NOCLOEXEC          0x02
#define COMM_REUSEADDR          0x04  // shared FD may be both accept()ing and read()ing
#define COMM_DOBIND             0x08  // requires a bind()
#define COMM_TRANSPARENT        0x10  // arrived via TPROXY
#define COMM_INTERCEPTION       0x20  // arrived via NAT
#define COMM_REUSEPORT          0x40 //< needs SO_REUSEPORT
#define COMM_ORPHANED           0x80
#define COMM_DOBIND_PORT_LATER 0x100
 
class Connection: public CodeContext
{
    MEMPROXY_CLASS(Comm::Connection);
 
public:
    Connection() { noteStart(); }
 
    ~Connection() override;
 
    Connection(const Connection &&) = delete;
 
    ConnectionPointer cloneProfile() const;
 
    void enterOrphanage() { flags |= COMM_ORPHANED; }
    void leaveOrphanage() { flags &= ~COMM_ORPHANED; }
 
    void close();
 
    void noteClosure();
 
    bool isOpen() const { return (fd >= 0); }
 
    void setAddrs(const Ip::Address &aLocal, const Ip::Address &aRemote) {local = aLocal; remote = aRemote;}
 
    CachePeer * getPeer() const;
 
    void setPeer(CachePeer * p);
 
    bool toGoneCachePeer() const;
 
    time_t startTime() const {return startTime_;}
 
    time_t lifeTime() const {return squid_curtime - startTime_;}
 
    time_t timeLeft(const time_t idleTimeout) const;
 
    time_t connectTimeout(const time_t fwdStart) const;
 
    void noteStart() {startTime_ = squid_curtime;}
 
    Security::NegotiationHistory *tlsNegotiations();
    const Security::NegotiationHistory *hasTlsNegotiations() const {return tlsHistory;}
 
    /* CodeContext API */
    ScopedId codeContextGist() const override;
    std::ostream &detailCodeContext(std::ostream &os) const override;
 
public:
    Ip::Address local;
 
    Ip::Address remote;
 
    hier_code peerType = HIER_NONE;
 
    int fd = -1;
 
    tos_t tos = 0;
 
    nfmark_t nfmark = 0;
 
    nfmark_t nfConnmark = 0;
 
    int flags = COMM_NONBLOCKING;
 
#if USE_SQUID_EUI
    Eui::Eui48 remoteEui48;
    Eui::Eui64 remoteEui64;
#endif
 
    InstanceId<Connection, uint64_t> id;
 
private:
    CachePeer *peer_ = nullptr;
 
    time_t startTime_;
 
    Security::NegotiationHistory *tlsHistory = nullptr;
};
 
std::ostream &operator <<(std::ostream &, const Connection &);
 
inline std::ostream &
operator <<(std::ostream &os, const ConnectionPointer &conn)
{
    if (conn != nullptr)
        os << *conn;
    return os;
}
 
} // namespace Comm
 
#endif /* SQUID_SRC_COMM_CONNECTION_H */