(file) Return to HostAddress.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/HostAddress.cpp between version 1.6 and 1.7

version 1.6, 2008/12/16 18:56:00 version 1.7, 2012/07/03 11:53:22
Line 30 
Line 30 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/HostAddress.h> #include <Pegasus/Common/HostAddress.h>
   #include <Pegasus/Common/Tracer.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 107 
Line 108 
 } }
  
 /* /*
      Converts given ipv6 text address (ex. ::1) to binary form and stroes       Converts given ipv6 text address (ex. ::1) to binary form and stores
      in "dst" buffer (ex. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1). Returns 1      in "dst" buffer (ex. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1). Returns 1
      if src ipv6 address is valid or returns -1 if invalid. Returns value      if src ipv6 address is valid or returns -1 if invalid. Returns value
      in network byte order.      in network byte order.
Line 310 
Line 311 
 } }
 #endif  // defined (PEGASUS_OS_TYPE_WINDOWS) || !defined (PEGASUS_ENABLE_IPV6) #endif  // defined (PEGASUS_OS_TYPE_WINDOWS) || !defined (PEGASUS_ENABLE_IPV6)
  
 void HostAddress::_init()  HostAddress::HostAddress():
 {      _hostAddrStr(),
     _hostAddrStr = String::EMPTY;      _addrType(AT_INVALID),
     _isValid = false;      _isValid(false),
     _addrType = AT_INVALID;      _isAddrLinkLocal(false),
 }      _scopeID(0)
   
 HostAddress::HostAddress()  
 {  
     _init();  
 }  
  
 HostAddress::HostAddress(const String &addrStr)  
 { {
     _init();  
     _hostAddrStr = addrStr;  
     _parseAddress();  
 } }
  
 HostAddress& HostAddress::operator =(const HostAddress &rhs) HostAddress& HostAddress::operator =(const HostAddress &rhs)
Line 336 
Line 328 
         _hostAddrStr = rhs._hostAddrStr;         _hostAddrStr = rhs._hostAddrStr;
         _isValid = rhs._isValid;         _isValid = rhs._isValid;
         _addrType = rhs._addrType;         _addrType = rhs._addrType;
           _scopeID = rhs._scopeID;
           _isAddrLinkLocal = rhs._isAddrLinkLocal;
     }     }
  
     return *this;     return *this;
Line 350 
Line 344 
 { {
 } }
  
 void HostAddress::setHostAddress(const String &addrStr)  Boolean HostAddress::setHostAddress(const String &addrStr)
   {
   
       if (addrStr.size() != 0)
       {
   
           if (isValidIPV4Address(addrStr))
           {
               _isValid = true;
               _addrType = AT_IPV4;
               _hostAddrStr = addrStr;
               _scopeID = 0;
               _isAddrLinkLocal = false;
               return _isValid;
           }
   
           if (isValidHostName(addrStr))
 { {
     _init();              _isValid = true;
               _addrType = AT_HOSTNAME;
     _hostAddrStr = addrStr;     _hostAddrStr = addrStr;
     _parseAddress();              _scopeID = 0;
               _isAddrLinkLocal = false;
               return _isValid;
           }
   
           if (_checkIPv6AndLinkLocal( addrStr ))
           {
               _isValid = true;
               _addrType = AT_IPV6;
               return _isValid;
 } }
  
 Uint32 HostAddress::getAddressType()      } // if addrStr == 0 or no valid address specified.
   
       _hostAddrStr.clear();
       _isValid = false;
       _addrType = AT_INVALID;
       _scopeID = 0;
       _isAddrLinkLocal = false;
       return _isValid;
   }
   
   Uint32 HostAddress::getAddressType() const
 { {
     return _addrType;     return _addrType;
 } }
  
 Boolean HostAddress::isValid()  Boolean HostAddress::isValid() const
 { {
     return _isValid;     return _isValid;
 } }
  
 String HostAddress::getHost()  String HostAddress::getHost() const
 { {
     return _hostAddrStr;     return _hostAddrStr;
 } }
Line 385 
Line 415 
     return false;     return false;
 } }
  
 void HostAddress::_parseAddress()  Boolean HostAddress::_checkIPv6AndLinkLocal( const String &ip6add2check)
 { {
     if (_hostAddrStr.size() == 0)      _isValid = false;
         return;      _isAddrLinkLocal = false;
       _scopeID = 0;
  
     if (isValidIPV4Address(_hostAddrStr))      String iptmp = ip6add2check;
       String tmp = iptmp.subString(0, 4);
       // If the IP address starts with "fe80" it is a link-local address
       if(String::equalNoCase(tmp, "fe80"))
       {
           Uint32 idx = iptmp.find('%');
           if(idx != PEG_NOT_FOUND)
           {
   #if defined PEGASUS_OS_TYPE_WINDOWS
               // On Windows the zone ID/inteface index for link-local is an
               // integer value starting with 1.
               _scopeID = atoi(
                       (const char *)(iptmp.subString(idx+1).getCString()));
   #else
               // if_nametoindex() retruns 0 when zone ID was not valid/found.
               _scopeID = if_nametoindex(
                       (const char *)(iptmp.subString(idx+1).getCString()));
   #endif
               // The scope ID should not be 0, even RFC4007 specifies 0 as the
               // default interface. But
               if (0 == _scopeID)
               {
                   PEG_TRACE((TRC_HTTP,Tracer::LEVEL1,
                       "The zone index of IPv6 link-local address %s is invalid.",
                       (const char*)ip6add2check.getCString()));
                   return false;
               }
               // Remove the zone id before checkeing for a valid IPv6 address.
               iptmp.remove(idx);
               _isAddrLinkLocal = true;
           }
           else
     {     {
         _isValid = true;              PEG_TRACE((TRC_HTTP,Tracer::LEVEL1,
         _addrType = AT_IPV4;                  "The IPv6 link-local address %s has no zone index specified.",
                   (const char*)ip6add2check.getCString()));
               return false;
     }     }
     else if (isValidIPV6Address(_hostAddrStr))      }
   
       if (isValidIPV6Address(iptmp))
     {     {
           _hostAddrStr = iptmp;
         _isValid = true;         _isValid = true;
         _addrType = AT_IPV6;          return true;
       }
       PEG_TRACE((TRC_HTTP,Tracer::LEVEL1,
           "Invalid IPv6 address %s specified.",
           (const char*)ip6add2check.getCString()));
       return false;
     }     }
     else if (isValidHostName(_hostAddrStr))  
   Uint32 HostAddress::getScopeID() const
     {     {
         _isValid = true;      return _scopeID;
         _addrType = AT_HOSTNAME;  
     }     }
   
   Boolean HostAddress::isHostAddLinkLocal() const
   {
       return _isAddrLinkLocal;
 } }
  
 Boolean HostAddress::isValidIPV6Address (const String &ipv6Address) Boolean HostAddress::isValidIPV6Address (const String &ipv6Address)
Line 468 
Line 544 
         if ((octet == 4) && (src[i] != ':') && src[i] != char(0))         if ((octet == 4) && (src[i] != ':') && src[i] != char(0))
             return false;             return false;
     }     }
   
     return true;     return true;
 } }
  

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2