private void handleEvent(XMLEvent event, XMLEventReader reader, ParserTarget<T> target)
      throws Exception {
    XMLEvent nextEvent = null;
    if (event.isStartElement()) {
      xmlEventAdapter.setEvent(event);
      StartElement element = xmlEventAdapter.asStartElement();
      String name = element.getName().getLocalPart();
      elementStack.push(name);
      nextEvent = startElement(name, element, reader, target);
    } else if (event.isEndElement()) {
      EndElement element = event.asEndElement();
      String name = element.getName().getLocalPart();
      nextEvent = endElement(name, element, reader, target);

      Set<String> attributes = startElementAdapter.attributes;
      Iterator<Attribute> iterator = startElementAdapter.element.getAttributes();
      while (iterator.hasNext()) {
        Attribute attribute = iterator.next();
        if (!attributes.contains(attribute.getName().getLocalPart())) {
          notHandled(attribute.getName().getLocalPart(), Type.Attribute);
        }
      }

      elementStack.pop();
    }
    if (nextEvent != null && !cancel) {
      handleEvent(nextEvent, reader, target);
    }
  }
Ejemplo n.º 2
0
  /**
   * Parse a {@code NameIDType}
   *
   * @param xmlEventReader
   * @return
   * @throws ParsingException
   */
  public static NameIDType parseNameIDType(XMLEventReader xmlEventReader) throws ParsingException {
    StartElement nameIDElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    NameIDType nameID = new NameIDType();

    Attribute nameQualifier =
        nameIDElement.getAttributeByName(new QName(JBossSAMLConstants.NAME_QUALIFIER.get()));
    if (nameQualifier != null) {
      nameID.setNameQualifier(StaxParserUtil.getAttributeValue(nameQualifier));
    }

    Attribute format = nameIDElement.getAttributeByName(new QName(JBossSAMLConstants.FORMAT.get()));
    if (format != null) {
      nameID.setFormat(URI.create(StaxParserUtil.getAttributeValue(format)));
    }

    Attribute spProvidedID =
        nameIDElement.getAttributeByName(new QName(JBossSAMLConstants.SP_PROVIDED_ID.get()));
    if (spProvidedID != null) {
      nameID.setSPProvidedID(StaxParserUtil.getAttributeValue(spProvidedID));
    }

    Attribute spNameQualifier =
        nameIDElement.getAttributeByName(new QName(JBossSAMLConstants.SP_NAME_QUALIFIER.get()));
    if (spNameQualifier != null) {
      nameID.setSPNameQualifier(StaxParserUtil.getAttributeValue(spNameQualifier));
    }

    String nameIDValue = StaxParserUtil.getElementText(xmlEventReader);
    nameID.setValue(nameIDValue);

    return nameID;
  }
  private XMLEvent handleAnchorElement(StartElement se, XMLEventFactory xef) {

    Set<Attribute> attrs = new HashSet<Attribute>();
    Attribute href = AttributeByName.get(new QName("href"), se);

    if (href != null) {
      String value = "http";
      if (href.getValue().toLowerCase().contains(("mailto"))) {
        value = "mailto:[email protected]";
      } else if (href.getValue().trim().startsWith("#")) {
        value = href.getValue();
      } else if (href.getValue().toLowerCase().contains("smil")) {
        value = href.getValue();
      } else {
        value = "http://dummy.org";
      }
      attrs.add(xef.createAttribute(href.getName(), value));
    }

    Iterator<?> i = se.getAttributes();
    while (i.hasNext()) {
      Attribute a = (Attribute) i.next();
      if (!a.getName().getLocalPart().equals("href")) {
        attrs.add(a);
      }
    }
    return xef.createStartElement(se.getName(), attrs.iterator(), se.getNamespaces());
  }
Ejemplo n.º 4
0
  protected void parseTu(StartElement element) throws Exception {
    currentTu.clear();

    currentTu.changeid = getAttributeValue(element, "changeid");
    currentTu.changedate = parseISO8601date(getAttributeValue(element, "changedate"));
    currentTu.creationid = getAttributeValue(element, "creationid");
    currentTu.creationdate = parseISO8601date(getAttributeValue(element, "creationdate"));

    while (true) {
      XMLEvent e = xml.nextEvent();
      switch (e.getEventType()) {
        case XMLEvent.START_ELEMENT:
          StartElement eStart = (StartElement) e;
          if ("tuv".equals(eStart.getName().getLocalPart())) {
            parseTuv(eStart);
          } else if ("prop".equals(eStart.getName().getLocalPart())) {
            parseProp(eStart);
          } else if ("note".equals(eStart.getName().getLocalPart())) {
            parseNote(eStart);
          }
          break;
        case XMLEvent.END_ELEMENT:
          EndElement eEnd = (EndElement) e;
          if ("tu".equals(eEnd.getName().getLocalPart())) {
            return;
          }
          break;
      }
    }
  }
