Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <sfx2/DocumentMetadataAccess.hxx>
22 :
23 : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
24 : #include <com/sun/star/beans/XPropertySet.hpp>
25 : #include <com/sun/star/embed/ElementModes.hpp>
26 : #include <com/sun/star/embed/XStorage.hpp>
27 : #include <com/sun/star/embed/XTransactedObject.hpp>
28 : #include <com/sun/star/task/ErrorCodeIOException.hpp>
29 : #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
30 : #include <com/sun/star/rdf/FileFormat.hpp>
31 : #include <com/sun/star/rdf/URIs.hpp>
32 : #include <com/sun/star/rdf/Statement.hpp>
33 : #include <com/sun/star/rdf/Literal.hpp>
34 : #include <com/sun/star/rdf/URI.hpp>
35 : #include <com/sun/star/rdf/Repository.hpp>
36 :
37 : #include <rtl/ustrbuf.hxx>
38 : #include <rtl/uri.hxx>
39 : #include <rtl/bootstrap.hxx>
40 :
41 : #include <comphelper/interaction.hxx>
42 : #include <comphelper/makesequence.hxx>
43 : #include <unotools/mediadescriptor.hxx>
44 : #include <comphelper/sequence.hxx>
45 : #include <comphelper/storagehelper.hxx>
46 :
47 : #include <sfx2/docfile.hxx>
48 : #include <sfx2/XmlIdRegistry.hxx>
49 :
50 : #include <libxml/tree.h>
51 :
52 : #include <boost/bind.hpp>
53 : #include <boost/shared_array.hpp>
54 : #include <boost/tuple/tuple.hpp>
55 :
56 : #include <vector>
57 : #include <set>
58 : #include <map>
59 : #include <functional>
60 : #include <algorithm>
61 :
62 : #include <unotools/ucbhelper.hxx>
63 : #include <com/sun/star/uri/XUriReference.hpp>
64 : #include <com/sun/star/uri/UriReferenceFactory.hpp>
65 : #include <com/sun/star/uri/XVndSunStarPkgUrlReferenceFactory.hpp>
66 :
67 :
68 : /*
69 : Note: in the context of this implementation, all rdf.QueryExceptions and
70 : rdf.RepositoryExceptions are RuntimeExceptions, and will be reported as such.
71 :
72 : This implementation assumes that it is only used with ODF documents, not mere
73 : ODF packages. In other words, we enforce that metadata files must not be
74 : called reserved names.
75 : */
76 :
77 : using namespace ::com::sun::star;
78 :
79 : namespace sfx2 {
80 :
81 :
82 918 : bool isValidNCName(OUString const & i_rIdref)
83 : {
84 : const OString id(
85 918 : OUStringToOString(i_rIdref, RTL_TEXTENCODING_UTF8) );
86 : return !(xmlValidateNCName(
87 918 : reinterpret_cast<const unsigned char*>(id.getStr()), 0));
88 : }
89 :
90 :
91 : static const char s_content [] = "content.xml";
92 : static const char s_styles [] = "styles.xml";
93 : static const char s_meta [] = "meta.xml";
94 : static const char s_settings[] = "settings.xml";
95 : static const char s_manifest[] = "manifest.rdf";
96 : static const char s_rdfxml [] = "application/rdf+xml";
97 : static const char s_odfmime [] = "application/vnd.oasis.opendocument.";
98 :
99 :
100 1539 : static bool isContentFile(OUString const & i_rPath)
101 : {
102 1539 : return i_rPath == s_content;
103 : }
104 :
105 323 : static bool isStylesFile (OUString const & i_rPath)
106 : {
107 323 : return i_rPath == s_styles;
108 : }
109 :
110 918 : bool isValidXmlId(OUString const & i_rStreamName,
111 : OUString const & i_rIdref)
112 : {
113 918 : return isValidNCName(i_rIdref)
114 918 : && (isContentFile(i_rStreamName) || isStylesFile(i_rStreamName));
115 : }
116 :
117 18 : static bool isReservedFile(OUString const & i_rPath)
118 : {
119 18 : return isContentFile(i_rPath) || isStylesFile(i_rPath) || i_rPath == s_meta || i_rPath == s_settings;
120 : }
121 :
122 :
123 453 : uno::Reference<rdf::XURI> createBaseURI(
124 : uno::Reference<uno::XComponentContext> const & i_xContext,
125 : uno::Reference<embed::XStorage> const & i_xStorage,
126 : OUString const & i_rPkgURI, OUString const & i_rSubDocument)
127 : {
128 453 : if (!i_xContext.is() || !i_xStorage.is() || i_rPkgURI.isEmpty()) {
129 5 : throw uno::RuntimeException();
130 : }
131 :
132 : // #i108078# workaround non-hierarchical vnd.sun.star.expand URIs
133 : // this really should be done somewhere else, not here.
134 448 : OUString pkgURI(i_rPkgURI);
135 448 : if (pkgURI.matchIgnoreAsciiCase("vnd.sun.star.expand:"))
136 : {
137 : // expand it here (makeAbsolute requires hierarchical URI)
138 0 : pkgURI = pkgURI.copy( RTL_CONSTASCII_LENGTH("vnd.sun.star.expand:") );
139 0 : if (!pkgURI.isEmpty()) {
140 0 : pkgURI = ::rtl::Uri::decode(
141 0 : pkgURI, rtl_UriDecodeStrict, RTL_TEXTENCODING_UTF8);
142 0 : if (pkgURI.isEmpty()) {
143 0 : throw uno::RuntimeException();
144 : }
145 0 : ::rtl::Bootstrap::expandMacros(pkgURI);
146 : }
147 : }
148 :
149 : const uno::Reference<uri::XUriReferenceFactory> xUriFactory =
150 896 : uri::UriReferenceFactory::create( i_xContext);
151 896 : uno::Reference< uri::XUriReference > xBaseURI;
152 :
153 : const uno::Reference< uri::XUriReference > xPkgURI(
154 896 : xUriFactory->parse(pkgURI), uno::UNO_SET_THROW );
155 448 : xPkgURI->clearFragment();
156 :
157 : // need to know whether the storage is a FileSystemStorage
158 : // XServiceInfo would be better, but it is not implemented
159 : // if ( pkgURI.getLength() && ::utl::UCBContentHelper::IsFolder(pkgURI) )
160 : if (true) {
161 448 : xBaseURI.set( xPkgURI, uno::UNO_SET_THROW );
162 : }
163 896 : OUStringBuffer buf;
164 448 : if (!xBaseURI->getUriReference().endsWith("/"))
165 : {
166 448 : const sal_Int32 count( xBaseURI->getPathSegmentCount() );
167 448 : if (count > 0)
168 : {
169 448 : const OUString last( xBaseURI->getPathSegment(count - 1) );
170 448 : buf.append(last);
171 : }
172 448 : buf.append('/');
173 : }
174 448 : if (!i_rSubDocument.isEmpty())
175 : {
176 0 : buf.append(i_rSubDocument);
177 0 : buf.append('/');
178 : }
179 896 : const OUString Path(buf.makeStringAndClear());
180 448 : if (!Path.isEmpty())
181 : {
182 : const uno::Reference< uri::XUriReference > xPathURI(
183 448 : xUriFactory->parse(Path), uno::UNO_SET_THROW );
184 : xBaseURI.set(
185 448 : xUriFactory->makeAbsolute(xBaseURI, xPathURI,
186 448 : true, uri::RelativeUriExcessParentSegments_ERROR),
187 448 : uno::UNO_SET_THROW);
188 : }
189 :
190 1062 : return rdf::URI::create(i_xContext, xBaseURI->getUriReference());
191 : }
192 :
193 :
194 295 : struct DocumentMetadataAccess_Impl
195 : {
196 : // note: these are all initialized in constructor, and loadFromStorage
197 : const uno::Reference<uno::XComponentContext> m_xContext;
198 : const IXmlIdRegistrySupplier & m_rXmlIdRegistrySupplier;
199 : uno::Reference<rdf::XURI> m_xBaseURI;
200 : uno::Reference<rdf::XRepository> m_xRepository;
201 : uno::Reference<rdf::XNamedGraph> m_xManifest;
202 301 : DocumentMetadataAccess_Impl(
203 : uno::Reference<uno::XComponentContext> const& i_xContext,
204 : IXmlIdRegistrySupplier const & i_rRegistrySupplier)
205 : : m_xContext(i_xContext)
206 : , m_rXmlIdRegistrySupplier(i_rRegistrySupplier)
207 : , m_xBaseURI()
208 : , m_xRepository()
209 301 : , m_xManifest()
210 : {
211 : OSL_ENSURE(m_xContext.is(), "context null");
212 301 : }
213 : };
214 :
215 : // this is... a hack.
216 : template<sal_Int16 Constant>
217 : /*static*/ uno::Reference<rdf::XURI>
218 3235 : getURI(uno::Reference< uno::XComponentContext > const & i_xContext)
219 : {
220 : static uno::Reference< rdf::XURI > xURI(
221 3235 : rdf::URI::createKnown(i_xContext, Constant), uno::UNO_QUERY_THROW);
222 3235 : return xURI;
223 : }
224 :
225 :
226 : /** would storing the file to a XStorage succeed? */
227 29 : static bool isFileNameValid(const OUString & i_rFileName)
228 : {
229 29 : if (i_rFileName.isEmpty()) return false;
230 25 : if (i_rFileName[0] == '/') return false; // no absolute paths!
231 23 : sal_Int32 idx(0);
232 27 : do {
233 : const OUString segment(
234 31 : i_rFileName.getToken(0, static_cast<sal_Unicode> ('/'), idx) );
235 93 : if (segment.isEmpty() || // no empty segments
236 61 : segment == "." || // no . segments
237 89 : segment == ".." || // no .. segments
238 : !::comphelper::OStorageHelper::IsValidZipEntryFileName(
239 28 : segment, false)) // no invalid characters
240 4 : return false;
241 27 : } while (idx >= 0);
242 19 : return true;
243 : }
244 :
245 : /** split a uri hierarchy into first segment and rest */
246 : static bool
247 369 : splitPath(OUString const & i_rPath,
248 : OUString & o_rDir, OUString& o_rRest)
249 : {
250 369 : const sal_Int32 idx(i_rPath.indexOf(static_cast<sal_Unicode>('/')));
251 369 : if (idx < 0 || idx >= i_rPath.getLength()) {
252 361 : o_rDir.clear();
253 361 : o_rRest = i_rPath;
254 361 : return true;
255 8 : } else if (idx == 0 || idx == i_rPath.getLength() - 1) {
256 : // input must not start or end with '/'
257 0 : return false;
258 : } else {
259 8 : o_rDir = (i_rPath.copy(0, idx));
260 8 : o_rRest = (i_rPath.copy(idx+1));
261 8 : return true;
262 : }
263 : }
264 :
265 : static bool
266 1 : splitXmlId(OUString const & i_XmlId,
267 : OUString & o_StreamName, OUString& o_Idref )
268 : {
269 1 : const sal_Int32 idx(i_XmlId.indexOf(static_cast<sal_Unicode>('#')));
270 1 : if ((idx <= 0) || (idx >= i_XmlId.getLength() - 1)) {
271 0 : return false;
272 : } else {
273 1 : o_StreamName = (i_XmlId.copy(0, idx));
274 1 : o_Idref = (i_XmlId.copy(idx+1));
275 1 : return isValidXmlId(o_StreamName, o_Idref);
276 : }
277 : }
278 :
279 :
280 : static uno::Reference<rdf::XURI>
281 541 : getURIForStream(struct DocumentMetadataAccess_Impl& i_rImpl,
282 : OUString const& i_rPath)
283 : {
284 : const uno::Reference<rdf::XURI> xURI(
285 : rdf::URI::createNS( i_rImpl.m_xContext,
286 1082 : i_rImpl.m_xBaseURI->getStringValue(), i_rPath),
287 1082 : uno::UNO_SET_THROW);
288 541 : return xURI;
289 : }
290 :
291 : /** add statements declaring i_xResource to be a file of type i_xType with
292 : path i_rPath to manifest, with optional additional types i_pTypes */
293 : static void
294 164 : addFile(struct DocumentMetadataAccess_Impl & i_rImpl,
295 : uno::Reference<rdf::XURI> const& i_xType,
296 : OUString const & i_rPath,
297 : const uno::Sequence < uno::Reference< rdf::XURI > > * i_pTypes = 0)
298 : {
299 : try {
300 : const uno::Reference<rdf::XURI> xURI( getURIForStream(
301 164 : i_rImpl, i_rPath) );
302 :
303 328 : i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
304 : getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext),
305 328 : xURI.get());
306 328 : i_rImpl.m_xManifest->addStatement(xURI.get(),
307 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
308 328 : i_xType.get());
309 164 : if (i_pTypes) {
310 3 : for (sal_Int32 i = 0; i < i_pTypes->getLength(); ++i) {
311 2 : i_rImpl.m_xManifest->addStatement(xURI.get(),
312 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
313 2 : (*i_pTypes)[i].get());
314 : }
315 164 : }
316 0 : } catch (const uno::RuntimeException &) {
317 0 : throw;
318 0 : } catch (const uno::Exception & e) {
319 : throw lang::WrappedTargetRuntimeException(
320 0 : "addFile: exception", /*this*/0, uno::makeAny(e));
321 : }
322 164 : }
323 :
324 : /** add content.xml or styles.xml to manifest */
325 : static bool
326 163 : addContentOrStylesFileImpl(struct DocumentMetadataAccess_Impl & i_rImpl,
327 : const OUString & i_rPath)
328 : {
329 163 : uno::Reference<rdf::XURI> xType;
330 163 : if (isContentFile(i_rPath)) {
331 81 : xType.set(getURI<rdf::URIs::ODF_CONTENTFILE>(i_rImpl.m_xContext));
332 82 : } else if (isStylesFile(i_rPath)) {
333 81 : xType.set(getURI<rdf::URIs::ODF_STYLESFILE>(i_rImpl.m_xContext));
334 : } else {
335 1 : return false;
336 : }
337 162 : addFile(i_rImpl, xType.get(), i_rPath);
338 162 : return true;
339 : }
340 :
341 : /** add metadata file to manifest */
342 : static void
343 2 : addMetadataFileImpl(struct DocumentMetadataAccess_Impl & i_rImpl,
344 : const OUString & i_rPath,
345 : const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
346 : {
347 : addFile(i_rImpl,
348 : getURI<rdf::URIs::PKG_METADATAFILE>(i_rImpl.m_xContext),
349 2 : i_rPath, &i_rTypes);
350 2 : }
351 :
352 : /** remove a file from the manifest */
353 : static void
354 3 : removeFile(struct DocumentMetadataAccess_Impl & i_rImpl,
355 : uno::Reference<rdf::XURI> const& i_xPart)
356 : {
357 3 : if (!i_xPart.is()) throw uno::RuntimeException();
358 : try {
359 6 : i_rImpl.m_xManifest->removeStatements(i_rImpl.m_xBaseURI.get(),
360 : getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext),
361 6 : i_xPart.get());
362 6 : i_rImpl.m_xManifest->removeStatements(i_xPart.get(),
363 6 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), 0);
364 0 : } catch (const uno::RuntimeException &) {
365 0 : throw;
366 0 : } catch (const uno::Exception & e) {
367 : throw lang::WrappedTargetRuntimeException(
368 : "removeFile: exception",
369 0 : 0, uno::makeAny(e));
370 : }
371 3 : }
372 :
373 : static ::std::vector< uno::Reference< rdf::XURI > >
374 283 : getAllParts(struct DocumentMetadataAccess_Impl & i_rImpl)
375 : {
376 283 : ::std::vector< uno::Reference< rdf::XURI > > ret;
377 : try {
378 : const uno::Reference<container::XEnumeration> xEnum(
379 566 : i_rImpl.m_xManifest->getStatements( i_rImpl.m_xBaseURI.get(),
380 283 : getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), 0),
381 566 : uno::UNO_SET_THROW);
382 1009 : while (xEnum->hasMoreElements()) {
383 443 : rdf::Statement stmt;
384 443 : if (!(xEnum->nextElement() >>= stmt)) {
385 0 : throw uno::RuntimeException();
386 : }
387 : const uno::Reference<rdf::XURI> xPart(stmt.Object,
388 886 : uno::UNO_QUERY);
389 443 : if (!xPart.is()) continue;
390 443 : ret.push_back(xPart);
391 443 : }
392 283 : return ret;
393 0 : } catch (const uno::RuntimeException &) {
394 0 : throw;
395 0 : } catch (const uno::Exception & e) {
396 : throw lang::WrappedTargetRuntimeException(
397 : "getAllParts: exception",
398 0 : 0, uno::makeAny(e));
399 : }
400 : }
401 :
402 : static bool
403 443 : isPartOfType(struct DocumentMetadataAccess_Impl & i_rImpl,
404 : uno::Reference<rdf::XURI> const & i_xPart,
405 : uno::Reference<rdf::XURI> const & i_xType)
406 : {
407 443 : if (!i_xPart.is() || !i_xType.is()) throw uno::RuntimeException();
408 : try {
409 : const uno::Reference<container::XEnumeration> xEnum(
410 886 : i_rImpl.m_xManifest->getStatements(i_xPart.get(),
411 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
412 443 : i_xType.get()),
413 886 : uno::UNO_SET_THROW);
414 443 : return (xEnum->hasMoreElements());
415 0 : } catch (const uno::RuntimeException &) {
416 0 : throw;
417 0 : } catch (const uno::Exception & e) {
418 : throw lang::WrappedTargetRuntimeException(
419 : "isPartOfType: exception",
420 0 : 0, uno::makeAny(e));
421 : }
422 : }
423 :
424 :
425 : static ucb::InteractiveAugmentedIOException
426 64 : mkException( OUString const & i_rMessage,
427 : ucb::IOErrorCode const i_ErrorCode,
428 : OUString const & i_rUri, OUString const & i_rResource)
429 : {
430 64 : ucb::InteractiveAugmentedIOException iaioe;
431 64 : iaioe.Message = i_rMessage;
432 64 : iaioe.Classification = task::InteractionClassification_ERROR;
433 64 : iaioe.Code = i_ErrorCode;
434 :
435 : const beans::PropertyValue uriProp(OUString("Uri"),
436 128 : -1, uno::makeAny(i_rUri), static_cast<beans::PropertyState>(0));
437 : const beans::PropertyValue rnProp(
438 : OUString("ResourceName"),
439 128 : -1, uno::makeAny(i_rResource), static_cast<beans::PropertyState>(0));
440 128 : iaioe.Arguments = ::comphelper::makeSequence(
441 64 : uno::makeAny(uriProp), uno::makeAny(rnProp));
442 128 : return iaioe;
443 : }
444 :
445 : /** error handling policy.
446 : <p>If a handler is given, ask it how to proceed:
447 : <ul><li>(default:) cancel import, raise exception</li>
448 : <li>ignore the error and continue</li>
449 : <li>retry the action that led to the error</li></ul></p>
450 : N.B.: must not be called before DMA is fully initalized!
451 : @returns true iff caller should retry
452 : */
453 : static bool
454 0 : handleError( ucb::InteractiveAugmentedIOException const & i_rException,
455 : const uno::Reference<task::XInteractionHandler> & i_xHandler)
456 : {
457 0 : if (!i_xHandler.is()) {
458 : throw lang::WrappedTargetException(
459 : "DocumentMetadataAccess::loadMetadataFromStorage: exception",
460 0 : /* *this*/ 0, uno::makeAny(i_rException));
461 : }
462 :
463 : ::rtl::Reference< ::comphelper::OInteractionRequest > pRequest(
464 0 : new ::comphelper::OInteractionRequest(uno::makeAny(i_rException)) );
465 : ::rtl::Reference< ::comphelper::OInteractionRetry > pRetry(
466 0 : new ::comphelper::OInteractionRetry );
467 : ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove(
468 0 : new ::comphelper::OInteractionApprove );
469 : ::rtl::Reference< ::comphelper::OInteractionAbort > pAbort(
470 0 : new ::comphelper::OInteractionAbort );
471 :
472 0 : pRequest->addContinuation( pApprove.get() );
473 0 : pRequest->addContinuation( pAbort.get() );
474 : // actually call the handler
475 0 : i_xHandler->handle( pRequest.get() );
476 0 : if (pRetry->wasSelected()) {
477 0 : return true;
478 0 : } else if (pApprove->wasSelected()) {
479 0 : return false;
480 : } else {
481 : OSL_ENSURE(pAbort->wasSelected(), "no continuation selected?");
482 : throw lang::WrappedTargetException(
483 : "DocumentMetadataAccess::loadMetadataFromStorage: exception",
484 0 : /* *this*/ 0, uno::makeAny(i_rException));
485 0 : }
486 : }
487 :
488 : /** check if storage has content.xml/styles.xml;
489 : e.g. ODB files seem to only have content.xml */
490 : static void
491 282 : collectFilesFromStorage(uno::Reference<embed::XStorage> const& i_xStorage,
492 : const OUString& i_Path,
493 : std::set< OUString > & o_rFiles)
494 : {
495 282 : static OUString content(s_content);
496 282 : static OUString styles(s_styles );
497 : try {
498 562 : if (i_xStorage->hasByName(content) &&
499 280 : i_xStorage->isStreamElement(content))
500 : {
501 280 : o_rFiles.insert(i_Path + content);
502 : }
503 562 : if (i_xStorage->hasByName(styles) &&
504 280 : i_xStorage->isStreamElement(styles))
505 : {
506 280 : o_rFiles.insert(i_Path + styles);
507 : }
508 0 : } catch (const uno::Exception &) {
509 : OSL_TRACE("collectFilesFromStorage: exception?");
510 : }
511 282 : }
512 :
513 : /** import a metadata file into repository */
514 : static void
515 290 : readStream(struct DocumentMetadataAccess_Impl & i_rImpl,
516 : uno::Reference< embed::XStorage > const & i_xStorage,
517 : OUString const & i_rPath,
518 : OUString const & i_rBaseURI)
519 : {
520 290 : OUString dir;
521 580 : OUString rest;
522 : try {
523 290 : if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException();
524 290 : if (dir.isEmpty()) {
525 286 : if (i_xStorage->isStreamElement(i_rPath)) {
526 : const uno::Reference<io::XStream> xStream(
527 222 : i_xStorage->openStreamElement(i_rPath,
528 222 : embed::ElementModes::READ), uno::UNO_SET_THROW);
529 : const uno::Reference<io::XInputStream> xInStream(
530 444 : xStream->getInputStream(), uno::UNO_SET_THROW );
531 : const uno::Reference<rdf::XURI> xBaseURI(
532 444 : rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI));
533 : const uno::Reference<rdf::XURI> xURI(
534 : rdf::URI::createNS(i_rImpl.m_xContext,
535 444 : i_rBaseURI, i_rPath));
536 222 : i_rImpl.m_xRepository->importGraph(rdf::FileFormat::RDF_XML,
537 444 : xInStream, xURI, xBaseURI);
538 : } else {
539 : throw mkException(
540 : "readStream: is not a stream",
541 0 : ucb::IOErrorCode_NO_FILE, i_rBaseURI + i_rPath, i_rPath);
542 : }
543 : } else {
544 4 : if (i_xStorage->isStorageElement(dir)) {
545 : const uno::Reference<embed::XStorage> xDir(
546 4 : i_xStorage->openStorageElement(dir,
547 4 : embed::ElementModes::READ));
548 : const uno::Reference< beans::XPropertySet > xDirProps(xDir,
549 8 : uno::UNO_QUERY_THROW);
550 : try {
551 4 : OUString mimeType;
552 4 : xDirProps->getPropertyValue(
553 4 : utl::MediaDescriptor::PROP_MEDIATYPE() )
554 4 : >>= mimeType;
555 4 : if (mimeType.startsWith(s_odfmime)) {
556 : OSL_TRACE("readStream: "
557 : "refusing to recurse into embedded document");
558 226 : return;
559 4 : }
560 0 : } catch (const uno::Exception &) { }
561 8 : OUStringBuffer buf(i_rBaseURI);
562 4 : buf.append(dir).append('/');
563 8 : readStream(i_rImpl, xDir, rest, buf.makeStringAndClear() );
564 : } else {
565 : throw mkException(
566 : "readStream: is not a directory",
567 0 : ucb::IOErrorCode_NO_DIRECTORY, i_rBaseURI + dir, dir);
568 : }
569 : }
570 128 : } catch (const container::NoSuchElementException & e) {
571 : throw mkException(e.Message, ucb::IOErrorCode_NOT_EXISTING_PATH,
572 64 : i_rBaseURI + i_rPath, i_rPath);
573 0 : } catch (const io::IOException & e) {
574 : throw mkException(e.Message, ucb::IOErrorCode_CANT_READ,
575 0 : i_rBaseURI + i_rPath, i_rPath);
576 0 : } catch (const rdf::ParseException & e) {
577 : throw mkException(e.Message, ucb::IOErrorCode_WRONG_FORMAT,
578 0 : i_rBaseURI + i_rPath, i_rPath);
579 290 : }
580 : }
581 :
582 : /** import a metadata file into repository */
583 : static void
584 4 : importFile(struct DocumentMetadataAccess_Impl & i_rImpl,
585 : uno::Reference<embed::XStorage> const & i_xStorage,
586 : OUString const & i_rBaseURI,
587 : uno::Reference<task::XInteractionHandler> const & i_xHandler,
588 : const OUString& i_rPath)
589 : {
590 : retry:
591 : try {
592 4 : readStream(i_rImpl, i_xStorage, i_rPath, i_rBaseURI);
593 0 : } catch (const ucb::InteractiveAugmentedIOException & e) {
594 0 : if (handleError(e, i_xHandler)) goto retry;
595 0 : } catch (const uno::RuntimeException &) {
596 0 : throw;
597 0 : } catch (const uno::Exception & e) {
598 : throw lang::WrappedTargetRuntimeException(
599 : "importFile: exception",
600 0 : 0, uno::makeAny(e));
601 : }
602 4 : }
603 :
604 : /** actually write a metadata file to the storage */
605 : static void
606 75 : exportStream(struct DocumentMetadataAccess_Impl & i_rImpl,
607 : uno::Reference< embed::XStorage > const & i_xStorage,
608 : uno::Reference<rdf::XURI> const & i_xGraphName,
609 : OUString const & i_rFileName,
610 : OUString const & i_rBaseURI)
611 : {
612 : const uno::Reference<io::XStream> xStream(
613 75 : i_xStorage->openStreamElement(i_rFileName,
614 75 : embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE),
615 75 : uno::UNO_SET_THROW);
616 : const uno::Reference< beans::XPropertySet > xStreamProps(xStream,
617 150 : uno::UNO_QUERY);
618 75 : if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
619 75 : xStreamProps->setPropertyValue(
620 : OUString("MediaType"),
621 75 : uno::makeAny(OUString(s_rdfxml)));
622 : }
623 : const uno::Reference<io::XOutputStream> xOutStream(
624 150 : xStream->getOutputStream(), uno::UNO_SET_THROW );
625 : const uno::Reference<rdf::XURI> xBaseURI(
626 150 : rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI));
627 75 : i_rImpl.m_xRepository->exportGraph(rdf::FileFormat::RDF_XML,
628 150 : xOutStream, i_xGraphName, xBaseURI);
629 75 : }
630 :
631 : /** write a metadata file to the storage */
632 : static void
633 79 : writeStream(struct DocumentMetadataAccess_Impl & i_rImpl,
634 : uno::Reference< embed::XStorage > const & i_xStorage,
635 : uno::Reference<rdf::XURI> const & i_xGraphName,
636 : OUString const & i_rPath,
637 : OUString const & i_rBaseURI)
638 : {
639 79 : OUString dir;
640 158 : OUString rest;
641 79 : if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException();
642 : try {
643 79 : if (dir.isEmpty()) {
644 : exportStream(i_rImpl, i_xStorage, i_xGraphName, i_rPath,
645 75 : i_rBaseURI);
646 : } else {
647 : const uno::Reference<embed::XStorage> xDir(
648 4 : i_xStorage->openStorageElement(dir,
649 4 : embed::ElementModes::WRITE));
650 : const uno::Reference< beans::XPropertySet > xDirProps(xDir,
651 8 : uno::UNO_QUERY_THROW);
652 : try {
653 4 : OUString mimeType;
654 4 : xDirProps->getPropertyValue(
655 4 : utl::MediaDescriptor::PROP_MEDIATYPE() )
656 4 : >>= mimeType;
657 4 : if (mimeType.startsWith(s_odfmime)) {
658 : OSL_TRACE("writeStream: "
659 : "refusing to recurse into embedded document");
660 79 : return;
661 4 : }
662 0 : } catch (const uno::Exception &) { }
663 8 : OUStringBuffer buf(i_rBaseURI);
664 4 : buf.append(dir).append('/');
665 : writeStream(i_rImpl, xDir, i_xGraphName, rest,
666 4 : buf.makeStringAndClear());
667 : uno::Reference<embed::XTransactedObject> const xTransaction(
668 8 : xDir, uno::UNO_QUERY);
669 4 : if (xTransaction.is()) {
670 4 : xTransaction->commit();
671 4 : }
672 : }
673 0 : } catch (const uno::RuntimeException &) {
674 0 : throw;
675 0 : } catch (const io::IOException &) {
676 0 : throw;
677 79 : }
678 : }
679 :
680 : static void
681 282 : initLoading(struct DocumentMetadataAccess_Impl & i_rImpl,
682 : const uno::Reference< embed::XStorage > & i_xStorage,
683 : const uno::Reference<rdf::XURI> & i_xBaseURI,
684 : const uno::Reference<task::XInteractionHandler> & i_xHandler)
685 : {
686 : retry:
687 : // clear old data
688 282 : i_rImpl.m_xManifest.clear();
689 : // init BaseURI
690 282 : i_rImpl.m_xBaseURI = i_xBaseURI;
691 :
692 : // create repository
693 282 : i_rImpl.m_xRepository.clear();
694 : i_rImpl.m_xRepository.set(rdf::Repository::create(i_rImpl.m_xContext),
695 282 : uno::UNO_SET_THROW);
696 :
697 282 : const OUString baseURI( i_xBaseURI->getStringValue() );
698 : // try to delay raising errors until after initialization is done
699 564 : uno::Any rterr;
700 564 : ucb::InteractiveAugmentedIOException iaioe;
701 282 : bool err(false);
702 :
703 : const uno::Reference <rdf::XURI> xManifest(
704 564 : getURIForStream(i_rImpl, s_manifest));
705 : try {
706 346 : readStream(i_rImpl, i_xStorage, s_manifest, baseURI);
707 128 : } catch (const ucb::InteractiveAugmentedIOException & e) {
708 : // no manifest.rdf: this is not an error in ODF < 1.2
709 64 : if (!(ucb::IOErrorCode_NOT_EXISTING_PATH == e.Code)) {
710 0 : iaioe = e;
711 0 : err = true;
712 : }
713 0 : } catch (const uno::Exception & e) {
714 0 : rterr <<= e;
715 : }
716 :
717 : // init manifest graph
718 : const uno::Reference<rdf::XNamedGraph> xManifestGraph(
719 564 : i_rImpl.m_xRepository->getGraph(xManifest));
720 282 : i_rImpl.m_xManifest.set(xManifestGraph.is() ? xManifestGraph :
721 282 : i_rImpl.m_xRepository->createGraph(xManifest), uno::UNO_SET_THROW);
722 : const uno::Reference<container::XEnumeration> xEnum(
723 282 : i_rImpl.m_xManifest->getStatements(0,
724 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
725 564 : getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get()));
726 :
727 : // document statement
728 564 : i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
729 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
730 564 : getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get());
731 :
732 : OSL_ENSURE(i_rImpl.m_xBaseURI.is(), "base URI is null");
733 : OSL_ENSURE(i_rImpl.m_xRepository.is(), "repository is null");
734 : OSL_ENSURE(i_rImpl.m_xManifest.is(), "manifest is null");
735 :
736 282 : if (rterr.hasValue()) {
737 : throw lang::WrappedTargetRuntimeException(
738 : OUString(
739 : "DocumentMetadataAccess::loadMetadataFromStorage: "
740 0 : "exception"), 0, rterr);
741 : }
742 :
743 282 : if (err) {
744 0 : if (handleError(iaioe, i_xHandler)) goto retry;
745 282 : }
746 282 : }
747 :
748 : /** init Impl struct */
749 17 : static void init(struct DocumentMetadataAccess_Impl & i_rImpl)
750 : {
751 : try {
752 :
753 17 : i_rImpl.m_xManifest.set(i_rImpl.m_xRepository->createGraph(
754 17 : getURIForStream(i_rImpl, s_manifest)),
755 17 : uno::UNO_SET_THROW);
756 :
757 : // insert the document statement
758 34 : i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
759 : getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
760 34 : getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get());
761 0 : } catch (const uno::Exception & e) {
762 : throw lang::WrappedTargetRuntimeException(
763 : "init: unexpected exception", 0,
764 0 : uno::makeAny(e));
765 : }
766 :
767 : // add top-level content files
768 17 : if (!addContentOrStylesFileImpl(i_rImpl, s_content)) {
769 0 : throw uno::RuntimeException();
770 : }
771 17 : if (!addContentOrStylesFileImpl(i_rImpl, s_styles)) {
772 0 : throw uno::RuntimeException();
773 : }
774 17 : }
775 :
776 :
777 :
778 284 : DocumentMetadataAccess::DocumentMetadataAccess(
779 : uno::Reference< uno::XComponentContext > const & i_xContext,
780 : const IXmlIdRegistrySupplier & i_rRegistrySupplier)
781 284 : : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier))
782 : {
783 : // no initalization: must call loadFrom...
784 284 : }
785 :
786 17 : DocumentMetadataAccess::DocumentMetadataAccess(
787 : uno::Reference< uno::XComponentContext > const & i_xContext,
788 : const IXmlIdRegistrySupplier & i_rRegistrySupplier,
789 : OUString const & i_rURI)
790 17 : : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier))
791 : {
792 : OSL_ENSURE(!i_rURI.isEmpty(), "DMA::DMA: no URI given!");
793 : OSL_ENSURE(i_rURI.endsWith("/"), "DMA::DMA: URI without / given!");
794 17 : if (!i_rURI.endsWith("/")) throw uno::RuntimeException();
795 17 : m_pImpl->m_xBaseURI.set(rdf::URI::create(m_pImpl->m_xContext, i_rURI));
796 34 : m_pImpl->m_xRepository.set(rdf::Repository::create(m_pImpl->m_xContext),
797 34 : uno::UNO_SET_THROW);
798 :
799 : // init repository
800 17 : init(*m_pImpl);
801 :
802 : OSL_ENSURE(m_pImpl->m_xBaseURI.is(), "base URI is null");
803 : OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository is null");
804 : OSL_ENSURE(m_pImpl->m_xManifest.is(), "manifest is null");
805 17 : }
806 :
807 590 : DocumentMetadataAccess::~DocumentMetadataAccess()
808 : {
809 590 : }
810 :
811 : // ::com::sun::star::rdf::XRepositorySupplier:
812 : uno::Reference< rdf::XRepository > SAL_CALL
813 115 : DocumentMetadataAccess::getRDFRepository() throw (uno::RuntimeException, std::exception)
814 : {
815 : OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository not initialized");
816 115 : return m_pImpl->m_xRepository;
817 : }
818 :
819 : // ::com::sun::star::rdf::XNode:
820 : OUString SAL_CALL
821 355 : DocumentMetadataAccess::getStringValue() throw (uno::RuntimeException, std::exception)
822 : {
823 355 : return m_pImpl->m_xBaseURI->getStringValue();
824 : }
825 :
826 : // ::com::sun::star::rdf::XURI:
827 : OUString SAL_CALL
828 0 : DocumentMetadataAccess::getNamespace() throw (uno::RuntimeException, std::exception)
829 : {
830 0 : return m_pImpl->m_xBaseURI->getNamespace();
831 : }
832 :
833 : OUString SAL_CALL
834 0 : DocumentMetadataAccess::getLocalName() throw (uno::RuntimeException, std::exception)
835 : {
836 0 : return m_pImpl->m_xBaseURI->getLocalName();
837 : }
838 :
839 : // ::com::sun::star::rdf::XDocumentMetadataAccess:
840 : uno::Reference< rdf::XMetadatable > SAL_CALL
841 1 : DocumentMetadataAccess::getElementByMetadataReference(
842 : const ::com::sun::star::beans::StringPair & i_rReference)
843 : throw (uno::RuntimeException, std::exception)
844 : {
845 : const IXmlIdRegistry * pReg(
846 1 : m_pImpl->m_rXmlIdRegistrySupplier.GetXmlIdRegistry() );
847 1 : if (!pReg) {
848 : throw uno::RuntimeException(
849 0 : "DocumentMetadataAccess::getElementByXmlId: no registry", *this);
850 : }
851 1 : return pReg->GetElementByMetadataReference(i_rReference);
852 : }
853 :
854 : uno::Reference< rdf::XMetadatable > SAL_CALL
855 2 : DocumentMetadataAccess::getElementByURI(
856 : const uno::Reference< rdf::XURI > & i_xURI )
857 : throw (uno::RuntimeException, lang::IllegalArgumentException, std::exception)
858 : {
859 2 : if (!i_xURI.is()) {
860 : throw lang::IllegalArgumentException(
861 1 : "DocumentMetadataAccess::getElementByURI: URI is null", *this, 0);
862 : }
863 :
864 1 : const OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() );
865 2 : const OUString name( i_xURI->getStringValue() );
866 1 : if (!name.match(baseURI)) {
867 0 : return 0;
868 : }
869 2 : const OUString relName( name.copy(baseURI.getLength()) );
870 2 : OUString path;
871 2 : OUString idref;
872 1 : if (!splitXmlId(relName, path, idref)) {
873 0 : return 0;
874 : }
875 :
876 2 : return getElementByMetadataReference( beans::StringPair(path, idref) );
877 : }
878 :
879 :
880 : uno::Sequence< uno::Reference< rdf::XURI > > SAL_CALL
881 2 : DocumentMetadataAccess::getMetadataGraphsWithType(
882 : const uno::Reference<rdf::XURI> & i_xType)
883 : throw (uno::RuntimeException, lang::IllegalArgumentException, std::exception)
884 : {
885 2 : if (!i_xType.is()) {
886 : throw lang::IllegalArgumentException(
887 : "DocumentMetadataAccess::getMetadataGraphsWithType: "
888 1 : "type is null", *this, 0);
889 : }
890 :
891 1 : ::std::vector< uno::Reference< rdf::XURI > > ret;
892 : const ::std::vector< uno::Reference< rdf::XURI > > parts(
893 2 : getAllParts(*m_pImpl) );
894 : ::std::remove_copy_if(parts.begin(), parts.end(),
895 : ::std::back_inserter(ret),
896 : ::boost::bind(
897 : ::std::logical_not<bool>(),
898 1 : ::boost::bind(&isPartOfType, ::boost::ref(*m_pImpl), _1, i_xType) ));
899 2 : return ::comphelper::containerToSequence(ret);
900 : }
901 :
902 : uno::Reference<rdf::XURI> SAL_CALL
903 12 : DocumentMetadataAccess::addMetadataFile(const OUString & i_rFileName,
904 : const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
905 : throw (uno::RuntimeException, lang::IllegalArgumentException,
906 : container::ElementExistException, std::exception)
907 : {
908 12 : if (!isFileNameValid(i_rFileName)) {
909 : throw lang::IllegalArgumentException(
910 : "DocumentMetadataAccess::addMetadataFile: invalid FileName",
911 6 : *this, 0);
912 : }
913 6 : if (isReservedFile(i_rFileName)) {
914 : throw lang::IllegalArgumentException(
915 : "DocumentMetadataAccess::addMetadataFile:"
916 4 : "invalid FileName: reserved", *this, 0);
917 : }
918 3 : for (sal_Int32 i = 0; i < i_rTypes.getLength(); ++i) {
919 1 : if (!i_rTypes[i].is()) {
920 : throw lang::IllegalArgumentException(
921 : "DocumentMetadataAccess::addMetadataFile: "
922 0 : "null type", *this, 2);
923 : }
924 : }
925 :
926 : const uno::Reference<rdf::XURI> xGraphName(
927 2 : getURIForStream(*m_pImpl, i_rFileName) );
928 :
929 : try {
930 2 : m_pImpl->m_xRepository->createGraph(xGraphName);
931 0 : } catch (const rdf::RepositoryException & e) {
932 : throw lang::WrappedTargetRuntimeException(
933 : "DocumentMetadataAccess::addMetadataFile: exception",
934 0 : *this, uno::makeAny(e));
935 : // note: all other exceptions are propagated
936 : }
937 :
938 2 : addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes);
939 2 : return xGraphName;
940 : }
941 :
942 : uno::Reference<rdf::XURI> SAL_CALL
943 5 : DocumentMetadataAccess::importMetadataFile(::sal_Int16 i_Format,
944 : const uno::Reference< io::XInputStream > & i_xInStream,
945 : const OUString & i_rFileName,
946 : const uno::Reference< rdf::XURI > & i_xBaseURI,
947 : const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
948 : throw (uno::RuntimeException, lang::IllegalArgumentException,
949 : datatransfer::UnsupportedFlavorException,
950 : container::ElementExistException, rdf::ParseException, io::IOException, std::exception)
951 : {
952 5 : if (!isFileNameValid(i_rFileName)) {
953 : throw lang::IllegalArgumentException(
954 : "DocumentMetadataAccess::importMetadataFile: invalid FileName",
955 1 : *this, 0);
956 : }
957 4 : if (isReservedFile(i_rFileName)) {
958 : throw lang::IllegalArgumentException(
959 : "DocumentMetadataAccess::importMetadataFile:"
960 1 : "invalid FileName: reserved", *this, 0);
961 : }
962 3 : for (sal_Int32 i = 0; i < i_rTypes.getLength(); ++i) {
963 0 : if (!i_rTypes[i].is()) {
964 : throw lang::IllegalArgumentException(
965 : "DocumentMetadataAccess::importMetadataFile: null type",
966 0 : *this, 5);
967 : }
968 : }
969 :
970 : const uno::Reference<rdf::XURI> xGraphName(
971 3 : getURIForStream(*m_pImpl, i_rFileName) );
972 :
973 : try {
974 3 : m_pImpl->m_xRepository->importGraph(
975 3 : i_Format, i_xInStream, xGraphName, i_xBaseURI);
976 0 : } catch (const rdf::RepositoryException & e) {
977 : throw lang::WrappedTargetRuntimeException(
978 : "DocumentMetadataAccess::importMetadataFile: "
979 0 : "RepositoryException", *this, uno::makeAny(e));
980 : // note: all other exceptions are propagated
981 : }
982 :
983 : // add to manifest
984 0 : addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes);
985 0 : return xGraphName;
986 : }
987 :
988 : void SAL_CALL
989 2 : DocumentMetadataAccess::removeMetadataFile(
990 : const uno::Reference< rdf::XURI > & i_xGraphName)
991 : throw (uno::RuntimeException, lang::IllegalArgumentException,
992 : container::NoSuchElementException, std::exception)
993 : {
994 : try {
995 2 : m_pImpl->m_xRepository->destroyGraph(i_xGraphName);
996 0 : } catch (const rdf::RepositoryException & e) {
997 : throw lang::WrappedTargetRuntimeException(
998 : "DocumentMetadataAccess::removeMetadataFile: "
999 0 : "RepositoryException", *this, uno::makeAny(e));
1000 : // note: all other exceptions are propagated
1001 : }
1002 :
1003 : // remove file from manifest
1004 1 : removeFile(*m_pImpl, i_xGraphName.get());
1005 1 : }
1006 :
1007 : void SAL_CALL
1008 5 : DocumentMetadataAccess::addContentOrStylesFile(
1009 : const OUString & i_rFileName)
1010 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1011 : container::ElementExistException, std::exception)
1012 : {
1013 5 : if (!isFileNameValid(i_rFileName)) {
1014 : throw lang::IllegalArgumentException(
1015 : "DocumentMetadataAccess::addContentOrStylesFile: "
1016 2 : "invalid FileName", *this, 0);
1017 : }
1018 :
1019 3 : if (!addContentOrStylesFileImpl(*m_pImpl, i_rFileName)) {
1020 : throw lang::IllegalArgumentException(
1021 : "DocumentMetadataAccess::addContentOrStylesFile: "
1022 : "invalid FileName: must end with content.xml or styles.xml",
1023 1 : *this, 0);
1024 : }
1025 2 : }
1026 :
1027 : void SAL_CALL
1028 3 : DocumentMetadataAccess::removeContentOrStylesFile(
1029 : const OUString & i_rFileName)
1030 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1031 : container::NoSuchElementException, std::exception)
1032 : {
1033 3 : if (!isFileNameValid(i_rFileName)) {
1034 : throw lang::IllegalArgumentException(
1035 : "DocumentMetadataAccess::removeContentOrStylesFile: "
1036 1 : "invalid FileName", *this, 0);
1037 : }
1038 :
1039 : try {
1040 : const uno::Reference<rdf::XURI> xPart(
1041 2 : getURIForStream(*m_pImpl, i_rFileName) );
1042 : const uno::Reference<container::XEnumeration> xEnum(
1043 4 : m_pImpl->m_xManifest->getStatements( m_pImpl->m_xBaseURI.get(),
1044 2 : getURI<rdf::URIs::PKG_HASPART>(m_pImpl->m_xContext),
1045 2 : xPart.get()),
1046 8 : uno::UNO_SET_THROW);
1047 2 : if (!xEnum->hasMoreElements()) {
1048 : throw container::NoSuchElementException(
1049 : "DocumentMetadataAccess::removeContentOrStylesFile: "
1050 0 : "cannot find stream in manifest graph: " + i_rFileName,
1051 0 : *this);
1052 : }
1053 :
1054 : // remove file from manifest
1055 4 : removeFile(*m_pImpl, xPart);
1056 :
1057 0 : } catch (const uno::RuntimeException &) {
1058 0 : throw;
1059 0 : } catch (const uno::Exception & e) {
1060 : throw lang::WrappedTargetRuntimeException(
1061 : "DocumentMetadataAccess::removeContentOrStylesFile: exception",
1062 0 : *this, uno::makeAny(e));
1063 : }
1064 2 : }
1065 :
1066 283 : void SAL_CALL DocumentMetadataAccess::loadMetadataFromStorage(
1067 : const uno::Reference< embed::XStorage > & i_xStorage,
1068 : const uno::Reference<rdf::XURI> & i_xBaseURI,
1069 : const uno::Reference<task::XInteractionHandler> & i_xHandler)
1070 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1071 : lang::WrappedTargetException, std::exception)
1072 : {
1073 283 : if (!i_xStorage.is()) {
1074 : throw lang::IllegalArgumentException(
1075 : "DocumentMetadataAccess::loadMetadataFromStorage: "
1076 1 : "storage is null", *this, 0);
1077 : }
1078 282 : if (!i_xBaseURI.is()) {
1079 : throw lang::IllegalArgumentException(
1080 : "DocumentMetadataAccess::loadMetadataFromStorage: "
1081 0 : "base URI is null", *this, 1);
1082 : }
1083 282 : const OUString baseURI( i_xBaseURI->getStringValue());
1084 282 : if (baseURI.indexOf('#') >= 0) {
1085 : throw lang::IllegalArgumentException(
1086 : "DocumentMetadataAccess::loadMetadataFromStorage: "
1087 0 : "base URI not absolute", *this, 1);
1088 : }
1089 282 : if (!baseURI.endsWith("/")) {
1090 : throw lang::IllegalArgumentException(
1091 : "DocumentMetadataAccess::loadMetadataFromStorage: "
1092 0 : "base URI does not end with slash", *this, 1);
1093 : }
1094 :
1095 282 : initLoading(*m_pImpl, i_xStorage, i_xBaseURI, i_xHandler);
1096 :
1097 564 : std::set< OUString > StgFiles;
1098 : collectFilesFromStorage(i_xStorage,
1099 282 : OUString(""), StgFiles);
1100 :
1101 564 : std::vector< OUString > MfstMetadataFiles;
1102 :
1103 : try {
1104 : const ::std::vector< uno::Reference< rdf::XURI > > parts(
1105 282 : getAllParts(*m_pImpl) );
1106 : const uno::Reference<rdf::XURI> xContentFile(
1107 564 : getURI<rdf::URIs::ODF_CONTENTFILE>(m_pImpl->m_xContext));
1108 : const uno::Reference<rdf::XURI> xStylesFile(
1109 564 : getURI<rdf::URIs::ODF_STYLESFILE>(m_pImpl->m_xContext));
1110 : const uno::Reference<rdf::XURI> xMetadataFile(
1111 564 : getURI<rdf::URIs::PKG_METADATAFILE>(m_pImpl->m_xContext));
1112 282 : const sal_Int32 len( baseURI.getLength() );
1113 2166 : for (::std::vector< uno::Reference< rdf::XURI > >::const_iterator it
1114 282 : = parts.begin();
1115 1444 : it != parts.end(); ++it) {
1116 440 : const OUString name((*it)->getStringValue());
1117 440 : if (!name.match(baseURI)) {
1118 : OSL_TRACE("loadMetadataFromStorage: graph not in document: %s",
1119 : OUStringToOString(name, RTL_TEXTENCODING_UTF8)
1120 : .getStr());
1121 0 : continue;
1122 : }
1123 880 : const OUString relName( name.copy(len) );
1124 440 : if (relName == s_manifest) {
1125 : OSL_TRACE("loadMetadataFromStorage: "
1126 : "found ourselves a recursive manifest!");
1127 0 : continue;
1128 : }
1129 : // remove found items from StgFiles
1130 440 : StgFiles.erase(relName);
1131 440 : if (isContentFile(relName)) {
1132 218 : if (!isPartOfType(*m_pImpl, *it, xContentFile)) {
1133 : const uno::Reference <rdf::XURI> xName(
1134 0 : getURIForStream(*m_pImpl, relName) );
1135 : // add missing type statement
1136 0 : m_pImpl->m_xManifest->addStatement(xName.get(),
1137 0 : getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext),
1138 0 : xContentFile.get());
1139 : }
1140 222 : } else if (isStylesFile(relName)) {
1141 218 : if (!isPartOfType(*m_pImpl, *it, xStylesFile)) {
1142 : const uno::Reference <rdf::XURI> xName(
1143 0 : getURIForStream(*m_pImpl, relName) );
1144 : // add missing type statement
1145 0 : m_pImpl->m_xManifest->addStatement(xName.get(),
1146 0 : getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext),
1147 0 : xStylesFile.get());
1148 : }
1149 4 : } else if (isReservedFile(relName)) {
1150 : OSL_TRACE("loadMetadataFromStorage: "
1151 : "reserved file name in manifest");
1152 : } else {
1153 4 : if (isPartOfType(*m_pImpl, *it, xMetadataFile)) {
1154 4 : MfstMetadataFiles.push_back(relName);
1155 : }
1156 : // do not add statement for MetadataFile; it could be
1157 : // something else! just ignore it...
1158 : }
1159 722 : }
1160 0 : } catch (const uno::RuntimeException &) {
1161 0 : throw;
1162 0 : } catch (const uno::Exception & e) {
1163 : throw lang::WrappedTargetRuntimeException(
1164 : "DocumentMetadataAccess::loadMetadataFromStorage: "
1165 0 : "exception", *this, uno::makeAny(e));
1166 : }
1167 :
1168 : std::for_each(StgFiles.begin(), StgFiles.end(),
1169 282 : boost::bind(addContentOrStylesFileImpl, boost::ref(*m_pImpl), _1));
1170 :
1171 : std::for_each(MfstMetadataFiles.begin(), MfstMetadataFiles.end(),
1172 282 : boost::bind(importFile, boost::ref(*m_pImpl),
1173 846 : i_xStorage, baseURI, i_xHandler, _1));
1174 282 : }
1175 :
1176 72 : void SAL_CALL DocumentMetadataAccess::storeMetadataToStorage(
1177 : const uno::Reference< embed::XStorage > & i_xStorage)
1178 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1179 : lang::WrappedTargetException, std::exception)
1180 : {
1181 72 : if (!i_xStorage.is()) {
1182 : throw lang::IllegalArgumentException(
1183 : "DocumentMetadataAccess::storeMetadataToStorage: "
1184 1 : "storage is null", *this, 0);
1185 : }
1186 :
1187 : // export manifest
1188 : const uno::Reference <rdf::XURI> xManifest(
1189 71 : getURIForStream(*m_pImpl, s_manifest) );
1190 142 : const OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() );
1191 : try {
1192 71 : writeStream(*m_pImpl, i_xStorage, xManifest, s_manifest, baseURI);
1193 0 : } catch (const uno::RuntimeException &) {
1194 0 : throw;
1195 0 : } catch (const io::IOException & e) {
1196 : throw lang::WrappedTargetException(
1197 0 : "storeMetadataToStorage: IO exception", *this, uno::makeAny(e));
1198 0 : } catch (const uno::Exception & e) {
1199 : throw lang::WrappedTargetRuntimeException(
1200 0 : "storeMetadataToStorage: exception", *this, uno::makeAny(e));
1201 : }
1202 :
1203 : // export metadata streams
1204 : try {
1205 : const uno::Sequence<uno::Reference<rdf::XURI> > graphs(
1206 71 : m_pImpl->m_xRepository->getGraphNames());
1207 71 : const sal_Int32 len( baseURI.getLength() );
1208 146 : for (sal_Int32 i = 0; i < graphs.getLength(); ++i) {
1209 75 : const uno::Reference<rdf::XURI> xName(graphs[i]);
1210 79 : const OUString name(xName->getStringValue());
1211 75 : if (!name.match(baseURI)) {
1212 : OSL_TRACE("storeMetadataToStorage: graph not in document: %s",
1213 : OUStringToOString(name, RTL_TEXTENCODING_UTF8)
1214 : .getStr());
1215 0 : continue;
1216 : }
1217 79 : const OUString relName( name.copy(len) );
1218 75 : if (relName == s_manifest) {
1219 71 : continue;
1220 : }
1221 4 : if (!isFileNameValid(relName) || isReservedFile(relName)) {
1222 : OSL_TRACE("storeMetadataToStorage: invalid file name: %s",
1223 : OUStringToOString(relName, RTL_TEXTENCODING_UTF8)
1224 : .getStr());
1225 0 : continue;
1226 : }
1227 : try {
1228 4 : writeStream(*m_pImpl, i_xStorage, xName, relName, baseURI);
1229 0 : } catch (const uno::RuntimeException &) {
1230 0 : throw;
1231 0 : } catch (const io::IOException & e) {
1232 : throw lang::WrappedTargetException(
1233 : "storeMetadataToStorage: IO exception",
1234 0 : *this, uno::makeAny(e));
1235 0 : } catch (const uno::Exception & e) {
1236 : throw lang::WrappedTargetRuntimeException(
1237 : "storeMetadataToStorage: exception",
1238 0 : *this, uno::makeAny(e));
1239 : }
1240 75 : }
1241 0 : } catch (const rdf::RepositoryException & e) {
1242 : throw lang::WrappedTargetRuntimeException(
1243 0 : "storeMetadataToStorage: exception", *this, uno::makeAny(e));
1244 71 : }
1245 71 : }
1246 :
1247 : void SAL_CALL
1248 4 : DocumentMetadataAccess::loadMetadataFromMedium(
1249 : const uno::Sequence< beans::PropertyValue > & i_rMedium)
1250 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1251 : lang::WrappedTargetException, std::exception)
1252 : {
1253 4 : uno::Reference<io::XInputStream> xIn;
1254 8 : utl::MediaDescriptor md(i_rMedium);
1255 8 : OUString URL;
1256 4 : md[ utl::MediaDescriptor::PROP_URL() ] >>= URL;
1257 8 : OUString BaseURL;
1258 4 : md[ utl::MediaDescriptor::PROP_DOCUMENTBASEURL() ] >>= BaseURL;
1259 4 : if (md.addInputStream()) {
1260 3 : md[ utl::MediaDescriptor::PROP_INPUTSTREAM() ] >>= xIn;
1261 : }
1262 4 : if (!xIn.is() && URL.isEmpty()) {
1263 : throw lang::IllegalArgumentException(
1264 : "DocumentMetadataAccess::loadMetadataFromMedium: "
1265 1 : "inalid medium: no URL, no input stream", *this, 0);
1266 : }
1267 6 : uno::Reference<embed::XStorage> xStorage;
1268 : try {
1269 3 : if (xIn.is()) {
1270 6 : xStorage = ::comphelper::OStorageHelper::GetStorageFromInputStream(
1271 6 : xIn, m_pImpl->m_xContext);
1272 : } else { // fallback to url
1273 0 : xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2(
1274 0 : URL, embed::ElementModes::READ, m_pImpl->m_xContext);
1275 : }
1276 0 : } catch (const uno::RuntimeException &) {
1277 0 : throw;
1278 0 : } catch (const io::IOException &) {
1279 0 : throw;
1280 0 : } catch (const uno::Exception & e) {
1281 : throw lang::WrappedTargetException(
1282 : "DocumentMetadataAccess::loadMetadataFromMedium: "
1283 0 : "exception", *this, uno::makeAny(e));
1284 : }
1285 3 : if (!xStorage.is()) {
1286 : throw uno::RuntimeException(
1287 : "DocumentMetadataAccess::loadMetadataFromMedium: "
1288 0 : "cannot get Storage", *this);
1289 : }
1290 6 : uno::Reference<rdf::XURI> xBaseURI;
1291 : try {
1292 3 : xBaseURI = createBaseURI(m_pImpl->m_xContext, xStorage, BaseURL);
1293 3 : } catch (const uno::Exception &) {
1294 : // fall back to URL
1295 : try {
1296 3 : xBaseURI = createBaseURI(m_pImpl->m_xContext, xStorage, URL);
1297 0 : } catch (const uno::Exception &) {
1298 : OSL_FAIL("cannot create base URI");
1299 : }
1300 : }
1301 6 : uno::Reference<task::XInteractionHandler> xIH;
1302 3 : md[ utl::MediaDescriptor::PROP_INTERACTIONHANDLER() ] >>= xIH;
1303 7 : loadMetadataFromStorage(xStorage, xBaseURI, xIH);
1304 3 : }
1305 :
1306 : void SAL_CALL
1307 2 : DocumentMetadataAccess::storeMetadataToMedium(
1308 : const uno::Sequence< beans::PropertyValue > & i_rMedium)
1309 : throw (uno::RuntimeException, lang::IllegalArgumentException,
1310 : lang::WrappedTargetException, std::exception)
1311 : {
1312 2 : utl::MediaDescriptor md(i_rMedium);
1313 4 : OUString URL;
1314 2 : md[ utl::MediaDescriptor::PROP_URL() ] >>= URL;
1315 2 : if (URL.isEmpty()) {
1316 : throw lang::IllegalArgumentException(
1317 : "DocumentMetadataAccess::storeMetadataToMedium: "
1318 1 : "invalid medium: no URL", *this, 0);
1319 : }
1320 :
1321 2 : SfxMedium aMedium(i_rMedium);
1322 2 : uno::Reference<embed::XStorage> xStorage(aMedium.GetOutputStorage());
1323 :
1324 1 : bool sfx(false);
1325 1 : if (xStorage.is()) {
1326 1 : sfx = true;
1327 : } else {
1328 0 : xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2(
1329 0 : URL, embed::ElementModes::WRITE, m_pImpl->m_xContext);
1330 : }
1331 :
1332 1 : if (!xStorage.is()) {
1333 : throw uno::RuntimeException(
1334 : "DocumentMetadataAccess::storeMetadataToMedium: "
1335 0 : "cannot get Storage", *this);
1336 : }
1337 : // set MIME type of the storage
1338 : utl::MediaDescriptor::const_iterator iter
1339 1 : = md.find(utl::MediaDescriptor::PROP_MEDIATYPE());
1340 1 : if (iter != md.end()) {
1341 : uno::Reference< beans::XPropertySet > xProps(xStorage,
1342 1 : uno::UNO_QUERY_THROW);
1343 : try {
1344 : // this is NOT supported in FileSystemStorage
1345 1 : xProps->setPropertyValue(
1346 1 : utl::MediaDescriptor::PROP_MEDIATYPE(),
1347 2 : iter->second);
1348 1 : } catch (const uno::Exception &) { }
1349 : }
1350 1 : storeMetadataToStorage(xStorage);
1351 :
1352 1 : if (sfx) {
1353 1 : const bool bOk = aMedium.Commit();
1354 1 : aMedium.Close();
1355 1 : if ( !bOk ) {
1356 0 : sal_uInt32 nError = aMedium.GetError();
1357 0 : if ( nError == ERRCODE_NONE ) {
1358 0 : nError = ERRCODE_IO_GENERAL;
1359 : }
1360 : task::ErrorCodeIOException ex(
1361 : ("DocumentMetadataAccess::storeMetadataToMedium Commit failed: "
1362 0 : "0x" + OUString::number(nError, 16)),
1363 0 : uno::Reference< uno::XInterface >(), nError);
1364 : throw lang::WrappedTargetException(OUString(), *this,
1365 0 : uno::makeAny(ex));
1366 : }
1367 2 : }
1368 1 : }
1369 :
1370 648 : } // namespace sfx2
1371 :
1372 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
