// // REGKNODE.C // // Copyright (C) Microsoft Corporation, 1995 // #include "pch.h" DECLARE_DEBUG_COUNT(g_RgKeynodeLockCount); #define HAS_COMPACT_KEYNODES(lpfi) ((lpfi)-> Flags & FI_VERSION20) #define SIZEOF_KEYNODE_BLOCK(lpfi) \ ((HAS_COMPACT_KEYNODES(lpfi)) ? sizeof(KEYNODE_BLOCK) : sizeof(W95KEYNODE_BLOCK)) #define SIZEOF_FILE_KEYNODE(lpfi) \ ((HAS_COMPACT_KEYNODES(lpfi)) ? sizeof(KEYNODE) : sizeof(W95KEYNODE)) #define ROUND_UP(i, basesize) (((((i) + (basesize) - 1) / (basesize))) * (basesize)) #define BLOCK_DESC_GROW_SIZE 0x400 #define W95KEYNODES_PER_PAGE (PAGESIZE / sizeof(W95KEYNODE)) typedef BOOL (INTERNAL *LPPROCESSKEYNODEPROC)(LPKEYNODE, LPW95KEYNODE); // // RgOffsetToIndex // DWORD INTERNAL RgOffsetToIndex( DWORD W95KeynodeOffset ) { return (W95KeynodeOffset == REG_NULL) ? W95KeynodeOffset : (W95KeynodeOffset / sizeof(W95KEYNODE)); } // // RgIndexToOffset // DWORD INTERNAL RgIndexToOffset( DWORD KeynodeIndex ) { if (IsNullKeynodeIndex(KeynodeIndex)) return REG_NULL; else { if (KeynodeIndex >= 2 * W95KEYNODES_PER_PAGE) { DWORD dwUnroundedOff = (KeynodeIndex * sizeof(W95KEYNODE)) + sizeof(W95KEYNODE)-1; DWORD dwRoundPage = ((dwUnroundedOff & PAGEMASK) / sizeof(W95KEYNODE)) * sizeof(W95KEYNODE); return((dwUnroundedOff & ~PAGEMASK) + dwRoundPage); } else { return(((KeynodeIndex-1)*sizeof(W95KEYNODE))+sizeof(KEYNODE_HEADER)); } } } // // RgPackKeynode // // Packs the data from the provided W95KEYNODE to the KEYNODE structure. // BOOL INTERNAL RgPackKeynode( LPKEYNODE lpKeynode, LPW95KEYNODE lpW95Keynode ) { lpKeynode->Flags = 0; // Don't use a switch statement here. Apparently the compiler will treat // lpW95Keynode->W95State as an integer, so the 16-bit compiler ends up truncating // the value. if (lpW95Keynode->W95State == KNS_USED || lpW95Keynode->W95State == KNS_BIGUSED || lpW95Keynode->W95State == KNS_BIGUSEDEXT) { lpKeynode->Flags = KNF_INUSE; lpKeynode->ParentIndex = RgOffsetToIndex(lpW95Keynode->W95ParentOffset); lpKeynode->NextIndex = RgOffsetToIndex(lpW95Keynode->W95NextOffset); lpKeynode->ChildIndex = RgOffsetToIndex(lpW95Keynode->W95ChildOffset); lpKeynode->KeyRecordIndex = LOWORD(lpW95Keynode->W95DatablockAddress); lpKeynode->BlockIndex = HIWORD(lpW95Keynode->W95DatablockAddress); lpKeynode->Hash = (WORD)lpW95Keynode->W95Hash; if (lpW95Keynode->W95State == KNS_BIGUSED) lpKeynode->Flags |= KNF_BIGKEYROOT; else if (lpW95Keynode->W95State == KNS_BIGUSEDEXT) lpKeynode->Flags |= KNF_BIGKEYEXT; } else if (lpW95Keynode->W95State == KNS_FREE || lpW95Keynode->W95State == KNS_ALLFREE) { lpKeynode->FreeRecordSize = lpW95Keynode->W95FreeRecordSize; lpKeynode->NextIndex = RgOffsetToIndex(lpW95Keynode->W95NextFreeOffset); // Review this later. Previous versions of this code checked // if the next index was REG_NULL and bailed out of the processing // loop. It's possible to have a registry with a free keynode sitting // in the middle of some keynode block and that keynode is the last // in the chain. We don't want to bail out in those cases. // // For now, just bail out if the free record size is greater than a // couple keynodes indicating that this is probably the last free // record and the last record of the keynode. if (lpKeynode-> FreeRecordSize > (sizeof(W95KEYNODE)*2)) return TRUE; } else { DEBUG_OUT(("RgPackKeynode: Unrecognized state (%lx)\n", lpW95Keynode-> W95State)); } return FALSE; } // // RgUnpackKeynode // // Unpacks the data from the provided KEYNODE to the W95KEYNODE structure. // BOOL INTERNAL RgUnpackKeynode( LPKEYNODE lpKeynode, LPW95KEYNODE lpW95Keynode ) { if (lpKeynode->Flags & KNF_INUSE) { if (lpKeynode->Flags & KNF_BIGKEYROOT) lpW95Keynode->W95State = KNS_BIGUSED; else if (lpKeynode->Flags & KNF_BIGKEYEXT) lpW95Keynode->W95State = KNS_BIGUSEDEXT; else lpW95Keynode->W95State = KNS_USED; lpW95Keynode->W95ParentOffset = RgIndexToOffset(lpKeynode->ParentIndex); lpW95Keynode->W95NextOffset = RgIndexToOffset(lpKeynode->NextIndex); lpW95Keynode->W95ChildOffset = RgIndexToOffset(lpKeynode->ChildIndex); lpW95Keynode->W95Hash = lpKeynode->Hash; // Handle Win95 registries that don't have a key record for the root // key. The datablock address must be REG_NULL for Win95 to work. lpW95Keynode->W95DatablockAddress = IsNullBlockIndex(lpKeynode-> BlockIndex) ? REG_NULL : MAKELONG(lpKeynode-> KeyRecordIndex, lpKeynode-> BlockIndex); } else { lpW95Keynode->W95State = KNS_FREE; lpW95Keynode->W95FreeRecordSize = lpKeynode->FreeRecordSize; lpW95Keynode->W95NextFreeOffset = RgIndexToOffset(lpKeynode->NextIndex); } return FALSE; } // // RgProcessKeynodeBlock // // The provided callback function is called for each pair of KEYNODE and // W95KEYNODE structures from the given keynode blocks. // VOID INTERNAL RgProcessKeynodeBlock( DWORD dwStartOffset, DWORD dwBlockSize, LPKEYNODE_BLOCK lpKeynodeBlock, LPW95KEYNODE_BLOCK lpW95KeynodeBlock, LPPROCESSKEYNODEPROC lpfnProcessKeynode ) { DWORD dwCurOffset; LPKEYNODE lpKeynode; LPW95KEYNODE lpW95Keynode; UINT SkipSize; dwCurOffset = dwStartOffset; lpW95Keynode = &lpW95KeynodeBlock->aW95KN[0]; SkipSize = (dwStartOffset == 0) ? sizeof(KEYNODE_HEADER) : 0; for (;;) { lpW95Keynode = (LPW95KEYNODE)(((LPBYTE)lpW95Keynode)+SkipSize); dwCurOffset += SkipSize; if (dwCurOffset >= dwStartOffset+dwBlockSize) { goto Done; } lpKeynode = &lpKeynodeBlock->aKN[KN_INDEX_IN_BLOCK(RgOffsetToIndex(dwCurOffset))]; while ((dwCurOffset < dwStartOffset+dwBlockSize) && ((dwCurOffset >> PAGESHIFT) == 0) || ((dwCurOffset >> PAGESHIFT) == ((dwCurOffset + sizeof(W95KEYNODE)) >> PAGESHIFT))) { if (lpfnProcessKeynode(lpKeynode, lpW95Keynode)) { goto Done; } dwCurOffset += sizeof(W95KEYNODE); lpW95Keynode++; lpKeynode++; } // // Compute the number of bytes to skip to get to the next page // SkipSize = PAGESIZE - (UINT) (dwCurOffset & PAGEMASK); } Done: {}; } // // RgLockKeynode // int INTERNAL RgLockKeynode( LPFILE_INFO lpFileInfo, DWORD KeynodeIndex, LPKEYNODE FAR* lplpKeynode ) { int ErrorCode; UINT KeynodeBlockIndex; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; UINT KeynodeBlockSize; HFILE hFile; LPKEYNODE_BLOCK lpKeynodeBlock; LPW95KEYNODE_BLOCK lpW95KeynodeBlock; DWORD BlockOffset; UINT ReadBlockSize; KeynodeBlockIndex = KN_BLOCK_NUMBER(KeynodeIndex); if (KeynodeBlockIndex > lpFileInfo-> KeynodeBlockCount) { DEBUG_OUT(("RgLockKeynode: invalid keynode offset\n")); return ERROR_BADDB; } // // Is the keynode block currently in memory? // lpKeynodeBlockInfo = RgIndexKeynodeBlockInfoPtr(lpFileInfo, KeynodeBlockIndex); lpKeynodeBlock = lpKeynodeBlockInfo-> lpKeynodeBlock; if (IsNullPtr(lpKeynodeBlock)) { NOISE(("RgLockKeynode: ")); NOISE((lpFileInfo-> FileName)); NOISE((", block %d\n", KeynodeBlockIndex)); if (IsNullPtr((lpKeynodeBlock = (LPKEYNODE_BLOCK) RgAllocMemory(sizeof(KEYNODE_BLOCK))))) return ERROR_OUTOFMEMORY; KeynodeBlockSize = SIZEOF_KEYNODE_BLOCK(lpFileInfo); BlockOffset = (DWORD) KeynodeBlockIndex * KeynodeBlockSize; if (BlockOffset < lpFileInfo-> KeynodeHeader.FileKnSize) { ASSERT(!(lpFileInfo-> Flags & FI_VOLATILE)); ReadBlockSize = (UINT) min(KeynodeBlockSize, (lpFileInfo-> KeynodeHeader.FileKnSize - BlockOffset)); if ((hFile = RgOpenFile(lpFileInfo-> FileName, OF_READ)) == HFILE_ERROR) goto CleanupAfterFileError; if (HAS_COMPACT_KEYNODES(lpFileInfo)) { if (!RgSeekFile(hFile, sizeof(VERSION20_HEADER_PAGE) + BlockOffset)) goto CleanupAfterFileError; if (!RgReadFile(hFile, lpKeynodeBlock, ReadBlockSize)) goto CleanupAfterFileError; } else { if (!RgSeekFile(hFile, sizeof(FILE_HEADER) + BlockOffset)) goto CleanupAfterFileError; lpW95KeynodeBlock = (LPW95KEYNODE_BLOCK) RgLockWorkBuffer(); if (!RgReadFile(hFile, lpW95KeynodeBlock, ReadBlockSize)) { RgUnlockWorkBuffer(lpW95KeynodeBlock); goto CleanupAfterFileError; } RgProcessKeynodeBlock(BlockOffset, ReadBlockSize, lpKeynodeBlock, lpW95KeynodeBlock, RgPackKeynode); RgUnlockWorkBuffer(lpW95KeynodeBlock); } RgCloseFile(hFile); } lpKeynodeBlockInfo-> lpKeynodeBlock = lpKeynodeBlock; lpKeynodeBlockInfo-> Flags = 0; lpKeynodeBlockInfo-> LockCount = 0; } *lplpKeynode = &lpKeynodeBlock-> aKN[KN_INDEX_IN_BLOCK(KeynodeIndex)]; lpKeynodeBlockInfo-> Flags |= KBIF_ACCESSED; lpKeynodeBlockInfo-> LockCount++; INCREMENT_DEBUG_COUNT(g_RgKeynodeLockCount); return ERROR_SUCCESS; CleanupAfterFileError: ErrorCode = ERROR_REGISTRY_IO_FAILED; RgFreeMemory(lpKeynodeBlock); if (hFile != HFILE_ERROR) RgCloseFile(hFile); DEBUG_OUT(("RgLockKeynode() returning error %d\n", ErrorCode)); return ErrorCode; } // // RgLockInUseKeynode // // Wrapper for RgLockKeynode that guarantees that the returned keynode is // marked as being in-use. If not, ERROR_BADDB is returned. // int INTERNAL RgLockInUseKeynode( LPFILE_INFO lpFileInfo, DWORD KeynodeIndex, LPKEYNODE FAR* lplpKeynode ) { int ErrorCode; if ((ErrorCode = RgLockKeynode(lpFileInfo, KeynodeIndex, lplpKeynode)) == ERROR_SUCCESS) { if (!((*lplpKeynode)-> Flags & KNF_INUSE)) { DEBUG_OUT(("RgLockInUseKeynode: keynode unexpectedly not marked used\n")); RgUnlockKeynode(lpFileInfo, KeynodeIndex, FALSE); ErrorCode = ERROR_BADDB; } } return ErrorCode; } // // RgUnlockKeynode // VOID INTERNAL RgUnlockKeynode( LPFILE_INFO lpFileInfo, DWORD KeynodeIndex, BOOL fMarkDirty ) { UINT KeynodeBlockIndex; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; KeynodeBlockIndex = KN_BLOCK_NUMBER(KeynodeIndex); ASSERT(KeynodeBlockIndex < lpFileInfo-> KeynodeBlockCount); lpKeynodeBlockInfo = RgIndexKeynodeBlockInfoPtr(lpFileInfo, KeynodeBlockIndex); ASSERT(lpKeynodeBlockInfo-> LockCount > 0); lpKeynodeBlockInfo-> LockCount--; if (fMarkDirty) { lpKeynodeBlockInfo-> Flags |= KBIF_DIRTY; lpFileInfo-> Flags |= FI_DIRTY | FI_KEYNODEDIRTY; RgDelayFlush(); } DECREMENT_DEBUG_COUNT(g_RgKeynodeLockCount); } // // RgAllocKeynode // int INTERNAL RgAllocKeynode( LPFILE_INFO lpFileInfo, LPDWORD lpKeynodeIndex, LPKEYNODE FAR* lplpKeynode ) { int ErrorCode; DWORD FreeKeynodeOffset; DWORD FreeKeynodeIndex; UINT FreeRecordSize; UINT ExtraPadding; UINT KeynodeBlockIndex; UINT AllocCount; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; LPKEYNODE lpKeynode; DWORD NextFreeKeynodeIndex; LPKEYNODE lpNextFreeKeynode; UINT KeynodeSize; FreeKeynodeIndex = lpFileInfo-> KeynodeHeader.FirstFreeIndex; // If no more free keynodes exist, then we try to extend the keynode table // to provide more entries. if (IsNullKeynodeIndex(FreeKeynodeIndex)) { if (HAS_COMPACT_KEYNODES(lpFileInfo)) { FreeKeynodeIndex = ROUND_UP(lpFileInfo-> CurTotalKnSize, PAGESIZE) / sizeof(KEYNODE); FreeRecordSize = PAGESIZE; ExtraPadding = 0; } else { // Handle the special case of a new file being created: for // uncompacted keynode tables, the first offset is immediately // after the keynode header and the size of the free record must // account for the size of this header. if (lpFileInfo-> CurTotalKnSize == sizeof(KEYNODE_HEADER)) { FreeKeynodeOffset = sizeof(KEYNODE_HEADER); // Win95 compatiblity: Same initial table size, plus // causes us to stress the below special grow case. FreeRecordSize = PAGESIZE - sizeof(KEYNODE_HEADER) * 2; ExtraPadding = 0; } else { FreeKeynodeOffset = ROUND_UP(lpFileInfo-> CurTotalKnSize, PAGESIZE); FreeRecordSize = PAGESIZE; ExtraPadding = (UINT) (FreeKeynodeOffset - lpFileInfo-> CurTotalKnSize); // Handle the case of a keynode table with a non-integral // number of pages. We'll place the new free keynode at the // top of the existing keynode table with a size including // the remaining bytes on the page plus a new page (effectively // the same as Win95). if (ExtraPadding > sizeof(W95KEYNODE) || FreeKeynodeOffset == PAGESIZE) { // Although this code will work for any non-integral // number of pages, it should ONLY occur for <4K tables. ASSERT(FreeKeynodeOffset == PAGESIZE); FreeRecordSize += ExtraPadding; FreeKeynodeOffset = lpFileInfo-> CurTotalKnSize; ExtraPadding = 0; } } FreeKeynodeIndex = RgOffsetToIndex(FreeKeynodeOffset); } KeynodeBlockIndex = KN_BLOCK_NUMBER(FreeKeynodeIndex); // Put in some sort of "max" count/KEYNODE_BLOCKS_PER_FILE // check. // Check if lpKeynodeBlockInfo is too small to hold the info for a new // keynode block. If so, then we must grow it a bit. if (KeynodeBlockIndex >= lpFileInfo-> KeynodeBlockInfoAllocCount) { AllocCount = KeynodeBlockIndex + KEYNODE_BLOCK_INFO_SLACK_ALLOC; if (IsNullPtr((lpKeynodeBlockInfo = (LPKEYNODE_BLOCK_INFO) RgSmReAllocMemory(lpFileInfo-> lpKeynodeBlockInfo, AllocCount * sizeof(KEYNODE_BLOCK_INFO))))) return ERROR_OUTOFMEMORY; ZeroMemory(lpKeynodeBlockInfo + lpFileInfo-> KeynodeBlockInfoAllocCount, (AllocCount - lpFileInfo-> KeynodeBlockInfoAllocCount) * sizeof(KEYNODE_BLOCK_INFO)); lpFileInfo-> lpKeynodeBlockInfo = lpKeynodeBlockInfo; lpFileInfo-> KeynodeBlockInfoAllocCount = AllocCount; } if (KeynodeBlockIndex < lpFileInfo-> KeynodeBlockCount) { lpFileInfo-> CurTotalKnSize += (FreeRecordSize + ExtraPadding); lpFileInfo-> Flags |= FI_EXTENDED; lpFileInfo-> KeynodeHeader.FirstFreeIndex = FreeKeynodeIndex; } if ((ErrorCode = RgLockKeynode(lpFileInfo, FreeKeynodeIndex, &lpKeynode)) != ERROR_SUCCESS) return ErrorCode; if (KeynodeBlockIndex >= lpFileInfo-> KeynodeBlockCount) { lpFileInfo-> KeynodeBlockCount = KeynodeBlockIndex + 1; lpFileInfo-> CurTotalKnSize += (FreeRecordSize + ExtraPadding); lpFileInfo-> Flags |= FI_EXTENDED; lpFileInfo-> KeynodeHeader.FirstFreeIndex = FreeKeynodeIndex; } lpKeynode-> NextIndex = REG_NULL; lpKeynode-> Flags = 0; lpKeynode-> FreeRecordSize = FreeRecordSize; } else { if ((ErrorCode = RgLockKeynode(lpFileInfo, FreeKeynodeIndex, &lpKeynode)) != ERROR_SUCCESS) return ErrorCode; } NextFreeKeynodeIndex = lpKeynode-> NextIndex; KeynodeSize = SIZEOF_FILE_KEYNODE(lpFileInfo); // If the free keynode record can be broken up into smaller chunks, then // create another free record immediately after the one we're about to // snag. if ((lpKeynode-> FreeRecordSize >= KeynodeSize * 2) && (RgLockKeynode(lpFileInfo, FreeKeynodeIndex + 1, &lpNextFreeKeynode) == ERROR_SUCCESS)) { // Copy the next link from the current free keynode (likely REG_NULL). lpNextFreeKeynode-> NextIndex = NextFreeKeynodeIndex; lpNextFreeKeynode-> Flags = 0; lpNextFreeKeynode-> FreeRecordSize = lpKeynode-> FreeRecordSize - KeynodeSize; NextFreeKeynodeIndex = FreeKeynodeIndex + 1; RgUnlockKeynode(lpFileInfo, NextFreeKeynodeIndex, TRUE); } lpFileInfo-> KeynodeHeader.FirstFreeIndex = NextFreeKeynodeIndex; lpKeynode-> Flags |= KNF_INUSE; // Mark the keynode block that holds this keynode dirty. lpKeynodeBlockInfo = RgIndexKeynodeBlockInfoPtr(lpFileInfo, KN_BLOCK_NUMBER(FreeKeynodeIndex)); lpKeynodeBlockInfo-> Flags |= KBIF_DIRTY; lpFileInfo-> Flags |= FI_DIRTY | FI_KEYNODEDIRTY; RgDelayFlush(); // WARNING: The following two statements used to be above the block that // dirtied the keynode. The 16-bit compiler messed up and // lpKeynodeBlockInfo ended up with a bogus offset thus corrupting random // memory. Be sure to trace through this function if you change it! *lpKeynodeIndex = FreeKeynodeIndex; *lplpKeynode = lpKeynode; return ERROR_SUCCESS; } // // RgFreeKeynode // // Marks the specified keynode index free and adds it to the hive's free // keynode list. // int INTERNAL RgFreeKeynode( LPFILE_INFO lpFileInfo, DWORD KeynodeIndex ) { int ErrorCode; LPKEYNODE lpKeynode; if ((ErrorCode = RgLockKeynode(lpFileInfo, KeynodeIndex, &lpKeynode)) == ERROR_SUCCESS) { lpKeynode-> Flags &= ~(KNF_INUSE | KNF_BIGKEYROOT | KNF_BIGKEYEXT); lpKeynode-> NextIndex = lpFileInfo-> KeynodeHeader.FirstFreeIndex; lpKeynode-> FreeRecordSize = SIZEOF_FILE_KEYNODE(lpFileInfo); lpFileInfo-> KeynodeHeader.FirstFreeIndex = KeynodeIndex; RgUnlockKeynode(lpFileInfo, KeynodeIndex, TRUE); } return ErrorCode; } // // RgGetKnBlockIOInfo // VOID INTERNAL RgGetKnBlockIOInfo( LPFILE_INFO lpFileInfo, DWORD BaseKeynodeIndex, UINT FAR* lpFileBlockSize, LONG FAR* lpFileOffset ) { UINT FileBlockSize; DWORD FileOffset; DWORD BaseKeynodeOffset; if (HAS_COMPACT_KEYNODES(lpFileInfo)) { FileBlockSize = sizeof(KEYNODE_BLOCK); BaseKeynodeOffset = BaseKeynodeIndex * sizeof(KEYNODE); if (BaseKeynodeOffset + FileBlockSize > lpFileInfo-> CurTotalKnSize) FileBlockSize = (UINT) (lpFileInfo-> CurTotalKnSize - BaseKeynodeOffset); FileOffset = sizeof(VERSION20_HEADER_PAGE) + BaseKeynodeIndex * sizeof(KEYNODE); } else { FileBlockSize = sizeof(W95KEYNODE_BLOCK); // The first keynode block of an uncompacted keynode table should // start writing AFTER the keynode header. if (BaseKeynodeIndex == 0) { BaseKeynodeIndex = RgOffsetToIndex(sizeof(KEYNODE_HEADER)); FileBlockSize -= sizeof(KEYNODE_HEADER); } BaseKeynodeOffset = RgIndexToOffset(BaseKeynodeIndex); if (BaseKeynodeOffset + FileBlockSize > lpFileInfo-> CurTotalKnSize) FileBlockSize = (UINT) (lpFileInfo-> CurTotalKnSize - BaseKeynodeOffset); FileOffset = sizeof(FILE_HEADER) + BaseKeynodeOffset; } *lpFileBlockSize = FileBlockSize; *lpFileOffset = FileOffset; } int _inline RgCopyKeynodeBlock( LPFILE_INFO lpFileInfo, DWORD BaseIndex, HFILE hSrcFile, HFILE hDestFile ) { UINT FileBlockSize; LONG FileOffset; RgGetKnBlockIOInfo(lpFileInfo, BaseIndex, &FileBlockSize, &FileOffset); return RgCopyFileBytes(hSrcFile, FileOffset, hDestFile, FileOffset, FileBlockSize); } // // RgWriteKeynodeBlock // int INTERNAL RgWriteKeynodeBlock( LPFILE_INFO lpFileInfo, DWORD BaseIndex, HFILE hDestFile, LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo ) { int ErrorCode; UINT FileBlockSize; LONG FileOffset; LPW95KEYNODE_BLOCK lpW95KeynodeBlock; RgGetKnBlockIOInfo(lpFileInfo, BaseIndex, &FileBlockSize, &FileOffset); ErrorCode = ERROR_REGISTRY_IO_FAILED; // Assume I/O fails if (!RgSeekFile(hDestFile, FileOffset)) { goto Exit; } if (HAS_COMPACT_KEYNODES(lpFileInfo)) { if (RgWriteFile(hDestFile, lpKeynodeBlockInfo->lpKeynodeBlock, FileBlockSize)) { ErrorCode = ERROR_SUCCESS; } } else { LPBYTE lpWriteBlock; lpW95KeynodeBlock = (LPW95KEYNODE_BLOCK) RgLockWorkBuffer(); RgProcessKeynodeBlock( BaseIndex * sizeof(W95KEYNODE), FileBlockSize, lpKeynodeBlockInfo->lpKeynodeBlock, lpW95KeynodeBlock, RgUnpackKeynode); lpWriteBlock = (LPBYTE)lpW95KeynodeBlock; if (BaseIndex == 0) { lpWriteBlock += sizeof(KEYNODE_HEADER); } if (RgWriteFile(hDestFile, lpWriteBlock, FileBlockSize)) { ErrorCode = ERROR_SUCCESS; } RgUnlockWorkBuffer(lpW95KeynodeBlock); } Exit: ; return(ErrorCode); } // // RgWriteKeynodes // int INTERNAL RgWriteKeynodes( LPFILE_INFO lpFileInfo, HFILE hSrcFile, HFILE hDestFile ) { DWORD SavedRootIndex; DWORD SavedFreeIndex; DWORD SavedFileKnSize; BOOL fResult; UINT KeynodeBlockIndex; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; if ((hSrcFile == HFILE_ERROR) && !(lpFileInfo->Flags & FI_KEYNODEDIRTY)) return ERROR_SUCCESS; NOISE(("writing keynodes of ")); NOISE((lpFileInfo-> FileName)); NOISE(("\n")); // // Write out the keynode header. If the keynodes are not compact then // convert to offsets before writing. // if (!RgSeekFile(hDestFile, sizeof(FILE_HEADER))) return ERROR_REGISTRY_IO_FAILED; SavedFileKnSize = lpFileInfo-> KeynodeHeader.FileKnSize; SavedRootIndex = lpFileInfo-> KeynodeHeader.RootIndex; SavedFreeIndex = lpFileInfo-> KeynodeHeader.FirstFreeIndex; // Write the real size of the keynode table to disk. lpFileInfo-> KeynodeHeader.FileKnSize = lpFileInfo-> CurTotalKnSize; // Convert keynode indexes back to offsets temporarily for uncompacted // keynode tables. if (!HAS_COMPACT_KEYNODES(lpFileInfo)) { lpFileInfo-> KeynodeHeader.RootIndex = RgIndexToOffset(lpFileInfo-> KeynodeHeader.RootIndex); lpFileInfo-> KeynodeHeader.FirstFreeIndex = RgIndexToOffset(lpFileInfo-> KeynodeHeader.FirstFreeIndex); } fResult = RgWriteFile(hDestFile, &lpFileInfo-> KeynodeHeader, sizeof(KEYNODE_HEADER)); lpFileInfo-> KeynodeHeader.FileKnSize = SavedFileKnSize; lpFileInfo-> KeynodeHeader.RootIndex = SavedRootIndex; lpFileInfo-> KeynodeHeader.FirstFreeIndex = SavedFreeIndex; if (!fResult) return ERROR_REGISTRY_IO_FAILED; // // Now loop through each block. // lpKeynodeBlockInfo = lpFileInfo-> lpKeynodeBlockInfo; for (KeynodeBlockIndex = 0; KeynodeBlockIndex < lpFileInfo-> KeynodeBlockCount; KeynodeBlockIndex++, lpKeynodeBlockInfo++) { DWORD BaseKeynodeIndex = KeynodeBlockIndex * KEYNODES_PER_BLOCK; if (!IsNullPtr(lpKeynodeBlockInfo-> lpKeynodeBlock)) { if (hSrcFile != HFILE_ERROR || lpKeynodeBlockInfo-> Flags & KBIF_DIRTY) { if (RgWriteKeynodeBlock(lpFileInfo, BaseKeynodeIndex, hDestFile, lpKeynodeBlockInfo) != ERROR_SUCCESS) return ERROR_REGISTRY_IO_FAILED; } } else { if (hSrcFile != HFILE_ERROR) { if (RgCopyKeynodeBlock(lpFileInfo, BaseKeynodeIndex, hSrcFile, hDestFile) != ERROR_SUCCESS) return ERROR_REGISTRY_IO_FAILED; } } } return ERROR_SUCCESS; } // // RgWriteKeynodesComplete // // Called after a file has been successfully written. We can now safely clear // all dirty flags and update our state information with the knowledge that // the file is in a consistent state. // VOID INTERNAL RgWriteKeynodesComplete( LPFILE_INFO lpFileInfo ) { UINT BlocksLeft; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; lpFileInfo-> Flags &= ~FI_KEYNODEDIRTY; lpFileInfo-> KeynodeHeader.FileKnSize = lpFileInfo-> CurTotalKnSize; for (BlocksLeft = lpFileInfo-> KeynodeBlockCount, lpKeynodeBlockInfo = lpFileInfo-> lpKeynodeBlockInfo; BlocksLeft > 0; BlocksLeft--, lpKeynodeBlockInfo++) lpKeynodeBlockInfo-> Flags &= ~KBIF_DIRTY; } // // RgSweepKeynodes // // Makes a pass through all the present keynode blocks of the given FILE_INFO // structure and discards keynode blocks that have not been accessed since the // last sweep. // VOID INTERNAL RgSweepKeynodes( LPFILE_INFO lpFileInfo ) { UINT BlocksLeft; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; for (BlocksLeft = lpFileInfo-> KeynodeBlockCount, lpKeynodeBlockInfo = lpFileInfo-> lpKeynodeBlockInfo; BlocksLeft > 0; BlocksLeft--, lpKeynodeBlockInfo++) { if (!IsNullPtr(lpKeynodeBlockInfo-> lpKeynodeBlock)) { if (((lpKeynodeBlockInfo-> Flags & (KBIF_ACCESSED | KBIF_DIRTY)) == 0) && (lpKeynodeBlockInfo-> LockCount == 0)) { RgFreeMemory(lpKeynodeBlockInfo-> lpKeynodeBlock); lpKeynodeBlockInfo-> lpKeynodeBlock = NULL; } lpKeynodeBlockInfo-> Flags &= ~KBIF_ACCESSED; } } } #ifdef VXD #pragma VxD_RARE_CODE_SEG #endif // // RgInitKeynodeInfo // // Initializes fields in the provided FILE_INFO related to the keynode table. // int INTERNAL RgInitKeynodeInfo( LPFILE_INFO lpFileInfo ) { UINT KeynodeBlockSize; UINT BlockCount; UINT AllocCount; LPKEYNODE_BLOCK_INFO lpKeynodeBlockInfo; KeynodeBlockSize = SIZEOF_KEYNODE_BLOCK(lpFileInfo); BlockCount = (UINT) ((DWORD) (lpFileInfo-> KeynodeHeader.FileKnSize + KeynodeBlockSize - 1) / (DWORD) KeynodeBlockSize); AllocCount = BlockCount + KEYNODE_BLOCK_INFO_SLACK_ALLOC; if (IsNullPtr((lpKeynodeBlockInfo = (LPKEYNODE_BLOCK_INFO) RgSmAllocMemory(AllocCount * sizeof(KEYNODE_BLOCK_INFO))))) return ERROR_OUTOFMEMORY; ZeroMemory(lpKeynodeBlockInfo, AllocCount * sizeof(KEYNODE_BLOCK_INFO)); lpFileInfo-> lpKeynodeBlockInfo = lpKeynodeBlockInfo; lpFileInfo-> KeynodeBlockCount = BlockCount; lpFileInfo-> KeynodeBlockInfoAllocCount = AllocCount; lpFileInfo-> KeynodeHeader.Flags &= ~(KHF_DIRTY | KHF_EXTENDED | KHF_HASCHECKSUM); // Convert file offsets to index values for uncompressed files if (!HAS_COMPACT_KEYNODES(lpFileInfo)) { lpFileInfo-> KeynodeHeader.RootIndex = RgOffsetToIndex(lpFileInfo-> KeynodeHeader.RootIndex); lpFileInfo-> KeynodeHeader.FirstFreeIndex = RgOffsetToIndex(lpFileInfo-> KeynodeHeader.FirstFreeIndex); } lpFileInfo-> CurTotalKnSize = lpFileInfo-> KeynodeHeader.FileKnSize; return ERROR_SUCCESS; }