Ejemplo n.º 5
0
  private Definition parseEvent(XMLEvent event, Definition def) {
    StartElement se = event.asStartElement();
    String elementName = se.getName().getLocalPart();
    if (elementName.equals("catalog")) {
      return null;
    }

    Iterator<Attribute> attributes = se.getAttributes();

    if (def == null) {
      Attribute id = attributes.next();
      if (id.getName().toString() != ID) {
        throw new RuntimeException(
            "At line "
                + event.getLocation().getLineNumber()
                + ", problem with definition '"
                + elementName
                + "'. The first attribute of a definition must be called '"
                + ID
                + "'.");
      }
      def = new Definition(elementName, id.getValue());
      // LogUtil.logger.info("def cree "+def.type+" - "+def.id);
    } else {
      DefElement de = new DefElement(elementName);
      while (attributes.hasNext()) {
        Attribute a = attributes.next();
        de.addVal(a.getName().toString(), a.getValue());
      }
      def.getElements().add(de);
      // LogUtil.logger.info("    element ajouté : "+de.name+" - "+de.getVal());
    }
    return def;
  }
Ejemplo n.º 6
0
  /**
   * Parse the {@link SAML11AttributeQueryType}
   *
   * @param xmlEventReader
   * @return
   * @throws ParsingException
   */
  public static SAML11AuthenticationQueryType parseSAML11AuthenticationQuery(
      XMLEventReader xmlEventReader) throws ParsingException {
    SAML11AuthenticationQueryType query = new SAML11AuthenticationQueryType();
    StartElement startElement;
    // There may be additional things under subject confirmation
    while (xmlEventReader.hasNext()) {
      XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent instanceof EndElement) {
        EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader);
        if (StaxParserUtil.matches(endElement, SAML11Constants.AUTHENTICATION_QUERY)) break;
        else throw logger.parserUnknownEndElement(StaxParserUtil.getEndElementName(endElement));
      }

      if (xmlEvent instanceof StartElement) {
        startElement = (StartElement) xmlEvent;

        String startTag = StaxParserUtil.getStartElementName(startElement);

        if (startTag.equals(JBossSAMLConstants.SUBJECT.get())) {
          SAML11SubjectParser parser = new SAML11SubjectParser();
          query.setSubject((SAML11SubjectType) parser.parse(xmlEventReader));
        } else throw logger.parserUnknownTag(startTag, startElement.getLocation());
      }
    }
    return query;
  }
Ejemplo n.º 7
0
  private static void readStartElement(XMLEventReader eventReader) throws XMLStreamException {
    XMLEvent event = eventReader.nextEvent();
    StartElement startElement = event.asStartElement();

    QName elementName = startElement.getName();
    System.out.println("Tag: " + elementName.getLocalPart());
  }
Ejemplo n.º 8
0
  /** @see {@link ParserNamespaceSupport#parse(XMLEventReader)} */
  public Object parse(XMLEventReader xmlEventReader) throws ParsingException {
    // Get the startelement
    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    StaxParserUtil.validate(startElement, RESPONSE);

    ResponseType response = (ResponseType) parseBaseAttributes(startElement);

    while (xmlEventReader.hasNext()) {
      // Let us peek at the next start element
      startElement = StaxParserUtil.peekNextStartElement(xmlEventReader);
      if (startElement == null) break;
      String elementName = StaxParserUtil.getStartElementName(startElement);

      if (JBossSAMLConstants.ISSUER.get().equals(elementName)) {
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        NameIDType issuer = new NameIDType();
        issuer.setValue(StaxParserUtil.getElementText(xmlEventReader));
        response.setIssuer(issuer);
      } else if (JBossSAMLConstants.SIGNATURE.get().equals(elementName)) {
        Element sig = StaxParserUtil.getDOMElement(xmlEventReader);
        response.setSignature(sig);
      } else if (JBossSAMLConstants.ASSERTION.get().equals(elementName)) {
        SAMLAssertionParser assertionParser = new SAMLAssertionParser();
        response.addAssertion(
            new RTChoiceType((AssertionType) assertionParser.parse(xmlEventReader)));
      } else if (JBossSAMLConstants.STATUS.get().equals(elementName)) {
        response.setStatus(parseStatus(xmlEventReader));
      } else if (JBossSAMLConstants.ENCRYPTED_ASSERTION.get().equals(elementName)) {
        Element encryptedAssertion = StaxParserUtil.getDOMElement(xmlEventReader);
        response.addAssertion(new RTChoiceType(new EncryptedAssertionType(encryptedAssertion)));
      } else throw logger.parserUnknownTag(elementName, startElement.getLocation());
    }

    return response;
  }
Ejemplo n.º 9
0
  // first analyzing of XML input, creating hash map for holding backfire redirects
  public dataSending firstAnalyzing(String fileName) {
    Map<String, ReverseRedirects> map = new HashMap<String, ReverseRedirects>();
    int pages = 0;

    String filePath = fileName;
    XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();

    try {
      XMLEventReader xmlEventReader =
          xmlInputFactory.createXMLEventReader(new FileInputStream(filePath));
      while (xmlEventReader.hasNext()) {
        XMLEvent xmlEvent = xmlEventReader.nextEvent();

        if (xmlEvent.isStartElement()) {
          StartElement startElement = xmlEvent.asStartElement();
          if (startElement.getName().getLocalPart().toLowerCase().equals("page")) {
            pages++;
          } else if (startElement.getName().getLocalPart().toLowerCase().equals("title")) {
            xmlEvent = xmlEventReader.nextEvent();
            map.put(xmlEvent.asCharacters().getData(), new ReverseRedirects(true));
          }
        }
      }

    } catch (Exception e) {
      System.out.println("error: " + e);
      e.printStackTrace();
      return null;
    }

    dataSending Result = new dataSending();
    Result.map = map;
    Result.pages = pages;
    return Result;
  }
