public void calculateCustomRuleToAdd(CirData fadCirData)
{
var lsRulesToAdd = new List<string>();
fromTreeNodeListCalculateRulesToAdd_recursive(tvCommandNameObjectFields.Nodes, lsRulesToAdd, fadCirData);
lbRulesToAdd.Items.Clear();
lbRulesToAdd.Items.AddRange(lsRulesToAdd.ToArray());
}
public void fromTreeNodeListCalculateRulesToAdd_recursive(TreeNodeCollection tncTreeNodes,
List<String> lsRulesToAdd, CirData fadCirData)
{
foreach (TreeNode tnTreeNode in tncTreeNodes)
{
if (fadCirData.dClasses_bySignature.ContainsKey(tnTreeNode.Text))
{
ICirClass ccCirClass = fadCirData.dClasses_bySignature[tnTreeNode.Text];
foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values)
foreach (TreeNode tnChildNode in tnTreeNode.Nodes)
{
String sGetterVersion = tnChildNode.Text.Replace("set", "get");
if (new FilteredSignature(cfCirFunction.FunctionSignature).sFunctionName == sGetterVersion)
{
if (false == lsRulesToAdd.Contains(cfCirFunction.FunctionSignature))
lsRulesToAdd.Add(cfCirFunction.FunctionSignature);
}
if (tnChildNode.Nodes.Count > 0)
fromTreeNodeListCalculateRulesToAdd_recursive(tnChildNode.Nodes, lsRulesToAdd,
fadCirData);
}
}
// String sClass = tnTreeNode.Text;
}
}
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 test_CreateCirDataFilesForDotNetFramework()
{
var dotNetFrameworkDirectory = @"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727";
string directoryToSaveCidDataFiles = Path.Combine(DI.config.O2TempDir, "_CirDataFilesFor_DotNetFramework2_0_50727");
Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCidDataFiles);
List<string> targetAssemblies = Files.getFilesFromDir_returnFullPath(dotNetFrameworkDirectory, "*.dll");
//targetAssemblies.AddRange(Files.getFilesFromDir_returnFullPath(DI.hardCodedO2DeploymentDir, "*.dll"));
ICirData cirDataWithAllAssemblies = new CirData();
foreach (var assemblyToProcess in targetAssemblies)
{
if (CecilUtils.isDotNetAssembly(assemblyToProcess))
{
DI.log.info("Processing file: {0}", Path.GetFileName(assemblyToProcess));
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, assemblyToProcess);
cirFactory.processAssemblyDefinition(cirDataWithAllAssemblies, assemblyToProcess);
var savedCirDataFile = Path.Combine(directoryToSaveCidDataFiles,
Path.GetFileName(assemblyToProcess) + ".CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
}
}
DI.log.info("Almost there, now saving cirDataWithAllAssemblies ");
var fileWithCirDataWithAllAssemblies = Path.Combine(directoryToSaveCidDataFiles, "cirDataWithAllAssemblies.CirData");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirDataWithAllAssemblies, fileWithCirDataWithAllAssemblies);
DI.log.info("Done ..");
}
public static ascx_CirDataViewer show(this ICirClass cirClass)
{
var cirData = new CirData();
cirData.dClasses_bySignature.Add(cirClass.Name, cirClass);
var cirDataViewer = cirData.show(0);
return cirDataViewer;
}
public static List<IO2Finding> findParameterStaticValueInMethodX(CirData cirData)
{
string functionToFind = "System.Web.UI.WebControls.Button.add_Click(System.EventHandler):void";
var createdO2Findings = new List<IO2Finding>();
try
{
if (cirData.dFunctions_bySignature.ContainsKey(functionToFind))
{
var function = cirData.dFunctions_bySignature[functionToFind];
foreach (CirFunction functionXRef in function.FunctionIsCalledBy)
{
//var functionXRef = cirData.dFunctions_bySignature[functionXRefName];
foreach (var basicBlock in functionXRef.lcfgBasicBlocks)
{
if (basicBlock != null && basicBlock.Items != null)
for (var i = 0; i < basicBlock.Items.Length; i++)
{
var item = basicBlock.Items[i];
if (item.GetType().Name == "ControlFlowGraphBasicBlockEvalExprStmt")
{
var evalExprStmt = (ControlFlowGraphBasicBlockEvalExprStmt)item;
if (evalExprStmt.NaryCallVirtual != null && evalExprStmt.NaryCallVirtual.FunctionName == functionToFind)
{
// go to the previous block
var evalExprStmtWithStaticParameterValue = (ControlFlowGraphBasicBlockEvalExprStmt)basicBlock.Items[i - 1];
if (evalExprStmtWithStaticParameterValue.NaryCall != null && evalExprStmtWithStaticParameterValue.NaryCall.UnaryOprCast != null && evalExprStmtWithStaticParameterValue.NaryCall.UnaryOprCast.Length == 2)
{
string staticParameterValue =
evalExprStmtWithStaticParameterValue.NaryCall.UnaryOprCast[1].
ConstFunctionAddress.FunctionName;
var o2Finding = new O2Finding(staticParameterValue, "Asp.NET Event Mapping") { o2Traces = new List<IO2Trace>{ new O2Trace(functionXRef.FunctionSignature, TraceType.Root_Call)} };
var sourceTrace = new O2Trace(functionXRef.ParentClass.Signature, functionXRef.FunctionSignature, TraceType.Source);
var sinkTrace = new O2Trace(staticParameterValue, TraceType.Known_Sink)
{
context =
"this . HacmeBank_v2_Website.ascx.PostMessageForm.btnPostMessage_Click ( sender, e )"
};
sourceTrace.childTraces.Add(sinkTrace);
o2Finding.o2Traces[0].childTraces.Add(sourceTrace);
createdO2Findings.Add(o2Finding);
DI.log.debug("{0} -- > {1}", functionXRef.FunctionSignature, staticParameterValue);
}
}
}
}
}
}
return createdO2Findings;
}
}
catch (Exception ex)
{
DI.log.debug("in findParameterStaticValueInMethodX :{0}:", ex.Message);
}
return null;
}
public void Test_getMemberFunction(CirData cirData, TypeDefinition testType, string methodToTest,
Type[] methodParameters)
{
MethodDefinition cecilMethodDefinition = CecilUtils.getMethod(testType, methodToTest, methodParameters);
Assert.IsNotNull(cecilMethodDefinition, "cecilMethodDefinition was null for method", methodToTest);
ICirFunction cirFunction = cirFactory.processMethodDefinition(cirData, cecilMethodDefinition,null);
Assert.IsNotNull(cirFunction, "cecilMethodDefinition was null for method", cecilMethodDefinition);
Assert.That(CirCecilCompare.areEqual_MethodDefinitionAndCirFunction(cecilMethodDefinition, cirFunction),
"areEqual_MethodDefinitionAndCirFunction failed for method: " + cecilMethodDefinition);
}
public static ICirData toCir(this string _string)
{
if (_string.isDotNet())
{
var cirData = new CirData();
new CirFactory().processAssemblyDefinition(cirData, _string);
cirData.remapXRefs();
return cirData;
}
return null;
}
public void test_SaveCirDataFile()
{
ICirData cirData = new CirData();
cirFactory.processAssemblyDefinition(cirData, DI.config.ExecutingAssembly);
var savedCirDataFile = DI.config.getTempFileInTempDirectory("CirData");
Assert.That(false == File.Exists(savedCirDataFile), "savedCirDataFile shouldn't exist here");
CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedCirDataFile);
Assert.That(File.Exists(savedCirDataFile), "savedCirDataFile exist here");
File.Delete(savedCirDataFile);
Assert.That(false == File.Exists(savedCirDataFile), "savedCirDataFile Should be deleted");
DI.log.info("all done");
}
public static ICirClass toCir(this Type type)
{
var cirData = new CirData();
var assemblyLocation = type.assemblyLocation();
var assembly = CecilUtils.getAssembly(assemblyLocation);
var cirFactory = new CirFactory();
cirFactory.loadAndMapSymbols(assembly, assemblyLocation, false, "");
var typeDefinition = CecilUtils.getType(assembly, type.Name);
var cirType = cirFactory.processTypeDefinition(cirData, typeDefinition);
cirData.remapXRefs();
return cirType;
}
public void createCirDataObject()
{
var cirFactory = new CirFactory();
ICirData 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);
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");
O2Messages.setCirData(cirData);
//CirFactoryUtils.showCirDataStats();
}
private void createCirDataForFile(string fileToProcess, bool deleteFileOnCompletion, bool decompileCodeIfNoPdb)
{
O2Thread.mtaThread(() =>
{
ICirData assemblyCirData = new CirData();
new CirFactory().processAssemblyAndSaveAsCirDataFile(assemblyCirData, fileToProcess, directory_CreatedCirFiles.getCurrentDirectory(), decompileCodeIfNoPdb);
if (deleteFileOnCompletion)
{
File.Delete(fileToProcess);
}
})
;
//new CirCreatorEngineForDotnet().createCirForAssembly(fileToProcess);
}
public static CirData loadFile(String sPathToFileToLoad)
{
CirData cirData;
if (Path.GetExtension(sPathToFileToLoad) == ".CirData")
{
cirData = loadSerializedO2CirDataObject(sPathToFileToLoad);
}
else
{
DI.log.debug("Loading CirDumpFile file: {0}", sPathToFileToLoad);
cirData = new CirData();
// always resolve these xrefs since older o2CirData might have probs (note that this is a one time only effort (per O2 session))
loadCirDumpXmlFile_andPopulateDictionariesWithXrefs(sPathToFileToLoad, cirData, false);
}
fixFunctionsCalledXRefs(cirData); // required for the new objects added by the CirCreator.CirFactory funtionality
return cirData;
}
public static bool createConsolidatedCirDataFile(String sPathToCirDumpFiles, String sTargetCirDataFile,
bool bStoreControlFlowBlockRawDataInsideCirDataFile)
{
DI.log.debug("Creating Consolidated CirData file");
try
{
List<String> lsCirDumpFiles = Files.getFilesFromDir_returnFullPath(sPathToCirDumpFiles);
var fcdCirData = new CirData
{
bStoreControlFlowBlockRawDataInsideCirDataFile =
bStoreControlFlowBlockRawDataInsideCirDataFile
};
if (lsCirDumpFiles.Count == 0)
DI.log.error("No CirDump to process (were created during scan?)");
else
{
DI.log.debug("in loadCirDumpXmlFile_andPopulateDictionariesWithXrefs");
foreach (String sFile in lsCirDumpFiles)
try
{
fcdCirData.dSymbols = new Dictionary<string, string>();
fcdCirData.dTemp_Functions_bySymbolDef = new Dictionary<string, ICirFunction>();
CirLoad.loadCirDumpXmlFile_andPopulateDictionariesWithXrefs(sFile, fcdCirData, true);
}
catch (Exception ex)
{
DI.log.error("In createConsolidatedCirDataFile, error while processing file {0}: {1}",
sFile, ex.Message);
}
DI.log.debug("in saveSerializedO2CirDataObjectToFile");
CirDataUtils.saveSerializedO2CirDataObjectToFile(fcdCirData,sTargetCirDataFile);
return true;
}
}
catch (Exception ex)
{
DI.log.error("In createConsolidatedCirDataFile: {0}:", ex.Message);
}
return false;
}
public CirDataAnalysis createCirDataAnalysisObject(List<string> assembliesToLoad, bool decompileCodeIfNoPdb)
{
ICirData cirData = new CirData();
foreach(var assemblyToLoad in assembliesToLoad)
processAssemblyDefinition(cirData, assemblyToLoad,decompileCodeIfNoPdb);
if (cirData.dClasses_bySignature.Count >0)
{
return new CirDataAnalysis(cirData);
}
DI.log.error("in createCirDataAnalysisObject there were no clases in CirData file");
return null;
}
public string convertAssemblyIntoCirDataFile(string assemblyToProcess, string targetDirectory, bool decompileCodeIfNoPdb)
{
ICirData cirData = new CirData();
return processAssemblyAndSaveAsCirDataFile(cirData, assemblyToProcess, targetDirectory, decompileCodeIfNoPdb);
}
private void lbO2CirDataFilesInSelectedDir_DoubleClick(object sender, EventArgs e)
{
lbO2CirDataFilesInSelectedDir.Enabled = false;
Application.DoEvents();
String sPathToFileToProcess = Path.Combine(sCurrentBaseDir, lbO2CirDataFilesInSelectedDir.Text);
lbFileLoaded.Text = sPathToFileToProcess;
CirData fcdLoadedCirData = CirLoad.loadSerializedO2CirDataObject(sPathToFileToProcess);
if (fcdLoadedCirData != null)
{
if (cbOnSelectUpdateIsCalledByMappigns.Checked)
{
if (fcdCirData == null)
DI.log.error(
"in lbO2CirDataFilesInSelectedDir_DoubleClick: this.fcdCirData == null (you must a project first before consolidating");
else
CirDataUtils.addIsCalledByMappings(fcdCirData,fcdLoadedCirData);
}
else
fcdCirData = fcdLoadedCirData;
if (cbCirAnaLyzer_DontUpdateOnLoad.Checked)
{
tvAllClassesAndMethods.Nodes.Clear();
lbO2CirData_Functions.Items.Clear();
}
else
{
cbCirAnalyzer_TextFilter_Classes.Checked = false;
cbCirAnalyzer_TextFilter_Functions.Checked = false;
cbCirAnalyzer_TextFilter_MakesCallsTo.Checked = false;
cbCirAnalyzer_TextFilter_Parameters.Checked = false;
cbCirAnalyzer_TextFilter_RemoveMakesCallsTo.Checked = false;
cbCirAnalyzer_TextFilter_SuperClass.Checked = false;
showO2CirDataInTreeViewAndListBox(fcdCirData, tvAllClassesAndMethods, lbO2CirData_Functions);
}
}
lbO2CirDataFilesInSelectedDir.Enabled = true;
DI.log.info("Done loading CirDataFile");
}
public void runTextSearch(String sSuperClass, String sClassName, String sFunctionName, String sParameterType,
String sMakesCallsTo, String sRemoveMakesCallsTo)
{
DI.log.debug("Running Cir Text Search on: ClassName={0} , FunctionName={1} , ParameterType={1}",
sClassName, sFunctionName, sParameterType);
bool bOnlyProcessFunctionsWithControlFlowGraph = true;
bool bVerbose = true;
String sStringToSearch = tbCirAnalyszer_TextSearchFilter_SuperClass.Text;
Dictionary<String, ICirClass> dMatches = CirDataUtils.analysis_getFunctionsThatMatchFilter(fcdCirData,
sSuperClass, sClassName, sFunctionName, sParameterType, sMakesCallsTo, sRemoveMakesCallsTo,
bOnlyProcessFunctionsWithControlFlowGraph, bVerbose);
// foreach (CirClass ccClass in dMatches.Values)
// DI.log.info(ccClass.FunctionSignature);
var fcdResults = new CirData
{
dClasses_bySignature = dMatches,
dSymbols = fcdCirData.dSymbols,
lFiles = fcdCirData.lFiles
};
CirDataUtils.resolveDbId(fcdCirData);
fcdResults.sDbId = fcdCirData.sDbId;
/*
foreach (CirClass ccCirClass in fcdCirData.dClasses.Values)
{
//String sResolvedClassName = fcdResults.getSymbol(sClassName);
// DI.log.info(ccCirClass.FunctionSignature);
if (ccCirClass.FunctionSignature.ToUpper().IndexOf(sStringToSearch) > -1) // case insensive search
fcdResults.dClasses.Add(ccCirClass.SymbolDef, ccCirClass);
}*/
showO2CirDataInTreeViewAndListBox(fcdResults, tvAllClassesAndMethods, lbO2CirData_Functions);
DI.log.debug("Search completed");
}
public void Test_processTypeDefinition()
{
ICirData cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
TypeDefinition testTypeDefinition = CecilUtils.getType(testAssembly, "testType");
ICirClass cirClass = cirFactory.processTypeDefinition(cirData, testTypeDefinition);
Test_processTypeDefinition(cirData, cirClass);
}
public static void loadFileIntoCirDataAnalysisObject(string sFileToLoad, ICirDataAnalysis cirDataAnalysis, bool showNotSupportedExtensionError, bool useCachedVersionIfAvailable, bool runRemapXrefs, bool decompileCodeIfNoPdb)
{
try
{
switch (Path.GetExtension(sFileToLoad).ToLower())
{
case ".cirdata":
addO2CirDataFile(cirDataAnalysis, sFileToLoad, useCachedVersionIfAvailable);
break;
case ".dll":
case ".exe":
if (CecilUtils.isDotNetAssembly(sFileToLoad, false))
{
ICirData assemblyCirData = new CirData();
new CirFactory().processAssemblyDefinition(assemblyCirData,
CecilUtils.getAssembly(sFileToLoad), sFileToLoad, decompileCodeIfNoPdb);
if (assemblyCirData.dClasses_bySignature.Count == 0)
DI.log.error("There were no classes imporeted from the file: {0}", sFileToLoad);
else
{
var fileName = Path.GetFileName(sFileToLoad);
if (false == cirDataAnalysis.dCirDataFilesLoaded.ContainsKey(fileName))
{
cirDataAnalysis.dCirDataFilesLoaded.Add(Path.GetFileName(sFileToLoad),
assemblyCirData);
}
addO2CirDataFile(cirDataAnalysis, assemblyCirData, runRemapXrefs);
}
}
else
DI.log.error("Droped *.exe or *.dll file was not a .Net assembly: {0}", sFileToLoad);
break;
case "*.xml":
if (CirLoad.isFileACirDumpFile(sFileToLoad))
addO2CirDataFile(cirDataAnalysis, sFileToLoad,useCachedVersionIfAvailable);
break;
default:
if (showNotSupportedExtensionError)
DI.log.error(
"Could not process file dropped (it it not a CirData file or a .NET assembly: {0}",
sFileToLoad);
break;
}
}
catch (Exception ex)
{
DI.log.error(
"in loadFileIntoCirDataAnalysisObject, error {0} while loading {1} : ", sFileToLoad, ex.Message);
}
}
public void showO2CirDataInListBox(CirData fcdCirData, ListBox lbTargetListBox, List<String> lsFunctionsAdded)
{
int iItemsProcessed = 0;
lbTargetListBox.Items.Clear();
//ascx_RulesCreator1.clearTargetslist();
foreach (String sSignature in lsFunctionsAdded)
{
if (fcdCirData.dFunctions_bySignature.ContainsKey(sSignature))
{
ICirFunction cfCirFunction = fcdCirData.dFunctions_bySignature[sSignature];
cfCirFunction.OnlyShowFunctionNameInToString = !cbViewByFunction_FullSignature.Checked;
if (false == lbTargetListBox.Items.Contains(cfCirFunction))
lbTargetListBox.Items.Add(cfCirFunction);
}
else if (false == lbTargetListBox.Items.Contains(sSignature))
lbTargetListBox.Items.Add("*" + sSignature);
if (iItemsProcessed++ < iMaxItemsToShowOnMainTreeView)
{
DI.log.error("MaxItemsToShow reached {0}, aborting", iMaxItemsToShowOnMainTreeView);
break;
}
}
lbTargetListBox.Sorted = true;
/*
if (fcdCirData.dClasses_bySignature != null)
foreach (CirClass ccCirClass in fcdCirData.dClasses_bySignature.Values)
if (ccCirClass.bClassHasMethodsWithControlFlowGraphs && ccCirClass.dFunctions.Count > 0) //only Classes with methods with ControlFlowGraphs
foreach (CirFunction cfCirFunction in ccCirClass.dFunctions.Values)
if (cfCirFunction.HasControlFlowGraph)
{
cfCirFunction.OnlyShowFunctionNameInToString = !cbViewByFunction_FullSignature.Checked;
lbTargetListBox.Items.Add(cfCirFunction);
}
*/
}
public void showO2CirDataInTreeView(CirData fcdCirData)
{
showO2CirDataInTreeView(fcdCirData, tvAllClassesAndMethods, new List<string>());
}
public void showO2CirDataInTreeViewAndListBox(CirData fcdCirData, TreeView tvTargetTreeView,
ListBox lbTargetListBox)
{
var lsFunctionsAdded = new List<string>();
showO2CirDataInTreeView(fcdCirData, tvTargetTreeView, lsFunctionsAdded);
showO2CirDataInListBox(fcdCirData, lbTargetListBox, lsFunctionsAdded);
}
public void Test_ProcessingO2Kernel()
{
DI.log.info("Testing with O2Kernel");
ICirData cirData = new CirData();
string O2KernelExe = DI.config.ExecutingAssembly; // this gets O2_Kernel.Exe
Test_LoadingAssembly(cirData, O2KernelExe, true /*verify*/, false /*verbose*/);
CirFactoryUtils.showCirDataStats(cirData);
}
public CirDataAnalysis createCirDataAnalysisObject(List<MethodInfo> methodInfos)
{
var assemblyDefinitions = new Dictionary<Assembly,AssemblyDefinition>();
ICirData cirData = new CirData();
//foreach(var assemblyToLoad in assembliesToLoad)
foreach (MethodInfo methodInfo in methodInfos)
{
var assembly = methodInfo.DeclaringType.Assembly;
if (false == assemblyDefinitions.ContainsKey(assembly))
{
var assemblyDefinition = CecilUtils.getAssembly(assembly.Location);
if (assemblyDefinition != null)
assemblyDefinitions.Add(assembly, assemblyDefinition);
}
if (assemblyDefinitions.ContainsKey(assembly))
{
var methodDefinition = CecilConvert.getMethodDefinitionFromMethodInfo(methodInfo, assemblyDefinitions[assembly]);
if (methodDefinition != null)
processMethodDefinition(cirData,methodDefinition,null);
}
}
return new CirDataAnalysis(cirData);
}
public void showO2CirDataInTreeView(CirData fcdCirData, TreeView tvTargetTreeView, List<String> lsFunctionsAdded)
{
clearViewers();
// make it not visible for performance reasons:
tvTargetTreeView.Visible = false;
// add list of files process to ListBox
lbCirAnalyzer_Files.Visible = false;
foreach (String sFile in fcdCirData.lFiles)
lbCirAnalyzer_Files.Items.Add(sFile);
lbCirAnalyzer_Files.Visible = true;
// add data to ClassesAndMethod Tree View
tvTargetTreeView.Sort();
if (fcdCirData.dClasses_bySignature != null)
foreach (CirClass ccCirClass in fcdCirData.dClasses_bySignature.Values)
{
if (ccCirClass.bClassHasMethodsWithControlFlowGraphs && ccCirClass.dFunctions.Count > 0)
//only Classes with methods with ControlFlowGraphs
{
bool bFunctionAdded = false;
TreeNode tnClass = O2Forms.newTreeNode(ccCirClass.Signature, "", 0, null);
// add SuperClasses
foreach (String sSuperClass in ccCirClass.dSuperClasses.Keys)
tnClass.Nodes.Add(O2Forms.newTreeNode(CirDataUtils.getSymbol(fcdCirData,sSuperClass), "", 5, null));
foreach (String sIsSuperClassedBy in ccCirClass.dIsSuperClassedBy.Keys)
tnClass.Nodes.Add(
O2Forms.newTreeNode("IsSuperClassedBy:" + CirDataUtils.getSymbol(fcdCirData,sIsSuperClassedBy), "", 5,
null));
// add fields
if (rbShowFieldsAndVariables.Checked)
{
foreach (FieldClass fsFieldClass in ccCirClass.dField_Class.Values)
tnClass.Nodes.Add(
O2Forms.newTreeNode(
String.Format("fc: {0} {1} - {2}", fsFieldClass.Signature, fsFieldClass.Name,
fsFieldClass.Signature), "", 4, null));
foreach (FieldMember fsFieldMember in ccCirClass.dField_Member.Values)
tnClass.Nodes.Add(
O2Forms.newTreeNode(
String.Format("fm: {0} {1}", fsFieldMember.PrintableType, fsFieldMember.Name),
"", 4, null));
}
// add methods in code, its variables, who it calls
foreach (CirFunction cfCirFunction in ccCirClass.dFunctions.Values)
{
if (processFunctionAndAddItToNode(tnClass.Nodes, cfCirFunction, lsFunctionsAdded))
bFunctionAdded = true;
}
if (bFunctionAdded && tnClass.Nodes.Count > 0)
tvTargetTreeView.Nodes.Add(tnClass);
}
/* // for C++ files (handles with the NonClassFunctions)
foreach (CirFunction cfCirFunction in fcdCirData.dFunctions.Values)
{
processFunctionAndAddItToNode(tvTargetTreeView.Nodes, cfCirFunction);
}*/
Application.DoEvents(); // refresh GUI
}
//tvAllClassesAndMethods.ExpandAll();
// if (tvAllClassesAndMethods.Nodes.Count > 0 )
// tvAllClassesAndMethods.Nodes[0].Expand();
// if (cbCirAnalyzer_TextFilter_MakesCallsTo.Checked || cbCirAnalyzer_TextFilter_Functions.Checked || cbCirAnalyzer_TextFilter_RemoveMakesCallsTo.Checked)
// tvTargetTreeView.ExpandAll();
tvTargetTreeView.Visible = true;
}
public static ICirData createCirDataFromXmlFileWithJavaMetadata(string xmlFileWithJavaMetadata)
{
var cirData = new CirData();
try
{
DI.log.info("createCirDataFromXmlFileWithJavaMetadata for {0}", xmlFileWithJavaMetadata);
var javaMetadata =
(JavaAttributeMappings)
Serialize.getDeSerializedObjectFromXmlFile(xmlFileWithJavaMetadata, typeof (JavaAttributeMappings));
if (javaMetadata == null || javaMetadata.@class == null)
{
DI.log.error(
"in createCirDataFromXmlFileWithJavaMetadata, could not convert file into JavaMetadata XSD-drive .Net class: {0}",
xmlFileWithJavaMetadata);
return null;
}
foreach (var _class in javaMetadata.@class)
{
var cirClass = (CirClass) cirData.addClass(_class.name);
if (cirClass != null)
{
cirClass.bClassHasMethodsWithControlFlowGraphs = true;
cirClass.File = _class.sourceFile;
cirClass.FileLine = "0";
// map superclasses and Interfaces (which in the current version of the the CirData are all stored on the same location
if (_class.superclass != null)
foreach (var superClass in _class.superclass)
//CirDataUtils.addSuperClassMapping(cirData, cirClass,superClass.name);
cirClass.dSuperClasses.Add(superClass.name, null);//cirData.getClass(superClass.name));
if (_class.@interface != null)
foreach (var @interface in _class.@interface)
//CirDataUtils.addSuperClassMapping(cirData,cirClass, @interface.name);
cirClass.dSuperClasses.Add(@interface.name, null); //cirData.getClass(@interface.name));
if (_class.method != null)
foreach (var _method in _class.method)
{
var functionSignature = createSignatureFromMethodData(_class.name, _method.name, _method.descriptor);
var cirFunction = (CirFunction)cirClass.addFunction(functionSignature);
cirFunction.File = _class.sourceFile;
cirFunction.FileLine = _method.lineNumber.ToString();
if (_method.methodCalled != null)
{
cirFunction.HasControlFlowGraph = true;
foreach (var _calledMethod in _method.methodCalled)
{
var calledFunctionSignature = createSignatureFromMethodData(_calledMethod.@class,
_calledMethod.name,
_calledMethod.descriptor);
cirFunction.addCalledFunction(calledFunctionSignature, cirFunction.File, _calledMethod.lineNumber);
}
}
}
}
}
//cirData.remapXRefs();
}
catch (Exception ex)
{
DI.log.error("in createCirDataFromXmlFileWithJavaMetadata:{0}",ex.Message);
}
return cirData;
}
private void btCirAnalyzer_LoadCirDataFile_Click(object sender, EventArgs e)
{
CirData fcdLoadedCirData =
CirLoad.loadSerializedO2CirDataObject(tbCirAnalyzer_PathToSavedCirDataFile.Text);
if (fcdLoadedCirData != null)
{
fcdCirData = fcdLoadedCirData;
showO2CirDataInTreeViewAndListBox(fcdCirData, tvAllClassesAndMethods, lbO2CirData_Functions);
}
}
public static ICirData createCirDataFromCirDataAnalysis(ICirDataAnalysis cirDataAnalysis)
{
if (cirDataAnalysis == null)
return null;
var cirData = new CirData
{
dClasses_bySignature = cirDataAnalysis.dCirClass_bySignature,
dFunctions_bySignature = cirDataAnalysis.dCirFunction_bySignature,
};
return cirData;
}
public void Test_processMethodDefinition()
{
var cirData = new CirData();
AssemblyDefinition testAssembly = getTestAssembly();
TypeDefinition testType = CecilUtils.getType(testAssembly, "testType");
Test_getMemberFunction(cirData, testType, "testMethodA", new Type[0]);
Test_getMemberFunction(cirData, testType, "testMethodC", new[] {typeof (string)});
Test_getMemberFunction(cirData, testType, "testMethodD", new[] {typeof (string), typeof (Type)});
}
