EIC code displayed by LXR master/​include/​xrootd/​XrdNet/​XrdNetAddrInfo.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-30 10:27:54

 #ifndef __XRDNETADDRINFO_HH__
 #define __XRDNETADDRINFO_HH__
 /******************************************************************************/
 /*                                                                            */
 /*                     X r d N e t A d d r I n f o . h h                      */
 /*                                                                            */
 /* (c) 2013 by the Board of Trustees of the Leland Stanford, Jr., University  */
 /*                            All Rights Reserved                             */
 /*   Produced by Andrew Hanushevsky for Stanford University under contract    */
 /*              DE-AC02-76-SFO0515 with the Department of Energy              */
 /*                                                                            */
 /* This file is part of the XRootD software suite.                            */
 /*                                                                            */
 /* XRootD is free software: you can redistribute it and/or modify it under    */
 /* the terms of the GNU Lesser General Public License as published by the     */
 /* Free Software Foundation, either version 3 of the License, or (at your     */
 /* option) any later version.                                                 */
 /*                                                                            */
 /* XRootD is distributed in the hope that it will be useful, but WITHOUT      */
 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      */
 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public       */
 /* License for more details.                                                  */
 /*                                                                            */
 /* You should have received a copy of the GNU Lesser General Public License   */
 /* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
 /* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
 /*                                                                            */
 /* The copyright holder's institutional names and contributor's names may not */
 /* be used to endorse or promote products derived from this software without  */
 /* specific prior written permission of the institution or contributor.       */
 /******************************************************************************/
   
 #include <cinttypes>
 #include <cstdlib>
 #include <cstring>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
 #include "XrdNet/XrdNetSockAddr.hh"
 #include "XrdSys/XrdSysPlatform.hh"
   
 //------------------------------------------------------------------------------
 //! The XrdNetAddrInfo class is meant to provide read/only access to members
 //! that only class XrdNetAddr can manipulate. This allows the generic use of
 //! the XrdNetAddr class but provides a means of exporting that information to
 //! other objects without allowing those objects to modify the information.
 //------------------------------------------------------------------------------
 
 struct addrinfo;
 class  XrdNetCache;
 
 class XrdNetAddrInfo
 {
 public:
 
 //------------------------------------------------------------------------------
 //! Provide the protocol languag being spoken (e.g. xroot, http, etc).
 //!
 //! @return Pointer to the protocol language being used. If unknown, nil ia
 //!         returned. Use the isUsingTLS() method to see if a secure version of
 //!         the protocol is being used.
 //------------------------------------------------------------------------------
 
 const char *Dialect() {return protName;}
 
 //------------------------------------------------------------------------------
 //! Provide our address family.
 //!
 //! @return Success: Returns AF_INET, AF_INET6, or AF_UNIX.
 //!         Failure: Returns 0, address is not valid.
 //------------------------------------------------------------------------------
 
 int         Family() const {return static_cast<int>(IP.Addr.sa_family);}
 
 //------------------------------------------------------------------------------
 //! Format our address into a supplied buffer with one of the following layouts
 //! (the ':<port>' or ':/path' can be omitted if desired, see fmtOpts param):
 //! IP.xx:   host_name:<port>
 //! IP.v4:   a.b.c.d:<port>
 //! IP.4to6: [::ffff:a.b.c.d]:<port>  | [::a.b.c.d]:<port>
 //! IP.v6:   [a:b:c:d:e:f:g:h]:<port>
 //! IP.Unix: localhost:/<path>
 //!
 //! @param  bAddr    address of buffer for result
 //! @param  bLen     length  of buffer
 //! @param  fmtType  specifies the type of format desired via fmtUse enum.
 //! @param  fmtOpts  additional formatting options (can be or'd):
 //!                  noPort    - do not append the port number to the address.
 //!                  noPortRaw - no port and no brackets for IPv6.
 //!                  old6Map4  - use deprecated IPV6 mapped format '[::x.x.x.x]'
 //!
 //! @return Success: The number of characters (less null) in Buff.
 //! @return Failure: 0 (buffer is too small or not a valid address). However,
 //!                  if bLen > 0 the buffer will contain a null terminated
 //!                  string of up to 8 question marks.
 //------------------------------------------------------------------------------
 
 enum fmtUse {fmtAuto=0, //!< Hostname if already resolved o/w use fmtAddr
              fmtName,   //!< Hostname if it is resolvable o/w use fmtAddr
              fmtAddr,   //!< Address using suitable ipv4 or ipv6 format
              fmtAdv6};  //!< Address only in ipv6 format
 
 static const int noPort    = 0x0000001; //!< Do not add port number
 static const int noPortRaw = 0x0000002; //!< Use raw address format (no port)
 static const int old6Map4  = 0x0000004; //!< Use deprecated IPV6 mapped format
 static const int prefipv4  = 0x0000008; //!< Use if mapped  IPV4 actual format
 
 int         Format(char *bAddr, int bLen, fmtUse fmtType=fmtAuto, int fmtOpts=0);
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not our address is the loopback address. Use this
 //! method to gaurd against UDP packet spoofing.
 //!
 //! @return True:    This is     the loopback address.
 //! @return False:   This is not the loopback address.
 //------------------------------------------------------------------------------
 
 bool        isLoopback();
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not a string is a possible hostname and not IP address.
 //! The return value does not aimply any kind of validity. For instance, a
 //! false return indicates this is not a valid hostname does not mean it is
 //! a valid IP address.
 //!
 //! @param name      The string to check.
 //!
 //! @return True:    This is     a possible hostname (i.e. not IP address).
 //! @return False:   This is not a possible hostname.
 //------------------------------------------------------------------------------
 
 static bool isHostName(const char *name);
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not our address is if the desired type.
 //!
 //! @param ipType    The IP address version to test (see enum below).
 //!
 //! @return True:    This is     the address version of ipType.
 //! @return False:   This is not the address version of ipType.
 //------------------------------------------------------------------------------
 
 enum IPType {IPv4 = AF_INET, IPv6 = AF_INET6, IPuX = AF_UNIX};
 
 bool        isIPType(IPType ipType) const {return IP.Addr.sa_family == ipType;}
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not our address is an IPv4 mapped to IPv6 address.
 //!
 //! @return True:  The address is     a mapped IPv4 address.
 //!         False: The address is not a mapped IPv4 address.
 //------------------------------------------------------------------------------
 
 bool        isMapped() const {return IP.Addr.sa_family == AF_INET6
                                   && IN6_IS_ADDR_V4MAPPED(&IP.v6.sin6_addr);
                              }
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not our address is private.
 //!
 //! @return True:    This address is     private.
 //!         False:   This address is not private.
 //------------------------------------------------------------------------------
 
 bool        isPrivate();
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not our address is registered in the DNS.
 //!
 //! @return True:    This address is     registered.
 //!         False:   This address is not registered.
 //------------------------------------------------------------------------------
 
 bool        isRegistered();
 
 //------------------------------------------------------------------------------
 //! Indicate whether or not the endpoint is using TLS for communications.
 //!
 //! @return True:    This address is     using TLS.
 //!         False:   This address is not using TLS.
 //------------------------------------------------------------------------------
 
 bool        isUsingTLS();
 
 //------------------------------------------------------------------------------
 //! Obtain the location of this address.
 //!
 //! @return !0       pointer to the unverified location information. Not all
 //!                  fields may be set.
 //! @return =0       location information is not available.
 //------------------------------------------------------------------------------
 
 struct LocInfo
       {unsigned char  Country[2]; //!< Two letter TLD country code
        unsigned char  Region;     //!< Region (may combine adjacent countries)
        unsigned char  Locale;     //!< Locale (may combine adjacent regions)
                 char  TimeZone;   //!< +/- hours from GMT (-128 if not set)
                 char  Flags;      //!< Flags
                 short Speed;      //!< I/F speed (Gb*1024/100)(not supported)
                 int   Latitude;   //!< Degrees +/- xx.xxxxxx  (not supported)
                 int   Longtitude; //!< Degrees +/- xx.xxxxxx  (not supported)
 
                 LocInfo() : Region(0), Locale(0), TimeZone(-128), Flags(0),
                             Speed(0), Latitude(0), Longtitude(0) {*Country = 0;}
 
        };
 
 const struct
 LocInfo    *Location() {return (addrLoc.Country[0] ? &addrLoc : 0);}
 
 //------------------------------------------------------------------------------
 //! Convert our IP address to the corresponding [host] name.
 //!
 //! @param  eName    value to return when the name cannot be determined.
 //! @param  eText    when not null, the reason for a failure is returned.
 //!
 //! @return Success: Pointer to the name or ip address with eText, if supplied,
 //!                  set to zero. The memory is owned by the object and is
 //!                  deleted when the object is deleted or Set() is called.
 //!         Failure: eName param and if eText is not zero, returns a pointer
 //!                  to a message describing the reason for the failure. The
 //!                  message is in persistent storage and cannot be modified.
 //------------------------------------------------------------------------------
 
 const char *Name(const char *eName=0, const char **eText=0);
 
 //------------------------------------------------------------------------------
 //! Provide a pointer to our socket address suitable for use in calls to methods
 //! that require our internal format of sock addr. A value is only returned for
 //! IPV6/4 addresses and is nill otherwise. The pointer refers to memory
 //! allocated by this object and becomes invalid should the object be deleted.
 //! Use SockSize() to get its logical length.
 //------------------------------------------------------------------------------
 
 const
 XrdNetSockAddr  *NetAddr() {return (sockAddr == (void *)&IP ? &IP : 0);}
 
 //------------------------------------------------------------------------------
 //! Return the port number for our address.
 //!
 //! @return Success: The port number, which may be 0 if not set.
 //!         Failure: -1 address is not an internet address or port is invalid.
 //------------------------------------------------------------------------------
 
 int         Port();
 
 //------------------------------------------------------------------------------
 //! Provide our protocol family.
 //!
 //! @return Success: Returns PF_INET, PF_INET6, or PF_UNIX.
 //!         Failure: Returns 0, address is not valid.
 //------------------------------------------------------------------------------
 
 int         Protocol() {return static_cast<int>(protType);}
 
 //------------------------------------------------------------------------------
 //! Check if the IP address in this object is the same as the one passed.
 //!
 //! @param ipAddr    points to the network address object to compare.
 //! @param plusPort  when true, port values must also match. In any case, both
 //!                  addresses must be of the same address family.
 //!
 //! @return Success: True  (addresses are     the same).
 //!         Failure: False (addresses are not the same).
 //!
 //! Note: implemented in terms of const version
 //------------------------------------------------------------------------------
 
 int         Same(const XrdNetAddrInfo *ipAddr, bool plusPort=false);
 
 //------------------------------------------------------------------------------
 //! Provide a pointer to our socket address suitable for use in calls to
 //! functions that require one (e.g. bind() etc). The pointer refers to memory
 //! allocated by this object and becomes invalid should the object be deleted
 //! or when Set() is called. Use SockSize() to get its length.
 //------------------------------------------------------------------------------
 
 const
 sockaddr   *SockAddr() {return sockAddr;}
 
 //------------------------------------------------------------------------------
 //! Provide the length of our socket adress. Useful for system calls needing it.
 //!
 //! @return Success: Returns the length of the address returned by SockAddr().
 //!         Failure: Returns 0, address is not valid.
 //------------------------------------------------------------------------------
 
 SOCKLEN_t   SockSize() {return static_cast<SOCKLEN_t>(addrSize);}
 
 //------------------------------------------------------------------------------
 //! Get the associated file descriptor.
 //!
 //! @return The associated file descriptor. If negative, no association exists.
 //------------------------------------------------------------------------------
 
 int         SockFD() {return (sockNum ? sockNum : -1);}
 
 //------------------------------------------------------------------------------
 //! Assignment operator
 //------------------------------------------------------------------------------
 
 XrdNetAddrInfo &operator=(XrdNetAddrInfo const &rhs)
                {if (&rhs != this)
                    {memmove(&IP, &rhs.IP, sizeof(IP));
                     addrSize = rhs.addrSize; sockNum = rhs.sockNum;
                     protType = rhs.protType;
                     protFlgs = rhs.protFlgs;
                     protName = rhs.protName;
                     if (hostName) free(hostName);
                     hostName = (rhs.hostName ? strdup(rhs.hostName):0);
                     addrLoc = rhs.addrLoc;
                     if (rhs.sockAddr != &rhs.IP.Addr)
                        {if (!unixPipe || sockAddr == &IP.Addr)
                            unixPipe = new sockaddr_un;
                         memcpy(unixPipe, rhs.unixPipe, sizeof(sockaddr_un));
                        } else sockAddr = &IP.Addr;
                    }
                 return *this;
                }
 
 //------------------------------------------------------------------------------
 //! Copy constructor
 //------------------------------------------------------------------------------
 
                XrdNetAddrInfo(XrdNetAddrInfo const &oP)
                              {hostName = 0;
                               unixPipe = 0;
                               *this = oP;
                              }
 
 //------------------------------------------------------------------------------
 //! Constructor
 //------------------------------------------------------------------------------
 
             XrdNetAddrInfo() : hostName(0), addrSize(0), protType(0),
                                protFlgs(0), sockNum(0), protName(0)
                            {IP.Addr.sa_family = 0;
                             sockAddr = &IP.Addr;
                            }
 
             XrdNetAddrInfo(const XrdNetAddrInfo *addr) : hostName(0) {*this = *addr;}
 
 //------------------------------------------------------------------------------
 //! Destructor
 //------------------------------------------------------------------------------
 
            ~XrdNetAddrInfo() {if (hostName) free(hostName);
                           if (sockAddr != &IP.Addr) delete unixPipe;
                          }
 
 protected:
        char               *LowCase(char *str);
        int                 QFill(char *bAddr, int bLen);
        int                 Resolve();
 
 static XrdNetCache        *dnsCache;
 
 XrdNetSockAddr             IP;
 union {struct sockaddr    *sockAddr;
        struct sockaddr_un *unixPipe;
       };
 char                      *hostName;
 LocInfo                    addrLoc;
 unsigned short             addrSize;
 unsigned char              protType;
 unsigned char              protFlgs;
 int                        sockNum;
 const char                *protName;
 
 // Flag settings in protFlgs
 //
 static const char          isTLS = 0x01; //!< Location using TLS
 };
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team