Ejemplo n.º 10
0
  /**
   * Parse an {@code AttributeStatementType}
   *
   * @param xmlEventReader
   * @return
   * @throws ParsingException
   */
  public static AttributeStatementType parseAttributeStatement(XMLEventReader xmlEventReader)
      throws ParsingException {
    AttributeStatementType attributeStatementType = new AttributeStatementType();

    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    String ATTRIBSTATEMT = JBossSAMLConstants.ATTRIBUTE_STATEMENT.get();
    StaxParserUtil.validate(startElement, ATTRIBSTATEMT);

    while (xmlEventReader.hasNext()) {
      XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent instanceof EndElement) {
        EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader);
        StaxParserUtil.validate(endElement, JBossSAMLConstants.ATTRIBUTE_STATEMENT.get());
        break;
      }
      // Get the next start element
      startElement = StaxParserUtil.peekNextStartElement(xmlEventReader);
      String tag = startElement.getName().getLocalPart();
      if (JBossSAMLConstants.ATTRIBUTE.get().equals(tag)) {
        AttributeType attribute = parseAttribute(xmlEventReader);
        attributeStatementType.addAttribute(new ASTChoiceType(attribute));
      } else throw logger.parserUnknownTag(tag, startElement.getLocation());
    }
    return attributeStatementType;
  }
Ejemplo n.º 11
0
  private static RSAKeyValueType parseRSAKeyValue(XMLEventReader xmlEventReader)
      throws ParsingException {
    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.RSA_KEYVALUE);

    XMLEvent xmlEvent = null;
    String tag = null;

    RSAKeyValueType rsaKeyValue = new RSAKeyValueType();

    while (xmlEventReader.hasNext()) {
      xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent instanceof EndElement) {
        tag = StaxParserUtil.getEndElementName((EndElement) xmlEvent);
        if (tag.equals(WSTrustConstants.XMLDSig.RSA_KEYVALUE)) {
          xmlEvent = StaxParserUtil.getNextEndElement(xmlEventReader);
          break;
        } else throw logger.parserUnknownEndElement(tag);
      }

      startElement = (StartElement) xmlEvent;
      tag = StaxParserUtil.getStartElementName(startElement);
      if (tag.equals(WSTrustConstants.XMLDSig.MODULUS)) {
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        String text = StaxParserUtil.getElementText(xmlEventReader);
        rsaKeyValue.setModulus(text.getBytes());
      } else if (tag.equals(WSTrustConstants.XMLDSig.EXPONENT)) {
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        String text = StaxParserUtil.getElementText(xmlEventReader);
        rsaKeyValue.setExponent(text.getBytes());
      } else throw logger.parserUnknownTag(tag, startElement.getLocation());
    }
    return rsaKeyValue;
  }
 /**
  * @param element the XML element to parse
  * @param parent the parent tag
  * @param stream the stream to read more elements from @return the parsed resource
  * @throws SPFormatException on SP format problems
  */
 @Override
 public HarvestableFixture read(
     final StartElement element, final QName parent, final Iterable<XMLEvent> stream)
     throws SPFormatException {
   requireTag(
       element, parent, "cache", "grove", "orchard", "field", "meadow", "mine", "mineral", "shrub",
       "stone");
   final int idNum = getOrGenerateID(element);
   final HarvestableFixture retval;
   switch (element.getName().getLocalPart().toLowerCase()) {
     case "cache":
       retval =
           new CacheFixture(
               getParameter(element, KIND_PAR), getParameter(element, "contents"), idNum);
       break;
     case "field":
       retval = createMeadow(element, true, idNum);
       break;
     case "grove":
       retval = createGrove(element, false, idNum);
       break;
     case "meadow":
       retval = createMeadow(element, false, idNum);
       break;
     case "mine":
       retval =
           new Mine(
               getParamWithDeprecatedForm(element, KIND_PAR, "product"),
               TownStatus.parseTownStatus(getParameter(element, STATUS_PAR)),
               idNum);
       break;
     case "mineral":
       retval =
           new MineralVein(
               getParamWithDeprecatedForm(element, KIND_PAR, "mineral"),
               parseBoolean(getParameter(element, "exposed")),
               getDC(element),
               idNum);
       break;
     case "orchard":
       retval = createGrove(element, true, idNum);
       break;
     case "shrub":
       retval = new Shrub(getParamWithDeprecatedForm(element, KIND_PAR, "shrub"), idNum);
       break;
     case "stone":
       retval =
           new StoneDeposit(
               StoneKind.parseStoneKind(getParamWithDeprecatedForm(element, KIND_PAR, "stone")),
               getDC(element),
               idNum);
       break;
     default:
       throw new IllegalArgumentException("Unhandled harvestable tag");
   }
   spinUntilEnd(element.getName(), stream);
   retval.setImage(getParameter(element, "image", ""));
   return retval;
 }
