public static CustomAttribute Clone(CustomAttribute custattr, ModuleDefinition context,
IImportMapper mapper)
{
var ca = new CustomAttribute(context.Import(custattr.Constructor, mapper));
custattr.CopyTo(ca, context, mapper);
return ca;
}
public void CopyTo(CustomAttribute target, ModuleDefinition context,
IImportMapper mapper)
{
foreach (var arg in ConstructorArguments)
target.ConstructorArguments.Add(
new CustomAttributeArgument(context.Import(arg.Type, mapper), arg.Value));
foreach (var field in Fields)
target.Fields.Add(
new CustomAttributeNamedArgument(field.Name, new CustomAttributeArgument(context.Import(field.Argument.Type, mapper), field.Argument.Value)));
foreach (var prop in Properties)
target.Properties.Add(
new CustomAttributeNamedArgument(prop.Name, new CustomAttributeArgument(context.Import(prop.Argument.Type, mapper), prop.Argument.Value)));
}
private readonly IHttpRequestHelper _helper; // Helper class
/// <summary>
/// Ctor: Accepts injected dataservice
/// </summary>
/// <param name="dataService">The DataService instance being injected</param>
/// <param name="mapper"></param>
/// <param name="generator">The Hypermedia link generator</param>
/// <param name="helper">The helper class instance</param>
public ImportController(IDataService dataService, IImportMapper mapper, IImportLinkGenerator generator, IHttpRequestHelper helper)
{
if (dataService == null)
throw new ArgumentNullException("dataService", "No valid dataservice supplied to the controller.");
if (mapper == null)
throw new ArgumentNullException("mapper", "No valid mapper supplied to the controller.");
if (generator == null)
throw new ArgumentNullException("generator", "No valid link generator supplied to the controller.");
if (helper == null)
throw new ArgumentNullException("helper", "No valid helper supplied to the controller.");
_service = dataService;
_mapper = mapper;
_generator = generator;
_helper = helper;
}
public ImportService(
IImportRepository importRepository,
IHostRepository hostRepository,
IVulnerabilityRepository vulnerabilityRepository,
IHostVulnerabilityRepository hostVulnerabilityRepository,
IFactory csvFactory,
IImportMapper importMapper,
IImportVulnerabilityMapper importVulnerabilityMapper,
IImportHostMapper importHostMapper,
ICryptographyService cryptographyService)
{
_csvFactory = csvFactory;
_importMapper = importMapper;
_importVulnerabilityMapper = importVulnerabilityMapper;
_importHostMapper = importHostMapper;
_cryptographyService = cryptographyService;
_importRepository = importRepository;
_hostRepository = hostRepository;
_vulnerabilityRepository = vulnerabilityRepository;
_hostVulnerabilityRepository = hostVulnerabilityRepository;
}
internal TypeReference ImportType(TypeReference type, ImportGenericContext context,
IImportMapper mapper)
{
if (type.IsTypeSpecification())
return ImportTypeSpecification(type, context, mapper);
var mapped = mapper.MapType(type);
if (mapped == null)
mapped = type;
var reference = new TypeReference(
mapped.Namespace,
mapped.Name,
module,
ImportScope(mapper.MapMetadataScope(type.Scope)),
mapped.IsValueType);
MetadataSystem.TryProcessPrimitiveTypeReference(reference);
if (mapped.IsNested)
reference.DeclaringType = ImportType(mapped.DeclaringType, context, mapper);
if (mapped.HasGenericParameters)
ImportGenericParameters(reference, mapped);
return reference;
}
MethodSpecification ImportMethodSpecification(MethodReference method, ImportGenericContext context,
IImportMapper mapper)
{
if (!method.IsGenericInstance)
throw new NotSupportedException ();
var instance = (GenericInstanceMethod) method;
var element_method = ImportMethod(instance.ElementMethod, context, mapper);
var imported_instance = new GenericInstanceMethod (element_method);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add(ImportType(arguments[i], context, mapper));
return imported_instance;
}
internal MethodReference ImportMethod(MethodReference method, ImportGenericContext context,
IImportMapper mapper)
{
if (method.IsGenericInstance)
return ImportMethodSpecification(method, context, mapper);
var mapped = mapper.MapMethod(method);
if (mapped == null)
mapped = method;
var declaring_type = ImportType(mapped.DeclaringType, context, mapper);
var reference = new MethodReference {
Name = mapped.Name,
HasThis = mapped.HasThis,
ExplicitThis = mapped.ExplicitThis,
DeclaringType = declaring_type,
CallingConvention = mapped.CallingConvention,
};
if (mapped.HasGenericParameters)
ImportGenericParameters(reference, mapped);
context.Push (reference);
try {
reference.ReturnType = ImportType(mapped.ReturnType, context, mapper);
if (!mapped.HasParameters)
return reference;
var reference_parameters = reference.Parameters;
var parameters = mapped.Parameters;
for (int i = 0; i < parameters.Count; i++)
reference_parameters.Add (
new ParameterDefinition(ImportType(parameters[i].ParameterType, context, mapper)));
return reference;
} finally {
context.Pop();
}
}
internal FieldReference ImportField(FieldReference field, ImportGenericContext context,
IImportMapper mapper)
{
var mapped = mapper.MapField(field);
if (mapped == null)
mapped = field;
var declaring_type = ImportType(mapped.DeclaringType, context, mapper);
context.Push (declaring_type);
try {
return new FieldReference {
Name = mapped.Name,
DeclaringType = declaring_type,
FieldType = ImportType(mapped.FieldType, context, mapper),
};
} finally {
context.Pop ();
}
}
public TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context,
IImportMapper mapper)
{
switch (type.etype) {
case ElementType.SzArray:
var vector = (ArrayType) type;
return new ArrayType(ImportType(vector.ElementType, context, mapper));
case ElementType.Ptr:
var pointer = (PointerType) type;
return new PointerType(ImportType(pointer.ElementType, context, mapper));
case ElementType.ByRef:
var byref = (ByReferenceType) type;
return new ByReferenceType(ImportType(byref.ElementType, context, mapper));
case ElementType.Pinned:
var pinned = (PinnedType) type;
return new PinnedType(ImportType(pinned.ElementType, context, mapper));
case ElementType.Sentinel:
var sentinel = (SentinelType) type;
return new SentinelType(ImportType(sentinel.ElementType, context, mapper));
case ElementType.CModOpt:
var modopt = (OptionalModifierType) type;
return new OptionalModifierType (
ImportType(modopt.ModifierType, context, mapper),
ImportType(modopt.ElementType, context, mapper));
case ElementType.CModReqD:
var modreq = (RequiredModifierType) type;
return new RequiredModifierType (
ImportType(modreq.ModifierType, context, mapper),
ImportType(modreq.ElementType, context, mapper));
case ElementType.Array:
var array = (ArrayType) type;
var imported_array = new ArrayType(ImportType(array.ElementType, context, mapper));
if (array.IsVector)
return imported_array;
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear ();
for (int i = 0; i < dimensions.Count; i++) {
var dimension = dimensions [i];
imported_dimensions.Add (new ArrayDimension (dimension.LowerBound, dimension.UpperBound));
}
return imported_array;
case ElementType.GenericInst:
var instance = (GenericInstanceType) type;
var element_type = ImportType(instance.ElementType, context, mapper);
var imported_instance = new GenericInstanceType (element_type);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add(ImportType(arguments[i], context, mapper));
return imported_instance;
case ElementType.Var:
var var_parameter = (GenericParameter) type;
return context.TypeParameter(type.DeclaringType, var_parameter.Position, mapper);
case ElementType.MVar:
var mvar_parameter = (GenericParameter) type;
return context.MethodParameter(mvar_parameter.DeclaringMethod, mvar_parameter.Position, mapper);
}
throw new NotSupportedException (type.etype.ToString ());
}
public TypeReference TypeParameter(TypeReference tref, int position, IImportMapper typeMapper)
{
var mapped = typeMapper.MapTypeGenericParameter(tref, position);
if (mapped != null)
return mapped;
for (int i = stack.Count - 1; i >= 0; i--) {
var candidate = GenericTypeFor (stack [i]);
mapped = typeMapper.MapType(tref);
var name = mapped != null ? mapped.FullName : tref.FullName;
if (candidate.FullName != name)
continue;
return candidate.GenericParameters [position];
}
throw new InvalidOperationException ();
}
public TypeReference MethodParameter(MethodReference method, int position, IImportMapper mapper)
{
var mapped = mapper.MapMethodGenericParameter(method, position);
if (mapped != null)
return mapped;
for (int i = stack.Count - 1; i >= 0; i--) {
var candidate = stack [i] as MethodReference;
if (candidate == null)
continue;
var mappedMethod = mapper.MapMethod(candidate);
var name = mappedMethod != null ? mappedMethod.Name : method.Name;
if (method.Name != name)
continue;
return candidate.GenericParameters [position];
}
throw new InvalidOperationException ();
}
