| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <documentbuilder.hxx> |
| |
| #include <string.h> |
| #include <stdio.h> |
| #include <stdarg.h> |
| |
| #include <libxml/xmlerror.h> |
| #include <libxml/tree.h> |
| |
| #include <boost/shared_ptr.hpp> |
| |
| #include <rtl/alloc.h> |
| #include <rtl/memory.h> |
| #include <rtl/ustrbuf.hxx> |
| |
| #include <cppuhelper/implbase1.hxx> |
| |
| #include <com/sun/star/xml/sax/SAXParseException.hpp> |
| #include <com/sun/star/ucb/XCommandEnvironment.hpp> |
| #include <com/sun/star/task/XInteractionHandler.hpp> |
| |
| #include <ucbhelper/content.hxx> |
| #include <ucbhelper/commandenvironment.hxx> |
| |
| #include <node.hxx> |
| #include <document.hxx> |
| |
| |
| using ::rtl::OUStringBuffer; |
| using ::rtl::OString; |
| using ::com::sun::star::xml::sax::InputSource; |
| using namespace ucbhelper; |
| using namespace ::com::sun::star::ucb; |
| using ::com::sun::star::task::XInteractionHandler; |
| |
| |
| namespace DOM |
| { |
| |
| class CDefaultEntityResolver : public cppu::WeakImplHelper1< XEntityResolver > |
| { |
| public: |
| virtual InputSource SAL_CALL resolveEntity( const OUString& sPublicId, const OUString& sSystemId ) |
| throw (::com::sun::star::uno::RuntimeException) |
| { |
| InputSource is; |
| is.sPublicId = sPublicId; |
| is.sSystemId = sSystemId; |
| is.sEncoding = OUString(); |
| |
| try { |
| Reference< XCommandEnvironment > aEnvironment( |
| new CommandEnvironment(Reference< XInteractionHandler >(), |
| Reference< XProgressHandler >() )); |
| Content aContent(sSystemId, aEnvironment); |
| |
| is.aInputStream = aContent.openStream(); |
| } catch (com::sun::star::uno::Exception) { |
| OSL_ENSURE(sal_False, "exception in default entity resolver"); |
| is.aInputStream = Reference< XInputStream >(); |
| } |
| return is; |
| } |
| |
| }; |
| |
| CDocumentBuilder::CDocumentBuilder( |
| Reference< XMultiServiceFactory > const& xFactory) |
| : m_xFactory(xFactory) |
| , m_xEntityResolver(new CDefaultEntityResolver()) |
| { |
| // init libxml. libxml will protect itself against multiple |
| // initializations so there is no problem here if this gets |
| // called multiple times. |
| xmlInitParser(); |
| } |
| |
| Reference< XInterface > CDocumentBuilder::_getInstance(const Reference< XMultiServiceFactory >& rSMgr) |
| { |
| return static_cast< XDocumentBuilder* >(new CDocumentBuilder(rSMgr)); |
| } |
| |
| const char* CDocumentBuilder::aImplementationName = "com.sun.star.comp.xml.dom.DocumentBuilder"; |
| const char* CDocumentBuilder::aSupportedServiceNames[] = { |
| "com.sun.star.xml.dom.DocumentBuilder", |
| NULL |
| }; |
| |
| OUString CDocumentBuilder::_getImplementationName() |
| { |
| return OUString::createFromAscii(aImplementationName); |
| } |
| Sequence<OUString> CDocumentBuilder::_getSupportedServiceNames() |
| { |
| Sequence<OUString> aSequence; |
| for (int i=0; aSupportedServiceNames[i]!=NULL; i++) { |
| aSequence.realloc(i+1); |
| aSequence[i]=(OUString::createFromAscii(aSupportedServiceNames[i])); |
| } |
| return aSequence; |
| } |
| |
| Sequence< OUString > SAL_CALL CDocumentBuilder::getSupportedServiceNames() |
| throw (RuntimeException) |
| { |
| return CDocumentBuilder::_getSupportedServiceNames(); |
| } |
| |
| OUString SAL_CALL CDocumentBuilder::getImplementationName() |
| throw (RuntimeException) |
| { |
| return CDocumentBuilder::_getImplementationName(); |
| } |
| |
| sal_Bool SAL_CALL CDocumentBuilder::supportsService(const OUString& aServiceName) |
| throw (RuntimeException) |
| { |
| Sequence< OUString > supported = CDocumentBuilder::_getSupportedServiceNames(); |
| for (sal_Int32 i=0; i<supported.getLength(); i++) |
| { |
| if (supported[i] == aServiceName) return sal_True; |
| } |
| return sal_False; |
| } |
| |
| Reference< XDOMImplementation > SAL_CALL CDocumentBuilder::getDOMImplementation() |
| throw (RuntimeException) |
| { |
| |
| return Reference< XDOMImplementation >(); |
| } |
| |
| sal_Bool SAL_CALL CDocumentBuilder::isNamespaceAware() |
| throw (RuntimeException) |
| { |
| return sal_True; |
| } |
| |
| sal_Bool SAL_CALL CDocumentBuilder::isValidating() |
| throw (RuntimeException) |
| { |
| return sal_False; |
| } |
| |
| Reference< XDocument > SAL_CALL CDocumentBuilder::newDocument() |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| // create a new document |
| xmlDocPtr pDocument = xmlNewDoc((const xmlChar*)"1.0"); |
| Reference< XDocument > const xRet( |
| CDocument::CreateCDocument(pDocument).get()); |
| return xRet; |
| } |
| |
| static OUString make_error_message(xmlParserCtxtPtr ctxt) |
| { |
| OUStringBuffer buf; |
| buf.appendAscii(ctxt->lastError.message); |
| buf.appendAscii("Line: "); |
| buf.append(static_cast<sal_Int32>(ctxt->lastError.line)); |
| buf.appendAscii("\nColumn: "); |
| buf.append(static_cast<sal_Int32>(ctxt->lastError.int2)); |
| OUString msg = buf.makeStringAndClear(); |
| return msg; |
| } |
| |
| // -- callbacks and context struct for parsing from stream |
| // -- c-linkage, so the callbacks can be used by libxml |
| extern "C" { |
| |
| // context struct passed to IO functions |
| typedef struct context { |
| CDocumentBuilder *pBuilder; |
| Reference< XInputStream > rInputStream; |
| bool close; |
| bool freeOnClose; |
| } context_t; |
| |
| static int xmlIO_read_func( void *context, char *buffer, int len) |
| { |
| // get the context... |
| context_t *pctx = static_cast<context_t*>(context); |
| if (!pctx->rInputStream.is()) |
| return -1; |
| try { |
| // try to read the requested number of bytes |
| Sequence< sal_Int8 > chunk(len); |
| int nread = pctx->rInputStream->readBytes(chunk, len); |
| |
| // copy bytes to the provided buffer |
| rtl_copyMemory(buffer, chunk.getConstArray(), nread); |
| return nread; |
| } catch (com::sun::star::uno::Exception& ex) { |
| (void) ex; |
| OSL_ENSURE(sal_False, OUStringToOString(ex.Message, RTL_TEXTENCODING_UTF8).getStr()); |
| return -1; |
| } |
| } |
| |
| static int xmlIO_close_func(void* context) |
| { |
| // get the context... |
| context_t *pctx = static_cast<context_t*>(context); |
| if (!pctx->rInputStream.is()) |
| return 0; |
| try |
| { |
| if (pctx->close) |
| pctx->rInputStream->closeInput(); |
| if (pctx->freeOnClose) |
| delete pctx; |
| return 0; |
| } catch (com::sun::star::uno::Exception& ex) { |
| (void) ex; |
| OSL_ENSURE(sal_False, OUStringToOString(ex.Message, RTL_TEXTENCODING_UTF8).getStr()); |
| return -1; |
| } |
| } |
| |
| static xmlParserInputPtr resolve_func(void *ctx, |
| const xmlChar *publicId, |
| const xmlChar *systemId) |
| { |
| // get the CDocumentBuilder object |
| xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx; |
| CDocumentBuilder *builder = static_cast< CDocumentBuilder* >(ctxt->_private); |
| Reference< XEntityResolver > resolver = builder->getEntityResolver(); |
| OUString sysid; |
| if (systemId != 0) |
| sysid = OUString((sal_Char*)systemId, strlen((char*)systemId), RTL_TEXTENCODING_UTF8); |
| OUString pubid; |
| if (publicId != 0) |
| pubid = OUString((sal_Char*)publicId, strlen((char*)publicId), RTL_TEXTENCODING_UTF8); |
| |
| // resolve the entity |
| InputSource src = resolver->resolveEntity(pubid, sysid); |
| |
| // create IO context on heap because this call will no longer be on the stack |
| // when IO is actually performed through the callbacks. The close function must |
| // free the memory which is indicated by the freeOnClose field in the context struct |
| context_t *c = new context_t; |
| c->pBuilder = builder; |
| c->rInputStream = src.aInputStream; |
| c->close = true; |
| c->freeOnClose = true; |
| |
| // set up the inputBuffer and inputPtr for libxml |
| xmlParserInputBufferPtr pBuffer = |
| xmlParserInputBufferCreateIO(xmlIO_read_func, xmlIO_close_func, c, XML_CHAR_ENCODING_NONE); |
| xmlParserInputPtr pInput = |
| xmlNewIOInputStream(ctxt, pBuffer, XML_CHAR_ENCODING_NONE); |
| return pInput; |
| } |
| |
| #if 0 |
| static xmlParserInputPtr external_entity_loader(const char *URL, const char * /*ID*/, xmlParserCtxtPtr ctxt) |
| { |
| // just call our resolver function using the URL as systemId |
| return resolve_func(ctxt, 0, (const xmlChar*)URL); |
| } |
| #endif |
| |
| // default warning handler triggers assertion |
| static void warning_func(void * ctx, const char * /*msg*/, ...) |
| { |
| OUStringBuffer buf(OUString::createFromAscii("libxml2 warning\n")); |
| buf.append(make_error_message(static_cast< xmlParserCtxtPtr >(ctx))); |
| OString msg = OUStringToOString(buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US); |
| OSL_ENSURE(sal_False, msg.getStr()); |
| } |
| |
| // default error handler triggers assertion |
| static void error_func(void * ctx, const char * /*msg*/, ...) |
| { |
| OUStringBuffer buf(OUString::createFromAscii("libxml2 error\n")); |
| buf.append(make_error_message(static_cast< xmlParserCtxtPtr >(ctx))); |
| OString msg = OUStringToOString(buf.makeStringAndClear(), RTL_TEXTENCODING_ASCII_US); |
| OSL_ENSURE(sal_False, msg.getStr()); |
| } |
| |
| } // extern "C" |
| |
| void throwEx(xmlParserCtxtPtr ctxt) { |
| OUString msg = make_error_message(ctxt); |
| com::sun::star::xml::sax::SAXParseException saxex; |
| saxex.Message = msg; |
| saxex.LineNumber = static_cast<sal_Int32>(ctxt->lastError.line); |
| saxex.ColumnNumber = static_cast<sal_Int32>(ctxt->lastError.int2); |
| throw saxex; |
| } |
| |
| Reference< XDocument > SAL_CALL CDocumentBuilder::parse(const Reference< XInputStream >& is) |
| throw (RuntimeException, SAXParseException, IOException) |
| { |
| if (!is.is()) { |
| throw RuntimeException(); |
| } |
| |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| // encoding... |
| /* |
| xmlChar *encstr = (xmlChar*) OUStringToOString(src.sEncoding, RTL_TEXTENCODING_UTF8).getStr(); |
| xmlCharEncoding enc = xmlParseCharEncoding(encstr); |
| */ |
| |
| ::boost::shared_ptr<xmlParserCtxt> const pContext( |
| xmlNewParserCtxt(), xmlFreeParserCtxt); |
| |
| // register error functions to prevent errors being printed |
| // on the console |
| pContext->_private = this; |
| pContext->sax->error = error_func; |
| pContext->sax->warning = warning_func; |
| pContext->sax->resolveEntity = resolve_func; |
| |
| // IO context struct |
| context_t c; |
| c.pBuilder = this; |
| c.rInputStream = is; |
| // we did not open the stream, thus we do not close it. |
| c.close = false; |
| c.freeOnClose = false; |
| xmlDocPtr const pDoc = xmlCtxtReadIO(pContext.get(), |
| xmlIO_read_func, xmlIO_close_func, &c, 0, 0, 0); |
| |
| if (pDoc == 0) { |
| throwEx(pContext.get()); |
| } |
| Reference< XDocument > const xRet( |
| CDocument::CreateCDocument(pDoc).get()); |
| return xRet; |
| } |
| |
| Reference< XDocument > SAL_CALL CDocumentBuilder::parseURI(const OUString& sUri) |
| throw (RuntimeException, SAXParseException, IOException) |
| { |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| ::boost::shared_ptr<xmlParserCtxt> const pContext( |
| xmlNewParserCtxt(), xmlFreeParserCtxt); |
| pContext->_private = this; |
| pContext->sax->error = error_func; |
| pContext->sax->warning = warning_func; |
| pContext->sax->resolveEntity = resolve_func; |
| // xmlSetExternalEntityLoader(external_entity_loader); |
| OString oUri = OUStringToOString(sUri, RTL_TEXTENCODING_UTF8); |
| char *uri = (char*) oUri.getStr(); |
| xmlDocPtr pDoc = xmlCtxtReadFile(pContext.get(), uri, 0, 0); |
| if (pDoc == 0) { |
| throwEx(pContext.get()); |
| } |
| Reference< XDocument > const xRet( |
| CDocument::CreateCDocument(pDoc).get()); |
| return xRet; |
| } |
| |
| void SAL_CALL |
| CDocumentBuilder::setEntityResolver(Reference< XEntityResolver > const& xER) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| m_xEntityResolver = xER; |
| } |
| |
| Reference< XEntityResolver > SAL_CALL CDocumentBuilder::getEntityResolver() |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| return m_xEntityResolver; |
| } |
| |
| void SAL_CALL |
| CDocumentBuilder::setErrorHandler(Reference< XErrorHandler > const& xEH) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard const g(m_Mutex); |
| |
| m_xErrorHandler = xEH; |
| } |
| } |
