public static void SetValueEx(object key, string valueName, int reserved, int type, object value) { HKEYType rootKey = GetRootKey(key); RegistryValueKind regKind = (RegistryValueKind)type; if (regKind == RegistryValueKind.MultiString) { int size = ((List)value)._size; string[] strArray = new string[size]; Array.Copy(((List)value)._data, strArray, size); rootKey.key.SetValue(valueName, strArray, regKind); } else if (regKind == RegistryValueKind.Binary) { byte[] byteArr = null; if (value is string) { string strValue = value as string; ASCIIEncoding encoding = new ASCIIEncoding(); byteArr = encoding.GetBytes(strValue); } rootKey.key.SetValue(valueName, byteArr, regKind); } else { rootKey.key.SetValue(valueName, value, regKind); } }
public static PythonTuple QueryInfoKey(object key) { HKEYType rootKey = null; //The key can also be a handle. If it is, then retrieve it from the cache. if (key is int) { if (HKeyHandleCache.cache.ContainsKey((int)key)) { if (HKeyHandleCache.cache[(int)key].IsAlive) { rootKey = HKeyHandleCache.cache[(int)key].Target as HKEYType; } } } else { rootKey = GetRootKey(key); } if (rootKey == null) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, "key has been closed"); } try { var nativeRootKey = rootKey.GetKey(); return(PythonTuple.MakeTuple(nativeRootKey.SubKeyCount, nativeRootKey.ValueCount, 0)); } catch (ObjectDisposedException e) { throw new ExternalException(e.Message); } }
public static void DeleteKey(object key, string sub_key) { HKEYType rootKey = GetRootKey(key); if (key is BigInteger && string.IsNullOrEmpty(sub_key)) { throw new InvalidCastException("DeleteKey() argument 2 must be string, not None"); } // the .NET APIs don't work with a key name of length 256, use a PInvoke instead // unlike in CreateKey(), `subKeyName.Length` on deletion can be greater than 256 if combined with parent key name. if (sub_key.Length >= 256) { int result = RegDeleteKey(rootKey.GetKey().Handle, sub_key); if (result != ERROR_SUCCESS) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, result); } return; } try { rootKey.GetKey().DeleteSubKey(sub_key); } catch (ArgumentException e) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, e.HResult); } }
public static HKEYType CreateKeyEx(object key, string sub_key, int reserved = 0, int access = KEY_ALL_ACCESS) { HKEYType rootKey = GetRootKey(key); //if key is a system key and no subkey is specified return that. if (key is BigInteger && string.IsNullOrEmpty(sub_key)) { return(rootKey); } SafeRegistryHandle handle; int disposition; int result = RegCreateKeyEx( rootKey.GetKey().Handle, sub_key, 0, null, RegistryOptions.None, (RegistryRights)access, IntPtr.Zero, out handle, out disposition ); if (result != ERROR_SUCCESS) { throw PythonExceptions.CreateThrowable(error, result, FormatError(result)); } return(new HKEYType(RegistryKey.FromHandle(handle))); }
public static PythonTuple EnumValue(object key, int index) { HKEYType rootKey = GetRootKey(key); if (index >= rootKey.key.ValueCount) { throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_BAD_COMMAND, "No more data is available"); } string valueName = rootKey.key.GetValueNames()[index]; int valueKind = MapRegistryValueKind(rootKey.key.GetValueKind(valueName)); object value = rootKey.key.GetValue(valueName); //Handle some special cases of registry values. if (valueKind == REG_MULTI_SZ) { value = new List(value); } else if (valueKind == REG_BINARY) { ASCIIEncoding encoding = new ASCIIEncoding(); value = encoding.GetString((byte[])value); } // REG_EXPAND_SZ expands any environment variable present in the registry key. // CPython does the wrong thing and returns the unexpanded value. Should we put in a // hack to return the wrong value that CPython does? return(PythonTuple.MakeTuple(valueName, value, valueKind)); }
public static PythonTuple QueryInfoKey(object key) { HKEYType rootKey = null; //The key can also be a handle. If it is, then retrieve it from the cache. if (key is int) { if (HKeyHandleCache.cache.ContainsKey((int)key)) { if (HKeyHandleCache.cache[(int)key].IsAlive) { rootKey = HKeyHandleCache.cache[(int)key].Target as HKEYType; } } } else { rootKey = GetRootKey(key); } try { return(PythonTuple.MakeTuple(rootKey.key.SubKeyCount, rootKey.key.ValueCount, 0)); } catch (ObjectDisposedException e) { throw new ExternalException(e.Message); } }
public static PythonTuple QueryInfoKey(object key) { HKEYType rootKey = null; //The key can also be a handle. If it is, then retrieve it from the cache. if (key is int) { if (HKEYType.cache.TryGetValue((int)key, out var value)) { value.TryGetTarget(out rootKey); } } else { rootKey = GetRootKey(key); } if (rootKey == null) { throw PythonExceptions.CreateThrowable(PythonExceptions.EnvironmentError, "key has been closed"); } try { var nativeRootKey = rootKey.GetKey(); return(PythonTuple.MakeTuple(nativeRootKey.SubKeyCount, nativeRootKey.ValueCount, 0)); } catch (ObjectDisposedException e) { throw new ExternalException(e.Message); } }
public static void SetValueEx(object key, string value_name, object reserved, int type, object value) { HKEYType rootKey = GetRootKey(key); RegistryValueKind regKind = (RegistryValueKind)type; // null is a valid value but RegistryKey.SetValue doesn't like it so PInvoke to set it if (value == null) { RegSetValueEx(rootKey.GetKey().Handle, value_name, 0, type, null, 0); return; } if (regKind == RegistryValueKind.MultiString) { int size = ((PythonList)value)._size; string[] strArray = new string[size]; Array.Copy(((PythonList)value)._data, strArray, size); rootKey.GetKey().SetValue(value_name, strArray, regKind); } else if (regKind == RegistryValueKind.Binary) { byte[] byteArr = null; if (value is string) { string strValue = value as string; ASCIIEncoding encoding = new ASCIIEncoding(); byteArr = encoding.GetBytes(strValue); } else if (value is Bytes ibytes) { byteArr = ibytes.UnsafeByteArray; } rootKey.GetKey().SetValue(value_name, byteArr, regKind); } else if (regKind == RegistryValueKind.DWord) { // DWORDs are uint but the .NET API requires int if (value is BigInteger) { var val = (uint)(BigInteger)value; value = unchecked ((int)val); } rootKey.GetKey().SetValue(value_name, value, regKind); } else if (regKind == RegistryValueKind.QWord) { // QWORDs are ulong but the .NET API requires long if (value is BigInteger) { var val = (ulong)(BigInteger)value; value = unchecked ((long)val); } rootKey.GetKey().SetValue(value_name, value, regKind); } else { rootKey.GetKey().SetValue(value_name, value, regKind); } }
public static HKEYType OpenKey(object key, string sub_key, int reserved = 0, int access = KEY_READ) { HKEYType rootKey = GetRootKey(key); RegistryKey newKey = null; // I'm assuming that the masks that CPy uses are the same as the Win32 API one mentioned here- // http://msdn2.microsoft.com/en-us/library/ms724878(VS.85).aspx // KEY_WRITE is a combination of KEY_SET_VALUE and KEY_CREATE_SUB_KEY. We'll open with write access // if any of this is set. // KEY_READ is a combination of KEY_QUERY_VALUE, KEY_ENUMERATE_SUB_KEYS and KEY_NOTIFY. We'll open // with read access for all of these. var nativeRootKey = rootKey.GetKey(); try { if ((access & KEY_SET_VALUE) == KEY_SET_VALUE || (access & KEY_CREATE_SUB_KEY) == KEY_CREATE_SUB_KEY) { if (reserved != 0) { newKey = nativeRootKey.OpenSubKey(sub_key, RegistryKeyPermissionCheck.Default, (RegistryRights)reserved); } else { newKey = nativeRootKey.OpenSubKey(sub_key, true); } } else if ((access & KEY_QUERY_VALUE) == KEY_QUERY_VALUE || (access & KEY_ENUMERATE_SUB_KEYS) == KEY_ENUMERATE_SUB_KEYS || (access & KEY_NOTIFY) == KEY_NOTIFY) { if (reserved != 0) { newKey = nativeRootKey.OpenSubKey(sub_key, RegistryKeyPermissionCheck.ReadSubTree, (RegistryRights)reserved); } else { newKey = nativeRootKey.OpenSubKey(sub_key, false); } } else { throw new Win32Exception("Unexpected mode"); } } catch (SecurityException) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_ACCESS_DENIED, "Access is denied", null, PythonExceptions._OSError.ERROR_ACCESS_DENIED); } if (newKey == null) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_FILE_NOT_FOUND, "The system cannot find the file specified", null, PythonExceptions._OSError.ERROR_FILE_NOT_FOUND); } return(new HKEYType(newKey)); }
public static string EnumKey(object key, int index) { HKEYType rootKey = GetRootKey(key); if (index >= rootKey.key.SubKeyCount) { throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_BAD_COMMAND, "No more data is available"); } return(rootKey.key.GetSubKeyNames()[index]); }
public static PythonTuple QueryValueEx(object key, string valueName) { HKEYType rootKey = GetRootKey(key); int valueKind; object value; QueryValueExImpl(rootKey.GetKey(), valueName, out valueKind, out value); return(PythonTuple.MakeTuple(value, valueKind)); }
public static PythonTuple QueryValueEx(object key, string value_name) { HKEYType rootKey = GetRootKey(key); // it looks like rootKey.GetKey().Handle fails on HKEY_PERFORMANCE_DATA so manually create the handle instead var handle = rootKey.hkey == HKEY_PERFORMANCE_DATA ? new SafeRegistryHandle(new IntPtr(unchecked ((int)0x80000004)), true) : rootKey.GetKey().Handle; int valueKind; object value; QueryValueExImpl(handle, value_name, out valueKind, out value); return(PythonTuple.MakeTuple(value, valueKind)); }
public static HKEYType CreateKey(object key, string subKeyName) { HKEYType rootKey = GetRootKey(key); //if key is a system key and no subkey is specified return that. if (key is BigInteger && string.IsNullOrEmpty(subKeyName)) { return(rootKey); } HKEYType subKey = new HKEYType(rootKey.key.CreateSubKey(subKeyName)); return(subKey); }
public static string EnumKey(object key, int index) { HKEYType rootKey = GetRootKey(key); int len = 257; // maximum key name length is 256 StringBuilder name = new StringBuilder(len); int ret = RegEnumKeyEx(rootKey.GetKey().Handle, index, name, ref len, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); if (ret != ERROR_SUCCESS) { Debug.Assert(ret == ERROR_NO_MORE_ITEMS); throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_BAD_COMMAND, "No more data is available", null, PythonExceptions._OSError.ERROR_BAD_COMMAND); } return(name.ToString()); }
public static void DeleteKey(object key, string subKeyName) { HKEYType rootKey = GetRootKey(key); if (key is BigInteger && string.IsNullOrEmpty(subKeyName)) { throw new InvalidCastException("DeleteKey() argument 2 must be string, not None"); } try { rootKey.key.DeleteSubKey(subKeyName); } catch (ArgumentException e) { throw new ExternalException(e.Message); } }
public static void EnableReflectionKey(object key) { HKEYType rootKey = GetRootKey(key); if (!Environment.Is64BitOperatingSystem) { throw new NotImplementedException("not implemented on this platform"); } int dwRet = RegEnableReflectionKey(rootKey.GetKey().Handle); if (dwRet != ERROR_SUCCESS) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, dwRet); } }
public static void DeleteKeyEx(object key, string sub_key, int access = KEY_WOW64_64KEY, int reserved = 0) { HKEYType rootKey = GetRootKey(key); if (key is BigInteger && string.IsNullOrEmpty(sub_key)) { throw new InvalidCastException("DeleteKeyEx() argument 2 must be string, not None"); } int result = RegDeleteKeyEx(rootKey.GetKey().Handle, sub_key, access, reserved); if (result != ERROR_SUCCESS) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, result); } }
public static PythonTuple EnumValue(object key, int index) { HKEYType rootKey = GetRootKey(key); if (index >= rootKey.GetKey().ValueCount) { throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, PythonExceptions._WindowsError.ERROR_BAD_COMMAND, "No more data is available"); } var nativeRootKey = rootKey.GetKey(); string valueName = nativeRootKey.GetValueNames()[index]; int valueKind; object value; QueryValueExImpl(nativeRootKey, valueName, out valueKind, out value); return(PythonTuple.MakeTuple(valueName, value, valueKind)); }
private static HKEYType GetRootKey(object key) { HKEYType rootKey; rootKey = key as HKEYType; if (rootKey == null) { if (key is BigInteger) { rootKey = new HKEYType(RegistryKey.OpenBaseKey(MapSystemKey((BigInteger)key), RegistryView.Default), (BigInteger)key); } else { throw new InvalidCastException("The object is not a PyHKEY object"); } } return(rootKey); }
public static PythonTuple QueryValueEx(object key, string valueName) { HKEYType rootKey = GetRootKey(key); object value = rootKey.key.GetValue(valueName); int valueKind = MapRegistryValueKind(rootKey.key.GetValueKind(valueName)); if (valueKind == REG_MULTI_SZ) { value = new List(value); } if (valueKind == REG_BINARY) { ASCIIEncoding encoding = new ASCIIEncoding(); value = encoding.GetString((byte[])value); } return(PythonTuple.MakeTuple(value, valueKind)); }
public static bool QueryReflectionKey(object key) { HKEYType rootKey = GetRootKey(key); bool isDisabled; if (!Environment.Is64BitOperatingSystem) { throw new NotImplementedException("not implemented on this platform"); } int dwRet = RegQueryReflectionKey(rootKey.GetKey().Handle, out isDisabled); if (dwRet != ERROR_SUCCESS) { throw PythonExceptions.CreateThrowable(PythonExceptions.WindowsError, dwRet); } return(isDisabled); }
public static HKEYType CreateKey(object key, string sub_key) { // the .NET APIs don't work with a key name of length 256, use CreateKeyEx which PInvokes instead if (sub_key.Length == 256) { return(CreateKeyEx(key, sub_key, 0, KEY_ALL_ACCESS)); } HKEYType rootKey = GetRootKey(key); //if key is a system key and no subkey is specified return that. if (key is BigInteger && string.IsNullOrEmpty(sub_key)) { return(rootKey); } HKEYType subKey = new HKEYType(rootKey.GetKey().CreateSubKey(sub_key)); return(subKey); }
public static PythonTuple EnumValue(object key, int index) { HKEYType rootKey = GetRootKey(key); if (index >= rootKey.GetKey().ValueCount) { throw PythonExceptions.CreateThrowable(PythonExceptions.OSError, PythonExceptions._OSError.ERROR_BAD_COMMAND, "No more data is available", null, PythonExceptions._OSError.ERROR_BAD_COMMAND); } var nativeRootKey = rootKey.GetKey(); string valueName = nativeRootKey.GetValueNames()[index]; // it looks like nativeRootKey.Handle fails on HKEY_PERFORMANCE_DATA so manually create the handle instead var handle = rootKey.hkey == HKEY_PERFORMANCE_DATA ? new SafeRegistryHandle(new IntPtr(unchecked ((int)0x80000004)), true) : nativeRootKey.Handle; int valueKind; object value; QueryValueExImpl(handle, valueName, out valueKind, out value); return(PythonTuple.MakeTuple(valueName, value, valueKind)); }
public static void DeleteKey(object key, string subKeyName) { HKEYType rootKey = GetRootKey(key); if (key is BigInteger && string.IsNullOrEmpty(subKeyName)) { throw new InvalidCastException("DeleteKey() argument 2 must be string, not None"); } // the .NET APIs don't work with a key name of length 256, use a PInvoke instead if (subKeyName.Length == 256) { RegDeleteKey(rootKey.GetKey().Handle, subKeyName); return; } try { rootKey.GetKey().DeleteSubKey(subKeyName); } catch (ArgumentException e) { throw new ExternalException(e.Message); } }
public static void CloseKey(HKEYType key) { key.Close(); }
public static void SetValue(object key, string subKeyName, int type, string value) { HKEYType pyKey = CreateKey(key, subKeyName); pyKey.key.SetValue(null, value); }
public static HKEYType CreateKey(object key, string subKeyName) { HKEYType rootKey = GetRootKey(key); //if key is a system key and no subkey is specified return that. if (key is BigInteger && string.IsNullOrEmpty(subKeyName)) return rootKey; HKEYType subKey = new HKEYType(rootKey.GetKey().CreateSubKey(subKeyName)); return subKey; }
private static HKEYType GetRootKey(object key) { HKEYType rootKey; rootKey = key as HKEYType; if (rootKey == null) { if (key is BigInteger) { rootKey = new HKEYType(RegistryKey.OpenRemoteBaseKey(MapSystemKey((BigInteger)key), string.Empty)); } else { throw new InvalidCastException("The object is not a PyHKEY object"); } } return rootKey; }
public static void SetValue(object key, string sub_key, int type, string value) { HKEYType pyKey = CreateKey(key, sub_key); pyKey.GetKey().SetValue(null, value); }
public static HKEYType CreateKey(object key, string subKeyName) { HKEYType rootKey = GetRootKey(key); //if key is a system key and no subkey is specified return that. BigInteger bi = key as BigInteger; if (!Object.ReferenceEquals(bi, null) && string.IsNullOrEmpty(subKeyName)) return rootKey; HKEYType subKey = new HKEYType(rootKey.key.CreateSubKey(subKeyName)); return subKey; }
public static object QueryValue(object key, string sub_key) { HKEYType pyKey = OpenKey(key, sub_key); return(pyKey.GetKey().GetValue(null)); }
private static HKEYType GetRootKey(object key) { HKEYType rootKey; rootKey = key as HKEYType; if (rootKey == null) { BigInteger bi = key as BigInteger; if (!Object.ReferenceEquals(bi, null)) { rootKey = new HKEYType(RegistryKey.OpenRemoteBaseKey(MapSystemKey(bi), string.Empty)); } else { throw new InvalidCastException("The object is not a PyHKEY object"); } } return rootKey; }
public static void FlushKey(object key) { HKEYType rootKey = GetRootKey(key); rootKey.GetKey().Flush(); }
public static void DeleteValue(object key, string value) { HKEYType rootKey = GetRootKey(key); rootKey.GetKey().DeleteValue(value, true); }