public static bool doesControllerFunctionCallFunction(ICirData cirData, SpringMvcController springMcvController, List <string> functionsToSearch, bool recursiveFunctionSearch)
{
if (cirData == null)
{
return(false);
}
if (cirData.dFunctions_bySignature.ContainsKey(springMcvController.JavaClassAndFunction))
{
var cirFunction = cirData.dFunctions_bySignature[springMcvController.JavaClassAndFunction];
var targetFunctions = recursiveFunctionSearch ? CirSearch.calculateListOfAllFunctionsCalled(cirFunction) : cirFunction.FunctionsCalledUniqueList;
DI.log.info("{0} called functions in {1}", targetFunctions.Count, cirFunction.FunctionSignature);
foreach (var calledCirFunction in targetFunctions)
{
if (functionsToSearch.Contains(calledCirFunction.FunctionSignature))
{
return(true);
}
}
}
else
{
DI.log.error("could not find function: {0}", springMcvController.JavaClassAndFunction);
}
return(false);
}
public static List<String> findClassesThatImplementTheSpringMvc(ICirData fadCirData)
{
var lResolvedClasses = new List<String>();
if (fadCirData == null)
{
DI.log.error("in findClassesThatImplementTheSpringMvc: CirData object is null");
return lResolvedClasses;
}
var sSpringMvcClass = "org.springframework.web.servlet.mvc";
var dClassesThatSuperClassSpringMVC = new Dictionary<String, ICirClass>();
// first find which classes direcly implement a Spring MVC
foreach (ICirClass ccCirClass in fadCirData.dClasses_bySignature.Values)
{
foreach (String sSuperClass in ccCirClass.dSuperClasses.Keys)
{
String sSuperClassSignature = ccCirClass.dSuperClasses[sSuperClass].Signature;
if (sSuperClassSignature.IndexOf(sSpringMvcClass) > -1)
// && ccCirClass.sSignature.IndexOf(sBaseClass) > -1)
{
String sSignatureAndSuperClass = String.Format("{0} <-- {1}", ccCirClass.Signature,
ccCirClass.dSuperClasses[sSuperClass].Signature);
dClassesThatSuperClassSpringMVC.Add(sSignatureAndSuperClass, ccCirClass);
// DI.log.debug("{0} <-- {1}" , ccCirClass.sSignature, ccCirClass.dSuperClasses[sSuperClass].sSignature);
}
}
}
findAllClassesThatSuperClassProvidedList_recursive(dClassesThatSuperClassSpringMVC, lResolvedClasses);
DI.log.debug("There are {0} classes that implement Spring MVC", lResolvedClasses.Count);
return lResolvedClasses;
// DI.log.debug("Loaded with {0} classes", fadCirData.dClasses_bySignature.Keys.Count);
}
public void Test_LoadingAssembly(ICirData cirData, string assemblyToLoad, bool verify, bool verbose)
{
AssemblyDefinition assemblyDefinition = CecilUtils.getAssembly(assemblyToLoad);
if (assemblyDefinition == null)
{
return;
}
var loadTimer = new O2Timer("Assembly " + Path.GetFileName(assemblyToLoad) + " Loaded in");
if (verbose)
{
loadTimer.start();
}
cirFactory.processAssemblyDefinition(cirData, assemblyDefinition, assemblyToLoad);
if (verbose)
{
loadTimer.stop();
}
if (verify)
{
var checkTimer = new O2Timer(" functions checked in ");
if (verbose)
{
checkTimer.start();
}
checkThatAllFunctionsMatch(cirData, assemblyDefinition);
if (verbose)
{
checkTimer.stop();
}
}
}
public static void removeO2CirDataFile(ICirDataAnalysis cirDataAnalysis, String sO2CirDataFileToRemove)
{
if (cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(sO2CirDataFileToRemove))
{
ICirData fcdCirData = cirDataAnalysis.dCirDataFilesLoaded[sO2CirDataFileToRemove];
cirDataAnalysis.dCirDataFilesLoaded.Remove(sO2CirDataFileToRemove);
foreach (ICirClass ccCirClass in fcdCirData.dClasses_bySignature.Values)
{
if (cirDataAnalysis.dCirClass.ContainsKey(ccCirClass))
{
cirDataAnalysis.dCirClass.Remove(ccCirClass);
cirDataAnalysis.dCirClass_bySignature.Remove(ccCirClass.Signature);
foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values)
{
if (cirDataAnalysis.dCirFunction.ContainsKey(cfCirFunction))
{
cirDataAnalysis.dCirFunction.Remove(cfCirFunction);
cirDataAnalysis.dCirFunction_bySignature.Remove(cfCirFunction.FunctionSignature);
}
else
{
}
}
}
else
{
}
}
showStatsOfLoadedData(cirDataAnalysis);
}
}
public static KM_CirAction setCirData(ICirData cirData)
{
var kmCirAction = new KM_CirAction();
kmCirAction.CirData = cirData;
kmCirAction.CirAction = IM_CirActions.setCirData;
return kmCirAction;
}
/// <summary>
/// this will return the current CirFunction object for the signature provided or create a new CirFunction
/// object and return it
/// </summary>
/// <param name="cirData"></param>
/// <param name="functionSignature"></param>
/// <param name="functionType"></param>
/// <returns></returns>
public ICirFunction getCirFunction(ICirData cirData, string functionSignature, string functionType)
{
try
{
if (cirData.dFunctions_bySignature.ContainsKey(functionSignature))
return cirData.dFunctions_bySignature[functionSignature];
// create the function reference
var newCirFunction = new CirFunction(functionSignature);
cirData.dFunctions_bySignature.Add(functionSignature, newCirFunction);
// add it to the respective CirClas
var cirClass = getCirClass(cirData,functionType);
cirClass.dFunctions.Add(functionSignature, newCirFunction);
return newCirFunction;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.getCirFunction", true);
return null;
}
}
public void mapClass(ICirClass cirClass, ICirData _cirData, bool clearPreviousList)
{
cirData = _cirData;
cirRootClass = cirClass;
mapCurrentClass(clearPreviousList);
}
public static void calculateListofMethodsCalledByClass_Recursive(
ICirClass ccClass, List <ICirClass> lccTargetCompilationClasses, List <String> lsFunctionsCalled,
String sResultsFilter /*, Dictionary<String, String> dFunctionsNames*/, ICirData fcdCirData)
{
if (ccClass != null)
{
foreach (ICirFunction cfCirFunction in ccClass.dFunctions.Values)
{
foreach (ICirFunction cirFunctionCalled in cfCirFunction.FunctionsCalledUniqueList)
{
String sName = cirFunctionCalled.FunctionSignature;
// if (sName.IndexOf("()") == -1) // don't add functions that receive no parameters
if (sResultsFilter == "" || sName.IndexOf(sResultsFilter) > -1)
{
if (false == lsFunctionsCalled.Contains(cirFunctionCalled.FunctionSignature))
{
lsFunctionsCalled.Add(cirFunctionCalled.FunctionSignature);
ICirClass ccCalledClass = getCirClassObjectFromFunctionSignature(cirFunctionCalled.FunctionSignature, fcdCirData);
if (false == lccTargetCompilationClasses.Contains(ccCalledClass))
{
lccTargetCompilationClasses.Add(ccCalledClass);
}
calculateListofMethodsCalledByClass_Recursive(ccCalledClass, lccTargetCompilationClasses,
lsFunctionsCalled, sResultsFilter,
/*dFunctionsNames,*/ fcdCirData);
// getCirClassObjectFromFunctionDef(sFunctionCalled,dFunctionsNames, fcdCirData);
}
}
}
}
}
}
public void Test_ProcessingAllO2AssembliesFromDirectory(ICirData cirData, string targetDirectory, bool verify,
bool verbose)
{
O2Timer checkTimer =
new O2Timer("Test_ProcessingAllAssembliesFromDirectory " + targetDirectory + " took ").start();
List <string> targetAssemblies = Files.getFilesFromDir_returnFullPath(targetDirectory, "*.exe");
targetAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(targetDirectory, "*.dll"));
//targetAssemblies.AddRange();
DI.log.debug("Testing processing of {0} dlls and exes directory {1}", targetAssemblies.Count,
targetDirectory);
if (!verify)
{
DI.log.debug("Note, verification is disabled");
}
foreach (string targetDll in targetAssemblies)
{
if (CecilUtils.isDotNetAssembly(targetDll, false))
{
Test_LoadingAssembly(cirData, targetDll, verify, verbose);
}
}
CirFactoryUtils.showCirDataStats(cirData);
checkTimer.stop();
}
/// <summary>
/// this will return the current CirFunction object for the signature provided or create a new CirFunction
/// object and return it
/// </summary>
/// <param name="cirData"></param>
/// <param name="functionSignature"></param>
/// <param name="functionType"></param>
/// <returns></returns>
public ICirFunction getCirFunction(ICirData cirData, string functionSignature, string functionType)
{
try
{
if (cirData.dFunctions_bySignature.ContainsKey(functionSignature))
{
return(cirData.dFunctions_bySignature[functionSignature]);
}
// create the function reference
var newCirFunction = new CirFunction(functionSignature);
cirData.dFunctions_bySignature.Add(functionSignature, newCirFunction);
// add it to the respective CirClas
var cirClass = getCirClass(cirData, functionType);
cirClass.dFunctions.Add(functionSignature, newCirFunction);
return(newCirFunction);
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.getCirFunction", true);
return(null);
}
}
public void test_SaveAndLoadAllO2Modules()
{
var directoryToSaveCidDataFiles = Path.Combine(DI.config.O2TempDir, "_O2_CirData_Files");
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCidDataFiles);
List <string> targetAssemblies = Files.getFilesFromDir_returnFullPath(DI.config.hardCodedO2LocalBuildDir, "*.exe");
targetAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(DI.config.hardCodedO2LocalBuildDir, "*.dll"));
foreach (var assemblyToProcess in targetAssemblies)
{
DI.log.info("Processing file: {0}", Path.GetFileName(assemblyToProcess));
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, assemblyToProcess);
Assert.That(cirData.dClasses_bySignature.Count > 0 && cirData.dFunctions_bySignature.Count > 0,
"There we no CirData results for :" + assemblyToProcess);
var savedCirDataFile = Path.Combine(directoryToSaveCidDataFiles,
Path.GetFileName(assemblyToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
Assert.That(File.Exists(savedCirDataFile), "Saved CirData file Didn't exist: " + savedCirDataFile);
ICirData cirData2 = CirLoad.loadFile(savedCirDataFile);
Assert.That(cirData2 != null, "cirData2 was null");
Assert.That(cirData.dClasses_bySignature.Count == cirData2.dClasses_bySignature.Count,
"dClasses_bySignature Count didnt match");
Assert.That(cirData.dFunctions_bySignature.Count == cirData2.dFunctions_bySignature.Count,
"dFunctions_bySignature Count didnt match");
// comment this to delete created files
//File.Delete(savedCirDataFile);
}
}
public void LoadFile(String sFileToLoad)
{
if (Path.GetExtension(sFileToLoad).ToLower() == ".cirdata")
{
cdCirData = CirLoad.loadSerializedO2CirDataObject(sFileToLoad);
lbCirFileLoaded.Text = Path.GetFileName(sFileToLoad);
}
else
{
if (Path.GetExtension(sFileToLoad).ToLower() == ".xml" ||
Path.GetExtension(sFileToLoad).ToLower() == ".ozasmt")
{
var oadO2AssessmentDataOunceV6 = JoinTracesUtils.loadAssessmentRunFileAndAddItToList(sFileToLoad);
if (oadO2AssessmentDataOunceV6 != null)
{
foreach (object oItem in lbTargetSavedAssessmentFiles.Items)
if (oItem.ToString() == oadO2AssessmentDataOunceV6.ToString())
{
DI.log.error(
"in loadAssessmentRunFileAndAddItToList, file is already in the list of F1AssessmentRun objects");
return;
}
lbTargetSavedAssessmentFiles.Items.Add(oadO2AssessmentDataOunceV6);
}
}
else
DI.log.debug("Skipping loading file (since it is one of type: .cirdata, .xml or .ozasmt: {0}",
sFileToLoad);
}
}
private void handleDrop(string fileOrFolderToProcess)
{
if (File.Exists(fileOrFolderToProcess))
{
var springMvcMappings = (SpringMvcMappings)Serialize.getDeSerializedObjectFromXmlFile(fileOrFolderToProcess, typeof(SpringMvcMappings));
if (springMvcMappings == null)
{
DI.log.error("in handleDrop: Could not create SpringMvcMappings object from :{0}", fileOrFolderToProcess);
return;
}
var cirDataFileToLoad = Path.Combine(Path.GetDirectoryName(fileOrFolderToProcess), springMvcMappings.cirDataFile);
if (false == File.Exists(cirDataFileToLoad))
{
DI.log.error("in handleDrop: Could not find cirData object to load :{0}", cirDataFileToLoad);
return;
}
cirData = CirLoad.loadSerializedO2CirDataObject(cirDataFileToLoad);
if (cirData == null)
{
DI.log.error("in handleDrop: Could not create CirData object from :{0}", cirDataFileToLoad);
return;
}
loadedSpringMvcControllers = springMvcMappings.controllers;
createTreeNodesForLoadedSpringMvcControllers();
showLoadedControllers();
}
}
public void LoadFile(String sFileToLoad)
{
if (Path.GetExtension(sFileToLoad).ToLower() == ".cirdata")
{
cdCirData = CirLoad.loadSerializedO2CirDataObject(sFileToLoad);
lbCirFileLoaded.Text = Path.GetFileName(sFileToLoad);
}
else
{
if (Path.GetExtension(sFileToLoad).ToLower() == ".xml" ||
Path.GetExtension(sFileToLoad).ToLower() == ".ozasmt")
{
var oadO2AssessmentDataOunceV6 = loadAssessmentRunFileAndAddItToList(sFileToLoad);
if (oadO2AssessmentDataOunceV6 != null)
{
foreach (object oItem in lbTargetSavedAssessmentFiles.Items)
{
if (oItem.ToString() == oadO2AssessmentDataOunceV6.ToString())
{
DI.log.error(
"in loadAssessmentRunFileAndAddItToList, file is already in the list of F1AssessmentRun objects");
return;
}
}
lbTargetSavedAssessmentFiles.Items.Add(oadO2AssessmentDataOunceV6);
}
}
else
{
DI.log.debug("Skipping loading file (since it is one of type: .cirdata, .xml or .ozasmt: {0}",
sFileToLoad);
}
}
}
public void loadMappedControllers(ICirData _cirData, List <SpringMvcController> _springMvcControllers)
{
cirData = _cirData;
loadedSpringMvcControllers = _springMvcControllers;
createTreeNodesForLoadedSpringMvcControllers();
showLoadedControllers();
}
public void Test_processTypeDefinition(ICirData cirData, ICirClass cirClass)
{
Assert.That(cirClass != null, "cirClass was null");
Assert.That(cirClass.dFunctions.Count == 7, "cirClass.dFunctions.Count != 7 , it was " + cirClass.dFunctions.Count);
// check if we can get the functions by name
ICirFunction testMethodA = cirClass.getFunction("testMethodA()");
Assert.IsNotNull(testMethodA, "could not get testMethodA from cirClass object");
ICirFunction testMethodB = cirClass.getFunction("testMethodB()");
Assert.IsNotNull(testMethodB, "could not get testMethodB from cirClass object");
Assert.IsNotNull(cirClass.getFunction("testMethodB(System.String)"),
"could not get testMethodB(string) from cirClass object");
Assert.IsNotNull(cirClass.getFunction("testMethodD(System.String,System.Type)"),
"could not get testMethodD(System.String,System.Type) from cirClass object");
ICirFunction testMethodC = cirClass.getFunction("testMethodC");
// check if we have the calls and isCalledBy
Assert.That(testMethodA.FunctionsCalledUniqueList.Contains(testMethodB),
"failed on testMethodA.FunctionsCalledUniqueList.Contains(testMethodB)");
Assert.That(testMethodA.FunctionsCalledUniqueList.Contains(testMethodC),
"failed on testMethodA.FunctionsCalledUniqueList.Contains(testMethodB)");
var found = false;
foreach (var calledByFunction in testMethodB.FunctionIsCalledBy)
if (calledByFunction.cirFunction == testMethodA)
found = true;
Assert.That(found,
"failed on testMethodB.FunctionIsCalledBy.Contains(testMethodA)");
}
public static O2RulePack createRules_CallBacksOnControlFlowGraphs_And_ExternalSinks(String sCirDataFile)
{
var rpRulePack = new O2RulePack();
if (false == File.Exists(sCirDataFile))
{
DI.log.error(
"in createRules_CallBacksOnControlFlowGraphs_And_ExternalSinks, provide CirData file not found: {0}",
sCirDataFile);
}
else
{
List <String> lsFunctions = MiscUtils.getFunctionsSignaturesFrom02CirData(sCirDataFile);
// in this type of scan, there are two rules
// if functions have a ControlFlowGraph they are Callbacks
// everything else is a sink
ICirData fcdCirData = CirLoad.loadSerializedO2CirDataObject(sCirDataFile);
Dictionary <String, ICirFunction> dFunctionsWithControlFlowGraphs =
CirDataUtils.getFunctionsWithControlFlowGraph(fcdCirData);
foreach (string sFunction in lsFunctions)
{
if (dFunctionsWithControlFlowGraphs.ContainsKey(sFunction))
{
addRule(createRule(O2RuleType.Callback, sFunction, fcdCirData.sDbId), rpRulePack);
}
else
{
addRule(createRule(O2RuleType.Sink, sFunction, fcdCirData.sDbId), rpRulePack);
}
}
}
return(rpRulePack);
}
public void processAssemblyDefinition(ICirData cirData, AssemblyDefinition assemblyDefinition, string assemblyPath, bool decompileCodeIfNoPdb)
{
var tempSourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" + assemblyDefinition.Name.Name);
if (cirData != null && assemblyDefinition != null)
{
var typesInAssembly = CecilUtils.getTypes(assemblyDefinition);
loadAndMapSymbols(assemblyDefinition, assemblyPath, decompileCodeIfNoPdb, tempSourceCodeFolder);
// first map all types
foreach (var typeInAssembly in typesInAssembly)
{
processTypeDefinition(cirData, typeInAssembly);
}
//then map their interfaces
foreach (var typeInAssembly in typesInAssembly)
{
mapTypeInterfaces(cirData, typeInAssembly);
}
// finally decompile the code if needed
/*if (decompileCodeIfNoPdb)
* {
* var sourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" +assemblyDefinition.Name.Name);
* foreach (var cirClass in cirData.dClasses_bySignature.Values)
* if(cirClass.
* new CecilDecompiler().decompile(typeInAssembly, sourceCodeFolder)
* }*/
}
else
{
DI.log.error("in processAssemblyDefinition, either cirData or assemblyDefinition was null");
}
}
public static KM_CirAction setCirData(ICirData cirData)
{
var kmCirAction = new KM_CirAction();
kmCirAction.CirData = cirData;
kmCirAction.CirAction = IM_CirActions.setCirData;
return(kmCirAction);
}
public static ascx_CirDataViewer show(this ICirData cirData, int namespaceDepth)
{
var cirDataViewer = typeof(ascx_CirDataViewer).openControlAsForm <ascx_CirDataViewer>("CirData", 500, 300);
cirDataViewer.namespaceDepth(namespaceDepth);
cirDataViewer.loadCirData(cirData);
cirDataViewer.showLoadedFunctions();
return(cirDataViewer);
}
public static KM_CirAction setCirData(ICirData cirData)
{
var kmCirAction = new KM_CirAction
{
CirAction = IM_CirActions.setCirData,
CirData = cirData
};
return kmCirAction;
}
public ICirDataAnalysis loadCirData(ICirData cirDataToLoad, bool clearLoadedData)
{
if (clearLoadedData)
{
deleteAllLoadedData();
}
CirDataAnalysisUtils.addO2CirDataFile(cirDataAnalysis, cirDataToLoad);
return(cirDataAnalysis);
}
public static string stats(this ICirData cirData)
{
return(("".line().line() +
"CirData Stats:".line() +
" {0} classes".line() +
" {1} funtions".line())
.format(cirData.dClasses_bySignature.Count,
cirData.dFunctions_bySignature.Count));
}
public void clearLoadedData()
{
this.invokeOnThread(() =>
{
cirData = null;
cirRootClass = null;
cirClassMapped = new List <ICirClass>();
tvBindableFields.Nodes.Clear();
});
}
public static KM_CirAction setCirData(ICirData cirData)
{
var kmCirAction = new KM_CirAction
{
CirAction = IM_CirActions.setCirData,
CirData = cirData
};
return(kmCirAction);
}
public void showSpringSuperClasses(List <String> lsClasses, ICirData fadCirData)
{
tvSpringMvc_SuperClasses.Nodes.Clear();
foreach (String sClass in lsClasses)
{
ICirClass ccCirClass = fadCirData.dClasses_bySignature[sClass];
var tnClass = new TreeNode(ccCirClass.Signature);
addIsSuperClassedByToTreeNode_ReCursive(tnClass, ccCirClass);
tvSpringMvc_SuperClasses.Nodes.Add(tnClass);
}
}
public static List <String> getListOfFilesToScanFromListOfClasses_J2EE(String sSourcePathToJavaFiles,
String sSourcePathToJspFiles,
List <ICirClass> lccTargetCompilationClasses,
ICirData fcdCirData)
{
var sPathsToClassFilesSourceCode = new List <string>();
foreach (ICirClass ccCirClass in lccTargetCompilationClasses)
{
if (ccCirClass != null)
{
String sFilePath = ccCirClass.Signature;
sFilePath = sFilePath.Replace(".", @"\");
if (sFilePath.IndexOf("_jsp") > -1)
{
bool bFoundFile = false;
sFilePath = sFilePath.Substring(sFilePath.IndexOf(@"\"));
sFilePath = sFilePath.Replace("_jsp", ".jsp");
foreach (String sFile in fcdCirData.lFiles)
{
if (sFile.IndexOf(sFilePath) > -1)
{
sPathsToClassFilesSourceCode.Add(sFile);
bFoundFile = true;
break;
}
}
if (false == bFoundFile)
{
DI.log.error(
"in createOunceProjectForAllReferencesOf_Class, could not resolve jsp file: {0}",
sFilePath);
}
}
else
{
sFilePath = Path.Combine(sSourcePathToJavaFiles, sFilePath + ".java");
if (fcdCirData.lFiles.Contains(sFilePath))
{
sPathsToClassFilesSourceCode.Add(sFilePath);
}
else
{
DI.log.error(
"in createOunceProjectForAllReferencesOf_Class, could not resolve class to file: {0}",
ccCirClass.Signature);
}
}
}
}
return(sPathsToClassFilesSourceCode);
}
public void mapTypeInterfaces(ICirData cirData, TypeDefinition typeToMap)
{
var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap);
var cirClass = getCirClass(cirData, classSignature);
foreach (object interfaceType in typeToMap.Interfaces)
{
var type = interfaceType.GetType().FullName;
TypeReference typeReference = null;
switch (interfaceType.GetType().FullName)
{
case "Mono.Cecil.GenericInstanceType":
{
//var genericInstanceType = (GenericInstanceType)interfaceType;
typeReference = (GenericInstanceType)interfaceType;
break;
}
case "Mono.Cecil.TypeReference":
{
typeReference = (TypeReference)interfaceType;
break;
}
case "Mono.Cecil.TypeDefinition":
{
typeReference = (TypeReference)interfaceType;
break;
}
default:
{
DI.log.error("in mapTypeInterfaces, unsupported interface type: {0}", interfaceType.GetType().FullName);
break;
}
}
if (typeReference != null)
{
// typeReference = (TypeReference)interfaceType;
var typeReferenceSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeReference);
var typeReferenceCirClass = getCirClass(cirData, typeReferenceSignature);
cirClass.dSuperClasses.Add(typeReferenceCirClass.Signature, typeReferenceCirClass);
}
}
if (typeToMap.BaseType != null)
{
var baseTypeSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap.BaseType);
var baseCirClass = getCirClass(cirData, baseTypeSignature);
cirClass.dSuperClasses.Add(baseCirClass.Signature, baseCirClass);
}
}
public static void resolveDbId(ICirData cirData)
{
if (cirData.lFiles.Count > 0) // && (sDbId == "" || sDbId == null))
foreach (String sFile in cirData.lFiles)
{
String sResult = CirDumpsUtils.fromFileExtension_get_DbId(Path.GetExtension(sFile));
if (!string.IsNullOrEmpty(sResult))
{
cirData.sDbId = sResult;
return;
}
}
}
public static TreeNode[] getNodes_ThatUseGetParameter_RecursiveSearch(ICirData cirdata, Dictionary <SpringMvcController, TreeNode> treeNodesForloadedSpringMvcControllers)
{
var nodes = new List <TreeNode>();
foreach (SpringMvcController springMcvController in treeNodesForloadedSpringMvcControllers.Keys)
{
if (SpringMvcUtils.doesControllerFunctionCallFunction(cirdata, springMcvController, javaxGetParameterSignatures, true))
{
nodes.Add(O2Forms.cloneTreeNode(treeNodesForloadedSpringMvcControllers[springMcvController]));
}
}
return(nodes.ToArray());
}
public static TreeNode getTreeNodeWithAutoWiredObject(ICirData cirData, string targetFunction, SpringMvcParameter springMvcParameter, int parameterIndex)
{
try
{
if (cirData != null && cirData.dFunctions_bySignature.ContainsKey(targetFunction))
{
var cirFunction = cirData.dFunctions_bySignature[targetFunction];
if (cirFunction.FunctionParameters.Count <= parameterIndex)
{
var filteredSignature = new O2.DotNetWrappers.Filters.FilteredSignature(targetFunction);
if (filteredSignature.lsParameters_Parsed.Count > parameterIndex)
{
springMvcParameter.className = filteredSignature.lsParameters_Parsed[parameterIndex];
}
else
{
DI.log.error("in getTreeNodeWithAutoWiredObject, requested parameter index not found in function: {0}", targetFunction);
}
}
else
{
var functionParameter = cirFunction.FunctionParameters[parameterIndex];
springMvcParameter.className = functionParameter.ParameterType.Replace("&", "");
}
if (springMvcParameter.className != "")
{
// Hack to handle int Java mappings
if (springMvcParameter.className == "int")
{
springMvcParameter.className = "java.lang.Integer";
}
if (cirData.dClasses_bySignature.ContainsKey(springMvcParameter.className))
{
var childNodeText = string.Format("{0} - {1} - {2}", springMvcParameter.autoWiredMethodUsed, springMvcParameter.name, springMvcParameter.className);
return(O2Forms.newTreeNode(childNodeText, childNodeText, 0, cirData.dClasses_bySignature[springMvcParameter.className]));
}
DI.log.error("in getTreeNodeWithAutoWiredObject, parameter type not found in cirData class list:{0}", springMvcParameter.className);
}
}
else
{
DI.log.error("in getTreeNodeWithAutoWiredObject, loaded cirData did not contained signature :{0}", targetFunction);
}
}
catch (Exception ex)
{
DI.log.error("in getTreeNodeWithAutoWiredObject:", ex.Message);
}
return(new TreeNode());
}
public static List<IO2Finding> mapInterfaces(List<IO2Finding> o2Findings, List<IO2Finding> sourcesMappedToInterfaces, ICirData cirData)
{
if (o2Findings == null || cirData == null)
return null;
//var sourcesMappedToInterfaces = getSourcesMappedToInterfaces(o2Findings, cirData);
var sources = getSources(sourcesMappedToInterfaces);
var lostSinks = getLostSinks(o2Findings);//o2Assessment.o2Findings);
//var sources = getSources(o2Assessment.o2Findings);
DI.log.info("There are {0} unique Lost Sinks", lostSinks.Count);
DI.log.info("There are {0} unique Sources", sources.Count);
var joinedFindings = mapSinksToSources(lostSinks, sources);
return joinedFindings;
}
private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint)
{
switch (memberDefinition.GetType().Name)
{
case "MethodReference":
return processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint);
case "MethodDefinition":
return processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint);
default:
DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name);
break;
}
return null;
}
public void createCirDataObject()
{
cirData = new CirData();
DI.log.info("using assembly:{0} and O2_Kernel.dll", Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData,Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData, DI.config.ExecutingAssembly);
/* // this will load all dlls in the O2 dir
foreach(var file in Files.getFilesFromDir_returnFullPath(DI.hardCodedO2DeploymentDir,"*.dll"))
cirFactory.processAssemblyDefinition(cirData, CecilUtils.getAssembly(file));*/
Assert.That(cirData.dClasses_bySignature.Count > 0, "There were no classes in cirData object");
Assert.That(cirData.dFunctions_bySignature.Count > 0, "There were no function in cirData object");
CirFactoryUtils.showCirDataStats(cirData);
}
public void createCirDataObject()
{
cirData = new CirData();
DI.log.info("using assembly:{0} and O2_Kernel.dll", Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData, Assembly.GetExecutingAssembly().Location);
cirFactory.processAssemblyDefinition(cirData, DI.config.ExecutingAssembly);
/* // this will load all dlls in the O2 dir
* foreach(var file in Files.getFilesFromDir_returnFullPath(DI.hardCodedO2DeploymentDir,"*.dll"))
* cirFactory.processAssemblyDefinition(cirData, CecilUtils.getAssembly(file));*/
Assert.That(cirData.dClasses_bySignature.Count > 0, "There were no classes in cirData object");
Assert.That(cirData.dFunctions_bySignature.Count > 0, "There were no function in cirData object");
CirFactoryUtils.showCirDataStats(cirData);
}
public static List<TreeNode> createListOfNormalizedTraces(
string textFilter, Dictionary<String, O2TraceBlock_OunceV6> dRawData,
ICirData cdCirData, Dictionary<String, O2TraceBlock_OunceV6> dO2TraceBlock,
bool bOnlyProcessTracesWithNoCallers)
{
//var tvCreatedTraces_NormalizedTracesView = new TreeView();
var normalizedTracesView = analyzer.ResolveNormalizeTraceFor(textFilter, dRawData,
cdCirData, dO2TraceBlock,
bOnlyProcessTracesWithNoCallers);
DI.log.info("getListOfNormalizedTraces");
List<TreeNode> ltnNormalizedTraces = analyzer.getListOfNormalizedTraces(normalizedTracesView);
return ltnNormalizedTraces;
}
private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint)
{
switch (memberDefinition.GetType().Name)
{
case "MethodReference":
return(processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint));
case "MethodDefinition":
return(processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint));
default:
DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name);
break;
}
return(null);
}
/// <summary>
/// this will return the current CirClass object for the signature provided or create a new CirClass
/// object and return it
/// </summary>
/// <param name="cirData"></param>
/// <param name="classSignature"></param>
/// <returns></returns>
private static ICirClass getCirClass(ICirData cirData, string classSignature)
{
try
{
if (cirData.dClasses_bySignature.ContainsKey(classSignature))
return cirData.dClasses_bySignature[classSignature];
var newCirClass = new CirClass(classSignature);
cirData.dClasses_bySignature.Add(classSignature, newCirClass);
return newCirClass;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.getCirClass", true);
return null;
}
}
public static List <TreeNode> createListOfNormalizedTraces(
string textFilter, Dictionary <String, O2TraceBlock_OunceV6> dRawData,
ICirData cdCirData, Dictionary <String, O2TraceBlock_OunceV6> dO2TraceBlock,
bool bOnlyProcessTracesWithNoCallers)
{
//var tvCreatedTraces_NormalizedTracesView = new TreeView();
var normalizedTracesView = analyzer.ResolveNormalizeTraceFor(textFilter, dRawData,
cdCirData, dO2TraceBlock,
bOnlyProcessTracesWithNoCallers);
DI.log.info("getListOfNormalizedTraces");
List <TreeNode> ltnNormalizedTraces = analyzer.getListOfNormalizedTraces(normalizedTracesView);
return(ltnNormalizedTraces);
}
internal string processAssemblyAndSaveAsCirDataFile(ICirData cirData, string fileToProcess, string directoryToSaveCirDataFile, bool decompileCodeIfNoPdb)
{
processAssemblyDefinition(cirData, fileToProcess, decompileCodeIfNoPdb);
if (cirData.dClasses_bySignature.Count == 0)
{
DI.log.error("There were no classes in created cirData file, so canceling save");
}
else
{
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCirDataFile);
var savedFileName = Path.Combine(directoryToSaveCirDataFile, Path.GetFileName(fileToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedFileName);
return(savedFileName);
}
return("");
}
public static ICirClass getCirClassObjectFromFunctionSignature(String functionSignature,
//Dictionary<String, String> dFunctionsNames,
ICirData fcdCirData)
{
//String sSignatureOfFunctionCalled = sFunctionDef;
//if (dFunctionsNames.ContainsKey(functionSignature))
if (fcdCirData.dFunctions_bySignature.ContainsKey(functionSignature))
{
ICirFunction cirFunction = fcdCirData.dFunctions_bySignature[functionSignature];
//fcdCirData.dFunctions_bySymbolDef[dFunctionsNames[sSignatureOfFunctionCalled]];
return(cirFunction.ParentClass);
}
DI.log.error("in getCirClassObjectFromFunctionDef, could not resolve class object");
//else
return(null);
}
public static TreeNode getTreeNodeWithAutoWiredObject(ICirData cirData, string targetFunction, SpringMvcParameter springMvcParameter, int parameterIndex)
{
try
{
if (cirData != null && cirData.dFunctions_bySignature.ContainsKey(targetFunction))
{
var cirFunction = cirData.dFunctions_bySignature[targetFunction];
if (cirFunction.FunctionParameters.Count <= parameterIndex)
{
var filteredSignature = new FilteredSignature(targetFunction);
if (filteredSignature.lsParameters_Parsed.Count > parameterIndex)
springMvcParameter.className = filteredSignature.lsParameters_Parsed[parameterIndex];
else
DI.log.error("in getTreeNodeWithAutoWiredObject, requested parameter index not found in function: {0}", targetFunction);
}
else
{
var functionParameter = cirFunction.FunctionParameters[parameterIndex];
springMvcParameter.className = functionParameter.ParameterType.Replace("&", "");
}
if (springMvcParameter.className != "")
{
// Hack to handle int Java mappings
if (springMvcParameter.className == "int")
springMvcParameter.className = "java.lang.Integer";
if (cirData.dClasses_bySignature.ContainsKey(springMvcParameter.className))
{
var childNodeText = string.Format("{0} - {1} - {2}", springMvcParameter.autoWiredMethodUsed, springMvcParameter.name, springMvcParameter.className);
return O2Forms.newTreeNode(childNodeText, childNodeText, 0, cirData.dClasses_bySignature[springMvcParameter.className]);
}
DI.log.error("in getTreeNodeWithAutoWiredObject, parameter type not found in cirData class list:{0}", springMvcParameter.className);
}
}
else
DI.log.error("in getTreeNodeWithAutoWiredObject, loaded cirData did not contained signature :{0}", targetFunction);
}
catch (Exception ex)
{
DI.log.error("in getTreeNodeWithAutoWiredObject:", ex.Message);
}
return new TreeNode();
}
public static void addIsCalledByMappings(ICirData cirData, ICirData fcdO2CirDataToProcess)
{
DI.log.debug("in addIsCalledByMappings");
foreach (CirFunction cfCirFunction in fcdO2CirDataToProcess.dFunctions_bySignature.Values)
foreach (ICirFunctionCall cirFunctionCalled in cfCirFunction.FunctionsCalled)
{
if (cirData.dFunctions_bySignature.ContainsKey(cirFunctionCalled.cirFunction.FunctionSignature))
{
if (cirData.dFunctions_bySignature[cirFunctionCalled.cirFunction.FunctionSignature].HasControlFlowGraph) // not sure about this
{
/* DI.log.info("Added isCalledByMapping: {0} is called by {1}",
cirData.dFunctions_bySignature[cirFunctionCalled.FunctionSignature].FunctionSignature, cfCirFunction.FunctionSignature);*/
cirData.dFunctions_bySignature[cirFunctionCalled.cirFunction.FunctionSignature].FunctionIsCalledBy.Add(cirFunctionCalled);
}
}
}
}
/// <summary>
/// this will return the current CirClass object for the signature provided or create a new CirClass
/// object and return it
/// </summary>
/// <param name="cirData"></param>
/// <param name="classSignature"></param>
/// <returns></returns>
private static ICirClass getCirClass(ICirData cirData, string classSignature)
{
try
{
if (cirData.dClasses_bySignature.ContainsKey(classSignature))
{
return(cirData.dClasses_bySignature[classSignature]);
}
var newCirClass = new CirClass(classSignature);
cirData.dClasses_bySignature.Add(classSignature, newCirClass);
return(newCirClass);
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.getCirClass", true);
return(null);
}
}
public static void mapInterfaces(TreeView tvRawData, ICirData cdCirData, String sHardCodedInterfaceKeywork,
bool bAddGluedTracesAsRealTraces)
{
DI.log.debug("Mapping Interfaces");
O2Timer tTimer = new O2Timer("Interfaces mapping completed").start();
// Int32 iItemsProcessed = 0;
Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dAllSinkFindings =
analyzer.getUniqueListOfSinks(tvRawData);
foreach (AssessmentAssessmentFileFinding fFinding in dAllSinkFindings.Keys)
{
String sSink = AnalysisUtils.getSink(fFinding, dAllSinkFindings[fFinding]);
if (sSink != "" && sSink.IndexOf(sHardCodedInterfaceKeywork) > -1)
{
if (false == cdCirData.dFunctions_bySignature.ContainsKey(sSink))
{
DI.log.error("in mapInterfaces, could not find signature in loaded CirData file: {0}",
sSink);
}
else
{
ICirFunction cfCirFunction = cdCirData.dFunctions_bySignature[sSink];
ICirClass ccCirClass = cfCirFunction.ParentClass;
foreach (ICirClass ccIsSuperClassedBy in ccCirClass.dIsSuperClassedBy.Values)
{
String sMappedMethodName = cfCirFunction.FunctionSignature.Replace(ccCirClass.Signature,
ccIsSuperClassedBy.
Signature);
List <O2TraceBlock_OunceV6> lotdMatches =
analyzer.getO2TraceBlocksThatMatchSignature(sMappedMethodName, tvRawData);
foreach (O2TraceBlock_OunceV6 otbO2TraceBlockWithTracesToGlue in lotdMatches)
{
addFindingAsGlueTrace(otbO2TraceBlockWithTracesToGlue, fFinding,
dAllSinkFindings[fFinding], tvRawData,
bAddGluedTracesAsRealTraces);
}
}
}
}
}
tTimer.stop();
}
private static void fixFunctionsCalledXRefs(ICirData cirData)
{
if (cirData != null && cirData.dFunctions_bySignature != null)
{
var timer = new O2Timer("fixFunctionsCalledXRefs").start();
foreach (CirFunction cirFunction in cirData.dFunctions_bySignature.Values)
{
if (cirFunction.FunctionName == null)
{
var filteredSignature = new FilteredSignature(cirFunction.FunctionSignature);
cirFunction.FunctionName = filteredSignature.sFunctionName;
cirFunction.FunctionNameAndParameters = filteredSignature.sFunctionNameAndParams;
cirFunction.ClassNameFunctionNameAndParameters = filteredSignature.sFunctionClass + "." +
filteredSignature.sFunctionNameAndParams;
}
}
timer.stop();
}
}
// this doesn't seem to be working since when I save this back into disk, the size of the .CirData file increases!
/* public static void removeClassesWithNoControlFlowGraphs(ICirData cirData)
{
cirData.dClasses_bySymbolDef.Clear();
cirData.dFunctions_bySymbolDef.Clear();
cirData.dSymbols.Clear();
var signaturesToRemove = new List<String>();
int originalSignatureCount = cirData.dClasses_bySignature.Keys.Count;
// remove CirClasses with no ControlFlowGraphs
foreach (CirClass cirClass in cirData.dClasses_bySignature.Values)
if (false == cirClass.bClassHasMethodsWithControlFlowGraphs)
signaturesToRemove.Add(cirClass.Signature);
foreach (string signature in signaturesToRemove)
cirData.dClasses_bySignature.Remove(signature);
DI.log.info(
"Originally there were {0} CirClass Objects in CirData file and now there are {1} ({2} were deleted)",
originalSignatureCount, cirData.dClasses_bySignature.Keys.Count,
originalSignatureCount - cirData.dClasses_bySignature.Keys.Count);
// remove CirFunctions with no ControlFlowGraphs
signaturesToRemove.Clear();
originalSignatureCount = cirData.dFunctions_bySignature.Values.Count;
foreach (CirFunction cirFunction in cirData.dFunctions_bySignature.Values)
if (false == cirFunction.HasControlFlowGraph)
signaturesToRemove.Add(cirFunction.FunctionSignature);
foreach (string signature in signaturesToRemove)
cirData.dFunctions_bySignature.Remove(signature);
DI.log.info(
"Originally there were {0} CirFunction Objects in CirData file and now there are {1} ({2} were deleted)",
originalSignatureCount, cirData.dFunctions_bySignature.Keys.Count,
originalSignatureCount - cirData.dFunctions_bySignature.Keys.Count);
}*/
public static void saveSerializedO2CirDataObjectToFile(ICirData cirData, String sTargetFile)
{
if (cirData == null)
return;
if (sTargetFile == "")
sTargetFile = DI.config.TempFileNameInTempDirectory + ".xml";
try
{
var bfBinaryFormatter = new BinaryFormatter();
var fsFileStream = new FileStream(sTargetFile, FileMode.Create);
bfBinaryFormatter.Serialize(fsFileStream, cirData);
fsFileStream.Close();
DI.log.debug("Serialized O2CirData Saved to: {0}", sTargetFile);
}
catch (Exception ex)
{
DI.log.error("In saveSerializedO2CirDataObjectToFile: {0}", ex.Message);
}
}
public void mapTypeInterfaces(ICirData cirData, TypeDefinition typeToMap)
{
var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap);
var cirClass = getCirClass(cirData, classSignature);
foreach (object interfaceType in typeToMap.Interfaces)
{
var type = interfaceType.GetType().FullName;
TypeReference typeReference = null;
switch (interfaceType.GetType().FullName)
{
case "Mono.Cecil.GenericInstanceType":
{
//var genericInstanceType = (GenericInstanceType)interfaceType;
typeReference = (GenericInstanceType)interfaceType;
break;
}
case "Mono.Cecil.TypeReference":
{
typeReference = (TypeReference)interfaceType;
break;
}
case "Mono.Cecil.TypeDefinition":
{
typeReference = (TypeReference)interfaceType;
break;
}
default:
{
DI.log.error("in mapTypeInterfaces, unsupported interface type: {0}", interfaceType.GetType().FullName);
break;
}
}
if (typeReference != null)
{
// typeReference = (TypeReference)interfaceType;
var typeReferenceSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeReference);
var typeReferenceCirClass = getCirClass(cirData, typeReferenceSignature);
cirClass.dSuperClasses.Add(typeReferenceCirClass.Signature, typeReferenceCirClass);
}
}
if (typeToMap.BaseType != null)
{
var baseTypeSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeToMap.BaseType);
var baseCirClass = getCirClass(cirData, baseTypeSignature);
cirClass.dSuperClasses.Add(baseCirClass.Signature, baseCirClass);
}
}
public void clearLoadedData()
{
this.invokeOnThread(() =>
{
cirData = null;
cirRootClass = null;
cirClassMapped = new List<ICirClass>();
tvBindableFields.Nodes.Clear();
});
}
public void mapClass(ICirClass cirClass, ICirData _cirData)
{
mapClass(cirClass, _cirData, true);
}
public void showClass(ICirClass cirClass, ICirData _cirData)
{
mapClass(cirClass, _cirData);
}
public ICirFunction processMethodReference(ICirData cirData, MethodReference methodReference, SequencePoint sequencePoint)
{
try
{
var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodReference);
var functionType = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType);
var cirFunction = getCirFunction(cirData, functionSignature, functionType);
cirFunction.CecilSignature = methodReference.ToString();
cirFunction.ReturnType = methodReference.ReturnType.ReturnType.FullName;
cirFunction.ParentClass = getCirClass(cirData, CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType));
cirFunction.ParentClassFullName = methodReference.DeclaringType.FullName;
cirFunction.ParentClassName = methodReference.DeclaringType.Name;
//
cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Assembly.ToString() : "[NullModule]";
//cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]";
cirFunction.FunctionName = methodReference.Name;
cirFunction.FunctionNameAndParameters = CecilUtils.getMethodNameAndParameters(methodReference);
cirFunction.ClassNameFunctionNameAndParameters = string.Format("{0}.{1}",
cirFunction.ParentClassFullName,
cirFunction.FunctionNameAndParameters);
cirFunction.SymbolDef = Guid.NewGuid().ToString();
/*if (sequencePoint != null)
{
if (string.IsNullOrEmpty(cirFunction.File) == false)
{
}
cirFunction.File = sequencePoint.Document.Url;
cirFunction.FileLine = sequencePoint.StartColumn.ToString();
}*/
//methodReference.ReturnType // to implement since we need to add reference to a CirClass
return cirFunction;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processMethodReference", true);
return null;
}
}
public ICirFunction processMethodDefinition(ICirData cirData, MethodDefinition methodDefinition, SequencePoint sequencePoint)
{
try
{
//var functionSignature = methodDefinition.ToString();
var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodDefinition);
var functionClass = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodDefinition.DeclaringType);
var cirFunction = getCirFunction(cirData, functionSignature, functionClass);
if (false == cirFunction.HasBeenProcessedByCirFactory)
{
if (methodDefinition.CustomAttributes != null && methodDefinition.CustomAttributes.Count > 0)
{
foreach (CustomAttribute customAttribute in methodDefinition.CustomAttributes)
{
var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor);
var cirAttribute = new CirAttribute(constructorSignature);
foreach (var constructorParameter in customAttribute.ConstructorParameters)
{
var type = constructorParameter.GetType().FullName;
}
if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0)
{
}
// PublicDI.log.debug("Added attribute {0} to {1}", customAttribute.Constructor.Name, cirFunction.FunctionName);
cirFunction.FunctionAttributes.Add(cirAttribute);
}
}
// map the common values with MethodReference
processMethodReference(cirData, methodDefinition, sequencePoint);
cirFunction.HasBeenProcessedByCirFactory = true; // we need to put this in here or we will have an infinite loop on recursive functions
cirFunction.HasControlFlowGraph = true; // ControlFlowGraph is use by the Viewers to determine if we have more than just a reference to this method
cirFunction.ParentClass.bClassHasMethodsWithControlFlowGraphs = true; // also mark the parent class
cirFunction.IsStatic = methodDefinition.IsStatic;
cirFunction.IsUnmanaged = methodDefinition.IsUnmanaged;
cirFunction.IsUnmanagedExport = methodDefinition.IsUnmanagedExport;
cirFunction.IsVirtual = methodDefinition.IsVirtual;
cirFunction.IsSetter = methodDefinition.IsSetter;
cirFunction.IsGetter = methodDefinition.IsGetter;
cirFunction.IsRuntime = methodDefinition.IsRuntime;
cirFunction.IsPublic = methodDefinition.IsPublic;
cirFunction.IsPrivate = methodDefinition.IsPrivate;
cirFunction.IsPInvokeImpl = methodDefinition.IsPInvokeImpl;
cirFunction.IsNative = methodDefinition.IsNative;
cirFunction.IsManaged = methodDefinition.IsManaged;
cirFunction.IsInternalCall = methodDefinition.IsInternalCall;
cirFunction.IsIL = methodDefinition.IsIL;
cirFunction.IsConstructor = methodDefinition.IsConstructor;
cirFunction.IsAbstract = methodDefinition.IsAbstract;
cirFunction.HasSecurity = methodDefinition.HasSecurity;
cirFunction.HasBody = methodDefinition.HasBody;
// try to find the location of the current method by going for the first line of the first method
if (methodDefinition.HasBody)
foreach (Instruction instruction in methodDefinition.Body.Instructions)
if (instruction.SequencePoint != null )
{
cirFunction.File = instruction.SequencePoint.Document.Url;
if (instruction.SequencePoint.StartLine == 16707566) // means there is no source code ref
cirFunction.FileLine = "0";
else
cirFunction.FileLine = instruction.SequencePoint.StartLine.ToString();
break;
}
// map method parameters (this could be on the MethodReference but if so we would have to check for doing it more than once:
foreach (ParameterDefinition parameter in methodDefinition.Parameters)
{
ICirFunctionParameter functionParameter = new CirFunctionParameter
{
ParameterName = parameter.ToString(),
ParameterType = parameter.ParameterType.FullName,
Constant = (parameter.Constant != null) ? parameter.Constant.ToString() : "",
HasConstant = parameter.HasConstant,
HasDefault = parameter.HasDefault,
Method = parameter.Method.ToString()
};
cirFunction.FunctionParameters.Add(functionParameter);
}
// map the calls made and the IsCalledBy
foreach (var methodCalled in CecilUtils.getMethodsCalledInsideMethod(methodDefinition))
{
ICirFunction cirCalledFunction = processMemberReference(cirData, methodCalled.memberReference, methodCalled.sequencePoint);
if (cirCalledFunction != null)
{
// store the fucntion called sequence
cirFunction.FunctionsCalled.Add(new CirFunctionCall(cirCalledFunction,methodCalled.sequencePoint));
// store the unique list of funcions called
if (false == cirFunction.FunctionsCalledUniqueList.Contains(cirCalledFunction))
cirFunction.FunctionsCalledUniqueList.Add(cirCalledFunction);
// map the FunctionCalled and FunctionIsCalledBy
var cirFunctionCall = new CirFunctionCall(cirCalledFunction, sequencePoint);
//cirFunction.FunctionsCalled.Add(cirFunctionCall);
cirCalledFunction.FunctionIsCalledBy.Add(cirFunctionCall);
//if (false == cirCalledFunction.FunctionIsCalledBy.Contains(cirFunction))
// cirCalledFunction.FunctionIsCalledBy.Add(cirFunction);
}
}
}
// to implement if needed
/* foreach (var methodOverride in methodDefinition.Overrides)
{
var name = methodOverride.GetType();
}*/
return cirFunction;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processMethodDefinition", true);
return null;
}
}
internal string processAssemblyAndSaveAsCirDataFile(ICirData cirData, string fileToProcess, string directoryToSaveCirDataFile, bool decompileCodeIfNoPdb)
{
processAssemblyDefinition(cirData, fileToProcess, decompileCodeIfNoPdb);
if (cirData.dClasses_bySignature.Count == 0)
DI.log.error("There were no classes in created cirData file, so canceling save");
else
{
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCirDataFile);
var savedFileName = Path.Combine(directoryToSaveCirDataFile,Path.GetFileName(fileToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedFileName);
return savedFileName;
}
return "";
}
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, ICirData cirData)
{
return addO2CirDataFile(cirDataAnalysis, cirData, true /* runRemapXrefs */);
}
public void processAssemblyDefinition(ICirData cirData, AssemblyDefinition assemblyDefinition, string assemblyPath, bool decompileCodeIfNoPdb)
{
var tempSourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" + assemblyDefinition.Name.Name);
if (cirData != null && assemblyDefinition != null)
{
var typesInAssembly = CecilUtils.getTypes(assemblyDefinition);
loadAndMapSymbols(assemblyDefinition, assemblyPath, decompileCodeIfNoPdb, tempSourceCodeFolder);
// first map all types
foreach (var typeInAssembly in typesInAssembly)
processTypeDefinition(cirData, typeInAssembly);
//then map their interfaces
foreach (var typeInAssembly in typesInAssembly)
{
mapTypeInterfaces(cirData, typeInAssembly);
}
// finally decompile the code if needed
/*if (decompileCodeIfNoPdb)
{
var sourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" +assemblyDefinition.Name.Name);
foreach (var cirClass in cirData.dClasses_bySignature.Values)
if(cirClass.
new CecilDecompiler().decompile(typeInAssembly, sourceCodeFolder)
}*/
}
else
DI.log.error("in processAssemblyDefinition, either cirData or assemblyDefinition was null");
}
public void processAssemblyDefinition(ICirData cirData, AssemblyDefinition assemblyDefinition, string assemblyPath)
{
processAssemblyDefinition(cirData, assemblyDefinition, assemblyPath, false /*decompileCodeIfNoPdb*/);
}
public void processAssemblyDefinition(ICirData cirData, string assemblyPath, bool decompileCodeIfNoPdb)
{
processAssemblyDefinition(cirData, CecilUtils.getAssembly(assemblyPath), assemblyPath, decompileCodeIfNoPdb);
}
public static ICirData addO2CirDataFile(ICirDataAnalysis cirDataAnalysis, ICirData cirData, bool runRemapXrefs)
{
if (cirData == null)
return null;
// check for sDbId (will be needed to get data from Ounce Db
if (!String.IsNullOrEmpty(cirDataAnalysis.sDb_Id) && cirDataAnalysis.sDb_Id != cirData.sDbId)
DI.log.error(
"The O2CirData files have different Db_Ids, The rules creation will use the last one loaded:{0}",
cirData.sDbId);
if (String.IsNullOrEmpty(cirDataAnalysis.sDb_Id))
cirDataAnalysis.sDb_Id = cirData.sDbId;
// add classes with ControlFlowGraphs to list of classes to process
var sClasses = new List<string>(cirData.dClasses_bySignature.Keys);
sClasses.Sort();
//cirDataAnalysis.dCirClass.Clear();
foreach (ICirClass ccCirClass in cirData.dClasses_bySignature.Values)
{
//if (ccCirClass.bClassHasMethodsWithControlFlowGraphs && false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass))
try
{
// if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass))
// cirDataAnalysis.dCirClass.Add(ccCirClass, cirData);
if (false == cirDataAnalysis.dCirClass_bySignature.ContainsKey(ccCirClass.Signature))
{
cirDataAnalysis.dCirClass_bySignature.Add(ccCirClass.Signature, ccCirClass);
addClass(cirDataAnalysis, ccCirClass);
if (false == cirDataAnalysis.dCirClass.ContainsKey(ccCirClass))
cirDataAnalysis.dCirClass.Add(ccCirClass, cirData);
}
else
{
var classHost = cirDataAnalysis.dCirClass_bySignature[ccCirClass.Signature];
var classToMerge = ccCirClass;
mergeClasses(cirDataAnalysis, classHost, classToMerge);
}
}
catch (Exception ex)
{
DI.log.debug("in addO2CirDataFile : {0}", ex.Message);
//DC: to-do: debug the cases where this exception is triggered
}
}
/* var methodtofind = "System.Data!System.Int32 System.Data.IDataRecord::GetOrdinal(System.String)";
if (cirData.dFunctions_bySignature.ContainsKey(methodtofind))
{
}
if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(methodtofind))
{
}*/
//if (true)
if (runRemapXrefs)
{
remapXrefs(cirDataAnalysis);
showStatsOfLoadedData(cirDataAnalysis);
}
else // if we are not remapping the XRefs then remove any FunctionIsCalledBy that are there (since some might be wrong)
{
foreach (var cirFunction in cirData.dFunctions_bySignature.Values)
cirFunction.FunctionIsCalledBy = new List<ICirFunctionCall>();
}
return cirData;
}
public ICirClass processTypeDefinition(ICirData cirData, TypeDefinition typeDefinition)
{
try
{
var classSignature = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(typeDefinition);
var cirClass = getCirClass(cirData, classSignature);
// map attributes for this classs
if (typeDefinition.CustomAttributes != null && typeDefinition.CustomAttributes.Count > 0)
{
foreach (CustomAttribute customAttribute in typeDefinition.CustomAttributes)
{
var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor);
var cirAttribute = new CirAttribute(constructorSignature);
foreach (var constructorParameter in customAttribute.ConstructorParameters)
{
// var type = constructorParameter.GetType().FullName;
cirAttribute.Parameters.Add(constructorParameter.ToString(), constructorParameter.GetType().FullName);
}
if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0)
{
}
cirClass.ClassAttributes.Add(cirAttribute);
}
}
if (false == cirClass.HasBeenProcessedByCirFactory)
{
cirClass.HasBeenProcessedByCirFactory = true;
cirClass.Name = typeDefinition.Name;
cirClass.FullName = typeDefinition.FullName;
cirClass.Module = typeDefinition.Module.Name;
cirClass.Namespace = cirClass.Namespace;
cirClass.SymbolDef = Guid.NewGuid().ToString();
cirClass.IsAbstract = typeDefinition.IsAbstract;
// cirClass.IsAnonymous = typeDefinition.
cirClass.IsClass = typeDefinition.IsClass;
cirClass.IsEnum = typeDefinition.IsEnum;
cirClass.IsInterface = typeDefinition.IsInterface;
cirClass.IsImport = typeDefinition.IsImport;
cirClass.IsNotPublic = typeDefinition.IsNotPublic;
cirClass.IsPublic = typeDefinition.IsPublic;
cirClass.HasSecurity = typeDefinition.HasSecurity;
}
else
DI.log.info("This Class has already been processed, so only adding any possible extra methods: {0}", cirClass.Name);
// handle constuctors
foreach (MethodDefinition methodDefinition in typeDefinition.Constructors)
{
ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null);
if (false == cirClass.dFunctions.ContainsValue(cirFunction))
cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction);
// try to find source code reference
if (cirFunction.FunctionsCalled.Count > 0 && cirClass.FileLine == null)
if (false == string.IsNullOrEmpty(cirFunction.FunctionsCalled[0].fileName))
{
cirClass.File = cirFunction.FunctionsCalled[0].fileName;
cirClass.FileLine = "0"; // set it to zero and try to map it later
}
}
// handle methods
foreach (MethodDefinition methodDefinition in typeDefinition.Methods)
{
ICirFunction cirFunction = processMethodDefinition(cirData, methodDefinition, null);
if (false == cirClass.dFunctions.ContainsValue(cirFunction))
cirClass.dFunctions.Add(cirFunction.FunctionSignature, cirFunction);
}
return cirClass;
}
catch (Exception ex)
{
DI.log.ex(ex, "in CirFactory.processTypeDefinition", true);
return null;
}
}
