RegFunc.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Registry functions and support classes.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/RegFunc.h>
#include <StdIo.h>

#define RNAME_CHUNK  MAX_PATH
#define RDATA_CHUNK  MAX_PATH

#ifdef __GNUC__ // Omissions and quirks...
  #ifndef LSTATUS
    typedef LONG LSTATUS;
  #endif // LSTATUS
#endif // __GNUC__

//== RegCloseKeyEx ==----------------------------------------------------------

HKEY RegCloseKeyEx( HKEY Key )
{
    if (!Key) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        LSTATUS rc = RegCloseKey( Key );
        if (rc == 0) Key = NULL; else SetLastError( rc );
    }
    return Key;
}

//== RegKeyExist ==------------------------------------------------------------

BOOL RegKeyExist( HKEY BaseKey, CSTR RegPath )
{
    HKEY hKey;
    LSTATUS rc = RegOpenKey( BaseKey, RegPath, &hKey );
    BOOL ok = (rc == 0);
    if (ok) RegCloseKey( hKey );
    return ok;
}

//== RegValueExist ==----------------------------------------------------------

BOOL RegValueExist( HKEY key, CSTR name )
{
    LONG rc = RegQueryValueEx( key, name, 0,NULL,NULL,NULL );
    return REG_OK( rc );
}

//== Get registry value info ==------------------------------------------------

LONG RegGetValueInfo( HKEY hKey, CSTR ValName, PDWORD pSize, PDWORD pType )
{
    DWORD cbData = 0, dwData = 0;
    // NOTE: lpData can not be NULL if we want to find out cbData reliably. Why?
    LONG rc = RegQueryValueEx( hKey, ValName, NULL, pType, (PBYTE)&dwData, &cbData );
    if (pSize && (rc == ERROR_MORE_DATA))
    {
        rc = NOERROR;
        *pSize = cbData;
    }
    return rc;
}

//-----------------------------------------------------------------------------
// Rename a registry value
//-----------------------------------------------------------------------------

LONG RegRenameValue( HKEY hKey, CSTR OldName, CSTR NewName )
{
    DWORD vType, cbData;
    BYTE tmpBuf[MAX_PATH], useHeap;
    LONG rc;

    rc = RegGetValueInfo( hKey, OldName, &cbData, NULL );
    if (REG_OK( rc ))
    {
        useHeap = (cbData > sizeof(tmpBuf));
        PBYTE pData = useHeap ? (PBYTE) mem_Alloc( cbData ) : tmpBuf;
        rc = RegQueryValueEx( hKey, OldName, NULL, &vType, pData, &cbData );
        if (REG_OK( rc ))
        {
            rc = RegSetValueEx( hKey, NewName, 0, vType, pData, cbData );
            if (REG_OK( rc )) RegDeleteValue( hKey, OldName );
        }
        if (useHeap) mem_Free( pData );
    }
    return rc;
}

//== REG_DWORD ==--------------------------------------------------------------

LONG RegSetDWord( HKEY hKey, CSTR ValName, DWORD Val )
{
    return RegSetValueEx( hKey, ValName, 0, REG_DWORD, (PBYTE)&Val, sizeof(DWORD) );
}

LONG RegGetDWord( HKEY hKey, CSTR ValName, PDWORD pVal )
{
    DWORD type, cbRd = sizeof(DWORD);
    LONG rc = RegQueryValueEx( hKey, ValName, NULL, &type, (PBYTE)pVal, &cbRd );
    if (REG_OK( rc ))
    {
        if (type != REG_DWORD || cbRd != sizeof(DWORD)) rc = ERROR_INVALID_DATA;
    }
    return rc;
}

LONG RegGetUInt( HKEY hKey, CSTR ValName, PUINT pVal )
{
    return RegGetDWord( hKey, ValName, (PDWORD)pVal );
}

LONG RegGetBool( HKEY hKey, CSTR ValName, bool* pVal )
{
    DWORD tmp = 0;
    LONG rc = RegGetDWord( hKey, ValName, &tmp );
    if (REG_OK( rc )) *pVal = bool_cast( tmp );
    return rc;
}

//== REG_BINARY ==-------------------------------------------------------------

LONG RegSetBinary( HKEY hKey, CSTR ValName, PBYTE Val, DWORD Size )
{
    return RegSetValueEx( hKey, ValName, 0, REG_BINARY, Val, Size );
}

