RegKey.h

Go to the documentation of this file.

/*  RegKey.h - registry key wrappers
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_RegKey_h
#define OW32_RegKey_h

#include <OW32/XHKEY.h>
#include <OW32/strconv.h>
#include <OW32/auto_array_ptr.h>

#include <cstring>
#include <tchar.h>

#ifndef OW32_NO_STL
#include <string>
#endif

namespace OW32
{

class OW32_LIB_EXPORT CRegKey
{
private:
    CRegKey(const CRegKey& );
    CRegKey& operator=(const CRegKey& );

    XHKEY m_hKey;

    // helper functions to select the appropriate ANSI/UNICODE version of RegQueryValue based on the
    // output buffer's type
    LONG RegQueryString(LPCTSTR lpszValueName, LPDWORD pdwType, char* buf, LPDWORD pBufSize)
    {
        USES_CONVERSION;
        return RegQueryValueExA(m_hKey, T2CA(lpszValueName), NULL, pdwType, (LPBYTE)buf, pBufSize);
    }

    LONG RegQueryString(LPCTSTR lpszValueName, LPDWORD pdwType, wchar_t* buf, LPDWORD pBufSize)
    {
        USES_CONVERSION;
        return RegQueryValueExW(m_hKey, T2CW(lpszValueName), NULL, pdwType, (LPBYTE)buf, pBufSize);
    }

    template <class T>
    DWORD GrowBuffer(auto_array_ptr<T>* ppBuffer, DWORD curlen, bool copy = true, DWORD growby = 256)
    {
        DWORD lennew = curlen + growby;
        auto_array_ptr<T> pNew(new T[lennew]);
        if (copy) memcpy(pNew.get(), (*ppBuffer).get(), curlen * sizeof(T));
        *ppBuffer = pNew;
        return lennew;
    }

public:
    CRegKey() 
    {
    }

    CRegKey(HKEY hKey) :
        m_hKey(hKey)
    {
    }

    void Close()
    {
        m_hKey.Close();
    }

    static inline IsStringType(DWORD dwType)
    {
        return dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ || dwType == REG_SZ;
    }

    static inline IsDWORDType(DWORD dwType)
    {
        return dwType == REG_DWORD || dwType == REG_DWORD_LITTLE_ENDIAN || dwType == REG_DWORD_BIG_ENDIAN;
    }

    LONG Open(HKEY hKeyParent, LPCTSTR lpszKeyName, REGSAM samDesired = KEY_READ) 
    {
        Close();
        return RegOpenKeyEx(hKeyParent, lpszKeyName, 0, samDesired, &m_hKey);
    }

#ifndef OW32_NO_STL

    template <class T>
    LONG QueryValue(std::basic_string<T>& strValue, LPCTSTR lpszValueName = NULL)
    {
        // initially use a quick query buffer
        T strBuf[MAX_PATH];
        DWORD BufSize = sizeof(strBuf);

        // do the query
        DWORD dwType;
        LONG lRet = RegQueryString(lpszValueName, &dwType, strBuf, &BufSize);
        if (lRet == ERROR_SUCCESS) 
        {
            // check type
            if (!IsStringType(dwType))
                return ERROR_INVALID_DATATYPE;

            // trim trailing NULL if present.  RegQueryValueEx indicates that
            // we we may or may not get a NULL depending on what was stored in the
            // registry, and that we should do this checking here...
            DWORD nChars = BufSize/sizeof(T);

            if ((dwType == REG_EXPAND_SZ || dwType == REG_SZ) && nChars > 0)
            {
                if (strBuf[nChars - 1] == T(0))
                    nChars--;
            } 
            else if (nChars >= 2) // REG_MULTI_SZ, trim final NULL
            {
                if (strBuf[nChars - 1] == T(0) && strBuf[nChars - 2] == T(0))
                    nChars--;
            }
            strValue = std::basic_string<T>(strBuf, nChars);
            return ERROR_SUCCESS;
        }

        if (lRet != ERROR_MORE_DATA)
            return lRet;

        // value was too big - allocate a buffer of the correct size & retry
        DWORD nChars = BufSize/sizeof(T);
        auto_array_ptr<T> pBuf(new T[nChars]);
        lRet = RegQueryString(lpszValueName, &dwType, pBuf.get(), &BufSize);

        if (lRet == ERROR_SUCCESS) 
        {
            if (IsStringType(dwType))
            {
                // Trim trailing NULL if present.  See note above.
                DWORD nChars = BufSize/sizeof(T);

                if ((dwType == REG_EXPAND_SZ || dwType == REG_SZ) && nChars > 0)
                {
                    if (pBuf[nChars - 1] == T(0))
                        nChars--;
                } 
                else if (nChars >= 2) // REG_MULTI_SZ, trim final NULL
                {
                    if (pBuf[nChars - 1] == T(0) && pBuf[nChars - 2] == T(0))
                        nChars--;
                }

                strValue = std::basic_string<T>(pBuf.get(), nChars);
            }
            else
            {
                lRet = ERROR_INVALID_DATATYPE;
            }
        }
        return lRet;
    }
    
    template <class T>
    LONG EnumKey(DWORD index, std::basic_string<T>& name, FILETIME* pftime = NULL)
    {
        DWORD lenBuffer = 256;
        auto_array_ptr<T> pBuffer(new T[lenBuffer]);

        DWORD lenName = lenBuffer;
        FILETIME ftime;
        
        DWORD ret = 0;
        while((ret = ::RegEnumKeyEx(m_hKey, index, pBuffer.get(), &lenName, 0, NULL, NULL, pftime ? pftime : &ftime)) == ERROR_MORE_DATA)
        {
            // Grow buffer and try again
            lenBuffer = GrowBuffer(&pBuffer, lenBuffer, false);
            lenName = lenBuffer;
        }

        // Terminate & copy
        pBuffer[lenBuffer-1] = _T('\0');
        if (ERROR_SUCCESS == ret) {
            name = pBuffer.get();
        }
        return ret;
    }

    template <class T>
    LONG EnumValue(DWORD index, std::basic_string<T>& name, DWORD* pType = NULL, /*out*/BYTE** ppData = NULL, /*out*/DWORD* pLenData = NULL)
    {
        bool fWantData = ppData != NULL;

        DWORD lenNameBuffer = 256;
        auto_array_ptr<T> pNameBuffer(new T[lenNameBuffer]);
        
        DWORD lenDataBuffer = 256;
        auto_array_ptr<BYTE> pData;
        if (fWantData)
        {
            pData.reset(new BYTE[lenDataBuffer]);
        }

        DWORD lenName = lenNameBuffer;  
        DWORD lenData = lenDataBuffer;

        DWORD type = 0;
        DWORD ret = 0;
        while ((ret = ::RegEnumValue(m_hKey, index, pNameBuffer.get(), &lenName, 0, 
                &type, fWantData ? pData.get() : NULL, fWantData ? &lenData : NULL)) == ERROR_MORE_DATA)
        {
            // Grow the name buffer and try again -- the name doesn't report it's actual
            // length, which is a bit irritating
            if (lenName >= lenNameBuffer) {
                lenNameBuffer = GrowBuffer(&pNameBuffer, lenNameBuffer, false);
            }
            // If data is wanted, and was not all retrieved, then grow the data buffer and try and again
            if (fWantData && lenData > lenDataBuffer) {
                lenDataBuffer = GrowBuffer(&pData, lenDataBuffer, false, lenData - lenDataBuffer);
            }
            lenName = lenNameBuffer;
        }
        
        if (ERROR_SUCCESS == ret) {
            // Terminate & copy name
            pNameBuffer[lenNameBuffer-1] = _T('\0');
            name = pNameBuffer.get();

            // outputs
            if (pLenData) *pLenData = lenData;
            if (ppData) *ppData = pData.release();
            if (pType) *pType = type;

        } else {
            // outputs
            if (pLenData) *pLenData = 0;
            if (ppData) *ppData = 0;
            if (pType) *pType = 0;
        }
        return ret;
    }