Ejemplo n.º 13
0
  private void parseTerm(StartElement root, XMLEventReader r)
      throws IOException, XMLStreamException {

    Attribute aboutAtt = root.getAttributeByName(rdfAbout);
    if (aboutAtt == null) {
      throw new IOException("no rdf:about");
    }
    TermImpl term = uri2term.get(aboutAtt.getValue());

    if (term == null) {
      term = new TermImpl();
      term.accession = aboutAtt.getValue();
      if (term.accession.startsWith(PREFIX)) {
        term.accession = term.accession.substring(PREFIX.length());
      }
      term.name = term.accession;
      uri2term.put(aboutAtt.getValue(), term);
    }
    while (r.hasNext()) {
      XMLEvent evt = r.nextEvent();
      if (evt.isStartElement()) {
        StartElement E = evt.asStartElement();
        QName qN = E.getName();
        if (NS.equals(qN.getNamespaceURI())) {
          if (qN.getLocalPart().equals("accession")) {
            term.accession = r.getElementText();
          } else if (qN.getLocalPart().equals("name")) {
            term.name = r.getElementText();
          } else if (qN.getLocalPart().equals("is_a")) {
            Attribute rsrc = E.getAttributeByName(rdfRsrc);
            if (rsrc == null)
              throw new IOException("att missing " + rdfRsrc + " for " + aboutAtt.getValue());

            String parentUri = rsrc.getValue();
            term.parents.add(parentUri);
            TermImpl parentTerm = this.uri2term.get(parentUri);
            if (parentTerm == null) {
              parentTerm = new TermImpl();
              parentTerm.accession = parentUri;
              if (parentTerm.accession.startsWith(PREFIX)) {
                parentTerm.accession = parentTerm.accession.substring(PREFIX.length());
              }
              parentTerm.name = parentTerm.accession;
              uri2term.put(parentUri, parentTerm);
            }
            parentTerm.children.add(aboutAtt.getValue());
          }
        }

      } else if (evt.isEndElement()) {
        EndElement E = evt.asEndElement();
        QName qN = E.getName();
        if (qN.getLocalPart().equals("term") && NS.equals(qN.getNamespaceURI())) {
          break;
        }
      }
    }
  }
Ejemplo n.º 14
0
  public static KeyInfoType parseKeyInfo(XMLEventReader xmlEventReader) throws ParsingException {
    KeyInfoType keyInfo = new KeyInfoType();
    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.KEYINFO);

    XMLEvent xmlEvent = null;
    String tag = null;

    while (xmlEventReader.hasNext()) {
      xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent instanceof EndElement) {
        tag = StaxParserUtil.getEndElementName((EndElement) xmlEvent);
        if (tag.equals(WSTrustConstants.XMLDSig.KEYINFO)) {
          xmlEvent = StaxParserUtil.getNextEndElement(xmlEventReader);
          break;
        } else throw logger.parserUnknownEndElement(tag);
      }
      startElement = (StartElement) xmlEvent;
      tag = StaxParserUtil.getStartElementName(startElement);
      if (tag.equals(WSTrustConstants.XMLEnc.ENCRYPTED_KEY)) {
        keyInfo.addContent(StaxParserUtil.getDOMElement(xmlEventReader));
      } else if (tag.equals(WSTrustConstants.XMLDSig.X509DATA)) {
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        X509DataType x509 = new X509DataType();

        // Let us go for the X509 certificate
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        StaxParserUtil.validate(startElement, WSTrustConstants.XMLDSig.X509CERT);

        X509CertificateType cert = new X509CertificateType();
        String certValue = StaxParserUtil.getElementText(xmlEventReader);
        cert.setEncodedCertificate(certValue.getBytes());
        x509.add(cert);

        EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader);
        StaxParserUtil.validate(endElement, WSTrustConstants.XMLDSig.X509DATA);
        keyInfo.addContent(x509);
      } else if (tag.equals(WSTrustConstants.XMLDSig.KEYVALUE)) {
        startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
        KeyValueType keyValue = null;

        startElement = StaxParserUtil.peekNextStartElement(xmlEventReader);
        tag = StaxParserUtil.getStartElementName(startElement);
        if (tag.equals(WSTrustConstants.XMLDSig.RSA_KEYVALUE)) {
          keyValue = parseRSAKeyValue(xmlEventReader);
        } else if (tag.equals(WSTrustConstants.XMLDSig.DSA_KEYVALUE)) {
          keyValue = parseDSAKeyValue(xmlEventReader);
        } else throw logger.parserUnknownTag(tag, startElement.getLocation());

        EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader);
        StaxParserUtil.validate(endElement, WSTrustConstants.XMLDSig.KEYVALUE);

        keyInfo.addContent(keyValue);
      }
    }
    return keyInfo;
  }
  protected Map<String, Preference> toPreferencesMap(String xml) {
    if (Validator.isNull(xml)) {
      return Collections.emptyMap();
    }

    Map<String, Preference> preferencesMap = _preferencesMapPortalCache.get(xml);

    if (preferencesMap != null) {
      return preferencesMap;
    }

    XMLEventReader xmlEventReader = null;

    try {
      XMLInputFactory xmlInputFactory = StAXReaderUtil.getXMLInputFactory();

      xmlEventReader = xmlInputFactory.createXMLEventReader(new UnsyncStringReader(xml));

      while (xmlEventReader.hasNext()) {
        XMLEvent xmlEvent = xmlEventReader.nextEvent();

        if (xmlEvent.isStartElement()) {
          StartElement startElement = xmlEvent.asStartElement();

          String elementName = startElement.getName().getLocalPart();

          if (elementName.equals("preference")) {
            Preference preference = readPreference(xmlEventReader);

            if (preferencesMap == null) {
              preferencesMap = new HashMap<String, Preference>();
            }

            preferencesMap.put(preference.getName(), preference);
          }
        }
      }
    } catch (XMLStreamException xse) {
      throw new SystemException(xse);
    } finally {
      if (xmlEventReader != null) {
        try {
          xmlEventReader.close();
        } catch (XMLStreamException xse) {
        }
      }
    }

    if (preferencesMap == null) {
      preferencesMap = Collections.emptyMap();
    }

    _preferencesMapPortalCache.put(xml, preferencesMap);

    return preferencesMap;
  }