LONG RegGetBinary( HKEY hKey, CSTR ValName, PBYTE pVal, PDWORD pSize )
{
    DWORD type;
    LONG rc = RegQueryValueEx( hKey, ValName, NULL, &type, pVal, pSize );
    if (REG_OK( rc ))
    {
        if (type != REG_BINARY) rc = ERROR_INVALID_DATA; // Check it's BINARY
    }
    return rc;
}

//== REG_SZ ==-----------------------------------------------------------------

LONG RegSetString( HKEY hKey, CSTR ValName, CSTR Str, DWORD Type )
{
    DWORD size = (Type == REG_MULTI_SZ) ? MultiSzLength( Str ) : (1 + (DWORD)_tcslen( Str ));
    size *= sizeof(TCHAR);
    return RegSetValueEx( hKey, ValName, 0, Type, (PBYTE)Str, size );
}

LONG RegGetString( HKEY hKey, CSTR ValName, TSTR Buf, PDWORD Size, PDWORD Type )
{
    LONG rc = RegQueryValueEx( hKey, ValName, 0, Type, (PBYTE)Buf, Size );
    if (REG_OK( rc ))
    {
        // Reg strings are not always NUL terminated, so terminate it.
        DWORD type = *Type; // Avoid repeated ptr referencing..
        if (type == REG_SZ || type == REG_EXPAND_SZ || type == REG_MULTI_SZ)
            Buf[ *Size ] = 0;
        else rc = ERROR_INVALID_DATA; // Reg value is not a string.
    }
    return rc;
}

// Save/Restore window rectangle

LONG SaveWindowRect( HWND hWnd, HKEY baseKey, CSTR regPath, CSTR valName )
{
    HKEY Key; RECT R; LONG rc;
    if (IsMinimized( hWnd )) rc = ERROR_INCORRECT_SIZE;
    else
    {
        rc = RegCreateKeyEx( baseKey, regPath, 0, NULL, 0, KEY_WRITE, NULL, &Key, NULL );
        if (rc == NOERROR)
        {
            GetWindowRect( hWnd, &R );
            RegSetValueEx( Key, valName, 0, REG_BINARY, (PBYTE)&R, sizeof(RECT) );
            RegCloseKey( Key );
        }
    }
    return rc;
}

LONG RestoreWindowRect( HWND hWnd, HKEY baseKey, CSTR regPath, CSTR valName )
{
    HKEY Key; RECT R;
    LONG rc = RegOpenKeyEx( baseKey, regPath, 0, KEY_READ, &Key );
    if (rc == NOERROR)
    {
        DWORD type = 0, cb = sizeof(RECT);
        rc = RegQueryValueEx( Key, valName, 0, &type, (PBYTE)&R, &cb );
        if (rc == NOERROR)
        {
            // Constrain rect to stay on the visible screen.
            SIZE scrSiz = { SYSMET( CXSCREEN ), SYSMET( CYSCREEN ) };
            if ((R.left < 0) || (R.left > scrSiz.cx)) OffsetRect( &R, -R.left, 0 );
            if ((R.top < 0) || (R.top > scrSiz.cy)) OffsetRect( &R, 0, -R.top );

            AbsToDimRect( &R ); //right/bottom = width/height
            SetWindowPos( hWnd, NULL, R.left, R.top, R.right, R.bottom, SWP_NOZORDER );
        }
        RegCloseKey( Key );
    }
    return rc;
}

//-----------------------------------------------------------------------------
// RegDeleteBranch - Recursively delete a key and it's sub-keys
// Parent     - An open key
// SubkeyName - Name of a subkey to delete
//-----------------------------------------------------------------------------

