internal static extern int RegSetValueEx( SafeRegistryHandle hKey, String lpValueName, int Reserved, RegistryValueKind dwType, String lpData, int cbData);
static void UnmapRegistryKey(RegistryKey registryKey) { using (var emptyHandle = new SafeRegistryHandle(IntPtr.Zero, true)) { Win32Api.Registry.RedirectRegistryKey(registryKey.Handle, emptyHandle); } }
public IRegistryKey FromHandle( SafeRegistryHandle handle, RegistryView view ) { return new RegistryKeyWrap(RegistryKey.FromHandle(handle, view)); }
internal static extern int RegQueryValueEx( SafeRegistryHandle hKey, String lpValueName, int[] lpReserved, ref int lpType, [Out]StringBuilder lpData, ref int lpcbData);
internal unsafe static extern int RegEnumKeyEx( SafeRegistryHandle hKey, int dwIndex, char* lpName, ref int lpcbName, int[] lpReserved, [Out]StringBuilder lpClass, int[] lpcbClass, long[] lpftLastWriteTime);
internal static extern unsafe int RegEnumValue( SafeRegistryHandle hKey, int dwIndex, char* lpValueName, ref int lpcbValueName, IntPtr lpReserved_MustBeZero, int[] lpType, byte[] lpData, int[] lpcbData);
internal static extern int RegCreateKeyEx( SafeRegistryHandle hKey, String lpSubKey, int Reserved, String lpClass, int dwOptions, int samDesired, ref SECURITY_ATTRIBUTES secAttrs, out SafeRegistryHandle hkResult, out int lpdwDisposition);
internal static extern int RegQueryInfoKey( SafeRegistryHandle hKey, [Out]StringBuilder lpClass, int[] lpcbClass, IntPtr lpReserved_MustBeZero, ref int lpcSubKeys, int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen, ref int lpcValues, int[] lpcbMaxValueNameLen, int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor, int[] lpftLastWriteTime);
private RegistryKey(SafeRegistryHandle hkey, bool writable, bool systemkey, bool remoteKey, bool isPerfData, RegistryView view) { this.hkey = hkey; this.keyName = ""; this.remoteKey = remoteKey; this.regView = view; if (systemkey) { this.state |= 2; } if (writable) { this.state |= 4; } if (isPerfData) { this.state |= 8; } ValidateKeyView(view); }
internal void Persist(SafeRegistryHandle hKey, string keyName) { new RegistryPermission(RegistryPermissionAccess.NoAccess, AccessControlActions.Change, keyName).Demand(); base.WriteLock(); try { AccessControlSections accessControlSectionsFromChanges = this.GetAccessControlSectionsFromChanges(); if (accessControlSectionsFromChanges != AccessControlSections.None) { bool flag; bool flag2; base.Persist(hKey, accessControlSectionsFromChanges); base.AccessRulesModified = flag = false; base.AuditRulesModified = flag2 = flag; base.OwnerModified = base.GroupModified = flag2; } } finally { base.WriteUnlock(); } }
/// <summary> /// Creates a RegistryKey. /// This key is bound to hkey, if writable is <b>false</b> then no write operations /// will be allowed. If systemkey is set then the hkey won't be released /// when the object is GC'ed. /// The remoteKey flag when set to true indicates that we are dealing with registry entries /// on a remote machine and requires the program making these calls to have full trust. /// </summary> private RegistryKey(SafeRegistryHandle hkey, bool writable, bool systemkey, bool remoteKey, bool isPerfData, RegistryView view) { ValidateKeyView(view); _hkey = hkey; _keyName = ""; _remoteKey = remoteKey; _regView = view; if (systemkey) { _state |= StateFlags.SystemKey; } if (writable) { _state |= StateFlags.WriteAccess; } if (isPerfData) { _state |= StateFlags.PerfData; } }
public static RegistryKey FromHandle(SafeRegistryHandle handle) { return FromHandle(handle, RegistryView.Default); }
public RegistryHandler(int hKey) { key_found = false; SafeRegistryHandle safeRegistryHandle = new SafeRegistryHandle(new IntPtr(hKey), true); root_key = RegistryKey.FromHandle(safeRegistryHandle); }
public RegistryKey FromHandle (SafeRegistryHandle handle) { // At this point we can't tell whether the key is writable // or not (nor the name), so we let the error check code handle it later, as // .Net seems to do. return new RegistryKey (handle.DangerousGetHandle (), String.Empty, true); }
/// <summary> /// Override a registry hive key to another registry key. /// </summary> /// <param name="key">Handle of the key to override.</param> /// <param name="newKey">Handle to override key.</param> internal static void RedirectRegistryKey(SafeRegistryHandle key, SafeRegistryHandle newKey) { if (0 != RegOverridePredefKey(key, newKey)) { throw new Exception(); } }
internal static extern int RegOpenKeyEx(IntPtr hKey, String lpSubKey, int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
public static RegistryKey FromHandle (SafeRegistryHandle handle) { if (handle == null) throw new ArgumentNullException ("handle"); return RegistryApi.FromHandle (handle); }
internal static extern int RegDeleteKey(SafeRegistryHandle hKey, String lpSubKey);
internal static extern int RegDeleteKeyEx(SafeRegistryHandle hKey, String lpSubKey, int samDesired, int Reserved);
static extern int RegOverridePredefKey(SafeRegistryHandle key, SafeRegistryHandle newKey);
internal static extern int RegConnectRegistry(String machineName, SafeRegistryHandle key, out SafeRegistryHandle result);
internal RegistrySecurity(SafeRegistryHandle hKey, string name, AccessControlSections includeSections) : base(true, ResourceType.RegistryKey, hKey, includeSections, new NativeObjectSecurity.ExceptionFromErrorCode(RegistrySecurity._HandleErrorCode), null) { new RegistryPermission(RegistryPermissionAccess.NoAccess, AccessControlActions.View, name).Demand(); }
public RegistryKey FromHandle (SafeRegistryHandle handle) { throw new NotImplementedException (); }
public static RegistryKey FromHandle (SafeRegistryHandle handle, RegistryView view) { return FromHandle (handle); }
public static RegistryKey FromHandle(SafeRegistryHandle handle, RegistryView view) { if (handle == null) throw new ArgumentNullException(nameof(handle)); ValidateKeyView(view); return new RegistryKey(handle, writable: true, view: view); }
internal static extern int RegDeleteValue(SafeRegistryHandle hKey, String lpValueName);
/// <summary> /// Creates a RegistryKey. This key is bound to hkey, if writable is <b>false</b> then no write operations will be allowed. /// </summary> private RegistryKey(SafeRegistryHandle hkey, bool writable, RegistryView view) : this(hkey, writable, false, false, false, view) { }
internal static extern int RegFlushKey(SafeRegistryHandle hKey);
public void Dispose() { if (_hkey != null) { if (!IsSystemKey()) { try { _hkey.Dispose(); } catch (IOException) { // we don't really care if the handle is invalid at this point } finally { _hkey = null; } } else if (IsPerfDataKey()) { ClosePerfDataKey(); } } }
/// <summary> /// Close the current registry key and flushes the state of the registry /// right away. /// </summary> public void Close() { Flush (); // a handle to a remote hive must be closed, while one to a local // hive should not be closed if (!isRemoteRoot && IsRoot) return; RegistryApi.Close (this); handle = null; safe_handle = null; }