public static void findSpringOnSubmitMethods(List <String> lsSpringMvcClasses)
{
lsClassesToFindInBeanList_Bad = new List <String>();
lsClassesToFindInBeanList_Good = new List <String>();
foreach (String sClassSignature in lsSpringMvcClasses)
{
foreach (CirFunction cfCirFunction in fadCirData.dClasses_bySignature[sClassSignature].dFunctions.Values
)
{
if (cfCirFunction.FunctionSignature.IndexOf("onSubmit") > -1)
{
if (false == lsClassesToFindInBeanList_Bad.Contains(sClassSignature))
{
lsClassesToFindInBeanList_Bad.Add(sClassSignature);
DI.log.info("Bad: {0}", sClassSignature);
}
}
if (cfCirFunction.FunctionSignature.IndexOf("initBinder") > -1)
{
foreach (String sCalledFunction in ViewHelpers.getCirFunctionStringList(cfCirFunction.FunctionsCalledUniqueList))
{
if (sCalledFunction.IndexOf("setAllowedFields") > -1)
{
lsClassesToFindInBeanList_Good.Add(sClassSignature);
DI.log.debug("init binder -> setAllowedFields: " + sCalledFunction);
}
}
}
}
//if (false == lsClassesToFindInBeanList_Bad.Contains(sClassSignature))
// DI.log.info("Skipping: {0}", sClassSignature);
}
}
public void showSpringMvcClases(List <String> lsClasses, CirData fadCirData)
{
tvSpringMvcClasses.Nodes.Clear();
foreach (String sClass in lsClasses)
{
ICirClass ccCirClass = fadCirData.dClasses_bySignature[sClass];
var tnClass = new TreeNode(ccCirClass.Signature);
foreach (CirFunction cfCirFunction in ccCirClass.dFunctions.Values)
{
var fsSignature = new FilteredSignature(cfCirFunction.FunctionSignature);
var tnFunction = new TreeNode(fsSignature.sFunctionNameAndParams);
foreach (String sFunctionCalled in ViewHelpers.getCirFunctionStringList(cfCirFunction.FunctionsCalledUniqueList))
{
var tnFunctionCalled = new TreeNode(sFunctionCalled);
//if (sFunctionCalled.IndexOf("setCommandName") > -1)
String sCommandNameValue = getValueFromControlFlowGraphCall(cfCirFunction.lcfgBasicBlocks,
sFunctionCalled);
if (sCommandNameValue != "")
{
tnFunctionCalled.Nodes.Add(sCommandNameValue);
}
tnFunction.Nodes.Add(tnFunctionCalled);
}
tnClass.Nodes.Add(tnFunction);
}
tvSpringMvcClasses.Nodes.Add(tnClass);
}
}
public void event_NodeAfterSelect_functions(String sSignature)
{
// if (fcdAnalysis.dCirFunction_bySignature.ContainsKey(FunctionSignature))
// {
if (cbOnlyShowFunctionsCalledBySelectedFunction.Checked)
{
/* var asd = fcdAnalysis.dCirFunction_bySignature[sSignature].FunctionsCalledUniqueList;
* var aa = fcdAnalysis.dCirFunction_bySignature.ContainsKey(asd[0].FunctionSignature);
* var aaa = fcdAnalysis.dCirFunction_bySignature[asd[0].FunctionSignature];*/
if (fcdAnalysis.dCirFunction_bySignature.ContainsKey(sSignature))
{
afv_MakesCallsTo.showSignatures(ViewHelpers.getCirFunctionStringList(
fcdAnalysis.dCirFunction_bySignature[sSignature].FunctionsCalledUniqueList));
}
else
{
afv_MakesCallsTo.showSignatures(new List <string>());
}
}
invokeEvent_SignatureSelected(sSignature);
// }
}
public void showDataForSignature_thread(String sSignatureToShow)
{
if (cirDataAnalysis == null)
{
DI.log.error("in ascx_CirViewer_Signature.showDataForSignature , fcdAnalysis == null");
}
else
{
lbClassesBeingViewed.Text = sSignatureToShow;
if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignatureToShow) ||
cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignatureToShow) &&
cirDataAnalysis.dCirFunction_bySignature[sSignatureToShow].HasControlFlowGraph == false)
{
DI.log.debug("{0} is not recognized as a full signature, trying to resolve it by name",
sSignatureToShow);
foreach (CirFunction ccFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
{
String sFunctionFullNameWithNoParamsAndReturnvalue =
new FilteredSignature(ccFunction.FunctionSignature).sFunctionFullName;
if (sFunctionFullNameWithNoParamsAndReturnvalue.IndexOf(sSignatureToShow) > -1)
{
DI.log.debug("Found a match:{0}", ccFunction.FunctionSignature);
sSignatureToShow = ccFunction.FunctionSignature;
break;
}
}
}
if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignatureToShow))
{
ICirFunction ccCirFunction = cirDataAnalysis.dCirFunction_bySignature[sSignatureToShow];
afv_Calls.showSignatures(ViewHelpers.getCirFunctionStringList(ccCirFunction.FunctionsCalledUniqueList));
afv_IsCalledBy.showSignatures(ViewHelpers.getCirFunctionStringList(ccCirFunction.FunctionIsCalledBy));
lbBoxSsaVariables.Items.Clear();
lBoxVariables.Items.Clear();
foreach (SsaVariable cfSSaVariable in ccCirFunction.dSsaVariables.Values)
{
String sVariableMapping = String.Format("{0} = {1}", cfSSaVariable.sBaseName,
cfSSaVariable.sPrintableType);
lbBoxSsaVariables.Items.Add(sVariableMapping);
// DI.log.debug(sVariableMapping);
}
foreach (FunctionVariable fvVariable in ccCirFunction.dVariables.Values)
{
lBoxVariables.Items.Add(String.Format("[def:{0}] [ref:{1}] {2}", fvVariable.sSymbolDef,
fvVariable.refSymbol, fvVariable.sUniqueID));
}
ViewHelpers.showFunctionBlocksInWebBrower(((CirFunction)ccCirFunction).lcfgBasicBlocks,
wbControlFlowGraphsOFSelectedMethod);
asv_CalledFunctions.showDataForSignature(sSignatureToShow);
asv_IsCalledBy.showDataForSignature(sSignatureToShow);
}
else
{
var lsEmpty = new List <string>();
afv_Calls.showSignatures(lsEmpty);
afv_IsCalledBy.showSignatures(lsEmpty);
lbBoxSsaVariables.Items.Clear();
lBoxVariables.Items.Clear();
asv_CalledFunctions.showDataForSignature(sSignatureToShow);
asv_IsCalledBy.showDataForSignature(sSignatureToShow);
}
}
// lBoxVariables.Items.Add(fcdO2CirData_ofThisFunction.getSymbol(sVariable));
}
public static bool areEqual_MethodDefinitionAndCirFunction(MethodDefinition cecilMethodDefintion, ICirFunction cirFunction)
{
try
{
if (cecilMethodDefintion == null || cirFunction == null)
{
return(false);
}
var cirFunctionProperties = new Dictionary <string, object>();
foreach (var property in DI.reflection.getProperties(cirFunction.GetType()))
{
cirFunctionProperties.Add(property.Name, DI.reflection.getProperty(property.Name, cirFunction));
// DI.log.info("prop: {0} = {1}", property.Name, cirFunctionProperties[property.Name]);
}
var methodsCalledInsideMethod = CecilUtils.getMethodsCalledInsideMethod(cecilMethodDefintion);
var moduleName = (cecilMethodDefintion.DeclaringType.Module != null) ? cecilMethodDefintion.DeclaringType.Module.Assembly.Name.ToString() : "[NullModule]";
foreach (var property in cirFunctionProperties.Keys)
{
switch (property)
{
case "FunctionSignature":
if (cirFunctionProperties[property].ToString() != String.Format("{0}!{1}", moduleName, cecilMethodDefintion))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[FunctionSignature]!=cecilMethodDefintion");
return(false);
}
break;
case "IsPrivate":
case "IsStatic":
case "IsConstructor":
case "IsUnmanaged":
case "IsUnmanagedExport":
case "IsVirtual":
case "IsSetter":
case "IsGetter":
case "IsRuntime":
case "IsPublic":
case "IsPInvokeImpl":
case "IsNative":
case "IsManaged":
case "IsInternalCall":
case "IsIL":
case "IsAbstract":
case "HasSecurity":
case "HasBody":
if ((bool)cirFunctionProperties[property] !=
(bool)DI.reflection.getProperty(property, cecilMethodDefintion))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: (bool)cirFunctionProperties[" + property +
"] != (bool)DI.reflection.getProperty(" + property + ", cecilMethodDefintion)");
return(false);
}
break;
case "ParentClass":
var cirClass1 = (CirClass)cirFunctionProperties[property];
if (cirClass1.Signature != CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(cecilMethodDefintion.DeclaringType))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[ParentClass]!=cecilMethodDefintion == " + cecilMethodDefintion.DeclaringType.FullName);
return(false);
}
break;
case "ParentClassFullName":
var parentClassFullName = (string)cirFunctionProperties[property];
if (parentClassFullName != cecilMethodDefintion.DeclaringType.FullName)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[ParentClassFullName]!=cecilMethodDefintion.FullName " + cecilMethodDefintion.DeclaringType.FullName);
return(false);
}
break;
case "ParentClassName":
var parentClassName = (string)cirFunctionProperties[property];
if (parentClassName != cecilMethodDefintion.DeclaringType.Name)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: cirFunction[parentClassName]!=cecilMethodDefintion.FullName " + cecilMethodDefintion.DeclaringType.Name);
return(false);
}
break;
case "FunctionParameters":
var cirFunctionParameters = (List <ICirFunctionParameter>)cirFunctionProperties[property];
if (cecilMethodDefintion.Parameters.Count != cirFunctionParameters.Count)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionParameters count didn't match");
return(false);
}
foreach (ParameterDefinition parameter in cecilMethodDefintion.Parameters)
{
if (false == ViewHelpers.getCirParameterTypeStringList(cirFunctionParameters).Contains(parameter.ParameterType.FullName))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionParameters signatures didn't match");
return(false);
}
}
break;
case "FunctionsCalledUniqueList":
var functionsCalledUniqueList = (List <ICirFunction>)cirFunctionProperties[property];
foreach (MethodCalled methodCalled in methodsCalledInsideMethod)
{
if (false == ViewHelpers.getCirFunctionStringList(functionsCalledUniqueList).Contains(CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodCalled.memberReference)))
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: there was a missing function in the FunctionsCalledUniqueList");
return(false);
}
}
break;
case "FunctionsCalledSequence":
var functionsCalledSequence = (List <ICirFunction>)cirFunctionProperties[property];
if (functionsCalledSequence.Count != methodsCalledInsideMethod.Count)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: functionsCalledSequence.Count != methodsCalledInsideMethod.Count");
return(false);
}
for (int i = 0; i < methodsCalledInsideMethod.Count; i++)
{
if (CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodsCalledInsideMethod[i].memberReference) != ViewHelpers.getCirFunctionStringList(functionsCalledSequence)[i])
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: the FunctionsCalledSequence does match");
return(false);
}
}
break;
case "ReturnType":
if (cecilMethodDefintion.ReturnType.ReturnType.FullName != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: ReturnType don't match");
return(false);
}
break;
case "CecilSignature":
if (cecilMethodDefintion.ToString() != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: CecilSignature din't match");
return(false);
}
break;
case "FunctionNameAndParameters":
if (CecilUtils.getMethodNameAndParameters(cecilMethodDefintion) != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: FunctionNameAndParameters din't match");
return(false);
}
break;
case "FunctionName":
if (cecilMethodDefintion.Name != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: FunctionName din't match");
return(false);
}
break;
case "Module":
if (moduleName != cirFunctionProperties[property].ToString())
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: Module din't match");
return(false);
}
break;
case "ClassNameFunctionNameAndParameters":
var classNameFunctionNameAndParameters = cirFunctionProperties[property].ToString();
var expectedClassNameFunctionNameAndParameters = string.Format("{0}.{1}",
cirFunction.ParentClassFullName,
cirFunction.FunctionNameAndParameters);
if (classNameFunctionNameAndParameters != expectedClassNameFunctionNameAndParameters)
{
DI.log.error(
"in areEqual_MethodDefinitionAndCirFunction: classNameFunctionNameAndParameters din't match");
return(false);
}
break;
// ignore these ones
case "IsSource":
case "IsSink":
case "FunctionParameterTypes":
case "lcfgBasicBlocks":
case "SymbolDef":
case "ReflectionSignature":
case "O2MDbgSignature":
case "UsedTypes":
case "FunctionIsCalledBy":
case "dSsaVariables":
case "dVariables":
case "HasControlFlowGraph":
case "OnlyShowFunctionNameInToString":
case "HasBeenProcessedByCirFactory":
break;
// case "":
//break;
default:
DI.log.error(" property not handled: {0}", property);
break;
}
}
return(true);
}
catch (Exception ex)
{
DI.log.ex(ex, "in areEqual_MethodDefinitionAndCirFunction", true);
return(false);
}
}
