public void SaveValueRemote(string key, string name, string value) { Microsoft.Win32.RegistryValueKind regValueKind = GetValueKind(name); RegistryKey regKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, this._remoteName).OpenSubKey(key, true); regKey.SetValue(name, value, regValueKind); }
private static bool RegisterModem(IntPtr hDeviceInfoSet, ref Win32Wrapper.SP_DEVINFO_DATA devInfoElem, string PortName, ref Win32Wrapper.SP_DRVINFO_DATA drvData) { if (!Win32Wrapper.SetupDiRegisterDeviceInfo(hDeviceInfoSet, ref devInfoElem, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero)) { return(false); } IntPtr hKeyDev = Win32Wrapper.SetupDiOpenDevRegKey(hDeviceInfoSet, ref devInfoElem, (uint)Win32Wrapper.DICS_FLAG.DICS_FLAG_GLOBAL, 0, (uint)Win32Wrapper.DIREG.DIREG_DEV, (uint)Win32Wrapper.REGKEYSECURITY.KEY_READ); if (hKeyDev.ToInt64() == INVALID_HANDLE_VALUE && Marshal.GetLastWin32Error() == (int)Win32Wrapper.WinErrors.ERROR_KEY_DOES_NOT_EXIST) { hKeyDev = Win32Wrapper.SetupDiCreateDevRegKey(hDeviceInfoSet, ref devInfoElem, (int)Win32Wrapper.DICS_FLAG.DICS_FLAG_GLOBAL, 0, (int)Win32Wrapper.DIREG.DIREG_DRV, IntPtr.Zero, IntPtr.Zero); if (hKeyDev.ToInt64() == INVALID_HANDLE_VALUE) { return(false); } } bool check = Win32Wrapper.SetupDiRegisterDeviceInfo(hDeviceInfoSet, ref devInfoElem, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); if (!Win32Wrapper.SetupDiGetSelectedDriver(hDeviceInfoSet, ref devInfoElem, ref drvData)) { int err = Marshal.GetLastWin32Error(); Console.WriteLine("No driver selected"); } Microsoft.Win32.RegistryValueKind RegType = Microsoft.Win32.RegistryValueKind.String; int size = (PortName.Length + 1) * Marshal.SystemDefaultCharSize; int ret = Win32Wrapper.RegSetValueEx(hKeyDev, "AttachedTo", 0, (uint)RegType, PortName, (uint)size); Win32Wrapper.RegCloseKey(hKeyDev); return(true); }
static extern int RegSetValueEx( IntPtr hKey, [MarshalAs(UnmanagedType.LPStr)] string lpValueName, int Reserved, Microsoft.Win32.RegistryValueKind dwType, [MarshalAs(UnmanagedType.LPStr)] string lpData, int cbData);
static extern Int32 RegSetValueEx( UInt32 hKey, [MarshalAs(UnmanagedType.LPStr)] String lpValueName, Int32 Reserved, Microsoft.Win32.RegistryValueKind dwType, IntPtr lpData, Int32 cbData);
public static extern int CM_Get_DevNode_Registry_Property( uint deviceInstance, uint property, out Microsoft.Win32.RegistryValueKind pulRegDataType, IntPtr buffer, ref uint length, uint flags);
/// <summary> /// Sets or deletes the desired registry value using the designated registry value kind. /// Will create the specified subkey if it does not exist. /// </summary> /// <remarks> /// This will use the following value types: /// int => DWORD /// byte[] => Binary /// string[] => MultiString /// other array => FAILS /// other => String /// </remarks> /// <param name="hive">The root key to use.</param> /// <param name="subkeyName">Subkey name or subpath.</param> /// <param name="valueName">Name of value</param> /// <param name="value">The value to set or null to delete the existing value, if any.</param> /// <param name="valueKind">Kind of registry value</param> /// <returns>'true' if successful.</returns> public static bool SetRegistryValue <T>(RegistryHive hive, string subkeyName, string valueName, T value) { // Causes the behavior detailed in the remarks above Win32.RegistryValueKind valueKind = Win32.RegistryValueKind.Unknown; Win32.RegistryKey registryKey = GetHive(hive); var registrySubkey = OpenSubkey(registryKey, subkeyName, writable: true); if (registrySubkey == null) { // Key not found, now create it if (value == null) { // No point in creating a subkey for a value we're going to delete return(true); } Exception exception = RegistryExceptionWrapper(() => registrySubkey = registryKey.CreateSubKey(subkeyName)); if (exception != null) { Debug.WriteLine("Unable to create sub key '{0}'. Exception follows: \n{1}", subkeyName, exception); return(false); } } if (registrySubkey != null) { try { Exception exception = null; if (value == null) { // Value specified is null- delete exception = RegistryExceptionWrapper(() => registrySubkey.DeleteValue(valueName, false)); } else { // Normal set exception = RegistryExceptionWrapper(() => registrySubkey.SetValue(valueName, value, valueKind)); } if (exception != null) { Debug.WriteLine("Unable to set value '{0}'. Exception follows: \n{1}", valueName, exception); return(false); } else { return(true); } } finally { registrySubkey.Close(); } } return(false); }
public void SaveValue(string key, string name, string value) { Microsoft.Win32.RegistryValueKind regValueKind = GetValueKind(name); RegistryKey regKey = Registry.LocalMachine.OpenSubKey(key); Registry.SetValue(regKey.ToString(), name, value, regValueKind); }
/// <summary> /// Installs all registry values packaged in the installer to the local device /// </summary> public void InstallRegValues() { m_failedRegVals = 0; if (m_descriptor.RegistryKeys == null) { return; } foreach (InstallerRegistryKey key in m_descriptor.RegistryKeys) { string keyName = string.Format("{0}{1}", m_descriptor.GetHiveByHiveID(key.HiveID).ToString(), m_descriptor.GetSubkeyByHiveID(key.HiveID)); string valueName = string.Copy(key.ValueName); Microsoft.Win32.RegistryValueKind valueKind = Microsoft.Win32.RegistryValueKind.Unknown; switch (key.KeyType & (~RegistyKeyType.NoClobber)) { case RegistyKeyType.Binary: valueKind = Microsoft.Win32.RegistryValueKind.Binary; break; case RegistyKeyType.MultiString: valueKind = Microsoft.Win32.RegistryValueKind.MultiString; break; case RegistyKeyType.Number: valueKind = Microsoft.Win32.RegistryValueKind.DWord; break; case RegistyKeyType.String: valueKind = Microsoft.Win32.RegistryValueKind.String; break; } byte[] data = (byte[])key.Data.Clone(); RegistryInstallInfo registryInfo = new RegistryInstallInfo(((key.KeyType & RegistyKeyType.NoClobber) == RegistyKeyType.NoClobber), keyName, valueName, valueKind, data); try { OnInstallRegValue(ref registryInfo); } catch (Exception ex) { if (RegistryFailure != null) { bool cancel = false; RegistryFailure(registryInfo, ex, ref cancel); if (!cancel) { m_failedRegVals++; } } else { m_failedRegVals++; } } } }
public static extern uint RegQueryValueEx( UIntPtr hKey, String lpValueName, Int32 lpReserved, ref MW32.RegistryValueKind lpType, IntPtr lpData, ref Int32 lpcbData );
public static extern uint RegQueryValueEx( uint kHey, string lpValueName, int lpReserved, ref Microsoft.Win32.RegistryValueKind lpType, ref uint lpData, ref uint lpcbData );
/// <summary> /// 在注册表里添加键值 /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="valueKind"></param> public void SetValue(string name, string value, Microsoft.Win32.RegistryValueKind valueKind) { try { softWare.SetValue(name, value, valueKind); } catch (Exception ex) { MessageBox.Show("出现异常:" + ex); } }
/// <summary> /// Sets a value in the registry. /// </summary> /// <param name="RegHiveKeyValue">The path to the registry key to set, including: hive, subkey, and value name.</param> /// <param name="Value">The value to write to the registry key.</param> /// <param name="ValueKind">The kind of value to write to the registry key.</param> /// <returns>True if succeeded, false otherwise.</returns> public static bool SetRegistryKey(string RegHiveKeyValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String) { string[] pieces = RegHiveKeyValue.Split(Path.DirectorySeparatorChar); if (!pieces.Any()) { return(false); } string RegHiveKey = ""; for (int i = 1; i < pieces.Length - 1; i++) { RegHiveKey = pieces[i] + Path.DirectorySeparatorChar; } return(SetRegistryKey(ConvertToRegistryHive(pieces.First()), RegHiveKey.Trim(Path.DirectorySeparatorChar), pieces[pieces.Length - 1], Value, ValueKind)); }
static bool Registry_Write(string index, object val, Microsoft.Win32.RegistryValueKind valkind) { try { if (Registry.GetValue("HKEY_CURRENT_USER\\Software\\CBomb", "Infected", false) == null /* hacky way to do the thing*/) { Registry.CurrentUser.CreateSubKey("Software\\CBomb"); } Registry.SetValue("HKEY_CURRENT_USER\\Software\\CBomb", index, val, valkind); return(true); } catch (Exception) { return(false); } }
//TODO: Refactor, Move to a More be-fitting Class internal void SetRegValueHKLM(string regkeyfolder, string paramname, string paramvalue, Microsoft.Win32.RegistryValueKind keytype) { try { RegistryKey myKey = Registry.LocalMachine.OpenSubKey(regkeyfolder, true); if (myKey != null) { myKey.SetValue(paramname, paramvalue, keytype); myKey.Close(); } } catch (Exception ex) { // fatalerrors++; logger.output(logger.GetTranslateText("Error") + ": " + ex.Message); } }
private void SetRegValueHKCU(string regkeyfolder, string paramname, string paramvalue, Microsoft.Win32.RegistryValueKind keytype) { try { RegistryKey myKey = Registry.CurrentUser.OpenSubKey(regkeyfolder, true); if (myKey != null) { myKey.SetValue(paramname, paramvalue, keytype); myKey.Close(); } } catch (Exception ex) { fatalerrors++; output(GetTranslateText("Error") + ": " + ex.Message); } }
/// <summary> /// Set registry value, creating the key if neccesary. With support for 32 and 64 bit registries /// </summary> /// <param name="keyAndValue">Key name in format [\\machineName]RootKey[:32|:64]\subkey\value</param> /// <param name="value">Value to set</param> /// <param name="kind">Registry value kind</param> /// <returns>previous value, or null if didn't exist</returns> public static object RegistrySet(string keyAndValue, object value, Microsoft.Win32.RegistryValueKind kind) { if (keyAndValue == null) { throw new ArgumentNullException("keyAndValue"); } object ret = RegistryGet(keyAndValue, null); using (RegW64Helper rn = new RegW64Helper(keyAndValue)) { using (var rk = rn.Create(RegistryKeyPermissionCheck.Default)) { if (value == null) { rk.DeleteValue(rn.ValueName, false); } else { rk.SetValue(rn.ValueName, value, kind); } } } return(ret); }
public static bool CheckRegistryValueExist(eRegistryRoot rootType, string keyPath, string paramterName, object expectedValue, Microsoft.Win32.RegistryValueKind expectedValueType, bool addValueIfMissing, bool silentMode) { bool addValue = false; try { if ((GetRegistryValue(rootType, keyPath, paramterName) != null) && GetRegistryValue(rootType, keyPath, paramterName).ToString() == expectedValue.ToString()) { return(true); } else { if (addValueIfMissing) { if (silentMode) { addValue = true; } else { //ask user if ((Reporter.ToUser(eUserMsgKey.AddRegistryValue, rootType + "\\" + keyPath)) == eUserMsgSelection.Yes) { addValue = true; } else { return(false); } } } else { return(false); } if (addValue) { //create the registry key if needed if (CreateRegistryKey(rootType, keyPath)) { //add the registry value if (SetRegistryValue(rootType, keyPath, paramterName, expectedValue, expectedValueType)) { //succeed to add the value if (!silentMode) { //show success to user Reporter.ToUser(eUserMsgKey.AddRegistryValueSucceed, rootType + "\\" + keyPath); } return(true); } else { //failed to add the value if (!silentMode) { //show failure to user Reporter.ToUser(eUserMsgKey.AddRegistryValueFailed, rootType + "\\" + keyPath); } return(false); } } else { if (!silentMode) { //show failure to user Reporter.ToUser(eUserMsgKey.AddRegistryValueFailed, rootType + "\\" + keyPath); } return(false); } } } return(false); } catch (Exception ex) { Reporter.ToLog(eLogLevel.ERROR, "Failed to complete the registry value check for the key: " + rootType + "\\" + keyPath, ex); if (!silentMode) { Reporter.ToUser(eUserMsgKey.RegistryValuesCheckFailed); } return(false); } }
internal RegistryValue(string name, Microsoft.Win32.RegistryValueKind type, string value) { ValueName = name; Type = type; Value = value; }
/// <summary> /// Sets a value in the registry. /// </summary> /// <param name="RegHiveKey">The RegistryKey to set.</param> /// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param> /// <param name="Value">The value to write to the registry key.</param> /// <param name="ValueKind">The kind of value to write to the registry key.</param> /// <returns>True if succeeded, false otherwise.</returns> private static bool SetRegistryKeyValue(Win.RegistryKey RegHiveKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String) { try { RegHiveKey.SetValue(RegValue, Value, ValueKind); return(true); } catch (Exception e) { Console.Error.WriteLine(e.GetType().FullName + ": " + e.Message); return(false); } }
/// <summary> /// Sets a value in the registry. /// </summary> /// <param name="Hostname">Remote hostname to connect to for remote registry.</param> /// <param name="RegHive">The RegistryHive to set within.</param> /// <param name="RegKey">The RegistryKey to set, including the hive.</param> /// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param> /// <param name="Value">The value to write to the registry key.</param> /// <param name="ValueKind">The kind of value to write to the registry key.</param> /// <returns>True if succeeded, false otherwise.</returns> public static bool SetRemoteRegistryKey(string Hostname, string RegHive, string RegKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String) { return(SetRemoteRegistryKey(Hostname, ConvertToRegistryHive(RegHive), RegKey, RegValue, Value, ValueKind)); }
/// <summary> /// Sets a value in the registry. /// </summary> /// <param name="Hostname">Remote hostname to connect to for remote registry.</param> /// <param name="RegHive">The RegistryHive to set within.</param> /// <param name="RegKey">The RegistryKey to set, including the hive.</param> /// <param name="RegValue">The name of name/value pair to write to in the RegistryKey.</param> /// <param name="Value">The value to write to the registry key.</param> /// <param name="ValueKind">The kind of value to write to the registry key.</param> /// <returns>True if succeeded, false otherwise.</returns> public static bool SetRemoteRegistryKey(string Hostname, Win.RegistryHive RegHive, string RegKey, string RegValue, object Value, Win.RegistryValueKind ValueKind = Win.RegistryValueKind.String) { Win.RegistryKey baseKey = null; switch (RegHive) { case Win.RegistryHive.CurrentUser: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentUser, Hostname); break; case Win.RegistryHive.LocalMachine: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.LocalMachine, Hostname); break; case Win.RegistryHive.ClassesRoot: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.ClassesRoot, Hostname); break; case Win.RegistryHive.CurrentConfig: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentConfig, Hostname); break; case Win.RegistryHive.Users: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.Users, Hostname); break; default: baseKey = Win.RegistryKey.OpenRemoteBaseKey(Win.RegistryHive.CurrentUser, Hostname); break; } string[] pieces = RegKey.Split(Path.DirectorySeparatorChar); for (int i = 0; i < pieces.Length; i++) { string[] subkeynames = baseKey.GetSubKeyNames(); if (!subkeynames.Contains(pieces[i], StringComparer.OrdinalIgnoreCase)) { baseKey = baseKey.CreateSubKey(pieces[i]); } else { baseKey = baseKey.OpenSubKey(pieces[i], true); } } return(SetRegistryKeyValue(baseKey, RegValue, Value, ValueKind)); }