public void loadO2CirDataFile(String sFileToLoad, bool raiseProcessNewDataLoad, bool decompileCodeIfNoPdb)
{
try
{
if (false == File.Exists(sFileToLoad))
{
DI.log.error("File to load doesnt exists: {0}", sFileToLoad);
}
else
{
CirDataAnalysisUtils.loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, decompileCodeIfNoPdb);
if (raiseProcessNewDataLoad)
{
raiseSetCirDataAnalysisO2Message();
}
else
{
updateCirDataStats();
}
}
}
catch (Exception ex)
{
DI.log.error("in loadO2CirDataFile: {0}", ex.Message);
}
}
private void raiseSetCirDataAnalysisO2Message()
{
//setO2CirDataAnalysisObject(cirDataAnalysis);
CirDataAnalysisUtils.remapIsCalledByXrefs(cirDataAnalysis); // this is called when everything has been added, so it is the best place to remap the ISCalledBy XRefs
O2Messages.setCirDataAnalysis(cirDataAnalysis);
updateCirDataStats();
}
public CirDataAnalysis()
{
CirDataAnalysisUtils.clear(this);
onlyShowFunctionsWithCallersOrCallees = false;
onlyShowFunctionsOrClassesWithControlFlowGraphs = true; // default to true;
onlyShowExternalFunctionsThatAreInvokedFromCFG = false;
}
public static void viewClassMethods(ascx_FunctionsViewer targetFunctionsViewer, ICirClass targetClass, bool showInheritedMethods, bool ignoreCoreObjectClass)
{
if (targetClass != null)
{
O2Thread.mtaThread(
() =>
{
targetFunctionsViewer.clearLoadedSignatures();
targetFunctionsViewer.setNamespaceDepth(0);
var signaturesToShow = new List <string>();
if (showInheritedMethods)
{
List <ICirFunction> inheritedSignatures = CirDataAnalysisUtils.getListOfInheritedMethods(targetClass, ignoreCoreObjectClass);
foreach (var inheritedSignature in inheritedSignatures)
{
signaturesToShow.Add(inheritedSignature.FunctionSignature);
}
}
else
{
signaturesToShow.AddRange(targetClass.dFunctions.Keys.ToList());
}
targetFunctionsViewer.showSignatures(signaturesToShow);
/*var thread = targetFunctionsViewer.showSignatures(signaturesToShow);
* if (thread != null)
* {
* thread.Join();
* targetFunctionsViewer.expandNodes();
* } */
});
}
}
public bool Save(string savedCirDataFile)
{
Files.deleteFile(savedCirDataFile);
var timer = new O2Timer("Saving CirData").start();
CirDataAnalysisUtils.saveCirDataAnalysisObjectAsCirDataFile(this, savedCirDataFile);
timer.stop();
return(File.Exists(savedCirDataFile));
}
public ICirDataAnalysis loadCirData(ICirData cirDataToLoad, bool clearLoadedData)
{
if (clearLoadedData)
{
deleteAllLoadedData();
}
CirDataAnalysisUtils.addO2CirDataFile(cirDataAnalysis, cirDataToLoad);
return(cirDataAnalysis);
}
public void loadFiles(IEnumerable <string> filesToLoad, bool showNotSupportedExtensionError, bool useCachedVersionIfAvailable, bool remapXrefs, bool decompileCodeIfNoPdb)
{
foreach (var fileToLoad in filesToLoad)
{
CirDataAnalysisUtils.loadFileIntoCirDataAnalysisObject(fileToLoad, cirDataAnalysis, showNotSupportedExtensionError, useCachedVersionIfAvailable, false /*runRemapXrefs*/, decompileCodeIfNoPdb); // since we are loading multiple files never run the remap on file load
}
if (remapXrefs)
{
CirDataAnalysisUtils.remapXrefs(cirDataAnalysis);
}
updateCirDataStats();
}
private ICirData createCirData(List <string> filesToProcess)
{
var cirDataAnalysis = new CirDataAnalysis();
foreach (var fileToProcess in filesToProcess)
{
if (fileToProcess != "" && Path.GetExtension(fileToProcess) == ".xml")
{
var tempCirData = CirFactory.createCirDataFromXmlFileWithJavaMetadata(fileToProcess);
CirDataAnalysisUtils.addO2CirDataFile(cirDataAnalysis, tempCirData, false /* runRemapXrefs*/);
}
}
CirDataAnalysisUtils.remapXrefs(cirDataAnalysis);
CirViewingUtils.openCirDataFileInCirViewerControl(cirDataAnalysis, "Cir Viewer");
return(CirDataAnalysisUtils.createCirDataFromCirDataAnalysis(cirDataAnalysis));
}
void o2MessageQueue_onMessages(IO2Message o2Message)
{
if (o2Message is IM_CirAction)
{
var cirAction = (IM_CirAction)o2Message;
switch (cirAction.CirAction)
{
case IM_CirActions.setCirData:
CirDataAnalysisUtils.addO2CirDataFile(cirDataAnalysis, cirAction.CirData);
raiseSetCirDataAnalysisO2Message();
//O2Messages.setCirDataAnalysis(cirDataAnalysis);
//DI.cirData = cirAction.CirData;
//updateCirDataStats();
break;
}
}
}
public void loadO2CirDataFile(String sFileToLoad, bool useCachedVersionIfAvailable)
{
if (sFileToLoad.IndexOf(".CirData") > -1 || CirLoad.isFileACirDumpFile(sFileToLoad))
{
//CirDataAnalysis fdaO2CirDataAnalysis;
if (cbClearPreviousO2CirData.Checked)
{
cdaO2CirDataAnalysis = new CirDataAnalysis();
}
CirDataAnalysisUtils.addO2CirDataFile(cdaO2CirDataAnalysis, sFileToLoad, useCachedVersionIfAvailable);
lbCirFileLoaded.Text = "";
foreach (String sLoadedO2CirData in cdaO2CirDataAnalysis.dCirDataFilesLoaded.Keys)
{
lbCirFileLoaded.Text += Path.GetFileName(sLoadedO2CirData);
}
btFindClassesWithNoControlFlowGraphs_Click(null, null);
}
}
void o2MessageQueue_onMessages(IO2Message o2Message)
{
if (o2Message is IM_CirAction)
{
var cirAction = (IM_CirAction)o2Message;
switch (cirAction.CirAction)
{
case IM_CirActions.setCirDataAnalysis:
loadCirDataAnalysisObject(cirAction.CirDataAnalysis);
updateCirDataStats();
break;
case IM_CirActions.setCirData: // if there was a CirData file set, then add it into CirDataAnalysis
CirDataAnalysisUtils.addO2CirDataFile(cirDataAnalysis, cirAction.CirData);
updateCirDataStats();
break;
}
}
}
public void LoadClassInfo()
{
if (this.okThread(delegate { LoadClassInfo(); }))
{
ICirDataSearchResult fcdSearchResult = CirDataAnalysisUtils.executeSearch(cirDataAnalysis);
if (cbOnlyShowClassesWithFunctionsWithControlFlowGraphs.Checked)
{
afv_Classes.showSignatures(fcdSearchResult.lsResult_Classes_WithControlFlowGraphs);
}
else
{
afv_Classes.showSignatures(fcdSearchResult.lsResult_Classes);
}
if (cbCalculateSuperClasses.Checked)
{
//afv_Classes.showSignatures(fcdSearchResult.lsResult_Classes);
afv_SuperClasses.iMaxItemsToShow = 10000;
afv_SuperClasses.showSignatures(cirDataAnalysis.lCirClass_bySuperClass);
}
}
// classNodeCheckClickEvent(new List<String>()); // this will clear all previous results;
}
/// <summary>
/// use this to make sure all main dictionaires are syncronized
/// </summary>
public void remapXRefs()
{
var tempCirDataAnalysis = new CirDataAnalysis(this);
try
{
foreach (var cirClass in dClasses_bySignature.Values)
{
foreach (var cirFunction in cirClass.dFunctions.Values)
{
if (false == dFunctions_bySignature.ContainsKey(cirFunction.FunctionSignature))
{
dFunctions_bySignature.Add(cirFunction.FunctionSignature, cirFunction);
}
}
}
}
catch (Exception ex)
{
O2.Kernel.PublicDI.log.error("in remapXRefs: {0}", ex.Message);
}
CirDataAnalysisUtils.remapIsCalledByXrefs(tempCirDataAnalysis);
}
public ICirData getCirDataObject()
{
return(CirDataAnalysisUtils.createCirDataFromCirDataAnalysis(cirDataAnalysis));
}
public void loadFile(string sFileToLoad, bool showNotSupportedExtensionError, bool useCachedVersionIfAvailable, bool remapXrefs, bool decompileCodeIfNoPdb)
{
CirDataAnalysisUtils.loadFileIntoCirDataAnalysisObject(sFileToLoad, cirDataAnalysis, showNotSupportedExtensionError, useCachedVersionIfAvailable, remapXrefs, decompileCodeIfNoPdb); // load file
updateCirDataStats();
}
public CirDataAnalysis(ICirData cirData) : this()
{
CirDataAnalysisUtils.addO2CirDataFile(this, cirData);
}
public void test_PopulateCirWithTraces()
{
// get Assessment Data
var o2Assessment = new O2Assessment(new O2AssessmentLoad_OunceV6(), findingsFile);
Assert.That(o2Assessment.o2Findings.Count > 0, "There were no findings in o2Assessment");
DI.log.info("There are {0} findings in the assessment loaded", o2Assessment.o2Findings.Count);
var uniqueListOfSignatures = OzasmtUtils.getUniqueListOfSignatures(o2Assessment.o2Findings);
Assert.That(uniqueListOfSignatures.Count() > 0, "uniqueListOfSignatures.Count ==0 ");
DI.log.info("There are {0} unique signatures ", uniqueListOfSignatures.Count());
// get cir data
var cirDataAnalysis = new CirDataAnalysis();
CirDataAnalysisUtils.loadFileIntoCirDataAnalysisObject(fileToCreateCirFrom, cirDataAnalysis);
CirDataAnalysisUtils.remapIsCalledByXrefs(cirDataAnalysis);
Assert.That(cirDataAnalysis.dCirFunction_bySignature.Count > 0, "cirDataAnalysis.dCirFunction_bySignature.Count == 0");
// need to convert to Ozasmt signature format
var cirMappedFunctions = new Dictionary <string, ICirFunction>();
foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
{
if (cirFunction.FunctionSignature.IndexOf("O2AppDomainFactory>") > -1)
{
}
var filteredSignature = new FilteredSignature(cirFunction);
cirMappedFunctions.Add(filteredSignature.sSignature, cirFunction);
}
var matches = new List <String>();
foreach (var sig in cirMappedFunctions.Keys)
{
if (sig.IndexOf("IndexOf") > -1)
{
matches.Add(sig);
}
}
//var matches = new List<String>();
/* foreach (var cirFunction in cirMappedFunctions.Values)
* foreach (var called in cirFunction.FunctionsCalledUniqueList)
* if (called.FunctionSignature.IndexOf("System.Object::.ctor") > -1)
* {
* matches.Add(called.FunctionSignature);
* var asd = cirDataAnalysis.dCirFunction_bySignature.ContainsKey(called.FunctionSignature);
* }*/
foreach (var signature in uniqueListOfSignatures)
{
if (false == cirMappedFunctions.ContainsKey(signature))
{
DI.log.info("NO MATCH:" + signature);
}
}
foreach (O2Finding o2Finding in o2Assessment.o2Findings)
{
var source = o2Finding.Sink;
if (source != "" && false == cirMappedFunctions.ContainsKey(source))
{
DI.log.info("NO MATCH for Source:" + source);
}
var sink = o2Finding.Sink;
if (sink != "" && false == cirMappedFunctions.ContainsKey(sink))
{
DI.log.info("NO MATCH for Sink:" + sink);
}
}
/*foreach (var signature in uniqueListOfSignatures)
* DI.log.info(signature);
* return;*/
}
