Connection.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2021 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 _SQUIDCONNECTIONDETAIL_H_
#define _SQUIDCONNECTIONDETAIL_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 "SquidTime.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           0x40
 
class Connection: public CodeContext
{
    MEMPROXY_CLASS(Comm::Connection);
 
public:
    Connection();
 
    virtual ~Connection();
 
    ConnectionPointer cloneIdentDetails() const;
 
    ConnectionPointer cloneDestinationDetails() 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);
 
    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 */
    virtual ScopedId codeContextGist() const override;
    virtual std::ostream &detailCodeContext(std::ostream &os) const override;
 
private:
    Connection(const Connection &c);
 
    Connection & operator =(const Connection &c);
 
public:
    Ip::Address local;
 
    Ip::Address remote;
 
    hier_code peerType;
 
    int fd;
 
    tos_t tos;
 
    nfmark_t nfmark;
 
    nfmark_t nfConnmark = 0;
 
    int flags;
 
    char rfc931[USER_IDENT_SZ];
 
#if USE_SQUID_EUI
    Eui::Eui48 remoteEui48;
    Eui::Eui64 remoteEui64;
#endif
 
    InstanceId<Connection, uint64_t> id;
 
private:
    CachePeer *peer_;
 
    time_t startTime_;
 
    Security::NegotiationHistory *tlsHistory;
};
 
}; // namespace Comm
 
std::ostream &operator << (std::ostream &os, const Comm::Connection &conn);
 
inline std::ostream &
operator << (std::ostream &os, const Comm::ConnectionPointer &conn)
{
    if (conn != NULL)
        os << *conn;
    return os;
}
 
#endif