LONG RegDeleteBranch( HKEY Parent, CSTR SubkeyName )
{
    DWORD       nSubkeys, nRemain, ccKeyname, len;
    TSTR        pKeyname;
    HKEY        hSubkey;
    FILETIME    time;
    LONG        rc, bufSize;

    rc = RegOpenKeyEx( Parent, SubkeyName, 0,KEY_ALL_ACCESS, &hSubkey );
    if (REG_ERR( rc ))
        DPrint( DP_ERROR, _F("RegOpenKeyEx '%s' failed: %s\n"), SubkeyName, SysErrorMsg(rc) );
    else
    {
        // The subkey exists - See if it has subkeys of it's own

        rc = RegQuerySubkeys( hSubkey, &nSubkeys, &ccKeyname );
        if (REG_ERR( rc ))
            DPrint( DP_ERROR, _F("RegQueryInfoKey '%s' failed: %s\n"), SubkeyName, SysErrorMsg(rc) );
        else if (nSubkeys > 0)
        {
            // It does - Enumerate them

            bufSize = ccKeyname + 1;
            pKeyname = (TSTR) mem_AllocStr( (WORD)bufSize ); // Get a name buffer
            if (!pKeyname)
            {
                rc = ERROR_OUTOFMEMORY; // Give up
                DPrint( DP_ERROR, _F("Alloc(%u) failed: %s\n"), bufSize, SysErrorMsg(rc) );
                goto rdb_bailout; // RegDeleteKey will (NT/2000) fail but let it try
            }

            // Now commence the recursive deletion loop

            nRemain = nSubkeys;
            while( nRemain > 0 )
            {
                len = bufSize;
                // Trick #9: Always retrieve index 0 and decrease count when deleting,
                // instead of stepping the index up which would overrun after N/2..
                rc = RegEnumKeyEx( hSubkey, 0, pKeyname,&len, NULL,NULL,NULL, &time );
                if (REG_OK( rc ))
                {
                    // Recurse with open key + subkey name

                    rc = RegDeleteBranch( hSubkey, pKeyname ); // RECURSE ...

                    if (REG_OK( rc )) nRemain--;
                    else if (rc == ERROR_NO_MORE_ITEMS) nRemain = 0;
                }
                else // RegEnumKey failed
                {
                    DPrint( DP_ERROR, _F("Key '%s'. RegEnumKeyEx(%d) failed: %s\n"), SubkeyName, 0, SysErrorMsg(rc) );
                    IF_DEBUG( DebugBreak(); )
                }
            }
            mem_FreeStr( pKeyname );
        }
    rdb_bailout:
        RegCloseKey( hSubkey );
    }

    // At this point, any and all subkeys have been deleted already.
    // (Unless there was a memory allocation failure.. Let system try anyway)

    rc = RegDeleteKey( Parent, SubkeyName ); // Not recursive on Win NT.
    if (REG_ERR( rc )) DPrint( DP_ERROR, _F(" RegDeleteKey '%s' failed: %s\n"), SubkeyName, SysErrorMsg(rc) );
    return rc;
}

//-----------------------------------------------------------------------------
// RegRenameKey - Synopsis
//
// 1) Adjust process priviledges
// 2) Open the existing source key
// 3) Save the source branch to a tempfile
// 4) Query source key class and security size
// 5) Allocate security descriptor
// 6) Create a new key with the new name, and equal security and class
// 7) Load the tempfile into the new key
// 8) On failure, delete the new key
// 9) On success, delete the old key
// 10) Clean up in reverse order (stack style)
//
//-----------------------------------------------------------------------------

#define tempName        TEXT("_RegKey_Temp_.bin") // Temporary file name
#define PRIVI_BUFSIZE   256