Ejemplo n.º 16
0
  /** Read TMX file. */
  public void readTMX(
      File file,
      final Language sourceLanguage,
      final Language targetLanguage,
      boolean isSegmentingEnabled,
      final boolean forceOmegaTMX,
      final boolean extTmxLevel2,
      final boolean useSlash,
      final LoadCallback callback)
      throws Exception {
    this.extTmxLevel2 = extTmxLevel2;
    this.useSlash = useSlash;
    this.isSegmentingEnabled = isSegmentingEnabled;

    // log the parsing attempt
    Log.logRB("TMXR_INFO_READING_FILE", new Object[] {file.getAbsolutePath()});

    boolean allFound = true;

    InputStream in;
    if (file.getName().endsWith(".gz")) {
      in = new BufferedInputStream(new GZIPInputStream(new FileInputStream(file)));
    } else {
      in = new BufferedInputStream(new FileInputStream(file));
    }
    xml = factory.createXMLEventReader(in);
    try {
      while (xml.hasNext()) {
        XMLEvent e = xml.nextEvent();
        switch (e.getEventType()) {
          case XMLEvent.START_ELEMENT:
            StartElement eStart = (StartElement) e;
            if ("tu".equals(eStart.getName().getLocalPart())) {
              parseTu(eStart);
              ParsedTuv origTuv = getTuvByLang(sourceLanguage);
              ParsedTuv targetTuv = getTuvByLang(targetLanguage);
              allFound &= callback.onEntry(currentTu, origTuv, targetTuv, isParagraphSegtype);
            } else if ("header".equals(eStart.getName().getLocalPart())) {
              parseHeader(eStart, sourceLanguage);
            }
            break;
        }
      }
    } finally {
      xml.close();
      in.close();
    }

    if (!allFound) {
      Log.logWarningRB("TMXR_WARNING_SOURCE_NOT_FOUND");
      warningsCount++;
    }
    Log.logRB("TMXR_INFO_READING_COMPLETE");
    Log.log("");
  }
  /**
   * Parse the attributes that are common to all SAML Request Types
   *
   * @param startElement
   * @param request
   * @throws ParsingException
   */
  protected void parseBaseAttributes(StartElement startElement, RequestAbstractType request)
      throws ParsingException {
    Attribute destinationAttr =
        startElement.getAttributeByName(new QName(JBossSAMLConstants.DESTINATION.get()));
    if (destinationAttr != null)
      request.setDestination(URI.create(StaxParserUtil.getAttributeValue(destinationAttr)));

    Attribute consent =
        startElement.getAttributeByName(new QName(JBossSAMLConstants.CONSENT.get()));
    if (consent != null) request.setConsent(StaxParserUtil.getAttributeValue(consent));
  }
Ejemplo n.º 18
0
  private boolean isEqual(StartElement e1, StartElement e2) {
    if (e1 == e2) return true;

    if (!isEqual(e1.getName(), e2.getName())) return false;

    if (!compareAttributes(e1.getAttributes(), e2.getAttributes())) return false;

    // Do not isEqual namespace declarations for now, it is not relevent
    // namespaces are propogated into the attribute and element QName
    return true;
  }
Ejemplo n.º 19
0
  /**
   * Write a new element with the specified name and text
   *
   * @return the end element
   */
  private XMLEvent getAddedEvent(
      XMLEvent event, XMLEventWriter writer, String elementName, String text)
      throws XMLStreamException {
    StartElement oldStartEvent = event.asStartElement();
    StartElement newStartEvent =
        xmlEventFactory.createStartElement(
            new QName(elementName), null, oldStartEvent.getNamespaces());

    writer.add(newStartEvent);
    writer.add(xmlEventFactory.createCharacters(text));
    return xmlEventFactory.createEndElement(newStartEvent.getName(), newStartEvent.getNamespaces());
  }
Ejemplo n.º 20
0
 private StartElement withNamespace(StartElement startElement) {
   // otherwise, wrap the start element event to provide a default namespace mapping
   final List<Namespace> namespaces = new ArrayList<Namespace>();
   namespaces.add(xmlEventFactory.createNamespace("", namespaceUri));
   Iterator<?> originalNamespaces = startElement.getNamespaces();
   while (originalNamespaces.hasNext()) {
     namespaces.add((Namespace) originalNamespaces.next());
   }
   return xmlEventFactory.createStartElement(
       new QName(namespaceUri, startElement.getName().getLocalPart()),
       startElement.getAttributes(),
       namespaces.iterator());
 }
Ejemplo n.º 21
0
  /**
   * Create a new start element based on the original but that does not include the specified
   * attribute.
   */
  private StartElement getSkippedElementStartEvent(XMLEvent event) {
    Set attributes = new HashSet();

    for (java.util.Iterator i = event.asStartElement().getAttributes(); i.hasNext(); ) {
      Attribute a = (Attribute) i.next();
      if (!DISABLE_SUB_ELEMENTS.contains(a.getName().getLocalPart())) {
        attributes.add(a);
      }
    }

    StartElement oldStartEvent = event.asStartElement();
    return xmlEventFactory.createStartElement(
        oldStartEvent.getName(), attributes.iterator(), oldStartEvent.getNamespaces());
  }
Ejemplo n.º 22
0
  public static void main(String[] args) {
    for (String arg : args) {
      try {
        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        xmlInputFactory.setXMLReporter(
            new XMLReporter() {
              @Override
              public void report(
                  String message, String errorType, Object relatedInformation, Location location)
                  throws XMLStreamException {
                System.err.println("Problem in " + location);
                System.err.println(
                    "at line "
                        + location.getLineNumber()
                        + ", column "
                        + location.getColumnNumber());
                System.err.println(message);
                System.err.println("errorType = " + errorType);
                System.err.println("relatedInformation = " + relatedInformation);
              }
            });
        XMLEventReader eventReader = xmlInputFactory.createXMLEventReader(new FileReader(arg));
        while (eventReader.hasNext()) {
          XMLEvent event = (XMLEvent) eventReader.next();
          switch (event.getEventType()) {
            case XMLEvent.START_DOCUMENT:
              {
                StartElement startElement = event.asStartElement();
                if (startElement.getName().getLocalPart().equals("target")) {
                  Attribute attribute = startElement.getAttributeByName(new QName("name"));
                  System.out.println(attribute.getValue());
                }
                break;
              }
              //  case XMLEvent.COMMENT:{ event.}
          }
        }

      } catch (XMLStreamException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (FileNotFoundException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      }
    }
  }
Ejemplo n.º 23
0
  /**
   * Parse an {@code AttributeType}
   *
   * @param xmlEventReader
   * @return
   * @throws ParsingException
   */
  public static AttributeType parseAttribute(XMLEventReader xmlEventReader)
      throws ParsingException {
    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    StaxParserUtil.validate(startElement, JBossSAMLConstants.ATTRIBUTE.get());
    AttributeType attributeType = null;

    Attribute name = startElement.getAttributeByName(new QName(JBossSAMLConstants.NAME.get()));
    if (name == null) throw logger.parserRequiredAttribute("Name");
    attributeType = new AttributeType(StaxParserUtil.getAttributeValue(name));

    parseAttributeType(
        xmlEventReader, startElement, JBossSAMLConstants.ATTRIBUTE.get(), attributeType);

    return attributeType;
  }
Ejemplo n.º 24
0
  /**
   * Parses the {@code ServiceProviders} section of the STS configuration file.
   *
   * @param xmlEventReader the reader used to parse the XML configuration file.
   * @return a {@code ServiceProvidersType} instance that contains the parsed data.
   * @throws ParsingException if an error occurs while parsing the XML file.
   */
  private ServiceProvidersType parseServiceProviders(XMLEventReader xmlEventReader)
      throws ParsingException {
    StartElement startElement = StaxParserUtil.getNextStartElement(xmlEventReader);
    StaxParserUtil.validate(startElement, SERVICE_PROVIDERS_ELEMENT);

    ServiceProvidersType serviceProviders = new ServiceProvidersType();

    // parse all token providers one by one.
    while (xmlEventReader.hasNext()) {
      XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent == null) break;
      if (xmlEvent instanceof EndElement) {
        EndElement endElement = (EndElement) StaxParserUtil.getNextEvent(xmlEventReader);
        String endElementName = StaxParserUtil.getEndElementName(endElement);
        if (endElementName.equals(SERVICE_PROVIDERS_ELEMENT)) break;
        else throw logger.parserUnknownEndElement(endElementName);
      }

      StartElement subEvent = StaxParserUtil.peekNextStartElement(xmlEventReader);
      if (subEvent == null) break;
      String elementName = StaxParserUtil.getStartElementName(subEvent);

      if (SERVICE_PROVIDER_ELEMENT.equalsIgnoreCase(elementName)) {
        subEvent = StaxParserUtil.getNextStartElement(xmlEventReader);
        StaxParserUtil.validate(subEvent, SERVICE_PROVIDER_ELEMENT);
        ServiceProviderType serviceProvider = new ServiceProviderType();

        // parse the provider attributes (endpoint, token type and truststore alias).
        QName attributeQName = new QName("", TOKEN_TYPE_ATTRIB);
        Attribute attribute = subEvent.getAttributeByName(attributeQName);
        if (attribute != null)
          serviceProvider.setTokenType(StaxParserUtil.getAttributeValue(attribute));
        attributeQName = new QName("", ENDPOINT_ATTRIB);
        attribute = subEvent.getAttributeByName(attributeQName);
        if (attribute != null)
          serviceProvider.setEndpoint(StaxParserUtil.getAttributeValue(attribute));
        attributeQName = new QName("", TRUSTSTORE_ALIAS_ATTRIB);
        attribute = subEvent.getAttributeByName(attributeQName);
        if (attribute != null)
          serviceProvider.setTruststoreAlias(StaxParserUtil.getAttributeValue(attribute));

        EndElement endElement = StaxParserUtil.getNextEndElement(xmlEventReader);
        StaxParserUtil.validate(endElement, SERVICE_PROVIDER_ELEMENT);
        serviceProviders.add(serviceProvider);
      } else throw logger.parserUnknownTag(elementName, subEvent.getLocation());
    }
    return serviceProviders;
  }
Ejemplo n.º 25
0
  /**
   * Parse an {@code AttributeType}
   *
   * @param xmlEventReader
   * @throws ParsingException
   */
  public static void parseAttributeType(
      XMLEventReader xmlEventReader,
      StartElement startElement,
      String rootTag,
      AttributeType attributeType)
      throws ParsingException {
    // Look for X500 Encoding
    QName x500EncodingName =
        new QName(
            JBossSAMLURIConstants.X500_NSURI.get(),
            JBossSAMLConstants.ENCODING.get(),
            JBossSAMLURIConstants.X500_PREFIX.get());
    Attribute x500EncodingAttr = startElement.getAttributeByName(x500EncodingName);

    if (x500EncodingAttr != null) {
      attributeType
          .getOtherAttributes()
          .put(x500EncodingAttr.getName(), StaxParserUtil.getAttributeValue(x500EncodingAttr));
    }

    Attribute friendlyName =
        startElement.getAttributeByName(new QName(JBossSAMLConstants.FRIENDLY_NAME.get()));
    if (friendlyName != null)
      attributeType.setFriendlyName(StaxParserUtil.getAttributeValue(friendlyName));

    Attribute nameFormat =
        startElement.getAttributeByName(new QName(JBossSAMLConstants.NAME_FORMAT.get()));
    if (nameFormat != null)
      attributeType.setNameFormat(StaxParserUtil.getAttributeValue(nameFormat));

    while (xmlEventReader.hasNext()) {
      XMLEvent xmlEvent = StaxParserUtil.peek(xmlEventReader);
      if (xmlEvent instanceof EndElement) {
        EndElement end = StaxParserUtil.getNextEndElement(xmlEventReader);
        if (StaxParserUtil.matches(end, rootTag)) break;
      }
      startElement = StaxParserUtil.peekNextStartElement(xmlEventReader);
      if (startElement == null) break;
      String tag = StaxParserUtil.getStartElementName(startElement);

      if (JBossSAMLConstants.ATTRIBUTE.get().equals(tag)) break;

      if (JBossSAMLConstants.ATTRIBUTE_VALUE.get().equals(tag)) {
        Object attributeValue = parseAttributeValue(xmlEventReader);
        attributeType.addAttributeValue(attributeValue);
      } else throw logger.parserUnknownTag(tag, startElement.getLocation());
    }
  }
Ejemplo n.º 26
0
  private void skipElement(
      final StartElement start,
      final XMLEventReader reader,
      final XMLEventWriter writer,
      final boolean excludeStart)
      throws Exception {

    if (!excludeStart) {
      writeEvent(start, writer);
    }

    int depth = 1;
    boolean found = false;

    while (reader.hasNext() && !found) {
      final XMLEvent event = reader.nextEvent();

      writeEvent(event, writer);

      if (event.getEventType() == XMLStreamConstants.START_ELEMENT) {
        depth++;
      } else if (event.getEventType() == XMLStreamConstants.END_ELEMENT) {
        depth--;
        found = depth == 0 && start.getName().equals(event.asEndElement().getName());
      }
    }
  }
  /**
   * Pars the STAX attributes into the Bails attribute map.
   *
   * @param element a STAX @link javax.xml.stream.events.StartElement that may or may not contain
   *     attributes.
   * @return a map of string object key value pairs that represent the Bails attributes.
   */
  private Map<String, Object> parsAttributes(StartElement element) {
    Map<String, Object> attributes =
        new HashMap<String, Object>(); // Initialise the attributes map.

    // Get the attributes iterator from the STAX start element object.
    Iterator<Attribute> attributeIterator = element.getAttributes();
    Attribute attribute = null; // Place holder for each attribute.

    bailsTag = false; // Prepare the element to be checked for a bails id.

    while (attributeIterator.hasNext()) { // Iterate over the attributes...
      attribute = attributeIterator.next(); // ...recording each one, ...

      QName qName = attribute.getName(); // ...taking the qName then...

      // ...recording the name as a string.
      // A check is done on the attribute prefix. If it exists it is added to the attributes name
      // separated by a
      // colon (:).
      String nameString =
          qName.getPrefix().equals("")
              ? qName.getLocalPart()
              : qName.getPrefix() + ":" + qName.getLocalPart();

      if (!bailsTag) { // If this isn't yet a bails tag keep checking to see if it is.
        bailsTag = TagElement.BAILS_ID_NAME.equals(nameString);
      }

      attributes.put(nameString, attribute.getValue());
    }

    return attributes;
  }
Ejemplo n.º 28
0
  /**
   * Read the numeric format string out of the styles table for this cell. Stores the result in the
   * Cell.
   *
   * @param startElement
   * @param cell
   */
  void setFormatString(StartElement startElement, StreamingCell cell) {
    Attribute cellStyle = startElement.getAttributeByName(new QName("s"));
    String cellStyleString = (cellStyle != null) ? cellStyle.getValue() : null;
    XSSFCellStyle style = null;

    if (cellStyleString != null) {
      style = stylesTable.getStyleAt(Integer.parseInt(cellStyleString));
    } else if (stylesTable.getNumCellStyles() > 0) {
      style = stylesTable.getStyleAt(0);
    }

    if (style != null) {
      cell.setNumericFormatIndex(style.getDataFormat());
      String formatString = style.getDataFormatString();

      if (formatString != null) {
        cell.setNumericFormat(formatString);
      } else {
        cell.setNumericFormat(BuiltinFormats.getBuiltinFormat(cell.getNumericFormatIndex()));
      }
    } else {
      cell.setNumericFormatIndex(null);
      cell.setNumericFormat(null);
    }
  }
  public static Set<Integer> extract(String fileName, String word) throws IOException {
    Set<Integer> ids = new HashSet<Integer>();
    BufferedReader reader = new BufferedReader(new FileReader(fileName), 4 * 1024 * 1024);
    String line = null;
    int lineCount = 0;
    System.out.println("Reading file...");
    while ((line = reader.readLine()) != null) {
      lineCount++;
      if (lineCount % 2000 == 0) System.out.print(".");
      if (lineCount % 100000 == 0) {
        System.out.println(lineCount);
      }
      try {
        if (!line.trim().startsWith("<row")) continue;

        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        XMLEventReader xmlEventReader =
            xmlInputFactory.createXMLEventReader(new StringReader(line));
        while (xmlEventReader.hasNext()) {
          XMLEvent xmlEvent = xmlEventReader.nextEvent();
          if (xmlEvent.isStartElement()) {
            StartElement startElement = xmlEvent.asStartElement();
            if (startElement.getName().getLocalPart().equalsIgnoreCase("row")) {
              int id = XMLUtil.getIntElement(startElement, "Id");

              String title = XMLUtil.getStringElement(startElement, "Title");
              if (title == null) {
                title = "";
                continue;
              }
              String tags = XMLUtil.getStringElement(startElement, "Tags");
              if ((tags == null) || (tags.trim().length() == 0)) {
                return null;
              }
              if (!SOUtil.hasJavaTag(tags)) continue;
              if (title.contains(word)) {
                ids.add(id);
              }
            }
          }
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    return ids;
  }
  /** @deprecated */
  public static List<AndroidString> getAndroidStringsList(InputStream xml) {
    List<AndroidString> result = new ArrayList<AndroidString>();

    try {
      XMLInputFactory inputFactory = XMLInputFactory.newInstance();
      XMLEventReader eventReader = inputFactory.createXMLEventReader(xml);

      AndroidString androidString = null;

      while (eventReader.hasNext()) {
        XMLEvent event = eventReader.nextEvent();

        if (event.isStartElement()) {
          StartElement startElement = event.asStartElement();
          if (startElement.getName().getLocalPart().equals("string")) {
            androidString = new AndroidString();

            Iterator<Attribute> attributes = startElement.getAttributes();

            while (attributes.hasNext()) {
              Attribute attribute = attributes.next();
              if (attribute.getName().toString().equals("name")) {
                androidString.setKey(attribute.getValue());
              }
            }

            event = eventReader.nextEvent();
            String value = event.asCharacters().getData().trim();

            // todo: if the value starts with xml tags(<u>), the value will be empty
            androidString.setValue(value);
            continue;
          }
        }

        if (event.isEndElement()) {
          EndElement endElement = event.asEndElement();
          if (endElement.getName().getLocalPart().equals("string")) {
            result.add(androidString);
          }
        }
      }
    } catch (XMLStreamException e) {
      e.printStackTrace();
    }
    return result;
  }