private static bool ValidateVersion(EnvelopeType ovfEnv, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Version) != 0)
{
if (ovfEnv.version == null)
{
if (ovfEnv.AnyAttr != null && ovfEnv.AnyAttr.Length > 0)
{
foreach (XmlAttribute attr in ovfEnv.AnyAttr)
{
if (attr.Name.ToLower().Contains("version"))
{
ovfEnv.version = attr.Value;
break;
}
}
}
if (ovfEnv.version == null)
{
Log.Warning("Version not set, applying 1.0.0");
ovfEnv.version = "1.0.0";
}
}
if (!Properties.Settings.Default.Versions.Contains(ovfEnv.version))
{
isValid = false;
var message = string.Format(Messages.VALIDATION_INVALID_VERSION, ovfEnv.version);
Log.Warning(message);
validationErrorMessages.Add(message);
}
}
return(isValid);
}
public void AddDetail(ValidationResult detail)
{
detail.Context = this;
EnsureDetails();
IssueType |= detail.IssueType; // adds the values of the detail
_details.Add(detail);
}
void InjectMethodReturnGuard(ValidationFlags localValidationFlags, MethodDefinition method, MethodBody body)
{
var returnPoints = body.Instructions
.Select((o, ix) => new { o, ix })
.Where(a => a.o.OpCode == OpCodes.Ret)
.Select(a => a.ix)
.OrderByDescending(ix => ix);
foreach (var ret in returnPoints)
{
if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) &&
method.ReturnType.IsRefType() &&
method.ReturnType.FullName != typeof(void).FullName &&
!method.IsGetter &&
!nullabilityAnalyzer.AllowsNullReturnValue(method))
{
var errorMessage = string.Format(ReturnValueOfMethodIsNull, method.FullName);
AddReturnNullGuard(method, ret, method.ReturnType, errorMessage, Instruction.Create(OpCodes.Throw));
}
if (localValidationFlags.HasFlag(ValidationFlags.Arguments))
{
foreach (var parameter in method.Parameters.Reverse())
{
// This is no longer the return instruction location, but it is where we want to jump to.
var returnInstruction = body.Instructions[ret];
if (localValidationFlags.HasFlag(ValidationFlags.OutValues) &&
parameter.ParameterType.IsRefType() &&
parameter.ParameterType.IsByReference &&
!parameter.IsIn &&
!nullabilityAnalyzer.AllowsNullOutput(parameter, method))
{
var errorMessage = $"[NullGuard] Out parameter '{parameter.Name}' is null.";
var guardInstructions = new List <Instruction>();
if (isDebug)
{
LoadArgumentOntoStack(guardInstructions, parameter);
CallDebugAssertInstructions(guardInstructions, errorMessage);
}
LoadArgumentOntoStack(guardInstructions, parameter);
IfNull(guardInstructions, returnInstruction, i =>
{
LoadInvalidOperationException(i, errorMessage);
// Throw the top item off the stack
i.Add(Instruction.Create(OpCodes.Throw));
});
body.InsertAtMethodReturnPoint(ret, guardInstructions);
}
}
}
}
}
private void InjectMethodReturnGuard(ValidationFlags localValidationFlags, MethodDefinition method, MethodBody body)
{
var guardInstructions = new List <Instruction>();
var returnPoints = body.Instructions
.Select((o, ix) => new { o, ix })
.Where(a => a.o.OpCode == OpCodes.Ret)
.Select(a => a.ix)
.OrderByDescending(ix => ix);
foreach (var ret in returnPoints)
{
var returnInstruction = body.Instructions[ret];
if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) &&
!method.MethodReturnType.AllowsNull() &&
method.ReturnType.IsRefType() &&
method.ReturnType.FullName != typeof(void).FullName)
{
AddReturnNullGuard(body.Instructions, ret, method.ReturnType, String.Format(CultureInfo.InvariantCulture, STR_ReturnValueOfMethodIsNull, method.FullName), Instruction.Create(OpCodes.Throw));
}
if (localValidationFlags.HasFlag(ValidationFlags.Arguments))
{
foreach (var parameter in method.Parameters.Reverse())
{
// This is no longer the return instruction location, but it is where we want to jump to.
returnInstruction = body.Instructions[ret];
if (localValidationFlags.HasFlag(ValidationFlags.OutValues) &&
parameter.IsOut &&
parameter.ParameterType.IsRefType())
{
guardInstructions.Clear();
if (isDebug)
{
InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter);
InstructionPatterns.CallDebugAssertInstructions(guardInstructions, String.Format(CultureInfo.InvariantCulture, STR_OutParameterIsNull, parameter.Name));
}
InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter);
InstructionPatterns.IfNull(guardInstructions, returnInstruction, i =>
{
InstructionPatterns.LoadInvalidOperationException(i, String.Format(CultureInfo.InvariantCulture, STR_OutParameterIsNull, parameter.Name));
// Throw the top item off the stack
i.Add(Instruction.Create(OpCodes.Throw));
});
body.Instructions.Insert(ret, guardInstructions);
}
}
}
}
}
public ValidationResult ValidateObject(
ValidationResult validationResult,
object objToValidate,
ValidationFlags validationFlags)
{
ValidateObject(validationResult, objToValidate, validationFlags,
System.Threading.Thread.CurrentThread.CurrentUICulture);
return validationResult;
}
/// <summary>
///
/// </summary>
/// <param name="objToValidate">The object that is being validated.</param>
/// <param name="validationFlags">Options used to decide how validation is performed</param>
/// <returns></returns>
public ValidationResult ValidateObject(
object objToValidate,
ValidationFlags validationFlags)
{
ValidationUnitCollection rules = GetRules(objToValidate);
ValidationResult result = new ValidationResult();
return(rules.ValidateObject(result, objToValidate, validationFlags));
}
public void CheckObject(Object objToValidate, ValidationFlags validationFlags)
{
ValidationResult res = ValidateObject(objToValidate, validationFlags);
if (!res)
{
throw new ValidationException(res.Errors);
}
}
public ValidationResult ValidateObject(
ValidationResult validationResult,
object objToValidate,
ValidationFlags validationFlags)
{
ValidateObject(validationResult, objToValidate, validationFlags,
System.Threading.Thread.CurrentThread.CurrentUICulture);
return(validationResult);
}
/// <summary>
/// this is the real function that performs validation.
/// </summary>
/// <param name="actualResult"></param>
/// <param name="objToValidate"></param>
/// <param name="validationFlag"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public override Boolean Validate(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlag,
CultureInfo cultureInfo)
{
var res = mValidator.Validate(objToValidate, validationFlag);
actualResult.Compose(res);
return res.Success;
}
/// <summary>
/// this is the real function that performs validation.
/// </summary>
/// <param name="actualResult"></param>
/// <param name="objToValidate"></param>
/// <param name="validationFlag"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public override Boolean Validate(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlag,
CultureInfo cultureInfo)
{
var res = mValidator.Validate(objToValidate, validationFlag);
actualResult.Compose(res);
return(res.Success);
}
public IntegerValidator(int minValue, int maxValue, bool rangeIsExclusive, int resolution)
{
if (resolution <= 0) throw new ArgumentOutOfRangeException(nameof(resolution));
if (minValue > maxValue)
throw new ArgumentOutOfRangeException(nameof(minValue), SR.Validator_min_greater_than_max);
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolution;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds)
{
if (resolutionInSeconds < 0) throw new ArgumentOutOfRangeException(nameof(resolutionInSeconds));
if (minValue > maxValue)
throw new ArgumentOutOfRangeException(nameof(minValue), SR.Validator_min_greater_than_max);
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolutionInSeconds;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds) {
if (resolutionInSeconds < 0) {
throw new ArgumentOutOfRangeException("resolutionInSeconds");
}
if (minValue > maxValue) {
throw new ArgumentOutOfRangeException("minValue", SR.GetString(SR.Validator_min_greater_than_max));
}
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolutionInSeconds;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
/// <summary>
/// this is the real function that performs validation.
/// </summary>
/// <param name="actualResult"></param>
/// <param name="objToValidate"></param>
/// <param name="validationFlag"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public override Boolean Validate(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlag,
CultureInfo cultureInfo)
{
SingleValidationResult res = mValidator.Validate(objToValidate);
if (!res)
{
actualResult.Success = false;
actualResult.AddErrorMessage(GetErrorMessage(res, cultureInfo), res.SourceName);
}
return(res);
}
public LongValidator(long minValue, long maxValue, bool rangeIsExclusive, long resolution) {
if (resolution <= 0) {
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue) {
throw new ArgumentOutOfRangeException("minValue", SR.GetString(SR.Validator_min_greater_than_max));
}
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolution;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
/// <summary>
/// Validate an object modifying an existing Validation Result.
/// </summary>
/// <param name="actualResult">The result object that contains validation result, it will
/// be populated by this function</param>
/// <param name="objToValidate">The object to be validated.</param>
/// <param name="validationFlags">Options for comparing objects.</param>
/// <param name="cultureInfo">The cultureinfo used to validate the object.</param>
public void ValidateObject(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlags,
CultureInfo cultureInfo)
{
foreach (ValidationUnit vu in mList)
{
if (ValdationFlagsUtils.RecursiveValidation(validationFlags) || vu.IsFirstLevelValidationUnit)
{
Boolean validationResult = vu.Validate(actualResult, objToValidate, validationFlags, cultureInfo);
if (!validationResult && ValdationFlagsUtils.StopOnFirstError(validationFlags)) break;
}
}
}
/// <summary>
/// Validate an object
/// </summary>
/// <param name="objectToValidate"></param>
/// <param name="validationFlags"></param>
/// <returns></returns>
public override ValidationResult Validate(object objectToValidate, ValidationFlags validationFlags)
{
//First of all retrieve the object, if it is null validate.
ValidationResult results = new ValidationResult();
object obj = Extract<Object>(objectToValidate);
if (obj != null)
{
if (obj is IEnumerable)
{
//the object is IEnumerable, we need to validate inner objects
Int32 index = 0;
foreach (var innerObj in obj as IEnumerable)
{
var errors = ValidateSingleObject(innerObj, validationFlags);
foreach (var validationError in errors)
{
results.Success = false;
results.AddErrorMessage(
validationError.Message,
string.Format("{0}[{1}].{2}",mValueExtractor.SourceName, index, validationError.SourceName));
}
index++;
}
}
else
{
//Check if this object support a validation, if we do not have a rule the object should
//be considered valid.
var errors = ValidateSingleObject(obj, validationFlags);
foreach (var validationError in errors)
{
results.AddErrorMessage(
validationError.Message,
mValueExtractor.SourceName + "." + validationError.SourceName);
}
}
return results;
}
return results;
}
public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds)
{
this._minValue = TimeSpan.MinValue;
this._maxValue = TimeSpan.MaxValue;
if (resolutionInSeconds < 0L)
{
throw new ArgumentOutOfRangeException("resolutionInSeconds");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolutionInSeconds;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds)
{
this._minValue = TimeSpan.MinValue;
this._maxValue = TimeSpan.MaxValue;
if (resolutionInSeconds < 0L)
{
throw new ArgumentOutOfRangeException("resolutionInSeconds");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolutionInSeconds;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public IntegerValidator(int minValue, int maxValue, bool rangeIsExclusive, int resolution)
{
this._minValue = -2147483648;
this._maxValue = 0x7fffffff;
this._resolution = 1;
if (resolution <= 0)
{
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolution;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public LongValidator(long minValue, long maxValue, bool rangeIsExclusive, long resolution)
{
if (resolution <= 0)
{
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", SR.GetString(SR.Validator_min_greater_than_max));
}
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolution;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public LongValidator(long minValue, long maxValue, bool rangeIsExclusive, long resolution)
{
this._minValue = -9223372036854775808L;
this._maxValue = 0x7fffffffffffffffL;
this._resolution = 1L;
if (resolution <= 0L)
{
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolution;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public IntegerValidator(int minValue, int maxValue, bool rangeIsExclusive, int resolution)
{
this._minValue = -2147483648;
this._maxValue = 0x7fffffff;
this._resolution = 1;
if (resolution <= 0)
{
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolution;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public IntegerValidator(int minValue, int maxValue, bool rangeIsExclusive, int resolution)
{
if (resolution <= 0)
{
throw new ArgumentOutOfRangeException(nameof(resolution));
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException(nameof(minValue), SR.Validator_min_greater_than_max);
}
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolution;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds)
{
if (resolutionInSeconds < 0)
{
throw new ArgumentOutOfRangeException(nameof(resolutionInSeconds));
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException(nameof(minValue), SR.Validator_min_greater_than_max);
}
_minValue = minValue;
_maxValue = maxValue;
_resolution = resolutionInSeconds;
_flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
public LongValidator(long minValue, long maxValue, bool rangeIsExclusive, long resolution)
{
this._minValue = -9223372036854775808L;
this._maxValue = 0x7fffffffffffffffL;
this._resolution = 1L;
if (resolution <= 0L)
{
throw new ArgumentOutOfRangeException("resolution");
}
if (minValue > maxValue)
{
throw new ArgumentOutOfRangeException("minValue", System.Configuration.SR.GetString("Validator_min_greater_than_max"));
}
this._minValue = minValue;
this._maxValue = maxValue;
this._resolution = resolution;
this._flags = rangeIsExclusive ? ValidationFlags.ExclusiveRange : ValidationFlags.None;
}
/// <summary>
/// Validate an object modifying an existing Validation Result.
/// </summary>
/// <param name="actualResult">The result object that contains validation result, it will
/// be populated by this function</param>
/// <param name="objToValidate">The object to be validated.</param>
/// <param name="validationFlags">Options for comparing objects.</param>
/// <param name="cultureInfo">The cultureinfo used to validate the object.</param>
public void ValidateObject(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlags,
CultureInfo cultureInfo)
{
foreach (ValidationUnit vu in mList)
{
if (ValdationFlagsUtils.RecursiveValidation(validationFlags) || vu.IsFirstLevelValidationUnit)
{
Boolean validationResult = vu.Validate(actualResult, objToValidate, validationFlags, cultureInfo);
if (!validationResult && ValdationFlagsUtils.StopOnFirstError(validationFlags))
{
break;
}
}
}
}
public void Execute()
{
var nullGuardAttribute = ModuleDefinition.GetNullGuardAttribute();
if (nullGuardAttribute == null)
nullGuardAttribute = ModuleDefinition.Assembly.GetNullGuardAttribute();
if (nullGuardAttribute != null)
ValidationFlags = (ValidationFlags)nullGuardAttribute.ConstructorArguments[0].Value;
ReferenceFinder.FindReferences(AssemblyResolver, ModuleDefinition);
var types = new List<TypeDefinition>(ModuleDefinition.GetTypes());
CheckForBadAttributes(types);
ProcessAssembly(types);
RemoveAttributes(types);
RemoveReference();
}
Validate(object objectToValidate, ValidationFlags validationFlags)
{
//First of all retrieve the object, if it is null validate.
ValidationResult results = new ValidationResult();
object obj = Extract <Object>(objectToValidate);
if (obj != null)
{
if (obj is IEnumerable)
{
//the object is IEnumerable, we need to validate inner objects
Int32 index = 0;
foreach (var innerObj in obj as IEnumerable)
{
var errors = ValidateSingleObject(innerObj, validationFlags);
foreach (var validationError in errors)
{
results.Success = false;
results.AddErrorMessage(
validationError.Message,
string.Format("{0}[{1}].{2}", mValueExtractor.SourceName, index, validationError.SourceName));
}
index++;
}
}
else
{
//Check if this object support a validation, if we do not have a rule the object should
//be considered valid.
var errors = ValidateSingleObject(obj, validationFlags);
foreach (var validationError in errors)
{
results.AddErrorMessage(
validationError.Message,
mValueExtractor.SourceName + "." + validationError.SourceName);
}
}
return(results);
}
return(results);
}
protected IEnumerable <ValidationError> ValidateSingleObject(object obj, ValidationFlags validationFlags)
{
Type type = obj.GetType();
if (mRuleMap.ContainsKey(type))
{
ValidationUnitCollection vc = mRuleMap[type];
if (vc.Count > 0)
{
ValidationResult res = new ValidationResult();
vc.ValidateObject(res, obj, validationFlags);
if (!res)
{
return(res.Errors);
}
}
}
return(new ValidationError[] { });
}
private static bool ValidateCpu(RASD_Type[] rasds, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Cpu) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 3)
{
if (rasd.VirtualQuantity == null || rasd.VirtualQuantity.Value <= 0)
{
var message = string.Format(Messages.VALIDATION_INVALID_CPU_QUANTITY, rasd.VirtualQuantity.Value);
Log.Error(message);
validationErrorMessages.Add(message);
break;
}
if (rasd.Limit != null && rasd.VirtualQuantity.Value > rasd.Limit.Value)
{
var message = string.Format(Messages.VALIDATION_INVALID_CPU_EXCEEDS_LIMIT, rasd.VirtualQuantity.Value, rasd.Limit.Value);
Log.Error(message);
validationErrorMessages.Add(message);
isValid = false;
break;
}
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
Log.Info("CPU has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
}
}
}
return(isValid);
}
private static bool ValidateSchema(string ovffilename, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Schema) != 0)
{
try
{
isValid = Tools.ValidateXmlToSchema(ovffilename);
}
catch (Exception ex)
{
isValid = false;
validationErrorMessages.Add(ex.Message);
}
if (!isValid)
{
isValid = false;
Log.Error(Messages.VALIDATION_SCHEMA_FAILED);
validationErrorMessages.Add(Messages.VALIDATION_SCHEMA_FAILED);
}
}
return(isValid);
}
private static bool ValidateMemory(RASD_Type[] rasds, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Memory) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 4)
{
if (rasd.VirtualQuantity == null || rasd.VirtualQuantity.Value <= 0)
{
Log.Error("Memory invalid Virtual Quantity");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_MEMORY_QUANTITY);
isValid = false;
break;
}
if (rasd.AllocationUnits == null || rasd.AllocationUnits.Value.Length <= 0)
{
Log.Error("Memory AllocationUnits not valid");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_MEMORY_ALLOCATIONUNITS);
isValid = false;
break;
}
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
Log.Info("Memory has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
}
}
}
return(isValid);
}
protected IEnumerable<ValidationError> ValidateSingleObject(object obj, ValidationFlags validationFlags)
{
Type type = obj.GetType();
if (mRuleMap.ContainsKey(type))
{
ValidationUnitCollection vc = mRuleMap[type];
if (vc.Count > 0)
{
ValidationResult res = new ValidationResult();
vc.ValidateObject(res, obj, validationFlags);
if (!res)
{
return res.Errors;
}
}
}
return new ValidationError[] { };
}
private void InjectMethodReturnGuard(ValidationFlags localValidationFlags, MethodDefinition method, MethodBody body)
{
var guardInstructions = new List<Instruction>();
var returnPoints = body.Instructions
.Select((o, ix) => new { o, ix })
.Where(a => a.o.OpCode == OpCodes.Ret)
.Select(a => a.ix)
.OrderByDescending(ix => ix);
foreach (var ret in returnPoints)
{
var returnInstruction = body.Instructions[ret];
if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) &&
!method.MethodReturnType.AllowsNull() &&
method.ReturnType.IsRefType() &&
method.ReturnType.FullName != typeof(void).FullName)
{
AddReturnNullGuard(body.Instructions, ret, method.ReturnType, String.Format(CultureInfo.InvariantCulture, STR_ReturnValueOfMethodIsNull, method.FullName), Instruction.Create(OpCodes.Throw));
}
if (localValidationFlags.HasFlag(ValidationFlags.Arguments))
{
foreach (var parameter in method.Parameters.Reverse())
{
// This is no longer the return instruction location, but it is where we want to jump to.
returnInstruction = body.Instructions[ret];
if (localValidationFlags.HasFlag(ValidationFlags.OutValues) &&
parameter.IsOut &&
parameter.ParameterType.IsRefType())
{
guardInstructions.Clear();
if (isDebug)
{
InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter);
InstructionPatterns.CallDebugAssertInstructions(guardInstructions, String.Format(CultureInfo.InvariantCulture, STR_OutParameterIsNull, parameter.Name));
}
InstructionPatterns.LoadArgumentOntoStack(guardInstructions, parameter);
InstructionPatterns.IfNull(guardInstructions, returnInstruction, i =>
{
InstructionPatterns.LoadInvalidOperationException(i, String.Format(CultureInfo.InvariantCulture, STR_OutParameterIsNull, parameter.Name));
// Throw the top item off the stack
i.Add(Instruction.Create(OpCodes.Throw));
});
body.Instructions.Insert(ret, guardInstructions);
}
}
}
}
}
private static bool ValidateVersion(EnvelopeType ovfEnv, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Version) != 0)
{
if (ovfEnv.version == null)
{
if (ovfEnv.AnyAttr != null && ovfEnv.AnyAttr.Length > 0)
{
foreach (XmlAttribute attr in ovfEnv.AnyAttr)
{
if (attr.Name.ToLower().Contains("version"))
{
ovfEnv.version = attr.Value;
break;
}
}
}
if (ovfEnv.version == null)
{
log.Warn("Version not set, applying 1.0.0");
ovfEnv.version = "1.0.0";
}
}
if (!Properties.Settings.Default.Versions.Contains(ovfEnv.version))
{
isValid = false;
var message = string.Format(Messages.VALIDATION_INVALID_VERSION, ovfEnv.version);
log.Warn(message);
validationErrorMessages.Add(message);
}
}
return isValid;
}
public abstract ValidationResult Validate(object objectToValidate, ValidationFlags validationFlags);
internal static Boolean StopOnFirstError(
ValidationFlags value)
{
return (value & ValidationFlags.StopOnFirstError) == ValidationFlags.StopOnFirstError;
}
public MethodProcessor(ValidationFlags validationFlags, bool isDebug, Action <string> logWarn)
{
this.validationFlags = validationFlags;
this.isDebug = isDebug;
this.logWarn = logWarn;
}
private static bool ValidateMemory(RASD_Type[] rasds, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Memory) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 4)
{
if (rasd.VirtualQuantity == null || rasd.VirtualQuantity.Value <= 0)
{
log.Error("Memory invalid Virtual Quantity");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_MEMORY_QUANTITY);
isValid = false;
break;
}
if (rasd.AllocationUnits == null || rasd.AllocationUnits.Value.Length <= 0)
{
log.Error("Memory AllocationUnits not valid");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_MEMORY_ALLOCATIONUNITS);
isValid = false;
break;
}
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
log.Info("Memory has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
}
}
}
return isValid;
}
public PropertyProcessor(ValidationFlags validationFlags, bool isDebug)
{
this.validationFlags = validationFlags;
this.isDebug = isDebug;
}
private static bool ValidateNetworks(NetworkSection_TypeNetwork[] networks, RASD_Type[] rasds, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Networks) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 10)
{
bool linkage = false;
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
Log.Info("Network has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
foreach (NetworkSection_TypeNetwork net in networks)
{
//
// this may only work for Citrix Created VOFs
// haven't looked at others, may need to use a different key to validate linkage.
//
if ((rasd.Connection != null && rasd.Connection.Length > 0 &&
net.name == rasd.Connection[0].Value) ||
(net.Description.msgid == rasd.InstanceID.Value))
{
linkage = true;
}
}
if (!linkage)
{
Log.Error(Messages.VALIDATION_NETWORK_NO_DEVICE);
validationErrorMessages.Add(Messages.VALIDATION_NETWORK_NO_DEVICE);
isValid = false;
break;
}
}
}
}
return(isValid);
}
internal static Boolean RecursiveValidation(
ValidationFlags value)
{
return (value & ValidationFlags.RecursiveValidation) == ValidationFlags.RecursiveValidation;
}
private static bool ValidateNetworks(NetworkSection_TypeNetwork[] networks, RASD_Type[] rasds, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Networks) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 10)
{
bool linkage = false;
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
log.Info("Network has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
foreach (NetworkSection_TypeNetwork net in networks)
{
//
// this may only work for Citrix Created VOFs
// haven't looked at others, may need to use a different key to validate linkage.
//
if ((rasd.Connection != null && rasd.Connection.Length > 0 &&
net.name == rasd.Connection[0].Value) ||
(net.Description.msgid == rasd.InstanceID.Value))
{
linkage = true;
}
}
if (!linkage)
{
log.Error(Messages.VALIDATION_NETWORK_NO_DEVICE);
validationErrorMessages.Add(Messages.VALIDATION_NETWORK_NO_DEVICE);
isValid = false;
break;
}
}
}
}
return isValid;
}
private static bool ValidateSchema(string ovffilename, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Schema) != 0)
{
try
{
isValid = Tools.ValidateXmlToSchema(ovffilename);
}
catch (Exception ex)
{
isValid = false;
validationErrorMessages.Add(ex.Message);
}
if (!isValid)
{
isValid = false;
log.Error(Messages.VALIDATION_SCHEMA_FAILED);
validationErrorMessages.Add(Messages.VALIDATION_SCHEMA_FAILED);
}
}
return isValid;
}
public EnsureNonNullAspect(ValidationFlags validationFlags)
{
ValidationFlags = validationFlags;
}
public MethodProcessor(ValidationFlags validationFlags, bool isDebug)
{
this.validationFlags = validationFlags;
this.isDebug = isDebug;
}
public PropertyProcessor(ValidationFlags validationFlags, bool isDebug)
{
this.validationFlags = validationFlags;
this.isDebug = isDebug;
}
/// <summary>
/// this is the real function that performs validation.
/// </summary>
/// <param name="actualResult"></param>
/// <param name="objToValidate"></param>
/// <param name="validationFlag"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public override Boolean Validate(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlag,
CultureInfo cultureInfo)
{
SingleValidationResult res = mValidator.Validate(objToValidate);
if (!res)
{
actualResult.Success = false;
actualResult.AddErrorMessage(GetErrorMessage(res, cultureInfo), res.SourceName);
}
return res;
}
private static bool ValidateFiles(string ovfpath, File_Type[] files, VirtualDiskDesc_Type[] disks, RASD_Type[] rasds, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Files) != 0)
{
if (files != null && files.Length > 0)
{
foreach (File_Type file in files)
{
string ext = Path.GetExtension(file.href).ToLower();
if (ext == Properties.Settings.Default.manifestFileExtension || ext == Properties.Settings.Default.certificateFileExtension)
continue;
string filename = string.Format(@"{0}{1}{2}", string.IsNullOrEmpty(ovfpath) ? "" : ovfpath,
string.IsNullOrEmpty(ovfpath) ? "" : @"\",
file.href);
if (!File.Exists(filename))
{
var message = string.Format(Messages.VALIDATION_FILE_NOTFOUND, file.href);
validationErrorMessages.Add(message);
log.Error(message);
throw new Exception(message);
}
}
}
else
{
log.Info("ValidateFiles: no attached files defined, continuing");
return isValid;
}
if (isValid)
{
bool validlink = false;
foreach (File_Type file in files)
{
validlink = false;
foreach (VirtualDiskDesc_Type disk in disks)
{
if (file.id == disk.fileRef)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 17 ||
rasd.ResourceType.Value == 19 ||
rasd.ResourceType.Value == 20 ||
rasd.ResourceType.Value == 21)
{
if (rasd.HostResource != null && rasd.HostResource.Length > 0)
{
if (rasd.HostResource[0].Value.Contains(disk.diskId))
{
validlink = true;
break;
}
}
else if (disk.diskId == rasd.InstanceID.Value)
{
validlink = true;
break;
}
}
}
}
}
if (!validlink)
{
log.WarnFormat("Disk linkage [File to RASD] does not exist: {0}", file.href);
break;
}
}
}
}
return isValid;
}
private static bool ValidateCapability(RASD_Type[] rasds, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Capability) != 0)
{
foreach (RASD_Type rasd in rasds)
{
switch (rasd.ResourceType.Value)
{
// CIM SCHEMA 2.19.0
case 3: // Processor
case 4: // Memory
case 5: // IDE Controller
case 6: // Parallel SCSI HBA
case 7: // FC HBA
case 8: // iSCSI HBA
case 9: // IB HCA
case 10: // Ehternet Adapter
case 15: // CD Drive
case 16: // DVD Drive
case 17: // Disk Drive
case 19: // Storage Extent
case 20: // Other storage Device
case 21: // Serial Port // Microsoft uses this for Hard Disk Image also, based on an OLDER schema
{
if (rasd.required)
{
isValid = true;
}
break;
}
case 1: // Other
case 2: // Computer System
case 11: // Other Network Adapter
case 12: // I/O Slot
case 13: // I/O Device
case 14: // Floppy Drive
case 18: // Tape Drive
case 22: // Parallel Port
case 23: // USB Controller
case 24: // Graphics Controller
case 25: // IEEE 1394 Controller
case 26: // Partitionable Unit
case 27: // Base Partitionable Unit
case 28: // Power
case 29: // Cooling Capacity
case 30: // Ethernet Switch Port
case 31: // Logical Disk
case 32: // Storage Volume
case 33: // Ethernet Connection
default:
{
if (rasd.required)
{
var message = string.Format(Messages.VALIDATION_REQUIRED_ELEMENT_NOT_RECOGNIZED, rasd.ResourceType.Value, rasd.ElementName.Value);
log.Error(message);
validationErrorMessages.Add(message);
isValid = false;
}
break;
}
}
if (!isValid)
break;
}
}
return isValid;
}
private static bool ValidateCpu(RASD_Type[] rasds, ValidationFlags validationFlags, ref List<string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Cpu) != 0)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 3)
{
if (rasd.VirtualQuantity == null || rasd.VirtualQuantity.Value <= 0)
{
var message = string.Format(Messages.VALIDATION_INVALID_CPU_QUANTITY, rasd.VirtualQuantity.Value);
log.Error(message);
validationErrorMessages.Add(message);
break;
}
if (rasd.Limit != null && rasd.VirtualQuantity.Value > rasd.Limit.Value)
{
var message = string.Format(Messages.VALIDATION_INVALID_CPU_EXCEEDS_LIMIT, rasd.VirtualQuantity.Value, rasd.Limit.Value);
log.Error(message);
validationErrorMessages.Add(message);
isValid = false;
break;
}
if (rasd.InstanceID == null || rasd.InstanceID.Value.Length <= 0)
{
log.Info("CPU has an invalid InstanceID, creating new.");
validationErrorMessages.Add(Messages.VALIDATION_INVALID_INSTANCEID);
rasd.InstanceID = new cimString(Guid.NewGuid().ToString());
break;
}
}
}
}
return isValid;
}
private static bool ValidateFiles(string ovfpath, File_Type[] files, VirtualDiskDesc_Type[] disks, RASD_Type[] rasds, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Files) != 0)
{
if (files != null && files.Length > 0)
{
foreach (File_Type file in files)
{
string ext = Path.GetExtension(file.href).ToLower();
if (ext == Properties.Settings.Default.manifestFileExtension || ext == Properties.Settings.Default.certificateFileExtension)
{
continue;
}
string filename = string.Format(@"{0}{1}{2}", string.IsNullOrEmpty(ovfpath) ? "" : ovfpath,
string.IsNullOrEmpty(ovfpath) ? "" : @"\",
file.href);
if (!File.Exists(filename))
{
var message = string.Format(Messages.VALIDATION_FILE_NOTFOUND, file.href);
validationErrorMessages.Add(message);
Log.Error(message);
throw new Exception(message);
}
}
}
else
{
Log.Info("ValidateFiles: no attached files defined, continuing");
return(isValid);
}
if (isValid)
{
bool validlink = false;
foreach (File_Type file in files)
{
validlink = false;
foreach (VirtualDiskDesc_Type disk in disks)
{
if (file.id == disk.fileRef)
{
foreach (RASD_Type rasd in rasds)
{
if (rasd.ResourceType.Value == 17 ||
rasd.ResourceType.Value == 19 ||
rasd.ResourceType.Value == 20 ||
rasd.ResourceType.Value == 21)
{
if (rasd.HostResource != null && rasd.HostResource.Length > 0)
{
if (rasd.HostResource[0].Value.Contains(disk.diskId))
{
validlink = true;
break;
}
}
else if (disk.diskId == rasd.InstanceID.Value)
{
validlink = true;
break;
}
}
}
}
}
if (!validlink)
{
Log.Warning("Disk linkage [File to RASD] does not exist: {0}", file.href);
break;
}
}
}
}
return(isValid);
}
public void Execute()
{
LoggerFactory.LogInfo = LogInfo;
LoggerFactory.LogWarn = LogWarn;
LoggerFactory.LogError = LogError;
ReadConfig();
var nullGuardAttribute = ModuleDefinition.GetNullGuardAttribute();
if (nullGuardAttribute == null)
nullGuardAttribute = ModuleDefinition.Assembly.GetNullGuardAttribute();
if (nullGuardAttribute != null)
ValidationFlags = (ValidationFlags)nullGuardAttribute.ConstructorArguments[0].Value;
ReferenceFinder.FindReferences(AssemblyResolver, ModuleDefinition);
var types = GetTypesToProcess();
CheckForBadAttributes(types);
ProcessAssembly(types);
RemoveAttributes(types);
RemoveReference();
}
public DisallowNonNullAspect(ValidationFlags validationFlags)
{
ValidationFlags = validationFlags;
}
protected IEnumerable <ValidationResult> PerformValidation(IPersistEntity ent, bool hierarchical, ValidationFlags validateLevel = ValidationFlags.Properties)
{
var thisEntAdded = false;
var hierResult = new ValidationResult()
{
Item = ent, IssueType = ValidationFlags.None
};
if (validateLevel == ValidationFlags.None)
{
yield break; //nothing to do
}
var expType = ent.ExpressType;
if (validateLevel.HasFlag(ValidationFlags.Properties))
{
foreach (var prop in expType.Properties.Values)
{
var errs = GetSchemaErrors(ent, prop, validateLevel, hierarchical);
foreach (var validationResult in errs)
{
validationResult.IssueType |= ValidationFlags.Properties;
thisEntAdded = UpdateCount(thisEntAdded);
if (hierarchical)
{
hierResult.AddDetail(validationResult);
}
else
{
validationResult.Item = ent;
yield return(validationResult);
}
}
}
}
if (validateLevel.HasFlag(ValidationFlags.Inverses))
{
foreach (var inv in expType.Inverses)
{
var errs = GetSchemaErrors(ent, inv, validateLevel, hierarchical);
foreach (var validationResult in errs)
{
validationResult.IssueType |= ValidationFlags.Inverses;
thisEntAdded = UpdateCount(thisEntAdded);
if (hierarchical)
{
hierResult.AddDetail(validationResult);
}
else
{
validationResult.Item = ent;
yield return(validationResult);
}
}
}
}
if (validateLevel.HasFlag(ValidationFlags.EntityWhereClauses) && ent is IExpressValidatable)
{
var errs = ((IExpressValidatable)ent).Validate();
foreach (var validationResult in errs)
{
thisEntAdded = UpdateCount(thisEntAdded);
if (hierarchical)
{
hierResult.AddDetail(validationResult);
}
else
{
yield return(validationResult);
}
}
}
if (hierarchical && hierResult.IssueType != ValidationFlags.None)
{
// the IssueType is populated if any children have been added.
hierResult.Message = string.Format("Entity #{0} ({1}) has validation failures.", ent.EntityLabel,
expType.Name);
yield return(hierResult);
}
}
private static bool ValidateCapability(RASD_Type[] rasds, ValidationFlags validationFlags, ref List <string> validationErrorMessages)
{
bool isValid = true;
if ((validationFlags & ValidationFlags.Capability) != 0)
{
foreach (RASD_Type rasd in rasds)
{
switch (rasd.ResourceType.Value)
{
// CIM SCHEMA 2.19.0
case 3: // Processor
case 4: // Memory
case 5: // IDE Controller
case 6: // Parallel SCSI HBA
case 7: // FC HBA
case 8: // iSCSI HBA
case 9: // IB HCA
case 10: // Ehternet Adapter
case 15: // CD Drive
case 16: // DVD Drive
case 17: // Disk Drive
case 19: // Storage Extent
case 20: // Other storage Device
case 21: // Serial Port // Microsoft uses this for Hard Disk Image also, based on an OLDER schema
{
if (rasd.required)
{
isValid = true;
}
break;
}
case 1: // Other
case 2: // Computer System
case 11: // Other Network Adapter
case 12: // I/O Slot
case 13: // I/O Device
case 14: // Floppy Drive
case 18: // Tape Drive
case 22: // Parallel Port
case 23: // USB Controller
case 24: // Graphics Controller
case 25: // IEEE 1394 Controller
case 26: // Partitionable Unit
case 27: // Base Partitionable Unit
case 28: // Power
case 29: // Cooling Capacity
case 30: // Ethernet Switch Port
case 31: // Logical Disk
case 32: // Storage Volume
case 33: // Ethernet Connection
default:
{
if (rasd.required)
{
var message = string.Format(Messages.VALIDATION_REQUIRED_ELEMENT_NOT_RECOGNIZED, rasd.ResourceType.Value, rasd.ElementName.Value);
Log.Error(message);
validationErrorMessages.Add(message);
isValid = false;
}
break;
}
}
if (!isValid)
{
break;
}
}
}
return(isValid);
}
/// <summary>
/// this is the real function that performs validation.
/// </summary>
/// <param name="actualResult"></param>
/// <param name="objToValidate"></param>
/// <param name="validationFlag"></param>
/// <param name="cultureInfo"></param>
/// <returns></returns>
public abstract Boolean Validate(
ValidationResult actualResult,
object objToValidate,
ValidationFlags validationFlag,
CultureInfo cultureInfo);
/// <summary>
/// Initializes a new instance of the <see cref="NullGuardAttribute"/> with a <see cref="ValidationFlags"/>.
/// </summary>
/// <param name="flags">The <see cref="ValidationFlags"/> to use for the target this attribute is being applied to.</param>
public NullGuardAttribute(ValidationFlags flags)
{
}
public MethodProcessor(ValidationFlags validationFlags, bool isDebug)
{
this.validationFlags = validationFlags;
this.isDebug = isDebug;
}