LONG _RegRenameKey( HKEY BaseKey, CSTR Subkey, CSTR NewSubkeyName )
{
    PISECURITY_DESCRIPTOR   secDesc; // PI.. Internal (with fields)
    SECURITY_ATTRIBUTES     secAtt;
    PTOKEN_PRIVILEGES       savePriv;

    HANDLE      hTok;   // Process token
    HKEY        hKey;   // Source key with security descriptor access
    HKEY        newKey;
    BOOL        privOk, allDone;
    LONG        err;
    DWORD       ccClass, cbSecDesc, dispo;
    TCHAR       szClass[ MAX_PATH ];
    FILETIME    ftWrit;

    savePriv = NULL;
    secDesc = NULL;
    allDone = FALSE;
    privOk = FALSE;

    // Adjust process privileges

    if (!OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY| TOKEN_ADJUST_PRIVILEGES, &hTok )) {
        TRACE( DP_ERROR, _F("OpenProcessToken failed: %s\n"), SysErrorMsg() );
        hTok = NULL;
    } else {
        privOk = EnablePrivileges(
            hTok, true, &savePriv, SE_BACKUP_NAME, SE_RESTORE_NAME, SE_SECURITY_NAME, 0
            );
        if (!privOk)
        {
            err = GetLastError();
            privOk = (err == ERROR_NOT_ALL_ASSIGNED); // Possibly acceptable error..
            IF_DEBUG( if (!privOk) DPrint(
                DP_ERROR, _F("AdjustTokenPrivileges failed: %s\n"), SysErrorMsg( err )
                );
            )
        }
    }
    // If it failed, try anyway, and fail out later if unsuccessful.

    // Open a source key with security access

    err = RegOpenKeyEx( BaseKey, Subkey, 0, KEY_ALL_ACCESS| ACCESS_SYSTEM_SECURITY, &hKey );
    if (REG_ERR( err )) {
        TRACE( DP_ERROR, _F("RegOpenKeyEx failed: %s\n"), SysErrorMsg( err ));
        goto exit_RestorePriv;
    }

    // Save branch to tempfile

    if (FileExist( tempName )) DeleteFile( tempName ); // Delete old file if any
    err = RegSaveKey( hKey, tempName, 0 ); // Save to temp file
    if (REG_ERR( err )) {
        TRACE( DP_ERROR, _F("RegSaveKey failed: %s\n"), SysErrorMsg( err ));
        goto exit_CloseSrc;
    }

    // Get key class and security descriptor size

    ccClass = MAX_PATH;
    err = RegQueryInfoKey( hKey, szClass, &ccClass, 0,0,0,0,0,0,0, &cbSecDesc, &ftWrit );
    if (REG_ERR( err )) {
        TRACE( DP_ERROR, _F("RegQueryInfoKey failed: %s\n"), SysErrorMsg( err ));
        goto exit_DeleteTemp;
    }

    // Get security descriptor (if step 1 was ok, we have sufficient privilege)

    secDesc = (PISECURITY_DESCRIPTOR) mem_Alloc( cbSecDesc );
    if (secDesc) err = RegGetKeySecurity( hKey, ALL_SECURITY_INFO, secDesc, &cbSecDesc );
    else err = ERROR_OUTOFMEMORY;
    if (REG_ERR( err )) {
        TRACE( DP_ERROR, _F("RegGetKeySecurity failed: %s\n"), SysErrorMsg( err ));
        goto exit_DeleteTemp;
    }

    // Create new key with the same class and security as the old

    secAtt.lpSecurityDescriptor = secDesc;
    secAtt.bInheritHandle = FALSE;
    secAtt.nLength = sizeof(secAtt);

    err = RegCreateKeyEx(
        BaseKey, NewSubkeyName, 0, szClass, REG_OPTION_BACKUP_RESTORE, //| REG_OPTION_NON_VOLATILE
        KEY_ALL_ACCESS| ACCESS_SYSTEM_SECURITY, &secAtt, &newKey, &dispo
        );
    if (REG_ERR( err )) {
        TRACE( DP_ERROR, _F("RegCreateKeyEx failed: %s\n"), SysErrorMsg( err ));
        goto exit_DeleteSec;
    }

    // Load saved branch

    err = RegRestoreKey( newKey, tempName, REG_FORCE_RESTORE );
    if (REG_OK( err ))
        allDone = TRUE;
    else { // Braced, since this is an empty statement in Release buils.
        TRACE( DP_ERROR, _F("RegRestoreKey failed: %s\n"), SysErrorMsg( err ));
    }

//exit_CloseNew: // 6
    RegCloseKey( newKey ); // Close it and ..
    if (allDone == FALSE) RegDeleteBranch( BaseKey, NewSubkeyName ); // .. revert all parts done, if any

exit_DeleteSec: // 5
    mem_Free( secDesc );

exit_DeleteTemp: // 3
    if (FileExist( tempName )) DeleteFile( tempName );

exit_CloseSrc: // 2 // Delete the source key and keep the new
    err = RegCloseKey( hKey );
    #if _DEBUG
    if (REG_ERR( err ))
        DPrint( DP_ERROR, _F("RegCloseKey failed: %s\n"), SysErrorMsg( err ));
    #endif

    if (allDone)
    {
        err = RegDeleteBranch( BaseKey, Subkey ); // delete old key + subkeys
        #if _DEBUG
        if (REG_ERR( err ))
            DPrint( DP_ERROR, _F("RegDeleteBranch failed: %s\n"), SysErrorMsg( err ));
        #endif
    }

