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); } }