public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException, XPathExpressionException, TransformerFactoryConfigurationError, TransformerException { DocumentBuilder bud = DocumentBuilderFactory.newInstance().newDocumentBuilder(); InputStream inp = new ByteArrayInputStream(xml.getBytes()); Document doc = bud.parse(inp); XPath xpath = XPathFactory.newInstance().newXPath(); XPathExpression expr = xpath.compile("//Person/PostalCode"); NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); for (int i = 0; i < nodes.getLength(); i++) { System.out.println(nodes.item(i).getTextContent()); nodes.item(i).setTextContent("Ala ma kota " + i); } Transformer xformer = TransformerFactory.newInstance().newTransformer(); StringWriter bufor = new StringWriter(); xformer.transform(new DOMSource(doc), new StreamResult(bufor)); System.out.println("==================="); System.out.println(bufor.toString()); }
@Test public void testFieldHasMatchingUserValues() throws Exception { LOG.info("testFieldHasMatchingUserValues"); DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder(); XPath xpath = XPathFactory.newInstance().newXPath(); Document doc = db.parse(this.getClass().getResourceAsStream(SAMPLE_EDOC_XML)); // enumerate all fields final String fieldDefs = "/edlContent/edl/field/display/values"; NodeList nodes = (NodeList) xpath.evaluate(fieldDefs, doc, XPathConstants.NODESET); for (int i = 0; i < nodes.getLength(); i++) { Node node = nodes.item(i); String name = (String) xpath.evaluate("../../@name", node, XPathConstants.STRING); LOG.debug("Name: " + name); LOG.debug("Value: " + node.getFirstChild().getNodeValue()); final String expr = "/edlContent/data/version[@current='true']/fieldEntry[@name=current()/../../@name and value=current()]"; NodeList matchingUserValues = (NodeList) xpath.evaluate(expr, node, XPathConstants.NODESET); LOG.debug(matchingUserValues + ""); LOG.debug(matchingUserValues.getLength() + ""); if ("gender".equals(name)) { assertTrue("Matching values > 0", matchingUserValues.getLength() > 0); } for (int j = 0; j < matchingUserValues.getLength(); j++) { LOG.debug(matchingUserValues.item(j).getFirstChild().getNodeValue()); } } }
/* goodG2B() - use goodsource and badsink */ private void goodG2B(HttpServletRequest request, HttpServletResponse response) throws Throwable { String data = (new CWE643_Unsafe_Treatment_of_XPath_Input__getCookiesServlet_61b()) .goodG2B_source(request, response); final String xmldoc = "\\src\\testcases\\CWE643_Unsafe_Treatment_of_XPath_Input\\console_to_evaluate\\CWE643_Unsafe_Treatment_of_XPath_Input__helper.xml"; /* assume username||password as source */ String[] tokens = data.split("||"); if (tokens.length < 2) { return; } String uname = tokens[0]; String pword = tokens[1]; /* build xpath */ XPath xp = XPathFactory.newInstance().newXPath(); InputSource inxml = new InputSource(xmldoc); /* INCIDENTAL: CWE180 Incorrect Behavior Order: Validate Before Canonicalize * The user input should be canonicalized before validation. */ /* FLAW: user input is used without validate */ String query = "//users/user[name/text()='" + uname + "' and pass/text()='" + pword + "']" + "/secret/text()"; String secret = (String) xp.evaluate(query, inxml, XPathConstants.STRING); }
@Override public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); final PsiExpressionList argumentList = expression.getArgumentList(); final PsiExpression[] arguments = argumentList.getExpressions(); if (arguments.length == 0) { return; } final PsiExpression xpathArgument = arguments[0]; if (!ExpressionUtils.hasStringType(xpathArgument)) { return; } if (!PsiUtil.isConstantExpression(xpathArgument)) { return; } final PsiType type = xpathArgument.getType(); if (type == null) { return; } final String value = (String) ConstantExpressionUtil.computeCastTo(xpathArgument, type); if (value == null) { return; } if (!callTakesXPathExpression(expression)) { return; } final XPathFactory xpathFactory = XPathFactory.newInstance(); final XPath xpath = xpathFactory.newXPath(); //noinspection UnusedCatchParameter,ProhibitedExceptionCaught try { xpath.compile(value); } catch (XPathExpressionException ignore) { registerError(xpathArgument); } }
public NodeList getOQasNodeList() throws SAXException, ParserConfigurationException, XPathExpressionException { NodeList result = null; if (oqUrl == null) { logger.warn("OQ.url not found. Synchronization impossible."); trace.append("Синхронизация невозможна: OQ.url не указан."); return result; } try { URLConnection oqc = oqUrl.openConnection(); DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); DocumentBuilder builder = domFactory.newDocumentBuilder(); Document doc = builder.parse(oqc.getInputStream()); XPath xpath = XPathFactory.newInstance().newXPath(); XPathExpression expr = xpath.compile("/root/projects/project"); result = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); } catch (IOException e) { // обрабатываем только IOException - остальные выбрасываем наверх logger.error("oq project sync error: ", e); trace .append( "Синхронизация прервана из-за ошибки ввода/вывода при попытке получить и прочитать файл " + "синхронизации: ") .append(e.getMessage()) .append("\n"); } return result; }
/** * This method evaluates the predicate based on the xpath expression on the supplied node. * * @param xpath The xpath expression * @param node The node * @return The result */ public static boolean predicate(String xpath, Object node) { Node domNode = getNode(node); if (domNode == null) { log.severe("Unable to evaluate non DOM Node object"); return false; } if (xpath == null) { log.severe("Predicate has not xpath expression"); return false; } // TODO: HWKBTM-104 Investigate caching compiled xpath expressions try { xpath = getExpression(xpath); XPath xp = XPathFactory.newInstance().newXPath(); Boolean result = (Boolean) xp.evaluate(xpath, domNode, XPathConstants.BOOLEAN); if (result != null) { return result; } } catch (Exception e) { log.log(Level.SEVERE, "Failed to execute predicate xpath '" + xpath + "'", e); } return false; }
/** * Get container window * * <p> * * @return String */ private String getWindowName(String sWidgetID) { String sWindowName = null; // get widget ID XPath xpath = XPathFactory.newInstance().newXPath(); XPathExpression expr; Object result; NodeList nodes; try { String xpathExpression = "/GUIStructure/GUI[Container//Property[Name=\"" + GUITARConstants.ID_TAG_NAME + "\" and Value=\"" + sWidgetID + "\"]]/Window/Attributes/Property[Name=\"" + GUITARConstants.TITLE_TAG_NAME + "\"]/Value/text()"; expr = xpath.compile(xpathExpression); result = expr.evaluate(docGUI, XPathConstants.NODESET); nodes = (NodeList) result; if (nodes.getLength() > 0) sWindowName = nodes.item(0).getNodeValue(); } catch (XPathExpressionException e) { GUITARLog.log.error(e); } return sWindowName; }
private String fromXmlToColor(String xml) { String result = BLUE; DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); // never forget this! DocumentBuilder builder = null; try { builder = domFactory.newDocumentBuilder(); Document document = builder.parse(new InputSource(new StringReader(xml))); XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); XPathExpression expr = xpath.compile("//color"); Object n = expr.evaluate(document, XPathConstants.NODESET); NodeList nodes = (NodeList) n; if (nodes.getLength() > 0) { result = (String) nodes.item(0).getTextContent(); } } catch (Exception e) { System.err.println("fromXmlToColor:" + e); } return result; }
private Node evaluateXPathNode( Node bindings, Node target, String expression, NamespaceContext namespaceContext) { NodeList nlst; try { xpath.setNamespaceContext(namespaceContext); nlst = (NodeList) xpath.evaluate(expression, target, XPathConstants.NODESET); } catch (XPathExpressionException e) { reportError( (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATION_ERROR(e.getMessage()), e); return null; // abort processing this <jaxb:bindings> } if (nlst.getLength() == 0) { reportError( (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATES_TO_NO_TARGET(expression)); return null; // abort } if (nlst.getLength() != 1) { reportError( (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVAULATES_TO_TOO_MANY_TARGETS( expression, nlst.getLength())); return null; // abort } Node rnode = nlst.item(0); if (!(rnode instanceof Element)) { reportError( (Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATES_TO_NON_ELEMENT(expression)); return null; // abort } return rnode; }
public List<String> getOriginCatalogs() { XPathFactory xpathFactory = XPathFactory.newInstance(); XPath xpath = xpathFactory.newXPath(); List<String> catalogs = new ArrayList<String>(); try { XPathExpression expr = xpath.compile("//Resolver"); NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); for (int i = 0; i < nodes.getLength(); i++) { XPathExpression hasAliasExp = xpath.compile("./alias"); NodeList aliases = (NodeList) hasAliasExp.evaluate(nodes.item(i), XPathConstants.NODESET); if (aliases.getLength() > 0) { XPathExpression nameAttribute = xpath.compile("@name"); String name = (String) nameAttribute.evaluate(nodes.item(i), XPathConstants.STRING); catalogs.add(name); } } } catch (XPathExpressionException e) { e.printStackTrace(); } return catalogs; }
/** * Extract an XML element. * * @param xpathExp * @param file * @return */ private Document getDocFragment(String xpathExp, XmlMetadata file) { Document testDoc = null; try { XPath xpath = XPathFactory.newInstance().newXPath(); Node node = (Node) xpath.evaluate(xpathExp, file.getParsedDocument(), XPathConstants.NODE); if (node != null) { TransformerFactory transFactory = TransformerFactory.newInstance(); Transformer transformer = transFactory.newTransformer(); StringWriter buffer = new StringWriter(); transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); transformer.transform(new DOMSource(node), new StreamResult(buffer)); String testStr = buffer.toString(); LOG.debug("src string: " + testStr); DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); testDoc = dBuilder.parse(new InputSource(new ByteArrayInputStream(testStr.getBytes("utf-8")))); } } catch (XPathExpressionException xee) { LOG.error("Invalid XPath expression: " + xpathExp); } catch (Exception e) { LOG.error("Error extracting XML content: ", e); } return testDoc; }
public static MediaNode create(final Node media, final XPath xpath) throws Exception { final String url = xpath.evaluate("./@url", media); final int bitrate = getBitrate(media, xpath); final String bootstrapInfoId = xpath.evaluate("./@bootstrapInfoId", media); final String href = xpath.evaluate("./@href", media); return new MediaNode(url, bitrate, bootstrapInfoId, href); }
/** * Initialize the GuideXML class with a local file XML path * * @param context the app context * @param guideId the guide identifier * @param path the local file name of the guide XML file */ public GuideXML(Context context, String guideId, String path) { mContext = context; mGuideId = guideId; FileReader fr = null; try { fr = new FileReader(path); } catch (FileNotFoundException e) { e.printStackTrace(); return; } InputSource inputSource = new InputSource(fr); mTagCounts = new HashMap<String, Integer>(); mTags = new HashMap<String, Set<String>>(); try { // Read root node so we won't re-parse the XML file every time we evaluate an XPath XPath xpath = XPathFactory.newInstance().newXPath(); setRootNode((Node) xpath.evaluate("/", inputSource, XPathConstants.NODE)); // Parse all taxon tags parseTags(); } catch (XPathExpressionException e) { e.printStackTrace(); } }
public InternalDocColumnSchema getColumnSchema() { columnSchema = new InternalDocColumnSchemaImpl(numberOfColumns); XPath xpath = XPathFactory.newInstance().newXPath(); for (Integer index : indexesTable.keySet()) { NodeList indexToColumnData = null; try { indexToColumnData = (NodeList) xpath.evaluate( "//contact[count(*[@columnCounter=" + index + "]) = " + indexesTable.get(index).size() + "][1]/*[@columnCounter=" + index + "]", compiledDoc, XPathConstants.NODESET); } catch (XPathExpressionException ex) { Logger.getLogger(ReadCompiledDoc.class.getName()).log(Level.SEVERE, null, ex); } if (indexToColumnData == null) { System.err.println("Error while parsing compiled doc into column schema - errNo:4"); return null; } int iterator = 0; for (Integer column : indexesTable.get(index)) { String type = ((Element) indexToColumnData.item(iterator)).getTagName(); columnSchema.setCandidateType(column, type); columnSchema.setSelectedtypeType(column, type); iterator++; } } return columnSchema; }
public static void main(String[] args) { CodeExtractor myCode = new CodeExtractor(4); // myCode.parseFile("http://java.sun.com/docs/books/tutorial/java/nutsandbolts/for.html"); myCode.parseFile("http://www.javadeveloper.co.in/java-example/java-hashmap-example.html"); String docString = myCode.getDoc(); try { XPath xPath = XPathFactory.newInstance().newXPath(); XPathExpression nodeXPathExpr = xPath.compile("/codesnippets/text | /codesnippets/sourcecode"); InputSource inputSource = new InputSource(new ByteArrayInputStream(docString.getBytes())); NodeList allNodes = (NodeList) nodeXPathExpr.evaluate(inputSource, XPathConstants.NODESET); int nodeNumber = allNodes.getLength(); System.out.println("Text Found:: " + nodeNumber + " nodes."); System.out.println("========================================"); for (int i = 0; i < nodeNumber; i++) { Node node = allNodes.item(i); String content = node.getTextContent(); // content = StringEscapeUtils.unescapeHtml(content).trim(); System.out.println(node + ":--->:" + node.getNodeName()); if (node.getTextContent() != null) System.out.println("--->" + content); System.out.println("========================================"); } } catch (XPathExpressionException e) { e.printStackTrace(); } }
public GetAuthDetailsResponseDetailsType(Node node) throws XPathExpressionException { XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); Node childNode = null; NodeList nodeList = null; childNode = (Node) xpath.evaluate("FirstName", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.FirstName = childNode.getTextContent(); } childNode = (Node) xpath.evaluate("LastName", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.LastName = childNode.getTextContent(); } childNode = (Node) xpath.evaluate("Email", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.Email = childNode.getTextContent(); } childNode = (Node) xpath.evaluate("PayerID", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.PayerID = childNode.getTextContent(); } }
/** * This method evaluates the xpath expression on the supplied node. The result can either be a * document fragment, a text node value or null if the expression references a missing part of the * document. * * @param xpath The xpath expression * @param node The node * @return The result, or null if not found (which may be due to an expression error) */ public static String evaluate(String xpath, Object node) { Node domNode = getNode(node); if (domNode == null) { log.severe("Unable to evaluate non DOM Node object"); return null; } // If no xpath expression, then serialize if (xpath == null || xpath.trim().length() == 0) { return serialize(node); } // TODO: HWKBTM-104 Investigate caching compiled xpath expressions try { xpath = getExpression(xpath); XPath xp = XPathFactory.newInstance().newXPath(); Node result = (Node) xp.evaluate(xpath, domNode, XPathConstants.NODE); if (result != null) { if (result.getNodeType() == Node.TEXT_NODE) { return result.getNodeValue(); } else if (result.getNodeType() == Node.ATTRIBUTE_NODE) { return result.getNodeValue(); } return serialize(result); } } catch (Exception e) { log.log(Level.SEVERE, "Failed to evaluate xpath '" + xpath + "'", e); } return null; }
@Override protected String verifyWpsResponse(final String responseStr) throws Exception { final Document responseData = XmlDocumentBuilder.parse(responseStr, false); Assert.assertNotNull(responseData); // System.out.println(XmlDocumentBuilder.toString(responseData)); XPath xpath = XmlDocumentBuilder.createXPath(); String jobIdStr = null; try { Assert.assertEquals(processId, xpath.evaluate(".//Process/Identifier", responseData)); NodeList returnedNodes = XPathAPI.selectNodeList(responseData, ".//ProcessOutputs/Output"); Assert.assertEquals(1, returnedNodes.getLength()); Assert.assertEquals( "jobId", xpath.evaluate(".//ProcessOutputs/Output/Identifier", responseData)); Assert.assertEquals( "string", xpath.evaluate(".//ProcessOutputs/Output/Data/LiteralData/@dataType", responseData)); jobIdStr = xpath.evaluate(".//ProcessOutputs/Output/Data/LiteralData", responseData); Assert.assertNotNull(UUID.fromString(jobIdStr)); } catch (XPathExpressionException e) { Assert.fail("Error parsing response document: " + e.getMessage()); } return jobIdStr; }
public Location getLocationData() { Location location = new Location(); try { LocationDoc = builder.parse(new FileInputStream("location.xml")); String ExtendedNameExpression = "/GeocodeResponse/result/formatted_address/text()"; String LatitudeExpression = "/GeocodeResponse/result/geometry/location/lat/text()"; String LongitudeExpression = "/GeocodeResponse/result/geometry/location/lng/text()"; String ShortNameExpression = "/GeocodeResponse/result/address_component/short_name/text()"; XPath xPath = XPathFactory.newInstance().newXPath(); // read a string value location.setExtendedName(xPath.compile(ExtendedNameExpression).evaluate(LocationDoc)); location.setLatitude( Float.parseFloat(xPath.compile(LatitudeExpression).evaluate(LocationDoc))); location.setLongitude( Float.parseFloat(xPath.compile(LongitudeExpression).evaluate(LocationDoc))); location.setName(xPath.compile(ShortNameExpression).evaluate(LocationDoc)); // read an xml node using xpath } catch (Exception ex) { Logger.getLogger(DataFiller.class.getName()).log(Level.SEVERE, null, ex); } System.out.println(location); return location; }
/** * Runs an XPath expression on this node. * * @param env * @param expression * @return array of results * @throws XPathExpressionException */ public Value xpath(Env env, String expression) { try { XPath xpath = XPathFactory.newInstance().newXPath(); InputSource is = new InputSource(asXML(env).toInputStream()); NodeList nodes = (NodeList) xpath.evaluate(expression, is, XPathConstants.NODESET); int nodeLength = nodes.getLength(); if (nodeLength == 0) return NullValue.NULL; // There are matching nodes ArrayValue result = new ArrayValueImpl(); for (int i = 0; i < nodeLength; i++) { Node node = nodes.item(i); boolean isPrefix = node.getPrefix() != null; SimpleXMLElement xml = buildNode(env, _cls, null, nodes.item(i), node.getNamespaceURI(), isPrefix); result.put(wrapJava(env, _cls, xml)); } return result; } catch (XPathExpressionException e) { env.warning(e); log.log(Level.FINE, e.getMessage()); return NullValue.NULL; } }
private Node[] merge(MergeHandler handler, List<Node> exhaustedNodes) throws XPathExpressionException, TransformerException { if (LOG.isDebugEnabled()) { LOG.debug("Processing handler: " + handler.getXPath()); } if (handler.getChildren() != null) { MergeHandler[] children = handler.getChildren(); for (int j = 0; j < children.length; j++) { Node[] temp = merge(children[j], exhaustedNodes); if (temp != null) { for (Node node : temp) { exhaustedNodes.add(node); } } } } NodeList nodeList1 = (NodeList) xPath.evaluate(handler.getXPath(), doc1, XPathConstants.NODESET); NodeList nodeList2 = (NodeList) xPath.evaluate(handler.getXPath(), doc2, XPathConstants.NODESET); if (nodeList1 != null && nodeList2 != null) { return handler.merge(nodeList1, nodeList2, exhaustedNodes); } return null; }
/** * Parses a single <code><result></code> entry from the Google Places XML response. * * @param resultNode * @return * @throws XPathExpressionException */ private GooglePlace parseSingleResult(Node resultNode) throws XPathExpressionException { XPath xpath = XPathFactory.newInstance().newXPath(); String expr; GooglePlace place = new GooglePlace(); if (resultNode != null) { expr = "name"; place.setName((String) xpath.evaluate(expr, resultNode, XPathConstants.STRING)); expr = "formatted_address"; place.setFormattedAddress((String) xpath.evaluate(expr, resultNode, XPathConstants.STRING)); expr = "geometry/location/lat"; String lat = (String) xpath.evaluate(expr, resultNode, XPathConstants.STRING); if (lat != null && lat.length() > 0) { place.setLatitude(Double.parseDouble(lat)); } expr = "geometry/location/lng"; String lng = (String) xpath.evaluate(expr, resultNode, XPathConstants.STRING); if (lng != null && lng.length() > 0) { place.setLongitude(Double.parseDouble(lng)); } } return place; }
private void checkBomVersionInPom(String xml) { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder; Document doc = null; try { builder = factory.newDocumentBuilder(); doc = builder.parse(new InputSource(new StringReader(xml))); } catch (SAXException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ParserConfigurationException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } XPathFactory xPathfactory = XPathFactory.newInstance(); XPath xpath = xPathfactory.newXPath(); XPathExpression expr = null; String bom_version = null; try { expr = xpath.compile("/project/properties/version.jboss.bom"); bom_version = (String) expr.evaluate(doc, XPathConstants.STRING); } catch (XPathExpressionException e) { // TODO Auto-generated catch block e.printStackTrace(); } assertEquals( "jboss bom version in pom differs from the one given by wizard", version, bom_version); }
public static void readXpath() throws ParserConfigurationException, SAXException, IOException, XPathExpressionException { DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); DocumentBuilder builder = domFactory.newDocumentBuilder(); Document doc = builder.parse("D:\\temp\\test_2\\screen_2.xml"); XPath xpath = XPathFactory.newInstance().newXPath(); // XPath Query for showing all nodes value // XPathExpression expr = xpath // .compile("//Screens/Screen[@number='1']/Button[@number='1']/Action[@type='onclick']/*"); String xpathStr = "//Screen[@number='2007']/Button[@number='87'][@h='1']"; XPathExpression expr = xpath.compile(xpathStr); Object result = expr.evaluate(doc, XPathConstants.NODESET); NodeList nodes = (NodeList) result; for (int i = 0; i < nodes.getLength(); i++) { NamedNodeMap nodeMap = nodes.item(i).getAttributes(); String attrName = ""; for (int j = 0; j < nodeMap.getLength(); j++) { attrName = xpathStr.substring(xpathStr.lastIndexOf('@') + 1, xpathStr.lastIndexOf("=")); if (nodes.item(i).getAttributes().item(j).getNodeName().equals(attrName)) { System.out.println(nodes.item(i).getAttributes().item(j).getNodeValue()); } } } }
public List<String> getNodeDetails(NamespaceContext nsc, String exprString, String filePath) throws XPathExpressionException { List<String> list = new ArrayList<String>(); XPathFactory factory = XPathFactory.newInstance(); // 2. Use the XPathFactory to create a new XPath object XPath xpath = factory.newXPath(); xpath.setNamespaceContext(nsc); // 3. Compile an XPath string into an XPathExpression XPathExpression expression = xpath.compile(exprString); // 4. Evaluate the XPath expression on an input document Node result = (Node) expression.evaluate(new org.xml.sax.InputSource(filePath), XPathConstants.NODE); String svcName = null; NamedNodeMap attMap = result.getAttributes(); Node att = attMap.getNamedItem("group"); if (att != null) svcName = att.getNodeValue(); if (result != null) { list.add(result.getNodeName()); list.add(result.getTextContent()); list.add(svcName); } factory = null; xpath = null; expression = null; result = null; attMap = null; att = null; return list; }
/** * Evaluate an XPath string and return true if the output is to be included or not. * * @param contextNode The node to start searching from. * @param xpathnode The XPath node * @param str The XPath expression * @param namespaceNode The node from which prefixes in the XPath will be resolved to namespaces. */ public boolean evaluate(Node contextNode, Node xpathnode, String str, Node namespaceNode) throws TransformerException { if (!str.equals(xpathStr) || xpathExpression == null) { if (xpf == null) { xpf = XPathFactory.newInstance(); try { xpf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE); } catch (XPathFactoryConfigurationException ex) { throw new TransformerException(ex); } } XPath xpath = xpf.newXPath(); xpath.setNamespaceContext(new DOMNamespaceContext(namespaceNode)); xpathStr = str; try { xpathExpression = xpath.compile(xpathStr); } catch (XPathExpressionException ex) { throw new TransformerException(ex); } } try { return (Boolean) xpathExpression.evaluate(contextNode, XPathConstants.BOOLEAN); } catch (XPathExpressionException ex) { throw new TransformerException(ex); } }
/* goodB2G() - use badsource and goodsink */ private void goodB2G(HttpServletRequest request, HttpServletResponse response) throws Throwable { String data = (new CWE643_Unsafe_Treatment_of_XPath_Input__getCookiesServlet_61b()) .goodB2G_source(request, response); final String xmldoc = "\\src\\testcases\\CWE643_Unsafe_Treatment_of_XPath_Input\\console_to_evaluate\\CWE643_Unsafe_Treatment_of_XPath_Input__helper.xml"; /* assume username||password as source */ String[] tokens = data.split("||"); if (tokens.length < 2) { return; } /* FIX: validate input using StringEscapeUtils */ String uname = StringEscapeUtils.escapeXml(tokens[0]); String pword = StringEscapeUtils.escapeXml(tokens[1]); /* build xpath */ XPath xp = XPathFactory.newInstance().newXPath(); InputSource inxml = new InputSource(xmldoc); String query = "//users/user[name/text()='" + uname + "' and pass/text()='" + pword + "']" + "/secret/text()"; String secret = (String) xp.evaluate(query, inxml, XPathConstants.STRING); }
@Override public void addAssociation( String associationName, String workflowId, String eventId, String condition) throws WorkflowException { if (StringUtils.isBlank(workflowId)) { log.error("Null or empty string given as workflow id to be associated to event."); throw new InternalWorkflowException("Service alias cannot be null"); } if (StringUtils.isBlank(eventId)) { log.error("Null or empty string given as 'event' to be associated with the service."); throw new InternalWorkflowException("Event type cannot be null"); } if (StringUtils.isBlank(condition)) { log.error( "Null or empty string given as condition expression when associating " + workflowId + " to event " + eventId); throw new InternalWorkflowException("Condition cannot be null"); } // check for xpath syntax errors XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); try { xpath.compile(condition); workflowDAO.addAssociation(associationName, workflowId, eventId, condition); } catch (XPathExpressionException e) { log.error("The condition:" + condition + " is not an valid xpath expression.", e); throw new WorkflowRuntimeException("The condition is not a valid xpath expression."); } }
public OptionSelectionDetailsType(Node node) throws XPathExpressionException { XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); Node childNode = null; NodeList nodeList = null; childNode = (Node) xpath.evaluate("OptionSelection", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.optionSelection = childNode.getTextContent(); } childNode = (Node) xpath.evaluate("Price", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.price = childNode.getTextContent(); } childNode = (Node) xpath.evaluate("OptionType", node, XPathConstants.NODE); if (childNode != null && !isWhitespaceNode(childNode)) { this.optionType = OptionTypeListType.fromValue(childNode.getTextContent()); } nodeList = (NodeList) xpath.evaluate("PaymentPeriod", node, XPathConstants.NODESET); if (nodeList != null && nodeList.getLength() > 0) { for (int i = 0; i < nodeList.getLength(); i++) { Node subNode = nodeList.item(i); this.paymentPeriod.add(new InstallmentDetailsType(subNode)); } } }
/** * Adds code for stylesheet parameters to wrapperDoc * * @param wrapperDoc DOM Document representing the UTF-X test definition file. * @param elem stylesheet-params element * @return void * @throws Exception */ private void addStylesheetParams(Document wrapperDoc, Element elem) throws Exception { // find refElement (for insertBefore) Element xslOutputElement = (Element) xpath.evaluate("xsl:output", wrapperDoc.getDocumentElement(), XPathConstants.NODE); Node refNode = xslOutputElement.getNextSibling(); NodeList params; try { params = (NodeList) xpath.evaluate("*[name() = 'utfx:with-param']", elem, XPathConstants.NODESET); } catch (XPathExpressionException e) { throw new AssertionError(e); } for (int i = 0; i < params.getLength(); i++) { Element withParamElement = (Element) params.item(i); // create xsl:param element Element xslParam = wrapperDoc.createElementNS(UTFXNamespaceContext.XSL_NS_URI, "xsl:param"); xslParam.setAttribute("name", withParamElement.getAttribute("name")); copySelectAttrOrChildNodes(withParamElement, wrapperDoc, xslParam); wrapperDoc.getDocumentElement().insertBefore(xslParam, refNode); } }