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

File indexing completed on 2025-01-18 10:15:38

 #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>
 
 //------------------------------------------------------------------------------
 //! The XrdNetIF class handles host interfaces. It is used to obtain the
 //! available interface addresses, encode them to be easily transmitted, and
 //! decode them to set the interface variations that can be used.
 //------------------------------------------------------------------------------
 
 class XrdNetAddrInfo;
 class XrdOucTList;
 class XrdSysError;
 
 struct sockaddr;
 
 class XrdNetIF
 {
 public:
 
 //------------------------------------------------------------------------------
 //! Display the final interface configuration.
 //!
 //! @param  pfx   The desired message prefix (default is as shown).
 //------------------------------------------------------------------------------
 
        void Display(const char *pfx="=====> ");
 
 //------------------------------------------------------------------------------
 //! The enum that is used to index into ifData to get appropriate interface.
 //------------------------------------------------------------------------------
 
        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
 
 //------------------------------------------------------------------------------
 //! Get the interface address with a port number.
 //!
 //! @param  dest  Pointer to the buffer where dest will be placed.
 //! @param  dlen  The length of the buffer.
 //! @param  ifT   Desired ifType (PublicV6 is the default)
 //! @param  prefn When true, a hostname:port is returned if possible
 //!
 //! @return The length of the name whose pointer is placed in name.
 //!         A value of zero indicates that no such interface exists or
 //!         the buffer was too small.
 //------------------------------------------------------------------------------
 
        int  GetDest(char *dest, int dlen, ifType ifT=PublicV6, bool prefn=false);
 
 //------------------------------------------------------------------------------
 //! Get the interface name without a port number.
 //!
 //! @param  name  Reference to where a pointer to the name will be placed
 //! @param  ifT   Desired ifType (PublicV6 is the default)
 //!
 //! @return The length of the name whose pointer is placed in name.
 //!         A value of zero indicates that no such interface exists.
 //------------------------------------------------------------------------------
 
 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;
                    }
 
 //------------------------------------------------------------------------------
 //! Copy the interface name and return port number.
 //!
 //! @param  nbuff Reference to buffer where the name will be placed. It must
 //!               be atleast 256 bytes in length.
 //! @param  nport Place where the port number will be placed.
 //! @param  ifT   Desired ifType (PublicV6 is the default)
 //!
 //! @return The length of the name copied into the buffer.
 //!         A value of zero indicates that no such interface exists.
 //------------------------------------------------------------------------------
 
 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;
                    }
 
 //------------------------------------------------------------------------------
 //! Obtain an easily digestable list of IP routable interfaces to this machine.
 //!
 //! @param  ifList   Place where the list of interfaces will be placed. If
 //!                  ifList is null, returns configured interface types.
 //! @param  eText    When not nil, is where to place error message text.
 //!
 //! @return Success: ifList != 0: returns the count of interfaces in the list.
 //!                  *ifList->sval[0] strlen(ifList->text)
 //!                  *ifList->sval[1] when != 0 the address is private.
 //!                  *ifList->text    the interface address is standard format.
 //!                  The list of objects belongs to the caller and must be
 //!                  deleted when no longer needed.
 //!
 //!                  ifList == 0: returns types of configured non-local i/f.
 //!                  This is or'd values of the static const ints haveXXXX.
 //!
 //!         Failure: Zero is returned. If eText is supplied, the error message,
 //!                  in persistent storage, is returned.
 //------------------------------------------------------------------------------
 
 static
 const  int  haveNoGI = 0;  //!< ifList == 0 && getifaddrs() is not supported
 static
 const  int  haveIPv4 = 1;  //!< ifList == 0 && non-local ipv4 i/f found (or'd)
 static
 const  int  haveIPv6 = 2;  //!< ifList == 0 && non-local ipv6 i/f found (or'd)
 static
 const  int  havePrv4 = 4;  //!< ifList == 0 && private   ipv4 i/f found (or'd)
 static
 const  int  havePrv6 = 8;  //!< ifList == 0 && private   ipv6 i/f found (or'd)
 static
 const  int  havePub4 =16;  //!< ifList == 0 && public    ipv4 i/f found (or'd)
 static
 const  int  havePub6 =32;  //!< ifList == 0 && public    ipv6 i/f found (or'd)
 
 static int  GetIF(XrdOucTList **ifList, const char **eText=0);
 
 //------------------------------------------------------------------------------
 //! Obtain an easily transmittable IP routable interfaces to this machine.
 //!
 //! @param  buff     Pointer to buffer to hold result which can be fed to SetIF.
 //! @param  blen     The length of the buffer (4K is really sufficient).
 //! @param  eText    When not nil, is where to place error message text.
 //! @param  show     When true configured interfaces are also displayed.
 //!
 //! @return Success: Number of bytes placed in buff, excluding the null.
 //!         Failure: Zero is returned. If eText is supplied, the error message,
 //!                  in persistent storage, is returned.
 //------------------------------------------------------------------------------
 
 static int  GetIF(char *buff, int blen, const char **eText=0, bool show=false);
 
 //------------------------------------------------------------------------------
 //! Obtain an easily transmittable IP routable interfaces to this machine.
 //!
 //! @param  ifline   Reference to a char * pointer that will get the result.
 //! @param  eText    When not nil, is where to place error message text.
 //! @param  show     When true configured interfaces are also displayed.
 //!
 //! @return Success: Number of bytes in the returned string ecluding the null.
 //!                  The caller is responsible for unallocating it via free().
 //!         Failure: Zero is returned. If eText is supplied, the error message,
 //!                  in persistent storage, is returned. *ifline is set to 0.
 //------------------------------------------------------------------------------
 
 static int  GetIF(char *&ifline, const char **eText=0, bool show=false);
 
 //------------------------------------------------------------------------------
 //! Get the ifType for client connection.
 //!
 //! @param  conIPv4  True if connected via IPv4, false means IPv6.
 //! @param  hasIP64  True if the client has an IPv4 and IPv6 address.
 //! @param  pvtIP    True if the ip address is private.
 //!
 //! @return The ifType correspodning to the passed arguments.
 //------------------------------------------------------------------------------
 
 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;
                        }
 
 //------------------------------------------------------------------------------
 //! Determine whether or not an interface exists.
 //!
 //! @param  ifT   -> Desired ifType (PublicV6 is the default)
 //!
 //! @return true  -> desired dest exists.
 //!         false -> desired dest does not exist.
 //------------------------------------------------------------------------------
 
 inline bool HasDest(ifType ifT=PublicV6)
                    {return ifT >= ifAny || ifDest[ifT]->iLen != 0;}
 
 //------------------------------------------------------------------------------
 //! Determine if an endpoint is this domain based on hostname.
 //!
 //! @param  epaddr   Pointer to the endpoint NetAddrInfo object.
 //!
 //! @result true     The endpoint is in this domain.
 //! @result false    Either the endpoint is not in this domain, is a private
 //!                  address, or is not registered in DNS.
 //------------------------------------------------------------------------------
 
 static bool InDomain(XrdNetAddrInfo *epaddr);
 
 //------------------------------------------------------------------------------
 //! Get the ifType selection mask for this object.
 //!
 //! @return A single char that represents the selection mask.
 //------------------------------------------------------------------------------
 
        char Mask() {return ifMask;}
 
 //------------------------------------------------------------------------------
 //! Convert an ifType to its corresponding selection mask.
 //!
 //! @param  ifT   The ifType to convert.
 //!
 //! @return A single char that represents the selection mask.
 //------------------------------------------------------------------------------
 
 static char Mask(ifType ifT)
                 {if (ifT >= ifAny) return 0x0f;
                  return ifMaskVec[ifT];
                 }
 
 //------------------------------------------------------------------------------
 //! Get the human readable for for an ifType.
 //!
 //! @param  ifT   The ifType to convert.
 //!
 //! @return A pointer to the human readable name. The string resides in static
 //!         storage and is always valid.
 //------------------------------------------------------------------------------
 static
 const char *Name(ifType ifT) {if (ifT >= ifAny) return "any";
                               return ifTName[ifT];
                              }
 
 //------------------------------------------------------------------------------
 //! Get the assigned port number
 //!
 //! @return The port number.
 //------------------------------------------------------------------------------
 
 inline int  Port() {return ifPort;}
 
 //------------------------------------------------------------------------------
 //! Make an iofType refer to the private network.
 //!
 //! @param x     The iftype variable that will have the private bit set.
 //------------------------------------------------------------------------------
 
 static void Privatize(ifType &x) {x = ifType(x | PrivateIF);}
 
 //------------------------------------------------------------------------------
 //! Set the assigned port number. This method is not thread safe!
 //!
 //! @param  pnum     The port number.
 //!
 //! @return The previous port number.
 //------------------------------------------------------------------------------
 
        int  Port(int pnum);
 
 //------------------------------------------------------------------------------
 //! Set the default assigned port number.
 //!
 //! @param  pnum     The port number.
 //------------------------------------------------------------------------------
 
 static void PortDefault(int pnum=1094);
 
 //------------------------------------------------------------------------------
 //! Routing() and SetIF() parameter.
 //!
 //! netDefault - netSplit for Routing() and Routing() value for SetIF().
 //! netSplit   - public and private addresses are routed separately so that
 //!              substitution of one type of address for another is not allowed.
 //! netCommon  - clients with private addresses also have public addresses.
 //!              Source and target addresses should match but a public address
 //!              may be used in the absence of a private address.
 //! netLocal   - private addresses are registered and can be used by public
 //!              clients within this domain. Clients with public addresses can
 //!              be routed to private addresses.
 //------------------------------------------------------------------------------
 
        enum netType {netDefault = 0, netSplit, netCommon, netLocal};
 
 //------------------------------------------------------------------------------
 //! Set default interface network routing.
 //!
 //! @param  nettype  Network routing (see netType definition).
 //------------------------------------------------------------------------------
 
 static void Routing(netType nettype);
 
 //------------------------------------------------------------------------------
 //! Set the ifData structure based on the interface string generated by GetIF().
 //!
 //! @param  src      The network information of host supplying the if string.
 //! @param  ifList   The interface string, it must be null terminated.
 //! @param  port     The port associated with the interfaces; as follows:
 //!                  <0 -> Use previous setting if any.
 //!                  =0 -> use default port (the default).
 //!                  >0 -> Use the number passed.
 //! @param  nettype  Determines how undefined interfaces are resolved. See
 //!                  the netType definition.
 //! @param  xName    the known registered host name should ip address
 //!                  translation fail.
 //!
 //! @return Success: True.
 //!         Failure: False and if eText is supplied, the error message,
 //!                  in persistent storage, is returned.
 //------------------------------------------------------------------------------
 
        bool SetIF(XrdNetAddrInfo *src, const char *ifList, int port=0,
                   netType nettype=netDefault, const char *xName=0);
 
 //------------------------------------------------------------------------------
 //! Set the public and private network interface names.
 //!
 //! @param  ifnames  Pointer to the comma seperated interface names. This
 //!                  string is modified.
 //!
 //! @return true     Names have been set.
 //! @return false    Invalid interface name list.
 //------------------------------------------------------------------------------
 
 static bool SetIFNames(char *ifnames);
 
 //------------------------------------------------------------------------------
 //! Specify where messages are to be sent.
 //!
 //! @param  erp      Pointer to the error message object. By default, no error
 //!                  messages are printed. This is not a thread-safe call and
 //!                  the err disposition must be set at initialization time.
 //------------------------------------------------------------------------------
 
 static void SetMsgs(XrdSysError *erp);
 
 //------------------------------------------------------------------------------
 //! Specify wheter or not private IP addresses should be resolved.
 //!
 //! @param  rval     When true, private IP addresses are resolved. Otherwise,
 //!                  the IP addresses is used as the hostname.
 //------------------------------------------------------------------------------
 
 static void SetRPIPA(bool rval);
 
 //------------------------------------------------------------------------------
 //! Constructor and Destructor
 //------------------------------------------------------------------------------
 
        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;
 
 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

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