#endif

    LONG QueryValue(BYTE* Buf, DWORD* BufSize, LPCTSTR lpszValueName = NULL)
    {
        DWORD dwType;
        LONG lRet = RegQueryValueEx(m_hKey, lpszValueName, NULL,
            &dwType, Buf, BufSize);
        if (lRet == ERROR_SUCCESS && dwType != REG_BINARY)
            return ERROR_INVALID_DATATYPE;
        return lRet;
    }

    template <class T>
    LONG QueryValue(T* buf, int nBuf, LPCTSTR lpszValueName = NULL)
    {
        DWORD BufSize = sizeof(T)*nBuf, dwType;
        LONG lRet = RegQueryString(lpszValueName, &dwType, buf, &BufSize);
        if (lRet == ERROR_SUCCESS && !IsStringType(dwType))
            return ERROR_INVALID_DATATYPE;
        return lRet;
    }

    LONG QueryValue(DWORD& dwValue, LPCWSTR lpszValueName = NULL)
    {
        DWORD dwType, BufSize=sizeof(DWORD);
        LONG lRet = RegQueryValueExW(m_hKey, lpszValueName, NULL, &dwType, (LPBYTE)&dwValue, &BufSize);
        if (lRet == ERROR_SUCCESS && !IsDWORDType(dwType))
            return ERROR_INVALID_DATATYPE;
        return lRet;
    }

    LONG QueryValue(DWORD& dwValue, LPCSTR lpszValueName = NULL)
    {
        DWORD dwType, BufSize=sizeof(DWORD);
        LONG lRet = RegQueryValueExA(m_hKey, lpszValueName, NULL, &dwType, (LPBYTE)&dwValue, &BufSize);
        if (lRet == ERROR_SUCCESS && !IsDWORDType(dwType))
            return ERROR_INVALID_DATATYPE;
        return lRet;
    }

    LONG Create(HKEY hKeyParent, LPCTSTR lpszKeyName, LPTSTR lpszClass = REG_NONE, 
                DWORD dwOptions = REG_OPTION_NON_VOLATILE, REGSAM samDesired = KEY_ALL_ACCESS, 
                LPSECURITY_ATTRIBUTES lpSecAttr = NULL, LPDWORD lpdwDisposition = NULL )
    {
        Close();
        return RegCreateKeyEx(hKeyParent, lpszKeyName, 0, lpszClass, dwOptions,
                              samDesired, lpSecAttr, &m_hKey, lpdwDisposition);
    }

    LONG DeleteValue(LPCTSTR lpszValueName = NULL)
    {
        return RegDeleteValue(m_hKey, lpszValueName);
    }

    LONG DeleteKey(LPCTSTR lpSubKey = NULL)
    {
        return RegDeleteKey(m_hKey, lpSubKey);
    }

    LONG SetValue(LPCTSTR lpszValue, LPCTSTR lpszValueName = NULL)
    {
        DWORD DataSize = (DWORD)(_tcslen(lpszValue)+1)*sizeof(TCHAR);
        return RegSetValueEx(m_hKey, lpszValueName, 0, REG_SZ, (CONST BYTE*)lpszValue, DataSize);
    }

    LONG SetValue(const BYTE* pData, LONG bufSize, DWORD dwType = REG_BINARY, LPCTSTR lpszValueName = NULL)
    {
        return RegSetValueEx(m_hKey, lpszValueName, 0, dwType, pData, bufSize);
    }

    LONG SetValue(DWORD dwValue, LPCTSTR lpszValueName = NULL)
    {
        return RegSetValueEx(m_hKey, lpszValueName, 0, REG_DWORD, (CONST BYTE*)&dwValue, sizeof(DWORD));
    }

    LONG Flush()
    {
        return RegFlushKey(m_hKey);
    }

    operator HKEY() { return m_hKey; }
};

} // namespace OW32

#endif // OW32_RegKey_h

---