XrdNetAddrInfo.hh

Go to the documentation of this file.

#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 <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/un.h>
 
#include "XrdNet/XrdNetSockAddr.hh"
#include "XrdSys/XrdSysPlatform.hh"
  
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
struct addrinfo;
class  XrdNetCache;
 
class XrdNetAddrInfo
{
public:
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  Family() const {return static_cast<int>(IP.Addr.sa_family);}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
enum fmtUse {fmtAuto=0, 
             fmtName,   
             fmtAddr,   
             fmtAdv6};  
 
static const int noPort    = 0x0000001; 
static const int noPortRaw = 0x0000002; 
static const int old6Map4  = 0x0000004; 
static const int prefipv4  = 0x0000008; 
 
int         Format(char *bAddr, int bLen, fmtUse fmtType=fmtAuto, int fmtOpts=0);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
bool        isLoopback();
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static bool isHostName(const char *name);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
enum IPType {IPv4 = AF_INET, IPv6 = AF_INET6, IPuX = AF_UNIX};
 
inline bool isIPType(IPType ipType) const {return IP.Addr.sa_family == ipType;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline bool isMapped() const {return IP.Addr.sa_family == AF_INET6
                                  && IN6_IS_ADDR_V4MAPPED(&IP.v6.sin6_addr);
                             }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
bool        isPrivate();
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
bool        isRegistered();
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
struct LocInfo
      {unsigned char  Country[2]; 
       unsigned char  Region;     
       unsigned char  Locale;     
                char  TimeZone;   
                char  Reserved;
                short Speed;      
                int   Latitude;   
                int   Longtitude; 
 
                LocInfo() : Region(0), Locale(0), TimeZone(-128), Reserved(0),
                            Speed(0), Latitude(0), Longtitude(0) {*Country = 0;}
       };
 
const struct
LocInfo    *Location() {return (addrLoc.Country[0] ? &addrLoc : 0);}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
const char *Name(const char *eName=0, const char **eText=0);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline const
XrdNetSockAddr  *NetAddr() {return (sockAddr == (void *)&IP ? &IP : 0);}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
int         Port();
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  Protocol() {return static_cast<int>(protType);}
 
//------------------------------------------------------------------------------
//-----------------------------------------------------------------------------sav-
 
int         Same(const XrdNetAddrInfo *ipAddr, bool plusPort=false);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline const
sockaddr   *SockAddr() {return sockAddr;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline
SOCKLEN_t   SockSize() {return addrSize;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  SockFD() {return (sockNum ? static_cast<int>(sockNum) : -1);}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
XrdNetAddrInfo &operator=(XrdNetAddrInfo const &rhs)
               {if (&rhs != this)
                   {memmove(&IP, &rhs.IP, sizeof(IP));
                    addrSize = rhs.addrSize; sockNum = rhs.sockNum;
                    protType = rhs.protType;
                    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;
               }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
               XrdNetAddrInfo(XrdNetAddrInfo const &oP)
                             {hostName = 0;
                              unixPipe = 0;
                              *this = oP;
                             }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
            XrdNetAddrInfo() : hostName(0), addrSize(0), protType(0), sockNum(0)
                           {IP.Addr.sa_family = 0;
                            sockAddr = &IP.Addr;
                           }
 
            XrdNetAddrInfo(const XrdNetAddrInfo *addr) : hostName(0) {*this = *addr;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
           ~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;
SOCKLEN_t                  addrSize;
short                      protType;
unsigned short             sockNum;
};
#endif