?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / applied_patches / 0101-webdav-locking-from-ooo-build-2-4-1.diff
blob01d4b6820a9a8a3ca3d376c06c873921144e95dd
1 --- officecfg/registry/data/org/openoffice/ucb/Configuration.xcu.old 2009-04-02 11:01:44.000000000 +0000
2 +++ officecfg/registry/data/org/openoffice/ucb/Configuration.xcu 2009-04-06 16:41:46.000000000 +0000
3 @@ -178,6 +178,28 @@
4 <value/>
5 </prop>
6 </node>
7 + <node oor:name="Provider14" oor:op="replace">
8 + <prop oor:name="ServiceName">
9 + <value>com.sun.star.ucb.WebDAVContentProvider</value>
10 + </prop>
11 + <prop oor:name="URLTemplate">
12 + <value>webdav</value>
13 + </prop>
14 + <prop oor:name="Arguments">
15 + <value/>
16 + </prop>
17 + </node>
18 + <node oor:name="Provider15" oor:op="replace">
19 + <prop oor:name="ServiceName">
20 + <value>com.sun.star.ucb.WebDAVContentProvider</value>
21 + </prop>
22 + <prop oor:name="URLTemplate">
23 + <value>webdavs</value>
24 + </prop>
25 + <prop oor:name="Arguments">
26 + <value/>
27 + </prop>
28 + </node>
29 <!-- We want the Provider to be the final fallback provider -->
30 <node oor:name="Provider999" oor:op="replace" install:module="gio">
31 <prop oor:name="ServiceName">
32 --- sal/inc/osl/file.h.old 2009-04-02 10:43:39.000000000 +0000
33 +++ sal/inc/osl/file.h 2009-04-06 16:41:46.000000000 +0000
34 @@ -139,6 +139,7 @@ typedef enum {
35 osl_File_E_USERS,
36 osl_File_E_OVERFLOW,
37 osl_File_E_NOTREADY,
38 + osl_File_E_TXTBSY,
39 osl_File_E_invalidError, /* unmapped error: always last entry in enum! */
40 osl_File_E_TIMEDOUT,
41 osl_File_E_NETWORK,
42 --- sal/inc/osl/file.hxx.old 2009-04-02 10:43:39.000000000 +0000
43 +++ sal/inc/osl/file.hxx 2009-04-06 16:41:46.000000000 +0000
44 @@ -106,6 +106,7 @@ public:
45 E_USERS = osl_File_E_USERS,
46 E_OVERFLOW = osl_File_E_OVERFLOW,
47 E_NOTREADY = osl_File_E_NOTREADY,
48 + E_TXTBSY = osl_File_E_TXTBSY,
49 E_invalidError = osl_File_E_invalidError, /* unmapped error: always last entry in enum! */
50 E_TIMEDOUT = osl_File_E_TIMEDOUT,
51 E_NETWORK = osl_File_E_NETWORK
52 --- sal/osl/unx/file_error_transl.cxx.old 2009-04-02 10:43:46.000000000 +0000
53 +++ sal/osl/unx/file_error_transl.cxx 2009-04-06 16:41:46.000000000 +0000
54 @@ -247,6 +247,10 @@ oslFileError oslTranslateFileError(sal_B
55 osl_error = osl_File_E_TIMEDOUT;
56 break;
57
58 + case ETXTBSY:
59 + osl_error = osl_File_E_TXTBSY;
60 + break;
61 +
62 default:
63 /* FIXME translateFileError: is this alright? Or add a new one: osl_File_E_Unknown? */
64 osl_error = osl_File_E_invalidError;
65 --- sc/source/ui/docshell/docsh.cxx.old 2009-04-02 10:45:27.000000000 +0000
66 +++ sc/source/ui/docshell/docsh.cxx 2009-04-06 16:41:46.000000000 +0000
67 @@ -823,7 +823,7 @@ BOOL __EXPORT ScDocShell::ConvertFrom( S
68 // Alle Filter brauchen die komplette Datei am Stueck (nicht asynchron),
69 // darum vorher per CreateFileStream dafuer sorgen, dass die komplette
70 // Datei uebertragen wird.
71 - rMedium.GetPhysicalName(); //! CreateFileStream direkt rufen, wenn verfuegbar
72 + rMedium.GetPhysicalName( sal_False ); //! CreateFileStream direkt rufen, wenn verfuegbar
73
74 SFX_ITEMSET_ARG( rMedium.GetItemSet(), pUpdateDocItem, SfxUInt16Item, SID_UPDATEDOCMODE, sal_False);
75 nCanUpdate = pUpdateDocItem ? pUpdateDocItem->GetValue() : com::sun::star::document::UpdateDocMode::NO_UPDATE;
76 --- sfx2/inc/sfx2/docfile.hxx
77 +++ sfx2/inc/sfx2/docfile.hxx
78 @@ -186,7 +186,7 @@ public:
79 ::com::sun::star::util::DateTime GetInitFileDate( sal_Bool bIgnoreOldValue );
80
81 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XContent > GetContent() const;
82 - const String& GetPhysicalName() const;
83 + const String& GetPhysicalName( sal_Bool bForceCreateTempIfRemote = sal_True ) const;
84 void SetTemporary( sal_Bool bTemp );
85 sal_Bool IsTemporary() const;
86 sal_Bool IsRemote();
87 @@ -260,6 +260,8 @@ public:
88 void SetCharset( ::rtl::OUString );
89 ::rtl::OUString GetBaseURL( bool bForSaving=false );
90
91 + sal_Bool SupportsActiveStreaming( const rtl::OUString &rName ) const;
92 +
93 #if _SOLAR__PRIVATE
94 //REMOVE // the storage will be truncated, if it is still not open then the stream will be truncated
95 //REMOVE ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > GetOutputStorage_Impl();
96 --- sfx2/source/bastyp/helper.cxx.old 2009-04-02 10:43:55.000000000 +0000
97 +++ sfx2/source/bastyp/helper.cxx 2009-04-06 16:41:46.000000000 +0000
98 @@ -796,16 +796,15 @@ ErrCode SfxContentHelper::QueryDiskSpace
99
100 // -----------------------------------------------------------------------
101
102 -ULONG SfxContentHelper::GetSize( const String& rContent )
103 +sal_Int64 SfxContentHelper::GetSize( const String& rContent )
104 {
105 - ULONG nSize = 0;
106 - sal_Int64 nTemp = 0;
107 + sal_Int64 nSize = -1;
108 INetURLObject aObj( rContent );
109 DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" );
110 try
111 {
112 ::ucbhelper::Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ucb::XCommandEnvironment > () );
113 - aCnt.getPropertyValue( OUString::createFromAscii( "Size" ) ) >>= nTemp;
114 + aCnt.getPropertyValue( OUString::createFromAscii( "Size" ) ) >>= nSize;
115 }
116 catch( ucb::CommandAbortedException& )
117 {
118 @@ -815,7 +814,6 @@ ULONG SfxContentHelper::GetSize( const S
119 {
120 DBG_ERRORFILE( "Any other exception" );
121 }
122 - nSize = (UINT32)nTemp;
123 return nSize;
124 }
125
126 --- sfx2/source/dialog/dinfdlg.cxx.old 2009-04-02 10:43:54.000000000 +0000
127 +++ sfx2/source/dialog/dinfdlg.cxx 2009-04-06 16:41:46.000000000 +0000
128 @@ -1153,8 +1153,9 @@ void SfxDocumentPage::Reset( const SfxIt
129
130 // determine size and type
131 String aSizeText( aUnknownSize );
132 - if ( aURL.GetProtocol() == INET_PROT_FILE )
133 - aSizeText = CreateSizeText( SfxContentHelper::GetSize( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
134 + sal_Int64 nSize = SfxContentHelper::GetSize( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
135 + if ( nSize >= 0 )
136 + aSizeText = CreateSizeText( static_cast< ULONG >( nSize ) );
137 aShowSizeFT.SetText( aSizeText );
138
139 String aDescription = SvFileInformationManager::GetDescription( INetURLObject(rMainURL) );
140 --- sfx2/source/doc/docfile.cxx
141 +++ sfx2/source/doc/docfile.cxx
142 @@ -533,7 +533,7 @@
143 //------------------------------------------------------------------
144 sal_Bool SfxMedium::DocNeedsFileDateCheck()
145 {
146 - return ( !IsReadOnly() && ::utl::LocalFileHelper::IsLocalFile( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) ) );
147 + return ( !IsReadOnly() && SupportsActiveStreaming( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) ) );
148 }
149
150 //------------------------------------------------------------------
151 @@ -749,10 +749,13 @@ sal_Bool SfxMedium::CloseOutStream_Impl(
152 }
153
154 //------------------------------------------------------------------
155 -const String& SfxMedium::GetPhysicalName() const
156 +const String& SfxMedium::GetPhysicalName( sal_Bool bForceCreateTempIfRemote ) const
157 {
158 if ( !aName.Len() && aLogicName.Len() )
159 - (( SfxMedium*)this)->CreateFileStream();
160 + {
161 + if ( bForceCreateTempIfRemote || !SupportsActiveStreaming( aLogicName ) )
162 + (( SfxMedium*)this)->CreateFileStream();
163 + }
164
165 // return the name then
166 return aName;
167 @@ -796,8 +799,6 @@ sal_Bool SfxMedium::Commit()
168 if ( bResult && DocNeedsFileDateCheck() )
169 GetInitFileDate( sal_True );
170
171 - // remove truncation mode from the flags
172 - nStorOpenMode &= (~STREAM_TRUNC);
173 return bResult;
174 }
175
176 @@ -928,11 +929,31 @@ sal_Bool SfxMedium::TryStorage()
177 }
178
179 //------------------------------------------------------------------
180 +sal_Bool SfxMedium::SupportsActiveStreaming( const rtl::OUString &rName ) const
181 +{
182 + if ( ::utl::LocalFileHelper::IsLocalFile( rName ) )
183 + return sal_True;
184 +
185 + ::ucbhelper::Content aTmpContent;
186 + Reference< ::com::sun::star::ucb::XCommandEnvironment > xDummyEnv;
187 + if ( ::ucbhelper::Content::create( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv, aTmpContent ) )
188 + {
189 + Any aAny = aTmpContent.getPropertyValue(
190 + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "SupportsActiveStreaming" )) );
191 +
192 + sal_Bool bSupportsStreaming = sal_False;
193 + return ( ( aAny >>= bSupportsStreaming ) && bSupportsStreaming );
194 + }
195 +
196 + return sal_False;
197 +}
198 +
199 +//------------------------------------------------------------------
200 sal_Bool SfxMedium::BasedOnOriginalFile_Impl()
201 {
202 return ( !pImp->pTempFile && !( aLogicName.Len() && pImp->m_bSalvageMode )
203 && GetURLObject().GetMainURL( INetURLObject::NO_DECODE ).getLength()
204 - && ::utl::LocalFileHelper::IsLocalFile( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) )
205 + && SupportsActiveStreaming( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) )
206 && ::utl::UCBContentHelper::IsDocument( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) ) );
207 }
208
209 @@ -996,10 +1017,105 @@ uno::Reference < embed::XStorage > SfxMe
210
211 DBG_ASSERT( !pOutStream, "OutStream in a readonly Medium?!" );
212
213 - // TODO/LATER: The current solution is to store the document temporary and then copy it to the target location;
214 - // in future it should be stored directly and then copied to the temporary location, since in this case no
215 - // file attributes have to be preserved and system copying mechanics could be used instead of streaming.
216 + // medium based on OutputStream: must work with TempFile
217 + if( aLogicName.CompareToAscii( "private:stream", 14 ) == COMPARE_EQUAL
218 + || !::utl::LocalFileHelper::IsLocalFile( aLogicName ) )
219 CreateTempFileNoCopy();
220 + // if Medium already contains a stream - TODO/LATER: store stream/outputstream in ImplData, not in Medium
221 + else if ( GetItemSet()->GetItemState( SID_STREAM ) < SFX_ITEM_SET )
222 + {
223 + // check whether the backup should be created
224 + StorageBackup_Impl();
225 +
226 + if ( GetError() )
227 + return uno::Reference< embed::XStorage >();
228 +
229 + ::rtl::OUString aOutputURL = GetOutputStorageURL_Impl();
230 +
231 + SFX_ITEMSET_ARG( GetItemSet(), pOverWrite, SfxBoolItem, SID_OVERWRITE, sal_False );
232 + SFX_ITEMSET_ARG( GetItemSet(), pRename, SfxBoolItem, SID_RENAME, sal_False );
233 + sal_Bool bRename = pRename ? pRename->GetValue() : FALSE;
234 + sal_Bool bOverWrite = pOverWrite ? pOverWrite->GetValue() : !bRename;
235 +
236 + // the target file must be truncated before a storage based on it is created
237 + try
238 + {
239 + uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory();
240 + uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess > xSimpleFileAccess(
241 + xFactory->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.ucb.SimpleFileAccess") ),
242 + uno::UNO_QUERY_THROW );
243 +
244 + uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
245 + ::ucbhelper::Content aContent = ::ucbhelper::Content( aOutputURL, xDummyEnv );
246 +
247 + uno::Reference< io::XStream > xStream;
248 + sal_Bool bDeleteOnFailure = sal_False;
249 +
250 + try
251 + {
252 + xStream = aContent.openWriteableStreamNoLock();
253 +
254 + if ( !bOverWrite )
255 + {
256 + // the stream should not exist, it should not be possible to open it
257 + if ( xStream->getOutputStream().is() )
258 + xStream->getOutputStream()->closeOutput();
259 + if ( xStream->getInputStream().is() )
260 + xStream->getInputStream()->closeInput();
261 +
262 + xStream = uno::Reference< io::XStream >();
263 + SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
264 + }
265 + }
266 + catch ( ucb::InteractiveIOException const & e )
267 + {
268 + if ( e.Code == ucb::IOErrorCode_NOT_EXISTING )
269 + {
270 + // Create file...
271 + SvMemoryStream aStream(0,0);
272 + uno::Reference< io::XInputStream > xInput( new ::utl::OInputStreamWrapper( aStream ) );
273 + ucb::InsertCommandArgument aInsertArg;
274 + aInsertArg.Data = xInput;
275 + aInsertArg.ReplaceExisting = sal_False;
276 + aContent.executeCommand( rtl::OUString::createFromAscii( "insert" ), uno::makeAny( aInsertArg ) );
277 +
278 + // Try to open one more time
279 + xStream = aContent.openWriteableStreamNoLock();
280 + bDeleteOnFailure = sal_True;
281 + }
282 + else
283 + throw;
284 + }
285 +
286 + if ( xStream.is() )
287 + {
288 + if ( BasedOnOriginalFile_Impl() )
289 + {
290 + // the storage will be based on original file, the wrapper should be used
291 + xStream = new OPostponedTruncationFileStream( aOutputURL, xFactory, xSimpleFileAccess, xStream, bDeleteOnFailure );
292 + }
293 + else
294 + {
295 + // the storage will be based on the temporary file, the stream can be truncated directly
296 + uno::Reference< io::XOutputStream > xOutStream = xStream->getOutputStream();
297 + uno::Reference< io::XTruncate > xTruncate( xOutStream, uno::UNO_QUERY );
298 + if ( !xTruncate.is() )
299 + throw uno::RuntimeException();
300 +
301 + xTruncate->truncate();
302 + xOutStream->flush();
303 + }
304 +
305 + pImp->xStream = xStream;
306 + GetItemSet()->Put( SfxUsrAnyItem( SID_STREAM, makeAny( xStream ) ) );
307 + }
308 + }
309 + catch( uno::Exception& )
310 + {
311 + // TODO/LATER: try to use the temporary file in case the target content can not be opened, it might happen in case of some FS, the copy functionality might work in this case
312 + SetError( ERRCODE_IO_GENERAL, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
313 + }
314 + }
315
316 return GetStorage();
317 }
318 @@ -1381,7 +1497,7 @@ uno::Reference < embed::XStorage > SfxMe
319
320 try
321 {
322 - if ( IsReadOnly() && ::utl::LocalFileHelper::IsLocalFile( aLogicName ) )
323 + if ( IsReadOnly() && SupportsActiveStreaming( aLogicName ) )
324 {
325 //TODO/LATER: performance problem if not controlled by special Mode in SfxMedium
326 //(should be done only for permanently open storages)
327 @@ -2210,7 +2326,7 @@ void SfxMedium::Transfer_Impl()
328 xComEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler,
329 Reference< ::com::sun::star::ucb::XProgressHandler >() );
330
331 - if ( ::utl::LocalFileHelper::IsLocalFile( aDest.GetMainURL( INetURLObject::NO_DECODE ) ) || !aDest.removeSegment() )
332 + if ( SupportsActiveStreaming( aDest.GetMainURL( INetURLObject::NO_DECODE ) ) || !aDest.removeSegment() )
333 {
334 TransactedTransferForFS_Impl( aSource, aDest, xComEnv );
335 }
336 @@ -2542,7 +2658,7 @@ void SfxMedium::GetMedium_Impl()
337 aMedium.erase( comphelper::MediaDescriptor::PROP_READONLY() );
338 aMedium.addInputStream();
339 }
340 - else if ( ::utl::LocalFileHelper::IsLocalFile( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) ) )
341 + else if ( SupportsActiveStreaming( GetURLObject().GetMainURL( INetURLObject::NO_DECODE ) ) )
342 {
343 // use the special locking approach only for file URLs
344 aMedium.addInputStreamOwnLock();
345 --- sfx2/source/inc/helper.hxx.old 2009-04-02 10:43:59.000000000 +0000
346 +++ sfx2/source/inc/helper.hxx 2009-04-06 16:41:46.000000000 +0000
347 @@ -69,7 +69,7 @@ public:
348
349 static sal_Bool MakeFolder( const String& rFolder );
350 static ErrCode QueryDiskSpace( const String& rPath, sal_Int64& rFreeBytes );
351 - static ULONG GetSize( const String& rContent );
352 + static sal_Int64 GetSize( const String& rContent );
353 static sal_Bool IsYounger( const String& rIsYoung, const String& rIsOlder );
354
355 // please don't use this!
356 --- sfx2/source/view/viewfrm.cxx.old 2009-04-02 10:44:00.000000000 +0000
357 +++ sfx2/source/view/viewfrm.cxx 2009-04-06 16:41:46.000000000 +0000
358 @@ -631,6 +631,11 @@ void SfxViewFrame::ExecReload_Impl( SfxR
359 sal_Bool bHandsOff =
360 ( pMedium->GetURLObject().GetProtocol() == INET_PROT_FILE && !xOldObj->IsDocShared() );
361
362 + // we must do the same for the contents that support active
363 + // streaming
364 + if ( !bHandsOff && pMedium && pMedium->SupportsActiveStreaming( aURL ) )
365 + bHandsOff = sal_True;
366 +
367 // bestehende SfxMDIFrames f"ur dieses Doc leeren
368 // eigenes Format oder R/O jetzt editierbar "offnen?
369 SfxViewNotificatedFrameList_Impl aFrames;
370 --- tools/inc/tools/urlobj.hxx.old 2009-04-06 16:41:45.000000000 +0000
371 +++ tools/inc/tools/urlobj.hxx 2009-04-06 16:41:46.000000000 +0000
372 @@ -141,9 +141,14 @@ enum INetProtocol
373 INET_PROT_TELNET = 28,
374 INET_PROT_VND_SUN_STAR_EXPAND = 29,
375 INET_PROT_VND_SUN_STAR_TDOC = 30,
376 - INET_PROT_GENERIC = 31,
377 - INET_PROT_SMB = 32,
378 - INET_PROT_END = 33
379 + INET_PROT_SMB = 31,
380 + INET_PROT_DAV = 32,
381 + INET_PROT_DAVS = 33,
382 + INET_PROT_WEBDAV = 34,
383 + INET_PROT_WEBDAVS = 35,
384 + INET_PROT_GENERIC = 36,
385 + INET_PROT_GENERIC_HIERARCHICAL = 37,
386 + INET_PROT_END = 38
387 };
388
389 //============================================================================
390 --- tools/source/fsys/urlobj.cxx.old 2009-04-06 16:41:45.000000000 +0000
391 +++ tools/source/fsys/urlobj.cxx 2009-04-06 16:41:46.000000000 +0000
392 @@ -374,21 +374,21 @@ static INetURLObject::SchemeInfo const a
393 false },
394 { "ftp", "ftp://", 21, true, true, false, true, true, true, true,
395 false },
396 - { "http", "http://", 80, true, false, false, false, true, true,
397 + { "http", "http://", 80, true, true, false, true, true, true,
398 true, true },
399 { "file", "file://", 0, true, false, false, false, true, false,
400 true, false },
401 { "mailto", "mailto:", 0, false, false, false, false, false,
402 false, false, true },
403 - { "vnd.sun.star.webdav", "vnd.sun.star.webdav://", 80, true, false,
404 - false, false, true, true, true, true },
405 + { "vnd.sun.star.webdav", "vnd.sun.star.webdav://", 80, true, true,
406 + false, true, true, true, true, true },
407 { "news", "news:", 0, false, false, false, false, false, false, false,
408 false },
409 { "private", "private:", 0, false, false, false, false, false,
410 false, false, true },
411 { "vnd.sun.star.help", "vnd.sun.star.help://", 0, true, false, false,
412 false, false, false, true, true },
413 - { "https", "https://", 443, true, false, false, false, true, true,
414 + { "https", "https://", 443, true, true, false, true, true, true,
415 true, true },
416 { "slot", "slot:", 0, false, false, false, false, false, false,
417 false, true },
418 @@ -432,9 +432,19 @@ static INetURLObject::SchemeInfo const a
419 false, false, false, false, false },
420 { "vnd.sun.star.tdoc", "vnd.sun.star.tdoc:", 0, false, false, false,
421 false, false, false, true, false },
422 - { "", "", 0, false, false, false, false, false, false, false, false },
423 { "smb", "smb://", 139, true, true, false, true, true, true, true,
424 - true } };
425 + true },
426 + { "dav", "dav://", 80, true, true, false, true, true, true, true,
427 + true },
428 + { "davs", "davs://", 443, true, true, false, true, true, true,
429 + true, true },
430 + { "webdav", "webdav://", 80, true, true, false, true, true, true, true,
431 + true },
432 + { "webdavs", "webdavs://", 443, true, true, false, true, true, true,
433 + true, true },
434 + { "", "", 0, false, false, false, false, false, false, false, false },
435 + { "", "", 0, false, false, false, false, false, false, true, false }
436 + };
437
438 // static
439 inline INetURLObject::SchemeInfo const &
440 @@ -849,7 +859,10 @@ bool INetURLObject::setAbsURIRef(rtl::OU
441 aSynScheme = parseScheme(&p1, pEnd, nFragmentDelimiter);
442 if (aSynScheme.getLength() > 0)
443 {
444 - m_eScheme = INET_PROT_GENERIC;
445 + if (p1 != pEnd && *p1 == '/')
446 + m_eScheme = INET_PROT_GENERIC_HIERARCHICAL;
447 + else
448 + m_eScheme = INET_PROT_GENERIC;
449 pPos = p1;
450 }
451 }
452 @@ -866,8 +879,9 @@ bool INetURLObject::setAbsURIRef(rtl::OU
453 return false;
454 }
455
456 - if (m_eScheme != INET_PROT_GENERIC) {
457 - aSynScheme = rtl::OUString::createFromAscii(getSchemeInfo().m_pScheme);
458 + const char *pSchemeName = getSchemeInfo().m_pScheme;
459 + if (pSchemeName[0] != '\0') {
460 + aSynScheme = rtl::OUString::createFromAscii(pSchemeName);
461 }
462 m_aScheme.set(aSynAbsURIRef, aSynScheme, aSynAbsURIRef.getLength());
463 aSynAbsURIRef.append(sal_Unicode(':'));
464 @@ -2120,6 +2134,8 @@ INetURLObject::getPrefix(sal_Unicode con
465 PrefixInfo::INTERNAL },
466 { "cid:", 0, INET_PROT_CID, PrefixInfo::OFFICIAL },
467 { "data:", 0, INET_PROT_DATA, PrefixInfo::OFFICIAL },
468 + { "dav:", 0, INET_PROT_DAV, PrefixInfo::OFFICIAL },
469 + { "davs:", 0, INET_PROT_DAVS, PrefixInfo::OFFICIAL },
470 { "db:", "staroffice.db:", INET_PROT_DB, PrefixInfo::INTERNAL },
471 { "file:", 0, INET_PROT_FILE, PrefixInfo::OFFICIAL },
472 { "ftp:", 0, INET_PROT_FTP, PrefixInfo::OFFICIAL },
473 @@ -2201,6 +2217,8 @@ INetURLObject::getPrefix(sal_Unicode con
474 PrefixInfo::OFFICIAL },
475 { "vnd.sun.star.wfs:", 0, INET_PROT_VND_SUN_STAR_WFS,
476 PrefixInfo::OFFICIAL },
477 + { "webdav:", 0, INET_PROT_WEBDAV, PrefixInfo::OFFICIAL },
478 + { "webdavs:", 0, INET_PROT_WEBDAVS, PrefixInfo::OFFICIAL },
479 { "wfs:", "vnd.sun.star.wfs:", INET_PROT_VND_SUN_STAR_WFS,
480 PrefixInfo::ALIAS } };
481 PrefixInfo const * pFirst = aMap + 1;
482 @@ -3004,6 +3022,10 @@ bool INetURLObject::parsePath(INetProtoc
483 case INET_PROT_VND_SUN_STAR_WEBDAV:
484 case INET_PROT_HTTPS:
485 case INET_PROT_SMB:
486 + case INET_PROT_DAV:
487 + case INET_PROT_DAVS:
488 + case INET_PROT_WEBDAV:
489 + case INET_PROT_WEBDAVS:
490 if (pPos < pEnd && *pPos != '/')
491 return false;
492 while (pPos < pEnd && *pPos != nQueryDelimiter
493 @@ -3422,6 +3444,7 @@ bool INetURLObject::parsePath(INetProtoc
494 break;
495
496 case INET_PROT_GENERIC:
497 + case INET_PROT_GENERIC_HIERARCHICAL:
498 while (pPos < pEnd && *pPos != nFragmentDelimiter)
499 {
500 EscapeType eEscapeType;
501 @@ -4133,10 +4156,13 @@ bool INetURLObject::ConcatData(INetProto
502 {
503 setInvalid();
504 m_eScheme = eTheScheme;
505 - if (HasError() || m_eScheme == INET_PROT_GENERIC)
506 + const char *pSchemeName = getSchemeInfo().m_pScheme;
507 +
508 + if (HasError() || pSchemeName[0] == '\0')
509 return false;
510 +
511 m_aAbsURIRef.setLength(0);
512 - m_aAbsURIRef.appendAscii(getSchemeInfo().m_pScheme);
513 + m_aAbsURIRef.appendAscii(pSchemeName);
514 m_aAbsURIRef.append(sal_Unicode(':'));
515 if (getSchemeInfo().m_bAuthority)
516 {
517 --- tools/workben/urltest.cxx.old 2009-04-02 10:36:25.000000000 +0000
518 +++ tools/workben/urltest.cxx 2009-04-06 16:41:46.000000000 +0000
519 @@ -1476,7 +1476,7 @@ main()
520
521 url = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("A-b.3:/%2f?x#y"));
522 urlobj = INetURLObject(url);
523 - bSuccess &= assertEqual(url, INET_PROT_GENERIC, urlobj.GetProtocol());
524 + bSuccess &= assertEqual(url, INET_PROT_GENERIC_HIERARCHICAL, urlobj.GetProtocol());
525 bSuccess &= assertEqual(
526 url, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("a-b.3:/%2F?x#y")),
527 rtl::OUString(urlobj.GetMainURL(INetURLObject::NO_DECODE)));
528 @@ -1504,7 +1504,7 @@ main()
529
530 url = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo:/"));
531 urlobj = INetURLObject(url);
532 - bSuccess &= assertEqual(url, INET_PROT_GENERIC, urlobj.GetProtocol());
533 + bSuccess &= assertEqual(url, INET_PROT_GENERIC_HIERARCHICAL, urlobj.GetProtocol());
534 bSuccess &= assertEqual(
535 url, url,
536 rtl::OUString(urlobj.GetMainURL(INetURLObject::NO_DECODE)));
537 @@ -1542,7 +1542,7 @@ main()
538
539 url = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("A-b.3:/%2f?x#y"));
540 urlobj = INetURLObject(url, INET_PROT_CID);
541 - bSuccess &= assertEqual(url, INET_PROT_GENERIC, urlobj.GetProtocol());
542 + bSuccess &= assertEqual(url, INET_PROT_GENERIC_HIERARCHICAL, urlobj.GetProtocol());
543 bSuccess &= assertEqual(
544 url, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("a-b.3:/%2F?x#y")),
545 rtl::OUString(urlobj.GetMainURL(INetURLObject::NO_DECODE)));
546 @@ -1563,7 +1563,7 @@ main()
547
548 url = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo:/"));
549 urlobj = INetURLObject(url, INET_PROT_CID);
550 - bSuccess &= assertEqual(url, INET_PROT_GENERIC, urlobj.GetProtocol());
551 + bSuccess &= assertEqual(url, INET_PROT_GENERIC_HIERARCHICAL, urlobj.GetProtocol());
552 bSuccess &= assertEqual(
553 url, url,
554 rtl::OUString(urlobj.GetMainURL(INetURLObject::NO_DECODE)));
555 --- ucb/source/ucp/file/filglob.cxx.old 2009-04-02 11:01:37.000000000 +0000
556 +++ ucb/source/ucp/file/filglob.cxx 2009-04-06 16:41:46.000000000 +0000
557 @@ -361,17 +361,13 @@ namespace fileaccess {
558 // not enough memory for allocating structures
559 ioErrorCode = IOErrorCode_OUT_OF_MEMORY;
560 break;
561 - case FileBase::E_BUSY:
562 - // Text file busy
563 - ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
564 - break;
565 - case FileBase::E_AGAIN:
566 - // Operation would block
567 +
568 + case FileBase::E_BUSY: // Text file busy
569 + case FileBase::E_AGAIN: // Operation would block
570 + case FileBase::E_NOLCK: // No record locks available
571 + case FileBase::E_TXTBSY:// Text file busy
572 ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
573 break;
574 - case FileBase::E_NOLCK: // No record locks available
575 - ioErrorCode = IOErrorCode_LOCKING_VIOLATION;
576 - break;
577
578 case FileBase::E_FAULT: // Bad address
579 case FileBase::E_LOOP: // Too many symbolic links encountered
580 --- ucb/source/ucp/webdav/DAVRequestEnvironment.hxx.old 2009-04-02 11:01:38.000000000 +0000
581 +++ ucb/source/ucp/webdav/DAVRequestEnvironment.hxx 2009-04-06 16:41:46.000000000 +0000
582 @@ -34,6 +34,10 @@
583 #include <rtl/ref.hxx>
584 #include "DAVAuthListener.hxx"
585
586 +#ifndef _COM_SUN_STAR_UCB_XCOMMANDENVIRONMENT_HPP_
587 +#include <com/sun/star/ucb/XCommandEnvironment.hpp>
588 +#endif
589 +
590 namespace webdav_ucp
591 {
592 typedef std::pair< rtl::OUString, rtl::OUString > DAVRequestHeader;
593 @@ -46,12 +50,12 @@ struct DAVRequestEnvironment
594 // rtl::Reference< DAVStatusListener > m_xStatusListener;
595 // rtl::Reference< DAVProgressListener > m_xStatusListener;
596 DAVRequestHeaders m_aRequestHeaders;
597 - uno::Reference< ucb::XCommandEnvironment > m_xEnv;
598 + com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > m_xEnv;
599
600 -DAVRequestEnvironment( const rtl::OUString & rRequestURI,
601 + DAVRequestEnvironment( const rtl::OUString & rRequestURI,
602 const rtl::Reference< DAVAuthListener > & xListener,
603 const DAVRequestHeaders & rRequestHeaders,
604 - const uno::Reference< ucb::XCommandEnvironment > & xEnv)
605 + const com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > & xEnv)
606 : m_aRequestURI( rRequestURI ),
607 m_xAuthListener( xListener ),
608 m_aRequestHeaders( rRequestHeaders ),
609 --- ucb/source/ucp/webdav/DAVResourceAccess.cxx
610 +++ ucb/source/ucp/webdav/DAVResourceAccess.cxx
611 @@ -42,6 +42,9 @@
612 #include "DAVAuthListenerImpl.hxx"
613 #include "DAVResourceAccess.hxx"
614
615 +#include <comphelper/processfactory.hxx>
616 +#include <ucbhelper/commandenvironment.hxx>
617 +
618 using namespace webdav_ucp;
619 using namespace com::sun::star;
620
621 @@ -61,58 +64,57 @@ int DAVAuthListener_Impl::authenticate(
622 ::rtl::OUString & outPassWord,
623 const sal_Bool & bAllowPersistentStoring)
624 {
625 - if ( m_xEnv.is() )
626 - {
627 - uno::Reference< task::XInteractionHandler > xIH
628 - = m_xEnv->getInteractionHandler();
629 - if ( xIH.is() )
630 - {
631 - // #102871# - Supply username and password from previous try.
632 - // Password container service depends on this!
633 - if ( inoutUserName.getLength() == 0 )
634 - inoutUserName = m_aPrevUsername;
635 -
636 - if ( outPassWord.getLength() == 0 )
637 - outPassWord = m_aPrevPassword;
638 -
639 - rtl::Reference< ucbhelper::SimpleAuthenticationRequest > xRequest
640 - = new ucbhelper::SimpleAuthenticationRequest( inHostName,
641 - inRealm,
642 - inoutUserName,
643 - outPassWord,
644 - ::rtl::OUString(),
645 - bAllowPersistentStoring);
646 - xIH->handle( xRequest.get() );
647 + uno::Reference< task::XInteractionHandler > xIH;
648
649 - rtl::Reference< ucbhelper::InteractionContinuation > xSelection
650 - = xRequest->getSelection();
651 -
652 - if ( xSelection.is() )
653 - {
654 - // Handler handled the request.
655 - uno::Reference< task::XInteractionAbort > xAbort(
656 - xSelection.get(), uno::UNO_QUERY );
657 - if ( !xAbort.is() )
658 - {
659 - const rtl::Reference<
660 - ucbhelper::InteractionSupplyAuthentication > & xSupp
661 - = xRequest->getAuthenticationSupplier();
662 -
663 - inoutUserName = xSupp->getUserName();
664 - outPassWord = xSupp->getPassword();
665 -
666 - // #102871# - Remember username and password.
667 - m_aPrevUsername = inoutUserName;
668 - m_aPrevPassword = outPassWord;
669 + if ( m_xEnv.is() )
670 + xIH = m_xEnv->getInteractionHandler();
671 + else
672 + xIH = DAVResourceAccess::createCommandEnvironment()->getInteractionHandler();
673 +
674 + if ( !xIH.is() )
675 + return -1;
676 +
677 + // #102871# - Supply username and password from previous try.
678 + // Password container service depends on this!
679 + if ( inoutUserName.getLength() == 0 )
680 + inoutUserName = m_aPrevUsername;
681 +
682 + if ( outPassWord.getLength() == 0 )
683 + outPassWord = m_aPrevPassword;
684 +
685 + rtl::Reference< ucbhelper::SimpleAuthenticationRequest > xRequest
686 + = new ucbhelper::SimpleAuthenticationRequest( inHostName,
687 + inRealm,
688 + inoutUserName,
689 + outPassWord,
690 + ::rtl::OUString(),
691 + bAllowPersistentStoring );
692 + xIH->handle( xRequest.get() );
693 +
694 + rtl::Reference< ucbhelper::InteractionContinuation > xSelection
695 + = xRequest->getSelection();
696 +
697 + if ( !xSelection.is() )
698 + return -1;
699 +
700 + // Handler handled the request.
701 + uno::Reference< task::XInteractionAbort > xAbort(
702 + xSelection.get(), uno::UNO_QUERY );
703 + if ( xAbort.is() )
704 + return -1;
705 +
706 + const rtl::Reference< ucbhelper::InteractionSupplyAuthentication > & xSupp
707 + = xRequest->getAuthenticationSupplier();
708 +
709 + inoutUserName = xSupp->getUserName();
710 + outPassWord = xSupp->getPassword();
711 +
712 + // #102871# - Remember username and password.
713 + m_aPrevUsername = inoutUserName;
714 + m_aPrevPassword = outPassWord;
715
716 - // go on.
717 - return 0;
718 - }
719 - }
720 - }
721 - }
722 - // Abort.
723 - return -1;
724 + // go on.
725 + return 0;
726 }
727
728 //=========================================================================
729 @@ -444,15 +446,16 @@ void DAVResourceAccess::GET(
730 }
731
732 //=========================================================================
733 -uno::Reference< io::XInputStream > DAVResourceAccess::GET(
734 +uno::Reference< io::XStream > DAVResourceAccess::GET(
735 const std::vector< rtl::OUString > & rHeaderNames,
736 DAVResource & rResource,
737 - const uno::Reference< ucb::XCommandEnvironment > & xEnv )
738 + const uno::Reference< ucb::XCommandEnvironment > & xEnv,
739 + sal_Bool bAllowEmpty )
740 throw( DAVException )
741 {
742 initialize();
743
744 - uno::Reference< io::XInputStream > xStream;
745 + uno::Reference< io::XStream > xStream;
746 int errorCount = 0;
747 bool bRetry;
748 do
749 @@ -472,7 +475,8 @@ uno::Reference< io::XInputStream > DAVRe
750 DAVRequestEnvironment(
751 getRequestURI(),
752 new DAVAuthListener_Impl( xEnv ),
753 - aHeaders, xEnv ) );
754 + aHeaders, xEnv ),
755 + bAllowEmpty );
756 }
757 catch ( DAVException & e )
758 {
759 @@ -606,6 +610,45 @@ void DAVResourceAccess::PUT(
760 }
761
762 //=========================================================================
763 +void DAVResourceAccess::PUT(
764 + const char * buffer, size_t size,
765 + const uno::Reference< ucb::XCommandEnvironment > & xEnv )
766 +throw( DAVException )
767 +{
768 + initialize();
769 +
770 + bool bRetry = false;
771 + int errorCount = 0;
772 + do
773 + {
774 + bRetry = false;
775 + try
776 + {
777 + DAVRequestHeaders aHeaders;
778 + getUserRequestHeaders( xEnv,
779 + getRequestURI(),
780 + rtl::OUString::createFromAscii( "PUT" ),
781 + aHeaders );
782 +
783 + m_xSession->PUT( getRequestURI(),
784 + buffer, size,
785 + DAVRequestEnvironment(
786 + getRequestURI(),
787 + new DAVAuthListener_Impl( xEnv ),
788 + aHeaders, xEnv ) );
789 + }
790 + catch ( DAVException & e )
791 + {
792 + errorCount++;
793 + bRetry = handleException( e, errorCount );
794 + if ( !bRetry )
795 + throw;
796 + }
797 + }
798 + while ( bRetry );
799 +}
800 +
801 +//=========================================================================
802 uno::Reference< io::XInputStream > DAVResourceAccess::POST(
803 const rtl::OUString & rContentType,
804 const rtl::OUString & rReferer,
805 @@ -888,22 +931,44 @@ void DAVResourceAccess::DESTROY(
806
807 //=========================================================================
808 void DAVResourceAccess::LOCK (
809 - const ucb::Lock & /*rLock*/,
810 - const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
811 + ucb::Lock & rLock,
812 + const uno::Reference< ucb::XCommandEnvironment > & xEnv )
813 throw( DAVException )
814 {
815 -// initialize();
816 - OSL_ENSURE( sal_False, "DAVResourceAccess::LOCK - NYI" );
817 + initialize();
818 +
819 + DAVRequestHeaders aHeaders;
820 + getUserRequestHeaders( xEnv,
821 + getRequestURI(),
822 + rtl::OUString::createFromAscii( "LOCK" ),
823 + aHeaders );
824 +
825 + m_xSession->LOCK( rLock,
826 + DAVRequestEnvironment(
827 + getRequestURI(),
828 + new DAVAuthListener_Impl( xEnv ),
829 + aHeaders, xEnv ) );
830 }
831
832 //=========================================================================
833 void DAVResourceAccess::UNLOCK (
834 - const ucb::Lock & /*rLock*/,
835 - const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
836 + ucb::Lock & rLock,
837 + const uno::Reference< ucb::XCommandEnvironment > & xEnv )
838 throw( DAVException )
839 {
840 -// initialize();
841 - OSL_ENSURE( sal_False, "DAVResourceAccess::UNLOCK - NYI" );
842 + initialize();
843 +
844 + DAVRequestHeaders aHeaders;
845 + getUserRequestHeaders( xEnv,
846 + getRequestURI(),
847 + rtl::OUString::createFromAscii( "UNLOCK" ),
848 + aHeaders );
849 +
850 + m_xSession->UNLOCK( rLock,
851 + DAVRequestEnvironment(
852 + getRequestURI(),
853 + new DAVAuthListener_Impl( xEnv ),
854 + aHeaders, xEnv ) );
855 }
856
857 //=========================================================================
858 @@ -1008,6 +1073,18 @@ void DAVResourceAccess::getUserRequestHe
859 }
860 }
861
862 +// static
863 +com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > DAVResourceAccess::createCommandEnvironment( void )
864 +{
865 + uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
866 + uno::Reference< task::XInteractionHandler > xInteractionHandler = uno::Reference< task::XInteractionHandler > (
867 + xFactory->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uui.InteractionHandler") ) ), uno::UNO_QUERY );
868 + ucbhelper::CommandEnvironment* pCommandEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, uno::Reference< ucb::XProgressHandler >() );
869 +
870 + return uno::Reference< ucb::XCommandEnvironment >( static_cast< ucb::XCommandEnvironment* >( pCommandEnv ), uno::UNO_QUERY );
871 +}
872 +
873 +
874 //=========================================================================
875 sal_Bool DAVResourceAccess::detectRedirectCycle(
876 const rtl::OUString& rRedirectURL )
877 --- ucb/source/ucp/webdav/DAVResourceAccess.hxx.old 2009-04-02 11:01:38.000000000 +0000
878 +++ ucb/source/ucp/webdav/DAVResourceAccess.hxx 2009-04-06 16:41:46.000000000 +0000
879 @@ -134,11 +134,12 @@ public:
880 com::sun::star::ucb::XCommandEnvironment > & xEnv )
881 throw( DAVException );
882
883 - com::sun::star::uno::Reference< com::sun::star::io::XInputStream >
884 + com::sun::star::uno::Reference< com::sun::star::io::XStream >
885 GET( const std::vector< rtl::OUString > & rHeaderNames, // empty == 'all'
886 DAVResource & rResource,
887 const com::sun::star::uno::Reference<
888 - com::sun::star::ucb::XCommandEnvironment > & xEnv )
889 + com::sun::star::ucb::XCommandEnvironment > & xEnv,
890 + sal_Bool bAllowEmpty = sal_False )
891 throw( DAVException );
892
893 void
894 @@ -157,6 +158,11 @@ public:
895 com::sun::star::ucb::XCommandEnvironment > & xEnv )
896 throw( DAVException );
897
898 + void
899 + PUT( const char * buffer, size_t size,
900 + const com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > & xEnv )
901 + throw( DAVException );
902 +
903 com::sun::star::uno::Reference< com::sun::star::io::XInputStream >
904 POST( const rtl::OUString & rContentType,
905 const rtl::OUString & rReferer,
906 @@ -204,13 +210,13 @@ public:
907 throw( DAVException );
908
909 void
910 - LOCK( const com::sun::star::ucb::Lock & rLock,
911 + LOCK( com::sun::star::ucb::Lock & rLock,
912 const com::sun::star::uno::Reference<
913 com::sun::star::ucb::XCommandEnvironment > & xEnv )
914 throw( DAVException );
915
916 void
917 - UNLOCK( const com::sun::star::ucb::Lock & rLock,
918 + UNLOCK( com::sun::star::ucb::Lock & rLock,
919 const com::sun::star::uno::Reference<
920 com::sun::star::ucb::XCommandEnvironment > & xEnv )
921 throw( DAVException );
922 @@ -223,6 +229,8 @@ public:
923 const rtl::OUString & rMethod,
924 DAVRequestHeaders & rRequestHeaders );
925
926 + static com::sun::star::uno::Reference< com::sun::star::ucb::XCommandEnvironment > createCommandEnvironment( void );
927 +
928 private:
929 const rtl::OUString & getRequestURI() const;
930 sal_Bool detectRedirectCycle( const rtl::OUString& rRedirectURL )
931 --- ucb/source/ucp/webdav/DAVSession.hxx
932 +++ ucb/source/ucp/webdav/DAVSession.hxx
933 @@ -33,8 +33,11 @@
934
935 #include <memory>
936 #include <rtl/ustring.hxx>
937 +#include <com/sun/star/io/XStream.hpp>
938 #include <com/sun/star/io/XInputStream.hpp>
939 #include <com/sun/star/io/XOutputStream.hpp>
940 +#include <com/sun/star/ucb/Lock.hpp>
941 +
942 #include "DAVException.hxx"
943 #include "DAVProperties.hxx"
944 #include "DAVResource.hxx"
945 @@ -42,8 +45,6 @@
946 #include "DAVTypes.hxx"
947 #include "DAVRequestEnvironment.hxx"
948
949 -
950 -
951 namespace webdav_ucp
952 {
953
954 @@ -114,11 +115,12 @@ public:
955 const DAVRequestEnvironment & rEnv )
956 throw( DAVException ) = 0;
957
958 - virtual com::sun::star::uno::Reference< com::sun::star::io::XInputStream >
959 + virtual com::sun::star::uno::Reference< com::sun::star::io::XStream >
960 GET( const ::rtl::OUString & inPath,
961 const std::vector< ::rtl::OUString > & inHeaderNames,
962 DAVResource & ioResource,
963 - const DAVRequestEnvironment & rEnv )
964 + const DAVRequestEnvironment & rEnv,
965 + sal_Bool bAllowEmpty )
966 throw( DAVException ) = 0;
967
968 virtual void GET( const ::rtl::OUString & inPath,
969 @@ -134,6 +136,12 @@ public:
970 virtual void ABORT()
971 throw( DAVException ) = 0;
972
973 + virtual void PUT( const ::rtl::OUString & inPath,
974 + const char * buffer,
975 + size_t size,
976 + const DAVRequestEnvironment & rEnv )
977 + throw ( DAVException ) = 0;
978 +
979 virtual com::sun::star::uno::Reference< com::sun::star::io::XInputStream >
980 POST( const rtl::OUString & inPath,
981 const rtl::OUString & rContentType,
982 @@ -173,16 +181,14 @@ public:
983 const DAVRequestEnvironment & rEnv )
984 throw( DAVException ) = 0;
985
986 - // Note: Uncomment the following if locking support is required
987 - /*
988 - virtual void LOCK ( const Lock & inLock,
989 + virtual void LOCK ( com::sun::star::ucb::Lock & rLock,
990 const DAVRequestEnvironment & rEnv )
991 throw( DAVException ) = 0;
992
993 - virtual void UNLOCK ( const Lock & inLock,
994 + virtual void UNLOCK ( com::sun::star::ucb::Lock & rLock,
995 const DAVRequestEnvironment & rEnv )
996 throw( DAVException ) = 0;
997 - */
998 +
999 protected:
1000 rtl::Reference< DAVSessionFactory > m_xFactory;
1001
1002 --- ucb/source/ucp/webdav/NeonInputStream.cxx.old 2009-04-02 11:01:38.000000000 +0000
1003 +++ ucb/source/ucp/webdav/NeonInputStream.cxx 2009-04-06 16:41:46.000000000 +0000
1004 @@ -31,21 +31,28 @@
1005 // MARKER(update_precomp.py): autogen include statement, do not remove
1006 #include "precompiled_ucb.hxx"
1007 #include "NeonInputStream.hxx"
1008 +#include "DAVResourceAccess.hxx"
1009 +
1010 #include <rtl/memory.h>
1011 +#include <com/sun/star/ucb/CommandFailedException.hpp>
1012 +
1013 +#include <comphelper/processfactory.hxx>
1014 +#include <com/sun/star/lang/XMultiServiceFactory.hpp>
1015 +
1016 +#include <cstdio>
1017
1018 using namespace cppu;
1019 -using namespace rtl;
1020 using namespace com::sun::star::io;
1021 -using namespace com::sun::star::uno;
1022 +using namespace com::sun::star;
1023 using namespace webdav_ucp;
1024
1025 -
1026 // -------------------------------------------------------------------
1027 // Constructor
1028 // -------------------------------------------------------------------
1029 -NeonInputStream::NeonInputStream( void )
1030 -: mLen( 0 ),
1031 - mPos( 0 )
1032 +NeonInputStream::NeonInputStream()
1033 +: m_nLen( 0 ),
1034 + m_nPos( 0 ),
1035 + m_bDirty( sal_False )
1036 {
1037 }
1038
1039 @@ -62,24 +69,59 @@ NeonInputStream::~NeonInputStream( void
1040 // -------------------------------------------------------------------
1041 void NeonInputStream::AddToStream( const char * inBuf, sal_Int32 inLen )
1042 {
1043 - mInputBuffer.realloc( sal::static_int_cast<sal_Int32>(mLen) + inLen );
1044 - rtl_copyMemory( mInputBuffer.getArray() + mLen, inBuf, inLen );
1045 - mLen += inLen;
1046 + OSL_ENSURE( !m_bDirty, "Cannot AddToStream() when it was already written to it." );
1047 +
1048 + m_aInputBuffer.realloc( sal::static_int_cast<sal_Int32>(m_nLen) + inLen );
1049 + rtl_copyMemory( m_aInputBuffer.getArray() + m_nLen, inBuf, inLen );
1050 + m_nLen += inLen;
1051 +}
1052 +
1053 +// -------------------------------------------------------------------
1054 +// Associate a URL with this stream
1055 +// -------------------------------------------------------------------
1056 +void NeonInputStream::SetURL( const rtl::OUString &rURL )
1057 +{
1058 + osl::MutexGuard aGuard( m_aLock );
1059 +
1060 + m_aURL = rURL;
1061 }
1062
1063 // -------------------------------------------------------------------
1064 // queryInterface
1065 // -------------------------------------------------------------------
1066 -Any NeonInputStream::queryInterface( const Type &type )
1067 - throw( RuntimeException )
1068 +uno::Any NeonInputStream::queryInterface( const uno::Type &type )
1069 + throw( uno::RuntimeException )
1070 {
1071 - Any aRet = ::cppu::queryInterface( type,
1072 - static_cast< XInputStream * >( this ),
1073 - static_cast< XSeekable * >( this ) );
1074 + uno::Any aRet = ::cppu::queryInterface( type,
1075 + static_cast< XStream * >( this ),
1076 + static_cast< XInputStream * >( this ),
1077 + static_cast< XOutputStream * >( this ),
1078 + static_cast< XSeekable * >( this ),
1079 + static_cast< XTruncate * >( this ) );
1080 return aRet.hasValue() ? aRet : OWeakObject::queryInterface( type );
1081 }
1082
1083 // -------------------------------------------------------------------
1084 +// getInputStream
1085 +// -------------------------------------------------------------------
1086 +com::sun::star::uno::Reference< com::sun::star::io::XInputStream > SAL_CALL
1087 +NeonInputStream::getInputStream( void )
1088 + throw( com::sun::star::uno::RuntimeException )
1089 +{
1090 + return uno::Reference< XInputStream >( this );
1091 +}
1092 +
1093 +// -------------------------------------------------------------------
1094 +// getOutputStream
1095 +// -------------------------------------------------------------------
1096 +com::sun::star::uno::Reference< com::sun::star::io::XOutputStream > SAL_CALL
1097 +NeonInputStream::getOutputStream( void )
1098 + throw( com::sun::star::uno::RuntimeException )
1099 +{
1100 + return uno::Reference< XOutputStream >( this );
1101 +}
1102 +
1103 +// -------------------------------------------------------------------
1104 // readBytes
1105 // "Reads" the specified number of bytes from the stream
1106 // -------------------------------------------------------------------
1107 @@ -92,7 +134,7 @@ sal_Int32 SAL_CALL NeonInputStream::read
1108 {
1109 // Work out how much we're actually going to write
1110 sal_Int32 theBytes2Read = nBytesToRead;
1111 - sal_Int32 theBytesLeft = sal::static_int_cast<sal_Int32>(mLen - mPos);
1112 + sal_Int32 theBytesLeft = sal::static_int_cast<sal_Int32>(m_nLen - m_nPos);
1113 if ( theBytes2Read > theBytesLeft )
1114 theBytes2Read = theBytesLeft;
1115
1116 @@ -101,10 +143,10 @@ sal_Int32 SAL_CALL NeonInputStream::read
1117
1118 // Write the data
1119 rtl_copyMemory(
1120 - aData.getArray(), mInputBuffer.getConstArray() + mPos, theBytes2Read );
1121 + aData.getArray(), m_aInputBuffer.getConstArray() + m_nPos, theBytes2Read );
1122
1123 // Update our stream position for next time
1124 - mPos += theBytes2Read;
1125 + m_nPos += theBytes2Read;
1126
1127 return theBytes2Read;
1128 }
1129 @@ -133,9 +175,9 @@ void SAL_CALL NeonInputStream::skipBytes
1130 ::com::sun::star::io::IOException,
1131 ::com::sun::star::uno::RuntimeException )
1132 {
1133 - mPos += nBytesToSkip;
1134 - if ( mPos >= mLen )
1135 - mPos = mLen;
1136 + m_nPos += nBytesToSkip;
1137 + if ( m_nPos >= m_nLen )
1138 + m_nPos = m_nLen;
1139 }
1140
1141 // -------------------------------------------------------------------
1142 @@ -147,7 +189,7 @@ sal_Int32 SAL_CALL NeonInputStream::avai
1143 ::com::sun::star::io::IOException,
1144 ::com::sun::star::uno::RuntimeException )
1145 {
1146 - return sal::static_int_cast<sal_Int32>(mLen - mPos);
1147 + return sal::static_int_cast<sal_Int32>(m_nLen - m_nPos);
1148 }
1149
1150 // -------------------------------------------------------------------
1151 @@ -168,12 +210,12 @@ void SAL_CALL NeonInputStream::seek( sal
1152 ::com::sun::star::io::IOException,
1153 ::com::sun::star::uno::RuntimeException )
1154 {
1155 - if ( location < 0 )
1156 - throw ::com::sun::star::lang::IllegalArgumentException();
1157 + if ( location < 0 )
1158 + throw ::com::sun::star::lang::IllegalArgumentException();
1159
1160 - if ( location <= mLen )
1161 - mPos = location;
1162 - else
1163 + if ( location <= m_nLen )
1164 + m_nPos = location;
1165 + else
1166 throw ::com::sun::star::lang::IllegalArgumentException();
1167 }
1168
1169 @@ -184,7 +226,7 @@ sal_Int64 SAL_CALL NeonInputStream::getP
1170 throw( ::com::sun::star::io::IOException,
1171 ::com::sun::star::uno::RuntimeException )
1172 {
1173 - return mPos;
1174 + return m_nPos;
1175 }
1176
1177 // -------------------------------------------------------------------
1178 @@ -194,5 +236,108 @@ sal_Int64 SAL_CALL NeonInputStream::getL
1179 throw( ::com::sun::star::io::IOException,
1180 ::com::sun::star::uno::RuntimeException )
1181 {
1182 - return mLen;
1183 + return m_nLen;
1184 +}
1185 +
1186 +// -------------------------------------------------------------------
1187 +// writeBytes
1188 +// -------------------------------------------------------------------
1189 +void SAL_CALL NeonInputStream::writeBytes( const com::sun::star::uno::Sequence< sal_Int8 >& aData )
1190 + throw( com::sun::star::io::NotConnectedException,
1191 + com::sun::star::io::BufferSizeExceededException,
1192 + com::sun::star::io::IOException,
1193 + com::sun::star::uno::RuntimeException)
1194 +{
1195 +#if OSL_DEBUG_LEVEL > 0
1196 + fprintf( stderr, "WebDAV: writeBytes()\n" );
1197 +#endif
1198 +
1199 + sal_Int32 nDataLen = aData.getLength();
1200 + OSL_ASSERT( nDataLen >= 0 );
1201 +
1202 + // Anything to do?
1203 + if ( nDataLen == 0 )
1204 + return;
1205 +
1206 + // Update the length of the stream & size of the buffer
1207 + if ( m_nLen < m_nPos + nDataLen )
1208 + {
1209 + m_nLen = m_nPos + nDataLen;
1210 + if ( m_aInputBuffer.getLength() < m_nLen )
1211 + m_aInputBuffer.realloc( sal::static_int_cast<sal_Int32>( m_nLen ) );
1212 + }
1213 +
1214 + rtl_copyMemory( m_aInputBuffer.getArray() + m_nPos, aData.getConstArray(), nDataLen );
1215 + m_nPos += nDataLen;
1216 +
1217 + m_bDirty = sal_True;
1218 +}
1219 +
1220 +// -------------------------------------------------------------------
1221 +// flush
1222 +// -------------------------------------------------------------------
1223 +void SAL_CALL NeonInputStream::flush( void )
1224 + throw( NotConnectedException, BufferSizeExceededException,
1225 + IOException, uno::RuntimeException )
1226 +{
1227 + if ( m_bDirty )
1228 + {
1229 +#if OSL_DEBUG_LEVEL > 0
1230 + fprintf( stderr, "WebDAV: flush(), saving the changed file.\n" );
1231 +#endif
1232 + // FIXME It's really hacky to create the new session
1233 + // But so far it seems I have no other chance...
1234 + uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
1235 + rtl::Reference< DAVSessionFactory > rDAVFactory( new DAVSessionFactory() );
1236 +
1237 + DAVResourceAccess aResourceAccess( xFactory, rDAVFactory, m_aURL );
1238 +
1239 + try {
1240 + aResourceAccess.PUT( reinterpret_cast<const char*>( m_aInputBuffer.getConstArray() ), m_nLen,
1241 + DAVResourceAccess::createCommandEnvironment() );
1242 + }
1243 + catch ( DAVException & e )
1244 + {
1245 + throw ucb::CommandFailedException(
1246 + e.getData(),
1247 + uno::Reference< uno::XInterface >(),
1248 + uno::makeAny( e.getData() ) );
1249 + }
1250 +
1251 + m_bDirty = sal_False;
1252 + }
1253 +}
1254 +
1255 +// -------------------------------------------------------------------
1256 +// closeOutput
1257 +// -------------------------------------------------------------------
1258 +void SAL_CALL NeonInputStream::closeOutput( void )
1259 + throw( com::sun::star::io::NotConnectedException,
1260 + com::sun::star::io::IOException,
1261 + com::sun::star::uno::RuntimeException )
1262 +{
1263 + if ( m_bDirty )
1264 + {
1265 +#if OSL_DEBUG_LEVEL > 0
1266 + fprintf( stderr, "WebDAV: TODO write on closeOutput(), the stream is dirty!\n" );
1267 +#endif
1268 + }
1269 +}
1270 +
1271 +// -------------------------------------------------------------------
1272 +// truncate
1273 +// -------------------------------------------------------------------
1274 +void SAL_CALL NeonInputStream::truncate( void )
1275 + throw( com::sun::star::io::IOException,
1276 + com::sun::star::uno::RuntimeException )
1277 +{
1278 +#if OSL_DEBUG_LEVEL > 0
1279 + fprintf( stderr, "WebDAV: truncate()\n" );
1280 +#endif
1281 +
1282 + if ( m_nLen > 0 )
1283 + {
1284 + m_nLen = m_nPos = 0;
1285 + m_bDirty = sal_True;
1286 + }
1287 }
1288 --- ucb/source/ucp/webdav/NeonInputStream.hxx.old 2009-04-02 11:01:38.000000000 +0000
1289 +++ ucb/source/ucp/webdav/NeonInputStream.hxx 2009-04-06 16:41:46.000000000 +0000
1290 @@ -31,11 +31,19 @@
1291 #define _NEONINPUTSTREAM_HXX_
1292
1293 #include <sal/types.h>
1294 +#include <osl/mutex.hxx>
1295 +#include <osl/signal.h>
1296 #include <rtl/ustring.hxx>
1297 #include <cppuhelper/weak.hxx>
1298 +
1299 +#include <com/sun/star/io/XStream.hpp>
1300 #include <com/sun/star/io/XInputStream.hpp>
1301 +#include <com/sun/star/io/XOutputStream.hpp>
1302 #include <com/sun/star/io/XSeekable.hpp>
1303 +#include <com/sun/star/io/XTruncate.hpp>
1304 +#include <com/sun/star/ucb/Lock.hpp>
1305
1306 +#include "DAVRequestEnvironment.hxx"
1307
1308 namespace webdav_ucp
1309 {
1310 @@ -45,21 +53,33 @@ namespace webdav_ucp
1311 // A simple XInputStream implementation provided specifically for use
1312 // by the DAVSession::GET method.
1313 // -------------------------------------------------------------------
1314 -class NeonInputStream : public ::com::sun::star::io::XInputStream,
1315 +class NeonInputStream : public ::com::sun::star::io::XStream,
1316 + public ::com::sun::star::io::XInputStream,
1317 + public ::com::sun::star::io::XOutputStream,
1318 public ::com::sun::star::io::XSeekable,
1319 + public ::com::sun::star::io::XTruncate,
1320 public ::cppu::OWeakObject
1321 {
1322 - private:
1323 - com::sun::star::uno::Sequence< sal_Int8 > mInputBuffer;
1324 - sal_Int64 mLen;
1325 - sal_Int64 mPos;
1326 -
1327 - public:
1328 - NeonInputStream( void );
1329 - virtual ~NeonInputStream();
1330 +private:
1331 + com::sun::star::uno::Sequence< sal_Int8 > m_aInputBuffer;
1332 + sal_Int64 m_nLen; // cannot be just m_aInputBuffer.getLength() - the buffer can be bigger
1333 + sal_Int64 m_nPos;
1334 +
1335 + sal_Bool m_bDirty;
1336 +
1337 + rtl::OUString m_aURL;
1338 +
1339 + osl::Mutex m_aLock;
1340
1341 - // Add some data to the end of the stream
1342 - void AddToStream( const char * inBuf, sal_Int32 inLen );
1343 +public:
1344 + NeonInputStream( void );
1345 + virtual ~NeonInputStream();
1346 +
1347 + // Add some data to the end of the stream
1348 + void AddToStream( const char * inBuf, sal_Int32 inLen );
1349 +
1350 + // Associate a URL with this stream
1351 + void SetURL( const rtl::OUString &rURL );
1352
1353 // XInterface
1354 virtual com::sun::star::uno::Any SAL_CALL queryInterface(
1355 @@ -74,6 +94,12 @@ class NeonInputStream : public ::com::su
1356 throw()
1357 { OWeakObject::release(); }
1358
1359 + // XStream
1360 + virtual com::sun::star::uno::Reference< com::sun::star::io::XInputStream > SAL_CALL getInputStream( void )
1361 + throw( com::sun::star::uno::RuntimeException );
1362 +
1363 + virtual com::sun::star::uno::Reference< com::sun::star::io::XOutputStream > SAL_CALL getOutputStream( void )
1364 + throw( com::sun::star::uno::RuntimeException );
1365
1366 // XInputStream
1367 virtual sal_Int32 SAL_CALL readBytes(
1368 @@ -121,6 +147,30 @@ class NeonInputStream : public ::com::su
1369 virtual sal_Int64 SAL_CALL getLength()
1370 throw( ::com::sun::star::io::IOException,
1371 ::com::sun::star::uno::RuntimeException );
1372 +
1373 + // XOutputStream
1374 + virtual void SAL_CALL writeBytes( const com::sun::star::uno::Sequence< sal_Int8 >& aData )
1375 + throw( com::sun::star::io::NotConnectedException,
1376 + com::sun::star::io::BufferSizeExceededException,
1377 + com::sun::star::io::IOException,
1378 + com::sun::star::uno::RuntimeException);
1379 +
1380 + virtual void SAL_CALL flush( void )
1381 + throw( com::sun::star::io::NotConnectedException,
1382 + com::sun::star::io::BufferSizeExceededException,
1383 + com::sun::star::io::IOException,
1384 + com::sun::star::uno::RuntimeException);
1385 +
1386 +
1387 + virtual void SAL_CALL closeOutput( void )
1388 + throw( com::sun::star::io::NotConnectedException,
1389 + com::sun::star::io::IOException,
1390 + com::sun::star::uno::RuntimeException );
1391 +
1392 + // XTruncate
1393 + virtual void SAL_CALL truncate( void )
1394 + throw( com::sun::star::io::IOException,
1395 + com::sun::star::uno::RuntimeException );
1396 };
1397
1398 } // namespace webdav_ucp
1399 --- ucb/source/ucp/webdav/NeonSession.cxx.old 2009-04-02 11:01:38.000000000 +0000
1400 +++ ucb/source/ucp/webdav/NeonSession.cxx 2009-04-06 16:41:46.000000000 +0000
1401 @@ -65,6 +65,7 @@
1402 #ifndef _SIMPLECERTIFICATIONVALIDATIONREQUEST_HXX_
1403 #include "ucbhelper/simplecertificatevalidationrequest.hxx"
1404 #endif
1405 +#include <ucbhelper/cancelcommandexecution.hxx>
1406
1407 #include <cppuhelper/bootstrap.hxx>
1408
1409 @@ -153,6 +154,12 @@ static sal_uInt16 makeStatusCode( const
1410 return sal_uInt16( rStatusText.copy( 0, nPos ).toInt32() );
1411 }
1412
1413 +static sal_uInt16 getStatusCode( HttpSession *pSession )
1414 +{
1415 + rtl::OUString aText = rtl::OUString::createFromAscii( ne_get_error( pSession ) );
1416 + return makeStatusCode( aText );
1417 +}
1418 +
1419 // -------------------------------------------------------------------
1420 struct NeonRequestContext
1421 {
1422 @@ -196,12 +203,13 @@ struct NeonRequestContext
1423 // -------------------------------------------------------------------
1424
1425 #if NEON_VERSION >= 0x0250
1426 -extern "C" int NeonSession_ResponseBlockReader(void * inUserData,
1427 +extern "C" int
1428 #else
1429 -extern "C" void NeonSession_ResponseBlockReader(void * inUserData,
1430 +extern "C" void
1431 #endif
1432 - const char * inBuf,
1433 - size_t inLen )
1434 +NeonSession_ResponseBlockReader( void * inUserData,
1435 + const char * inBuf,
1436 + size_t inLen )
1437 {
1438 // neon calls this function with (inLen == 0)...
1439 if ( inLen > 0 )
1440 @@ -226,12 +234,13 @@ extern "C" void NeonSession_ResponseBloc
1441 // -------------------------------------------------------------------
1442
1443 #if NEON_VERSION >= 0x0250
1444 -extern "C" int NeonSession_ResponseBlockWriter( void * inUserData,
1445 +extern "C" int
1446 #else
1447 -extern "C" void NeonSession_ResponseBlockWriter( void * inUserData,
1448 +extern "C" void
1449 #endif
1450 - const char * inBuf,
1451 - size_t inLen )
1452 +NeonSession_ResponseBlockWriter( void * inUserData,
1453 + const char * inBuf,
1454 + size_t inLen )
1455 {
1456 // neon calls this function with (inLen == 0)...
1457 if ( inLen > 0 )
1458 @@ -299,11 +308,10 @@ extern "C" int NeonSession_NeonAuth( voi
1459
1460 try
1461 {
1462 - NeonUri uri( theSession->getRequestEnvironment().m_aRequestURI );
1463 - rtl::OUString aUserInfo( uri.GetUserInfo() );
1464 + rtl::OUString aUserInfo( theSession->getUserInfo() );
1465 if ( aUserInfo.getLength() )
1466 {
1467 - sal_Int32 nPos = aUserInfo.indexOf( '@' );
1468 + sal_Int32 nPos = aUserInfo.indexOf( ':' );
1469 if ( nPos == -1 )
1470 {
1471 theUserName = aUserInfo;
1472 @@ -564,6 +572,8 @@ extern "C" void NeonSession_PreSendReque
1473 }
1474 }
1475
1476 +NeonLockStore * NeonSession::s_aNeonLockStore = NULL;
1477 +
1478 // -------------------------------------------------------------------
1479 // Constructor
1480 // -------------------------------------------------------------------
1481 @@ -581,6 +591,7 @@ NeonSession::NeonSession(
1482 m_aScheme = theUri.GetScheme();
1483 m_aHostName = theUri.GetHost();
1484 m_nPort = theUri.GetPort();
1485 + m_aUserInfo = theUri.GetUserInfo();
1486
1487 // Init();
1488 }
1489 @@ -594,14 +605,6 @@ NeonSession::~NeonSession( )
1490 {
1491 ne_session_destroy( m_pHttpSession );
1492 m_pHttpSession = 0;
1493 - // Note: Uncomment the following if locking support is required
1494 - /*
1495 - if ( mNeonLockSession != NULL )
1496 - {
1497 - ne_lock_unregister( mNeonLockSession );
1498 - mNeonLockSession = NULL;
1499 - }
1500 - */
1501 }
1502
1503 delete static_cast<RequestDataMap*>(m_pRequestData);
1504 @@ -629,6 +632,9 @@ void NeonSession::Init()
1505 throw DAVException( DAVException::DAV_SESSION_CREATE,
1506 NeonUri::makeConnectionEndPointString(
1507 m_aHostName, m_nPort ) );
1508 +#if OSL_DEBUG_LEVEL > 0
1509 + ne_debug_init( stderr, NE_DBG_LOCKS );
1510 +#endif
1511 // #122205# - libxml2 needs to be initialized once if used by
1512 // multithreaded programs like OOo.
1513 xmlInitParser();
1514 @@ -746,14 +752,15 @@ void NeonSession::Init()
1515 m_nProxyPort );
1516 }
1517
1518 - // Note: Uncomment the following if locking support is required
1519 - /*
1520 - mNeonLockSession = ne_lock_register( m_pHttpSession );
1521 + if ( !s_aNeonLockStore )
1522 + s_aNeonLockStore = ne_lockstore_create();
1523
1524 - if ( mNeonLockSession == NULL )
1525 + if ( s_aNeonLockStore == NULL )
1526 throw DAVException( DAVException::DAV_SESSION_CREATE,
1527 - theUri::makeConnectionEndPointString() );
1528 - */
1529 + NeonUri::makeConnectionEndPointString( m_aHostName, m_nPort ) );
1530 +
1531 + // Register the lock store
1532 + ne_lockstore_register( s_aNeonLockStore, m_pHttpSession );
1533
1534 // Register for redirects.
1535 ne_redirect_register( m_pHttpSession );
1536 @@ -1088,11 +1095,12 @@ void NeonSession::GET( const rtl::OUStri
1537 // -------------------------------------------------------------------
1538 // GET
1539 // -------------------------------------------------------------------
1540 -uno::Reference< io::XInputStream >
1541 +uno::Reference< io::XStream >
1542 NeonSession::GET( const rtl::OUString & inPath,
1543 const std::vector< ::rtl::OUString > & inHeaderNames,
1544 DAVResource & ioResource,
1545 - const DAVRequestEnvironment & rEnv )
1546 + const DAVRequestEnvironment & rEnv,
1547 + sal_Bool bAllowEmpty )
1548 throw ( DAVException )
1549 {
1550 osl::Guard< osl::Mutex > theGuard( m_aMutex );
1551 @@ -1104,16 +1112,23 @@ NeonSession::GET( const rtl::OUString &
1552 ioResource.uri = inPath;
1553 ioResource.properties.clear();
1554
1555 - rtl::Reference< NeonInputStream > xInputStream( new NeonInputStream );
1556 - NeonRequestContext aCtx( xInputStream, inHeaderNames, ioResource );
1557 + rtl::Reference< NeonInputStream > xStream( new NeonInputStream );
1558 + NeonRequestContext aCtx( xStream, inHeaderNames, ioResource );
1559 int theRetVal = GET( m_pHttpSession,
1560 rtl::OUStringToOString(
1561 inPath, RTL_TEXTENCODING_UTF8 ),
1562 NeonSession_ResponseBlockReader,
1563 true,
1564 &aCtx );
1565 - HandleError( theRetVal );
1566 - return uno::Reference< io::XInputStream >( xInputStream.get() );
1567 + try {
1568 + HandleError( theRetVal );
1569 + }
1570 + catch ( DAVException const & e )
1571 + {
1572 + if ( !bAllowEmpty || ( e.getStatus() != SC_NOT_FOUND ) )
1573 + throw;
1574 + }
1575 + return uno::Reference< io::XStream >( xStream.get() );
1576 }
1577
1578 // -------------------------------------------------------------------
1579 @@ -1153,22 +1168,38 @@ void NeonSession::PUT( const rtl::OUStri
1580 const DAVRequestEnvironment & rEnv )
1581 throw ( DAVException )
1582 {
1583 + // initialization etc. is performed in the other PUT
1584 +
1585 + uno::Sequence< sal_Int8 > aDataToSend;
1586 + if ( !getDataFromInputStream( inInputStream, aDataToSend, false ) )
1587 + throw DAVException( DAVException::DAV_INVALID_ARG );
1588 +
1589 + PUT( inPath,
1590 + reinterpret_cast< const char * >( aDataToSend.getConstArray() ),
1591 + aDataToSend.getLength(),
1592 + rEnv );
1593 +}
1594 +
1595 +// -------------------------------------------------------------------
1596 +// PUT
1597 +// -------------------------------------------------------------------
1598 +void NeonSession::PUT( const rtl::OUString &inPath,
1599 + const char * buffer,
1600 + size_t size,
1601 + const DAVRequestEnvironment & rEnv )
1602 + throw ( DAVException )
1603 +{
1604 osl::Guard< osl::Mutex > theGuard( m_aMutex );
1605
1606 Init();
1607
1608 m_aEnv = rEnv;
1609
1610 - uno::Sequence< sal_Int8 > aDataToSend;
1611 - if ( !getDataFromInputStream( inInputStream, aDataToSend, false ) )
1612 - throw DAVException( DAVException::DAV_INVALID_ARG );
1613 -
1614 int theRetVal = PUT( m_pHttpSession,
1615 rtl::OUStringToOString(
1616 inPath, RTL_TEXTENCODING_UTF8 ),
1617 - reinterpret_cast< const char * >(
1618 - aDataToSend.getConstArray() ),
1619 - aDataToSend.getLength() );
1620 + buffer,
1621 + size );
1622
1623 HandleError( theRetVal );
1624 }
1625 @@ -1344,9 +1375,7 @@ void NeonSession::DESTROY( const rtl::OU
1626 // -------------------------------------------------------------------
1627 // LOCK
1628 // -------------------------------------------------------------------
1629 -// Note: Uncomment the following if locking support is required
1630 -/*
1631 -void NeonSession::LOCK( const Lock & inLock,
1632 +void NeonSession::LOCK( ucb::Lock & rLock,
1633 const DAVRequestEnvironment & rEnv )
1634 throw ( DAVException )
1635 {
1636 @@ -1356,16 +1385,13 @@ void NeonSession::LOCK( const Lock & inL
1637
1638 m_aEnv = rEnv;
1639
1640 - Lockit( inLock, true );
1641 + Lockit( rLock, true );
1642 }
1643 -*/
1644
1645 // -------------------------------------------------------------------
1646 // UNLOCK
1647 // -------------------------------------------------------------------
1648 -// Note: Uncomment the following if locking support is required
1649 -/*
1650 -void NeonSession::UNLOCK( const Lock & inLock,
1651 +void NeonSession::UNLOCK( ucb::Lock & rLock,
1652 const DAVRequestEnvironment & rEnv )
1653 throw ( DAVException )
1654 {
1655 @@ -1375,9 +1401,8 @@ void NeonSession::UNLOCK( const Lock & i
1656
1657 m_aEnv = rEnv;
1658
1659 - Lockit( inLock, false );
1660 + Lockit( rLock, false );
1661 }
1662 -*/
1663
1664 // -------------------------------------------------------------------
1665 const ucbhelper::InternetProxyServer & NeonSession::getProxySettings() const
1666 @@ -1416,7 +1441,10 @@ void NeonSession::HandleError( int nErro
1667 case NE_ERROR: // Generic error
1668 {
1669 rtl::OUString aText = rtl::OUString::createFromAscii(
1670 - ne_get_error( m_pHttpSession ) );
1671 + ne_get_error( m_pHttpSession ) );
1672 +#if OSL_DEBUG_LEVEL > 0
1673 + fprintf( stderr, "WebDAV: got error '%s'\n", rtl::OUStringToOString( aText, RTL_TEXTENCODING_UTF8 ).getStr() );
1674 +#endif
1675 throw DAVException( DAVException::DAV_HTTP_ERROR,
1676 aText,
1677 makeStatusCode( aText ) );
1678 @@ -1473,77 +1501,156 @@ void NeonSession::HandleError( int nErro
1679 }
1680 }
1681
1682 -// Note: Uncomment the following if locking support is required
1683 -/*
1684 -void NeonSession::Lockit( const Lock & inLock, bool inLockit )
1685 +void NeonSession::Lockit( ucb::Lock & rLock, bool bLockit )
1686 throw ( DAVException )
1687 {
1688 osl::Guard< osl::Mutex > theGuard( m_aMutex );
1689
1690 - // Create the neon lock
1691 - NeonLock * theLock = new NeonLock;
1692 - int theRetVal;
1693 -
1694 - // Set the lock uri
1695 - NeonUri theUri( inLock.uri );
1696 - theLock->uri = const_cast< char * >
1697 - ( rtl::OUStringToOString(
1698 - theUri.GetPath(), RTL_TEXTENCODING_UTF8 ).getStr() );
1699 + if ( !s_aNeonLockStore )
1700 + throw DAVException( DAVException::DAV_INVALID_ARG );
1701
1702 - if ( inLockit )
1703 - {
1704 - // Set the lock depth
1705 - switch( inLock.depth )
1706 - {
1707 - case DAVZERO:
1708 - case DAVINFINITY:
1709 - theLock->depth = int ( inLock.depth );
1710 - break;
1711 - default:
1712 - throw DAVException( DAVException::DAV_INVALID_ARG );
1713 - break;
1714 - }
1715 + ne_uri aUri;
1716 + ne_uri_parse( rtl::OUStringToOString( m_aEnv.m_aRequestURI, RTL_TEXTENCODING_UTF8 ).getStr(),
1717 + &aUri );
1718 +
1719 +#if NEON_VERSION < 0x0260
1720 +#define FILLIN( field, val ) aUri.field = aUri.field? aUri.field: strdup( rtl::OUStringToOString( val, RTL_TEXTENCODING_UTF8 ).getStr() )
1721 + FILLIN( scheme, m_aScheme );
1722 + FILLIN( host, m_aHostName );
1723 + aUri.port = aUri.port? aUri.port: m_nPort;
1724 +#undef FILLIN
1725 +#endif
1726
1727 - // Set the lock scope
1728 - switch ( inLock.scope )
1729 - {
1730 - case EXCLUSIVE:
1731 - theLock->scope = ne_lockscope_exclusive;
1732 - break;
1733 - case SHARED:
1734 - theLock->scope = ne_lockscope_shared;
1735 - break;
1736 - default:
1737 - throw DAVException( DAVException::DAV_INVALID_ARG );
1738 - break;
1739 - }
1740 + // Create the neon lock
1741 + NeonLock * theLock = ne_lockstore_findbyuri( s_aNeonLockStore, &aUri );
1742 + bool bAlreadyExists = false;
1743 + if ( theLock )
1744 + bAlreadyExists = true;
1745 + else
1746 + {
1747 + theLock = ne_lock_create();
1748
1749 - // Set the lock owner
1750 - const char * theOwner = rtl::OUStringToOString( inLock.owner,
1751 - RTL_TEXTENCODING_UTF8 );
1752 - theLock->owner = const_cast< char * > ( theOwner );
1753 -
1754 - // Set the lock timeout
1755 - // Note: Neon ignores the timeout
1756 - //theLock->timeout = inLock.timeout;
1757 + // Set the lock uri
1758 + theLock->uri = aUri;
1759
1760 - theRetVal = ne_lock( m_pHttpSession, theLock );
1761 - }
1762 - else
1763 - {
1764 + // Set the lock depth
1765 + switch( rLock.Depth )
1766 + {
1767 + case ucb::LockDepth_ZERO: theLock->depth = NE_DEPTH_ZERO; break;
1768 + case ucb::LockDepth_ONE: theLock->depth = NE_DEPTH_ONE; break;
1769 + case ucb::LockDepth_INFINITY: theLock->depth = NE_DEPTH_INFINITE; break;
1770 + default:
1771 + throw DAVException( DAVException::DAV_INVALID_ARG );
1772 + }
1773
1774 - // Set the lock token
1775 - rtl::OUString theToken = inLock.locktoken.getConstArray()[ 0 ];
1776 - theLock->token = const_cast< char * >
1777 - ( rtl::OUStringToOString(
1778 - theToken, RTL_TEXTENCODING_UTF8 ).getStr() );
1779 + // Set the lock scope
1780 + switch ( rLock.Scope )
1781 + {
1782 + case ucb::LockScope_EXCLUSIVE: theLock->scope = ne_lockscope_exclusive; break;
1783 + case ucb::LockScope_SHARED: theLock->scope = ne_lockscope_shared; break;
1784 + default:
1785 + throw DAVException( DAVException::DAV_INVALID_ARG );
1786 + break;
1787 + }
1788
1789 - theRetVal = ne_unlock( m_pHttpSession, theLock );
1790 - }
1791 + // Set the lock owner
1792 + rtl::OUString aValue;
1793 + rLock.Owner >>= aValue;
1794
1795 - HandleError( theRetVal );
1796 + theLock->owner = strdup( rtl::OUStringToOString( aValue, RTL_TEXTENCODING_UTF8 ).getStr() );
1797 +
1798 + // Set the lock timeout
1799 + // We re-new the lock while the stream is open
1800 + theLock->timeout = rLock.Timeout;
1801 + }
1802 +
1803 + if ( bLockit )
1804 + {
1805 + int nRet;
1806 + if ( bAlreadyExists )
1807 + {
1808 +#if NEON_VERSION >= 0x0260
1809 + nRet = ne_lock_refresh( m_pHttpSession, theLock );
1810 +#else
1811 + // workaround for a bug in neon 0.24
1812 + // we have to call with a bigger structure that is used internally
1813 + // and initialize parts of it
1814 +
1815 + struct lock_ctx
1816 + {
1817 + struct ne_lock active; /* activelock */
1818 + char *token; /* the token we're after. */
1819 + int found;
1820 + ne_buffer *cdata;
1821 + };
1822 +
1823 + struct lock_ctx ctx;
1824 +
1825 + memset( &ctx, 0, sizeof ctx );
1826 + ctx.cdata = ne_buffer_create();
1827 +
1828 + memcpy( &ctx, theLock, sizeof( *theLock ) );
1829 + nRet = ne_lock_refresh( m_pHttpSession, reinterpret_cast<NeonLock*>( &ctx ) );
1830 +
1831 + ne_buffer_destroy( ctx.cdata );
1832 +#endif
1833 + if ( ( nRet == NE_ERROR ) && strncmp (ne_get_error (m_pHttpSession), "No activelock ", strlen ("No activelock ")) == 0 )
1834 + {
1835 + bAlreadyExists = false;
1836 + ne_lockstore_remove( s_aNeonLockStore, theLock );
1837 + }
1838 + }
1839 + if ( !bAlreadyExists )
1840 + {
1841 + nRet = ne_lock( m_pHttpSession, theLock );
1842 +
1843 + if ( nRet == NE_OK )
1844 + {
1845 + ne_lockstore_add( s_aNeonLockStore, theLock );
1846 +
1847 + uno::Sequence< rtl::OUString > aTokens( 1 );
1848 + aTokens[0] = rtl::OUString::createFromAscii( theLock->token );
1849 + rLock.LockTokens = aTokens;
1850 +
1851 +#if OSL_DEBUG_LEVEL > 0
1852 + fprintf( stderr, "WebDAV: locked the URL, the token is: %s\n", theLock->token );
1853 +#endif
1854 + }
1855 + }
1856 +
1857 + if ( ( nRet == NE_ERROR ) && getStatusCode( m_pHttpSession ) == SC_LOCKED )
1858 + {
1859 + ucbhelper::cancelCommandExecution( ucb::IOErrorCode_LOCKING_VIOLATION,
1860 + uno::Sequence< uno::Any >( 0 ), // FIXME more info about the file?
1861 + m_aEnv.m_xEnv,
1862 + rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "a locking error occured" ) ),
1863 + uno::Reference< ucb::XCommandProcessor >() );
1864 + }
1865 +#if OSL_DEBUG_LEVEL > 0
1866 + else if ( nRet == NE_OK )
1867 + fprintf( stderr, "WebDAV: locked/refreshed lock OK\n" );
1868 + else
1869 + fprintf( stderr, "WebDAV: failed to lock the file: %s\n", ne_get_error( m_pHttpSession ) );
1870 +#endif
1871 + }
1872 + else
1873 + {
1874 + // Set the lock token
1875 + if ( rLock.LockTokens.getLength() > 0 )
1876 + {
1877 + rtl::OUString theToken = rLock.LockTokens.getConstArray()[ 0 ];
1878 + theLock->token = strdup( rtl::OUStringToOString( theToken, RTL_TEXTENCODING_UTF8 ).getStr() );
1879 +
1880 +#if OSL_DEBUG_LEVEL > 0
1881 + fprintf( stderr, "WebDAV: going to unlock the URL, the token is: %s\n", theLock->token );
1882 +#endif
1883 +
1884 + ne_unlock( m_pHttpSession, theLock );
1885 + ne_lockstore_remove( s_aNeonLockStore, theLock );
1886 + // FIXME even ne_lock_destroy( theLock )?
1887 + }
1888 + }
1889 }
1890 -*/
1891
1892 // -------------------------------------------------------------------
1893 namespace {
1894 --- ucb/source/ucp/webdav/NeonSession.hxx
1895 +++ ucb/source/ucp/webdav/NeonSession.hxx
1896 @@ -57,6 +57,7 @@ class NeonSession : public DAVSession
1897 rtl::OUString m_aScheme;
1898 rtl::OUString m_aHostName;
1899 rtl::OUString m_aProxyName;
1900 + rtl::OUString m_aUserInfo;
1901 sal_Int32 m_nPort;
1902 sal_Int32 m_nProxyPort;
1903 HttpSession * m_pHttpSession;
1904 @@ -70,8 +71,7 @@ class NeonSession : public DAVSession
1905 // moment.
1906 DAVRequestEnvironment m_aEnv;
1907
1908 - // Note: Uncomment the following if locking support is required
1909 - // NeonLockSession * mNeonLockSession;
1910 + static NeonLockStore *s_aNeonLockStore;
1911
1912 static bool m_bGlobalsInited;
1913
1914 @@ -92,6 +92,8 @@ class NeonSession : public DAVSession
1915 const DAVRequestEnvironment & getRequestEnvironment() const
1916 { return m_aEnv; }
1917
1918 + const rtl::OUString & getUserInfo() const { return m_aUserInfo; }
1919 +
1920 virtual void
1921 OPTIONS( const ::rtl::OUString & inPath,
1922 DAVCapabilities & outCapabilities,
1923 @@ -142,11 +144,12 @@ class NeonSession : public DAVSession
1924 throw ( DAVException );
1925
1926 virtual com::sun::star::uno::Reference<
1927 - com::sun::star::io::XInputStream >
1928 + com::sun::star::io::XStream >
1929 GET( const ::rtl::OUString & inPath,
1930 const std::vector< ::rtl::OUString > & inHeaderNames,
1931 DAVResource & ioResource,
1932 - const DAVRequestEnvironment & rEnv )
1933 + const DAVRequestEnvironment & rEnv,
1934 + sal_Bool bAllowEmpty = sal_False )
1935 throw ( DAVException );
1936
1937 virtual void
1938 @@ -165,6 +168,13 @@ class NeonSession : public DAVSession
1939 const DAVRequestEnvironment & rEnv )
1940 throw ( DAVException );
1941
1942 + virtual void
1943 + PUT( const ::rtl::OUString & inPath,
1944 + const char * buffer,
1945 + size_t size,
1946 + const DAVRequestEnvironment & rEnv )
1947 + throw ( DAVException );
1948 +
1949 virtual com::sun::star::uno::Reference<
1950 com::sun::star::io::XInputStream >
1951 POST( const rtl::OUString & inPath,
1952 @@ -209,16 +219,13 @@ class NeonSession : public DAVSession
1953 virtual void ABORT()
1954 throw ( DAVException );
1955
1956 - // Note: Uncomment the following if locking support is required
1957 - /*
1958 - virtual void LOCK (const Lock & inLock,
1959 - const DAVRequestEnvironment & rEnv )
1960 + virtual void LOCK ( com::sun::star::ucb::Lock & rLock,
1961 + const DAVRequestEnvironment & rEnv )
1962 throw ( DAVException );
1963
1964 - virtual void UNLOCK (const Lock & inLock,
1965 - const DAVRequestEnvironment & rEnv )
1966 + virtual void UNLOCK ( com::sun::star::ucb::Lock & rLock,
1967 + const DAVRequestEnvironment & rEnv )
1968 throw ( DAVException );
1969 - */
1970
1971 // helpers
1972 const rtl::OUString & getHostName() const { return m_aHostName; }
1973 @@ -239,9 +246,8 @@ class NeonSession : public DAVSession
1974
1975 const ucbhelper::InternetProxyServer & getProxySettings() const;
1976
1977 - // Note: Uncomment the following if locking support is required
1978 - // void Lockit( const Lock & inLock, bool inLockit )
1979 - // throw ( DAVException );
1980 + void Lockit( com::sun::star::ucb::Lock & rLock, bool bLockit )
1981 + throw ( DAVException );
1982
1983 // low level GET implementation, used by public GET implementations
1984 static int GET( ne_session * sess,
1985 --- ucb/source/ucp/webdav/NeonTypes.hxx.old 2009-04-02 11:01:38.000000000 +0000
1986 +++ ucb/source/ucp/webdav/NeonTypes.hxx 2009-04-06 16:41:46.000000000 +0000
1987 @@ -35,6 +35,7 @@
1988 #include <ne_utils.h>
1989 #include <ne_basic.h>
1990 #include <ne_props.h>
1991 +#include <ne_locks.h>
1992
1993 typedef ne_session HttpSession;
1994 typedef ne_status HttpStatus;
1995 @@ -43,4 +44,7 @@ typedef ne_server_capabilities Http
1996 typedef ne_propname NeonPropName;
1997 typedef ne_prop_result_set NeonPropFindResultSet;
1998
1999 +typedef ne_lock_store NeonLockStore;
2000 +typedef struct ne_lock NeonLock;
2001 +
2002 #endif // _NEONTYPES_HXX_
2003 --- ucb/source/ucp/webdav/webdavcontent.cxx.old 2009-04-02 11:01:38.000000000 +0000
2004 +++ ucb/source/ucp/webdav/webdavcontent.cxx 2009-04-06 16:41:46.000000000 +0000
2005 @@ -37,6 +37,7 @@
2006
2007 *************************************************************************/
2008 #include <osl/diagnose.h>
2009 +#include <osl/thread.hxx>
2010
2011 #include "osl/doublecheckedlocking.h"
2012 #include <rtl/uri.hxx>
2013 @@ -48,20 +49,17 @@
2014 #include <com/sun/star/beans/PropertySetInfoChangeEvent.hpp>
2015 #include <com/sun/star/beans/PropertyValue.hpp>
2016 #include <com/sun/star/io/XActiveDataSink.hpp>
2017 +#include <com/sun/star/io/XActiveDataStreamer.hpp>
2018 #include <com/sun/star/io/XOutputStream.hpp>
2019 #include <com/sun/star/lang/IllegalAccessException.hpp>
2020 #include "com/sun/star/ucb/AuthenticationRequest.hpp"
2021 #include <com/sun/star/ucb/CommandFailedException.hpp>
2022 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
2023 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
2024 -#ifndef _COM_SUN_STAR_UCB_INTERACTIVEBADTRANSFRERURLEXCEPTION_HPP_
2025 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
2026 -#endif
2027 #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
2028 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
2029 -#ifndef _COM_SUN_STAR_UCB_INTERACTIVENETWORKGENBERALEXCEPTION_HPP_
2030 #include <com/sun/star/ucb/InteractiveNetworkGeneralException.hpp>
2031 -#endif
2032 #include <com/sun/star/ucb/InteractiveNetworkReadException.hpp>
2033 #include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp>
2034 #include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp>
2035 @@ -90,6 +88,8 @@
2036 #include "NeonUri.hxx"
2037 #include "UCBDeadPropertyValue.hxx"
2038
2039 +#include "NeonInputStream.hxx"
2040 +
2041 using namespace com::sun::star;
2042 using namespace webdav_ucp;
2043
2044 @@ -345,6 +345,123 @@ void SAL_CALL CommandEnvironment_Impl::h
2045 //=========================================================================
2046 //=========================================================================
2047
2048 +// Our signal - 246 is just a random number ;-)
2049 +#define TICKER_THREAD_USER_SIGNAL ( OSL_SIGNAL_USER_RESERVED + 246 )
2050 +
2051 +// -------------------------------------------------------------------
2052 +// A thread that 'ticks' - emits the user signal every second
2053 +// -------------------------------------------------------------------
2054 +class TickerThread : public osl::Thread
2055 +{
2056 + bool m_bFinish;
2057 +
2058 +public:
2059 +
2060 + TickerThread() : osl::Thread(), m_bFinish( false ) {}
2061 +
2062 + void finish() { m_bFinish = true; }
2063 +
2064 +protected:
2065 +
2066 + virtual void SAL_CALL run();
2067 +};
2068 +
2069 +void TickerThread::run()
2070 +{
2071 + // we have to go through the loop more often to be able to finish ~quickly
2072 + const int nNth = 25;
2073 +
2074 + int nCount = nNth;
2075 + while ( !m_bFinish )
2076 + {
2077 + if ( nCount-- <= 0 )
2078 + {
2079 + osl_raiseSignal( TICKER_THREAD_USER_SIGNAL, NULL );
2080 + nCount = nNth;
2081 + }
2082 +
2083 + TimeValue aTV;
2084 + aTV.Seconds = 0;
2085 + aTV.Nanosec = 1000000000/nNth;
2086 + wait( aTV );
2087 + }
2088 +}
2089 +
2090 +// -------------------------------------------------------------------
2091 +// A class that takes care of creating and destroying the ticker thread
2092 +// -------------------------------------------------------------------
2093 +class TickerThreadController
2094 +{
2095 + osl::Mutex m_aMutex;
2096 + int m_nCount;
2097 + TickerThread *m_pTickerThread;
2098 +
2099 +public:
2100 +
2101 + TickerThreadController() : m_nCount( 0 ), m_pTickerThread( NULL ) {}
2102 +
2103 + void start();
2104 + void stop();
2105 +};
2106 +
2107 +void TickerThreadController::start()
2108 +{
2109 + osl::MutexGuard aGuard( m_aMutex );
2110 +
2111 + if ( ( m_nCount++ == 0 ) && !m_pTickerThread )
2112 + {
2113 + m_pTickerThread = new TickerThread();
2114 + m_pTickerThread->create();
2115 + }
2116 +}
2117 +
2118 +void TickerThreadController::stop()
2119 +{
2120 + osl::MutexGuard aGuard( m_aMutex );
2121 +
2122 + if ( ( --m_nCount == 0 ) && m_pTickerThread )
2123 + {
2124 + m_pTickerThread->finish();
2125 + m_pTickerThread->join();
2126 +
2127 + delete m_pTickerThread;
2128 + m_pTickerThread = NULL;
2129 + }
2130 +}
2131 +
2132 +// -------------------------------------------------------------------
2133 +// Signal handler
2134 +// -------------------------------------------------------------------
2135 +oslSignalAction Content::HandleLockingSignal( void* pData, oslSignalInfo* pSignalInfo )
2136 +{
2137 + Content *pContent = static_cast< Content *>( pData );
2138 +
2139 +#if OSL_DEBUG_LEVEL > 0
2140 + fprintf( stderr, "Content::HandleLockingSignal: pContent=%p pSignalInfo=%p\n", pContent, pSignalInfo );
2141 +#endif
2142 +
2143 + if ( !pContent )
2144 + return osl_Signal_ActCallNextHdl;
2145 +
2146 + if ( pSignalInfo &&
2147 + pSignalInfo->Signal == osl_Signal_User &&
2148 + pSignalInfo->UserSignal == TICKER_THREAD_USER_SIGNAL )
2149 + {
2150 + pContent->RefreshLock();
2151 + }
2152 + else if ( !pSignalInfo || ( pSignalInfo->Signal != osl_Signal_User ) )
2153 + {
2154 + // terminating or something
2155 + pContent->m_xResAccess->UNLOCK( *pContent->m_pLock, pContent->m_xLockEnv );
2156 + delete pContent->m_pLock;
2157 + pContent->m_pLock = NULL;
2158 + }
2159 +
2160 + return osl_Signal_ActCallNextHdl;
2161 +}
2162 +
2163 +static TickerThreadController sTickerThreadController;
2164 +
2165 //=========================================================================
2166 // ctr for content on an existing webdav resource
2167 Content::Content(
2168 @@ -358,7 +475,11 @@ Content::Content(
2169 m_pProvider( pProvider ),
2170 m_bTransient( false ),
2171 m_bCollection( false ),
2172 - m_bDidGetOrHead( false )
2173 + m_bDidGetOrHead( false ),
2174 + m_bForceReadOnly( false ),
2175 + m_pLock( NULL ),
2176 + m_nToExpire( -1 ),
2177 + m_pSignalHandler( NULL )
2178 {
2179 try
2180 {
2181 @@ -369,6 +490,14 @@ Content::Content(
2182
2183 NeonUri aURI( Identifier->getContentIdentifier() );
2184 m_aEscapedTitle = aURI.GetPathBaseName();
2185 +
2186 + m_pSignalHandler = osl_addSignalHandler( HandleLockingSignal, this );
2187 +
2188 +#if OSL_DEBUG_LEVEL > 0
2189 + fprintf( stderr, "Content::Content (existing resource): this=%p m_pSignalHandler=%p\n", this, m_pSignalHandler );
2190 + fprintf( stderr, " identifier=%s\n", rtl::OUStringToOString( Identifier->getContentIdentifier(), RTL_TEXTENCODING_UTF8 ).getStr() );
2191 +#endif
2192 + sTickerThreadController.start();
2193 }
2194 catch ( DAVException const & )
2195 {
2196 @@ -390,12 +518,24 @@ Content::Content(
2197 m_pProvider( pProvider ),
2198 m_bTransient( true ),
2199 m_bCollection( isCollection ),
2200 - m_bDidGetOrHead( false )
2201 + m_bDidGetOrHead( false ),
2202 + m_bForceReadOnly( false ),
2203 + m_pLock( NULL ),
2204 + m_nToExpire( -1 ),
2205 + m_pSignalHandler( NULL )
2206 {
2207 try
2208 {
2209 m_xResAccess.reset( new DAVResourceAccess(
2210 rxSMgr, rSessionFactory, Identifier->getContentIdentifier() ) );
2211 +
2212 + m_pSignalHandler = osl_addSignalHandler( HandleLockingSignal, this );
2213 +
2214 +#if OSL_DEBUG_LEVEL > 0
2215 + fprintf( stderr, "Content::Content (nonexistent resource): this=%p m_pSignalHandler=%p\n", this, m_pSignalHandler );
2216 + fprintf( stderr, " identifier=%s\n", rtl::OUStringToOString( Identifier->getContentIdentifier(), RTL_TEXTENCODING_UTF8 ).getStr() );
2217 +#endif
2218 + sTickerThreadController.start();
2219 }
2220 catch ( DAVException const & )
2221 {
2222 @@ -409,6 +548,47 @@ Content::Content(
2223 // virtual
2224 Content::~Content()
2225 {
2226 +#if OSL_DEBUG_LEVEL > 0
2227 + fprintf( stderr, "Content::~Content: this=%p m_pSignalHandler=%p\n", this, m_pSignalHandler );
2228 +#endif
2229 + sTickerThreadController.stop();
2230 +
2231 + osl_removeSignalHandler( m_pSignalHandler );
2232 +
2233 + if (m_pLock != NULL)
2234 + {
2235 + try {
2236 + m_xResAccess->UNLOCK( *m_pLock, m_xLockEnv );
2237 + delete m_pLock;
2238 + m_pLock = NULL;
2239 + }
2240 + catch ( ucb::CommandFailedException const & )
2241 + {
2242 + }
2243 + }
2244 +}
2245 +
2246 +// -------------------------------------------------------------------
2247 +// Lock the resource again
2248 +// -------------------------------------------------------------------
2249 +void Content::RefreshLock( void )
2250 +{
2251 + osl::MutexGuard aGuard( m_aLock );
2252 +
2253 +#if OSL_DEBUG_LEVEL > 0
2254 + fprintf( stderr, "Content::RefreshLock(): m_nToExpire=%d m_pLock=%p\n", m_nToExpire, m_pLock);
2255 +#endif
2256 +
2257 + if ( m_nToExpire > 0 )
2258 + --m_nToExpire;
2259 +
2260 + // Refresh the lock if it expires in less than 30 s
2261 + if ( m_pLock && m_nToExpire >= 0 && m_nToExpire < 30 )
2262 + {
2263 + m_xResAccess->LOCK( *m_pLock, m_xLockEnv );
2264 +
2265 + m_nToExpire = m_pLock->Timeout;
2266 + }
2267 }
2268
2269 //=========================================================================
2270 @@ -630,6 +811,11 @@ uno::Any SAL_CALL Content::execute(
2271 ucb::CommandAbortedException,
2272 uno::RuntimeException )
2273 {
2274 +#if OSL_DEBUG_LEVEL > 0
2275 + fprintf( stderr, "WebDAV: Content::execute(): this=%p command=%s\n",
2276 + this, rtl::OUStringToOString( aCommand.Name, RTL_TEXTENCODING_UTF8 ).getStr() );
2277 +#endif
2278 +
2279 uno::Any aRet;
2280
2281 if ( aCommand.Name.equalsAsciiL(
2282 @@ -1000,6 +1000,11 @@
2283 if ( !Name.getLength() )
2284 throw lang::IllegalArgumentException();
2285
2286 +#if OSL_DEBUG_LEVEL > 0
2287 + fprintf( stderr, "WebDAV: Content::addProperty(): this=%p property=%s\n",
2288 + this, rtl::OUStringToOString( Name, RTL_TEXTENCODING_UTF8 ).getStr() );
2289 +#endif
2290 +
2291 // Check property type.
2292 if ( !UCBDeadPropertyValue::supportsType( DefaultValue.getValueType() ) )
2293 {
2294 @@ -1100,6 +1100,11 @@
2295 // Try to remove property from server.
2296 //////////////////////////////////////////////////////////////////////
2297
2298 +#if OSL_DEBUG_LEVEL > 0
2299 + fprintf( stderr, "WebDAV: Content::removeProperty(): this=%p property=%s\n",
2300 + this, rtl::OUStringToOString( Name, RTL_TEXTENCODING_UTF8 ).getStr() );
2301 +#endif
2302 +
2303 try
2304 {
2305 std::vector< ProppatchValue > aProppatchValues;
2306 @@ -1349,6 +1535,31 @@ uno::Reference< sdbc::XRow > Content::ge
2307 uno::Reference< ucb::XContentIdentifier > xIdentifier;
2308 rtl::Reference< ::ucbhelper::ContentProviderImplHelper > xProvider;
2309
2310 +#if OSL_DEBUG_LEVEL > 0
2311 + fprintf( stderr, "WebDAV: Content::getPropertyValues(): answering the following properties: " );
2312 + for ( int i = 0; i < rProperties.getLength(); ++i )
2313 + fprintf( stderr, " %s,",
2314 + rtl::OUStringToOString( rProperties[i].Name, RTL_TEXTENCODING_UTF8 ).getStr() );
2315 + fprintf( stderr, "\n" );
2316 +#endif
2317 +
2318 + // WebDAV supports XActiveDataStreamer
2319 + // We have to return TRUE on
2320 + // - SupportsActiveStreaming - always
2321 + // - IsReadOnly - if we forced read only due to failed locking
2322 + if ( rProperties.getLength() == 1 )
2323 + {
2324 + if ( rProperties[ 0 ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "SupportsActiveStreaming" ) ) ||
2325 + ( rProperties[ 0 ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsReadOnly" ) ) && m_bForceReadOnly ) )
2326 + {
2327 + rtl::Reference< ::ucbhelper::PropertyValueSet > xRow
2328 + = new ::ucbhelper::PropertyValueSet( m_xSMgr );
2329 + xRow->appendBoolean( rProperties[0], sal_True );
2330 +
2331 + return uno::Reference< sdbc::XRow >( xRow.get() );
2332 + }
2333 + }
2334 +
2335 {
2336 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2337
2338 @@ -1475,8 +1686,13 @@ uno::Reference< sdbc::XRow > Content::ge
2339
2340 if ( !bNetworkAccessAllowed )
2341 {
2342 - cancelCommandExecution( e, xEnv );
2343 - // unreachable
2344 + if ( e.getStatus() == SC_NOT_FOUND )
2345 + xProps.reset();
2346 + else
2347 + {
2348 + cancelCommandExecution( e, xEnv );
2349 + // unreachable
2350 + }
2351 }
2352 }
2353 }
2354 @@ -2000,6 +2000,10 @@
2355 {
2356 uno::Any aRet;
2357
2358 +#if OSL_DEBUG_LEVEL > 0
2359 + fprintf( stderr, "WebDAV: Content::open() this=%p\n", this );
2360 +#endif
2361 +
2362 sal_Bool bOpenFolder = ( ( rArg.Mode == ucb::OpenMode::ALL ) ||
2363 ( rArg.Mode == ucb::OpenMode::FOLDERS ) ||
2364 ( rArg.Mode == ucb::OpenMode::DOCUMENTS ) );
2365 @@ -2092,13 +2308,17 @@ uno::Any Content::open(
2366 }
2367 }
2368
2369 - if ( rArg.Sink.is() )
2370 - {
2371 - // Open document.
2372 + if ( !rArg.Sink.is() )
2373 + return aRet;
2374 +
2375 + // Open document.
2376
2377 if ( ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) ||
2378 ( rArg.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE ) )
2379 {
2380 +#if OSL_DEBUG_LEVEL > 0
2381 + fprintf( stderr, "WebDAV: rArg.Mode currently(?) unsupported\n" );
2382 +#endif
2383 // Currently(?) unsupported.
2384 ucbhelper::cancelCommandExecution(
2385 uno::makeAny(
2386 @@ -2115,6 +2332,9 @@ uno::Any Content::open(
2387 = uno::Reference< io::XOutputStream >( rArg.Sink, uno::UNO_QUERY );
2388 if ( xOut.is() )
2389 {
2390 +#if OSL_DEBUG_LEVEL > 0
2391 + fprintf( stderr, "WebDAV: rArg.Sink is XOutputStream\n" );
2392 +#endif
2393 // PUSH: write data
2394 try
2395 {
2396 @@ -2159,6 +2379,60 @@ uno::Any Content::open(
2397 uno::UNO_QUERY );
2398 if ( xDataSink.is() )
2399 {
2400 +#if OSL_DEBUG_LEVEL > 0
2401 + fprintf( stderr, "WebDAV: rArg.Sink is XActiveDataSink\n" );
2402 +#endif
2403 + // PULL: wait for client read
2404 + try
2405 + {
2406 + {
2407 + osl::MutexGuard aGuard( m_aMutex );
2408 +
2409 + // throw away previously cached headers.
2410 + m_xCachedProps.reset();
2411 + }
2412 + // fill inputsream sync; return if all data present
2413 + DAVResource aResource;
2414 + std::vector< rtl::OUString > aHeaders;
2415 + // // Obtain list containing all HTTP headers that can
2416 + // // be mapped to UCB properties.
2417 + // ContentProperties::getMappableHTTPHeaders( aHeaders );
2418 + uno::Reference< io::XInputStream > xIn
2419 + = m_xResAccess->GET( aHeaders, aResource, xEnv )->getInputStream();
2420 +
2421 + {
2422 + osl::MutexGuard aGuard( m_aMutex );
2423 +
2424 + m_xCachedProps.reset(
2425 + new ContentProperties( aResource ) );
2426 + }
2427 +
2428 + xDataSink->setInputStream( xIn );
2429 + }
2430 + catch ( DAVException const & e )
2431 + {
2432 + cancelCommandExecution( e, xEnv );
2433 + // Unreachable
2434 + }
2435 + }
2436 + else
2437 + {
2438 + uno::Reference< io::XActiveDataStreamer > xDataStreamer
2439 + = uno::Reference< io::XActiveDataStreamer >( rArg.Sink,
2440 + uno::UNO_QUERY );
2441 + if ( xDataStreamer.is() && !m_bForceReadOnly )
2442 + {
2443 +#if OSL_DEBUG_LEVEL > 0
2444 + fprintf( stderr, "WebDAV: rArg.Sink is XActiveDataStreamer\n" );
2445 +#endif
2446 + // prepare the lock
2447 + m_pLock = new ucb::Lock;
2448 + m_pLock->Depth = ucb::LockDepth_ZERO;
2449 + m_pLock->Scope = ucb::LockScope_EXCLUSIVE;
2450 + m_pLock->Timeout = 2*60; // 2 minutes
2451 +
2452 + m_nToExpire = m_pLock->Timeout;
2453 +
2454 // PULL: wait for client read
2455 try
2456 {
2457 @@ -2174,9 +2448,31 @@ uno::Any Content::open(
2458 DAVResource aResource;
2459 std::vector< rtl::OUString > aHeaders;
2460
2461 - uno::Reference< io::XInputStream > xIn
2462 - = xResAccess->GET( aHeaders, aResource, xEnv );
2463 + try {
2464 + m_xResAccess->LOCK( *m_pLock, xEnv );
2465 + m_xLockEnv = xEnv;
2466 + }
2467 + catch ( ucb::CommandFailedException const &e )
2468 + {
2469 + // stream locked?
2470 + ucb::InteractiveIOException aIoException;
2471 + if ( ( e.Reason >>= aIoException ) && ( aIoException.Code == ucb::IOErrorCode_LOCKING_VIOLATION ) )
2472 + {
2473 + delete m_pLock;
2474 + m_pLock = NULL;
2475 + // yes => we must be read only at the next try
2476 + m_bForceReadOnly = sal_True;
2477 + }
2478 +
2479 + throw;
2480 + }
2481 +
2482 + uno::Reference< io::XStream > xStream
2483 + = xResAccess->GET( aHeaders, aResource, xEnv, sal_True );
2484 m_bDidGetOrHead = true;
2485 +
2486 + // pass the URL to the stream
2487 + static_cast< NeonInputStream* >( xStream.get() )->SetURL( m_xResAccess->getURL() );
2488
2489 {
2490 osl::MutexGuard aGuard( m_aMutex );
2491 @@ -2191,16 +2487,24 @@ uno::Any Content::open(
2492 new DAVResourceAccess( *xResAccess.get() ) );
2493 }
2494
2495 - xDataSink->setInputStream( xIn );
2496 + xDataStreamer->setStream( xStream );
2497 }
2498 catch ( DAVException const & e )
2499 {
2500 + m_xResAccess->UNLOCK( *m_pLock, xEnv );
2501 + delete m_pLock;
2502 + m_pLock = NULL;
2503 + m_bForceReadOnly = sal_False;
2504 +
2505 cancelCommandExecution( e, xEnv );
2506 // Unreachable
2507 }
2508 }
2509 else
2510 {
2511 +#if OSL_DEBUG_LEVEL > 0
2512 + fprintf( stderr, "WebDAV: unsupported rArg.Sink\n" );
2513 +#endif
2514 // Note: aOpenCommand.Sink may contain an XStream
2515 // implementation. Support for this type of
2516 // sink is optional...
2517 @@ -2228,9 +2532,16 @@ void Content::post(
2518 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
2519 throw( uno::Exception )
2520 {
2521 +#if OSL_DEBUG_LEVEL > 0
2522 + fprintf( stderr, "WebDAV: Content::post() this=%p\n", this );
2523 +#endif
2524 +
2525 uno::Reference< io::XActiveDataSink > xSink( rArg.Sink, uno::UNO_QUERY );
2526 if ( xSink.is() )
2527 {
2528 +#if OSL_DEBUG_LEVEL > 0
2529 + fprintf( stderr, "WebDAV: rArg.Sink is XActiveDataSink\n" );
2530 +#endif
2531 try
2532 {
2533 std::auto_ptr< DAVResourceAccess > xResAccess;
2534 @@ -2262,6 +2569,9 @@ void Content::post(
2535 uno::Reference< io::XOutputStream > xResult( rArg.Sink, uno::UNO_QUERY );
2536 if ( xResult.is() )
2537 {
2538 +#if OSL_DEBUG_LEVEL > 0
2539 + fprintf( stderr, "WebDAV: rArg.Sink is XOutputStream\n" );
2540 +#endif
2541 try
2542 {
2543 std::auto_ptr< DAVResourceAccess > xResAccess;
2544 @@ -2291,6 +2601,9 @@ void Content::post(
2545 }
2546 else
2547 {
2548 +#if OSL_DEBUG_LEVEL > 0
2549 + fprintf( stderr, "WebDAV: rArg.Sink is XActiveDataStreamer (or something)\n" );
2550 +#endif
2551 ucbhelper::cancelCommandExecution(
2552 uno::makeAny(
2553 ucb::UnsupportedDataSinkException(
2554 @@ -2600,6 +2600,10 @@
2555 rtl::OUString aEscapedTitle;
2556 std::auto_ptr< DAVResourceAccess > xResAccess;
2557
2558 +#if OSL_DEBUG_LEVEL > 0
2559 + fprintf( stderr, "WebDAV: Content::insert() this=%p\n", this );
2560 +#endif
2561 +
2562 {
2563 osl::Guard< osl::Mutex > aGuard( m_aMutex );
2564
2565 @@ -2643,11 +2956,23 @@ void Content::transfer(
2566 rtl::OUString::createFromAscii( HTTP_URL_SCHEME ) );
2567 }
2568 else if ( aScheme.equalsAsciiL(
2569 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAV_URL_SCHEME ) ) )
2570 + {
2571 + sourceURI.SetScheme(
2572 + rtl::OUString::createFromAscii( HTTP_URL_SCHEME ) );
2573 + }
2574 + else if ( aScheme.equalsAsciiL(
2575 RTL_CONSTASCII_STRINGPARAM( DAVS_URL_SCHEME ) ) )
2576 {
2577 sourceURI.SetScheme(
2578 rtl::OUString::createFromAscii( HTTPS_URL_SCHEME ) );
2579 }
2580 + else if ( aScheme.equalsAsciiL(
2581 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAVS_URL_SCHEME ) ) )
2582 + {
2583 + sourceURI.SetScheme(
2584 + rtl::OUString::createFromAscii( HTTPS_URL_SCHEME ) );
2585 + }
2586 else
2587 {
2588 if ( !aScheme.equalsAsciiL(
2589 @@ -2674,6 +2999,18 @@ void Content::transfer(
2590 RTL_CONSTASCII_STRINGPARAM( DAV_URL_SCHEME ) ) )
2591 targetURI.SetScheme(
2592 rtl::OUString::createFromAscii( HTTP_URL_SCHEME ) );
2593 + else if ( targetURI.GetScheme().toAsciiLowerCase().equalsAsciiL(
2594 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAV_URL_SCHEME ) ) )
2595 + targetURI.SetScheme(
2596 + rtl::OUString::createFromAscii( HTTP_URL_SCHEME ) );
2597 + else if ( targetURI.GetScheme().toAsciiLowerCase().equalsAsciiL(
2598 + RTL_CONSTASCII_STRINGPARAM( DAVS_URL_SCHEME ) ) )
2599 + targetURI.SetScheme(
2600 + rtl::OUString::createFromAscii( HTTPS_URL_SCHEME ) );
2601 + else if ( targetURI.GetScheme().toAsciiLowerCase().equalsAsciiL(
2602 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAVS_URL_SCHEME ) ) )
2603 + targetURI.SetScheme(
2604 + rtl::OUString::createFromAscii( HTTPS_URL_SCHEME ) );
2605
2606 // @@@ This implementation of 'transfer' only works
2607 // if the source and target are located at same host.
2608 --- ucb/source/ucp/webdav/webdavcontent.hxx.old 2009-04-02 11:01:38.000000000 +0000
2609 +++ ucb/source/ucp/webdav/webdavcontent.hxx 2009-04-06 16:41:46.000000000 +0000
2610 @@ -33,10 +33,13 @@
2611
2612 #include <memory>
2613 #include <list>
2614 +#include <osl/signal.h>
2615 #include <rtl/ref.hxx>
2616 #include <com/sun/star/ucb/ContentCreationException.hpp>
2617 #include <com/sun/star/ucb/XContentCreator.hpp>
2618 +#include <com/sun/star/ucb/Lock.hpp>
2619 #include <ucbhelper/contenthelper.hxx>
2620 +
2621 #include "DAVResourceAccess.hxx"
2622 #include "PropertyMap.hxx"
2623
2624 @@ -91,6 +94,9 @@ class Content : public ::ucbhelper::Cont
2625 bool m_bTransient;
2626 bool m_bCollection;
2627 bool m_bDidGetOrHead;
2628 + bool m_bForceReadOnly;
2629 + com::sun::star::ucb::Lock *m_pLock;
2630 + uno::Reference< ucb::XCommandEnvironment > m_xLockEnv;
2631 std::vector< rtl::OUString > m_aFailedPropNames;
2632
2633 private:
2634 @@ -184,6 +190,17 @@ private:
2635
2636 static bool shouldAccessNetworkAfterException( const DAVException & e );
2637
2638 + oslSignalHandler m_pSignalHandler;
2639 + int m_nToExpire;
2640 + osl::Mutex m_aLock;
2641 +
2642 + // Refresh the lock of the resource
2643 + void RefreshLock( void );
2644 +
2645 + // Refresh the lock if necessary, or unlock the resource when
2646 + // OOo crashes or is terminated
2647 + static oslSignalAction HandleLockingSignal( void* pData, oslSignalInfo* pInfo );
2648 +
2649 public:
2650 Content( const ::com::sun::star::uno::Reference<
2651 ::com::sun::star::lang::XMultiServiceFactory >& rxSMgr,
2652 --- ucb/source/ucp/webdav/webdavcontentcaps.cxx.old 2009-04-02 11:01:38.000000000 +0000
2653 +++ ucb/source/ucp/webdav/webdavcontentcaps.cxx 2009-04-06 16:41:46.000000000 +0000
2654 @@ -263,6 +263,24 @@ bool ContentProvider::getProperty(
2655 -1,
2656 getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
2657 beans::PropertyAttribute::BOUND ) );
2658 +
2659 + m_pProps->insert(
2660 + beans::Property(
2661 + rtl::OUString(
2662 + RTL_CONSTASCII_USTRINGPARAM( "SupportsActiveStreaming" ) ),
2663 + -1,
2664 + getCppuBooleanType(),
2665 + beans::PropertyAttribute::BOUND
2666 + | beans::PropertyAttribute::READONLY ) );
2667 +
2668 + m_pProps->insert(
2669 + beans::Property(
2670 + rtl::OUString(
2671 + RTL_CONSTASCII_USTRINGPARAM( "IsReadOnly" ) ),
2672 + -1,
2673 + getCppuBooleanType(),
2674 + beans::PropertyAttribute::BOUND
2675 + | beans::PropertyAttribute::READONLY ) );
2676 }
2677 }
2678
2679 --- ucb/source/ucp/webdav/webdavprovider.cxx.old 2009-04-02 11:01:38.000000000 +0000
2680 +++ ucb/source/ucp/webdav/webdavprovider.cxx 2009-04-06 16:41:46.000000000 +0000
2681 @@ -36,6 +36,9 @@
2682 **************************************************************************
2683
2684 *************************************************************************/
2685 +
2686 +#include <string.h>
2687 +
2688 #include <ucbhelper/contentidentifier.hxx>
2689 #include "webdavprovider.hxx"
2690 #include "webdavcontent.hxx"
2691 @@ -138,7 +141,11 @@ ContentProvider::queryContent(
2692 RTL_CONSTASCII_STRINGPARAM( DAV_URL_SCHEME ) ) &&
2693 !aScheme.equalsAsciiL(
2694 RTL_CONSTASCII_STRINGPARAM( DAVS_URL_SCHEME ) ) &&
2695 - !aScheme.equalsAsciiL(
2696 + !aScheme.equalsAsciiL(
2697 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAV_URL_SCHEME ) ) &&
2698 + !aScheme.equalsAsciiL(
2699 + RTL_CONSTASCII_STRINGPARAM( PLAIN_WEBDAVS_URL_SCHEME ) ) &&
2700 + !aScheme.equalsAsciiL(
2701 RTL_CONSTASCII_STRINGPARAM( FTP_URL_SCHEME ) ) )
2702 throw ucb::IllegalIdentifierException();
2703
2704 @@ -157,32 +164,27 @@ ContentProvider::queryContent(
2705 uno::Reference< ucb::XContentIdentifier > xCanonicId;
2706
2707 bool bNewId = false;
2708 - if ( aScheme.equalsAsciiL(
2709 - RTL_CONSTASCII_STRINGPARAM( WEBDAV_URL_SCHEME ) ) )
2710 + struct {
2711 + const char *from;
2712 + const char *to;
2713 + } const *pScheme, pReplace[] = {
2714 + { WEBDAV_URL_SCHEME, HTTP_URL_SCHEME },
2715 + { DAV_URL_SCHEME, HTTP_URL_SCHEME },
2716 + { DAVS_URL_SCHEME, HTTPS_URL_SCHEME },
2717 + { PLAIN_WEBDAV_URL_SCHEME, HTTP_URL_SCHEME },
2718 + { PLAIN_WEBDAVS_URL_SCHEME, HTTPS_URL_SCHEME },
2719 + { NULL, NULL }
2720 + };
2721 + for ( pScheme = pReplace; pScheme->from ; ++pScheme )
2722 {
2723 - aURL = aURL.replaceAt( 0,
2724 - WEBDAV_URL_SCHEME_LENGTH,
2725 - rtl::OUString::createFromAscii(
2726 - HTTP_URL_SCHEME ) );
2727 - bNewId = true;
2728 - }
2729 - else if ( aScheme.equalsAsciiL(
2730 - RTL_CONSTASCII_STRINGPARAM( DAV_URL_SCHEME ) ) )
2731 - {
2732 - aURL = aURL.replaceAt( 0,
2733 - DAV_URL_SCHEME_LENGTH,
2734 - rtl::OUString::createFromAscii(
2735 - HTTP_URL_SCHEME ) );
2736 - bNewId = true;
2737 - }
2738 - else if ( aScheme.equalsAsciiL(
2739 - RTL_CONSTASCII_STRINGPARAM( DAVS_URL_SCHEME ) ) )
2740 - {
2741 - aURL = aURL.replaceAt( 0,
2742 - DAVS_URL_SCHEME_LENGTH,
2743 - rtl::OUString::createFromAscii(
2744 - HTTPS_URL_SCHEME ) );
2745 - bNewId = true;
2746 + if ( aScheme.equalsAscii( pScheme->from ) )
2747 + {
2748 + aURL = aURL.replaceAt( 0,
2749 + strlen( pScheme->from ),
2750 + rtl::OUString::createFromAscii( pScheme->to ) );
2751 + bNewId = true;
2752 + break;
2753 + }
2754 }
2755
2756 sal_Int32 nPos = aURL.lastIndexOf( '/' );
2757 @@ -208,6 +208,12 @@
2758 else
2759 xCanonicId = Identifier;
2760
2761 +#if OSL_DEBUG_LEVEL > 0
2762 + fprintf( stderr, "ContentProvider::queryContent(): bNewId=%s, xCanonicId=%s\n",
2763 + bNewId ? "YES" : "NO",
2764 + rtl::OUStringToOString( xCanonicId->getContentIdentifier(), RTL_TEXTENCODING_UTF8 ).getStr() );
2765 +#endif
2766 +
2767 osl::MutexGuard aGuard( m_aMutex );
2768
2769 // Check, if a content with given id already exists...
2770 @@ -232,4 +234,3 @@ ContentProvider::queryContent(
2771
2772 return xContent;
2773 }
2774 -
2775 --- ucb/source/ucp/webdav/webdavprovider.hxx.old 2009-04-02 11:01:38.000000000 +0000
2776 +++ ucb/source/ucp/webdav/webdavprovider.hxx 2009-04-06 16:41:46.000000000 +0000
2777 @@ -52,13 +52,10 @@ namespace webdav_ucp {
2778 // contents ) according to this scheme.
2779 #define WEBDAV_URL_SCHEME \
2780 "vnd.sun.star.webdav"
2781 -#define WEBDAV_URL_SCHEME_LENGTH 19
2782
2783 #define HTTP_URL_SCHEME "http"
2784 -#define HTTP_URL_SCHEME_LENGTH 4
2785
2786 #define HTTPS_URL_SCHEME "https"
2787 -#define HTTPS_URL_SCHEME_LENGTH 5
2788
2789 #define DAV_URL_SCHEME "dav"
2790 #define DAV_URL_SCHEME_LENGTH 3
2791 @@ -70,6 +67,12 @@ namespace webdav_ucp {
2792
2793 #define FTP_URL_SCHEME "ftp"
2794
2795 +#define DAV_URL_SCHEME "dav"
2796 +#define DAVS_URL_SCHEME "davs"
2797 +
2798 +#define PLAIN_WEBDAV_URL_SCHEME "webdav"
2799 +#define PLAIN_WEBDAVS_URL_SCHEME "webdavs"
2800 +
2801 #define HTTP_CONTENT_TYPE \
2802 "application/" HTTP_URL_SCHEME "-content"
2803
2804 --- unotools/source/ucbhelper/ucblockbytes.cxx.old 2009-04-02 10:57:40.000000000 +0000
2805 +++ unotools/source/ucbhelper/ucblockbytes.cxx 2009-04-06 16:41:46.000000000 +0000
2806 @@ -964,6 +964,10 @@ static sal_Bool UCBOpenContentSync(
2807 if( ! aScheme.equalsIgnoreAsciiCaseAscii("http") &&
2808 ! aScheme.equalsIgnoreAsciiCaseAscii("https") &&
2809 ! aScheme.equalsIgnoreAsciiCaseAscii("vnd.sun.star.webdav") &&
2810 + ! aScheme.equalsIgnoreAsciiCaseAscii("dav") &&
2811 + ! aScheme.equalsIgnoreAsciiCaseAscii("davs") &&
2812 + ! aScheme.equalsIgnoreAsciiCaseAscii("webdav") &&
2813 + ! aScheme.equalsIgnoreAsciiCaseAscii("webdavs") &&
2814 ! aScheme.equalsIgnoreAsciiCaseAscii("ftp"))
2815 return _UCBOpenContentSync(
2816 xLockBytes,xContent,rArg,xSink,xInteract,xProgress,xHandler);
2817 @@ -1541,7 +1545,13 @@ ErrCode UcbLockBytes::Flush() const
2818 Reference <XOutputStream > xOutputStream = getOutputStream_Impl();
2819 if ( !xOutputStream.is() )
2820 return ERRCODE_IO_CANTWRITE;
2821 - xOutputStream->flush();
2822 + try {
2823 + xOutputStream->flush();
2824 + }
2825 + catch (...)
2826 + {
2827 + return ERRCODE_IO_CANTWRITE;
2828 + }
2829 return ERRCODE_NONE;
2830 }
2831
vba interoperability for OOo