exit_RestorePriv: // 1
    if (privOk) RestorePrivileges( hTok, savePriv, true );
    if (hTok) CloseHandle( hTok );
    return err;
}

//-----------------------------------------------------------------------------
// String representations of registry types
//-----------------------------------------------------------------------------

#define ULONG_HKCR  ULONG_PTR( HKEY_CLASSES_ROOT )

CSTR RegSysKeyName( HKEY hkey )
{
    static CCSTR SysKey[ 9 ] = {
        _T("HKEY_CLASSES_ROOT"),        // 0
        _T("HKEY_CURRENT_USER"),        // 1
        _T("HKEY_LOCAL_MACHINE"),       // 2
        _T("HKEY_USERS"),               // 3
        _T("HKEY_PERFORMANCE_DATA"),    // 4 Only WinNT/2000
        _T("HKEY_CURRENT_CONFIG"),      // 5
        _T("HKEY_DYN_DATA"),            // 6 Only Win95/98
        //
        _T("HKEY_PERFORMANCE_TEXT"),    // 0x50
        _T("HKEY_PERFORMANCE_NLSTEXT")  // 0x60
        };

    // Compute the array index, skipping over the gap between 6 and x50
    ULONG_PTR keyNr = ULONG_PTR( hkey ) - ULONG_HKCR;
    if (keyNr > 6) keyNr = (keyNr >> 4) + 2;

    if (keyNr < 9) return SysKey[ keyNr ];

    static __thread_local TCHAR kname[ 24 ]; // %p == 8/16 char (x86/x64)
    _stprintf_s( kname, dimof(kname), _T("HKEY_%p"), (PVOID) hkey );
    TRACE( DP_WARNING, _T("Non-system key %p passed to RegSysKeyName.\n"), hkey );
    return kname;
}

CSTR RegSysKeyAcronym( HKEY hkey ) // Return 4 char acronym of predefined hkey, or NULL
{
    static CCSTR SysAcro[ 9 ] = {
        _T("HKCR"),     // 0
        _T("HKCU"),     // 1
        _T("HKLM"),     // 2
        _T("HKU"),      // 3
        _T("HKPD"),     // 4 Only WinNT/2000
        _T("HKCC"),     // 5
        _T("HKDD"),     // 6 Only Win95/98
        //
        _T("HKPT"),     // 0x50
        _T("HKPN")      // 0x60
        };
    // Compute the array index, skipping over the gap between 6 and x50
    ULONG_PTR keyNr = ULONG_PTR( hkey ) - ULONG_HKCR;
    if (keyNr > 6) keyNr = (keyNr >> 4) + 2;

    if (keyNr < 9) return SysAcro[ keyNr ];

    static __thread_local TCHAR kname[ 24 ]; // %p == 8/16 char (x86/x64)
    _stprintf_s( kname, dimof(kname), _T("HK%p"), (PVOID) hkey );
    TRACE( DP_WARNING, _T("Non-system key %p passed to RegSysKeyAcronym.\n"), hkey );
    return kname;
}

CSTR RegTypeName( DWORD type )
{
    static CCSTR RegVType[ 12 ] = {
        _T("REG_NONE"),                         // 0
        _T("REG_SZ"),                           // 1
        _T("REG_EXPAND_SZ"),                    // 2
        _T("REG_BINARY"),                       // 3
        _T("REG_DWORD"),                        // 4
        _T("REG_DWORD_BIG_ENDIAN"),             // 5
        _T("REG_LINK"),                         // 6
        _T("REG_MULTI_SZ"),                     // 7
        _T("REG_RESOURCE_LIST"),                // 8
        _T("REG_FULL_RESOURCE_DESCRIPTOR"),     // 9
        _T("REG_RESOURCE_REQUIREMENTS_LIST"),   // 10
        _T("REG_QWORD")                         // 11
        };
    if (type <= REG_QWORD) return RegVType[ type ];

    static __thread_local TCHAR sbuf[ 16 ];
    _stprintf_s( sbuf, dimof(sbuf), _T("REG_0x%lX"), type );
    return sbuf; // User type
}

CSTR RegValueName( CSTR name )
{
    if (!name) name = _T("(null)");
    else if (!*name) name = _T("(default)");
    return name;
}

//-----------------------------------------------------------------------------
// EOF