/// <summary>
/// RegInject: Sets a value to the REG_NONE type. Therefore only its name is required.
/// </summary>
/// <param name="name">The name of the value.</param>
public void SetValueNone(string name)
{
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal(0);
//Marshal.Copy(data, 0, dataPtr, data.Length);
Win32Result result = OffregNative.SetValue(
_intPtr, name, RegValueType.REG_NONE, dataPtr, (uint)0);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
}
finally
{
if (dataPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(dataPtr);
}
}
RefreshMetadata();
}
/// <summary>
/// Enumerates all subkeys, retrieving both their name and class at the same time.
/// </summary>
/// <returns>Names and classes of all the subkeys.</returns>
public SubKeyContainer[] EnumerateSubKeys()
{
SubKeyContainer[] results = new SubKeyContainer[_metadata.SubKeysCount];
for (uint item = 0; item < _metadata.SubKeysCount; item++)
{
uint sizeName = _metadata.MaxSubKeyLen + 1;
uint sizeClass = _metadata.MaxClassLen + 1;
StringBuilder sbName = new StringBuilder((int)sizeName);
StringBuilder sbClass = new StringBuilder((int)sizeClass);
FILETIME fileTime = new FILETIME();
Win32Result result = OffregNative.EnumKey(_intPtr, item, sbName, ref sizeName, sbClass, ref sizeClass,
ref fileTime);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
SubKeyContainer container = new SubKeyContainer();
container.Name = sbName.ToString();
container.Class = sbClass.ToString();
container.LastWriteTime = fileTime;
results[item] = container;
}
return(results);
}
/// <summary>
/// Sets a value to the specified type.
/// </summary>
/// <param name="name">The name of the value.</param>
/// <param name="type">The optional type for the value.</param>
/// <param name="data">The data for the value.</param>
private void SetValue(string name, RegValueType type, byte[] data)
{
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal(data.Length);
Marshal.Copy(data, 0, dataPtr, data.Length);
Win32Result result = OffregNative.SetValue(_intPtr, name, type, dataPtr, (uint)data.Length);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
}
finally
{
if (dataPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(dataPtr);
}
}
RefreshMetadata();
}
/// <summary>
/// Enumerates all values, retrieving both their name, data and type at the same time.
/// </summary>
/// <returns>Names, datas and types of all the values.</returns>
public ValueContainer[] EnumerateValues()
{
ValueContainer[] results = new ValueContainer[_metadata.ValuesCount];
// Allocate data buffer
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal((int)_metadata.MaxValueLen);
// Iterate all values
for (uint item = 0; item < _metadata.ValuesCount; item++)
{
uint sizeName = _metadata.MaxValueNameLen + 1;
uint sizeData = _metadata.MaxValueLen;
StringBuilder sbName = new StringBuilder((int)sizeName);
RegValueType type;
// Get item
Win32Result result = OffregNative.EnumValue(_intPtr, item, sbName, ref sizeName, out type, dataPtr,
ref sizeData);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
byte[] data = new byte[sizeData];
Marshal.Copy(dataPtr, data, 0, (int)sizeData);
ValueContainer container = new ValueContainer();
if (!Enum.IsDefined(typeof(RegValueType), type))
{
WarnDebugForValueType(sbName.ToString(), type);
type = RegValueType.REG_BINARY;
}
object parsedData;
container.Name = sbName.ToString();
container.InvalidData = !OffregHelper.TryConvertValueDataToObject(type, data, out parsedData);
container.Data = parsedData;
container.Type = type;
results[item] = container;
}
}
finally
{
if (dataPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(dataPtr);
}
}
return(results);
}
/// <summary>
/// Detect if a value exists in this key.
/// </summary>
/// <param name="name">The value to find</param>
/// <returns>True if it exists, false otherwise.</returns>
public bool ValueExist(string name)
{
RegValueType type;
uint size = 0;
Win32Result result = OffregNative.GetValue(_intPtr, null, name, out type, IntPtr.Zero, ref size);
return(result == Win32Result.ERROR_SUCCESS);
}
/// <summary>
/// Saves a hive to Disk.
/// See http://msdn.microsoft.com/en-us/library/ee210773(v=vs.85).aspx for more details.
/// </summary>
/// <remarks>The target file must not exist.</remarks>
/// <param name="targetFile">The target file to write to.</param>
/// <param name="majorVersionTarget">The compatibility version to save for, see the link in summary.</param>
/// <param name="minorVersionTarget">The compatibility version to save for, see the link in summary.</param>
public void SaveHive(string targetFile, uint majorVersionTarget, uint minorVersionTarget)
{
Win32Result res = OffregNative.SaveHive(_intPtr, targetFile, majorVersionTarget, minorVersionTarget);
if (res != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)res);
}
}
/// <summary>
/// Deletes a specified value.
/// </summary>
/// <param name="name">The name of the value to delete.</param>
public void DeleteValue(string name)
{
Win32Result result = OffregNative.DeleteValue(_intPtr, name);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
RefreshMetadata();
}
/// <summary>
/// Calls QueryInfoKey and updates _metadata.
/// </summary>
private void RefreshMetadata()
{
uint sizeClass = 0;
uint countSubKeys = 0, maxSubKeyLen = 0, maxClassLen = 0;
uint countValues = 0, maxValueNameLen = 0, maxValueLen = 0;
uint securityDescriptorSize = 0;
FILETIME lastWrite = new FILETIME();
// Get size of class
StringBuilder sbClass = new StringBuilder((int)sizeClass);
Win32Result result = OffregNative.QueryInfoKey(_intPtr, sbClass, ref sizeClass, ref countSubKeys,
ref maxSubKeyLen,
ref maxClassLen,
ref countValues, ref maxValueNameLen, ref maxValueLen,
ref securityDescriptorSize,
ref lastWrite);
if (result == Win32Result.ERROR_MORE_DATA)
{
// The returned size does is in characters (unicode), excluding NULL chars. Increment it to have space
sizeClass = sizeClass + 1;
// Allocate
sbClass = new StringBuilder((int)sizeClass);
result = OffregNative.QueryInfoKey(_intPtr, sbClass, ref sizeClass, ref countSubKeys, ref maxSubKeyLen,
ref maxClassLen,
ref countValues, ref maxValueNameLen, ref maxValueLen,
ref securityDescriptorSize,
ref lastWrite);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
}
else if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
_metadata.Class = sbClass.ToString();
_metadata.LastWriteTime = lastWrite;
_metadata.SubKeysCount = countSubKeys;
_metadata.MaxSubKeyLen = maxSubKeyLen;
_metadata.MaxClassLen = maxClassLen;
_metadata.ValuesCount = countValues;
_metadata.MaxValueNameLen = maxValueNameLen;
_metadata.MaxValueLen = maxValueLen; // Bytes
_metadata.SizeSecurityDescriptor = securityDescriptorSize;
}
/// <summary>
/// Opens an existing hive from the disk.
/// </summary>
/// <param name="hiveFile">The file to open.</param>
/// <returns>The newly opened hive.</returns>
public static OffregHive Open(string hiveFile)
{
IntPtr existingHive;
Win32Result res = OffregNative.OpenHive(hiveFile, out existingHive);
if (res != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)res);
}
return(new OffregHive(existingHive));
}
/// <summary>
/// Creates a new hive in memory.
/// </summary>
/// <returns>The newly created hive.</returns>
public static OffregHive Create()
{
IntPtr newHive;
Win32Result res = OffregNative.CreateHive(out newHive);
if (res != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)res);
}
return(new OffregHive(newHive));
}
public override void Close()
{
if (_intPtr != IntPtr.Zero && _ownsPointer)
{
Win32Result res = OffregNative.CloseKey(_intPtr);
if (res != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)res);
}
}
}
/// <summary>
/// Gets the type of a single value.
/// </summary>
/// <param name="name">The name of the value to retrieve the type of.</param>
/// <returns>The type of the value.</returns>
public RegValueType GetValueKind(string name)
{
RegValueType type;
Win32Result result = OffregNative.GetValue(_intPtr, null, name, out type, IntPtr.Zero, IntPtr.Zero);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
return(type);
}
/// <summary>
/// Tries to opens a subkey.
/// Will handle multi-level names, such as "Software\SubKey\Subkey2\"
/// </summary>
/// <param name="name">Name of the subkey to open.</param>
/// <param name="key">The newly opened subkey</param>
/// <returns>True if the operation was sucessful, false otherwise.</returns>
public bool TryOpenSubKey(string name, out OffregKey key)
{
IntPtr childPtr;
Win32Result result = OffregNative.OpenKey(_intPtr, name, out childPtr);
if (result != Win32Result.ERROR_SUCCESS)
{
key = null;
return(false);
}
key = new OffregKey(this, childPtr, name);
return(true);
}
/// <summary>
/// Deletes a subkey of this key. The subkey must not contain any subkeys of its own, to delete recursively - see
/// <see
/// cref="DeleteSubKeyTree" />
/// .
/// </summary>
/// <param name="name">The name of the subkey to delete</param>
public void DeleteSubKey(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
Win32Result result = OffregNative.DeleteKey(_intPtr, name);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
RefreshMetadata();
}
/// <summary>
/// Constructor, opens a subkey.
/// </summary>
/// <param name="parentKey">The parent key.</param>
/// <param name="name">The name of the subkey to open.</param>
internal OffregKey(OffregKey parentKey, string name)
{
Win32Result result = OffregNative.OpenKey(parentKey._intPtr, name, out _intPtr);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
Name = name;
FullName = (parentKey.FullName == null ? "" : parentKey.FullName + "\\") + name;
_parent = parentKey;
_metadata = new QueryInfoKeyData();
RefreshMetadata();
}
/// <summary>
/// Deletes this key, further operations will be invalid (except calls to <see cref="Close" />).
/// </summary>
public void Delete()
{
if (_parent == null)
{
throw new InvalidOperationException("Cannot delete the root key");
}
Win32Result result = OffregNative.DeleteKey(_intPtr, null);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
// Refresh parent
_parent.RefreshMetadata();
}
/// <summary>
/// Internal helper to get the type and data for a specified value.
/// </summary>
/// <param name="name">The name of the value to retrieve data for.</param>
/// <returns>The type and data for the specified value.</returns>
internal Tuple <RegValueType, byte[]> GetValueInternal(string name)
{
RegValueType type;
// Get the size first
uint size = 0;
Win32Result result = OffregNative.GetValue(_intPtr, null, name, out type, IntPtr.Zero, ref size);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
// Allocate buffer
byte[] res = new byte[size];
IntPtr dataPtr = IntPtr.Zero;
try
{
dataPtr = Marshal.AllocHGlobal((int)size);
// Get data
result = OffregNative.GetValue(_intPtr, null, name, out type, dataPtr, ref size);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
// Copy data
Marshal.Copy(dataPtr, res, 0, (int)size);
}
finally
{
// Release data
if (dataPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(dataPtr);
}
}
return(new Tuple <RegValueType, byte[]>(type, res));
}
/// <summary>
/// Detect if a subkey exists in this key.
/// </summary>
/// <param name="name">The subkey to find</param>
/// <returns>True if it exists, false otherwise.</returns>
public bool SubkeyExist(string name)
{
IntPtr intPtr = IntPtr.Zero;
try
{
Win32Result result = OffregNative.OpenKey(_intPtr, name, out intPtr);
return(result == Win32Result.ERROR_SUCCESS);
}
finally
{
// Close up shop
if (intPtr != IntPtr.Zero)
{
OffregNative.CloseKey(intPtr);
}
}
}
/// <summary>
/// Creates a new subkey (or opens an existing one).
/// </summary>
/// <param name="name">The name of the subkey to create (or open).</param>
/// <param name="options">Key creation options.</param>
/// <returns>The newly created (or opened) key.</returns>
public OffregKey CreateSubKey(string name, RegOption options = 0)
{
IntPtr newKeyPtr;
KeyDisposition disposition;
Win32Result result = OffregNative.CreateKey(_intPtr, name, null, options, IntPtr.Zero, out newKeyPtr,
out disposition);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
// Return new key
OffregKey newKey = new OffregKey(this, newKeyPtr, name);
RefreshMetadata();
return(newKey);
}
/// <summary>
/// Enumerates all subkeys, only retrieving their names.
/// </summary>
/// <returns>Names of all the subkeys.</returns>
public string[] GetSubKeyNames()
{
string[] results = new string[_metadata.SubKeysCount];
for (uint item = 0; item < _metadata.SubKeysCount; item++)
{
uint sizeName = _metadata.MaxSubKeyLen + 1;
StringBuilder sbName = new StringBuilder((int)sizeName);
Win32Result result = OffregNative.EnumKey(_intPtr, item, sbName, ref sizeName, null, IntPtr.Zero,
IntPtr.Zero);
if (result != Win32Result.ERROR_SUCCESS)
{
throw new Win32Exception((int)result);
}
results[item] = sbName.ToString();
}
return(results);
}