public static List <IO2Finding> createO2FindingsFromCirFunction(ICirFunction cirFunction, bool createNewFindingOnExternalCall) { var o2FindingsCreated = new List <IO2Finding>(); var filteredSignature = new FilteredSignature(cirFunction); var functionSignature = filteredSignature.sSignature; var rootO2Finding = new O2Finding { method = cirFunction.ClassNameFunctionNameAndParameters, vulnName = functionSignature, vulnType = "O2.CirGeneratedTrace", severity = 2, confidence = 2, file = cirFunction.File }; if (cirFunction.File != null) { UInt32 lineNumber; if (UInt32.TryParse(cirFunction.FileLine, out lineNumber)) { rootO2Finding.lineNumber = lineNumber; } } createTracesAndFindingsFromCirFunction(cirFunction, rootO2Finding.file, rootO2Finding.lineNumber, rootO2Finding.o2Traces, new List <IO2Trace>(), rootO2Finding, o2FindingsCreated, createNewFindingOnExternalCall); // make the first trace a Source rootO2Finding.o2Traces[0].traceType = TraceType.Source; // and add it to the list of Findings Created o2FindingsCreated.Add(rootO2Finding); return(o2FindingsCreated); }
private static void mapMethods(method[] methodsToMap, string javaClassName, SpringMvcController controllerForCurrentClass, List <SpringMvcController> springMvcControllers, string fileName) { if (methodsToMap != null) { foreach (var methodToMap in methodsToMap) { var mappedController = getRequestMapping(methodToMap); if (mappedController != null) // || controllerForCurrentClass != null) { if (mappedController.HttpRequestUrl == null && controllerForCurrentClass != null) { mappedController.HttpRequestUrl = controllerForCurrentClass.HttpRequestUrl; } mappedController.JavaClass = javaClassName; mappedController.JavaFunction = (FilteredSignature.createFilteredSignatureFromJavaMethod(mappedController.JavaClass, methodToMap.name, methodToMap.descriptor).sFunctionNameAndParamsAndReturnClass); mappedController.JavaClassAndFunction = string.Format("{0}.{1}", mappedController.JavaClass, mappedController.JavaFunction); mappedController.AutoWiredJavaObjects = getAutoWiredJavaObjects(methodToMap); mappedController.FileName = fileName; mappedController.LineNumber = (uint)methodToMap.lineNumber; springMvcControllers.Add(mappedController); } //springMvcController.URL = ; //methodToMap.attribute // methodToMap.SpringMvcMapping } } }
public static void mapMethodsToFilteredSignatures(List <MethodInfo> methodsToMap, ref List <FilteredSignature> filteredSignatures, ref Dictionary <string, MethodInfo> methods_bySignature, bool hideCSharpGeneratedMethods) { filteredSignatures = new List <FilteredSignature>(); methods_bySignature = new Dictionary <string, MethodInfo>(); foreach (var method in methodsToMap) { var filteredSignature = new FilteredSignature(method); if (hideCSharpGeneratedMethods == false || (filteredSignature.sSignature.IndexOf("<>") == -1 && false == filteredSignature.sFunctionName.StartsWith("b__"))) { filteredSignatures.Add(filteredSignature); // create methodsLoaded_bySignature if (methods_bySignature.ContainsKey(filteredSignature.sSignature)) { PublicDI.log.error("in mapMethodsToFilteredSignatures, repeated signature: {0}", filteredSignature.sSignature); } else { methods_bySignature.Add(filteredSignature.sSignature, method); } } else { //PublicDI.log.info("Skipping: {0}", method.Name); } } }
public ICirFunction getCirFunctionFromSelectedItem(object selectedItem) { if (selectedItem != null && selectedItem is FilteredSignature) { var filteredSignature = (FilteredSignature)selectedItem; var functionSignature = filteredSignature.sOriginalSignature; if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(functionSignature)) { return(cirDataAnalysis.dCirFunction_bySignature[functionSignature]); } // if we could not find using the originalSignature, try the signature foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) { var s = new FilteredSignature(cirFunction).sSignature; var d = filteredSignature.sSignature; if (new FilteredSignature(cirFunction).sSignature == filteredSignature.sSignature) { return(cirFunction); } if (cirFunction.FunctionName == filteredSignature.sFunctionName) { } } } return(null); }
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 static void mapJavaAttributesToTraces(IO2Assessment o2Assessment, Dictionary <string, string> attributesXmlFiles) { DI.log.debug("Mapping Java Attributes to Traces"); //var testFindings = from O2Finding finding in o2Assessment.o2Findings where finding.Source.Contains("BugController") select (IO2Finding)finding; //var testFindings = o2Assessment.o2Findings; DI.log.debug("There are {0} findings to process", o2Assessment.o2Findings.Count()); foreach (O2Finding finding in o2Assessment.o2Findings) { var filteredSignature = new FilteredSignature(finding.Source); var className = filteredSignature.sFunctionClass; var fileToFind = string.Format("{0}.class.JavaAttributes.xml", className.Replace(".", "\\")); if (attributesXmlFiles.ContainsKey(fileToFind)) { mapJavaAttributesToFinding(finding, attributesXmlFiles[fileToFind]); } //DI.log.info("Found: {0} - > {1}", fileToFind , attributesXmlFiles[fileToFind]); //else // DI.log.error("could NOT find Xml Attribute file for: {0}", fileToFind); //DI.log.info(fileToFind); } //var findingsWithSpringMVCControllersAsSources = new List<IO2Finding>(); // save temp assessment file // var o2FindingsOfTypeO2SpringMvcController = (from o2Finding in o2Assessment.o2Findings where o2Finding.vulnType == "O2.SpringMvc.Controller" select o2Finding).ToList(); // DI.log.debug("There are {0} o2FindingsOfTypeO2SpringMvcController"); /* O2.Views.ASCX.O2Findings.ascx_FindingsViewer.openInFloatWindow(o2FindingsOfTypeO2SpringMvcController); * saveFindingsInNewO2AssessmentFile(o2FindingsOfTypeO2SpringMvcController, pathToOzasmtFile + "_SpringMvcController.ozasmt"); * */ }
public void executeAction_onFunctionSelect(Node nSelectedNode) { if (rbOnFunctionSelect_Show.Checked) { Int32 iNameSpaceDepth; Int32.TryParse(cBoxShowFunctionClass_Depth.Text, out iNameSpaceDepth); nSelectedNode.NodeAttribute.Label = FilteredSignature.filterSignature(nSelectedNode.Id, cbGLEE_ShowParameters.Checked, cbGLEE_ShowReturnClass.Checked, cbGLEE_ShowNamespace.Checked, iNameSpaceDepth); nSelectedNode.NodeAttribute.Shape = Shape.Box; } else if (rbOnFunctionSelect_Clear.Checked) { O2Graph.makeEmptyNode(nSelectedNode); } else if (rbOnFunctionSelect_Remove.Checked) { O2Graph.deleteNodeFromGraph(fgdGraphData, nSelectedNode, true); } else if (rbOnFunctionSelect_HighlightAllCalls_To.Checked) { applyFiltersToGraph(fgdGraphData.gGraph, true); highlighCallsToNode_Recursive(nSelectedNode); highlighCallsFromNode_Recursive(nSelectedNode); } else { } //else if (rbOnFunctionSelect_SClear.Checked) /* */ }
public static void onlyShowNodesContainingClass(Graph gGraph, String sStringClass) { if (sStringClass == "") { return; } foreach (Node nNode in gGraph.Nodes) { if (false == FilteredSignature.isSignatureCached(nNode.Id)) { DI.log.error( "in onlyShowNodesContainingClass, dFilteredFuntionSignatures did not contain the signature: {0}", nNode.Id); } else { FilteredSignature fFilteredSignature = FilteredSignature.getFromCache(nNode.Id); if (fFilteredSignature.getClassName(0).IndexOf(sStringClass) == -1) { if (false == isNodeASourceOrSink(nNode)) // Don't remove sources or sinks { makeEmptyNode(nNode); } } //nNode.NodeAttribute.Label = "TO REMOVE"; // DI.log.debug("{0} : {1}", fFilteredSignature.getClassName(0), nNode.Id); } } }
public static List <String> getListWithWordsFromSignature(string signature) { var filteredSignature = new FilteredSignature(signature); List <string> wordsFromSignature = filteredSignature.lsFunctionClass_Parsed; // words in namespace & class wordsFromSignature.Add(filteredSignature.sFunctionName); // also add the method name return(wordsFromSignature); }
public CirFunction(string functionSignature) : this() { FunctionSignature = functionSignature; var filteredSignature = new FilteredSignature(FunctionSignature); FunctionName = filteredSignature.sFunctionName; FunctionNameAndParameters = filteredSignature.sFunctionNameAndParams; ClassNameFunctionNameAndParameters = filteredSignature.sFunctionClass + "." + filteredSignature.sFunctionNameAndParams; ReturnType = filteredSignature.sReturnClass; }
public static void addVelocityMappings(TreeView tvRawData) { String sFunctionSignature = "ModelMap.addAttribute"; O2Timer tTimer = new O2Timer("Adding Velocity Mappings : {0} ").start(); Dictionary <AssessmentAssessmentFileFinding, O2AssessmentData_OunceV6> dMatches = analyzer.getSinksFindingsThatMatchRegEx(tvRawData, sFunctionSignature); foreach (AssessmentAssessmentFileFinding fFinding in dMatches.Keys) { // resolve addAddtibute name String sSinkContext = AnalysisUtils.getSinkContext(fFinding, dMatches[fFinding]); var fsFilteredSignature = new FilteredSignature(sSinkContext); String sParameters = fsFilteredSignature.sParameters.Replace("\"", ""); String sSpringParameter = sParameters.Substring(0, sParameters.IndexOf(',')).Trim(); // create a unique name for it: String sSink = AnalysisUtils.getSink(fFinding, dMatches[fFinding]); // String sSinkWithAttributeName = sSink.Replace("(", "_" + sSpringParameter + "("); String sVelocityMapping = String.Format("{0} 0", sSink); TreeNode tnVelocityNode = tvRawData.Nodes[sSink]; if (tnVelocityNode != null) { var otbO2TraceBlockWithVelocityMappings = (O2TraceBlock_OunceV6)tnVelocityNode.Tag; String sUniqueSignature = analyzer.getUniqueSignature(fFinding, TraceType.Known_Sink, dMatches[fFinding], true); var otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag; // sUniqueSignature = sUniqueSignature.Replace("_" + sSpringParameter + "(", "("); // O2TraceBlock_OunceV6 otbO2TraceBlockToAddVelocityMappings = (O2TraceBlock_OunceV6)tvRawData.Nodes[sUniqueSignature].Tag; if (otbO2TraceBlockWithVelocityMappings.dSinks.Count > 1) { } foreach ( AssessmentAssessmentFileFinding fVelocityFinding in otbO2TraceBlockWithVelocityMappings.dSinks.Keys) { if (false == otbO2TraceBlockToAddVelocityMappings.dGluedSinks.ContainsKey(fVelocityFinding)) { otbO2TraceBlockToAddVelocityMappings.dGluedSinks.Add(fVelocityFinding, otbO2TraceBlockWithVelocityMappings .dSinks[fVelocityFinding]); } if (false == otbO2TraceBlockToAddVelocityMappings.dSinks.ContainsKey(fVelocityFinding)) { otbO2TraceBlockToAddVelocityMappings.dSinks.Add(fVelocityFinding, otbO2TraceBlockWithVelocityMappings. dSinks[fVelocityFinding]); } } } } }
public override string ToString() { String sStringToFilter = Signature; const bool bShowParameters = true; const bool bShowReturnClass = false; const bool bShowNamespace = false; const int iNamespaceDepth = 1; return(FilteredSignature.filterSignature(sStringToFilter, bShowParameters, bShowReturnClass, bShowNamespace, iNamespaceDepth)); }
public void showSignatures(List <FilteredSignature> filteredSignatures) { var signaturesToShow = new List <String>(); // get them all in one collection var filteredSignaturesAsStrings = new List <String>(); foreach (var filteredSignature in filteredSignatures) { filteredSignaturesAsStrings.Add(filteredSignature.sOriginalSignature); } // now search for them on all loaded CirFunctions foreach (var cirFunction in cirDataAnalysis.dCirFunction_bySignature.Values) { var cirFunctionFilteredSignature = new FilteredSignature(cirFunction); if (filteredSignaturesAsStrings.Contains(cirFunctionFilteredSignature.sOriginalSignature)) { signaturesToShow.Add(cirFunction.FunctionSignature); filteredSignaturesAsStrings.Remove(cirFunctionFilteredSignature.sOriginalSignature); } if (filteredSignaturesAsStrings.Contains(cirFunctionFilteredSignature.sSignature)) { signaturesToShow.Add(cirFunction.FunctionSignature); filteredSignaturesAsStrings.Remove(cirFunctionFilteredSignature.sSignature); } } /* foreach (var filteredSignature in filteredSignatures) * { * if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(filteredSignature.sOriginalSignature)) * signaturesToShow.Add(filteredSignature.sOriginalSignature); * else * * DI.log.error("dropped signature is currently not loaded: {0}", filteredSignature); * }*/ if (filteredSignaturesAsStrings.Count > 0) { DI.log.error("There were {0} dropped signatures that could not be resolved", filteredSignaturesAsStrings.Count); foreach (var signatureNotFound in filteredSignaturesAsStrings) { DI.log.error(" {0}", signatureNotFound); } } if (signaturesToShow.Count == 0) { DI.log.error("None of the dropped signature was resolved, you need to load their CIR"); } else { showSignatures(signaturesToShow); } }
public void addBindableFieldsIntoTreeView_Recursive(TreeNodeCollection tncTreeNodes, String sClassToFind, bool bHideGetAndSetStrings, ICirData fadCirData) { String sFixedClassToFind = sClassToFind[0].ToString().ToUpper() + sClassToFind.Substring(1); foreach (ICirClass ccCirClass in fadCirData.dClasses_bySignature.Values) { if (ccCirClass.Name == sFixedClassToFind) { var tnClass = new TreeNode(ccCirClass.Signature); foreach (ICirFunction cfCirFunction in ccCirClass.dFunctions.Values) { String sFunctionName = new FilteredSignature(cfCirFunction.FunctionSignature).sFunctionName; switch (sFunctionName.Substring(0, 3)) { case "get": var tnSubObject = new TreeNode(sFunctionName); String sFixedSubObjectName = sFunctionName.Replace("get", ""); if (bHideGetAndSetStrings) { tnSubObject.Text = sFixedSubObjectName; } // tnSubObject = tnClass; addBindableFieldsIntoTreeView_Recursive(tnSubObject.Nodes, sFixedSubObjectName, bHideGetAndSetStrings, fadCirData); if (tnSubObject.Nodes.Count > 0) { tnClass.Nodes.Add(tnSubObject); } break; case "set": String sSetNodeText = new FilteredSignature(cfCirFunction.FunctionSignature).sFunctionName; if (bHideGetAndSetStrings) { sSetNodeText = sSetNodeText.Replace("set", ""); } tnClass.Nodes.Add(sSetNodeText); break; default: break; } } tncTreeNodes.Add(tnClass); } // String sClassName = } }
public static String populateGraphWithTreeNode(ref int iEdgeId, Graph gGraphToPopulate, TreeNode tnTreeNode, bool bOrder, bool bFilterName, bool bOnlyShowClasses, Int32 iShowClassesLevel, bool bShowParameters, bool bShowReturnClass, bool bShowNamespace, int iNamespaceDepth) { String sNormalizedName = FilteredSignature.filterName(tnTreeNode.Text, bShowParameters, bShowReturnClass, bShowNamespace, iNamespaceDepth, bFilterName, bOnlyShowClasses, iShowClassesLevel); if (sNormalizedName == "") { sNormalizedName = "[***Empty***]"; } var nNode = (Node)gGraphToPopulate.AddNode(sNormalizedName); nNode.UserData = tnTreeNode; nNode.Attr.Shape = Shape.Plaintext; String sNodeText_From = tnTreeNode.Text; foreach (TreeNode tnChild in tnTreeNode.Nodes) { String sNodeText_To = FilteredSignature.filterName(tnChild.Text, bShowParameters, bShowReturnClass, bShowNamespace, iNamespaceDepth, bFilterName, bOnlyShowClasses, iShowClassesLevel); if (sNodeText_From != sNodeText_To) // don't add edge if they are the same text { addEdgeToGraph(gGraphToPopulate, sNodeText_From, sNodeText_To, (iEdgeId++).ToString()); } sNodeText_From = populateGraphWithTreeNode(ref iEdgeId, gGraphToPopulate, tnChild, bOrder, bFilterName, bOnlyShowClasses, iShowClassesLevel); // add the return value // need to find a way to not do this for sinks // if (sNodeText_From != sNodeText_To) // { // addEdgeToGraph(gGraphToPopulate, sNodeText_From, sNodeText_To, (iEdgeId++).ToString()); // sNodeText_From = sNodeText_To; // } /* * String sMethodA = Analysis_CallFlow.display.filterName(tnChild.Text , bShowParameters, bShowReturnClass, bShowNamespace, bFilterName, bOnlyShowClasses, iShowClassesLevel); * String sMethodB = Analysis_CallFlow.display.filterName(tnTreeNode.Text , bShowParameters, bShowReturnClass, bShowNamespace, bFilterName, bOnlyShowClasses, iShowClassesLevel); * if (bOrder) * addEdgeToGraph(gGraphToPopulate,sMethodA,sMethodB,true); * else * addEdgeToGraph(gGraphToPopulate,sMethodB,sMethodA,false); */ } return(sNodeText_From); }
private static String MakeSignatureCompatibleWithOunceRules(string signatureToFix) { if (signatureToFix.IndexOf("..ctor") > -1) { var filteredSiganture = new FilteredSignature(signatureToFix); if (filteredSiganture.lsFunctionClass_Parsed.Count > 1) { signatureToFix = signatureToFix.Replace(".ctor", filteredSiganture.lsFunctionClass_Parsed[filteredSiganture.lsFunctionClass_Parsed.Count - 2]).Replace(".(", "("); } ; } signatureToFix = signatureToFix.Replace("..ctor", ""); return(FilteredSignature.makeDotNetSignatureCompatibleWithOunceRules(signatureToFix)); }
private void showFunctionAttributes(ICirFunction _rootCirFunction) { showClassAttributes(_rootCirFunction.ParentClass); tvFunctionAttributes.Nodes.Clear(); foreach (var attribute in _rootCirFunction.FunctionAttributes) { var signature = new FilteredSignature(attribute.AttributeClass).sSignature; var treeNode = tvFunctionAttributes.Nodes.Add(signature); foreach (var parameter in attribute.Parameters) { treeNode.Nodes.Add(parameter.Key); } } }
public void showSelectedMethodDetails(FilteredSignature filteredSignature) { if (filteredSignature != null) { tbMethodDetails_Name.invokeOnThread( () => { tbMethodDetails_Name.Text = filteredSignature.sFunctionName; tbMethodDetails_OriginalSignature.Text = filteredSignature.sOriginalSignature; tbMethodDetails_Parameters.Text = filteredSignature.sParameters; tbMethodDetails_ReturnType.Text = filteredSignature.sReturnClass; tbMethodDetails_Signature.Text = filteredSignature.sSignature; tbMethodDetails_Type.Text = filteredSignature.sFunctionClass; }); } }
public void loadAssembly(AssemblyDefinition assemblyDefinition) { tvDirectoriesAndFiles.invokeOnThread( () => { tvDirectoriesAndFiles.Nodes.Clear(); foreach (var method in CecilUtils.getMethods(assemblyDefinition)) { if (method.HasBody) { var filteredSignature = new FilteredSignature(method.ToString()); O2Forms.newTreeNode(tvDirectoriesAndFiles.Nodes, filteredSignature.sSignature, 0, method); } } tvDirectoriesAndFiles.Sort(); }); }
public void addToDataGridView_CommandMappingInTreeNode_Recursive(TreeNodeCollection tncNodes, DataGridView dgvTargetDataGridView) { foreach (TreeNode tnTreeNode in tncNodes) { if (tnTreeNode.Text.IndexOf("setCommandName") > -1 && tnTreeNode.Nodes.Count > 0) { String sMethod = new FilteredSignature(tnTreeNode.Text).sFunctionNameAndParams; String sClass = tnTreeNode.Parent.Parent.Text; String sValue = tnTreeNode.Nodes[0].Text; O2Forms.addToDataGridView_Row(dgvTargetDataGridView, null, new[] { sClass, sMethod, sValue }); } addToDataGridView_CommandMappingInTreeNode_Recursive(tnTreeNode.Nodes, dgvTargetDataGridView); } }
public override string ToString() { if (false == OnlyShowFunctionNameInToString) { return(FunctionSignature); } String sStringToFilter = FunctionSignature; const bool bShowParameters = true; const bool bShowReturnClass = true; const bool bShowNamespace = true; const int iNamespaceDepth = 1; return(FilteredSignature.filterSignature(sStringToFilter, bShowParameters, bShowReturnClass, bShowNamespace, iNamespaceDepth)); }
private void showClassAttributes(ICirClass cirClass) { if (cirClass != null) { tvClassAttributes.Nodes.Clear(); foreach (var attribute in cirClass.ClassAttributes) { var signature = new FilteredSignature(attribute.AttributeClass).sSignature; var treeNode = tvClassAttributes.Nodes.Add(signature); foreach (var parameter in attribute.Parameters) { treeNode.Nodes.Add(parameter.Key); } } } }
public static MethodDefinition getMethodDefinitionFromMethodInfo(MethodInfo methodInfo, Mono.Cecil.AssemblyDefinition assemblyDefinition) { foreach (var methodDefinition in CecilUtils.getMethods(assemblyDefinition)) { var functionSignature1 = new FilteredSignature(methodInfo); var functionSignature2 = new FilteredSignature(methodDefinition.ToString()); if (functionSignature1.sSignature == functionSignature2.sSignature) { return(methodDefinition); } if (functionSignature1.sFunctionName == functionSignature2.sFunctionName) { } } PublicDI.log.error("in getMethodDefinitionFromMethodInfo, could not map MethodInfo: {0}", methodInfo.ToString()); return(null); }
//DC this version was using the old QuickGraph MarkedEdge public static void createGraphWizDotFile(AdjacencyGraph <String, TaggedEdge <String, String> > gGraphWizToPopulate, TreeNode tnTreeNode, bool bOrder, bool bFilterName, bool bFilterClass, int iFilterClassLevel) { if (bFilterClass) { tnTreeNode.Text = FilteredSignature.filterName(tnTreeNode.Text, false, false, true, 0, true, true, iFilterClassLevel); } TaggedEdge <String, string> meTemp; if (gGraphWizToPopulate.ContainsVertex(tnTreeNode.Text)) { } else { gGraphWizToPopulate.AddVertex(tnTreeNode.Text); } foreach (TreeNode tnChild in tnTreeNode.Nodes) { if (bFilterClass) { tnChild.Text = FilteredSignature.filterName(tnChild.Text, false, false, true, 0, true, true, iFilterClassLevel); } createGraphWizDotFile(gGraphWizToPopulate, tnChild, bOrder, bFilterName, bFilterClass, iFilterClassLevel); if (bOrder) { if (false == gGraphWizToPopulate.TryGetEdge(tnTreeNode.Text, tnChild.Text, out meTemp)) { gGraphWizToPopulate.AddEdge(new TaggedEdge <String, string>(tnTreeNode.Text, tnChild.Text, "marker")); } } else if (false == gGraphWizToPopulate.TryGetEdge(tnChild.Text, tnTreeNode.Text, out meTemp)) { gGraphWizToPopulate.AddEdge(new TaggedEdge <String, string>(tnChild.Text, tnTreeNode.Text, "marker")); } //gGraphToPopulate.AddEdge(tnTreeNode.Text, tnChild.Text); // gGraphToPopulate.AddEdge(Analysis_CallFlow.display.filterName(tnChild.Text, false, false, false), Analysis_CallFlow.display.filterName(tnTreeNode.Text, false, false, false)); //else } }
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(); } }
public static void makeLostSourcesVisible(GraphData fgdGraphData, bool bShowParameters, bool bShowReturnClass, bool bShowNamespace, int iNamespaceDepth) { foreach (String sNode in fgdGraphData.dNodes.Keys) { if (false == fgdGraphData.dNodeIsCalledBy.ContainsKey(sNode)) { fgdGraphData.dNodes[sNode].NodeAttribute.Label = FilteredSignature.filterSignature(sNode, bShowParameters, bShowReturnClass, bShowNamespace, iNamespaceDepth); ; fgdGraphData.dNodes[sNode].NodeAttribute.Shape = Shape.Box; if (fgdGraphData.lnEmptyNodes.Contains(fgdGraphData.dNodes[sNode])) { fgdGraphData.lnEmptyNodes.Remove(fgdGraphData.dNodes[sNode]); } } } }
public static bool mapJavaAttributesToFinding(O2Finding o2Finding, string xmlAttributeFile) { var source = o2Finding.Source; var filteredSignature = new FilteredSignature(source); //DI.log.info(filteredSignature.sFunctionClass + " - " + filteredSignature.sFunctionName); var xClassElement = getClassDataFromXmlAttributeFile(xmlAttributeFile, filteredSignature.sFunctionClass); if (xClassElement != null) { SpringMVCAttributes.addClassAttributesToFinding(xClassElement, o2Finding); var xMethodElement = getMethodDataFromXmlAttributeFile(xClassElement, filteredSignature.sFunctionName); if (xMethodElement != null) { SpringMVCAttributes.addMethodAttributesToFinding(xMethodElement, o2Finding); return(true); // DI.log.info("have xElement"); } } return(false); //DI.log.info("mapping finding {0} with xml file {1}", o2Finding.ToString(), xmlAttributeFile); }
public static void mapMethodsToFilteredSignatures(List <MethodInfo> methodsToMap, ref List <FilteredSignature> filteredSignatures, ref Dictionary <string, MethodInfo> methods_bySignature, bool hideCSharpGeneratedMethods) { filteredSignatures = new List <FilteredSignature>(); methods_bySignature = new Dictionary <string, MethodInfo>(); foreach (var method in methodsToMap) { try { var filteredSignature = new FilteredSignature(method); if (hideCSharpGeneratedMethods == false || (filteredSignature.sSignature.IndexOf("<>") == -1 && false == filteredSignature.sFunctionName.StartsWith("b__"))) { // create methodsLoaded_bySignature if (methods_bySignature.ContainsKey(filteredSignature.sSignature)) { if (method.type().Assembly.GetName().Name.contains("FluentSharp")) { PublicDI.log.error("in mapMethodsToFilteredSignatures, repeated signature: {0}", filteredSignature.sSignature); } } else { filteredSignatures.Add(filteredSignature); methods_bySignature.Add(filteredSignature.sSignature, method); } } else { //PublicDI.log.info("Skipping: {0}", method.Name); } } catch (Exception ex) { "[O2 Object Model] mapMethodsToFilteredSignatures: {0}".error(ex.Message); } } }
public Reflection_MethodInfo(MethodInfo method) { Method = method; filteredSignature = new FilteredSignature(method); }
private void filterByFilteredSignature(FilteredSignature filteredSignature) { setFilter1TextValue(filteredSignature.sSignature, true); }