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