| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_ucb.hxx" |
| |
| #include "webdavresponseparser.hxx" |
| #include <com/sun/star/xml/sax/XDocumentHandler.hpp> |
| #include <cppuhelper/implbase2.hxx> |
| #include <com/sun/star/xml/sax/XParser.hpp> |
| #include <com/sun/star/xml/sax/InputSource.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <comphelper/seqstream.hxx> |
| #include <com/sun/star/ucb/LockEntry.hpp> |
| #include <com/sun/star/ucb/LockScope.hpp> |
| #include <com/sun/star/ucb/LockType.hpp> |
| #include <map> |
| #include <hash_map> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| using namespace com::sun::star; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // WebDAVNamespace enum and StringToEnum converter |
| |
| namespace |
| { |
| enum WebDAVNamespace |
| { |
| WebDAVNamespace_unknown = 0, |
| WebDAVNamespace_DAV, |
| WebDAVNamespace_ucb_openoffice_org_dav_props, |
| |
| WebDAVNamespace_last |
| }; |
| |
| WebDAVNamespace StrToWebDAVNamespace(const rtl::OUString& rStr) |
| { |
| static ::rtl::OUString aStrDAV(::rtl::OUString::createFromAscii("DAV:")); |
| static ::rtl::OUString aStrUcbOpenofficeOrgDAVProps(::rtl::OUString::createFromAscii("http://ucb.openoffice.org/dav/props/")); |
| |
| if(rStr.equals(aStrDAV)) |
| { |
| return WebDAVNamespace_DAV; |
| } |
| else if(rStr.equals(aStrUcbOpenofficeOrgDAVProps)) |
| { |
| return WebDAVNamespace_ucb_openoffice_org_dav_props; |
| } |
| |
| return WebDAVNamespace_unknown; |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // WebDAVName enum and StringToEnum converter using hash_map |
| |
| namespace |
| { |
| enum WebDAVName |
| { |
| WebDAVName_unknown = 0, |
| WebDAVName_multistatus, |
| WebDAVName_response, |
| WebDAVName_href, |
| WebDAVName_propstat, |
| WebDAVName_prop, |
| WebDAVName_resourcetype, |
| WebDAVName_collection, |
| WebDAVName_getcontenttype, |
| WebDAVName_supportedlock, |
| WebDAVName_lockentry, |
| WebDAVName_lockscope, |
| WebDAVName_exclusive, |
| WebDAVName_locktype, |
| WebDAVName_write, |
| WebDAVName_shared, |
| WebDAVName_status, |
| WebDAVName_getlastmodified, |
| WebDAVName_creationdate, |
| WebDAVName_getcontentlength, |
| |
| WebDAVName_last |
| }; |
| |
| WebDAVName StrToWebDAVName(const rtl::OUString& rStr) |
| { |
| typedef std::hash_map< rtl::OUString, WebDAVName, rtl::OUStringHash > WebDAVNameMapper; |
| typedef std::pair< rtl::OUString, WebDAVName > WebDAVNameValueType; |
| static WebDAVNameMapper aWebDAVNameMapperList; |
| |
| if(aWebDAVNameMapperList.empty()) |
| { |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("multistatus"), WebDAVName_multistatus)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("response"), WebDAVName_response)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("href"), WebDAVName_href)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("propstat"), WebDAVName_propstat)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("prop"), WebDAVName_prop)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("resourcetype"), WebDAVName_resourcetype)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("collection"), WebDAVName_collection)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("getcontenttype"), WebDAVName_getcontenttype)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("supportedlock"), WebDAVName_supportedlock)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("lockentry"), WebDAVName_lockentry)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("lockscope"), WebDAVName_lockscope)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("exclusive"), WebDAVName_exclusive)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("locktype"), WebDAVName_locktype)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("write"), WebDAVName_write)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("shared"), WebDAVName_shared)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("status"), WebDAVName_status)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("getlastmodified"), WebDAVName_getlastmodified)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("creationdate"), WebDAVName_creationdate)); |
| aWebDAVNameMapperList.insert(WebDAVNameValueType(rtl::OUString::createFromAscii("getcontentlength"), WebDAVName_getcontentlength)); |
| } |
| |
| const WebDAVNameMapper::const_iterator aResult(aWebDAVNameMapperList.find(rStr)); |
| |
| if(aResult == aWebDAVNameMapperList.end()) |
| { |
| return WebDAVName_unknown; |
| } |
| else |
| { |
| return aResult->second; |
| } |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // WebDAVContext, holding information for each start/endElement pair |
| |
| namespace |
| { |
| typedef std::map< ::rtl::OUString, ::rtl::OUString > NamespaceMap; |
| typedef std::pair< const ::rtl::OUString, ::rtl::OUString > NamespaceValueType; |
| |
| class WebDAVContext |
| { |
| private: |
| WebDAVContext* mpParent; |
| NamespaceMap maNamespaceMap; |
| ::rtl::OUString maWhiteSpace; |
| |
| ::rtl::OUString maNamespace; |
| ::rtl::OUString maName; |
| |
| WebDAVNamespace maWebDAVNamespace; |
| WebDAVName maWebDAVName; |
| |
| // local helpers |
| void parseForNamespaceTokens(const uno::Reference< xml::sax::XAttributeList >& xAttribs); |
| ::rtl::OUString mapNamespaceToken(const ::rtl::OUString& rToken) const; |
| void splitName(const ::rtl::OUString& rSource); |
| |
| public: |
| WebDAVContext(WebDAVContext* pParent, const ::rtl::OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs); |
| ~WebDAVContext(); |
| |
| WebDAVContext* getParent() const { return mpParent; } |
| ::rtl::OUString& getWhiteSpace() { return maWhiteSpace; } |
| void setWhiteSpace(const ::rtl::OUString& rNew) { maWhiteSpace = rNew; } |
| |
| const ::rtl::OUString& getNamespace() const { return maNamespace; } |
| const ::rtl::OUString& getName() const { return maName; } |
| WebDAVNamespace getWebDAVNamespace() const { return maWebDAVNamespace; } |
| WebDAVName getWebDAVName() const { return maWebDAVName; } |
| }; |
| |
| void WebDAVContext::parseForNamespaceTokens(const uno::Reference< xml::sax::XAttributeList >& xAttribs) |
| { |
| const sal_Int16 nAttributes(xAttribs->getLength()); |
| static ::rtl::OUString aStrXmlns(::rtl::OUString::createFromAscii("xmlns")); |
| |
| for(sal_Int16 a(0); a < nAttributes; a++) |
| { |
| const ::rtl::OUString aName(xAttribs->getNameByIndex(a)); |
| const sal_Int32 nLen(aName.getLength()); |
| |
| if(nLen) |
| { |
| if(aName.match(aStrXmlns, 0)) |
| { |
| const sal_Int32 nIndex(aName.indexOf(sal_Unicode(':'), 0)); |
| |
| if(-1 != nIndex && nIndex + 1 < nLen) |
| { |
| const ::rtl::OUString aToken(aName.copy(nIndex + 1)); |
| |
| maNamespaceMap.insert(NamespaceValueType(aToken, xAttribs->getValueByIndex(a))); |
| } |
| } |
| } |
| } |
| } |
| |
| ::rtl::OUString WebDAVContext::mapNamespaceToken(const ::rtl::OUString& rToken) const |
| { |
| NamespaceMap::const_iterator iter = maNamespaceMap.find(rToken); |
| |
| if(maNamespaceMap.end() == iter) |
| { |
| if(getParent()) |
| { |
| return getParent()->mapNamespaceToken(rToken); |
| } |
| else |
| { |
| return rToken; |
| } |
| } |
| else |
| { |
| return (*iter).second; |
| } |
| } |
| |
| void WebDAVContext::splitName(const ::rtl::OUString& rSource) |
| { |
| const sal_Int32 nLen(rSource.getLength()); |
| maNamespace = ::rtl::OUString(); |
| maName = rSource; |
| |
| if(nLen) |
| { |
| const sal_Int32 nIndex(rSource.indexOf(sal_Unicode(':'), 0)); |
| |
| if(-1 != nIndex && nIndex > 0 && nIndex + 1 < nLen) |
| { |
| maNamespace = mapNamespaceToken(rSource.copy(0, nIndex)); |
| maName = rSource.copy(nIndex + 1); |
| } |
| } |
| } |
| |
| WebDAVContext::WebDAVContext(WebDAVContext* pParent, const ::rtl::OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs) |
| : mpParent(pParent), |
| maNamespaceMap(), |
| maWhiteSpace(), |
| maNamespace(), |
| maName(), |
| maWebDAVNamespace(WebDAVNamespace_unknown), |
| maWebDAVName(WebDAVName_unknown) |
| { |
| const sal_Int16 nAttributes(xAttribs->getLength()); |
| |
| if(nAttributes) |
| { |
| // parse evtl. namespace entries |
| parseForNamespaceTokens(xAttribs); |
| } |
| |
| // split name to namespace and name |
| splitName(aName); |
| |
| // evaluate enums for namespace and name |
| maWebDAVNamespace = StrToWebDAVNamespace(maNamespace); |
| maWebDAVName = StrToWebDAVName(maName); |
| } |
| |
| WebDAVContext::~WebDAVContext() |
| { |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // the Xml parser itself |
| |
| namespace |
| { |
| enum WebDAVResponseParserMode |
| { |
| WebDAVResponseParserMode_PropFind = 0, |
| WebDAVResponseParserMode_PropName |
| }; |
| |
| class WebDAVResponseParser : public cppu::WeakImplHelper1< com::sun::star::xml::sax::XDocumentHandler > |
| { |
| private: |
| std::vector< http_dav_ucp::DAVResource > maResult_PropFind; |
| std::vector< http_dav_ucp::DAVResourceInfo > maResult_PropName; |
| |
| WebDAVContext* mpContext; |
| ::rtl::OUString maHref; |
| ::rtl::OUString maStatus; |
| std::vector< http_dav_ucp::DAVPropertyValue > maResponseProperties; |
| std::vector< http_dav_ucp::DAVPropertyValue > maPropStatProperties; |
| std::vector< ::rtl::OUString > maResponseNames; |
| std::vector< ::rtl::OUString > maPropStatNames; |
| uno::Sequence< ucb::LockEntry > maLockEntries; |
| ucb::LockScope maLockScope; |
| ucb::LockType maLockType; |
| WebDAVResponseParserMode meWebDAVResponseParserMode; |
| |
| // bitfield |
| bool mbResourceTypeCollection : 1; |
| bool mbLockScopeSet : 1; |
| bool mbLockTypeSet : 1; |
| |
| // local helpers |
| bool whitespaceIsAvailable() const |
| { |
| return mpContext && mpContext->getWhiteSpace().getLength(); |
| } |
| bool hasParent(WebDAVName aWebDAVName) const |
| { |
| return mpContext && mpContext->getParent() && aWebDAVName == mpContext->getParent()->getWebDAVName(); |
| } |
| bool propertyIsReady() const |
| { |
| return hasParent(WebDAVName_prop) && whitespaceIsAvailable(); |
| } |
| bool isCollectingProperties() const |
| { |
| return WebDAVResponseParserMode_PropFind == meWebDAVResponseParserMode; |
| } |
| bool isCollectingPropNames() const |
| { |
| return WebDAVResponseParserMode_PropName == meWebDAVResponseParserMode; |
| } |
| bool collectThisPropertyAsName() const |
| { |
| return isCollectingPropNames() && hasParent(WebDAVName_prop); |
| } |
| void pop_context() |
| { |
| if(mpContext) |
| { |
| WebDAVContext* pTemp = mpContext; |
| mpContext = mpContext->getParent(); |
| delete pTemp; |
| } |
| else |
| { |
| OSL_ENSURE(false, "Parser context pop without context (!)"); |
| } |
| } |
| |
| public: |
| WebDAVResponseParser(WebDAVResponseParserMode eWebDAVResponseParserMode); |
| ~WebDAVResponseParser(); |
| |
| // Methods XDocumentHandler |
| virtual void SAL_CALL startDocument( ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL endDocument( ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL startElement( const ::rtl::OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL endElement( const ::rtl::OUString& aName ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL characters( const ::rtl::OUString& aChars ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL ignorableWhitespace( const ::rtl::OUString& aWhitespaces ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL processingInstruction( const ::rtl::OUString& aTarget, const ::rtl::OUString& aData ) throw (xml::sax::SAXException, uno::RuntimeException); |
| virtual void SAL_CALL setDocumentLocator( const uno::Reference< xml::sax::XLocator >& xLocator ) throw (xml::sax::SAXException, uno::RuntimeException); |
| |
| const std::vector< http_dav_ucp::DAVResource >& getResult_PropFind() const { return maResult_PropFind; } |
| const std::vector< http_dav_ucp::DAVResourceInfo >& getResult_PropName() const { return maResult_PropName; } |
| }; |
| |
| WebDAVResponseParser::WebDAVResponseParser(WebDAVResponseParserMode eWebDAVResponseParserMode) |
| : maResult_PropFind(), |
| maResult_PropName(), |
| mpContext(0), |
| maHref(), |
| maStatus(), |
| maResponseProperties(), |
| maPropStatProperties(), |
| maResponseNames(), |
| maPropStatNames(), |
| maLockEntries(), |
| maLockScope(ucb::LockScope_EXCLUSIVE), |
| maLockType(ucb::LockType_WRITE), |
| meWebDAVResponseParserMode(eWebDAVResponseParserMode), |
| mbResourceTypeCollection(false), |
| mbLockScopeSet(false), |
| mbLockTypeSet(false) |
| { |
| } |
| |
| WebDAVResponseParser::~WebDAVResponseParser() |
| { |
| OSL_ENSURE(!mpContext, "Parser destructed with existing content (!)"); |
| while(mpContext) |
| { |
| pop_context(); |
| } |
| } |
| |
| void SAL_CALL WebDAVResponseParser::startDocument( ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| OSL_ENSURE(!mpContext, "Parser start with existing content (!)"); |
| } |
| |
| void SAL_CALL WebDAVResponseParser::endDocument( ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| OSL_ENSURE(!mpContext, "Parser end with existing content (!)"); |
| } |
| |
| void SAL_CALL WebDAVResponseParser::startElement( const ::rtl::OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| const sal_Int32 nLen(aName.getLength()); |
| |
| if(nLen) |
| { |
| // create new context (push) |
| mpContext = new WebDAVContext(mpContext, aName, xAttribs); |
| |
| if(collectThisPropertyAsName()) |
| { |
| // When collecting property names and parent is prop there is no need |
| // to handle the content of this property deeper (evtl. preparations) |
| } |
| else |
| { |
| switch(mpContext->getWebDAVNamespace()) |
| { |
| default: // WebDAVNamespace_unknown, WebDAVNamespace_last or unhandled |
| { |
| break; |
| } |
| case WebDAVNamespace_DAV: |
| { |
| switch(mpContext->getWebDAVName()) |
| { |
| default: // WebDAVName_unknown, WebDAVName_last or unhandled |
| { |
| break; |
| } |
| case WebDAVName_propstat: |
| { |
| // propstat start |
| if(isCollectingProperties()) |
| { |
| // reset maPropStatProperties |
| maPropStatProperties.clear(); |
| } |
| else |
| { |
| // when collecting properties reset maPropStatNames |
| maPropStatNames.clear(); |
| } |
| break; |
| } |
| case WebDAVName_response: |
| { |
| // response start, reset Href and status and maResponseProperties |
| maHref = maStatus = ::rtl::OUString(); |
| |
| if(isCollectingProperties()) |
| { |
| // reset maResponseProperties |
| maResponseProperties.clear(); |
| } |
| else |
| { |
| // reset maResponseNames when collecting properties |
| maResponseNames.clear(); |
| } |
| break; |
| } |
| case WebDAVName_resourcetype: |
| { |
| // resourcetype start, reset collection |
| mbResourceTypeCollection = false; |
| break; |
| } |
| case WebDAVName_supportedlock: |
| { |
| // supportedlock start, reset maLockEntries |
| maLockEntries.realloc(0); |
| break; |
| } |
| case WebDAVName_lockentry: |
| { |
| // lockentry start, reset maLockEntries |
| mbLockScopeSet = false; |
| mbLockTypeSet = false; |
| break; |
| } |
| } |
| break; |
| } |
| case WebDAVNamespace_ucb_openoffice_org_dav_props: |
| { |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL WebDAVResponseParser::endElement( const ::rtl::OUString& aName ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| const sal_Int32 nLen(aName.getLength()); |
| OSL_ENSURE(mpContext, "Parser EndElement without content (!)"); |
| |
| if(mpContext && nLen) |
| { |
| if(collectThisPropertyAsName()) |
| { |
| // When collecting property names and parent is prop, just append the prop name |
| // to the collection, no need to parse deeper |
| maPropStatNames.push_back(mpContext->getNamespace() + mpContext->getName()); |
| } |
| else |
| { |
| switch(mpContext->getWebDAVNamespace()) |
| { |
| default: // WebDAVNamespace_unknown, WebDAVNamespace_last or unhandled |
| { |
| break; |
| } |
| case WebDAVNamespace_DAV: |
| { |
| switch(mpContext->getWebDAVName()) |
| { |
| default: // WebDAVName_unknown, WebDAVName_last or unhandled |
| { |
| break; |
| } |
| case WebDAVName_href: |
| { |
| // href end, save it if we have whitespace |
| if(whitespaceIsAvailable()) |
| { |
| maHref = mpContext->getWhiteSpace(); |
| } |
| break; |
| } |
| case WebDAVName_status: |
| { |
| // status end, save it if we have whitespace |
| if(whitespaceIsAvailable()) |
| { |
| maStatus = mpContext->getWhiteSpace(); |
| } |
| break; |
| } |
| case WebDAVName_getlastmodified: |
| { |
| // getlastmodified end, safe if content is correct |
| if(propertyIsReady()) |
| { |
| static rtl::OUString aStr(rtl::OUString::createFromAscii("DAV:getlastmodified")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStr; |
| aDAVPropertyValue.Value <<= mpContext->getWhiteSpace(); |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_creationdate: |
| { |
| // creationdate end, safe if content is correct |
| if(propertyIsReady()) |
| { |
| static rtl::OUString aStr(rtl::OUString::createFromAscii("DAV:creationdate")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStr; |
| aDAVPropertyValue.Value <<= mpContext->getWhiteSpace(); |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_collection: |
| { |
| // collection end, check and set |
| if(hasParent(WebDAVName_resourcetype)) |
| { |
| mbResourceTypeCollection = true; |
| } |
| break; |
| } |
| case WebDAVName_resourcetype: |
| { |
| // resourcetype end, check for collection |
| if(hasParent(WebDAVName_prop)) |
| { |
| static rtl::OUString aStrA(rtl::OUString::createFromAscii("DAV:resourcetype")); |
| static rtl::OUString aStrB(rtl::OUString::createFromAscii("collection")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStrA; |
| aDAVPropertyValue.Value <<= (mbResourceTypeCollection ? aStrB : rtl::OUString()); |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_getcontentlength: |
| { |
| // getcontentlength end, safe if content is correct |
| if(propertyIsReady()) |
| { |
| static rtl::OUString aStr(rtl::OUString::createFromAscii("DAV:getcontentlength")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStr; |
| aDAVPropertyValue.Value <<= mpContext->getWhiteSpace(); |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_getcontenttype: |
| { |
| // getcontenttype end, safe if content is correct |
| if(propertyIsReady()) |
| { |
| static rtl::OUString aStr(rtl::OUString::createFromAscii("DAV:getcontenttype")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStr; |
| aDAVPropertyValue.Value <<= mpContext->getWhiteSpace(); |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_supportedlock: |
| { |
| // supportedlock end |
| if(hasParent(WebDAVName_prop) && maLockEntries.hasElements()) |
| { |
| static rtl::OUString aStr(rtl::OUString::createFromAscii("DAV:supportedlock")); |
| http_dav_ucp::DAVPropertyValue aDAVPropertyValue; |
| |
| aDAVPropertyValue.Name = aStr; |
| aDAVPropertyValue.Value <<= maLockEntries; |
| maPropStatProperties.push_back(aDAVPropertyValue); |
| } |
| break; |
| } |
| case WebDAVName_lockentry: |
| { |
| // lockentry end |
| if(hasParent(WebDAVName_supportedlock) && (mbLockScopeSet && mbLockTypeSet)) |
| { |
| const sal_Int32 nLength(maLockEntries.getLength()); |
| ucb::LockEntry aEntry; |
| |
| aEntry.Scope = maLockScope; |
| aEntry.Type = maLockType; |
| maLockEntries.realloc(nLength + 1); |
| maLockEntries[nLength] = aEntry; |
| } |
| break; |
| } |
| case WebDAVName_exclusive: |
| { |
| // exclusive lockscope end |
| if(hasParent(WebDAVName_lockscope)) |
| { |
| maLockScope = ucb::LockScope_EXCLUSIVE; |
| mbLockScopeSet = true; |
| } |
| break; |
| } |
| case WebDAVName_shared: |
| { |
| // shared lockscope end |
| if(hasParent(WebDAVName_lockscope)) |
| { |
| maLockScope = ucb::LockScope_SHARED; |
| mbLockScopeSet = true; |
| } |
| break; |
| } |
| case WebDAVName_write: |
| { |
| // write locktype end |
| if(hasParent(WebDAVName_locktype)) |
| { |
| maLockType = ucb::LockType_WRITE; |
| mbLockTypeSet = true; |
| } |
| break; |
| } |
| case WebDAVName_propstat: |
| { |
| // propstat end, check status |
| if(maStatus.getLength()) |
| { |
| static ::rtl::OUString aStrStatusOkay(::rtl::OUString::createFromAscii("HTTP/1.1 200 OK")); |
| |
| if(maStatus.equals(aStrStatusOkay)) |
| { |
| if(isCollectingProperties()) |
| { |
| if(maPropStatProperties.size()) |
| { |
| // append to maResponseProperties if okay |
| maResponseProperties.insert(maResponseProperties.end(), maPropStatProperties.begin(), maPropStatProperties.end()); |
| } |
| } |
| else |
| { |
| if(maPropStatNames.size()) |
| { |
| // when collecting properties append to |
| maResponseNames.insert(maResponseNames.end(), maPropStatNames.begin(), maPropStatNames.end()); |
| } |
| } |
| } |
| } |
| break; |
| } |
| case WebDAVName_response: |
| { |
| // respose end |
| if(maHref.getLength()) |
| { |
| if(isCollectingProperties()) |
| { |
| // create DAVResource when we have content |
| if(maResponseProperties.size()) |
| { |
| http_dav_ucp::DAVResource aDAVResource; |
| |
| aDAVResource.uri = maHref; |
| aDAVResource.properties = maResponseProperties; |
| maResult_PropFind.push_back(aDAVResource); |
| } |
| } |
| else |
| { |
| // when collecting properties add them to result when there are some |
| if(maResponseNames.size()) |
| { |
| http_dav_ucp::DAVResourceInfo aDAVResourceInfo(maHref); |
| |
| aDAVResourceInfo.properties = maResponseNames; |
| maResult_PropName.push_back(aDAVResourceInfo); |
| } |
| } |
| } |
| break; |
| } |
| } |
| break; |
| } |
| case WebDAVNamespace_ucb_openoffice_org_dav_props: |
| { |
| break; |
| } |
| } |
| } |
| |
| // destroy last context (pop) |
| pop_context(); |
| } |
| } |
| |
| void SAL_CALL WebDAVResponseParser::characters( const ::rtl::OUString& aChars ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| // collect whitespace over evtl. several calls in mpContext |
| OSL_ENSURE(mpContext, "Parser characters without content (!)"); |
| const sal_Int32 nLen(aChars.getLength()); |
| |
| if(mpContext && nLen) |
| { |
| // remove leading/trailing blanks and CRLF |
| const ::rtl::OUString aTrimmedChars(aChars.trim()); |
| |
| if(aTrimmedChars.getLength()) |
| { |
| ::rtl::OUString aNew(mpContext->getWhiteSpace()); |
| |
| if(aNew.getLength()) |
| { |
| // add one char when appending (see html1.1 spec) |
| aNew += ::rtl::OUString(sal_Unicode(' ')); |
| } |
| |
| aNew += aTrimmedChars; |
| mpContext->setWhiteSpace(aNew); |
| } |
| } |
| } |
| |
| void SAL_CALL WebDAVResponseParser::ignorableWhitespace( const ::rtl::OUString& /*aWhitespaces*/ ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| } |
| |
| void SAL_CALL WebDAVResponseParser::processingInstruction( const ::rtl::OUString& /*aTarget*/, const ::rtl::OUString& /*aData*/ ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| } |
| |
| void SAL_CALL WebDAVResponseParser::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& /*xLocator*/ ) throw (xml::sax::SAXException, uno::RuntimeException) |
| { |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // wrapper for various calls to the parser |
| |
| namespace |
| { |
| void parseWebDAVPropNameResponse( |
| const uno::Reference< io::XInputStream >& xInputStream, |
| std::vector< http_dav_ucp::DAVResource >& rPropFind, |
| std::vector< http_dav_ucp::DAVResourceInfo >& rPropName, |
| WebDAVResponseParserMode eWebDAVResponseParserMode) |
| { |
| if(xInputStream.is()) |
| { |
| try |
| { |
| // prepare ParserInputSrouce |
| xml::sax::InputSource myInputSource; |
| myInputSource.aInputStream = xInputStream; |
| |
| // get parser |
| uno::Reference< xml::sax::XParser > xParser( |
| comphelper::getProcessServiceFactory()->createInstance( |
| rtl::OUString::createFromAscii("com.sun.star.xml.sax.Parser") ), |
| uno::UNO_QUERY_THROW ); |
| |
| // create parser; connect parser and filter |
| WebDAVResponseParser* pWebDAVResponseParser = new WebDAVResponseParser(eWebDAVResponseParserMode); |
| uno::Reference< xml::sax::XDocumentHandler > xWebDAVHdl(pWebDAVResponseParser); |
| xParser->setDocumentHandler(xWebDAVHdl); |
| |
| // finally, parse the stream |
| xParser->parseStream(myInputSource); |
| |
| // get result |
| switch(eWebDAVResponseParserMode) |
| { |
| case WebDAVResponseParserMode_PropFind: |
| { |
| rPropFind = pWebDAVResponseParser->getResult_PropFind(); |
| break; |
| } |
| case WebDAVResponseParserMode_PropName: |
| { |
| rPropName = pWebDAVResponseParser->getResult_PropName(); |
| break; |
| } |
| } |
| } |
| catch(uno::Exception&) |
| { |
| OSL_ENSURE(false, "WebDAV Parse error (!)"); |
| } |
| } |
| } |
| } // end of anonymous namespace |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // helper to parse a XML WebDAV response |
| |
| namespace http_dav_ucp |
| { |
| std::vector< DAVResource > parseWebDAVPropFindResponse(const uno::Reference< io::XInputStream >& xInputStream) |
| { |
| std::vector< DAVResource > aRetval; |
| std::vector< DAVResourceInfo > aFoo; |
| |
| parseWebDAVPropNameResponse(xInputStream, aRetval, aFoo, WebDAVResponseParserMode_PropFind); |
| return aRetval; |
| } |
| |
| std::vector< DAVResourceInfo > parseWebDAVPropNameResponse(const uno::Reference< io::XInputStream >& xInputStream) |
| { |
| std::vector< DAVResource > aFoo; |
| std::vector< DAVResourceInfo > aRetval; |
| |
| parseWebDAVPropNameResponse(xInputStream, aFoo, aRetval, WebDAVResponseParserMode_PropName); |
| return aRetval; |
| } |
| } // namespace http_dav_ucp |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
