XrdNetIF.hh

Go to the documentation of this file.

#ifndef __XRDNETIF_HH__
#define __XRDNETIF_HH__
/******************************************************************************/
/*                                                                            */
/*                           X r d N e t I F . 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 <cstdlib>
#include <cstring>
#include <string>
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
class XrdNetAddrInfo;
class XrdOucTList;
class XrdSysError;
 
struct sockaddr;
 
class XrdNetIF
{
public:
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       void Display(const char *pfx="=====> ");
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       enum ifType {PublicV4  = 0,  //<! Public  IPv4 network
                    PrivateV4 = 1,  //<! Private IPv4 network
                    PublicV6  = 2,  //<! Public  IPv6 network
                    PrivateV6 = 3,  //<! Private IPv6 network
                    PrivateIF = 1,  //<! Bit to change PublicVx -> PrivateVx
                    ifNum     = 4,  //<! Count of actual interface types
                    Public46  = 4,  //<! Public  v4|6 network (dual stack)
                    Private46 = 5,  //<! Private v4|6 network (dual stack)
                    Public64  = 6,  //<! Public  v6|4 network (dual stack)
                    Private64 = 7,  //<! Private v6|4 network (dual stack)
                    ifMax     = 8,  //<! Total elements in if vector
                    ifAny     = 8}; //<! Used to select any avilable i/f
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       int  GetDest(char *dest, int dlen, ifType ifT=PublicV6, bool prefn=false);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       int  GetPublicDest(char *dest, size_t dlen);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  GetName(const char *&name, ifType ifT=PublicV6)
                   {if (ifT >= ifAny) ifT = static_cast<ifType>(ifAvail);
                    name = ifName[ifT]->iVal;
                    return ifName[ifT]->iLen;
                   }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  GetName(char *nbuff, int &nport, ifType ifT=PublicV6)
                   {if (ifT >= ifAny) ifT = static_cast<ifType>(ifAvail);
                    strcpy(nbuff, ifName[ifT]->iVal); nport = ifPort;
                    return ifName[ifT]->iLen;
                   }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int GetPublicName(char *nbuff, int &nport)
{
    strcpy(nbuff, m_PublicName.c_str());
    nport = ifPort;
    return m_PublicName.size();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool SetPublicName(const std::string &name)
{
    // TODO: Actually validate this is an acceptable DNS name.
    if (name.size() > 255) return false;
    m_PublicName = name;
    return true;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static
const  int  haveNoGI = 0;  
static
const  int  haveIPv4 = 1;  
static
const  int  haveIPv6 = 2;  
static
const  int  havePrv4 = 4;  
static
const  int  havePrv6 = 8;  
static
const  int  havePub4 =16;  
static
const  int  havePub6 =32;  
 
static int  GetIF(XrdOucTList **ifList, const char **eText=0);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static int  GetIF(char *buff, int blen, const char **eText=0, bool show=false);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static int  GetIF(char *&ifline, const char **eText=0, bool show=false);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static ifType GetIFType(bool conIPv4, bool hasIP64, bool pvtIP)
                       {ifType ifT;
                        if (conIPv4) ifT = (hasIP64 ? Public46 : PublicV4);
                           else      ifT = (hasIP64 ? Public64 : PublicV6);
                        if (pvtIP) Privatize(ifT);
                        return ifT;
                       }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline bool HasDest(ifType ifT=PublicV6)
                   {return ifT >= ifAny || ifDest[ifT]->iLen != 0;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static bool InDomain(XrdNetAddrInfo *epaddr);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       char Mask() {return ifMask;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static char Mask(ifType ifT)
                {if (ifT >= ifAny) return 0x0f;
                 return ifMaskVec[ifT];
                }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
static
const char *Name(ifType ifT) {if (ifT >= ifAny) return "any";
                              return ifTName[ifT];
                             }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
inline int  Port() {return ifPort;}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static void Privatize(ifType &x) {x = ifType(x | PrivateIF);}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       int  Port(int pnum);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static void PortDefault(int pnum=1094);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       enum netType {netDefault = 0, netSplit, netCommon, netLocal};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static void Routing(netType nettype);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       bool SetIF(XrdNetAddrInfo *src, const char *ifList, int port=0,
                  netType nettype=netDefault, const char *xName=0);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static bool SetIFNames(char *ifnames);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static void SetMsgs(XrdSysError *erp);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
static void SetRPIPA(bool rval);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
       XrdNetIF() : ifBuff(0), ifMask(0), ifAvail(0)  {}
 
      ~XrdNetIF() {if (ifBuff) free(ifBuff);}
 
private:
 
struct ifAddrs
      {short hALen;
       short hDLen;
       bool  ipV6;
       bool  prvt;
       char  hAddr[64];    // address
       char  hDest[64];    // address possibly in deprecated format
      };
 
bool  GenAddrs(ifAddrs &ifTab, XrdNetAddrInfo *src);
bool  GenAddrs(ifAddrs &ifTab, const char *hName, bool wantV6);
bool  GenIF(XrdNetAddrInfo **src, int srcnum, const char *xName=0);
static const
char *GetDomain();
static
bool  IsOkName(const char *ifn, short &ifIdx);
void  SetIFPP();
bool  SetIF64(bool retVal);
static
bool  V4LinkLocal(struct sockaddr *saP);
 
struct ifData
{
       short  iLen;
       char   iVal[6]; // Actually of size iLen
 
       ifData() : iLen(0) {*iVal = 0;}
      ~ifData() {}
};
 
ifData        *ifName[ifMax];
ifData        *ifDest[ifMax];
bool           ifxDNS[ifMax];
char          *ifBuff;
 
struct pInfo {char   len;
              char   val[7]; // Contains ":12345\0"
                     pInfo() : len(0) {*val = 0;}
             } portSfx;
 
int            ifPort;
short          ifRoute;
char           ifMask;
char           ifAvail;
 
// The public hostname of the interface.
std::string    m_PublicName;
 
static
XrdSysError   *eDest;
static
const char    *myDomain;
static char   *ifCfg[2];
static
const char    *ifTName[ifMax];
static
const char    *ifMaskVec;
static
netType        netRoutes;
static int     dfPort;
static ifData  ifNull;
static bool    rPIPA;
};
#endif