private void CopyProperty(IRegistryWrapper sourceKey, IRegistryWrapper destinationKey, string sourceProperty, string destinationProperty, bool writeOnSuccess) { string propertyName = this.GetPropertyName(sourceProperty); this.GetPropertyName(destinationProperty); object obj2 = sourceKey.GetValue(sourceProperty); RegistryValueKind valueKind = sourceKey.GetValueKind(sourceProperty); destinationKey.SetValue(destinationProperty, obj2, valueKind); if (writeOnSuccess) { this.WriteWrappedPropertyObject(obj2, propertyName, sourceKey.Name); } }
private void SetRegistryValue(IRegistryWrapper key, string propertyName, object value, RegistryValueKind kind, string path, bool writeResult) { string valueName = this.GetPropertyName(propertyName); RegistryValueKind unknown = RegistryValueKind.Unknown; if (kind == RegistryValueKind.Unknown) { unknown = GetValueKindForProperty(key, valueName); } if (unknown != RegistryValueKind.Unknown) { try { value = ConvertValueToKind(value, unknown); kind = unknown; } catch (InvalidCastException) { unknown = RegistryValueKind.Unknown; } } if (unknown == RegistryValueKind.Unknown) { if (kind == RegistryValueKind.Unknown) { if (value != null) { kind = GetValueKindFromObject(value); } else { kind = RegistryValueKind.String; } } value = ConvertValueToKind(value, kind); } key.SetValue(valueName, value, kind); if (writeResult) { object obj2 = key.GetValue(valueName); this.WriteWrappedPropertyObject(obj2, propertyName, path); } }
private object ResetRegistryKeyValue(IRegistryWrapper key, string valueName) { RegistryValueKind valueKind = key.GetValueKind(valueName); object obj2 = null; switch (valueKind) { case RegistryValueKind.Unknown: case RegistryValueKind.Binary: obj2 = new byte[0]; break; case RegistryValueKind.String: case RegistryValueKind.ExpandString: obj2 = ""; break; case RegistryValueKind.DWord: obj2 = 0; break; case RegistryValueKind.MultiString: obj2 = new string[0]; break; case RegistryValueKind.QWord: obj2 = 0L; break; } try { key.SetValue(valueName, obj2, valueKind); } catch (IOException exception) { base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.WriteError, valueName)); } catch (SecurityException exception2) { base.WriteError(new ErrorRecord(exception2, exception2.GetType().FullName, ErrorCategory.PermissionDenied, valueName)); } catch (UnauthorizedAccessException exception3) { base.WriteError(new ErrorRecord(exception3, exception3.GetType().FullName, ErrorCategory.PermissionDenied, valueName)); } return obj2; }
/// <summary> /// Sets or creates a registry value on a key. /// </summary> /// /// <param name="key"> /// The key to set or create the value on. /// </param> /// /// <param name="propertyName"> /// The name of the value to set or create. /// </param> /// /// <param name="value"> /// The new data for the value. /// </param> /// /// <param name="kind"> /// The RegistryValueKind of the value. /// </param> /// /// <param name="path"> /// The path to the key that the value is being set on. /// </param> /// /// <param name="writeResult"> /// If true, the value that is set will be written out. /// </param> /// private void SetRegistryValue( IRegistryWrapper key, string propertyName, object value, RegistryValueKind kind, string path, bool writeResult) { Dbg.Diagnostics.Assert( key != null, "Caller should have verified key"); string propertyNameToSet = GetPropertyName(propertyName); RegistryValueKind existingKind = RegistryValueKind.Unknown; // If user does not specify a kind: get the valuekind if the property // already exists if (kind == RegistryValueKind.Unknown) { existingKind = GetValueKindForProperty(key, propertyNameToSet); } // try to do a conversion based on the existing kind, if we // were able to retrieve one if (existingKind != RegistryValueKind.Unknown) { try { value = ConvertValueToKind(value, existingKind); kind = existingKind; } catch (InvalidCastException) { // failed attempt, we reset to unknown to let the // default conversion process take over existingKind = RegistryValueKind.Unknown; } } // set the kind as defined by the user if (existingKind == RegistryValueKind.Unknown) { // we use to kind passed in, either because we had // a valid one or because we failed to retrieve an existing kind to match if (kind == RegistryValueKind.Unknown) { // set the kind based on value if (value != null) { kind = GetValueKindFromObject(value); } else { // if no value and unknown kind, then default to empty string kind = RegistryValueKind.String; } } value = ConvertValueToKind(value, kind); } key.SetValue(propertyNameToSet, value, kind); if (writeResult) { // Now write out the value object newValue = key.GetValue(propertyNameToSet); WriteWrappedPropertyObject(newValue, propertyName, path); } } // SetRegistryValue
/// <summary> /// IT resets the a registry key value to its default /// </summary> /// <param name="key">Key whose value has to be reset</param> /// <param name="valueName">name of the value to reset</param> /// <returns>default value the key was set to</returns> private object ResetRegistryKeyValue(IRegistryWrapper key, string valueName) { RegistryValueKind valueKind = key.GetValueKind(valueName); object defaultValue = null; switch (valueKind) { // NOTICE: we assume that an unknown type is treated as // the same as a binary blob case RegistryValueKind.Binary: case RegistryValueKind.Unknown: { defaultValue = new byte[0]; } break; case RegistryValueKind.DWord: { defaultValue = (int)0; } break; case RegistryValueKind.ExpandString: case RegistryValueKind.String: { defaultValue = ""; } break; case RegistryValueKind.MultiString: { defaultValue = new string[0]; } break; case RegistryValueKind.QWord: { defaultValue = (long)0; } break; } try { key.SetValue(valueName, defaultValue, valueKind); } catch (System.IO.IOException ioException) { // An exception occurred while trying to set the value. Write // out the error. WriteError(new ErrorRecord(ioException, ioException.GetType().FullName, ErrorCategory.WriteError, valueName)); } catch (System.Security.SecurityException securityException) { // An exception occurred while trying to set the value. Write // out the error. WriteError(new ErrorRecord(securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, valueName)); } catch (System.UnauthorizedAccessException unauthorizedAccessException) { // An exception occurred while trying to get the key. Write // out the error. WriteError(new ErrorRecord(unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, valueName)); } return defaultValue; }
private void CopyProperty( IRegistryWrapper sourceKey, IRegistryWrapper destinationKey, string sourceProperty, string destinationProperty, bool writeOnSuccess) { string realSourceProperty = GetPropertyName(sourceProperty); string realDestinationProperty = GetPropertyName(destinationProperty); object sourceValue = sourceKey.GetValue(sourceProperty); RegistryValueKind sourceKind = sourceKey.GetValueKind(sourceProperty); destinationKey.SetValue(destinationProperty, sourceValue, sourceKind); if (writeOnSuccess) { WriteWrappedPropertyObject(sourceValue, realSourceProperty, sourceKey.Name); } } // CopyProperty