(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.2 and 1.6.8.1

version 1.2, 2007/06/26 20:26:13 version 1.6.8.1, 2013/06/03 22:35:12
Line 1 
Line 1 
 //%2007////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  
 // EMC Corporation; Symantec Corporation; The Open Group.  
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // Permission is hereby granted, free of charge, to any person obtaining a
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <Pegasus/Common/HostAddress.h> #include <Pegasus/Common/HostAddress.h>
   #include <Pegasus/Common/Tracer.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 109 
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 312 
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 338 
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 352 
Line 344 
 { {
 } }
  
 void HostAddress::setHostAddress(const String &addrStr)  Boolean HostAddress::setHostAddress(const String &addrStr)
   {
   
       if (addrStr.size() != 0)
 { {
     _init();  
           if (isValidIPV4Address(addrStr))
           {
               _isValid = true;
               _addrType = AT_IPV4;
               _hostAddrStr = addrStr;
               _scopeID = 0;
               _isAddrLinkLocal = false;
               return _isValid;
           }
   
           if (isValidHostName(addrStr))
           {
               _isValid = true;
               _addrType = AT_HOSTNAME;
     _hostAddrStr = addrStr;     _hostAddrStr = addrStr;
     _parseAddress();              _scopeID = 0;
               _isAddrLinkLocal = false;
               return _isValid;
 } }
  
 Uint32 HostAddress::getAddressType()          if (_checkIPv6AndLinkLocal( addrStr ))
           {
               _isValid = true;
               _addrType = AT_IPV6;
               return _isValid;
           }
   
       } // 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 387 
Line 415 
     return false;     return false;
 } }
  
 void HostAddress::_parseAddress()  Boolean HostAddress::_checkIPv6AndLinkLocal( const String &ip6add2check)
 { {
     if (_hostAddrStr == String::EMPTY)      _isValid = false;
     {      _isAddrLinkLocal = false;
         return;      _scopeID = 0;
   
       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;
     }     }
     if ((_isValid = isValidIPV6Address(_hostAddrStr)))          else
     {     {
         _addrType = AT_IPV6;              PEG_TRACE((TRC_HTTP,Tracer::LEVEL1,
                   "The IPv6 link-local address %s has no zone index specified.",
                   (const char*)ip6add2check.getCString()));
               return false;
     }     }
     else if( (_isValid = isValidIPV4Address(_hostAddrStr)))      }
   
       if (isValidIPV6Address(iptmp))
     {     {
         _addrType = AT_IPV4;          _hostAddrStr = iptmp;
           _isValid = true;
           return true;
       }
       PEG_TRACE((TRC_HTTP,Tracer::LEVEL1,
           "Invalid IPv6 address %s specified.",
           (const char*)ip6add2check.getCString()));
       return false;
     }     }
     else if((_isValid = isValidHostName(_hostAddrStr)))  
   Uint32 HostAddress::getScopeID() const
     {     {
         _addrType = AT_HOSTNAME;      return _scopeID;
     }     }
   
   Boolean HostAddress::isHostAddLinkLocal() const
   {
       return _isAddrLinkLocal;
 } }
  
 Boolean HostAddress::isValidIPV6Address (const String &ipv6Address) Boolean HostAddress::isValidIPV6Address (const String &ipv6Address)
 { {
     int i = 0;      const Uint16* p = (const Uint16*)ipv6Address.getChar16Data();
     while (ipv6Address[i])      int numColons = 0;
     {  
         if (!isascii(ipv6Address[i++]))      while (*p)
         {         {
           if (*p > 127)
             return false;             return false;
   
           if (*p == ':')
               numColons++;
   
           p++;
         }         }
     }  
       // No need to check whether IPV6 if no colons found.
   
       if (numColons == 0)
           return false;
  
     CString addr = ipv6Address.getCString();     CString addr = ipv6Address.getCString();
 #ifdef PEGASUS_ENABLE_IPV6 #ifdef PEGASUS_ENABLE_IPV6
Line 424 
Line 510 
 #else #else
     char iaddr[PEGASUS_IN6_ADDR_SIZE];     char iaddr[PEGASUS_IN6_ADDR_SIZE];
 #endif #endif
     return  1 == convertTextToBinary(AT_IPV6, (const char*) addr,      return  convertTextToBinary(AT_IPV6, (const char*)addr, (void*)&iaddr) == 1;
                      (void*)&iaddr);  
 } }
  
 Boolean HostAddress::isValidIPV4Address (const String &ipv4Address) Boolean HostAddress::isValidIPV4Address (const String &ipv4Address)
 { {
     int i = 0;      const Uint16* src = (const Uint16*)ipv4Address.getChar16Data();
     while (ipv4Address[i])      Uint16 octetValue[4] = {0};
   
       for (Uint32 octet = 1, i = 0; octet <= 4; octet++)
     {     {
         if (!isascii(ipv4Address[i++]))          int j = 0;
   
           if (!(isascii(src[i]) && isdigit(src[i])))
               return false;
   
           while (isascii(src[i]) && isdigit(src[i]))
         {         {
               if (j == 3)
             return false;             return false;
         }  
               octetValue[octet-1] = octetValue[octet-1] * 10 + (src[i] - '0');
               i++;
               j++;
     }     }
  
     CString addr = ipv4Address.getCString();          if (octetValue[octet-1] > 255)
     struct in_addr iaddr;              return false;
   
           if ((octet != 4) && (src[i++] != '.'))
               return false;
  
     return  1 == convertTextToBinary(AT_IPV4, (const char*) addr,          if ((octet == 4) && (src[i] != ':') && src[i] != char(0))
                      (void*)&iaddr);              return false;
       }
       return true;
 } }
  
 Boolean HostAddress::isValidHostName (const String &hostName)  Boolean HostAddress::isValidHostName (const String &hostName_)
 { {
       const Uint16* hostName = (const Uint16*)hostName_.getChar16Data();
   
     Uint32 i = 0;     Uint32 i = 0;
     Boolean expectHostSegment = true;     Boolean expectHostSegment = true;
     Boolean hostSegmentIsNumeric;     Boolean hostSegmentIsNumeric;

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