Address.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.
 */
 
/* DEBUG: section 14    IP Storage and Handling */
 
#ifndef _SQUID_SRC_IP_ADDRESS_H
#define _SQUID_SRC_IP_ADDRESS_H
 
#include "ip/forward.h"
 
#include <iosfwd>
#include <ostream>
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#if HAVE_NETINET_IP_H
#include <netinet/ip.h>
#endif
#if HAVE_WS2TCPIP_H
#include <ws2tcpip.h>
#endif
#if HAVE_NETDB_H
#include <netdb.h>
#endif
 
namespace Ip
{
 
class Address
{
 
public:
    Address() { setEmpty(); }
    Address(const struct in_addr &);
    Address(const struct sockaddr_in &);
    Address(const struct in6_addr &);
    Address(const struct sockaddr_in6 &);
    Address(const struct hostent &);
    Address(const struct addrinfo &);
    Address(const char*);
    Address& operator =(struct sockaddr_in const &s);
    Address& operator =(struct sockaddr_storage const &s);
    Address& operator =(struct in_addr const &s);
    Address& operator =(struct in6_addr const &s);
    Address& operator =(struct sockaddr_in6 const &s);
    bool operator =(const struct hostent &s);
    bool operator =(const struct addrinfo &s);
    bool operator =(const char *s);
    bool operator ==(Address const &s) const;
    bool operator !=(Address const &s) const;
    bool operator >=(Address const &rhs) const;
    bool operator <=(Address const &rhs) const;
    bool operator >(Address const &rhs) const;
    bool operator <(Address const &rhs) const;
 
public:
    /* methods */
 
    bool isIPv4() const;
 
    bool isIPv6() const;
 
    bool isSockAddr() const;
 
    bool isAnyAddr() const;
 
    bool isNoAddr() const;
 
    bool isLocalhost() const;
 
    bool isSiteLocal6() const;
 
    bool isSiteLocalAuto() const;
 
    unsigned short port() const;
 
    unsigned short port(unsigned short port);
 
    void setAnyAddr();
 
    void setNoAddr();
 
    void setLocalhost();
 
    void setEmpty();
 
    bool setIPv4();
 
    int cidr() const;
 
    int applyMask(const Address &mask);
 
    bool applyMask(const unsigned int cidr, int mtype);
 
    void applyClientMask(const Address &mask);
 
    char* toStr(char *buf, const unsigned int blen, int force = AF_UNSPEC) const;
 
    char* toUrl(char *buf, unsigned int len) const;
 
    unsigned int toHostStr(char *buf, const unsigned int len) const;
 
    bool fromHost(const char *hostWithoutPort);
 
    bool getReverseString(char buf[MAX_IPSTRLEN], int show_type = AF_UNSPEC) const;
 
    int matchIPAddr(const Address &rhs) const;
 
    int compareWhole(const Ip::Address &rhs) const;
 
    void getAddrInfo(struct addrinfo *&ai, int force = AF_UNSPEC) const;
 
    static void FreeAddr(struct addrinfo *&ai);
 
    static void InitAddr(struct addrinfo *&ai);
 
    bool GetHostByName(const char *s);
 
    static const Address &NoAddr() { static const Address noAddr(v6_noaddr); return noAddr; }
 
public:
    /* XXX: When C => C++ conversion is done will be fully private.
     * Legacy Transition Methods.
     * These are here solely to simplify the transition
     * when moving from converted code to unconverted
     * these functions can be used to convert this object
     * and pull out the data needed by the unconverted code
     * they are intentionaly hard to use, use getAddrInfo() instead.
     * these functions WILL NOT be in the final public API after transition.
     */
 
    void getSockAddr(struct sockaddr_storage &addr, const int family) const;
    void getSockAddr(struct sockaddr_in &) const;
    bool getInAddr(struct in_addr &) const; /* false if could not convert IPv6 down to IPv4 */
    void getSockAddr(struct sockaddr_in6 &) const;
    void getInAddr(struct in6_addr &) const;
 
private:
    /* Conversion for dual-type internals */
 
    bool getReverseString4(char buf[MAX_IPSTRLEN], const struct in_addr &dat) const;
 
    bool getReverseString6(char buf[MAX_IPSTRLEN], const struct in6_addr &dat) const;
 
    void map4to6(const struct in_addr &src, struct in6_addr &dest) const;
 
    void map6to4(const struct in6_addr &src, struct in_addr &dest) const;
 
    // Worker behind GetHostName and char* converters
    bool lookupHostIP(const char *s, bool nodns);
 
    /* variables */
    struct sockaddr_in6 mSocketAddr_;
 
private:
    /* Internally used constants */
    static const unsigned int STRLEN_IP4A = 16;              // aaa.bbb.ccc.ddd\0
    static const unsigned int STRLEN_IP4R = 28;              // ddd.ccc.bbb.aaa.in-addr.arpa.\0
    static const unsigned int STRLEN_IP4S = 21;              // ddd.ccc.bbb.aaa:ppppp\0
    static const unsigned int MAX_IP4_STRLEN = STRLEN_IP4R;
    static const unsigned int STRLEN_IP6A = 42;           // [ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]/0
    static const unsigned int STRLEN_IP6R = 75;           // f.f.f.f f.f.f.f f.f.f.f f.f.f.f f.f.f.f f.f.f.f f.f.f.f f.f.f.f ipv6.arpa./0
    static const unsigned int STRLEN_IP6S = 48;           // [ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:00000/0
    static const unsigned int MAX_IP6_STRLEN = STRLEN_IP6R;
    static const struct in6_addr v4_localhost;
    static const struct in6_addr v4_anyaddr;
    static const struct in6_addr v4_noaddr;
    static const struct in6_addr v6_noaddr;
};
 
inline std::ostream &
operator << (std::ostream &os, const Address &ipa)
{
    char buf[MAX_IPSTRLEN];
    os << ipa.toUrl(buf,MAX_IPSTRLEN);
    return os;
}
 
// WAS _sockaddr_in_list in an earlier incarnation
class Address_list
{
public:
    Address_list() { next = nullptr; };
    ~Address_list() { if (next) delete next; next = nullptr; };
 
    Address s;
    Address_list *next;
};
 
} // namespace Ip
 
void parse_IpAddress_list_token(Ip::Address_list **, char *);
 
#endif /* _SQUID_SRC_IP_ADDRESS_H */