?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix baseline build (old cairo) - 'cairo_rectangle_int_t' does not name a type
[LibreOffice.git] / ucb / source / ucp / webdav / webdavcontent.cxx
blob70f84047aa7ccdcac106cc1e9089ca68481640d0
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 #include <osl/diagnose.h>
21 #include <osl/doublecheckedlocking.h>
22 #include <rtl/uri.hxx>
23 #include <rtl/ustrbuf.hxx>
24 #include <ucbhelper/contentidentifier.hxx>
25 #include <ucbhelper/propertyvalueset.hxx>
26 #include <ucbhelper/simpleinteractionrequest.hxx>
27 #include <ucbhelper/cancelcommandexecution.hxx>
28
29 #include <com/sun/star/beans/PropertyAttribute.hpp>
30 #include <com/sun/star/beans/PropertySetInfoChange.hpp>
31 #include <com/sun/star/beans/PropertySetInfoChangeEvent.hpp>
32 #include <com/sun/star/beans/PropertyValue.hpp>
33 #include <com/sun/star/io/XActiveDataSink.hpp>
34 #include <com/sun/star/io/XOutputStream.hpp>
35 #include <com/sun/star/lang/IllegalAccessException.hpp>
36 #include <com/sun/star/task/PasswordContainerInteractionHandler.hpp>
37 #include <com/sun/star/ucb/CommandEnvironment.hpp>
38 #include <com/sun/star/ucb/CommandFailedException.hpp>
39 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
40 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
41 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
42 #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
43 #include <com/sun/star/ucb/InteractiveLockingLockedException.hpp>
44 #include <com/sun/star/ucb/InteractiveLockingLockExpiredException.hpp>
45 #include <com/sun/star/ucb/InteractiveLockingNotLockedException.hpp>
46 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
47 #include <com/sun/star/ucb/InteractiveNetworkGeneralException.hpp>
48 #include <com/sun/star/ucb/InteractiveNetworkReadException.hpp>
49 #include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp>
50 #include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp>
51 #include <com/sun/star/ucb/MissingInputStreamException.hpp>
52 #include <com/sun/star/ucb/MissingPropertiesException.hpp>
53 #include <com/sun/star/ucb/NameClash.hpp>
54 #include <com/sun/star/ucb/NameClashException.hpp>
55 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
56 #include <com/sun/star/ucb/OpenMode.hpp>
57 #include <com/sun/star/ucb/PostCommandArgument2.hpp>
58 #include <com/sun/star/ucb/PropertyCommandArgument.hpp>
59 #include <com/sun/star/ucb/TransferInfo.hpp>
60 #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
61 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
62 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
63 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
64 #include <com/sun/star/ucb/XCommandInfo.hpp>
65 #include <com/sun/star/ucb/XPersistentPropertySet.hpp>
66 #include <com/sun/star/uno/XComponentContext.hpp>
67
68 #include "webdavcontent.hxx"
69 #include "webdavprovider.hxx"
70 #include "webdavresultset.hxx"
71 #include "ContentProperties.hxx"
72 #include "SerfUri.hxx"
73 #include "UCBDeadPropertyValue.hxx"
74
75 using namespace com::sun::star;
76 using namespace http_dav_ucp;
77
78 namespace
79 {
80 static void lcl_sendPartialGETRequest( bool &bError,
81 DAVException &aLastException,
82 const std::vector< rtl::OUString >& rProps,
83 std::vector< rtl::OUString > &aHeaderNames,
84 const boost::scoped_ptr< DAVResourceAccess > &xResAccess,
85 boost::scoped_ptr< ContentProperties > &xProps,
86 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
87 {
88 bool bIsRequestSize = false;
89 DAVResource aResource;
90 DAVRequestHeaders aPartialGet;
91 aPartialGet.push_back(
92 DAVRequestHeader(
93 OUString( "Range" ),
94 OUString( "bytes=0-0" )));
95
96 for ( std::vector< rtl::OUString >::const_iterator it = aHeaderNames.begin();
97 it != aHeaderNames.end(); ++it )
98 {
99 if ( *it == "Content-Length" )
100 {
101 bIsRequestSize = true;
102 break;
103 }
104 }
105
106 if ( bIsRequestSize )
107 {
108 // we need to know if the server accepts range requests for a resource
109 // and the range unit it uses
110 aHeaderNames.push_back( OUString( "Accept-Ranges" ) );
111 aHeaderNames.push_back( OUString( "Content-Range" ) );
112 }
113 try
114 {
115 uno::Reference< io::XInputStream > xIn = xResAccess->GET( aPartialGet,
116 aHeaderNames,
117 aResource,
118 xEnv );
119 bError = false;
120
121 if ( bIsRequestSize )
122 {
123 // the ContentProperties maps "Content-Length" to the UCB "Size" property
124 // This would have an unrealistic value of 1 byte because we did only a partial GET
125 // Solution: if "Content-Range" is present, map it with UCB "Size" property
126 rtl::OUString aAcceptRanges, aContentRange, aContentLength;
127 std::vector< DAVPropertyValue > &aResponseProps = aResource.properties;
128 for ( std::vector< DAVPropertyValue >::const_iterator it = aResponseProps.begin();
129 it != aResponseProps.end(); ++it )
130 {
131 if ( it->Name == "Accept-Ranges" )
132 it->Value >>= aAcceptRanges;
133 else if ( it->Name == "Content-Range" )
134 it->Value >>= aContentRange;
135 else if ( it->Name == "Content-Length" )
136 it->Value >>= aContentLength;
137 }
138
139 sal_Int64 nSize = 1;
140 if ( aContentLength.getLength() )
141 {
142 nSize = aContentLength.toInt64();
143 }
144
145 // according to http://tools.ietf.org/html/rfc2616#section-3.12
146 // the only range unit defined is "bytes" and implementations
147 // MAY ignore ranges specified using other units.
148 if ( nSize == 1 &&
149 aContentRange.getLength() &&
150 aAcceptRanges == "bytes" )
151 {
152 // Parse the Content-Range to get the size
153 // vid. http://tools.ietf.org/html/rfc2616#section-14.16
154 // Content-Range: <range unit> <bytes range>/<size>
155 sal_Int32 nSlash = aContentRange.lastIndexOf( '/' );
156 if ( nSlash != -1 )
157 {
158 rtl::OUString aSize = aContentRange.copy( nSlash + 1 );
159 // "*" means that the instance-length is unknown at the time when the response was generated
160 if ( aSize != "*" )
161 {
162 for ( std::vector< DAVPropertyValue >::iterator it = aResponseProps.begin();
163 it != aResponseProps.end(); ++it )
164 {
165 if (it->Name == "Content-Length")
166 {
167 it->Value <<= aSize;
168 break;
169 }
170 }
171 }
172 }
173 }
174 }
175
176 if ( xProps.get() )
177 xProps->addProperties(
178 rProps,
179 ContentProperties( aResource ) );
180 else
181 xProps.reset ( new ContentProperties( aResource ) );
182 }
183 catch ( DAVException const & ex )
184 {
185 aLastException = ex;
186 }
187 }
188 }
189
190
191
192
193 // Content Implementation.
194
195
196
197
198
199 // ctr for content on an existing webdav resource
200 Content::Content(
201 const uno::Reference< uno::XComponentContext >& rxContext,
202 ContentProvider* pProvider,
203 const uno::Reference< ucb::XContentIdentifier >& Identifier,
204 rtl::Reference< DAVSessionFactory > const & rSessionFactory )
205 throw ( ucb::ContentCreationException )
206 : ContentImplHelper( rxContext, pProvider, Identifier ),
207 m_eResourceType( UNKNOWN ),
208 m_pProvider( pProvider ),
209 m_bTransient( false ),
210 m_bLocked( false ),
211 m_bCollection( false ),
212 m_bDidGetOrHead( false )
213 {
214 try
215 {
216 m_xResAccess.reset( new DAVResourceAccess(
217 rxContext,
218 rSessionFactory,
219 Identifier->getContentIdentifier() ) );
220
221 SerfUri aURI( Identifier->getContentIdentifier() );
222 m_aEscapedTitle = aURI.GetPathBaseName();
223 }
224 catch ( DAVException const & )
225 {
226 throw ucb::ContentCreationException();
227 }
228 }
229
230
231 // ctr for content on an non-existing webdav resource
232 Content::Content(
233 const uno::Reference< uno::XComponentContext >& rxContext,
234 ContentProvider* pProvider,
235 const uno::Reference< ucb::XContentIdentifier >& Identifier,
236 rtl::Reference< DAVSessionFactory > const & rSessionFactory,
237 bool isCollection )
238 throw ( ucb::ContentCreationException )
239 : ContentImplHelper( rxContext, pProvider, Identifier ),
240 m_eResourceType( UNKNOWN ),
241 m_pProvider( pProvider ),
242 m_bTransient( true ),
243 m_bLocked( false ),
244 m_bCollection( isCollection ),
245 m_bDidGetOrHead( false )
246 {
247 try
248 {
249 m_xResAccess.reset( new DAVResourceAccess(
250 rxContext, rSessionFactory, Identifier->getContentIdentifier() ) );
251 }
252 catch ( DAVException const & )
253 {
254 throw ucb::ContentCreationException();
255 }
256
257 // Do not set m_aEscapedTitle here! Content::insert relays on this!!!
258 }
259
260
261 // virtual
262 Content::~Content()
263 {
264 if (m_bLocked)
265 unlock(uno::Reference< ucb::XCommandEnvironment >());
266 }
267
268
269
270 // XInterface methods.
271
272
273
274 // virtual
275 void SAL_CALL Content::acquire()
276 throw( )
277 {
278 ContentImplHelper::acquire();
279 }
280
281
282 // virtual
283 void SAL_CALL Content::release()
284 throw( )
285 {
286 ContentImplHelper::release();
287 }
288
289
290 // virtual
291 uno::Any SAL_CALL Content::queryInterface( const uno::Type & rType )
292 throw ( uno::RuntimeException, std::exception )
293 {
294 // Note: isFolder may require network activities! So call it only
295 // if it is really necessary!!!
296 uno::Any aRet = cppu::queryInterface(
297 rType,
298 static_cast< ucb::XContentCreator * >( this ) );
299 if ( aRet.hasValue() )
300 {
301 try
302 {
303 uno::Reference< beans::XPropertySet > const xProps(
304 m_xContext, uno::UNO_QUERY_THROW );
305 uno::Reference< uno::XComponentContext > xCtx;
306 xCtx.set( xProps->getPropertyValue(
307 OUString( "DefaultContext" ) ),
308 uno::UNO_QUERY_THROW );
309
310 uno::Reference< task::XInteractionHandler > xIH(
311 task::PasswordContainerInteractionHandler::create( xCtx ) );
312
313 // Supply a command env to isFolder() that contains an interaction
314 // handler that uses the password container service to obtain
315 // credentials without displaying a password gui.
316
317 uno::Reference< ucb::XCommandEnvironment > xCmdEnv(
318 ucb::CommandEnvironment::create(
319 xCtx,
320 xIH,
321 uno::Reference< ucb::XProgressHandler >() ) );
322
323 return isFolder( xCmdEnv ) ? aRet : uno::Any();
324 }
325 catch ( uno::RuntimeException const & )
326 {
327 throw;
328 }
329 catch ( uno::Exception const & )
330 {
331 return uno::Any();
332 }
333 }
334 return aRet.hasValue() ? aRet : ContentImplHelper::queryInterface( rType );
335 }
336
337
338
339 // XTypeProvider methods.
340
341
342
343 XTYPEPROVIDER_COMMON_IMPL( Content );
344
345
346 // virtual
347 uno::Sequence< uno::Type > SAL_CALL Content::getTypes()
348 throw( uno::RuntimeException, std::exception )
349 {
350 bool bFolder = false;
351 try
352 {
353 bFolder
354 = isFolder( uno::Reference< ucb::XCommandEnvironment >() );
355 }
356 catch ( uno::RuntimeException const & )
357 {
358 throw;
359 }
360 catch ( uno::Exception const & )
361 {
362 }
363
364 cppu::OTypeCollection * pCollection = 0;
365
366 if ( bFolder )
367 {
368 static cppu::OTypeCollection* pFolderTypes = 0;
369
370 pCollection = pFolderTypes;
371 if ( !pCollection )
372 {
373 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
374
375 pCollection = pFolderTypes;
376 if ( !pCollection )
377 {
378 static cppu::OTypeCollection aCollection(
379 CPPU_TYPE_REF( lang::XTypeProvider ),
380 CPPU_TYPE_REF( lang::XServiceInfo ),
381 CPPU_TYPE_REF( lang::XComponent ),
382 CPPU_TYPE_REF( ucb::XContent ),
383 CPPU_TYPE_REF( ucb::XCommandProcessor ),
384 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
385 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
386 CPPU_TYPE_REF( beans::XPropertyContainer ),
387 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
388 CPPU_TYPE_REF( container::XChild ),
389 CPPU_TYPE_REF( ucb::XContentCreator ) ); // !!
390 pCollection = &aCollection;
391 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
392 pFolderTypes = pCollection;
393 }
394 }
395 else {
396 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
397 }
398 }
399 else
400 {
401 static cppu::OTypeCollection* pDocumentTypes = 0;
402
403 pCollection = pDocumentTypes;
404 if ( !pCollection )
405 {
406 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
407
408 pCollection = pDocumentTypes;
409 if ( !pCollection )
410 {
411 static cppu::OTypeCollection aCollection(
412 CPPU_TYPE_REF( lang::XTypeProvider ),
413 CPPU_TYPE_REF( lang::XServiceInfo ),
414 CPPU_TYPE_REF( lang::XComponent ),
415 CPPU_TYPE_REF( ucb::XContent ),
416 CPPU_TYPE_REF( ucb::XCommandProcessor ),
417 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
418 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
419 CPPU_TYPE_REF( beans::XPropertyContainer ),
420 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
421 CPPU_TYPE_REF( container::XChild ) );
422 pCollection = &aCollection;
423 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
424 pDocumentTypes = pCollection;
425 }
426 }
427 else {
428 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
429 }
430 }
431
432 return (*pCollection).getTypes();
433 }
434
435
436
437 // XServiceInfo methods.
438
439
440
441 // virtual
442 OUString SAL_CALL Content::getImplementationName()
443 throw( uno::RuntimeException )
444 {
445 return OUString( "com.sun.star.comp.ucb.WebDAVContent" );
446 }
447
448
449 // virtual
450 uno::Sequence< OUString > SAL_CALL Content::getSupportedServiceNames()
451 throw( uno::RuntimeException )
452 {
453 uno::Sequence< OUString > aSNS( 1 );
454 aSNS.getArray()[ 0 ] = WEBDAV_CONTENT_SERVICE_NAME;
455 return aSNS;
456 }
457
458
459
460 // XContent methods.
461
462
463
464 // virtual
465 OUString SAL_CALL Content::getContentType()
466 throw( uno::RuntimeException )
467 {
468 bool bFolder = false;
469 try
470 {
471 bFolder
472 = isFolder( uno::Reference< ucb::XCommandEnvironment >() );
473 }
474 catch ( uno::RuntimeException const & )
475 {
476 throw;
477 }
478 catch ( uno::Exception const & )
479 {
480 }
481
482 if ( bFolder )
483 return OUString( WEBDAV_COLLECTION_TYPE );
484
485 return OUString( WEBDAV_CONTENT_TYPE );
486 }
487
488
489
490 // XCommandProcessor methods.
491
492
493
494 // virtual
495 uno::Any SAL_CALL Content::execute(
496 const ucb::Command& aCommand,
497 sal_Int32 /*CommandId*/,
498 const uno::Reference< ucb::XCommandEnvironment >& Environment )
499 throw( uno::Exception,
500 ucb::CommandAbortedException,
501 uno::RuntimeException )
502 {
503 SAL_INFO("ucb.ucp.webdav", ">>>>> Content::execute: start: command: " << aCommand.Name
504 << ", env: " << (Environment.is() ? "present" : "missing") );
505
506 uno::Any aRet;
507
508 if ( aCommand.Name == "getPropertyValues" )
509 {
510
511 // getPropertyValues
512
513
514 uno::Sequence< beans::Property > Properties;
515 if ( !( aCommand.Argument >>= Properties ) )
516 {
517 ucbhelper::cancelCommandExecution(
518 uno::makeAny( lang::IllegalArgumentException(
519 OUString( "Wrong argument type!" ),
520 static_cast< cppu::OWeakObject * >( this ),
521 -1 ) ),
522 Environment );
523 // Unreachable
524 }
525
526 aRet <<= getPropertyValues( Properties, Environment );
527 }
528 else if ( aCommand.Name == "setPropertyValues" )
529 {
530
531 // setPropertyValues
532
533
534 uno::Sequence< beans::PropertyValue > aProperties;
535 if ( !( aCommand.Argument >>= aProperties ) )
536 {
537 ucbhelper::cancelCommandExecution(
538 uno::makeAny( lang::IllegalArgumentException(
539 OUString( "Wrong argument type!" ),
540 static_cast< cppu::OWeakObject * >( this ),
541 -1 ) ),
542 Environment );
543 // Unreachable
544 }
545
546 if ( !aProperties.getLength() )
547 {
548 ucbhelper::cancelCommandExecution(
549 uno::makeAny( lang::IllegalArgumentException(
550 OUString( "No properties!" ),
551 static_cast< cppu::OWeakObject * >( this ),
552 -1 ) ),
553 Environment );
554 // Unreachable
555 }
556
557 aRet <<= setPropertyValues( aProperties, Environment );
558 }
559 else if ( aCommand.Name == "getPropertySetInfo" )
560 {
561
562 // getPropertySetInfo
563
564
565 // Note: Implemented by base class.
566 aRet <<= getPropertySetInfo( Environment,
567 false /* don't cache data */ );
568 }
569 else if ( aCommand.Name == "getCommandInfo" )
570 {
571
572 // getCommandInfo
573
574
575 // Note: Implemented by base class.
576 aRet <<= getCommandInfo( Environment, false );
577 }
578 else if ( aCommand.Name == "open" )
579 {
580
581 // open
582
583
584 ucb::OpenCommandArgument2 aOpenCommand;
585 if ( !( aCommand.Argument >>= aOpenCommand ) )
586 {
587 ucbhelper::cancelCommandExecution(
588 uno::makeAny( lang::IllegalArgumentException(
589 OUString( "Wrong argument type!" ),
590 static_cast< cppu::OWeakObject * >( this ),
591 -1 ) ),
592 Environment );
593 // Unreachable
594 }
595
596 aRet = open( aOpenCommand, Environment );
597
598 if ( (aOpenCommand.Mode == ucb::OpenMode::DOCUMENT ||
599 aOpenCommand.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE) &&
600 supportsExclusiveWriteLock( Environment ) )
601 lock( Environment );
602 }
603 else if ( aCommand.Name == "insert" )
604 {
605
606 // insert
607
608
609 ucb::InsertCommandArgument arg;
610 if ( !( aCommand.Argument >>= arg ) )
611 {
612 ucbhelper::cancelCommandExecution(
613 uno::makeAny( lang::IllegalArgumentException(
614 OUString( "Wrong argument type!" ),
615 static_cast< cppu::OWeakObject * >( this ),
616 -1 ) ),
617 Environment );
618 // Unreachable
619 }
620
621 insert( arg.Data, arg.ReplaceExisting, Environment );
622 }
623 else if ( aCommand.Name == "delete" )
624 {
625
626 // delete
627
628
629 bool bDeletePhysical = false;
630 aCommand.Argument >>= bDeletePhysical;
631
632 // KSO: Ignore parameter and destroy the content, if you don't support
633 // putting objects into trashcan. ( Since we do not have a trash can
634 // service yet (src603), you actually have no other choice. )
635 // if ( bDeletePhysical )
636 // {
637 try
638 {
639 boost::scoped_ptr< DAVResourceAccess > xResAccess;
640 {
641 osl::Guard< osl::Mutex > aGuard( m_aMutex );
642 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
643 }
644 xResAccess->DESTROY( Environment );
645 {
646 osl::Guard< osl::Mutex > aGuard( m_aMutex );
647 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
648 }
649 }
650 catch ( DAVException const & e )
651 {
652 cancelCommandExecution( e, Environment, true );
653 // Unreachable
654 }
655 // }
656
657 // Propagate destruction.
658 destroy( bDeletePhysical );
659
660 // Remove own and all children's Additional Core Properties.
661 removeAdditionalPropertySet( true );
662 }
663 else if ( aCommand.Name == "transfer" && isFolder( Environment ) )
664 {
665
666 // transfer
667 // ( Not available at documents )
668
669
670 ucb::TransferInfo transferArgs;
671 if ( !( aCommand.Argument >>= transferArgs ) )
672 {
673 ucbhelper::cancelCommandExecution(
674 uno::makeAny( lang::IllegalArgumentException(
675 OUString( "Wrong argument type!" ),
676 static_cast< cppu::OWeakObject * >( this ),
677 -1 ) ),
678 Environment );
679 // Unreachable
680 }
681
682 transfer( transferArgs, Environment );
683 }
684 else if ( aCommand.Name == "post" )
685 {
686
687 // post
688
689
690 ucb::PostCommandArgument2 aArg;
691 if ( !( aCommand.Argument >>= aArg ) )
692 {
693 ucbhelper::cancelCommandExecution(
694 uno::makeAny( lang::IllegalArgumentException(
695 OUString( "Wrong argument type!" ),
696 static_cast< cppu::OWeakObject * >( this ),
697 -1 ) ),
698 Environment );
699 // Unreachable
700 }
701
702 post( aArg, Environment );
703 }
704 else if ( aCommand.Name == "lock" &&
705 supportsExclusiveWriteLock( Environment ) )
706 {
707
708 // lock
709
710
711 lock( Environment );
712 }
713 else if ( aCommand.Name == "unlock" &&
714 supportsExclusiveWriteLock( Environment ) )
715 {
716
717 // unlock
718
719
720 unlock( Environment );
721 }
722 else if ( aCommand.Name == "createNewContent" &&
723 isFolder( Environment ) )
724 {
725
726 // createNewContent
727
728
729 ucb::ContentInfo aArg;
730 if ( !( aCommand.Argument >>= aArg ) )
731 {
732 ucbhelper::cancelCommandExecution(
733 uno::makeAny( lang::IllegalArgumentException(
734 OUString( "Wrong argument type!" ),
735 static_cast< cppu::OWeakObject * >( this ),
736 -1 ) ),
737 Environment );
738 // Unreachable
739 }
740
741 aRet = uno::makeAny( createNewContent( aArg ) );
742 }
743 else if ( aCommand.Name == "addProperty" )
744 {
745 ucb::PropertyCommandArgument aPropArg;
746 if ( !( aCommand.Argument >>= aPropArg ))
747 {
748 ucbhelper::cancelCommandExecution(
749 uno::makeAny( lang::IllegalArgumentException(
750 OUString( "Wrong argument type!" ),
751 static_cast< cppu::OWeakObject * >( this ),
752 -1 ) ),
753 Environment );
754 }
755
756 // TODO when/if XPropertyContainer is removed,
757 // the command execution can be canceled in addProperty
758 try
759 {
760 addProperty( aPropArg, Environment );
761 }
762 catch ( const beans::PropertyExistException &e )
763 {
764 ucbhelper::cancelCommandExecution( uno::makeAny( e ), Environment );
765 }
766 catch ( const beans::IllegalTypeException&e )
767 {
768 ucbhelper::cancelCommandExecution( uno::makeAny( e ), Environment );
769 }
770 catch ( const lang::IllegalArgumentException&e )
771 {
772 ucbhelper::cancelCommandExecution( uno::makeAny( e ), Environment );
773 }
774 }
775 else if ( aCommand.Name == "removeProperty" )
776 {
777 rtl::OUString sPropName;
778 if ( !( aCommand.Argument >>= sPropName ) )
779 {
780 ucbhelper::cancelCommandExecution(
781 uno::makeAny( lang::IllegalArgumentException(
782 OUString( "Wrong argument type!" ),
783 static_cast< cppu::OWeakObject * >( this ),
784 -1 ) ),
785 Environment );
786 }
787
788 // TODO when/if XPropertyContainer is removed,
789 // the command execution can be canceled in removeProperty
790 try
791 {
792 removeProperty( sPropName, Environment );
793 }
794 catch( const beans::UnknownPropertyException &e )
795 {
796 ucbhelper::cancelCommandExecution( uno::makeAny( e ), Environment );
797 }
798 catch( const beans::NotRemoveableException &e )
799 {
800 ucbhelper::cancelCommandExecution( uno::makeAny( e ), Environment );
801 }
802 }
803 else
804 {
805
806 // Unsupported command
807
808
809 ucbhelper::cancelCommandExecution(
810 uno::makeAny( ucb::UnsupportedCommandException(
811 aCommand.Name,
812 static_cast< cppu::OWeakObject * >( this ) ) ),
813 Environment );
814 // Unreachable
815 }
816
817 SAL_INFO("ucb.ucp.webdav", "<<<<< Content::execute: end: command: " << aCommand.Name);
818 return aRet;
819 }
820
821
822 // virtual
823 void SAL_CALL Content::abort( sal_Int32 /*CommandId*/ )
824 throw( uno::RuntimeException )
825 {
826 try
827 {
828 boost::scoped_ptr< DAVResourceAccess > xResAccess;
829 {
830 osl::MutexGuard aGuard( m_aMutex );
831 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
832 }
833 xResAccess->abort();
834 {
835 osl::Guard< osl::Mutex > aGuard( m_aMutex );
836 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
837 }
838 }
839 catch ( DAVException const & )
840 {
841 // abort failed!
842 }
843 }
844
845
846
847 // XPropertyContainer methods.
848
849
850
851 void Content::addProperty( const com::sun::star::ucb::PropertyCommandArgument &aCmdArg,
852 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
853 throw( beans::PropertyExistException,
854 beans::IllegalTypeException,
855 lang::IllegalArgumentException,
856 uno::RuntimeException )
857 {
858 // if ( m_bTransient )
859 // @@@ ???
860 const beans::Property aProperty = aCmdArg.Property;
861 const uno::Any aDefaultValue = aCmdArg.DefaultValue;
862
863 // check property Name
864 if ( !aProperty.Name.getLength() )
865 throw lang::IllegalArgumentException(
866 OUString( "\"addProperty\" with empty Property.Name"),
867 static_cast< ::cppu::OWeakObject * >( this ),
868 -1 );
869
870 // Check property type.
871 if ( !UCBDeadPropertyValue::supportsType( aProperty.Type ) )
872 throw beans::IllegalTypeException(
873 OUString( "\"addProperty\" unsupported Property.Type"),
874 static_cast< ::cppu::OWeakObject * >( this ) );
875
876 // check default value
877 if ( aDefaultValue.hasValue() && aDefaultValue.getValueType() != aProperty.Type )
878 throw beans::IllegalTypeException(
879 OUString( "\"addProperty\" DefaultValue does not match Property.Type"),
880 static_cast< ::cppu::OWeakObject * >( this ) );
881
882
883 // Make sure a property with the requested name does not already
884 // exist in dynamic and static(!) properties.
885
886
887 // Take into account special properties with custom namespace
888 // using <prop:the_propname xmlns:prop="the_namespace">
889 rtl::OUString aSpecialName;
890 bool bIsSpecial = DAVProperties::isUCBSpecialProperty( aProperty.Name, aSpecialName );
891
892 // Note: This requires network access!
893 if ( getPropertySetInfo( xEnv, false /* don't cache data */ )
894 ->hasPropertyByName( bIsSpecial ? aSpecialName : aProperty.Name ) )
895 {
896 // Property does already exist.
897 throw beans::PropertyExistException();
898 }
899
900
901 // Add a new dynamic property.
902
903
904 ProppatchValue aValue( PROPSET, aProperty.Name, aDefaultValue );
905
906 std::vector< ProppatchValue > aProppatchValues;
907 aProppatchValues.push_back( aValue );
908
909 try
910 {
911 // Set property value at server.
912 boost::scoped_ptr< DAVResourceAccess > xResAccess;
913 {
914 osl::Guard< osl::Mutex > aGuard( m_aMutex );
915 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
916 }
917 xResAccess->PROPPATCH( aProppatchValues, xEnv );
918 {
919 osl::Guard< osl::Mutex > aGuard( m_aMutex );
920 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
921 }
922
923 // Notify propertyset info change listeners.
924 beans::PropertySetInfoChangeEvent evt(
925 static_cast< cppu::OWeakObject * >( this ),
926 bIsSpecial ? aSpecialName : aProperty.Name,
927 -1, // No handle available
928 beans::PropertySetInfoChange::PROPERTY_INSERTED );
929 notifyPropertySetInfoChange( evt );
930 }
931 catch ( DAVException const & e )
932 {
933 if ( e.getStatus() == SC_FORBIDDEN )
934 {
935 // Support for setting arbitrary dead properties is optional!
936
937 // Store property locally.
938 ContentImplHelper::addProperty( bIsSpecial ? aSpecialName : aProperty.Name,
939 aProperty.Attributes,
940 aDefaultValue );
941 }
942 else
943 {
944 if ( shouldAccessNetworkAfterException( e ) )
945 {
946 try
947 {
948 const ResourceType & rType = getResourceType( xEnv );
949 switch ( rType )
950 {
951 case UNKNOWN:
952 case DAV:
953 throw lang::IllegalArgumentException();
954
955 case NON_DAV:
956 // Store property locally.
957 ContentImplHelper::addProperty( bIsSpecial ? aSpecialName : aProperty.Name,
958 aProperty.Attributes,
959 aDefaultValue );
960 break;
961
962 default:
963 SAL_WARN( "ucb.ucp.webdav",
964 "Content::addProperty - "
965 "Unsupported resource type!" );
966 break;
967 }
968 }
969 catch ( uno::Exception const & )
970 {
971 SAL_WARN( "ucb.ucp.webdav",
972 "Content::addProperty - "
973 "Unable to determine resource type!" );
974 }
975 }
976 else
977 {
978 SAL_WARN( "ucb.ucp.webdav",
979 "Content::addProperty - "
980 "Unable to determine resource type!" );
981 }
982 }
983 }
984 }
985
986 void Content::removeProperty( const rtl::OUString& Name,
987 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
988 throw( beans::UnknownPropertyException,
989 beans::NotRemoveableException,
990 uno::RuntimeException )
991 {
992 #if 0
993 // @@@ REMOVABLE at the moment not properly set in the PropSetInfo
994 try
995 {
996 beans::Property aProp
997 = getPropertySetInfo( xEnv, false /* don't cache data */ )
998 ->getPropertyByName( Name );
999
1000 if ( !( aProp.Attributes & beans::PropertyAttribute::REMOVABLE ) )
1001 {
1002 // Not removable!
1003 throw beans::NotRemoveableException();
1004 }
1005 }
1006 catch ( beans::UnknownPropertyException const & )
1007 {
1008 //SAL_WARN( "ucb.ucp.webdav", "removeProperty - Unknown property!" );
1009 throw;
1010 }
1011 #endif
1012
1013 // Try to remove property from server.
1014 try
1015 {
1016 std::vector< ProppatchValue > aProppatchValues;
1017 ProppatchValue aValue( PROPREMOVE, Name, uno::Any() );
1018 aProppatchValues.push_back( aValue );
1019
1020 // Remove property value from server.
1021 boost::scoped_ptr< DAVResourceAccess > xResAccess;
1022 {
1023 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1024 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
1025 }
1026 xResAccess->PROPPATCH( aProppatchValues, xEnv );
1027 {
1028 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1029 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
1030 }
1031
1032 // Notify propertyset info change listeners.
1033 beans::PropertySetInfoChangeEvent evt(
1034 static_cast< cppu::OWeakObject * >( this ),
1035 Name,
1036 -1, // No handle available
1037 beans::PropertySetInfoChange::PROPERTY_REMOVED );
1038 notifyPropertySetInfoChange( evt );
1039 }
1040 catch ( DAVException const & e )
1041 {
1042 if ( e.getStatus() == SC_FORBIDDEN )
1043 {
1044 // Support for setting arbitrary dead properties is optional!
1045
1046 // Try to remove property from local store.
1047 ContentImplHelper::removeProperty( Name );
1048 }
1049 else
1050 {
1051 if ( shouldAccessNetworkAfterException( e ) )
1052 {
1053 try
1054 {
1055 const ResourceType & rType = getResourceType( xEnv );
1056 switch ( rType )
1057 {
1058 case UNKNOWN:
1059 case DAV:
1060 throw beans::UnknownPropertyException();
1061
1062 case NON_DAV:
1063 // Try to remove property from local store.
1064 ContentImplHelper::removeProperty( Name );
1065 break;
1066
1067 default:
1068 SAL_WARN( "ucb.ucp.webdav",
1069 "Content::removeProperty - "
1070 "Unsupported resource type!" );
1071 break;
1072 }
1073 }
1074 catch ( uno::Exception const & )
1075 {
1076 SAL_WARN( "ucb.ucp.webdav",
1077 "Content::removeProperty - "
1078 "Unable to determine resource type!" );
1079 }
1080 }
1081 else
1082 {
1083 SAL_WARN( "ucb.ucp.webdav",
1084 "Content::removeProperty - "
1085 "Unable to determine resource type!" );
1086 // throw beans::UnknownPropertyException();
1087 }
1088 }
1089 }
1090 }
1091
1092 // virtual
1093 void SAL_CALL Content::addProperty( const rtl::OUString& Name,
1094 sal_Int16 Attributes,
1095 const uno::Any& DefaultValue )
1096 throw( beans::PropertyExistException,
1097 beans::IllegalTypeException,
1098 lang::IllegalArgumentException,
1099 uno::RuntimeException )
1100 {
1101 beans::Property aProperty;
1102 aProperty.Name = Name;
1103 aProperty.Type = DefaultValue.getValueType();
1104 aProperty.Attributes = Attributes;
1105 aProperty.Handle = -1;
1106
1107 addProperty( ucb::PropertyCommandArgument( aProperty, DefaultValue ),
1108 uno::Reference< ucb::XCommandEnvironment >());
1109 }
1110
1111 // virtual
1112 void SAL_CALL Content::removeProperty( const rtl::OUString& Name )
1113 throw( beans::UnknownPropertyException,
1114 beans::NotRemoveableException,
1115 uno::RuntimeException )
1116 {
1117 removeProperty( Name,
1118 uno::Reference< ucb::XCommandEnvironment >() );
1119 }
1120
1121
1122
1123 // XContentCreator methods.
1124
1125
1126
1127 // virtual
1128 uno::Sequence< ucb::ContentInfo > SAL_CALL
1129 Content::queryCreatableContentsInfo()
1130 throw( uno::RuntimeException )
1131 {
1132 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1133
1134 uno::Sequence< ucb::ContentInfo > aSeq( 2 );
1135
1136 // document.
1137 aSeq.getArray()[ 0 ].Type = OUString( WEBDAV_CONTENT_TYPE );
1138 aSeq.getArray()[ 0 ].Attributes
1139 = ucb::ContentInfoAttribute::INSERT_WITH_INPUTSTREAM
1140 | ucb::ContentInfoAttribute::KIND_DOCUMENT;
1141
1142 beans::Property aProp;
1143 m_pProvider->getProperty(
1144 OUString( "Title" ), aProp );
1145
1146 uno::Sequence< beans::Property > aDocProps( 1 );
1147 aDocProps.getArray()[ 0 ] = aProp;
1148 aSeq.getArray()[ 0 ].Properties = aDocProps;
1149
1150 // folder.
1151 aSeq.getArray()[ 1 ].Type = OUString( WEBDAV_COLLECTION_TYPE );
1152 aSeq.getArray()[ 1 ].Attributes
1153 = ucb::ContentInfoAttribute::KIND_FOLDER;
1154
1155 uno::Sequence< beans::Property > aFolderProps( 1 );
1156 aFolderProps.getArray()[ 0 ] = aProp;
1157 aSeq.getArray()[ 1 ].Properties = aFolderProps;
1158 return aSeq;
1159 }
1160
1161
1162 // virtual
1163 uno::Reference< ucb::XContent > SAL_CALL
1164 Content::createNewContent( const ucb::ContentInfo& Info )
1165 throw( uno::RuntimeException )
1166 {
1167 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1168
1169 if ( !Info.Type.getLength() )
1170 return uno::Reference< ucb::XContent >();
1171
1172 if ( ( Info.Type != WEBDAV_COLLECTION_TYPE )
1173 &&
1174 ( Info.Type != WEBDAV_CONTENT_TYPE ) )
1175 return uno::Reference< ucb::XContent >();
1176
1177 OUString aURL = m_xIdentifier->getContentIdentifier();
1178
1179 SAL_WARN_IF( aURL.isEmpty(), "ucb.ucp.webdav",
1180 "WebdavContent::createNewContent - empty identifier!" );
1181
1182 if ( ( aURL.lastIndexOf( '/' ) + 1 ) != aURL.getLength() )
1183 aURL += "/";
1184
1185 bool isCollection;
1186 if ( Info.Type == WEBDAV_COLLECTION_TYPE )
1187 {
1188 aURL += "New_Collection";
1189 isCollection = true;
1190 }
1191 else
1192 {
1193 aURL += "New_Content";
1194 isCollection = false;
1195 }
1196
1197 uno::Reference< ucb::XContentIdentifier > xId(
1198 new ::ucbhelper::ContentIdentifier( aURL ) );
1199
1200 // create the local content
1201 try
1202 {
1203 return new ::http_dav_ucp::Content( m_xContext,
1204 m_pProvider,
1205 xId,
1206 m_xResAccess->getSessionFactory(),
1207 isCollection );
1208 }
1209 catch ( ucb::ContentCreationException & )
1210 {
1211 return uno::Reference< ucb::XContent >();
1212 }
1213 }
1214
1215
1216 // virtual
1217 OUString Content::getParentURL()
1218 {
1219 // <scheme>:// -> ""
1220 // <scheme>://foo -> ""
1221 // <scheme>://foo/ -> ""
1222 // <scheme>://foo/bar -> <scheme>://foo/
1223 // <scheme>://foo/bar/ -> <scheme>://foo/
1224 // <scheme>://foo/bar/abc -> <scheme>://foo/bar/
1225
1226 OUString aURL = m_xIdentifier->getContentIdentifier();
1227
1228 sal_Int32 nPos = aURL.lastIndexOf( '/' );
1229 if ( nPos == ( aURL.getLength() - 1 ) )
1230 {
1231 // Trailing slash found. Skip.
1232 nPos = aURL.lastIndexOf( '/', nPos );
1233 }
1234
1235 sal_Int32 nPos1 = aURL.lastIndexOf( '/', nPos );
1236 if ( nPos1 != -1 )
1237 nPos1 = aURL.lastIndexOf( '/', nPos1 );
1238
1239 if ( nPos1 == -1 )
1240 return OUString();
1241
1242 return OUString( aURL.copy( 0, nPos + 1 ) );
1243 }
1244
1245
1246
1247 // Non-interface methods.
1248
1249
1250
1251 // static
1252 uno::Reference< sdbc::XRow > Content::getPropertyValues(
1253 const uno::Reference< uno::XComponentContext >& rxContext,
1254 const uno::Sequence< beans::Property >& rProperties,
1255 const ContentProperties& rData,
1256 const rtl::Reference< ::ucbhelper::ContentProviderImplHelper >& rProvider,
1257 const OUString& rContentId )
1258 {
1259 // Note: Empty sequence means "get values of all supported properties".
1260
1261 rtl::Reference< ::ucbhelper::PropertyValueSet > xRow
1262 = new ::ucbhelper::PropertyValueSet( rxContext );
1263
1264 sal_Int32 nCount = rProperties.getLength();
1265 if ( nCount )
1266 {
1267 uno::Reference< beans::XPropertySet > xAdditionalPropSet;
1268 bool bTriedToGetAdditionalPropSet = false;
1269
1270 const beans::Property* pProps = rProperties.getConstArray();
1271 for ( sal_Int32 n = 0; n < nCount; ++n )
1272 {
1273 const beans::Property& rProp = pProps[ n ];
1274
1275 // Process standard UCB, DAV and HTTP properties.
1276 const uno::Any & rValue = rData.getValue( rProp.Name );
1277 if ( rValue.hasValue() )
1278 {
1279 xRow->appendObject( rProp, rValue );
1280 }
1281 else
1282 {
1283 // Process local Additional Properties.
1284 if ( !bTriedToGetAdditionalPropSet && !xAdditionalPropSet.is() )
1285 {
1286 xAdditionalPropSet
1287 = uno::Reference< beans::XPropertySet >(
1288 rProvider->getAdditionalPropertySet( rContentId,
1289 false ),
1290 uno::UNO_QUERY );
1291 bTriedToGetAdditionalPropSet = true;
1292 }
1293
1294 if ( !xAdditionalPropSet.is() ||
1295 !xRow->appendPropertySetValue(
1296 xAdditionalPropSet, rProp ) )
1297 {
1298 // Append empty entry.
1299 xRow->appendVoid( rProp );
1300 }
1301 }
1302 }
1303 }
1304 else
1305 {
1306 // Append all standard UCB, DAV and HTTP properties.
1307
1308 const boost::scoped_ptr< PropertyValueMap > & xProps = rData.getProperties();
1309
1310 PropertyValueMap::const_iterator it = xProps->begin();
1311 PropertyValueMap::const_iterator end = xProps->end();
1312
1313 ContentProvider * pProvider
1314 = static_cast< ContentProvider * >( rProvider.get() );
1315 beans::Property aProp;
1316
1317 while ( it != end )
1318 {
1319 if ( pProvider->getProperty( (*it).first, aProp ) )
1320 xRow->appendObject( aProp, (*it).second.value() );
1321
1322 ++it;
1323 }
1324
1325 // Append all local Additional Properties.
1326 uno::Reference< beans::XPropertySet > xSet(
1327 rProvider->getAdditionalPropertySet( rContentId, false ),
1328 uno::UNO_QUERY );
1329 xRow->appendPropertySet( xSet );
1330 }
1331
1332 return uno::Reference< sdbc::XRow >( xRow.get() );
1333 }
1334
1335
1336 uno::Reference< sdbc::XRow > Content::getPropertyValues(
1337 const uno::Sequence< beans::Property >& rProperties,
1338 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1339 throw ( uno::Exception )
1340 {
1341 boost::scoped_ptr< ContentProperties > xProps;
1342 boost::scoped_ptr< ContentProperties > xCachedProps;
1343 boost::scoped_ptr< DAVResourceAccess > xResAccess;
1344 OUString aUnescapedTitle;
1345 bool bHasAll = false;
1346 uno::Reference< uno::XComponentContext > xContext;
1347 uno::Reference< ucb::XContentIdentifier > xIdentifier;
1348 rtl::Reference< ::ucbhelper::ContentProviderImplHelper > xProvider;
1349
1350 {
1351 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1352
1353 aUnescapedTitle = SerfUri::unescape( m_aEscapedTitle );
1354 xContext.set( m_xContext );
1355 xIdentifier.set( m_xIdentifier );
1356 xProvider.set( m_xProvider.get() );
1357 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
1358
1359 // First, ask cache...
1360 if ( m_xCachedProps.get() )
1361 {
1362 xCachedProps.reset( new ContentProperties( *m_xCachedProps.get() ) );
1363
1364 std::vector< OUString > aMissingProps;
1365 if ( xCachedProps->containsAllNames( rProperties, aMissingProps ) )
1366 {
1367 // All properties are already in cache! No server access needed.
1368 bHasAll = true;
1369 }
1370
1371 // use the cached ContentProperties instance
1372 xProps.reset( new ContentProperties( *xCachedProps.get() ) );
1373 }
1374 }
1375
1376 if ( !m_bTransient && !bHasAll )
1377 {
1378 // Obtain values from server...
1379
1380
1381 // First, identify whether resource is DAV or not
1382 bool bNetworkAccessAllowed = true;
1383 const ResourceType & rType = getResourceType( xEnv, xResAccess, &bNetworkAccessAllowed );
1384
1385 if ( DAV == rType )
1386 {
1387 // cache lookup... getResourceType may fill the props cache via
1388 // PROPFIND!
1389 if ( m_xCachedProps.get() )
1390 {
1391 xCachedProps.reset(
1392 new ContentProperties( *m_xCachedProps.get() ) );
1393
1394 std::vector< OUString > aMissingProps;
1395 if ( xCachedProps->containsAllNames(
1396 rProperties, aMissingProps ) )
1397 {
1398 // All properties are already in cache! No server access
1399 // needed.
1400 bHasAll = true;
1401 }
1402
1403 // use the cached ContentProperties instance
1404 xProps.reset( new ContentProperties( *xCachedProps.get() ) );
1405 }
1406
1407 if ( !bHasAll )
1408 {
1409 // Only DAV resources support PROPFIND
1410 std::vector< OUString > aPropNames;
1411
1412 uno::Sequence< beans::Property > aProperties(
1413 rProperties.getLength() );
1414
1415 if ( !m_aFailedPropNames.empty() )
1416 {
1417 sal_Int32 nProps = 0;
1418 sal_Int32 nCount = rProperties.getLength();
1419 for ( sal_Int32 n = 0; n < nCount; ++n )
1420 {
1421 const OUString & rName = rProperties[ n ].Name;
1422
1423 std::vector< OUString >::const_iterator it
1424 = m_aFailedPropNames.begin();
1425 std::vector< OUString >::const_iterator end
1426 = m_aFailedPropNames.end();
1427
1428 while ( it != end )
1429 {
1430 if ( *it == rName )
1431 break;
1432
1433 ++it;
1434 }
1435
1436 if ( it == end )
1437 {
1438 aProperties[ nProps ] = rProperties[ n ];
1439 nProps++;
1440 }
1441 }
1442
1443 aProperties.realloc( nProps );
1444 }
1445 else
1446 {
1447 aProperties = rProperties;
1448 }
1449
1450 if ( aProperties.getLength() > 0 )
1451 ContentProperties::UCBNamesToDAVNames(
1452 aProperties, aPropNames );
1453
1454 if ( !aPropNames.empty() )
1455 {
1456 std::vector< DAVResource > resources;
1457 try
1458 {
1459 xResAccess->PROPFIND(
1460 DAVZERO, aPropNames, resources, xEnv );
1461
1462 if ( 1 == resources.size() )
1463 {
1464 if ( xProps.get())
1465 xProps->addProperties(
1466 aPropNames,
1467 ContentProperties( resources[ 0 ] ));
1468 else
1469 xProps.reset(
1470 new ContentProperties( resources[ 0 ] ) );
1471 }
1472 }
1473 catch ( DAVException const & e )
1474 {
1475 bNetworkAccessAllowed = bNetworkAccessAllowed &&
1476 shouldAccessNetworkAfterException( e );
1477
1478 if ( !bNetworkAccessAllowed )
1479 {
1480 cancelCommandExecution( e, xEnv );
1481 // unreachable
1482 }
1483 }
1484 }
1485 }
1486 }
1487
1488 if ( bNetworkAccessAllowed )
1489 {
1490 // All properties obtained already?
1491 std::vector< OUString > aMissingProps;
1492 if ( !( xProps.get()
1493 && xProps->containsAllNames(
1494 rProperties, aMissingProps ) )
1495 || !m_bDidGetOrHead )
1496 {
1497 // Possibly the missing props can be obtained using a HEAD
1498 // request.
1499
1500 std::vector< OUString > aHeaderNames;
1501 ContentProperties::UCBNamesToHTTPNames(
1502 rProperties,
1503 aHeaderNames,
1504 true /* bIncludeUnmatched */ );
1505
1506 if ( !aHeaderNames.empty() )
1507 {
1508 try
1509 {
1510 DAVResource resource;
1511 xResAccess->HEAD( aHeaderNames, resource, xEnv );
1512 m_bDidGetOrHead = true;
1513
1514 if ( xProps.get() )
1515 xProps->addProperties(
1516 aMissingProps,
1517 ContentProperties( resource ) );
1518 else
1519 xProps.reset ( new ContentProperties( resource ) );
1520
1521 if ( m_eResourceType == NON_DAV )
1522 xProps->addProperties( aMissingProps,
1523 ContentProperties(
1524 aUnescapedTitle,
1525 false ) );
1526 }
1527 catch ( DAVException const & e )
1528 {
1529 // non "general-purpose servers" may not support HEAD requests
1530 // see http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.1
1531 // In this case, perform a partial GET only to get the header info
1532 // vid. http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
1533 // WARNING if the server does not support partial GETs,
1534 // the GET will transfer the whole content
1535 bool bError = true;
1536 DAVException aLastException = e;
1537
1538 // According to the spec. the origin server SHOULD return
1539 // * 405 (Method Not Allowed):
1540 // the method is known but not allowed for the requested resource
1541 // * 501 (Not Implemented):
1542 // the method is unrecognized or not implemented
1543 // TODO SC_NOT_FOUND is only for google-code server
1544 if ( aLastException.getStatus() == SC_NOT_IMPLEMENTED ||
1545 aLastException.getStatus() == SC_METHOD_NOT_ALLOWED ||
1546 aLastException.getStatus() == SC_NOT_FOUND )
1547 {
1548 lcl_sendPartialGETRequest( bError,
1549 aLastException,
1550 aMissingProps,
1551 aHeaderNames,
1552 xResAccess,
1553 xProps,
1554 xEnv );
1555 m_bDidGetOrHead = !bError;
1556 }
1557
1558 if ( bError )
1559 {
1560 if ( !(bNetworkAccessAllowed
1561 = shouldAccessNetworkAfterException( aLastException )) )
1562 {
1563 cancelCommandExecution( aLastException, xEnv );
1564 // unreachable
1565 }
1566 }
1567 }
1568 }
1569 }
1570 }
1571
1572 // might trigger HTTP redirect.
1573 // Therefore, title must be updated here.
1574 SerfUri aUri( xResAccess->getURL() );
1575 aUnescapedTitle = aUri.GetPathBaseNameUnescaped();
1576
1577 if ( rType == UNKNOWN )
1578 {
1579 xProps.reset( new ContentProperties( aUnescapedTitle ) );
1580 }
1581
1582 // For DAV resources we only know the Title, for non-DAV
1583 // resources we additionally know that it is a document.
1584
1585 if ( rType == DAV )
1586 {
1587 //xProps.reset(
1588 // new ContentProperties( aUnescapedTitle ) );
1589 xProps->addProperty(
1590 OUString( "Title" ),
1591 uno::makeAny( aUnescapedTitle ),
1592 true );
1593 }
1594 else
1595 {
1596 if ( !xProps.get() )
1597 xProps.reset( new ContentProperties( aUnescapedTitle, false ) );
1598 else
1599 xProps->addProperty(
1600 OUString( "Title" ),
1601 uno::makeAny( aUnescapedTitle ),
1602 true );
1603
1604 xProps->addProperty(
1605 OUString( "IsFolder" ),
1606 uno::makeAny( false ),
1607 true );
1608 xProps->addProperty(
1609 OUString( "IsDocument" ),
1610 uno::makeAny( true ),
1611 true );
1612 xProps->addProperty(
1613 OUString( "ContentType" ),
1614 uno::makeAny( OUString(WEBDAV_CONTENT_TYPE) ),
1615 true );
1616 }
1617 }
1618 else
1619 {
1620 // No server access for just created (not yet committed) objects.
1621 // Only a minimal set of properties supported at this stage.
1622 if (m_bTransient)
1623 xProps.reset( new ContentProperties( aUnescapedTitle,
1624 m_bCollection ) );
1625 }
1626
1627 sal_Int32 nCount = rProperties.getLength();
1628 for ( sal_Int32 n = 0; n < nCount; ++n )
1629 {
1630 const OUString rName = rProperties[ n ].Name;
1631 if ( rName == "BaseURI" )
1632 {
1633 // Add BaseURI property, if requested.
1634 xProps->addProperty(
1635 OUString( "BaseURI" ),
1636 uno::makeAny( getBaseURI( xResAccess ) ),
1637 true );
1638 }
1639 else if ( rName == "CreatableContentsInfo" )
1640 {
1641 // Add CreatableContentsInfo property, if requested.
1642 bool bFolder = false;
1643 xProps->getValue(
1644 OUString( "IsFolder" ) )
1645 >>= bFolder;
1646 xProps->addProperty(
1647 OUString( "CreatableContentsInfo" ),
1648 uno::makeAny( bFolder
1649 ? queryCreatableContentsInfo()
1650 : uno::Sequence< ucb::ContentInfo >() ),
1651 true );
1652 }
1653 }
1654
1655 uno::Reference< sdbc::XRow > xResultRow
1656 = getPropertyValues( xContext,
1657 rProperties,
1658 *xProps,
1659 xProvider,
1660 xIdentifier->getContentIdentifier() );
1661
1662 {
1663 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1664
1665 if ( !m_xCachedProps.get() )
1666 m_xCachedProps.reset( new CachableContentProperties( *xProps.get() ) );
1667 else
1668 m_xCachedProps->addProperties( *xProps.get() );
1669
1670 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
1671 m_aEscapedTitle = SerfUri::escapeSegment( aUnescapedTitle );
1672 }
1673
1674 return xResultRow;
1675 }
1676
1677
1678 uno::Sequence< uno::Any > Content::setPropertyValues(
1679 const uno::Sequence< beans::PropertyValue >& rValues,
1680 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1681 throw ( uno::Exception )
1682 {
1683 uno::Reference< ucb::XContentIdentifier > xIdentifier;
1684 rtl::Reference< ContentProvider > xProvider;
1685 bool bTransient;
1686 boost::scoped_ptr< DAVResourceAccess > xResAccess;
1687
1688 {
1689 osl::Guard< osl::Mutex > aGuard( m_aMutex );
1690
1691 xProvider.set( m_pProvider );
1692 xIdentifier.set( m_xIdentifier );
1693 bTransient = m_bTransient;
1694 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
1695 }
1696
1697 uno::Sequence< uno::Any > aRet( rValues.getLength() );
1698 uno::Sequence< beans::PropertyChangeEvent > aChanges( rValues.getLength() );
1699 sal_Int32 nChanged = 0;
1700
1701 beans::PropertyChangeEvent aEvent;
1702 aEvent.Source = static_cast< cppu::OWeakObject * >( this );
1703 aEvent.Further = false;
1704 // aEvent.PropertyName =
1705 aEvent.PropertyHandle = -1;
1706 // aEvent.OldValue =
1707 // aEvent.NewValue =
1708
1709 std::vector< ProppatchValue > aProppatchValues;
1710 std::vector< sal_Int32 > aProppatchPropsPositions;
1711
1712 uno::Reference< ucb::XPersistentPropertySet > xAdditionalPropSet;
1713 bool bTriedToGetAdditionalPropSet = false;
1714
1715 bool bExchange = false;
1716 OUString aNewTitle;
1717 OUString aOldTitle;
1718 sal_Int32 nTitlePos = -1;
1719
1720 uno::Reference< beans::XPropertySetInfo > xInfo;
1721
1722 const beans::PropertyValue* pValues = rValues.getConstArray();
1723 sal_Int32 nCount = rValues.getLength();
1724 for ( sal_Int32 n = 0; n < nCount; ++n )
1725 {
1726 const beans::PropertyValue& rValue = pValues[ n ];
1727 const OUString & rName = rValue.Name;
1728
1729 beans::Property aTmpProp;
1730 xProvider->getProperty( rName, aTmpProp );
1731
1732 if ( aTmpProp.Attributes & beans::PropertyAttribute::READONLY )
1733 {
1734 // Read-only property!
1735 aRet[ n ] <<= lang::IllegalAccessException(
1736 OUString( "Property is read-only!" ),
1737 static_cast< cppu::OWeakObject * >( this ) );
1738 continue;
1739 }
1740
1741
1742 // Mandatory props.
1743
1744
1745 if ( rName == "ContentType" )
1746 {
1747 // Read-only property!
1748 aRet[ n ] <<= lang::IllegalAccessException(
1749 OUString( "Property is read-only!" ),
1750 static_cast< cppu::OWeakObject * >( this ) );
1751 }
1752 else if ( rName == "IsDocument" )
1753 {
1754 // Read-only property!
1755 aRet[ n ] <<= lang::IllegalAccessException(
1756 OUString( "Property is read-only!" ),
1757 static_cast< cppu::OWeakObject * >( this ) );
1758 }
1759 else if ( rName == "IsFolder" )
1760 {
1761 // Read-only property!
1762 aRet[ n ] <<= lang::IllegalAccessException(
1763 OUString( "Property is read-only!" ),
1764 static_cast< cppu::OWeakObject * >( this ) );
1765 }
1766 else if ( rName == "Title" )
1767 {
1768 OUString aNewValue;
1769 if ( rValue.Value >>= aNewValue )
1770 {
1771 // No empty titles!
1772 if ( aNewValue.getLength() > 0 )
1773 {
1774 try
1775 {
1776 SerfUri aURI( xIdentifier->getContentIdentifier() );
1777 aOldTitle = aURI.GetPathBaseNameUnescaped();
1778
1779 if ( aNewValue != aOldTitle )
1780 {
1781 // modified title -> modified URL -> exchange !
1782 if ( !bTransient )
1783 bExchange = true;
1784
1785 // new value will be set later...
1786 aNewTitle = aNewValue;
1787
1788 // remember position within sequence of values (for
1789 // error handling).
1790 nTitlePos = n;
1791 }
1792 }
1793 catch ( DAVException const & )
1794 {
1795 aRet[ n ] <<= lang::IllegalArgumentException(
1796 OUString( "Invalid content identifier!" ),
1797 static_cast< cppu::OWeakObject * >( this ),
1798 -1 );
1799 }
1800 }
1801 else
1802 {
1803 aRet[ n ] <<= lang::IllegalArgumentException(
1804 OUString( "Empty title not allowed!" ),
1805 static_cast< cppu::OWeakObject * >( this ),
1806 -1 );
1807 }
1808 }
1809 else
1810 {
1811 aRet[ n ] <<= beans::IllegalTypeException(
1812 OUString( "Property value has wrong type!" ),
1813 static_cast< cppu::OWeakObject * >( this ) );
1814 }
1815 }
1816 else
1817 {
1818
1819 // Optional props.
1820
1821
1822 rtl::OUString aSpecialName;
1823 bool bIsSpecial = DAVProperties::isUCBSpecialProperty( rName, aSpecialName );
1824
1825 if ( !xInfo.is() )
1826 xInfo = getPropertySetInfo( xEnv,
1827 false /* don't cache data */ );
1828
1829 if ( !xInfo->hasPropertyByName( bIsSpecial ? aSpecialName : rName ) )
1830 {
1831 // Check, whether property exists. Skip otherwise.
1832 // PROPPATCH::set would add the property automatically, which
1833 // is not allowed for "setPropertyValues" command!
1834 aRet[ n ] <<= beans::UnknownPropertyException(
1835 OUString( "Property is unknown!" ),
1836 static_cast< cppu::OWeakObject * >( this ) );
1837 continue;
1838 }
1839
1840 if ( rName == "Size" )
1841 {
1842 // Read-only property!
1843 aRet[ n ] <<= lang::IllegalAccessException(
1844 OUString( "Property is read-only!" ),
1845 static_cast< cppu::OWeakObject * >( this ) );
1846 }
1847 else if ( rName == "DateCreated" )
1848 {
1849 // Read-only property!
1850 aRet[ n ] <<= lang::IllegalAccessException(
1851 OUString( "Property is read-only!" ),
1852 static_cast< cppu::OWeakObject * >( this ) );
1853 }
1854 else if ( rName == "DateModified" )
1855 {
1856 // Read-only property!
1857 aRet[ n ] <<= lang::IllegalAccessException(
1858 OUString( "Property is read-only!" ),
1859 static_cast< cppu::OWeakObject * >( this ) );
1860 }
1861 else if ( rName == "MediaType" )
1862 {
1863 // Read-only property!
1864 // (but could be writable, if 'getcontenttype' would be)
1865 aRet[ n ] <<= lang::IllegalAccessException(
1866 OUString( "Property is read-only!" ),
1867 static_cast< cppu::OWeakObject * >( this ) );
1868 }
1869 if ( rName == "CreatableContentsInfo" )
1870 {
1871 // Read-only property!
1872 aRet[ n ] <<= lang::IllegalAccessException(
1873 OUString( "Property is read-only!" ),
1874 static_cast< cppu::OWeakObject * >( this ) );
1875 }
1876 else
1877 {
1878 if ( getResourceType( xEnv, xResAccess ) == DAV )
1879 {
1880 // Property value will be set on server.
1881 ProppatchValue aValue( PROPSET, rName, rValue.Value );
1882 aProppatchValues.push_back( aValue );
1883
1884 // remember position within sequence of values (for
1885 // error handling).
1886 aProppatchPropsPositions.push_back( n );
1887 }
1888 else
1889 {
1890 // Property value will be stored in local property store.
1891 if ( !bTriedToGetAdditionalPropSet &&
1892 !xAdditionalPropSet.is() )
1893 {
1894 xAdditionalPropSet
1895 = getAdditionalPropertySet( false );
1896 bTriedToGetAdditionalPropSet = true;
1897 }
1898
1899 if ( xAdditionalPropSet.is() )
1900 {
1901 try
1902 {
1903 uno::Any aOldValue
1904 = xAdditionalPropSet->getPropertyValue( rName );
1905 if ( aOldValue != rValue.Value )
1906 {
1907 xAdditionalPropSet->setPropertyValue(
1908 rName, rValue.Value );
1909
1910 aEvent.PropertyName = rName;
1911 aEvent.OldValue = aOldValue;
1912 aEvent.NewValue = rValue.Value;
1913
1914 aChanges.getArray()[ nChanged ] = aEvent;
1915 nChanged++;
1916 }
1917 }
1918 catch ( beans::UnknownPropertyException const & e )
1919 {
1920 aRet[ n ] <<= e;
1921 }
1922 catch ( lang::WrappedTargetException const & e )
1923 {
1924 aRet[ n ] <<= e;
1925 }
1926 catch ( beans::PropertyVetoException const & e )
1927 {
1928 aRet[ n ] <<= e;
1929 }
1930 catch ( lang::IllegalArgumentException const & e )
1931 {
1932 aRet[ n ] <<= e;
1933 }
1934 }
1935 else
1936 {
1937 aRet[ n ] <<= uno::Exception(
1938 OUString( "No property set for storing the value!" ),
1939 static_cast< cppu::OWeakObject * >( this ) );
1940 }
1941 }
1942 }
1943 }
1944 } // for
1945
1946 if ( !bTransient && (!aProppatchValues.empty()) )
1947 {
1948 try
1949 {
1950 // Set property values at server.
1951 xResAccess->PROPPATCH( aProppatchValues, xEnv );
1952
1953 std::vector< ProppatchValue >::const_iterator it
1954 = aProppatchValues.begin();
1955 std::vector< ProppatchValue >::const_iterator end
1956 = aProppatchValues.end();
1957
1958 while ( it != end )
1959 {
1960 aEvent.PropertyName = (*it).name;
1961 aEvent.OldValue = uno::Any(); // @@@ to expensive to obtain!
1962 aEvent.NewValue = (*it).value;
1963
1964 aChanges.getArray()[ nChanged ] = aEvent;
1965 nChanged++;
1966
1967 ++it;
1968 }
1969 }
1970 catch ( DAVException const & e )
1971 {
1972 // SAL_WARN( "ucb.ucp.webdav",
1973 // "Content::setPropertyValues - PROPPATCH failed!" );
1974
1975 #if 1
1976 cancelCommandExecution( e, xEnv );
1977 // unreachable
1978 #else
1979 // Note: PROPPATCH either sets ALL property values OR NOTHING.
1980
1981 std::vector< sal_Int32 >::const_iterator it
1982 = aProppatchPropsPositions.begin();
1983 std::vector< sal_Int32 >::const_iterator end
1984 = aProppatchPropsPositions.end();
1985
1986 while ( it != end )
1987 {
1988 // Set error.
1989 aRet[ (*it) ] <<= MapDAVException( e, true );
1990 ++it;
1991 }
1992 #endif
1993 }
1994 }
1995
1996 if ( bExchange )
1997 {
1998 // Assemble new content identifier...
1999
2000 OUString aNewURL = getParentURL();
2001 if ( aNewURL.lastIndexOf( '/' ) != ( aNewURL.getLength() - 1 ) )
2002 aNewURL += "/";
2003
2004 aNewURL += SerfUri::escapeSegment( aNewTitle );
2005
2006 uno::Reference< ucb::XContentIdentifier > xNewId
2007 = new ::ucbhelper::ContentIdentifier( aNewURL );
2008 uno::Reference< ucb::XContentIdentifier > xOldId = xIdentifier;
2009
2010 try
2011 {
2012 SerfUri sourceURI( xOldId->getContentIdentifier() );
2013 SerfUri targetURI( xNewId->getContentIdentifier() );
2014 targetURI.SetScheme( sourceURI.GetScheme() );
2015
2016 xResAccess->MOVE(
2017 sourceURI.GetPath(), targetURI.GetURI(), false, xEnv );
2018 // @@@ Should check for resources that could not be moved
2019 // (due to source access or target overwrite) and send
2020 // this information through the interaction handler.
2021
2022 // @@@ Existing content should be checked to see if it needs
2023 // to be deleted at the source
2024
2025 // @@@ Existing content should be checked to see if it has
2026 // been overwritten at the target
2027
2028 if ( exchangeIdentity( xNewId ) )
2029 {
2030 xResAccess->setURL( aNewURL );
2031
2032 // DAV resources store all additional props on server!
2033 // // Adapt Additional Core Properties.
2034 // renameAdditionalPropertySet( xOldId->getContentIdentifier(),
2035 // xNewId->getContentIdentifier(),
2036 // true );
2037 }
2038 else
2039 {
2040 // Do not set new title!
2041 aNewTitle.clear();
2042
2043 // Set error .
2044 aRet[ nTitlePos ] <<= uno::Exception(
2045 OUString( "Exchange failed!" ),
2046 static_cast< cppu::OWeakObject * >( this ) );
2047 }
2048 }
2049 catch ( DAVException const & e )
2050 {
2051 // Do not set new title!
2052 aNewTitle.clear();
2053
2054 // Set error .
2055 aRet[ nTitlePos ] <<= MapDAVException( e, true );
2056 }
2057 }
2058
2059 if ( aNewTitle.getLength() )
2060 {
2061 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2062
2063 aEvent.PropertyName = "Title";
2064 aEvent.OldValue = uno::makeAny( aOldTitle );
2065 aEvent.NewValue = uno::makeAny( aNewTitle );
2066
2067 m_aEscapedTitle = SerfUri::escapeSegment( aNewTitle );
2068
2069 aChanges.getArray()[ nChanged ] = aEvent;
2070 nChanged++;
2071 }
2072
2073 if ( nChanged > 0 )
2074 {
2075 aChanges.realloc( nChanged );
2076 notifyPropertiesChange( aChanges );
2077 }
2078
2079 {
2080 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2081 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
2082 }
2083
2084 return aRet;
2085 }
2086
2087
2088 uno::Any Content::open(
2089 const ucb::OpenCommandArgument2 & rArg,
2090 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
2091 throw( uno::Exception )
2092 {
2093 uno::Any aRet;
2094
2095 bool bOpenFolder = ( ( rArg.Mode == ucb::OpenMode::ALL ) ||
2096 ( rArg.Mode == ucb::OpenMode::FOLDERS ) ||
2097 ( rArg.Mode == ucb::OpenMode::DOCUMENTS ) );
2098 if ( bOpenFolder )
2099 {
2100 if ( isFolder( xEnv ) )
2101 {
2102 // Open collection.
2103
2104 uno::Reference< ucb::XDynamicResultSet > xSet
2105 = new DynamicResultSet( m_xContext, this, rArg, xEnv );
2106 aRet <<= xSet;
2107 }
2108 else
2109 {
2110 // Error: Not a folder!
2111
2112 OUStringBuffer aMsg;
2113 aMsg.appendAscii( "Non-folder resource cannot be "
2114 "opened as folder! Wrong Open Mode!" );
2115
2116 ucbhelper::cancelCommandExecution(
2117 uno::makeAny(
2118 lang::IllegalArgumentException(
2119 aMsg.makeStringAndClear(),
2120 static_cast< cppu::OWeakObject * >( this ),
2121 -1 ) ),
2122 xEnv );
2123 // Unreachable
2124 }
2125 }
2126
2127 if ( rArg.Sink.is() )
2128 {
2129 // Open document.
2130
2131 if ( ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) ||
2132 ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE ) )
2133 {
2134 // Currently(?) unsupported.
2135 ucbhelper::cancelCommandExecution(
2136 uno::makeAny(
2137 ucb::UnsupportedOpenModeException(
2138 OUString(),
2139 static_cast< cppu::OWeakObject * >( this ),
2140 sal_Int16( rArg.Mode ) ) ),
2141 xEnv );
2142 // Unreachable
2143 }
2144
2145 uno::Reference< io::XOutputStream > xOut
2146 = uno::Reference< io::XOutputStream >( rArg.Sink, uno::UNO_QUERY );
2147 if ( xOut.is() )
2148 {
2149 // PUSH: write data
2150 try
2151 {
2152 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2153
2154 {
2155 osl::MutexGuard aGuard( m_aMutex );
2156
2157 xResAccess.reset(
2158 new DAVResourceAccess( *m_xResAccess.get() ) );
2159 }
2160
2161 DAVResource aResource;
2162 std::vector< OUString > aHeaders;
2163
2164 xResAccess->GET( xOut, aHeaders, aResource, xEnv );
2165 m_bDidGetOrHead = true;
2166
2167 {
2168 osl::MutexGuard aGuard( m_aMutex );
2169
2170 // cache headers.
2171 if ( !m_xCachedProps.get())
2172 m_xCachedProps.reset(
2173 new CachableContentProperties( aResource ) );
2174 else
2175 m_xCachedProps->addProperties( aResource );
2176
2177 m_xResAccess.reset(
2178 new DAVResourceAccess( *xResAccess.get() ) );
2179 }
2180 }
2181 catch ( DAVException const & e )
2182 {
2183 cancelCommandExecution( e, xEnv );
2184 // Unreachable
2185 }
2186 }
2187 else
2188 {
2189 uno::Reference< io::XActiveDataSink > xDataSink
2190 = uno::Reference< io::XActiveDataSink >( rArg.Sink,
2191 uno::UNO_QUERY );
2192 if ( xDataSink.is() )
2193 {
2194 // PULL: wait for client read
2195 try
2196 {
2197 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2198 {
2199 osl::MutexGuard aGuard( m_aMutex );
2200
2201 xResAccess.reset(
2202 new DAVResourceAccess( *m_xResAccess.get() ) );
2203 }
2204
2205 // fill inputsream sync; return if all data present
2206 DAVResource aResource;
2207 std::vector< OUString > aHeaders;
2208
2209 uno::Reference< io::XInputStream > xIn
2210 = xResAccess->GET( aHeaders, aResource, xEnv );
2211 m_bDidGetOrHead = true;
2212
2213 {
2214 osl::MutexGuard aGuard( m_aMutex );
2215
2216 // cache headers.
2217 if ( !m_xCachedProps.get())
2218 m_xCachedProps.reset(
2219 new CachableContentProperties( aResource ) );
2220 else
2221 m_xCachedProps->addProperties(
2222 aResource.properties );
2223
2224 m_xResAccess.reset(
2225 new DAVResourceAccess( *xResAccess.get() ) );
2226 }
2227
2228 xDataSink->setInputStream( xIn );
2229 }
2230 catch ( DAVException const & e )
2231 {
2232 cancelCommandExecution( e, xEnv );
2233 // Unreachable
2234 }
2235 }
2236 else
2237 {
2238 // Note: aOpenCommand.Sink may contain an XStream
2239 // implementation. Support for this type of
2240 // sink is optional...
2241 ucbhelper::cancelCommandExecution(
2242 uno::makeAny(
2243 ucb::UnsupportedDataSinkException(
2244 OUString(),
2245 static_cast< cppu::OWeakObject * >( this ),
2246 rArg.Sink ) ),
2247 xEnv );
2248 // Unreachable
2249 }
2250 }
2251 }
2252
2253 return aRet;
2254 }
2255
2256
2257 void Content::post(
2258 const ucb::PostCommandArgument2 & rArg,
2259 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
2260 throw( uno::Exception )
2261 {
2262 uno::Reference< io::XActiveDataSink > xSink( rArg.Sink, uno::UNO_QUERY );
2263 if ( xSink.is() )
2264 {
2265 try
2266 {
2267 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2268 {
2269 osl::MutexGuard aGuard( m_aMutex );
2270 xResAccess.reset(
2271 new DAVResourceAccess( *m_xResAccess.get() ) );
2272 }
2273
2274 uno::Reference< io::XInputStream > xResult
2275 = xResAccess->POST( rArg.MediaType,
2276 rArg.Referer,
2277 rArg.Source,
2278 xEnv );
2279
2280 {
2281 osl::MutexGuard aGuard( m_aMutex );
2282 m_xResAccess.reset(
2283 new DAVResourceAccess( *xResAccess.get() ) );
2284 }
2285
2286 xSink->setInputStream( xResult );
2287 }
2288 catch ( DAVException const & e )
2289 {
2290 cancelCommandExecution( e, xEnv, true );
2291 // Unreachable
2292 }
2293 }
2294 else
2295 {
2296 uno::Reference< io::XOutputStream > xResult( rArg.Sink, uno::UNO_QUERY );
2297 if ( xResult.is() )
2298 {
2299 try
2300 {
2301 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2302 {
2303 osl::MutexGuard aGuard( m_aMutex );
2304 xResAccess.reset(
2305 new DAVResourceAccess( *m_xResAccess.get() ) );
2306 }
2307
2308 xResAccess->POST( rArg.MediaType,
2309 rArg.Referer,
2310 rArg.Source,
2311 xResult,
2312 xEnv );
2313
2314 {
2315 osl::MutexGuard aGuard( m_aMutex );
2316 m_xResAccess.reset(
2317 new DAVResourceAccess( *xResAccess.get() ) );
2318 }
2319 }
2320 catch ( DAVException const & e )
2321 {
2322 cancelCommandExecution( e, xEnv, true );
2323 // Unreachable
2324 }
2325 }
2326 else
2327 {
2328 ucbhelper::cancelCommandExecution(
2329 uno::makeAny(
2330 ucb::UnsupportedDataSinkException(
2331 OUString(),
2332 static_cast< cppu::OWeakObject * >( this ),
2333 rArg.Sink ) ),
2334 xEnv );
2335 // Unreachable
2336 }
2337 }
2338 }
2339
2340
2341 void Content::queryChildren( ContentRefList& rChildren )
2342 {
2343 // Obtain a list with a snapshot of all currently instantiated contents
2344 // from provider and extract the contents which are direct children
2345 // of this content.
2346
2347 ::ucbhelper::ContentRefList aAllContents;
2348 m_xProvider->queryExistingContents( aAllContents );
2349
2350 OUString aURL = m_xIdentifier->getContentIdentifier();
2351 sal_Int32 nURLPos = aURL.lastIndexOf( '/' );
2352
2353 if ( nURLPos != ( aURL.getLength() - 1 ) )
2354 {
2355 // No trailing slash found. Append.
2356 aURL += "/";
2357 }
2358
2359 sal_Int32 nLen = aURL.getLength();
2360
2361 ::ucbhelper::ContentRefList::const_iterator it = aAllContents.begin();
2362 ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end();
2363
2364 while ( it != end )
2365 {
2366 ::ucbhelper::ContentImplHelperRef xChild = (*it);
2367 OUString aChildURL
2368 = xChild->getIdentifier()->getContentIdentifier();
2369
2370 // Is aURL a prefix of aChildURL?
2371 if ( ( aChildURL.getLength() > nLen ) &&
2372 ( aChildURL.startsWith( aURL ) ) )
2373 {
2374 sal_Int32 nPos = nLen;
2375 nPos = aChildURL.indexOf( '/', nPos );
2376
2377 if ( ( nPos == -1 ) ||
2378 ( nPos == ( aChildURL.getLength() - 1 ) ) )
2379 {
2380 // No further slashes / only a final slash. It's a child!
2381 rChildren.push_back(
2382 ::http_dav_ucp::Content::ContentRef(
2383 static_cast< ::http_dav_ucp::Content * >(
2384 xChild.get() ) ) );
2385 }
2386 }
2387 ++it;
2388 }
2389 }
2390
2391
2392 void Content::insert(
2393 const uno::Reference< io::XInputStream > & xInputStream,
2394 bool bReplaceExisting,
2395 const uno::Reference< ucb::XCommandEnvironment >& Environment )
2396 throw( uno::Exception )
2397 {
2398 bool bTransient, bCollection;
2399 OUString aEscapedTitle;
2400 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2401
2402 {
2403 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2404
2405 bTransient = m_bTransient;
2406 bCollection = m_bCollection;
2407 aEscapedTitle = m_aEscapedTitle;
2408 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
2409 }
2410
2411 // Check, if all required properties are present.
2412
2413 if ( aEscapedTitle.isEmpty() )
2414 {
2415 SAL_WARN( "ucb.ucp.webdav", "Content::insert - Title missing!" );
2416
2417 uno::Sequence< OUString > aProps( 1 );
2418 aProps[ 0 ] = "Title";
2419 ucbhelper::cancelCommandExecution(
2420 uno::makeAny( ucb::MissingPropertiesException(
2421 OUString(),
2422 static_cast< cppu::OWeakObject * >( this ),
2423 aProps ) ),
2424 Environment );
2425 // Unreachable
2426 }
2427
2428 if ( !bReplaceExisting )
2429 {
2430 /* [RFC 2616] - HTTP
2431
2432 The PUT method requests that the enclosed entity be stored under the
2433 supplied Request-URI. If the Request-URI refers to an already
2434 existing resource, the enclosed entity SHOULD be considered as a
2435 modified version of the one residing on the origin server.
2436 */
2437
2438 /* [RFC 2518] - WebDAV
2439
2440 MKCOL creates a new collection resource at the location specified by
2441 the Request-URI. If the resource identified by the Request-URI is
2442 non-null then the MKCOL MUST fail.
2443 */
2444
2445 // ==> Complain on PUT, continue on MKCOL.
2446 if ( !bTransient || ( bTransient && !bCollection ) )
2447 {
2448 #undef ERROR
2449 ucb::UnsupportedNameClashException aEx(
2450 OUString( "Unable to write without overwrite!" ),
2451 static_cast< cppu::OWeakObject * >( this ),
2452 ucb::NameClash::ERROR );
2453
2454 uno::Reference< task::XInteractionHandler > xIH;
2455
2456 if ( Environment.is() )
2457 xIH = Environment->getInteractionHandler();
2458
2459 if ( xIH.is() )
2460 {
2461 uno::Any aExAsAny( uno::makeAny( aEx ) );
2462
2463 rtl::Reference< ucbhelper::SimpleInteractionRequest > xRequest
2464 = new ucbhelper::SimpleInteractionRequest(
2465 aExAsAny,
2466 ucbhelper::CONTINUATION_APPROVE
2467 | ucbhelper::CONTINUATION_DISAPPROVE );
2468 xIH->handle( xRequest.get() );
2469
2470 const sal_Int32 nResp = xRequest->getResponse();
2471
2472 switch ( nResp )
2473 {
2474 case ucbhelper::CONTINUATION_UNKNOWN:
2475 // Not handled; throw.
2476 throw aEx;
2477 // break;
2478
2479 case ucbhelper::CONTINUATION_APPROVE:
2480 // Continue -> Overwrite.
2481 bReplaceExisting = true;
2482 break;
2483
2484 case ucbhelper::CONTINUATION_DISAPPROVE:
2485 // Abort.
2486 throw ucb::CommandFailedException(
2487 OUString(),
2488 uno::Reference< uno::XInterface >(),
2489 aExAsAny );
2490 // break;
2491
2492 default:
2493 SAL_WARN( "ucb.ucp.webdav",
2494 "Content::insert - "
2495 "Unknown interaction selection!" );
2496 throw ucb::CommandFailedException(
2497 OUString( "Unknown interaction selection!" ),
2498 uno::Reference< uno::XInterface >(),
2499 aExAsAny );
2500 // break;
2501 }
2502 }
2503 else
2504 {
2505 // No IH; throw.
2506 throw aEx;
2507 }
2508 }
2509 }
2510
2511 if ( bTransient )
2512 {
2513 // Assemble new content identifier...
2514 OUString aURL = getParentURL();
2515 if ( aURL.lastIndexOf( '/' ) != ( aURL.getLength() - 1 ) )
2516 aURL += "/";
2517
2518 aURL += aEscapedTitle;
2519
2520 try
2521 {
2522 xResAccess->setURL( aURL );
2523
2524 if ( bCollection )
2525 xResAccess->MKCOL( Environment );
2526 else
2527 xResAccess->PUT( xInputStream, Environment );
2528 }
2529 catch ( DAVException const & except )
2530 {
2531 if ( bCollection )
2532 {
2533 if ( except.getStatus() == SC_METHOD_NOT_ALLOWED )
2534 {
2535 // [RFC 2518] - WebDAV
2536 // 405 (Method Not Allowed) - MKCOL can only be
2537 // executed on a deleted/non-existent resource.
2538
2539 if ( bReplaceExisting )
2540 {
2541 // Destroy old resource.
2542 try
2543 {
2544 xResAccess->DESTROY( Environment );
2545 }
2546 catch ( DAVException const & e )
2547 {
2548 cancelCommandExecution( e, Environment, true );
2549 // Unreachable
2550 }
2551
2552 // Insert (recursion!).
2553 insert( xInputStream, bReplaceExisting, Environment );
2554
2555 {
2556 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2557 m_xResAccess.reset(
2558 new DAVResourceAccess( *xResAccess.get() ) );
2559 }
2560
2561 // Success!
2562 return;
2563 }
2564 else
2565 {
2566 OUString aTitle;
2567 try
2568 {
2569 SerfUri aURI( aURL );
2570 aTitle = aURI.GetPathBaseNameUnescaped();
2571 }
2572 catch ( DAVException const & )
2573 {
2574 }
2575
2576 ucbhelper::cancelCommandExecution(
2577 uno::makeAny(
2578 ucb::NameClashException(
2579 OUString(),
2580 static_cast< cppu::OWeakObject * >( this ),
2581 task::InteractionClassification_ERROR,
2582 aTitle ) ),
2583 Environment );
2584 // Unreachable
2585 }
2586 }
2587 }
2588
2589 cancelCommandExecution( except, Environment, true );
2590 // Unreachable
2591 }
2592
2593 {
2594 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2595 m_xIdentifier
2596 = new ::ucbhelper::ContentIdentifier( aURL );
2597 }
2598
2599 inserted();
2600
2601 {
2602 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2603 m_bTransient = false;
2604 }
2605 }
2606 else
2607 {
2608 if ( !xInputStream.is() )
2609 {
2610 ucbhelper::cancelCommandExecution(
2611 uno::makeAny(
2612 ucb::MissingInputStreamException(
2613 OUString(),
2614 static_cast< cppu::OWeakObject * >( this ) ) ),
2615 Environment );
2616 // Unreachable
2617 }
2618
2619 try
2620 {
2621 xResAccess->PUT( xInputStream, Environment );
2622 }
2623 catch ( DAVException const & e )
2624 {
2625 cancelCommandExecution( e, Environment, true );
2626 // Unreachable
2627 }
2628 }
2629
2630 {
2631 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2632 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
2633 }
2634 }
2635
2636
2637 void Content::transfer(
2638 const ucb::TransferInfo & rArgs,
2639 const uno::Reference< ucb::XCommandEnvironment >& Environment )
2640 throw( uno::Exception )
2641 {
2642 uno::Reference< uno::XComponentContext > xContext;
2643 uno::Reference< ucb::XContentIdentifier > xIdentifier;
2644 uno::Reference< ucb::XContentProvider > xProvider;
2645 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2646
2647 {
2648 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2649
2650 xContext.set( m_xContext );
2651 xIdentifier.set( m_xIdentifier );
2652 xProvider.set( m_xProvider.get() );
2653 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
2654 }
2655
2656 OUString aTargetURI;
2657 try
2658 {
2659 SerfUri sourceURI( rArgs.SourceURL );
2660 SerfUri targetURI( xIdentifier->getContentIdentifier() );
2661 aTargetURI = targetURI.GetPathBaseNameUnescaped();
2662
2663 // Check source's and target's URL scheme
2664
2665 const OUString aScheme = sourceURI.GetScheme().toAsciiLowerCase();
2666 if ( aScheme == WEBDAV_URL_SCHEME )
2667 {
2668 sourceURI.SetScheme(
2669 OUString( HTTP_URL_SCHEME ) );
2670 }
2671 else if ( aScheme == DAV_URL_SCHEME )
2672 {
2673 sourceURI.SetScheme(
2674 OUString( HTTP_URL_SCHEME ) );
2675 }
2676 else if ( aScheme == DAVS_URL_SCHEME )
2677 {
2678 sourceURI.SetScheme(
2679 OUString( HTTPS_URL_SCHEME ) );
2680 }
2681 else
2682 {
2683 if ( aScheme != HTTP_URL_SCHEME && aScheme != HTTPS_URL_SCHEME )
2684 {
2685 ucbhelper::cancelCommandExecution(
2686 uno::makeAny(
2687 ucb::InteractiveBadTransferURLException(
2688 OUString( "Unsupported URL scheme!" ),
2689 static_cast< cppu::OWeakObject * >( this ) ) ),
2690 Environment );
2691 // Unreachable
2692 }
2693 }
2694
2695 if ( targetURI.GetScheme().toAsciiLowerCase() == WEBDAV_URL_SCHEME )
2696 targetURI.SetScheme(
2697 OUString( HTTP_URL_SCHEME ) );
2698 else if ( targetURI.GetScheme().toAsciiLowerCase() == DAV_URL_SCHEME )
2699 targetURI.SetScheme(
2700 OUString( HTTP_URL_SCHEME ) );
2701
2702 // @@@ This implementation of 'transfer' only works
2703 // if the source and target are located at same host.
2704 // (Neon does not support cross-server copy/move)
2705
2706 // Check for same host
2707
2708 if ( sourceURI.GetHost().getLength() &&
2709 ( sourceURI.GetHost() != targetURI.GetHost() ) )
2710 {
2711 ucbhelper::cancelCommandExecution(
2712 uno::makeAny( ucb::InteractiveBadTransferURLException(
2713 OUString( "Different hosts!" ),
2714 static_cast< cppu::OWeakObject * >( this ) ) ),
2715 Environment );
2716 // Unreachable
2717 }
2718
2719 OUString aTitle = rArgs.NewTitle;
2720
2721 if ( aTitle.isEmpty() )
2722 aTitle = sourceURI.GetPathBaseNameUnescaped();
2723
2724 if ( aTitle == "/" )
2725 {
2726 // kso: ???
2727 aTitle.clear();
2728 }
2729
2730 targetURI.AppendPath( aTitle );
2731
2732 OUString aTargetURL = xIdentifier->getContentIdentifier();
2733 if ( ( aTargetURL.lastIndexOf( '/' ) + 1 )
2734 != aTargetURL.getLength() )
2735 aTargetURL += "/";
2736
2737 aTargetURL += aTitle;
2738
2739 uno::Reference< ucb::XContentIdentifier > xTargetId
2740 = new ::ucbhelper::ContentIdentifier( aTargetURL );
2741
2742 DAVResourceAccess aSourceAccess( xContext,
2743 xResAccess->getSessionFactory(),
2744 sourceURI.GetURI() );
2745
2746 if ( rArgs.MoveData == sal_True )
2747 {
2748 uno::Reference< ucb::XContentIdentifier > xId
2749 = new ::ucbhelper::ContentIdentifier( rArgs.SourceURL );
2750
2751 // Note: The static cast is okay here, because its sure that
2752 // xProvider is always the WebDAVContentProvider.
2753 rtl::Reference< Content > xSource
2754 = static_cast< Content * >(
2755 xProvider->queryContent( xId ).get() );
2756
2757 // [RFC 2518] - WebDAV
2758 // If a resource exists at the destination and the Overwrite
2759 // header is "T" then prior to performing the move the server
2760 // MUST perform a DELETE with "Depth: infinity" on the
2761 // destination resource. If the Overwrite header is set to
2762 // "F" then the operation will fail.
2763
2764 aSourceAccess.MOVE( sourceURI.GetPath(),
2765 targetURI.GetURI(),
2766 rArgs.NameClash
2767 == ucb::NameClash::OVERWRITE,
2768 Environment );
2769
2770 if ( xSource.is() )
2771 {
2772 // Propagate destruction to listeners.
2773 xSource->destroy( true );
2774 }
2775
2776 // DAV resources store all additional props on server!
2777 // // Rename own and all children's Additional Core Properties.
2778 // renameAdditionalPropertySet( xId->getContentIdentifier(),
2779 // xTargetId->getContentIdentifier(),
2780 // true );
2781 }
2782 else
2783 {
2784 // [RFC 2518] - WebDAV
2785 // If a resource exists at the destination and the Overwrite
2786 // header is "T" then prior to performing the copy the server
2787 // MUST perform a DELETE with "Depth: infinity" on the
2788 // destination resource. If the Overwrite header is set to
2789 // "F" then the operation will fail.
2790
2791 aSourceAccess.COPY( sourceURI.GetPath(),
2792 targetURI.GetURI(),
2793 rArgs.NameClash
2794 == ucb::NameClash::OVERWRITE,
2795 Environment );
2796
2797 // DAV resources store all additional props on server!
2798 // // Copy own and all children's Additional Core Properties.
2799 // copyAdditionalPropertySet( xId->getContentIdentifier(),
2800 // xTargetId->getContentIdentifier(),
2801 // true );
2802 }
2803
2804 // Note: The static cast is okay here, because its sure that
2805 // xProvider is always the WebDAVContentProvider.
2806 rtl::Reference< Content > xTarget
2807 = static_cast< Content * >(
2808 xProvider->queryContent( xTargetId ).get() );
2809
2810 // Announce transferred content in its new folder.
2811 xTarget->inserted();
2812 }
2813 catch ( ucb::IllegalIdentifierException const & )
2814 {
2815 // queryContent
2816 }
2817 catch ( DAVException const & e )
2818 {
2819 // [RFC 2518] - WebDAV
2820 // 412 (Precondition Failed) - The server was unable to maintain
2821 // the liveness of the properties listed in the propertybehavior
2822 // XML element or the Overwrite header is "F" and the state of
2823 // the destination resource is non-null.
2824
2825 if ( e.getStatus() == SC_PRECONDITION_FAILED )
2826 {
2827 switch ( rArgs.NameClash )
2828 {
2829 case 0/*ucb::NameClash::ERROR*/:
2830 {
2831 ucbhelper::cancelCommandExecution(
2832 uno::makeAny(
2833 ucb::NameClashException(
2834 OUString(),
2835 static_cast< cppu::OWeakObject * >( this ),
2836 task::InteractionClassification_ERROR,
2837 aTargetURI ) ),
2838 Environment );
2839 // Unreachable
2840 }
2841
2842 case ucb::NameClash::OVERWRITE:
2843 break;
2844
2845 case ucb::NameClash::KEEP: // deprecated
2846 case ucb::NameClash::RENAME:
2847 case ucb::NameClash::ASK:
2848 default:
2849 {
2850 ucbhelper::cancelCommandExecution(
2851 uno::makeAny(
2852 ucb::UnsupportedNameClashException(
2853 OUString(),
2854 static_cast< cppu::OWeakObject * >( this ),
2855 rArgs.NameClash ) ),
2856 Environment );
2857 // Unreachable
2858 }
2859 }
2860 }
2861
2862 cancelCommandExecution( e, Environment, true );
2863 // Unreachable
2864 }
2865
2866 {
2867 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2868 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
2869 }
2870 }
2871
2872
2873 void Content::destroy( bool bDeletePhysical )
2874 throw( uno::Exception )
2875 {
2876 // @@@ take care about bDeletePhysical -> trashcan support
2877
2878 uno::Reference< ucb::XContent > xThis = this;
2879
2880 deleted();
2881
2882 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2883
2884 // Process instantiated children...
2885
2886 ::http_dav_ucp::Content::ContentRefList aChildren;
2887 queryChildren( aChildren );
2888
2889 ContentRefList::const_iterator it = aChildren.begin();
2890 ContentRefList::const_iterator end = aChildren.end();
2891
2892 while ( it != end )
2893 {
2894 (*it)->destroy( bDeletePhysical );
2895 ++it;
2896 }
2897 }
2898
2899
2900 bool Content::supportsExclusiveWriteLock(
2901 const uno::Reference< ucb::XCommandEnvironment >& Environment )
2902 {
2903 if ( getResourceType( Environment ) == DAV )
2904 {
2905 if ( m_xCachedProps.get() )
2906 {
2907 uno::Sequence< ucb::LockEntry > aSupportedLocks;
2908 if ( m_xCachedProps->getValue( DAVProperties::SUPPORTEDLOCK )
2909 >>= aSupportedLocks )
2910 {
2911 for ( sal_Int32 n = 0; n < aSupportedLocks.getLength(); ++n )
2912 {
2913 if ( aSupportedLocks[ n ].Scope
2914 == ucb::LockScope_EXCLUSIVE &&
2915 aSupportedLocks[ n ].Type
2916 == ucb::LockType_WRITE )
2917 return true;
2918 }
2919 }
2920 }
2921 }
2922 return false;
2923 }
2924
2925
2926 void Content::lock(
2927 const uno::Reference< ucb::XCommandEnvironment >& Environment )
2928 throw( uno::Exception )
2929 {
2930 try
2931 {
2932 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2933 {
2934 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2935 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
2936 }
2937
2938 uno::Any aOwnerAny;
2939 aOwnerAny <<= OUString( "http://ucb.openoffice.org" );
2940
2941 ucb::Lock aLock(
2942 ucb::LockScope_EXCLUSIVE,
2943 ucb::LockType_WRITE,
2944 ucb::LockDepth_ZERO,
2945 aOwnerAny,
2946 180, // lock timeout in secs
2947 //-1, // infinite lock
2948 uno::Sequence< OUString >() );
2949
2950 xResAccess->LOCK( aLock, Environment );
2951 m_bLocked = true;
2952
2953 {
2954 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2955 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
2956 }
2957 }
2958 catch ( DAVException const & e )
2959 {
2960 cancelCommandExecution( e, Environment, false );
2961 // Unreachable
2962 }
2963 }
2964
2965
2966 void Content::unlock(
2967 const uno::Reference< ucb::XCommandEnvironment >& Environment )
2968 throw( uno::Exception )
2969 {
2970 try
2971 {
2972 boost::scoped_ptr< DAVResourceAccess > xResAccess;
2973 {
2974 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2975 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
2976 }
2977
2978 xResAccess->UNLOCK( Environment );
2979 m_bLocked = false;
2980
2981 {
2982 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2983 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
2984 }
2985 }
2986 catch ( DAVException const & e )
2987 {
2988 cancelCommandExecution( e, Environment, false );
2989 // Unreachable
2990 }
2991 }
2992
2993
2994 bool Content::exchangeIdentity(
2995 const uno::Reference< ucb::XContentIdentifier >& xNewId )
2996 {
2997 if ( !xNewId.is() )
2998 return false;
2999
3000 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
3001
3002 uno::Reference< ucb::XContent > xThis = this;
3003
3004 // Already persistent?
3005 if ( m_bTransient )
3006 {
3007 SAL_WARN( "ucb.ucp.webdav", "Content::exchangeIdentity - Not persistent!" );
3008 return false;
3009 }
3010
3011 // Exchange own identitity.
3012
3013 // Fail, if a content with given id already exists.
3014 // if ( !hasData( xNewId ) )
3015 {
3016 OUString aOldURL = m_xIdentifier->getContentIdentifier();
3017
3018 aGuard.clear();
3019 if ( exchange( xNewId ) )
3020 {
3021 // Process instantiated children...
3022
3023 ContentRefList aChildren;
3024 queryChildren( aChildren );
3025
3026 ContentRefList::const_iterator it = aChildren.begin();
3027 ContentRefList::const_iterator end = aChildren.end();
3028
3029 while ( it != end )
3030 {
3031 ContentRef xChild = (*it);
3032
3033 // Create new content identifier for the child...
3034 uno::Reference< ucb::XContentIdentifier >
3035 xOldChildId = xChild->getIdentifier();
3036 OUString aOldChildURL
3037 = xOldChildId->getContentIdentifier();
3038 OUString aNewChildURL
3039 = aOldChildURL.replaceAt(
3040 0,
3041 aOldURL.getLength(),
3042 xNewId->getContentIdentifier() );
3043 uno::Reference< ucb::XContentIdentifier > xNewChildId
3044 = new ::ucbhelper::ContentIdentifier( aNewChildURL );
3045
3046 if ( !xChild->exchangeIdentity( xNewChildId ) )
3047 return false;
3048
3049 ++it;
3050 }
3051 return true;
3052 }
3053 }
3054
3055 SAL_WARN( "ucb.ucp.webdav",
3056 "Content::exchangeIdentity - "
3057 "Panic! Cannot exchange identity!" );
3058 return false;
3059 }
3060
3061
3062 bool Content::isFolder(
3063 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
3064 throw( uno::Exception )
3065 {
3066 {
3067 osl::MutexGuard aGuard( m_aMutex );
3068
3069 if ( m_bTransient )
3070 return m_bCollection;
3071 }
3072
3073 uno::Sequence< beans::Property > aProperties( 1 );
3074 aProperties[ 0 ].Name = "IsFolder";
3075 aProperties[ 0 ].Handle = -1;
3076 uno::Reference< sdbc::XRow > xRow( getPropertyValues( aProperties, xEnv ) );
3077 if ( xRow.is() )
3078 {
3079 try
3080 {
3081 return xRow->getBoolean( 1 );
3082 }
3083 catch ( sdbc::SQLException const & )
3084 {
3085 }
3086 }
3087
3088 return false;
3089 }
3090
3091
3092 uno::Any Content::MapDAVException( const DAVException & e, bool bWrite )
3093 {
3094 // Map DAVException...
3095 uno::Any aException;
3096
3097 OUString aURL;
3098 if ( m_bTransient )
3099 {
3100 aURL = getParentURL();
3101 if ( aURL.lastIndexOf( '/' ) != ( aURL.getLength() - 1 ) )
3102 aURL += "/";
3103
3104 aURL += m_aEscapedTitle;
3105 }
3106 else
3107 {
3108 aURL = m_xIdentifier->getContentIdentifier();
3109 }
3110
3111 switch ( e.getStatus() )
3112 {
3113 case SC_NOT_FOUND:
3114 {
3115 uno::Sequence< uno::Any > aArgs( 1 );
3116 aArgs[ 0 ] <<= beans::PropertyValue(
3117 OUString("Uri"), -1,
3118 uno::makeAny(aURL),
3119 beans::PropertyState_DIRECT_VALUE);
3120
3121 aException <<=
3122 ucb::InteractiveAugmentedIOException(
3123 OUString( "Not found!" ),
3124 static_cast< cppu::OWeakObject * >( this ),
3125 task::InteractionClassification_ERROR,
3126 ucb::IOErrorCode_NOT_EXISTING,
3127 aArgs );
3128 return aException;
3129 }
3130 default:
3131 break;
3132 }
3133
3134 switch ( e.getError() )
3135 {
3136 case DAVException::DAV_HTTP_ERROR:
3137 {
3138 if ( bWrite )
3139 aException <<=
3140 ucb::InteractiveNetworkWriteException(
3141 e.getData(),
3142 static_cast< cppu::OWeakObject * >( this ),
3143 task::InteractionClassification_ERROR,
3144 e.getData() );
3145 else
3146 aException <<=
3147 ucb::InteractiveNetworkReadException(
3148 e.getData(),
3149 static_cast< cppu::OWeakObject * >( this ),
3150 task::InteractionClassification_ERROR,
3151 e.getData() );
3152 break;
3153 }
3154
3155 case DAVException::DAV_HTTP_LOOKUP:
3156 aException <<=
3157 ucb::InteractiveNetworkResolveNameException(
3158 OUString(),
3159 static_cast< cppu::OWeakObject * >( this ),
3160 task::InteractionClassification_ERROR,
3161 e.getData() );
3162 break;
3163
3164 // @@@ No matching InteractiveNetwork*Exception
3165 // case DAVException::DAV_HTTP_AUTH:
3166 // break;
3167
3168 // @@@ No matching InteractiveNetwork*Exception
3169 // case DAVException::DAV_HTTP_AUTHPROXY:
3170 // break;
3171
3172 case DAVException::DAV_HTTP_CONNECT:
3173 aException <<=
3174 ucb::InteractiveNetworkConnectException(
3175 OUString(),
3176 static_cast< cppu::OWeakObject * >( this ),
3177 task::InteractionClassification_ERROR,
3178 e.getData() );
3179 break;
3180
3181 // @@@ No matching InteractiveNetwork*Exception
3182 // case DAVException::DAV_HTTP_TIMEOUT:
3183 // break;
3184
3185 // @@@ No matching InteractiveNetwork*Exception
3186 // case DAVException::DAV_HTTP_REDIRECT:
3187 // break;
3188
3189 // @@@ No matching InteractiveNetwork*Exception
3190 // case DAVException::DAV_SESSION_CREATE:
3191 // break;
3192
3193 case DAVException::DAV_INVALID_ARG:
3194 aException <<=
3195 lang::IllegalArgumentException(
3196 OUString(),
3197 static_cast< cppu::OWeakObject * >( this ),
3198 -1 );
3199 break;
3200
3201 case DAVException::DAV_LOCKED:
3202 #if 1
3203 aException <<=
3204 ucb::InteractiveLockingLockedException(
3205 OUString( "Locked!" ),
3206 static_cast< cppu::OWeakObject * >( this ),
3207 task::InteractionClassification_ERROR,
3208 aURL,
3209 false ); // not SelfOwned
3210 #else
3211 {
3212 uno::Sequence< uno::Any > aArgs( 1 );
3213 aArgs[ 0 ] <<= beans::PropertyValue(
3214 OUString("Uri"), -1,
3215 uno::makeAny(aURL),
3216 beans::PropertyState_DIRECT_VALUE);
3217
3218 aException <<=
3219 ucb::InteractiveAugmentedIOException(
3220 OUString( "Locked!" ),
3221 static_cast< cppu::OWeakObject * >( this ),
3222 task::InteractionClassification_ERROR,
3223 ucb::IOErrorCode_LOCKING_VIOLATION,
3224 aArgs );
3225 }
3226 #endif
3227 break;
3228
3229 case DAVException::DAV_LOCKED_SELF:
3230 aException <<=
3231 ucb::InteractiveLockingLockedException(
3232 OUString( "Locked (self)!" ),
3233 static_cast< cppu::OWeakObject * >( this ),
3234 task::InteractionClassification_ERROR,
3235 aURL,
3236 true ); // SelfOwned
3237 break;
3238
3239 case DAVException::DAV_NOT_LOCKED:
3240 aException <<=
3241 ucb::InteractiveLockingNotLockedException(
3242 OUString( "Not locked!" ),
3243 static_cast< cppu::OWeakObject * >( this ),
3244 task::InteractionClassification_ERROR,
3245 aURL );
3246 break;
3247
3248 case DAVException::DAV_LOCK_EXPIRED:
3249 aException <<=
3250 ucb::InteractiveLockingLockExpiredException(
3251 OUString( "Lock expired!" ),
3252 static_cast< cppu::OWeakObject * >( this ),
3253 task::InteractionClassification_ERROR,
3254 aURL );
3255 break;
3256
3257 default:
3258 aException <<=
3259 ucb::InteractiveNetworkGeneralException(
3260 OUString(),
3261 static_cast< cppu::OWeakObject * >( this ),
3262 task::InteractionClassification_ERROR );
3263 break;
3264 }
3265
3266 return aException;
3267 }
3268
3269
3270 // static
3271 bool Content::shouldAccessNetworkAfterException( const DAVException & e )
3272 {
3273 if ( ( e.getStatus() == SC_NOT_FOUND ) ||
3274 ( e.getError() == DAVException::DAV_HTTP_LOOKUP ) ||
3275 ( e.getError() == DAVException::DAV_HTTP_CONNECT ) ||
3276 ( e.getError() == DAVException::DAV_HTTP_AUTH ) ||
3277 ( e.getError() == DAVException::DAV_HTTP_AUTHPROXY ) )
3278 return false;
3279
3280 return true;
3281 }
3282
3283
3284 void Content::cancelCommandExecution(
3285 const DAVException & e,
3286 const uno::Reference< ucb::XCommandEnvironment > & xEnv,
3287 bool bWrite /* = false */ )
3288 throw ( uno::Exception )
3289 {
3290 ucbhelper::cancelCommandExecution( MapDAVException( e, bWrite ), xEnv );
3291 // Unreachable
3292 }
3293
3294
3295 const OUString
3296 Content::getBaseURI( const boost::scoped_ptr< DAVResourceAccess > & rResAccess )
3297 {
3298 osl::Guard< osl::Mutex > aGuard( m_aMutex );
3299
3300 // First, try to obtain value of response header "Content-Location".
3301 if ( m_xCachedProps.get() )
3302 {
3303 OUString aLocation;
3304 m_xCachedProps->getValue( OUString(
3305 "Content-Location" ) ) >>= aLocation;
3306 if ( aLocation.getLength() )
3307 {
3308 try
3309 {
3310 // Do not use m_xIdentifier->getContentIdentifier() because it
3311 // for example does not reflect redirects applied to requests
3312 // done using the original URI but m_xResAccess' URI does.
3313 return rtl::Uri::convertRelToAbs( rResAccess->getURL(),
3314 aLocation );
3315 }
3316 catch ( rtl::MalformedUriException const & )
3317 {
3318 }
3319 }
3320 }
3321
3322 return OUString( rResAccess->getURL() );
3323 }
3324
3325
3326 Content::ResourceType Content::getResourceType(
3327 const uno::Reference< ucb::XCommandEnvironment >& xEnv,
3328 const boost::scoped_ptr< DAVResourceAccess > & rResAccess,
3329 bool * networkAccessAllowed )
3330 throw ( uno::Exception )
3331 {
3332 {
3333 osl::MutexGuard g(m_aMutex);
3334 if (m_eResourceType != UNKNOWN) {
3335 return m_eResourceType;
3336 }
3337 }
3338
3339 ResourceType eResourceType = UNKNOWN;
3340
3341 try
3342 {
3343 // Try to fetch some frequently used property value, e.g. those
3344 // used when loading documents... along with identifying whether
3345 // this is a DAV resource.
3346 std::vector< DAVResource > resources;
3347 std::vector< OUString > aPropNames;
3348 uno::Sequence< beans::Property > aProperties( 5 );
3349 aProperties[ 0 ].Name = "IsFolder";
3350 aProperties[ 1 ].Name = "IsDocument";
3351 aProperties[ 2 ].Name = "IsReadOnly";
3352 aProperties[ 3 ].Name = "MediaType";
3353 aProperties[ 4 ].Name = DAVProperties::SUPPORTEDLOCK;
3354
3355 ContentProperties::UCBNamesToDAVNames(
3356 aProperties, aPropNames );
3357
3358 rResAccess->PROPFIND(
3359 DAVZERO, aPropNames, resources, xEnv );
3360
3361 // TODO - is this really only one?
3362 if ( resources.size() == 1 )
3363 {
3364 osl::MutexGuard g(m_aMutex);
3365 m_xCachedProps.reset(
3366 new CachableContentProperties( resources[ 0 ] ) );
3367 m_xCachedProps->containsAllNames(
3368 aProperties, m_aFailedPropNames );
3369 }
3370
3371 eResourceType = DAV;
3372 }
3373 catch ( DAVException const & e )
3374 {
3375 rResAccess->resetUri();
3376
3377 if ( e.getStatus() == SC_METHOD_NOT_ALLOWED )
3378 {
3379 // Status SC_METHOD_NOT_ALLOWED is a safe indicator that the
3380 // resource is NON_DAV
3381 eResourceType = NON_DAV;
3382 }
3383 else if (networkAccessAllowed != 0)
3384 {
3385 *networkAccessAllowed = *networkAccessAllowed
3386 && shouldAccessNetworkAfterException(e);
3387 }
3388
3389 // cancel command execution is case that no user authentication data has been provided.
3390 if ( e.getError() == DAVException::DAV_HTTP_NOAUTH )
3391 {
3392 cancelCommandExecution( e, uno::Reference< ucb::XCommandEnvironment >() );
3393 }
3394 }
3395
3396 osl::MutexGuard g(m_aMutex);
3397 if (m_eResourceType == UNKNOWN) {
3398 m_eResourceType = eResourceType;
3399 } else {
3400 SAL_WARN_IF(
3401 eResourceType != m_eResourceType, "ucb.ucp.webdav",
3402 "different resource types for <" << rResAccess->getURL() << ">: "
3403 << +eResourceType << " vs. " << +m_eResourceType);
3404 }
3405 return m_eResourceType;
3406 }
3407
3408
3409 Content::ResourceType Content::getResourceType(
3410 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
3411 throw ( uno::Exception )
3412 {
3413 boost::scoped_ptr< DAVResourceAccess > xResAccess;
3414 {
3415 osl::MutexGuard aGuard( m_aMutex );
3416 xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
3417 }
3418 const Content::ResourceType & ret = getResourceType( xEnv, xResAccess );
3419 {
3420 osl::Guard< osl::Mutex > aGuard( m_aMutex );
3421 m_xResAccess.reset( new DAVResourceAccess( *xResAccess.get() ) );
3422 }
3423 return ret;
3424 }
3425
3426 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE