Esempio n. 1
0
 /**
  * Warning message. Calls {@link ErrorHandler#warning(SAXParseException) ErrorHandler.warning}.
  *
  * @param message {@inheritDoc}
  */
 public void warning(String message) {
   try {
     mErrorHandler.warning(new SAXParseException(message, mLocator));
   } catch (SAXException se) {
     se.printStackTrace();
   }
 }
Esempio n. 2
0
 public void warning(TransformerException exception) throws TransformerException {
   SAXParseException spe = transform(exception);
   try {
     eh.warning(spe);
   } catch (SAXException e) {
     throw new TransformerException(new UserException(e));
   }
 }
  /**
   * Reports a warning. Warnings are non-fatal and can be safely ignored by most applications.
   *
   * @param domain The domain of the warning. The domain can be any string but is suggested to be a
   *     valid URI. The domain can be used to conveniently specify a web site location of the
   *     relevent specification or document pertaining to this warning.
   * @param key The warning key. This key can be any string and is implementation dependent.
   * @param exception Exception.
   * @throws XNIException Thrown to signal that the parser should stop parsing the document.
   */
  public void warning(String domain, String key, XMLParseException exception) throws XNIException {

    if (fErrorHandler != null) {
      SAXParseException saxException = createSAXParseException(exception);

      try {
        fErrorHandler.warning(saxException);
      } catch (SAXParseException e) {
        throw createXMLParseException(e);
      } catch (SAXException e) {
        throw createXNIException(e);
      }
    }
  } // warning(String,String,XMLParseException)
  /** @see org.xml.sax.ErrorHandler#warning(SAXParseException) */
  public void warning(SAXParseException exc) throws SAXException {
    super.warning(exc);

    if (m_saxHandler instanceof ErrorHandler) ((ErrorHandler) m_saxHandler).warning(exc);
  }
Esempio n. 5
0
 /** @see org.xml.sax.helpers.DefaultHandler#warning(org.xml.sax.SAXParseException) */
 public void warning(SAXParseException e) throws SAXException {
   if (delegate != null) delegate.warning(e);
   else super.warning(e);
 }
 public void warning(SAXParseException exception) throws SAXException {
   if (null == errorHandler) {
     throw exception;
   }
   errorHandler.warning(marshalSAXParseException(exception));
 }
  /** @see org.xml.sax.EntityResolver#resolveEntity(java.lang.String, java.lang.String) */
  @Override
  public InputSource resolveEntity(String publicId, String systemId)
      throws SAXException, IOException {
    if (requestsLeft > -1) {
      if (requestsLeft == 0) {
        throw new IOException("Number of permitted HTTP requests exceeded.");
      } else {
        requestsLeft--;
      }
    }
    HttpGet m = null;
    try {
      URL url;
      try {
        url = URL.parse(systemId);
      } catch (GalimatiasParseException e) {
        IOException ioe = (IOException) new IOException(e.getMessage()).initCause(e);
        SAXParseException spe =
            new SAXParseException(e.getMessage(), publicId, systemId, -1, -1, ioe);
        if (errorHandler != null) {
          errorHandler.fatalError(spe);
        }
        throw spe;
      }
      String scheme = url.scheme();
      if (!("http".equals(scheme) || "https".equals(scheme))) {
        String msg = "Unsupported URI scheme: \u201C" + scheme + "\u201D.";
        SAXParseException spe =
            new SAXParseException(msg, publicId, systemId, -1, -1, new IOException(msg));
        if (errorHandler != null) {
          errorHandler.fatalError(spe);
        }
        throw spe;
      }
      systemId = url.toString();
      try {
        m = new HttpGet(systemId);
      } catch (IllegalArgumentException e) {
        SAXParseException spe =
            new SAXParseException(
                e.getMessage(),
                publicId,
                systemId,
                -1,
                -1,
                (IOException) new IOException(e.getMessage()).initCause(e));
        if (errorHandler != null) {
          errorHandler.fatalError(spe);
        }
        throw spe;
      }
      m.setHeader("User-Agent", userAgent);
      m.setHeader("Accept", buildAccept());
      m.setHeader("Accept-Encoding", "gzip");
      log4j.info(systemId);
      HttpResponse response = client.execute(m);
      int statusCode = response.getStatusLine().getStatusCode();
      if (statusCode != 200) {
        String msg =
            "HTTP resource not retrievable. The HTTP status from the remote server was: "
                + statusCode
                + ".";
        SAXParseException spe =
            new SAXParseException(
                msg, publicId, m.getURI().toString(), -1, -1, new IOException(msg));
        if (errorHandler != null) {
          errorHandler.fatalError(spe);
        }
        throw spe;
      }
      HttpEntity entity = response.getEntity();
      long len = entity.getContentLength();
      if (sizeLimit > -1 && len > sizeLimit) {
        SAXParseException spe =
            new SAXParseException(
                "Resource size exceeds limit.",
                publicId,
                m.getURI().toString(),
                -1,
                -1,
                new StreamBoundException("Resource size exceeds limit."));
        if (errorHandler != null) {
          errorHandler.fatalError(spe);
        }
        throw spe;
      }
      TypedInputSource is;
      org.apache.http.Header ct = response.getFirstHeader("Content-Type");
      String contentType = null;
      final String baseUri = m.getURI().toString();
      if (ct != null) {
        contentType = ct.getValue();
      }
      is = contentTypeParser.buildTypedInputSource(baseUri, publicId, contentType);

      Header cl = response.getFirstHeader("Content-Language");
      if (cl != null) {
        is.setLanguage(cl.getValue().trim());
      }

      Header xuac = response.getFirstHeader("X-UA-Compatible");
      if (xuac != null) {
        String val = xuac.getValue().trim();
        if (!"ie=edge".equalsIgnoreCase(val)) {
          SAXParseException spe =
              new SAXParseException(
                  "X-UA-Compatible HTTP header must have the value \u201CIE=edge\u201D,"
                      + " was \u201C"
                      + val
                      + "\u201D.",
                  publicId,
                  systemId,
                  -1,
                  -1);
          errorHandler.error(spe);
        }
      }

      Header csp = response.getFirstHeader("Content-Security-Policy");
      if (csp != null) {
        try {
          ContentSecurityPolicy.THE_INSTANCE.checkValid(csp.getValue().trim());
        } catch (DatatypeException e) {
          SAXParseException spe =
              new SAXParseException(
                  "Content-Security-Policy HTTP header: " + e.getMessage(),
                  publicId,
                  systemId,
                  -1,
                  -1);
          Html5DatatypeException ex5 = (Html5DatatypeException) e;
          if (ex5.isWarning()) {
            errorHandler.warning(spe);
          } else {
            errorHandler.error(spe);
          }
        }
      }

      final HttpGet meth = m;
      InputStream stream = entity.getContent();
      if (sizeLimit > -1) {
        stream = new BoundedInputStream(stream, sizeLimit, baseUri);
      }
      Header ce = response.getFirstHeader("Content-Encoding");
      if (ce != null) {
        String val = ce.getValue().trim();
        if ("gzip".equalsIgnoreCase(val) || "x-gzip".equalsIgnoreCase(val)) {
          stream = new GZIPInputStream(stream);
          if (sizeLimit > -1) {
            stream = new BoundedInputStream(stream, sizeLimit, baseUri);
          }
        }
      }
      is.setByteStream(
          new ObservableInputStream(
              stream,
              new StreamObserver() {
                private final Logger log4j =
                    Logger.getLogger("nu.validator.xml.PrudentEntityResolver.StreamObserver");

                private boolean released = false;

                @Override
                public void closeCalled() {
                  log4j.debug("closeCalled");
                  if (!released) {
                    log4j.debug("closeCalled, not yet released");
                    released = true;
                    try {
                      meth.releaseConnection();
                    } catch (Exception e) {
                      log4j.debug("closeCalled, releaseConnection", e);
                    }
                  }
                }

                @Override
                public void exceptionOccurred(Exception ex) throws IOException {
                  if (!released) {
                    released = true;
                    try {
                      meth.abort();
                    } catch (Exception e) {
                      log4j.debug("exceptionOccurred, abort", e);
                    } finally {
                      try {
                        meth.releaseConnection();
                      } catch (Exception e) {
                        log4j.debug("exceptionOccurred, releaseConnection", e);
                      }
                    }
                  }
                  if (ex instanceof SystemIdIOException) {
                    throw (SystemIdIOException) ex;
                  } else if (ex instanceof IOException) {
                    IOException ioe = (IOException) ex;
                    throw new SystemIdIOException(baseUri, ioe.getMessage(), ioe);
                  } else if (ex instanceof RuntimeException) {
                    throw (RuntimeException) ex;
                  } else {
                    throw new RuntimeException("API contract violation. Wrong exception type.", ex);
                  }
                }

                @Override
                public void finalizerCalled() {
                  if (!released) {
                    released = true;
                    try {
                      meth.abort();
                    } catch (Exception e) {
                      log4j.debug("finalizerCalled, abort", e);
                    } finally {
                      try {
                        meth.releaseConnection();
                      } catch (Exception e) {
                        log4j.debug("finalizerCalled, releaseConnection", e);
                      }
                    }
                  }
                }
              }));
      return is;
    } catch (IOException | RuntimeException | SAXException e) {
      if (m != null) {
        try {
          m.abort();
        } catch (Exception ex) {
          log4j.debug("abort", ex);
        } finally {
          try {
            m.releaseConnection();
          } catch (Exception ex) {
            log4j.debug("releaseConnection", ex);
          }
        }
      }
      throw e;
    }
  }
Esempio n. 8
0
 @Override
 public void warning(SAXParseException e) throws SAXException {
   errorHandler.warning(e);
 }