* PURPOSE: Configuration Manager - Internal Registry APIs
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
* Eric Kohl
+ * Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
*/
/* INCLUDES ******************************************************************/
/* Same file found */
Loaded = TRUE;
*CmHive = Hive;
-
+
/* If the hive is frozen, not sure what to do */
if (Hive->Frozen)
{
ObDereferenceObject(KeyBody);
return Loaded;
}
-
+
BOOLEAN
NTAPI
CmpDoFlushAll(IN BOOLEAN ForceFlush)
{
/* Acquire the flusher lock */
CmpLockHiveFlusherExclusive(Hive);
-
+
/* Check for illegal state */
if ((ForceFlush) && (Hive->UseCount))
{
DPRINT1("FIXME: Hive is damaged and needs fixup\n");
while (TRUE);
}
-
+
/* Only sync if we are forced to or if it won't cause a hive shrink */
if ((ForceFlush) || (!HvHiveWillShrink(&Hive->Hive)))
{
CellData->u.KeyValue.DataLength = DataSize + CM_KEY_VALUE_SPECIAL_SIZE;
CellData->u.KeyValue.Data = SmallData;
}
-
+
/* Set the type now */
CellData->u.KeyValue.Type = Type;
PCELL_DATA CellData;
ULONG Length;
BOOLEAN WasSmall, IsSmall;
-
+
/* Registry writes must be blocked */
CMP_ASSERT_FLUSH_LOCK(Hive);
Value->Type = Type;
return STATUS_SUCCESS;
}
-
+
/* We have a normal key. Was the old cell also normal and had data? */
if (!(WasSmall) && (Length > 0))
{
IN OUT PULONG ResultLength)
{
NTSTATUS Status;
- ULONG Size, SizeLeft, MinimumSize;
+ ULONG Size, SizeLeft, MinimumSize, Offset;
PKEY_INFORMATION Info = (PKEY_INFORMATION)KeyInformation;
USHORT NameLength;
+ PVOID ClassData;
/* Check if the value is compressed */
if (Node->Flags & KEY_COMP_NAME)
/* Check if the node has a class */
if (Node->ClassLength > 0)
{
- /* It does. We don't support these yet */
- ASSERTMSG("Classes not supported\n", FALSE);
+ /* Set the class offset */
+ Offset = FIELD_OFFSET(KEY_NODE_INFORMATION, Name) + NameLength;
+ Offset = ALIGN_UP_BY(Offset, sizeof(ULONG));
+ Info->KeyNodeInformation.ClassOffset = Offset;
+
+ /* Get the class data */
+ ClassData = HvGetCell(Hive, Node->Class);
+ if (ClassData == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ break;
+ }
+
+ /* Check if we can copy anything */
+ if (Length > Offset)
+ {
+ /* Copy the class data */
+ RtlCopyMemory((PUCHAR)Info + Offset,
+ ClassData,
+ min(Node->ClassLength, Length - Offset));
+ }
+
+ /* Check if the buffer was large enough */
+ if (Length < Offset + Node->ClassLength)
+ {
+ Status = STATUS_BUFFER_OVERFLOW;
+ }
+
+ /* Release the class cell */
+ HvReleaseCell(Hive, Node->Class);
}
else
{
/* Check if we have a class */
if (Node->ClassLength > 0)
{
- /* We do, but we currently don't support this */
- ASSERTMSG("Classes not supported\n", FALSE);
+ /* Set the class offset */
+ Offset = FIELD_OFFSET(KEY_FULL_INFORMATION, Class);
+ Info->KeyFullInformation.ClassOffset = Offset;
+
+ /* Get the class data */
+ ClassData = HvGetCell(Hive, Node->Class);
+ if (ClassData == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ break;
+ }
+
+ /* Copy the class data */
+ NT_ASSERT(Length > Offset);
+ RtlCopyMemory(Info->KeyFullInformation.Class,
+ ClassData,
+ min(Node->ClassLength, Length - Offset));
+
+ /* Check if the buffer was large enough */
+ if (Length < Offset + Node->ClassLength)
+ {
+ Status = STATUS_BUFFER_OVERFLOW;
+ }
+
+ /* Release the class cell */
+ HvReleaseCell(Hive, Node->Class);
}
else
{
/* We don't have a class, so set offset to -1, not 0! */
- Info->KeyNodeInformation.ClassOffset = 0xFFFFFFFF;
+ Info->KeyFullInformation.ClassOffset = 0xFFFFFFFF;
}
break;
/* Acquire hive and KCB lock */
CmpLockRegistry();
CmpAcquireKcbLockShared(Kcb);
-
+
/* Sanity check */
ASSERT(sizeof(ULONG) == CM_KEY_VALUE_SMALL);
-
+
/* Don't touch deleted KCBs */
DoAgain:
if (Kcb->Delete)
Status = STATUS_KEY_DELETED;
goto Quickie;
}
-
+
/* Don't let anyone mess with symlinks */
if ((Kcb->Flags & KEY_SYM_LINK) &&
((Type != REG_LINK) ||
/* Acquire exclusive lock */
CmpConvertKcbSharedToExclusive(Kcb);
}
-
+
/* Cache lookup failed, so don't try it next time */
FirstTry = FALSE;
-
+
/* Now grab the flush lock since the key will be modified */
ASSERT(FlusherLocked == FALSE);
CmpLockHiveFlusherShared((PCMHIVE)Kcb->KeyHive);
Parent = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
ASSERT(Parent);
ParentCell = Cell;
-
+
/* Prepare to scan the key node */
Count = Parent->ValueList.Count;
Found = FALSE;
HvReleaseCell(Hive, ChildCell);
ChildCell = HCELL_NIL;
}
-
+
/* Get its value */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, CurrentChild);
if (!Value)
ChildIndex = 0;
}
}
-
+
/* Should only get here on the second pass */
ASSERT(FirstTry == FALSE);
-
+
/* The KCB must be locked exclusive at this point */
CMP_ASSERT_KCB_LOCK(Kcb);
-
+
/* Mark the cell dirty */
if (!HvMarkCellDirty(Hive, Cell, FALSE))
{
Parent->MaxValueNameLen = ValueName->Length;
Kcb->KcbMaxValueNameLen = ValueName->Length;
}
-
+
/* Check if the maximum data length changed */
ASSERT(Parent->MaxValueDataLen == Kcb->KcbMaxValueDataLen);
if (Parent->MaxValueDataLen < DataLength)
Parent->MaxValueDataLen = DataLength;
Kcb->KcbMaxValueDataLen = Parent->MaxValueDataLen;
}
-
+
/* Save the write time */
KeQuerySystemTime(&Parent->LastWriteTime);
Kcb->KcbLastWriteTime = Parent->LastWriteTime;
-
+
/* Check if the cell is cached */
if ((Found) && (CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)))
{
/* Sanity checks */
ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
-
+
/* Set the value cache */
Kcb->ValueCache.Count = Parent->ValueList.Count;
Kcb->ValueCache.ValueList = Parent->ValueList.List;
}
-
+
/* Notify registered callbacks */
CmpReportNotify(Kcb,
Hive,
Kcb->KeyCell,
REG_NOTIFY_CHANGE_LAST_SET);
}
-
+
/* Release the cells */
Quickie:
if ((ParentCell != HCELL_NIL) && (Hive)) HvReleaseCell(Hive, ParentCell);
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Lock KCB exclusively */
CmpAcquireKcbLockExclusive(Kcb);
-
+
/* Don't touch deleted keys */
if (Kcb->Delete)
{
/* Get the hive and the cell index */
Hive = Kcb->KeyHive;
Cell = Kcb->KeyCell;
-
+
/* Lock flushes */
CmpLockHiveFlusherShared((PCMHIVE)Hive);
Kcb->KcbMaxValueNameLen = 0;
Kcb->KcbMaxValueDataLen = 0;
}
-
+
/* Cleanup the value cache */
CmpCleanUpKcbValueCache(Kcb);
-
+
/* Sanity checks */
ASSERT(!(CMP_IS_CELL_CACHED(Kcb->ValueCache.ValueList)));
ASSERT(!(Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND));
-
+
/* Set the value cache */
Kcb->ValueCache.Count = ChildList->Count;
Kcb->ValueCache.ValueList = ChildList->List;
-
+
/* Notify registered callbacks */
CmpReportNotify(Kcb, Hive, Cell, REG_NOTIFY_CHANGE_LAST_SET);
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Lock the KCB shared */
CmpAcquireKcbLockShared(Kcb);
-
+
/* Don't touch deleted keys */
DoAgain:
if (Kcb->Delete)
CmpUnlockRegistry();
return STATUS_KEY_DELETED;
}
-
+
/* We don't deal with this yet */
if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND)
{
/* Check if we need an exclusive lock */
ASSERT(CellToRelease == HCELL_NIL);
ASSERT(ValueData == NULL);
-
+
/* Try with exclusive KCB lock */
CmpConvertKcbSharedToExclusive(Kcb);
goto DoAgain;
}
-
+
if (Result == SearchSuccess)
{
/* Sanity check */
ResultLength,
&Status);
if (Result == SearchNeedExclusiveLock)
- {
+ {
/* Release the value cell */
if (CellToRelease != HCELL_NIL)
{
HvReleaseCell(Hive, CellToRelease);
CellToRelease = HCELL_NIL;
}
-
+
/* Try with exclusive KCB lock */
CmpConvertKcbSharedToExclusive(Kcb);
- goto DoAgain;
+ _SEH2_YIELD(goto DoAgain);
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Lock the KCB shared */
CmpAcquireKcbLockShared(Kcb);
Kcb->ValueCache.Count = Parent->ValueList.Count;
}
- /* Make sure the index is valid */
+ /* Make sure the index is valid */
if (Index >= Kcb->ValueCache.Count)
{
/* Release the cell and fail */
Status = STATUS_NO_MORE_ENTRIES;
goto Quickie;
}
-
+
/* We don't deal with this yet */
if (Kcb->ExtFlags & CM_KCB_SYM_LINK_FOUND)
{
/* Check if we need an exclusive lock */
ASSERT(CellToRelease == HCELL_NIL);
HvReleaseCell(Hive, Kcb->KeyCell);
-
+
/* Try with exclusive KCB lock */
CmpConvertKcbSharedToExclusive(Kcb);
goto DoAgain;
Status = STATUS_INSUFFICIENT_RESOURCES;
goto Quickie;
}
-
+
/* User data, need SEH */
_SEH2_TRY
{
/* Try with exclusive KCB lock */
CmpConvertKcbSharedToExclusive(Kcb);
- goto DoAgain;
+ _SEH2_YIELD(goto DoAgain);
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
return Status;
}
+static
+NTSTATUS
+CmpQueryKeyDataFromCache(
+ _In_ PCM_KEY_CONTROL_BLOCK Kcb,
+ _Out_ PKEY_CACHED_INFORMATION KeyCachedInfo,
+ _In_ ULONG Length,
+ _Out_ PULONG ResultLength)
+{
+ PCM_KEY_NODE Node;
+ PHHIVE KeyHive;
+ HCELL_INDEX KeyCell;
+ USHORT NameLength;
+ PAGED_CODE();
+
+ /* Get the hive and cell index */
+ KeyHive = Kcb->KeyHash.KeyHive;
+ KeyCell = Kcb->KeyHash.KeyCell;
+
+#if DBG
+ /* Get the cell node */
+ Node = HvGetCell(KeyHive, KeyCell);
+ if (Node != NULL)
+ {
+ ULONG SubKeyCount;
+ ASSERT(Node->ValueList.Count == Kcb->ValueCache.Count);
+
+ if (!(Kcb->ExtFlags & CM_KCB_INVALID_CACHED_INFO))
+ {
+ SubKeyCount = Node->SubKeyCounts[0] + Node->SubKeyCounts[1];
+ if (Kcb->ExtFlags & CM_KCB_NO_SUBKEY)
+ {
+ ASSERT(SubKeyCount == 0);
+ }
+ else if (Kcb->ExtFlags & CM_KCB_SUBKEY_ONE)
+ {
+ ASSERT(SubKeyCount == 1);
+ }
+ else if (Kcb->ExtFlags & CM_KCB_SUBKEY_HINT)
+ {
+ ASSERT(SubKeyCount == Kcb->IndexHint->Count);
+ }
+ else
+ {
+ ASSERT(SubKeyCount == Kcb->SubKeyCount);
+ }
+ }
+
+ ASSERT(Node->LastWriteTime.QuadPart == Kcb->KcbLastWriteTime.QuadPart);
+ ASSERT(Node->MaxNameLen == Kcb->KcbMaxNameLen);
+ ASSERT(Node->MaxValueNameLen == Kcb->KcbMaxValueNameLen);
+ ASSERT(Node->MaxValueDataLen == Kcb->KcbMaxValueDataLen);
+
+ /* Release the cell */
+ HvReleaseCell(KeyHive, KeyCell);
+ }
+#endif // DBG
+
+ /* Make sure we have a name block */
+ if (Kcb->NameBlock == NULL)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ /* Check for compressed name */
+ if (Kcb->NameBlock->Compressed)
+ {
+ /* Calculate the name size */
+ NameLength = CmpCompressedNameSize(Kcb->NameBlock->NameHash.Name,
+ Kcb->NameBlock->NameHash.NameLength);
+ }
+ else
+ {
+ /* Use the stored name size */
+ NameLength = Kcb->NameBlock->NameHash.NameLength;
+ }
+
+ /* Validate buffer length (we do not copy the name!) */
+ *ResultLength = sizeof(*KeyCachedInfo);
+ if (Length < *ResultLength)
+ {
+ return STATUS_BUFFER_TOO_SMALL;
+ }
+
+ /* Fill the structure */
+ KeyCachedInfo->LastWriteTime = Kcb->KcbLastWriteTime;
+ KeyCachedInfo->TitleIndex = 0;
+ KeyCachedInfo->NameLength = NameLength;
+ KeyCachedInfo->Values = Kcb->ValueCache.Count;
+ KeyCachedInfo->MaxNameLen = Kcb->KcbMaxNameLen;
+ KeyCachedInfo->MaxValueNameLen = Kcb->KcbMaxValueNameLen;
+ KeyCachedInfo->MaxValueDataLen = Kcb->KcbMaxValueDataLen;
+
+ /* Check the ExtFlags for what we have */
+ if (Kcb->ExtFlags & CM_KCB_INVALID_CACHED_INFO)
+ {
+ /* Cache is not valid, do a full lookup */
+ DPRINT1("Kcb cache incoherency detected, kcb = %p\n", Kcb);
+
+ /* Get the cell node */
+ Node = HvGetCell(KeyHive, KeyCell);
+ if (Node == NULL)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ /* Calculate number of subkeys */
+ KeyCachedInfo->SubKeys = Node->SubKeyCounts[0] + Node->SubKeyCounts[1];
+
+ /* Release the cell */
+ HvReleaseCell(KeyHive, KeyCell);
+ }
+ else if (Kcb->ExtFlags & CM_KCB_NO_SUBKEY)
+ {
+ /* There are no subkeys */
+ KeyCachedInfo->SubKeys = 0;
+ }
+ else if (Kcb->ExtFlags & CM_KCB_SUBKEY_ONE)
+ {
+ /* There is exactly one subley */
+ KeyCachedInfo->SubKeys = 1;
+ }
+ else if (Kcb->ExtFlags & CM_KCB_SUBKEY_HINT)
+ {
+ /* Get the number of subkeys from the subkey hint */
+ KeyCachedInfo->SubKeys = Kcb->IndexHint->Count;
+ }
+ else
+ {
+ /* No subkey hint, use the key count field */
+ KeyCachedInfo->SubKeys = Kcb->SubKeyCount;
+ }
+
+ return STATUS_SUCCESS;
+}
+
+static
+NTSTATUS
+CmpQueryFlagsInformation(
+ _In_ PCM_KEY_CONTROL_BLOCK Kcb,
+ _Out_ PKEY_USER_FLAGS_INFORMATION KeyFlagsInfo,
+ _In_ ULONG Length,
+ _In_ PULONG ResultLength)
+{
+ /* Validate the buffer size */
+ *ResultLength = sizeof(*KeyFlagsInfo);
+ if (Length < *ResultLength)
+ {
+ return STATUS_BUFFER_TOO_SMALL;
+ }
+
+ /* Copy the user flags */
+ KeyFlagsInfo->UserFlags = Kcb->KcbUserFlags;
+
+ return STATUS_SUCCESS;
+}
+
NTSTATUS
NTAPI
CmQueryKey(IN PCM_KEY_CONTROL_BLOCK Kcb,
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Lock KCB shared */
CmpAcquireKcbLockShared(Kcb);
Hive = Kcb->KeyHive;
Parent = (PCM_KEY_NODE)HvGetCell(Hive, Kcb->KeyCell);
ASSERT(Parent);
-
+
/* Track cell references */
if (!HvTrackCellRef(&CellReferences, Hive, Kcb->KeyCell))
{
}
break;
- /* Unsupported classes for now */
- case KeyNameInformation:
case KeyCachedInformation:
+ /* Call the internal API */
+ Status = CmpQueryKeyDataFromCache(Kcb,
+ KeyInformation,
+ Length,
+ ResultLength);
+ break;
+
case KeyFlagsInformation:
+ /* Call the internal API */
+ Status = CmpQueryFlagsInformation(Kcb,
+ KeyInformation,
+ Length,
+ ResultLength);
+ break;
+
+ /* Unsupported class for now */
+ case KeyNameInformation:
/* Print message and fail */
DPRINT1("Unsupported class: %d!\n", KeyInformationClass);
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Lock the KCB shared */
CmpAcquireKcbLockShared(Kcb);
-
+
/* Don't touch deleted keys */
if (Kcb->Delete)
{
/* Now get the actual child node */
Child = (PCM_KEY_NODE)HvGetCell(Hive, ChildCell);
ASSERT(Child);
-
+
/* Track references */
if (!HvTrackCellRef(&CellReferences, Hive, ChildCell))
{
/* Acquire hive lock */
CmpLockRegistry();
-
+
/* Get the kcb */
Kcb = KeyBody->KeyControlBlock;
-
+
/* Don't allow deleting the root */
if (!Kcb->ParentKcb)
{
CmpUnlockRegistry();
return STATUS_CANNOT_DELETE;
}
-
+
/* Lock parent and child */
CmpAcquireTwoKcbLocksExclusiveByKey(Kcb->ConvKey, Kcb->ParentKcb->ConvKey);
-
+
/* Check if we're already being deleted */
if (Kcb->Delete)
{
/* Get the hive and node */
Hive = Kcb->KeyHive;
Cell = Kcb->KeyCell;
-
+
/* Lock flushes */
CmpLockHiveFlusherShared((PCMHIVE)Hive);
-
+
/* Get the key node */
Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
ASSERT(Node);
-
+
/* Sanity check */
ASSERT(Node->Flags == Kcb->Flags);
{
/* Send notification to registered callbacks */
CmpReportNotify(Kcb, Hive, Cell, REG_NOTIFY_CHANGE_NAME);
-
+
/* Get the parent and free the cell */
ParentCell = Node->Parent;
Status = CmpFreeKeyByCell(Hive, Cell, TRUE);
{
/* Flush any notifications */
CmpFlushNotifiesOnKeyBodyList(Kcb, FALSE);
-
+
/* Clean up information we have on the subkey */
CmpCleanUpSubKeyInfo(Kcb->ParentKcb);
if (Parent)
{
/* Update the maximum name length */
- Kcb->ParentKcb->KcbMaxNameLen = Parent->MaxNameLen;
-
+ Kcb->ParentKcb->KcbMaxNameLen = (USHORT)Parent->MaxNameLen;
+
/* Make sure we're dirty */
ASSERT(HvIsCellDirty(Hive, ParentCell));
/* Release the cell */
HvReleaseCell(Hive, ParentCell);
}
-
+
/* Set the KCB in delete mode and remove it */
Kcb->Delete = TRUE;
CmpRemoveKeyControlBlock(Kcb);
/* Fail */
Status = STATUS_CANNOT_DELETE;
}
-
+
/* Release the cell */
HvReleaseCell(Hive, Cell);
/* Ignore flushes until we're ready */
if (CmpNoWrite) return STATUS_SUCCESS;
-
+
/* Get the hives */
Hive = Kcb->KeyHive;
CmHive = (PCMHIVE)Hive;
-
+
/* Check if this is the master hive */
if (CmHive == CmiVolatileHive)
{
ASSERT(CmHive->ViewLock);
KeAcquireGuardedMutex(CmHive->ViewLock);
CmHive->ViewLockOwner = KeGetCurrentThread();
-
+
/* Will the hive shrink? */
if (HvHiveWillShrink(Hive))
{
ASSERT(KeGetCurrentThread() == CmHive->ViewLockOwner);
KeReleaseGuardedMutex(CmHive->ViewLock);
}
-
+
/* Flush only this hive */
if (!HvSyncHive(Hive))
{
/* Fail */
Status = STATUS_REGISTRY_IO_FAILED;
}
-
+
/* Release the flush lock */
CmpUnlockHiveFlusher((PCMHIVE)Hive);
}
PCMHIVE CmHive, LoadedHive;
NTSTATUS Status;
CM_PARSE_CONTEXT ParseContext;
-
+
/* Check if we have a trust key */
if (KeyBody)
{
/* Fail */
- DPRINT1("Trusted classes not yet supported\n");
- return STATUS_NOT_IMPLEMENTED;
+ DPRINT("Trusted classes not yet supported\n");
}
-
+
/* Build a service QoS for a security context */
ServiceQos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
ServiceQos.ImpersonationLevel = SecurityImpersonation;
DPRINT1("Security context failed\n");
return Status;
}
-
+
/* Open the target key */
#if 0
Status = ZwOpenKey(&KeyHandle, KEY_READ, TargetKey);
{
/* Lock the registry */
CmpLockRegistryExclusive();
-
+
/* Check if we are already loaded */
if (CmpIsHiveAlreadyLoaded(KeyHandle, SourceFile, &LoadedHive))
{
/* Release the registry */
CmpUnlockRegistry();
}
-
+
/* Close the key handle if we had one */
if (KeyHandle) ZwClose(KeyHandle);
return Status;
}
-
+
/* Lock the registry shared */
CmpLockRegistry();
-
+
/* Lock loading */
ExAcquirePushLockExclusive(&CmpLoadHiveLock);
-
+
/* Lock the hive to this thread */
CmHive->Hive.HiveFlags |= HIVE_IS_UNLOADING;
CmHive->CreatorOwner = KeGetCurrentThread();
-
+
/* Set flag */
if (Flags & REG_NO_LAZY_FLUSH) CmHive->Hive.HiveFlags |= HIVE_NOLAZYFLUSH;
-
+
/* Link the hive */
Status = CmpLinkHiveToMaster(TargetKey->ObjectName,
TargetKey->RootDirectory,
{
/* Add to HiveList key */
CmpAddToHiveFileList(CmHive);
-
+
/* Sync the hive if necessary */
if (Allocate)
{
HvSyncHive(&CmHive->Hive);
CmpUnlockHiveFlusher(CmHive);
}
-
+
/* Release the hive */
CmHive->Hive.HiveFlags &= ~HIVE_IS_UNLOADING;
CmHive->CreatorOwner = NULL;
-
+
/* Allow loads */
ExReleasePushLock(&CmpLoadHiveLock);
}
else
{
+ DPRINT1("CmpLinkHiveToMaster failed, Status %lx\n", Status);
/* FIXME: TODO */
ASSERT(FALSE);
}
-
+
/* Is this first profile load? */
if (!(CmpProfileLoaded) && !(CmpWasSetupBoot))
{
CmpProfileLoaded = TRUE;
CmpSetGlobalQuotaAllowed();
}
-
+
/* Unlock the registry */
CmpUnlockRegistry();
-
+
/* Close handle and return */
if (KeyHandle) ZwClose(KeyHandle);
return Status;
PCM_KEY_HASH Entry;
PCM_KEY_CONTROL_BLOCK CachedKcb;
PCM_KEY_CONTROL_BLOCK ParentKcb;
- USHORT ParentKeyCount;
- USHORT j;
- ULONG i;
+ ULONG ParentKeyCount;
+ ULONG i, j;
ULONG SubKeys = 0;
DPRINT("CmCountOpenSubKeys() called\n");
return SubKeys;
}
+
+HCELL_INDEX
+NTAPI
+CmpCopyCell(IN PHHIVE SourceHive,
+ IN HCELL_INDEX SourceCell,
+ IN PHHIVE DestinationHive,
+ IN HSTORAGE_TYPE StorageType)
+{
+ PCELL_DATA SourceData;
+ PCELL_DATA DestinationData = NULL;
+ HCELL_INDEX DestinationCell = HCELL_NIL;
+ LONG DataSize;
+ PAGED_CODE();
+
+ /* Get the data and the size of the source cell */
+ SourceData = HvGetCell(SourceHive, SourceCell);
+ DataSize = HvGetCellSize(SourceHive, SourceData);
+
+ /* Allocate a new cell in the destination hive */
+ DestinationCell = HvAllocateCell(DestinationHive,
+ DataSize,
+ StorageType,
+ HCELL_NIL);
+ if (DestinationCell == HCELL_NIL) goto Cleanup;
+
+ /* Get the data of the destination cell */
+ DestinationData = HvGetCell(DestinationHive, DestinationCell);
+
+ /* Copy the data from the source cell to the destination cell */
+ RtlMoveMemory(DestinationData, SourceData, DataSize);
+
+Cleanup:
+
+ /* Release the cells */
+ if (SourceData) HvReleaseCell(SourceHive, SourceCell);
+ if (DestinationData) HvReleaseCell(DestinationHive, DestinationCell);
+
+ /* Return the destination cell index */
+ return DestinationCell;
+}
+
+static
+NTSTATUS
+NTAPI
+CmpDeepCopyKeyInternal(IN PHHIVE SourceHive,
+ IN HCELL_INDEX SrcKeyCell,
+ IN PHHIVE DestinationHive,
+ IN HCELL_INDEX Parent,
+ IN HSTORAGE_TYPE StorageType,
+ OUT PHCELL_INDEX DestKeyCell OPTIONAL)
+{
+ NTSTATUS Status;
+ PCM_KEY_NODE SrcNode, DestNode;
+ HCELL_INDEX NewKeyCell, SubKey, NewSubKey;
+ ULONG Index, SubKeyCount;
+ PAGED_CODE();
+
+ DPRINT("CmpDeepCopyKeyInternal(0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X)\n",
+ SourceHive,
+ SrcKeyCell,
+ DestinationHive,
+ Parent,
+ StorageType,
+ DestKeyCell);
+
+ /* Get the source cell node */
+ SrcNode = HvGetCell(SourceHive, SrcKeyCell);
+
+ /* Sanity check */
+ ASSERT(SrcNode->Signature == CM_KEY_NODE_SIGNATURE);
+
+ /* Create a simple copy of the source key */
+ NewKeyCell = CmpCopyCell(SourceHive,
+ SrcKeyCell,
+ DestinationHive,
+ StorageType);
+ if (NewKeyCell == HCELL_NIL)
+ {
+ /* Not enough storage space */
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto Cleanup;
+ }
+
+ /* Get the destination cell node */
+ DestNode = HvGetCell(DestinationHive, NewKeyCell);
+
+ /* Set the parent */
+ DestNode->Parent = Parent;
+
+ // TODO: These should also be copied!
+ DestNode->Security = DestNode->Class = HCELL_NIL;
+
+ /* Copy the value list */
+ Status = CmpCopyKeyValueList(SourceHive,
+ &SrcNode->ValueList,
+ DestinationHive,
+ &DestNode->ValueList,
+ StorageType);
+ if (!NT_SUCCESS(Status)) goto Cleanup;
+
+ /* Clear the invalid subkey index */
+ DestNode->SubKeyCounts[Stable] = DestNode->SubKeyCounts[Volatile] = 0;
+ DestNode->SubKeyLists[Stable] = DestNode->SubKeyLists[Volatile] = HCELL_NIL;
+
+ /* Calculate the total number of subkeys */
+ SubKeyCount = SrcNode->SubKeyCounts[Stable] + SrcNode->SubKeyCounts[Volatile];
+
+ /* Loop through all the subkeys */
+ for (Index = 0; Index < SubKeyCount; Index++)
+ {
+ /* Get the subkey */
+ SubKey = CmpFindSubKeyByNumber(SourceHive, SrcNode, Index);
+ ASSERT(SubKey != HCELL_NIL);
+
+ /* Call the function recursively for the subkey */
+ Status = CmpDeepCopyKeyInternal(SourceHive,
+ SubKey,
+ DestinationHive,
+ NewKeyCell,
+ StorageType,
+ &NewSubKey);
+ if (!NT_SUCCESS(Status)) goto Cleanup;
+
+ /* Add the copy of the subkey to the new key */
+ if (!CmpAddSubKey(DestinationHive,
+ NewKeyCell,
+ NewSubKey))
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto Cleanup;
+ }
+ }
+
+ /* Set the cell index if requested and return success */
+ if (DestKeyCell) *DestKeyCell = NewKeyCell;
+ Status = STATUS_SUCCESS;
+
+Cleanup:
+
+ /* Release the cells */
+ if (SrcNode) HvReleaseCell(SourceHive, SrcKeyCell);
+ if (DestNode) HvReleaseCell(DestinationHive, NewKeyCell);
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CmpDeepCopyKey(IN PHHIVE SourceHive,
+ IN HCELL_INDEX SrcKeyCell,
+ IN PHHIVE DestinationHive,
+ IN HSTORAGE_TYPE StorageType,
+ OUT PHCELL_INDEX DestKeyCell OPTIONAL)
+{
+ /* Call the internal function */
+ return CmpDeepCopyKeyInternal(SourceHive,
+ SrcKeyCell,
+ DestinationHive,
+ HCELL_NIL,
+ StorageType,
+ DestKeyCell);
+}
+
+NTSTATUS
+NTAPI
+CmSaveKey(IN PCM_KEY_CONTROL_BLOCK Kcb,
+ IN HANDLE FileHandle,
+ IN ULONG Flags)
+{
+ NTSTATUS Status = STATUS_SUCCESS;
+ PCMHIVE KeyHive = NULL;
+ PAGED_CODE();
+
+ DPRINT("CmSaveKey(0x%08X, 0x%08X, %lu)\n", Kcb, FileHandle, Flags);
+
+ /* Lock the registry and KCB */
+ CmpLockRegistry();
+ CmpAcquireKcbLockShared(Kcb);
+
+ if (Kcb->Delete)
+ {
+ /* The source key has been deleted, do nothing */
+ Status = STATUS_KEY_DELETED;
+ goto Cleanup;
+ }
+
+ if (Kcb->KeyHive == &CmiVolatileHive->Hive)
+ {
+ /* Keys that are directly in the master hive can't be saved */
+ Status = STATUS_ACCESS_DENIED;
+ goto Cleanup;
+ }
+
+ /* Create a new hive that will hold the key */
+ Status = CmpInitializeHive(&KeyHive,
+ HINIT_CREATE,
+ HIVE_VOLATILE,
+ HFILE_TYPE_PRIMARY,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ 0);
+ if (!NT_SUCCESS(Status)) goto Cleanup;
+
+ /* Copy the key recursively into the new hive */
+ Status = CmpDeepCopyKey(Kcb->KeyHive,
+ Kcb->KeyCell,
+ &KeyHive->Hive,
+ Stable,
+ &KeyHive->Hive.BaseBlock->RootCell);
+ if (!NT_SUCCESS(Status)) goto Cleanup;
+
+ /* Set the primary handle of the hive */
+ KeyHive->FileHandles[HFILE_TYPE_PRIMARY] = FileHandle;
+
+ /* Dump the hive into the file */
+ HvWriteHive(&KeyHive->Hive);
+
+Cleanup:
+
+ /* Free the hive */
+ if (KeyHive) CmpDestroyHive(KeyHive);
+
+ /* Release the locks */
+ CmpReleaseKcbLock(Kcb);
+ CmpUnlockRegistry();
+
+ return Status;
+}
projects / reactos.git / blobdiff