| /*============================================================================ |
| KWSys - Kitware System Library |
| Copyright 2000-2009 Kitware, Inc., Insight Software Consortium |
| |
| Distributed under the OSI-approved BSD License (the "License"); |
| see accompanying file Copyright.txt for details. |
| |
| This software is distributed WITHOUT ANY WARRANTY; without even the |
| implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the License for more information. |
| ============================================================================*/ |
| #include "kwsysPrivate.h" |
| #include KWSYS_HEADER(Registry.hxx) |
| |
| #include KWSYS_HEADER(Configure.hxx) |
| #include KWSYS_HEADER(ios/iostream) |
| #include KWSYS_HEADER(stl/string) |
| #include KWSYS_HEADER(stl/map) |
| #include KWSYS_HEADER(ios/iostream) |
| #include KWSYS_HEADER(ios/fstream) |
| #include KWSYS_HEADER(ios/sstream) |
| // Work-around CMake dependency scanning limitation. This must |
| // duplicate the above list of headers. |
| #if 0 |
| # include "Registry.hxx.in" |
| # include "Configure.hxx.in" |
| # include "kwsys_stl.hxx.in" |
| # include "kwsys_stl_string.hxx.in" |
| # include "kwsys_stl_map.hxx.in" |
| # include "kwsys_ios_iostream.h.in" |
| # include "kwsys_ios_fstream.h.in" |
| # include "kwsys_ios_sstream.h.in" |
| #endif |
| |
| #include <ctype.h> // for isspace |
| #include <stdio.h> |
| #include <string.h> /* strlen, strncpy */ |
| #include <stdlib.h> /* getenv */ |
| |
| #ifdef _WIN32 |
| # include <windows.h> |
| #endif |
| |
| |
| namespace KWSYS_NAMESPACE |
| { |
| class RegistryHelper { |
| public: |
| RegistryHelper(Registry::RegistryType registryType); |
| virtual ~RegistryHelper(); |
| |
| // Read a value from the registry. |
| virtual bool ReadValue(const char *key, const char **value); |
| |
| // Delete a key from the registry. |
| virtual bool DeleteKey(const char *key); |
| |
| // Delete a value from a given key. |
| virtual bool DeleteValue(const char *key); |
| |
| // Set value in a given key. |
| virtual bool SetValue(const char *key, const char *value); |
| |
| // Open the registry at toplevel/subkey. |
| virtual bool Open(const char *toplevel, const char *subkey, |
| int readonly); |
| |
| // Close the registry. |
| virtual bool Close(); |
| |
| // Set the value of changed |
| void SetChanged(bool b) { m_Changed = b; } |
| void SetTopLevel(const char* tl); |
| const char* GetTopLevel() { return m_TopLevel.c_str(); } |
| |
| //! Read from local or global scope. On Windows this mean from local machine |
| // or local user. On unix this will read from $HOME/.Projectrc or |
| // /etc/Project |
| void SetGlobalScope(bool b); |
| bool GetGlobalScope(); |
| |
| kwsys_stl::string EncodeKey(const char* str); |
| kwsys_stl::string EncodeValue(const char* str); |
| kwsys_stl::string DecodeValue(const char* str); |
| |
| protected: |
| bool m_Changed; |
| kwsys_stl::string m_TopLevel; |
| bool m_GlobalScope; |
| |
| #ifdef _WIN32 |
| HKEY HKey; |
| #endif |
| // Strip trailing and ending spaces. |
| char *Strip(char *str); |
| void SetSubKey(const char* sk); |
| kwsys_stl::string CreateKey(const char *key); |
| |
| typedef kwsys_stl::map<kwsys_stl::string, kwsys_stl::string> StringToStringMap; |
| StringToStringMap EntriesMap; |
| kwsys_stl::string m_SubKey; |
| bool m_Empty; |
| bool m_SubKeySpecified; |
| kwsys_stl::string m_HomeDirectory; |
| |
| Registry::RegistryType m_RegistryType; |
| }; |
| |
| //---------------------------------------------------------------------------- |
| #define Registry_BUFFER_SIZE 8192 |
| |
| //---------------------------------------------------------------------------- |
| Registry::Registry(Registry::RegistryType registryType) |
| { |
| m_Opened = false; |
| m_Locked = false; |
| this->Helper = 0; |
| this->Helper = new RegistryHelper(registryType); |
| } |
| |
| //---------------------------------------------------------------------------- |
| Registry::~Registry() |
| { |
| if ( m_Opened ) |
| { |
| kwsys_ios::cerr << "Registry::Close should be " |
| "called here. The registry is not closed." |
| << kwsys_ios::endl; |
| } |
| delete this->Helper; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void Registry::SetGlobalScope(bool b) |
| { |
| this->Helper->SetGlobalScope(b); |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::GetGlobalScope() |
| { |
| return this->Helper->GetGlobalScope(); |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::Open(const char *toplevel, |
| const char *subkey, int readonly) |
| { |
| bool res = false; |
| if ( m_Locked ) |
| { |
| return res; |
| } |
| if ( m_Opened ) |
| { |
| if ( !this->Close() ) |
| { |
| return res; |
| } |
| } |
| if ( !toplevel || !*toplevel ) |
| { |
| kwsys_ios::cerr << "Registry::Opened() Toplevel not defined" |
| << kwsys_ios::endl; |
| return res; |
| } |
| |
| if ( isspace(toplevel[0]) || |
| isspace(toplevel[strlen(toplevel)-1]) ) |
| { |
| kwsys_ios::cerr << "Toplevel has to start with letter or number and end" |
| " with one" << kwsys_ios::endl; |
| return res; |
| } |
| |
| res = this->Helper->Open(toplevel, subkey, readonly); |
| if ( readonly != Registry::READONLY ) |
| { |
| m_Locked = true; |
| } |
| |
| if ( res ) |
| { |
| m_Opened = true; |
| this->Helper->SetTopLevel(toplevel); |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::Close() |
| { |
| bool res = false; |
| if ( m_Opened ) |
| { |
| res = this->Helper->Close(); |
| } |
| |
| if ( res ) |
| { |
| m_Opened = false; |
| m_Locked = false; |
| this->Helper->SetChanged(false); |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::ReadValue(const char *subkey, |
| const char *key, |
| const char **value) |
| { |
| bool res = false; |
| bool open = false; |
| if ( ! value ) |
| { |
| return res; |
| } |
| *value = 0; |
| if ( !m_Opened ) |
| { |
| if ( !this->Open(this->GetTopLevel(), subkey, |
| Registry::READONLY) ) |
| { |
| return res; |
| } |
| open = true; |
| } |
| res = this->Helper->ReadValue(key, value); |
| |
| if ( open ) |
| { |
| if ( !this->Close() ) |
| { |
| res = false; |
| } |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::DeleteKey(const char *subkey, const char *key) |
| { |
| bool res = false; |
| bool open = false; |
| if ( !m_Opened ) |
| { |
| if ( !this->Open(this->GetTopLevel(), subkey, |
| Registry::READWRITE) ) |
| { |
| return res; |
| } |
| open = true; |
| } |
| |
| res = this->Helper->DeleteKey(key); |
| if ( res ) |
| { |
| this->Helper->SetChanged(true); |
| } |
| |
| if ( open ) |
| { |
| if ( !this->Close() ) |
| { |
| res = false; |
| } |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::DeleteValue(const char *subkey, const char *key) |
| { |
| bool res = false; |
| bool open = false; |
| if ( !m_Opened ) |
| { |
| if ( !this->Open(this->GetTopLevel(), subkey, |
| Registry::READWRITE) ) |
| { |
| return res; |
| } |
| open = true; |
| } |
| |
| res = this->Helper->DeleteValue(key); |
| if ( res ) |
| { |
| this->Helper->SetChanged(true); |
| } |
| |
| if ( open ) |
| { |
| if ( !this->Close() ) |
| { |
| res = false; |
| } |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool Registry::SetValue(const char *subkey, const char *key, |
| const char *value) |
| { |
| bool res = false; |
| bool open = false; |
| if ( !m_Opened ) |
| { |
| if ( !this->Open(this->GetTopLevel(), subkey, |
| Registry::READWRITE) ) |
| { |
| return res; |
| } |
| open = true; |
| } |
| |
| res = this->Helper->SetValue( key, value ); |
| if ( res ) |
| { |
| this->Helper->SetChanged(true); |
| } |
| |
| if ( open ) |
| { |
| if ( !this->Close() ) |
| { |
| res = false; |
| } |
| } |
| return res; |
| } |
| |
| //---------------------------------------------------------------------------- |
| const char* Registry::GetTopLevel() |
| { |
| return this->Helper->GetTopLevel(); |
| } |
| |
| //---------------------------------------------------------------------------- |
| void Registry::SetTopLevel(const char* tl) |
| { |
| this->Helper->SetTopLevel(tl); |
| } |
| |
| //---------------------------------------------------------------------------- |
| void RegistryHelper::SetTopLevel(const char* tl) |
| { |
| if ( tl ) |
| { |
| m_TopLevel = tl; |
| } |
| else |
| { |
| m_TopLevel = ""; |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| RegistryHelper::RegistryHelper(Registry::RegistryType registryType) |
| { |
| m_Changed = false; |
| m_TopLevel = ""; |
| m_SubKey = ""; |
| m_SubKeySpecified = false; |
| m_Empty = true; |
| m_GlobalScope = false; |
| m_RegistryType = registryType; |
| } |
| |
| //---------------------------------------------------------------------------- |
| RegistryHelper::~RegistryHelper() |
| { |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::Open(const char *toplevel, const char *subkey, |
| int readonly) |
| { |
| this->EntriesMap.clear(); |
| m_Empty = 1; |
| |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| HKEY scope = HKEY_CURRENT_USER; |
| if ( this->GetGlobalScope() ) |
| { |
| scope = HKEY_LOCAL_MACHINE; |
| } |
| int res = 0; |
| kwsys_ios::ostringstream str; |
| DWORD dwDummy; |
| str << "Software\\Kitware\\" << toplevel << "\\" << subkey; |
| if ( readonly == Registry::READONLY ) |
| { |
| res = ( RegOpenKeyEx(scope, str.str().c_str(), |
| 0, KEY_READ, &this->HKey) == ERROR_SUCCESS ); |
| } |
| else |
| { |
| char lpClass[] = ""; |
| res = ( RegCreateKeyEx(scope, str.str().c_str(), |
| 0, lpClass, REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE, |
| NULL, &this->HKey, &dwDummy) == ERROR_SUCCESS ); |
| } |
| if ( res != 0 ) |
| { |
| this->SetSubKey( subkey ); |
| } |
| return (res != 0); |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| bool res = false; |
| int cc; |
| kwsys_ios::ostringstream str; |
| const char* homeDirectory; |
| if ( (homeDirectory = getenv("HOME")) == 0 ) |
| { |
| if ( (homeDirectory = getenv("USERPROFILE")) == 0 ) |
| { |
| return false; |
| } |
| } |
| m_HomeDirectory = homeDirectory; |
| str << m_HomeDirectory.c_str() << "/." << toplevel << "rc"; |
| if ( readonly == Registry::READWRITE ) |
| { |
| kwsys_ios::ofstream ofs( str.str().c_str(), kwsys_ios::ios::out|kwsys_ios::ios::app ); |
| if ( ofs.fail() ) |
| { |
| return false; |
| } |
| ofs.close(); |
| } |
| |
| kwsys_ios::ifstream *ifs = new kwsys_ios::ifstream(str.str().c_str(), kwsys_ios::ios::in |
| #ifndef KWSYS_IOS_USE_ANSI |
| | kwsys_ios::ios::nocreate |
| #endif |
| ); |
| if ( !ifs ) |
| { |
| return false; |
| } |
| if ( ifs->fail()) |
| { |
| delete ifs; |
| return false; |
| } |
| |
| res = true; |
| char buffer[Registry_BUFFER_SIZE]; |
| while( !ifs->fail() ) |
| { |
| ifs->getline(buffer, Registry_BUFFER_SIZE); |
| if ( ifs->fail() || ifs->eof() ) |
| { |
| break; |
| } |
| char *line = this->Strip(buffer); |
| if ( *line == '#' || *line == 0 ) |
| { |
| // Comment |
| continue; |
| } |
| int linelen = static_cast<int>(strlen(line)); |
| for ( cc = 0; cc < linelen; cc++ ) |
| { |
| if ( line[cc] == '=' ) |
| { |
| char *key = new char[ cc+1 ]; |
| strncpy( key, line, cc ); |
| key[cc] = 0; |
| char *value = line + cc + 1; |
| char *nkey = this->Strip(key); |
| char *nvalue = this->Strip(value); |
| this->EntriesMap[nkey] = this->DecodeValue(nvalue); |
| m_Empty = 0; |
| delete [] key; |
| break; |
| } |
| } |
| } |
| ifs->close(); |
| this->SetSubKey( subkey ); |
| delete ifs; |
| return res; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::Close() |
| { |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| int res; |
| res = ( RegCloseKey(this->HKey) == ERROR_SUCCESS ); |
| return (res != 0); |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| if ( !m_Changed ) |
| { |
| this->SetSubKey(0); |
| return true; |
| } |
| |
| kwsys_ios::ostringstream str; |
| str << m_HomeDirectory.c_str() << "/." << this->GetTopLevel() << "rc"; |
| kwsys_ios::ofstream *ofs = new kwsys_ios::ofstream(str.str().c_str(), kwsys_ios::ios::out); |
| if ( !ofs ) |
| { |
| return false; |
| } |
| if ( ofs->fail()) |
| { |
| delete ofs; |
| return false; |
| } |
| *ofs << "# This file is automatically generated by the application" << kwsys_ios::endl |
| << "# If you change any lines or add new lines, note that all" << kwsys_ios::endl |
| << "# comments and empty lines will be deleted. Every line has" << kwsys_ios::endl |
| << "# to be in format: " << kwsys_ios::endl |
| << "# key = value" << kwsys_ios::endl |
| << "#" << kwsys_ios::endl; |
| |
| if ( !this->EntriesMap.empty() ) |
| { |
| RegistryHelper::StringToStringMap::iterator it; |
| for ( it = this->EntriesMap.begin(); |
| it != this->EntriesMap.end(); |
| ++ it ) |
| { |
| *ofs << it->first.c_str() << " = " << this->EncodeValue(it->second.c_str()).c_str() << kwsys_ios::endl; |
| } |
| } |
| this->EntriesMap.clear(); |
| ofs->close(); |
| delete ofs; |
| this->SetSubKey(0); |
| m_Empty = 1; |
| return true; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::ReadValue(const char *skey, const char **value) |
| |
| { |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| kwsys_stl::string key = this->CreateKey( skey ); |
| if ( key.empty() ) |
| { |
| return false; |
| } |
| DWORD dwType, dwSize; |
| dwType = REG_SZ; |
| char buffer[1024]; // Replace with RegQueryInfoKey |
| dwSize = sizeof(buffer); |
| int res = ( RegQueryValueEx(this->HKey, skey, NULL, &dwType, |
| (BYTE *)buffer, &dwSize) == ERROR_SUCCESS ); |
| if ( !res ) |
| { |
| return false; |
| } |
| this->EntriesMap[key] = buffer; |
| RegistryHelper::StringToStringMap::iterator it |
| = this->EntriesMap.find(key); |
| *value = it->second.c_str(); |
| return true; |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| bool res = false; |
| kwsys_stl::string key = this->CreateKey( skey ); |
| if ( key.empty() ) |
| { |
| return false; |
| } |
| |
| RegistryHelper::StringToStringMap::iterator it |
| = this->EntriesMap.find(key); |
| if ( it != this->EntriesMap.end() ) |
| { |
| *value = it->second.c_str(); |
| res = true; |
| } |
| return res; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::DeleteKey(const char* skey) |
| { |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| int res = ( RegDeleteKey( this->HKey, skey ) == ERROR_SUCCESS ); |
| return (res != 0); |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| kwsys_stl::string key = this->CreateKey( skey ); |
| if ( key.empty() ) |
| { |
| return false; |
| } |
| this->EntriesMap.erase(key); |
| return true; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::DeleteValue(const char *skey) |
| { |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| int res = ( RegDeleteValue( this->HKey, skey ) == ERROR_SUCCESS ); |
| return (res != 0); |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| kwsys_stl::string key = this->CreateKey( skey ); |
| if ( key.empty() ) |
| { |
| return false; |
| } |
| this->EntriesMap.erase(key); |
| return true; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::SetValue(const char *skey, const char *value) |
| { |
| #ifdef _WIN32 |
| if ( m_RegistryType == Registry::WIN32_REGISTRY) |
| { |
| DWORD len = (DWORD)(value ? strlen(value) : 0); |
| int res = ( RegSetValueEx(this->HKey, skey, 0, REG_SZ, |
| (CONST BYTE *)(const char *)value, |
| len+1) == ERROR_SUCCESS ); |
| return (res != 0); |
| } |
| #endif |
| if ( m_RegistryType == Registry::FILE_REGISTRY ) |
| { |
| kwsys_stl::string key = this->CreateKey( skey ); |
| if ( key.empty() ) |
| { |
| return 0; |
| } |
| this->EntriesMap[key] = value; |
| return 1; |
| } |
| return false; |
| } |
| |
| //---------------------------------------------------------------------------- |
| kwsys_stl::string RegistryHelper::CreateKey( const char *key ) |
| { |
| if ( !m_SubKeySpecified || m_SubKey.empty() || !key ) |
| { |
| return ""; |
| } |
| kwsys_ios::ostringstream ostr; |
| ostr << this->EncodeKey(this->m_SubKey.c_str()).c_str() |
| << "\\" << this->EncodeKey(key).c_str(); |
| return ostr.str(); |
| } |
| |
| //---------------------------------------------------------------------------- |
| void RegistryHelper::SetSubKey(const char* sk) |
| { |
| if ( !sk ) |
| { |
| m_SubKey = ""; |
| m_SubKeySpecified = false; |
| } |
| else |
| { |
| m_SubKey = sk; |
| m_SubKeySpecified = true; |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| char *RegistryHelper::Strip(char *str) |
| { |
| int cc; |
| size_t len; |
| char *nstr; |
| if ( !str ) |
| { |
| return NULL; |
| } |
| len = strlen(str); |
| nstr = str; |
| for( cc=0; cc < static_cast<int>(len); cc++ ) |
| { |
| if ( !isspace( *nstr ) ) |
| { |
| break; |
| } |
| nstr ++; |
| } |
| for( cc= static_cast<int>(strlen(nstr))-1; cc>=0; cc-- ) |
| { |
| if ( !isspace( nstr[cc] ) ) |
| { |
| nstr[cc+1] = 0; |
| break; |
| } |
| } |
| return nstr; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void RegistryHelper::SetGlobalScope(bool b) |
| { |
| m_GlobalScope = b; |
| } |
| |
| //---------------------------------------------------------------------------- |
| bool RegistryHelper::GetGlobalScope() |
| { |
| return m_GlobalScope; |
| } |
| |
| //---------------------------------------------------------------------------- |
| kwsys_stl::string RegistryHelper::EncodeKey(const char* str) |
| { |
| kwsys_ios::ostringstream ostr; |
| while ( *str ) |
| { |
| switch ( *str ) |
| { |
| case '%': case '=': case '\n': case '\r': case '\t': |
| char buffer[4]; |
| sprintf(buffer, "%%%02X", *str); |
| ostr << buffer; |
| break; |
| default: |
| ostr << *str; |
| } |
| str ++; |
| } |
| return ostr.str(); |
| } |
| |
| //---------------------------------------------------------------------------- |
| kwsys_stl::string RegistryHelper::EncodeValue(const char* str) |
| { |
| kwsys_ios::ostringstream ostr; |
| while ( *str ) |
| { |
| switch ( *str ) |
| { |
| case '%': case '=': case '\n': case '\r': case '\t': |
| char buffer[4]; |
| sprintf(buffer, "%%%02X", *str); |
| ostr << buffer; |
| break; |
| default: |
| ostr << *str; |
| } |
| str ++; |
| } |
| return ostr.str(); |
| } |
| |
| //---------------------------------------------------------------------------- |
| kwsys_stl::string RegistryHelper::DecodeValue(const char* str) |
| { |
| kwsys_ios::ostringstream ostr; |
| while ( *str ) |
| { |
| unsigned int val; |
| switch ( *str ) |
| { |
| case '%': |
| if ( *(str+1) && *(str+2) && sscanf(str+1, "%x", &val) == 1 ) |
| { |
| ostr << static_cast<char>(val); |
| str += 2; |
| } |
| else |
| { |
| ostr << *str; |
| } |
| break; |
| default: |
| ostr << *str; |
| } |
| str ++; |
| } |
| return ostr.str(); |
| } |
| |
| } // namespace KWSYS_NAMESPACE |