1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include <string.h> 25 #include <unistd.h> 26 #include <sys/types.h> 27 28 #include "osl/time.h" 29 #include <osl/diagnose.h> 30 31 #include "osl/doublecheckedlocking.h" 32 33 #include <com/sun/star/beans/PropertyValue.hpp> 34 #include <com/sun/star/beans/PropertyAttribute.hpp> 35 #include <com/sun/star/beans/PropertySetInfoChange.hpp> 36 #include <com/sun/star/beans/PropertySetInfoChangeEvent.hpp> 37 #include <com/sun/star/io/XActiveDataSink.hpp> 38 #include <com/sun/star/io/XOutputStream.hpp> 39 #include <com/sun/star/lang/IllegalAccessException.hpp> 40 #include <com/sun/star/ucb/ContentInfoAttribute.hpp> 41 #include <com/sun/star/ucb/InsertCommandArgument.hpp> 42 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp> 43 #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> 44 #include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp> 45 #include <com/sun/star/ucb/InteractiveNetworkGeneralException.hpp> 46 #include <com/sun/star/ucb/InteractiveNetworkReadException.hpp> 47 #include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp> 48 #include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp> 49 #include <com/sun/star/ucb/NameClash.hpp> 50 #include <com/sun/star/ucb/NameClashException.hpp> 51 #include <com/sun/star/ucb/OpenCommandArgument2.hpp> 52 #include <com/sun/star/ucb/OpenMode.hpp> 53 #include <com/sun/star/ucb/PostCommandArgument2.hpp> 54 #include <com/sun/star/ucb/TransferInfo.hpp> 55 #include <com/sun/star/ucb/XCommandInfo.hpp> 56 #include <com/sun/star/ucb/XPersistentPropertySet.hpp> 57 #include <com/sun/star/ucb/MissingInputStreamException.hpp> 58 #include <com/sun/star/ucb/MissingPropertiesException.hpp> 59 #include <com/sun/star/ucb/UnsupportedCommandException.hpp> 60 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp> 61 #include <com/sun/star/ucb/UnsupportedNameClashException.hpp> 62 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp> 63 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp> 64 #include <com/sun/star/ucb/NameClashException.hpp> 65 #include <ucbhelper/contentidentifier.hxx> 66 #include <ucbhelper/propertyvalueset.hxx> 67 #include <ucbhelper/interactionrequest.hxx> 68 #include <ucbhelper/cancelcommandexecution.hxx> 69 #include <ucbhelper/simpleauthenticationrequest.hxx> 70 71 const int TRANSFER_BUFFER_SIZE = 65536; 72 73 /* 74 * NB. Name escaping is done only for URIs 75 * the 'Title' property is unescaped on set/get 76 */ 77 #include <libgnomevfs/gnome-vfs-utils.h> 78 #include <libgnomevfs/gnome-vfs-result.h> 79 #include <libgnomevfs/gnome-vfs-standard-callbacks.h> 80 extern "C" { // missing in the header: doh. 81 # include <libgnomevfs/gnome-vfs-module-callback.h> 82 } 83 84 #include "gvfs_content.hxx" 85 #include "gvfs_provider.hxx" 86 #include "gvfs_directory.hxx" 87 #include "gvfs_stream.hxx" 88 89 using namespace gvfs; 90 using namespace com::sun::star; 91 92 #define CLEAR_INFO(info) memset((info), 0, sizeof ((info)[0])) 93 94 95 static char * 96 OUStringToGnome( const rtl::OUString &str ) 97 { 98 rtl::OString aTempStr = rtl::OUStringToOString( str, RTL_TEXTENCODING_UTF8 ); 99 return g_strdup( aTempStr.getStr() ); 100 } 101 102 static rtl::OUString 103 GnomeToOUString( const char *utf8_str) 104 { 105 if (!utf8_str) 106 return rtl::OUString(); 107 else 108 return rtl::OUString( utf8_str, strlen( utf8_str ), RTL_TEXTENCODING_UTF8 ); 109 } 110 111 112 Content::Content( 113 const uno::Reference< lang::XMultiServiceFactory >& rxSMgr, 114 ContentProvider* pProvider, 115 const uno::Reference< ucb::XContentIdentifier >& Identifier) 116 throw ( ucb::ContentCreationException ) 117 : ContentImplHelper( rxSMgr, pProvider, Identifier ), 118 m_pProvider( pProvider ), 119 m_bTransient( sal_False ) 120 { 121 CLEAR_INFO (&m_info); 122 #ifdef DEBUG 123 g_warning ("New Content ('%s')", getURI()); 124 #endif 125 } 126 127 Content::Content( 128 const uno::Reference< lang::XMultiServiceFactory >& rxSMgr, 129 ContentProvider * pProvider, 130 const uno::Reference< ucb::XContentIdentifier >& Identifier, 131 sal_Bool IsFolder) 132 throw ( ucb::ContentCreationException ) 133 : ContentImplHelper( rxSMgr, pProvider, Identifier ), 134 m_pProvider( pProvider ), 135 m_bTransient( sal_True ) 136 { 137 CLEAR_INFO (&m_info); 138 139 #ifdef DEBUG 140 g_warning ("New Transient content ('%s') (%d)", getURI(), IsFolder); 141 #endif 142 // m_info.name = FIXME: set name ? 143 m_info.valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE; 144 m_info.type = IsFolder ? GNOME_VFS_FILE_TYPE_DIRECTORY : 145 GNOME_VFS_FILE_TYPE_REGULAR; 146 } 147 148 // virtual 149 Content::~Content() 150 { 151 gnome_vfs_file_info_clear( &m_info ); 152 } 153 154 // 155 // XInterface methods. 156 // 157 158 void SAL_CALL Content::acquire() 159 throw( ) 160 { 161 ContentImplHelper::acquire(); 162 } 163 void SAL_CALL Content::release() 164 throw( ) 165 { 166 ContentImplHelper::release(); 167 } 168 uno::Any SAL_CALL Content::queryInterface( const uno::Type & rType ) 169 throw ( uno::RuntimeException ) 170 { 171 // Note: isFolder may require network activities! So call it only 172 // if it is really necessary!!! 173 uno::Any aRet = cppu::queryInterface( rType, 174 static_cast< ucb::XContentCreator * >( this ) ); 175 if ( aRet.hasValue() ) 176 return isFolder( uno::Reference< ucb::XCommandEnvironment >() ) 177 ? aRet : uno::Any(); 178 else 179 return aRet.hasValue() ? aRet : ContentImplHelper::queryInterface( rType ); 180 } 181 182 // 183 // XTypeProvider methods. 184 // 185 186 XTYPEPROVIDER_COMMON_IMPL( Content ); 187 188 uno::Sequence< uno::Type > SAL_CALL Content::getTypes() 189 throw( uno::RuntimeException ) 190 { 191 static cppu::OTypeCollection *pFolderCollection = NULL; 192 static cppu::OTypeCollection *pFileCollection = NULL; 193 194 if (!pFolderCollection) { 195 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); 196 197 if (!pFolderCollection) { 198 static cppu::OTypeCollection aFolderCollection 199 (CPPU_TYPE_REF( lang::XTypeProvider ), 200 CPPU_TYPE_REF( lang::XServiceInfo ), 201 CPPU_TYPE_REF( lang::XComponent ), 202 CPPU_TYPE_REF( ucb::XContent ), 203 CPPU_TYPE_REF( ucb::XCommandProcessor ), 204 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ), 205 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ), 206 CPPU_TYPE_REF( beans::XPropertyContainer ), 207 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ), 208 CPPU_TYPE_REF( container::XChild ), 209 CPPU_TYPE_REF( ucb::XContentCreator ) ); // !! 210 static cppu::OTypeCollection aFileCollection 211 (CPPU_TYPE_REF( lang::XTypeProvider ), 212 CPPU_TYPE_REF( lang::XServiceInfo ), 213 CPPU_TYPE_REF( lang::XComponent ), 214 CPPU_TYPE_REF( ucb::XContent ), 215 CPPU_TYPE_REF( ucb::XCommandProcessor ), 216 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ), 217 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ), 218 CPPU_TYPE_REF( beans::XPropertyContainer ), 219 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ), 220 CPPU_TYPE_REF( container::XChild ) ); 221 222 pFolderCollection = &aFolderCollection; 223 pFileCollection = &aFileCollection; 224 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); 225 } 226 } 227 else { 228 OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); 229 } 230 231 if ( isFolder( uno::Reference< ucb::XCommandEnvironment >() ) ) 232 return pFolderCollection->getTypes(); 233 else 234 return pFileCollection->getTypes(); 235 } 236 237 // 238 // XServiceInfo methods. 239 // 240 241 rtl::OUString SAL_CALL Content::getImplementationName() 242 throw( uno::RuntimeException ) 243 { 244 return rtl::OUString::createFromAscii("com.sun.star.comp.GnomeVFSContent" ); 245 } 246 247 uno::Sequence< rtl::OUString > SAL_CALL Content::getSupportedServiceNames() 248 throw( uno::RuntimeException ) 249 { 250 uno::Sequence< rtl::OUString > aSNS( 1 ); 251 aSNS.getArray()[ 0 ] = rtl::OUString::createFromAscii( 252 "com.sun.star.ucb.GnomeVFSContent" ); 253 return aSNS; 254 } 255 256 // 257 // XContent methods. 258 // 259 260 rtl::OUString SAL_CALL Content::getContentType() 261 throw( uno::RuntimeException ) 262 { 263 if ( isFolder( uno::Reference< ucb::XCommandEnvironment >() ) ) 264 return rtl::OUString::createFromAscii( GVFS_FOLDER_TYPE ); 265 else 266 return rtl::OUString::createFromAscii( GVFS_FILE_TYPE ); 267 } 268 269 // 270 // XCommandProcessor methods. 271 // 272 273 uno::Any Content::getBadArgExcept() 274 { 275 return uno::makeAny( lang::IllegalArgumentException 276 ( rtl::OUString::createFromAscii( "Wrong argument type!" ), 277 static_cast< cppu::OWeakObject * >( this ), 278 -1 ) ); 279 } 280 281 #include <stdio.h> 282 283 uno::Any SAL_CALL Content::execute( 284 const ucb::Command& aCommand, 285 sal_Int32 /*CommandId*/, 286 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 287 throw( uno::Exception, 288 ucb::CommandAbortedException, 289 uno::RuntimeException ) 290 { 291 uno::Any aRet; 292 293 #ifdef DEBUG 294 { 295 uno::Reference< task::XInteractionHandler > xIH; 296 297 if ( xEnv.is() ) 298 xIH = xEnv->getInteractionHandler(); 299 g_warning( "Execute command: '%s' with %s interaction env", 300 OUStringToGnome( aCommand.Name ), 301 xIH.is() ? "" : "NO" ); 302 } 303 #endif 304 305 #define COMMAND_IS(cmd,name) ( (cmd).Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( name ) ) ) 306 307 if ( COMMAND_IS( aCommand, "getPropertyValues" ) ) { 308 uno::Sequence< beans::Property > Properties; 309 310 if ( !( aCommand.Argument >>= Properties ) ) 311 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv ); 312 313 aRet <<= getPropertyValues( Properties, xEnv ); 314 315 } else if ( COMMAND_IS( aCommand, "setPropertyValues" ) ) { 316 uno::Sequence< beans::PropertyValue > aProperties; 317 318 if ( !( aCommand.Argument >>= aProperties ) || 319 !aProperties.getLength() ) 320 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv ); 321 322 aRet <<= setPropertyValues( aProperties, xEnv ); 323 324 } else if ( COMMAND_IS( aCommand, "getPropertySetInfo" ) ) { 325 aRet <<= getPropertySetInfo( xEnv, sal_False ); 326 327 } else if ( COMMAND_IS( aCommand, "getCommandInfo" ) ) { 328 aRet <<= getCommandInfo( xEnv, sal_False ); 329 330 } else if ( COMMAND_IS( aCommand, "open" ) ) { 331 rtl::OUString str = m_xIdentifier->getContentIdentifier(); 332 rtl::OString stra( 333 str.getStr(), 334 str.getLength(), 335 RTL_TEXTENCODING_UTF8); 336 337 ucb::OpenCommandArgument2 aOpenCommand; 338 if ( !( aCommand.Argument >>= aOpenCommand ) ) 339 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv ); 340 341 sal_Bool bOpenFolder = 342 ( ( aOpenCommand.Mode == ucb::OpenMode::ALL ) || 343 ( aOpenCommand.Mode == ucb::OpenMode::FOLDERS ) || 344 ( aOpenCommand.Mode == ucb::OpenMode::DOCUMENTS ) ); 345 346 if ( bOpenFolder && isFolder( xEnv ) ) { 347 uno::Reference< ucb::XDynamicResultSet > xSet 348 = new DynamicResultSet(m_xSMgr, this, aOpenCommand, xEnv ); 349 aRet <<= xSet; 350 351 } else if ( aOpenCommand.Sink.is() ) { 352 353 if ( ( aOpenCommand.Mode 354 == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) || 355 ( aOpenCommand.Mode 356 == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE ) ) { 357 ucbhelper::cancelCommandExecution 358 ( uno::makeAny ( ucb::UnsupportedOpenModeException 359 ( rtl::OUString(), 360 static_cast< cppu::OWeakObject * >( this ), 361 sal_Int16( aOpenCommand.Mode ) ) ), 362 xEnv ); 363 } 364 if ( !feedSink( aOpenCommand.Sink, xEnv ) ) { 365 // Note: aOpenCommand.Sink may contain an XStream 366 // implementation. Support for this type of 367 // sink is optional... 368 #ifdef DEBUG 369 g_warning ("Failed to load data from '%s'", getURI()); 370 #endif 371 ucbhelper::cancelCommandExecution 372 ( uno::makeAny (ucb::UnsupportedDataSinkException 373 ( rtl::OUString(), 374 static_cast< cppu::OWeakObject * >( this ), 375 aOpenCommand.Sink ) ), 376 xEnv ); 377 } 378 } 379 #ifdef DEBUG 380 else 381 g_warning ("Open falling through ..."); 382 #endif 383 384 } else if ( COMMAND_IS( aCommand, "createNewContent" ) && isFolder( xEnv ) ) { 385 ucb::ContentInfo arg; 386 if ( !( aCommand.Argument >>= arg ) ) 387 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv ); 388 389 aRet <<= createNewContent( arg ); 390 391 } else if ( COMMAND_IS( aCommand, "insert" ) ) { 392 ucb::InsertCommandArgument arg; 393 if ( !( aCommand.Argument >>= arg ) ) 394 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv ); 395 396 insert( arg.Data, arg.ReplaceExisting, xEnv ); 397 398 } else if ( COMMAND_IS( aCommand, "delete" ) ) { 399 400 sal_Bool bDeletePhysical = sal_False; 401 aCommand.Argument >>= bDeletePhysical; 402 403 ::rtl::OString aURI = getOURI(); 404 GnomeVFSResult result = gnome_vfs_unlink( aURI.getStr()); 405 406 if (result != GNOME_VFS_OK) 407 cancelCommandExecution( result, xEnv, sal_True ); 408 409 destroy( bDeletePhysical ); 410 411 } else if ( COMMAND_IS( aCommand, "transfer" ) && isFolder( xEnv ) ) { 412 ucb::TransferInfo transferArgs; 413 414 if ( !( aCommand.Argument >>= transferArgs ) ) 415 ucbhelper::cancelCommandExecution( getBadArgExcept(), xEnv ); 416 417 transfer( transferArgs, xEnv ); 418 419 } else { // Unsuported 420 #ifdef DEBUG 421 g_warning( "Unsupported command: '%s'", 422 OUStringToGnome( aCommand.Name ) ); 423 #endif 424 ucbhelper::cancelCommandExecution 425 ( uno::makeAny( ucb::UnsupportedCommandException 426 ( rtl::OUString(), 427 static_cast< cppu::OWeakObject * >( this ) ) ), 428 xEnv ); 429 } 430 #undef COMMAND_IS 431 432 return aRet; 433 } 434 435 void SAL_CALL Content::abort( sal_Int32 /*CommandId*/ ) 436 throw( uno::RuntimeException ) 437 { 438 // FIXME: we should use the GnomeVFSCancellation APIs here ... 439 } 440 441 // 442 // XContentCreator methods. 443 // 444 445 uno::Sequence< ucb::ContentInfo > Content::queryCreatableContentsInfo( 446 const uno::Reference< ucb::XCommandEnvironment >& xEnv) 447 throw( uno::RuntimeException ) 448 { 449 if ( isFolder( xEnv ) ) 450 { 451 uno::Sequence< ucb::ContentInfo > seq(2); 452 453 // Minimum set of props we really need 454 uno::Sequence< beans::Property > props( 1 ); 455 props[0] = beans::Property( 456 rtl::OUString::createFromAscii( "Title" ), 457 -1, 458 getCppuType( static_cast< rtl::OUString* >( 0 ) ), 459 beans::PropertyAttribute::MAYBEVOID | beans::PropertyAttribute::BOUND ); 460 461 // file 462 seq[0].Type = rtl::OUString::createFromAscii( GVFS_FILE_TYPE ); 463 seq[0].Attributes = ( ucb::ContentInfoAttribute::INSERT_WITH_INPUTSTREAM | 464 ucb::ContentInfoAttribute::KIND_DOCUMENT ); 465 seq[0].Properties = props; 466 467 // folder 468 seq[1].Type = rtl::OUString::createFromAscii( GVFS_FOLDER_TYPE ); 469 seq[1].Attributes = ucb::ContentInfoAttribute::KIND_FOLDER; 470 seq[1].Properties = props; 471 472 return seq; 473 } 474 else 475 { 476 return uno::Sequence< ucb::ContentInfo >(); 477 } 478 } 479 480 uno::Sequence< ucb::ContentInfo > SAL_CALL Content::queryCreatableContentsInfo() 481 throw( uno::RuntimeException ) 482 { 483 return queryCreatableContentsInfo( uno::Reference< ucb::XCommandEnvironment >() ); 484 } 485 486 uno::Reference< ucb::XContent > SAL_CALL 487 Content::createNewContent( const ucb::ContentInfo& Info ) 488 throw( uno::RuntimeException ) 489 { 490 bool create_document; 491 const char *name; 492 493 if ( Info.Type.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( GVFS_FILE_TYPE ) ) ) 494 create_document = true; 495 else if ( Info.Type.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( GVFS_FOLDER_TYPE ) ) ) 496 create_document = false; 497 else { 498 #ifdef DEBUG 499 g_warning( "Failed to create new content '%s'", 500 OUStringToGnome( Info.Type ) ); 501 #endif 502 return uno::Reference< ucb::XContent >(); 503 } 504 505 #ifdef DEBUG 506 g_warning( "createNewContent (%d)", (int) create_document ); 507 #endif 508 509 rtl::OUString aURL = getOUURI(); 510 511 if ( ( aURL.lastIndexOf( '/' ) + 1 ) != aURL.getLength() ) 512 aURL += rtl::OUString::createFromAscii( "/" ); 513 514 name = create_document ? "[New_Content]" : "[New_Collection]"; 515 // This looks problematic to me cf. webdav 516 aURL += rtl::OUString::createFromAscii( name ); 517 518 uno::Reference< ucb::XContentIdentifier > xId 519 ( new ::ucbhelper::ContentIdentifier( m_xSMgr, aURL ) ); 520 521 try { 522 return new ::gvfs::Content( m_xSMgr, m_pProvider, xId, !create_document ); 523 } catch ( ucb::ContentCreationException & ) { 524 return uno::Reference< ucb::XContent >(); 525 } 526 } 527 528 rtl::OUString Content::getParentURL() 529 { 530 rtl::OUString aParentURL; 531 // <scheme>:// -> "" 532 // <scheme>://foo -> "" 533 // <scheme>://foo/ -> "" 534 // <scheme>://foo/bar -> <scheme>://foo/ 535 // <scheme>://foo/bar/ -> <scheme>://foo/ 536 // <scheme>://foo/bar/abc -> <scheme>://foo/bar/ 537 538 rtl::OUString aURL = getOUURI(); 539 540 sal_Int32 nPos = aURL.lastIndexOf( '/' ); 541 if ( nPos == ( aURL.getLength() - 1 ) ) { 542 // Trailing slash found. Skip. 543 nPos = aURL.lastIndexOf( '/', nPos ); 544 } 545 546 sal_Int32 nPos1 = aURL.lastIndexOf( '/', nPos ); 547 if ( nPos1 != -1 ) 548 nPos1 = aURL.lastIndexOf( '/', nPos1 ); 549 550 if ( nPos1 != -1 ) 551 aParentURL = rtl::OUString( aURL.copy( 0, nPos + 1 ) ); 552 553 #ifdef DEBUG 554 g_warning ("getParentURL '%s' -> '%s'", 555 getURI(), rtl::OUStringToOString( aParentURL, RTL_TEXTENCODING_UTF8).getStr() ); 556 #endif 557 558 return aParentURL; 559 } 560 561 static util::DateTime 562 getDateFromUnix (time_t t) 563 { 564 TimeValue tv; 565 tv.Nanosec = 0; 566 tv.Seconds = t; 567 oslDateTime dt; 568 569 if ( osl_getDateTimeFromTimeValue( &tv, &dt ) ) 570 return util::DateTime( 0, dt.Seconds, dt.Minutes, dt.Hours, 571 dt.Day, dt.Month, dt.Year); 572 else 573 return util::DateTime(); 574 } 575 576 uno::Reference< sdbc::XRow > Content::getPropertyValues( 577 const uno::Sequence< beans::Property >& rProperties, 578 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 579 { 580 int nProps; 581 GnomeVFSResult result; 582 uno::Sequence< beans::Property > allProperties; 583 584 if( ( result = getInfo( xEnv ) ) != GNOME_VFS_OK ) 585 cancelCommandExecution( result, xEnv, sal_False ); 586 587 const beans::Property* pProps; 588 589 if( rProperties.getLength() ) { 590 nProps = rProperties.getLength(); 591 pProps = rProperties.getConstArray(); 592 } else { 593 allProperties = getPropertySetInfo( xEnv )->getProperties(); 594 nProps = allProperties.getLength(); 595 pProps = allProperties.getConstArray(); 596 } 597 598 rtl::Reference< ::ucbhelper::PropertyValueSet > xRow 599 = new ::ucbhelper::PropertyValueSet( m_xSMgr ); 600 601 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 602 for( sal_Int32 n = 0; n < nProps; ++n ) { 603 const beans::Property& rProp = pProps[ n ]; 604 605 if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) ) { 606 if (m_info.name && m_info.name[0] == '/') 607 g_warning ("Odd NFS title on item '%s' == '%s'", 608 getURI(), m_info.name); 609 xRow->appendString( rProp, GnomeToOUString( m_info.name ) ); 610 } 611 612 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) ) 613 xRow->appendString( rProp, getContentType () ); 614 615 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) ) { 616 if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE) 617 xRow->appendBoolean( rProp, ( m_info.type == GNOME_VFS_FILE_TYPE_REGULAR || 618 m_info.type == GNOME_VFS_FILE_TYPE_UNKNOWN ) ); 619 else 620 xRow->appendVoid( rProp ); 621 } 622 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) ) { 623 if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE) 624 xRow->appendBoolean( rProp, ( m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY ) ); 625 else 626 xRow->appendVoid( rProp ); 627 } 628 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsReadOnly" ) ) ) { 629 630 GnomeVFSFileInfo* fileInfo = gnome_vfs_file_info_new (); 631 632 ::rtl::OString aURI = getOURI(); 633 gnome_vfs_get_file_info( aURI.getStr(), fileInfo, 634 GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS ); 635 636 if (fileInfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ACCESS) { 637 bool read_only = true; 638 639 if (fileInfo->permissions & GNOME_VFS_PERM_ACCESS_WRITABLE) 640 read_only = false; 641 642 xRow->appendBoolean( rProp, read_only ); 643 } else 644 xRow->appendVoid( rProp ); 645 gnome_vfs_file_info_unref (fileInfo); 646 } 647 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Size" ) ) ) { 648 if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) 649 xRow->appendLong( rProp, m_info.size ); 650 else 651 xRow->appendVoid( rProp ); 652 } 653 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsHidden" ) ) ) 654 xRow->appendBoolean( rProp, ( m_info.name && m_info.name[0] == '.' ) ); 655 656 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsVolume" ) ) || 657 rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsCompactDisk" ) ) ) 658 xRow->appendBoolean( rProp, sal_False ); 659 660 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateCreated" ) ) ) { 661 if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_CTIME) 662 xRow->appendTimestamp( rProp, getDateFromUnix( m_info.ctime ) ); 663 else 664 xRow->appendVoid( rProp ); 665 } 666 667 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateModified" ) ) ) { 668 if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MTIME) 669 xRow->appendTimestamp( rProp, getDateFromUnix( m_info.mtime ) ); 670 else 671 xRow->appendVoid( rProp ); 672 } 673 674 else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) ) { 675 // We do this by sniffing in gnome-vfs; rather expensively. 676 #ifdef DEBUG 677 g_warning ("FIXME: Requested mime-type - an expensive op. indeed!"); 678 #endif 679 xRow->appendVoid( rProp ); 680 } else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CreatableContentsInfo" ) ) ) 681 xRow->appendObject( rProp, uno::makeAny( queryCreatableContentsInfo( xEnv ) ) ); 682 683 else { 684 xRow->appendVoid( rProp ); 685 } 686 } 687 #ifdef DEBUG 688 g_warning ("getPropertyValues on '%s' %d properties returned (of %d)", 689 getURI(), (int)xRow->getLength(), (int)nProps); 690 #endif 691 692 return uno::Reference< sdbc::XRow >( xRow.get() ); 693 } 694 695 static lang::IllegalAccessException 696 getReadOnlyException( Content *ctnt ) 697 { 698 return lang::IllegalAccessException 699 ( rtl::OUString::createFromAscii( "Property is read-only!" ), 700 static_cast< cppu::OWeakObject * >( ctnt ) ); 701 } 702 703 rtl::OUString 704 Content::makeNewURL( const char */*newName*/ ) 705 { 706 rtl::OUString aNewURL = getParentURL(); 707 if ( aNewURL.lastIndexOf( '/' ) != ( aNewURL.getLength() - 1 ) ) 708 aNewURL += rtl::OUString::createFromAscii( "/" ); 709 710 char *name = gnome_vfs_escape_string( m_info.name ); 711 aNewURL += GnomeToOUString( name ); 712 g_free( name ); 713 714 return aNewURL; 715 } 716 717 // This is slightly complicated by needing to support either 'move' or 'setname' 718 GnomeVFSResult 719 Content::doSetFileInfo( const GnomeVFSFileInfo *newInfo, 720 GnomeVFSSetFileInfoMask setMask, 721 const uno::Reference< ucb::XCommandEnvironment >& /*xEnv*/ ) 722 { 723 GnomeVFSResult result = GNOME_VFS_OK; 724 725 g_assert (!m_bTransient); 726 727 ::rtl::OString aURI = getOURI(); 728 729 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 730 731 // The simple approach: 732 if( setMask != GNOME_VFS_SET_FILE_INFO_NONE ) 733 result = gnome_vfs_set_file_info // missed a const in the API there 734 ( aURI.getStr(), (GnomeVFSFileInfo *)newInfo, setMask ); 735 736 if ( result == GNOME_VFS_ERROR_NOT_SUPPORTED && 737 ( setMask & GNOME_VFS_SET_FILE_INFO_NAME ) ) { 738 // Try a move instead 739 #ifdef DEBUG 740 g_warning( "SetFileInfo not supported on '%s'", getURI() ); 741 #endif 742 743 char *newURI = OUStringToGnome( makeNewURL( newInfo->name ) ); 744 745 result = gnome_vfs_move( aURI.getStr(), newURI, FALSE); 746 747 g_free (newURI); 748 } 749 750 return result; 751 } 752 753 754 uno::Sequence< uno::Any > Content::setPropertyValues( 755 const uno::Sequence< beans::PropertyValue >& rValues, 756 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 757 { 758 rtl::OUString aNewTitle; 759 GnomeVFSFileInfo newInfo; 760 int setMask = GNOME_VFS_SET_FILE_INFO_NONE; 761 762 getInfo( xEnv ); 763 764 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex ); 765 766 gnome_vfs_file_info_copy( &newInfo, &m_info ); 767 768 Authentication aAuth( xEnv ); 769 770 int nChanged = 0, nTitlePos = 0; 771 uno::Sequence< uno::Any > aRet( rValues.getLength() ); 772 uno::Sequence< beans::PropertyChangeEvent > aChanges( rValues.getLength() ); 773 774 beans::PropertyChangeEvent aEvent; 775 aEvent.Source = static_cast< cppu::OWeakObject * >( this ); 776 aEvent.Further = sal_False; 777 aEvent.PropertyHandle = -1; 778 // aEvent.PropertyName = fill in later ... 779 // aEvent.OldValue = 780 // aEvent.NewValue = 781 782 int nCount = rValues.getLength(); 783 const beans::PropertyValue* pValues = rValues.getConstArray(); 784 785 for ( sal_Int32 n = 0; n < nCount; ++n ) { 786 const beans::PropertyValue& rValue = pValues[ n ]; 787 788 #ifdef DEBUG 789 g_warning( "Set prop '%s'", OUStringToGnome( rValue.Name ) ); 790 #endif 791 if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) || 792 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) || 793 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) || 794 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) || 795 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Size" ) ) || 796 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CreatableContentsInfo" ) ) ) 797 aRet[ n ] <<= getReadOnlyException( this ); 798 799 else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) ) { 800 if ( rValue.Value >>= aNewTitle ) { 801 if ( aNewTitle.getLength() <= 0 ) 802 aRet[ n ] <<= lang::IllegalArgumentException 803 ( rtl::OUString::createFromAscii( "Empty title not allowed!" ), 804 static_cast< cppu::OWeakObject * >( this ), -1 ); 805 else { 806 char *newName = OUStringToGnome( aNewTitle ); 807 808 if( !newName || !m_info.name || strcmp( newName, m_info.name ) ) { 809 #ifdef DEBUG 810 g_warning ("Set new name to '%s'", newName); 811 #endif 812 813 aEvent.PropertyName = rtl::OUString::createFromAscii( "Title" ); 814 aEvent.OldValue = uno::makeAny( GnomeToOUString( newInfo.name ) ); 815 aEvent.NewValue = uno::makeAny( aNewTitle ); 816 aChanges.getArray()[ nChanged ] = aEvent; 817 nTitlePos = nChanged++; 818 819 newInfo.name = newName; 820 setMask |= GNOME_VFS_SET_FILE_INFO_NAME; 821 } else // same name 822 g_free (newName); 823 } 824 } else 825 aRet[ n ] <<= beans::IllegalTypeException 826 ( rtl::OUString::createFromAscii( "Property value has wrong type!" ), 827 static_cast< cppu::OWeakObject * >( this ) ); 828 829 } else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateCreated" ) ) || 830 rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateModified" ) ) ) { 831 // FIXME: should be able to set the timestamps 832 aRet[ n ] <<= getReadOnlyException( this ); 833 } else { 834 #ifdef DEBUG 835 g_warning( "Unhandled property '%s'", OUStringToGnome( rValue.Name ) ); 836 #endif 837 aRet[ n ] <<= getReadOnlyException( this ); 838 } 839 } 840 841 GnomeVFSResult result = GNOME_VFS_OK; 842 843 if ( !m_bTransient && 844 ( result = doSetFileInfo( &newInfo, 845 (GnomeVFSSetFileInfoMask) setMask, 846 xEnv ) ) != GNOME_VFS_OK ) { 847 for (int i = 0; i < nChanged; i++) 848 aRet[ i ] <<= mapVFSException( result, sal_True ); 849 850 } 851 852 if ( result == GNOME_VFS_OK) { 853 gnome_vfs_file_info_copy( &m_info, &newInfo ); 854 855 if ( setMask & GNOME_VFS_SET_FILE_INFO_NAME ) { 856 uno::Reference< ucb::XContentIdentifier > xNewId 857 = new ::ucbhelper::ContentIdentifier( 858 m_xSMgr, makeNewURL( newInfo.name ) ); 859 860 aGuard.clear(); 861 if (!exchangeIdentity( xNewId ) ) 862 aRet[ nTitlePos ] <<= uno::Exception 863 ( rtl::OUString::createFromAscii( "Exchange failed!" ), 864 static_cast< cppu::OWeakObject * >( this ) ); 865 } 866 } 867 868 gnome_vfs_file_info_clear( &newInfo ); 869 870 if ( nChanged > 0 ) { 871 aGuard.clear(); 872 aChanges.realloc( nChanged ); 873 notifyPropertiesChange( aChanges ); 874 } 875 876 return aRet; 877 } 878 879 void Content::queryChildren( ContentRefList& rChildren ) 880 { 881 // Obtain a list with a snapshot of all currently instanciated contents 882 // from provider and extract the contents which are direct children 883 // of this content. 884 885 ::ucbhelper::ContentRefList aAllContents; 886 m_xProvider->queryExistingContents( aAllContents ); 887 888 rtl::OUString aURL = getOUURI(); 889 sal_Int32 nURLPos = aURL.lastIndexOf( '/' ); 890 891 if ( nURLPos != ( aURL.getLength() - 1 ) ) 892 aURL += rtl::OUString::createFromAscii( "/" ); 893 894 sal_Int32 nLen = aURL.getLength(); 895 896 ::ucbhelper::ContentRefList::const_iterator it = aAllContents.begin(); 897 ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end(); 898 899 while ( it != end ) { 900 ::ucbhelper::ContentImplHelperRef xChild = (*it); 901 rtl::OUString aChildURL 902 = xChild->getIdentifier()->getContentIdentifier(); 903 904 // Is aURL a prefix of aChildURL? 905 if ( ( aChildURL.getLength() > nLen ) && 906 ( aChildURL.compareTo( aURL, nLen ) == 0 ) ) { 907 sal_Int32 nPos = nLen; 908 nPos = aChildURL.indexOf( '/', nPos ); 909 910 if ( ( nPos == -1 ) || 911 ( nPos == ( aChildURL.getLength() - 1 ) ) ) { 912 // No further slashes / only a final slash. It's a child! 913 rChildren.push_back( ::gvfs::Content::ContentRef 914 (static_cast< ::gvfs::Content * >(xChild.get() ) ) ); 915 } 916 } 917 ++it; 918 } 919 } 920 921 void Content::insert( 922 const uno::Reference< io::XInputStream > &xInputStream, 923 sal_Bool bReplaceExisting, 924 const uno::Reference< ucb::XCommandEnvironment > &xEnv ) 925 throw( uno::Exception ) 926 { 927 osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex ); 928 929 #ifdef DEBUG 930 g_warning( "Insert '%s' (%d) (0x%x:%d)", getURI(), bReplaceExisting, 931 m_info.valid_fields, m_info.type ); 932 #endif 933 934 GnomeVFSResult result = getInfo( xEnv ); 935 // a racy design indeed. 936 if( !bReplaceExisting && !m_bTransient && 937 result != GNOME_VFS_ERROR_NOT_FOUND) { 938 #ifdef DEBUG 939 g_warning ("Nasty error inserting to '%s' ('%s')", 940 getURI(), gnome_vfs_result_to_string( result )); 941 #endif 942 cancelCommandExecution( GNOME_VFS_ERROR_FILE_EXISTS, xEnv, sal_True ); 943 } 944 945 if ( m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE && 946 m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY ) { 947 ::rtl::OString aURI = getOURI(); 948 int perm; 949 950 perm = ( GNOME_VFS_PERM_USER_ALL | 951 GNOME_VFS_PERM_GROUP_READ | 952 GNOME_VFS_PERM_OTHER_READ ); 953 954 #ifdef DEBUG 955 g_warning ("Make directory"); 956 #endif 957 result = gnome_vfs_make_directory( aURI.getStr(), perm ); 958 959 if( result != GNOME_VFS_OK ) 960 cancelCommandExecution( result, xEnv, sal_True ); 961 962 return; 963 } 964 965 if ( !xInputStream.is() ) { 966 // FIXME: slightly unclear whether to accept this and create an empty file 967 ucbhelper::cancelCommandExecution 968 ( uno::makeAny 969 ( ucb::MissingInputStreamException 970 ( rtl::OUString(), 971 static_cast< cppu::OWeakObject * >( this ) ) ), 972 xEnv ); 973 } 974 975 GnomeVFSHandle *handle = NULL; 976 ::rtl::OString aURI = getOURI(); 977 978 result = GNOME_VFS_OK; 979 if ( bReplaceExisting ) { 980 Authentication aAuth( xEnv ); 981 result = gnome_vfs_open( &handle, aURI.getStr(), 982 GNOME_VFS_OPEN_WRITE ); 983 } 984 985 if ( result != GNOME_VFS_OK ) { 986 int perm; 987 Authentication aAuth( xEnv ); 988 989 perm = ( ( GNOME_VFS_PERM_USER_WRITE | GNOME_VFS_PERM_USER_READ ) | 990 ( GNOME_VFS_PERM_GROUP_WRITE | GNOME_VFS_PERM_GROUP_READ ) ); 991 992 result = gnome_vfs_create 993 ( &handle, aURI.getStr(), GNOME_VFS_OPEN_WRITE, TRUE, perm ); 994 } 995 996 if( result != GNOME_VFS_OK ) 997 cancelCommandExecution( result, xEnv, sal_True ); 998 999 if ( !xInputStream.is() ) { 1000 result = gnome_vfs_close( handle ); 1001 if (result != GNOME_VFS_OK) 1002 cancelCommandExecution( result, xEnv, sal_True ); 1003 1004 } else { // copy it over 1005 uno::Reference < io::XOutputStream > xOutput = 1006 new gvfs::Stream( handle, &m_info ); 1007 1008 copyData( xInputStream, xOutput ); 1009 } 1010 1011 if (m_bTransient) { 1012 m_bTransient = sal_False; 1013 aGuard.clear(); 1014 inserted(); 1015 } 1016 } 1017 1018 void Content::transfer(const ucb::TransferInfo & /*rArgs*/, 1019 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1020 throw( uno::Exception ) 1021 { 1022 // FIXME: see gnome-vfs-xfer.h - but we need to be able to easily 1023 // detect which are gnome-vfs owned URI types ... 1024 ucbhelper::cancelCommandExecution 1025 ( uno::makeAny 1026 ( ucb::InteractiveBadTransferURLException 1027 ( rtl::OUString::createFromAscii( "Unsupported URL scheme!" ), 1028 static_cast< cppu::OWeakObject * >( this ) ) ), 1029 xEnv ); 1030 } 1031 1032 void Content::destroy( sal_Bool bDeletePhysical ) 1033 throw( uno::Exception ) 1034 { 1035 // @@@ take care about bDeletePhysical -> trashcan support 1036 rtl::OUString aURL = getOUURI(); 1037 1038 uno::Reference< ucb::XContent > xThis = this; 1039 1040 deleted(); 1041 1042 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1043 1044 // Process instanciated children... 1045 ::gvfs::Content::ContentRefList aChildren; 1046 queryChildren( aChildren ); 1047 1048 ContentRefList::const_iterator it = aChildren.begin(); 1049 ContentRefList::const_iterator end = aChildren.end(); 1050 1051 while ( it != end ) { 1052 (*it)->destroy( bDeletePhysical ); 1053 ++it; 1054 } 1055 } 1056 1057 // Used by the 'setPropertyValues' method for 1058 // propagating the renaming of a Content. 1059 sal_Bool Content::exchangeIdentity( 1060 const uno::Reference< ucb::XContentIdentifier >& xNewId ) 1061 { 1062 if ( !xNewId.is() ) 1063 return sal_False; 1064 1065 uno::Reference< ucb::XContent > xThis = this; 1066 1067 #ifdef DEBUG 1068 g_warning( "exchangeIdentity from '%s' to '%s'", 1069 getURI(), OUStringToGnome( xNewId->getContentIdentifier() ) ); 1070 #endif 1071 1072 if ( m_bTransient ) { 1073 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1074 /* FIXME: can we not screw up an identically named 1075 * Content pointing to ourself here ? */ 1076 m_xIdentifier = xNewId; 1077 return sal_False; 1078 } 1079 1080 rtl::OUString aOldURL = getOUURI(); 1081 1082 // Exchange own identitity. 1083 if ( exchange( xNewId ) ) { 1084 1085 // Process instanciated children... 1086 ContentRefList aChildren; 1087 queryChildren( aChildren ); 1088 1089 ContentRefList::const_iterator it = aChildren.begin(); 1090 ContentRefList::const_iterator end = aChildren.end(); 1091 1092 while ( it != end ) { 1093 ContentRef xChild = (*it); 1094 1095 // Create new content identifier for the child... 1096 uno::Reference< ucb::XContentIdentifier > 1097 xOldChildId = xChild->getIdentifier(); 1098 rtl::OUString aOldChildURL 1099 = xOldChildId->getContentIdentifier(); 1100 rtl::OUString aNewChildURL 1101 = aOldChildURL.replaceAt( 1102 0, 1103 aOldURL.getLength(), 1104 xNewId->getContentIdentifier() ); 1105 uno::Reference< ucb::XContentIdentifier > 1106 xNewChildId 1107 = new ::ucbhelper::ContentIdentifier( m_xSMgr, aNewChildURL ); 1108 1109 if ( !xChild->exchangeIdentity( xNewChildId ) ) 1110 return sal_False; 1111 1112 ++it; 1113 } 1114 return sal_True; 1115 } 1116 1117 return sal_False; 1118 } 1119 1120 GnomeVFSResult 1121 Content::getInfo( const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1122 { 1123 GnomeVFSResult result; 1124 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1125 1126 if (m_bTransient) 1127 result = GNOME_VFS_OK; 1128 1129 else if ( !m_info.valid_fields ) { 1130 ::rtl::OString aURI = getOURI(); 1131 Authentication aAuth( xEnv ); 1132 result = gnome_vfs_get_file_info 1133 ( aURI.getStr(), &m_info, GNOME_VFS_FILE_INFO_DEFAULT ); 1134 if (result != GNOME_VFS_OK) 1135 gnome_vfs_file_info_clear( &m_info ); 1136 } else 1137 result = GNOME_VFS_OK; 1138 #ifdef DEBUG 1139 g_warning( "getInfo on '%s' returns '%s' (%d) (0x%x)", 1140 getURI(), gnome_vfs_result_to_string( result ), 1141 result, m_info.valid_fields ); 1142 #endif 1143 return result; 1144 } 1145 1146 sal_Bool 1147 Content::isFolder(const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1148 { 1149 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1150 getInfo( xEnv ); 1151 return (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE && 1152 m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY); 1153 } 1154 1155 uno::Any Content::mapVFSException( const GnomeVFSResult result, sal_Bool bWrite ) 1156 { 1157 uno::Any aException; 1158 const char *gvfs_message; 1159 rtl::OUString message; 1160 uno::Sequence< uno::Any > aArgs( 1 ); 1161 1162 #ifdef DEBUG 1163 g_warning ("Map VFS exception '%s' (%d)", 1164 gnome_vfs_result_to_string( result ), result ); 1165 #endif 1166 1167 if ((gvfs_message = gnome_vfs_result_to_string (result))) 1168 message = GnomeToOUString( gvfs_message ); 1169 1170 switch (result) { 1171 case GNOME_VFS_OK: 1172 g_warning("VFS_OK mapped to exception."); 1173 break; 1174 case GNOME_VFS_ERROR_EOF: 1175 g_warning ("VFS_EOF not handled somewhere."); 1176 break; 1177 case GNOME_VFS_ERROR_NOT_FOUND: 1178 aArgs[ 0 ] <<= m_xIdentifier->getContentIdentifier(); 1179 aException <<= 1180 ucb::InteractiveAugmentedIOException 1181 ( rtl::OUString::createFromAscii( "Not found!" ), 1182 static_cast< cppu::OWeakObject * >( this ), 1183 task::InteractionClassification_ERROR, 1184 ucb::IOErrorCode_NOT_EXISTING, 1185 aArgs ); 1186 break; 1187 case GNOME_VFS_ERROR_BAD_PARAMETERS: 1188 aException <<= 1189 lang::IllegalArgumentException 1190 ( rtl::OUString(), 1191 static_cast< cppu::OWeakObject * >( this ), 1192 -1 ); 1193 break; 1194 case GNOME_VFS_ERROR_GENERIC: 1195 case GNOME_VFS_ERROR_INTERNAL: 1196 case GNOME_VFS_ERROR_NOT_SUPPORTED: 1197 #ifdef DEBUG 1198 g_warning ("Internal - un-mapped error"); 1199 #endif 1200 aException <<= io::IOException(); 1201 break; 1202 case GNOME_VFS_ERROR_IO: 1203 if ( bWrite ) 1204 aException <<= 1205 ucb::InteractiveNetworkWriteException 1206 ( rtl::OUString(), 1207 static_cast< cppu::OWeakObject * >( this ), 1208 task::InteractionClassification_ERROR, 1209 message ); 1210 else 1211 aException <<= 1212 ucb::InteractiveNetworkReadException 1213 ( rtl::OUString(), 1214 static_cast< cppu::OWeakObject * >( this ), 1215 task::InteractionClassification_ERROR, 1216 message ); 1217 break; 1218 case GNOME_VFS_ERROR_HOST_NOT_FOUND: 1219 case GNOME_VFS_ERROR_INVALID_HOST_NAME: 1220 aException <<= 1221 ucb::InteractiveNetworkResolveNameException 1222 ( rtl::OUString(), 1223 static_cast< cppu::OWeakObject * >( this ), 1224 task::InteractionClassification_ERROR, 1225 message ); 1226 break; 1227 case GNOME_VFS_ERROR_SERVICE_NOT_AVAILABLE: 1228 case GNOME_VFS_ERROR_SERVICE_OBSOLETE: 1229 case GNOME_VFS_ERROR_PROTOCOL_ERROR: 1230 case GNOME_VFS_ERROR_NO_MASTER_BROWSER: 1231 aException <<= 1232 ucb::InteractiveNetworkConnectException 1233 ( rtl::OUString(), 1234 static_cast< cppu::OWeakObject * >( this ), 1235 task::InteractionClassification_ERROR, 1236 message ); 1237 break; 1238 1239 case GNOME_VFS_ERROR_FILE_EXISTS: 1240 aException <<= ucb::NameClashException 1241 ( rtl::OUString(), 1242 static_cast< cppu::OWeakObject * >( this ), 1243 task::InteractionClassification_ERROR, 1244 message ); 1245 break; 1246 1247 case GNOME_VFS_ERROR_INVALID_OPEN_MODE: 1248 aException <<= ucb::UnsupportedOpenModeException(); 1249 break; 1250 1251 case GNOME_VFS_ERROR_CORRUPTED_DATA: 1252 case GNOME_VFS_ERROR_WRONG_FORMAT: 1253 case GNOME_VFS_ERROR_BAD_FILE: 1254 case GNOME_VFS_ERROR_TOO_BIG: 1255 case GNOME_VFS_ERROR_NO_SPACE: 1256 case GNOME_VFS_ERROR_READ_ONLY: 1257 case GNOME_VFS_ERROR_INVALID_URI: 1258 case GNOME_VFS_ERROR_NOT_OPEN: 1259 case GNOME_VFS_ERROR_ACCESS_DENIED: 1260 case GNOME_VFS_ERROR_TOO_MANY_OPEN_FILES: 1261 case GNOME_VFS_ERROR_NOT_A_DIRECTORY: 1262 case GNOME_VFS_ERROR_IN_PROGRESS: 1263 case GNOME_VFS_ERROR_INTERRUPTED: 1264 case GNOME_VFS_ERROR_LOOP: 1265 case GNOME_VFS_ERROR_NOT_PERMITTED: 1266 case GNOME_VFS_ERROR_IS_DIRECTORY: 1267 case GNOME_VFS_ERROR_NO_MEMORY: 1268 case GNOME_VFS_ERROR_HOST_HAS_NO_ADDRESS: 1269 case GNOME_VFS_ERROR_LOGIN_FAILED: 1270 case GNOME_VFS_ERROR_CANCELLED: 1271 case GNOME_VFS_ERROR_DIRECTORY_BUSY: 1272 case GNOME_VFS_ERROR_DIRECTORY_NOT_EMPTY: 1273 case GNOME_VFS_ERROR_TOO_MANY_LINKS: 1274 case GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM: 1275 case GNOME_VFS_ERROR_NOT_SAME_FILE_SYSTEM: 1276 case GNOME_VFS_ERROR_NAME_TOO_LONG: 1277 #ifdef DEBUG 1278 g_warning( "FIXME: Un-mapped VFS exception '%s' (%d)", 1279 gnome_vfs_result_to_string( result ), result ); 1280 #endif 1281 default: 1282 aException <<= ucb::InteractiveNetworkGeneralException 1283 ( rtl::OUString(), 1284 static_cast< cppu::OWeakObject * >( this ), 1285 task::InteractionClassification_ERROR ); 1286 break; 1287 } 1288 1289 return aException; 1290 } 1291 1292 void Content::cancelCommandExecution( 1293 GnomeVFSResult result, 1294 const uno::Reference< ucb::XCommandEnvironment > & xEnv, 1295 sal_Bool bWrite /* = sal_False */ ) 1296 throw ( uno::Exception ) 1297 { 1298 ucbhelper::cancelCommandExecution( mapVFSException( result, bWrite ), xEnv ); 1299 // Unreachable 1300 } 1301 1302 uno::Sequence< beans::Property > Content::getProperties( 1303 const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ ) 1304 { 1305 static const beans::Property aGenericProperties[] = { 1306 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ContentType" ) ), 1307 -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ), 1308 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1309 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsDocument" ) ), 1310 -1, getCppuBooleanType(), 1311 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1312 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsFolder" ) ), 1313 -1, getCppuBooleanType(), 1314 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1315 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ), 1316 -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ), 1317 beans::PropertyAttribute::BOUND ), 1318 // Optional ... 1319 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DateCreated" ) ), 1320 -1, getCppuType( static_cast< const util::DateTime * >( 0 ) ), 1321 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1322 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DateModified" ) ), 1323 -1, getCppuType( static_cast< const util::DateTime * >( 0 ) ), 1324 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1325 // FIXME: Too expensive for now (?) 1326 // beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ), 1327 // -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ), 1328 // beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1329 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Size" ) ), 1330 -1, getCppuType( static_cast< const sal_Int64 * >( 0 ) ), 1331 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1332 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsReadOnly" ) ), 1333 -1, getCppuBooleanType(), 1334 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1335 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsVolume" ) ), 1336 -1, getCppuBooleanType(), 1337 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1338 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsCompactDisk" ) ), 1339 -1, getCppuBooleanType(), 1340 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1341 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsHidden" ) ), 1342 -1, getCppuBooleanType(), 1343 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ), 1344 beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CreatableContentsInfo" ) ), 1345 -1, getCppuType( static_cast< const uno::Sequence< ucb::ContentInfo > * >( 0 ) ), 1346 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ) 1347 }; 1348 1349 const int nProps = sizeof (aGenericProperties) / sizeof (aGenericProperties[0]); 1350 1351 return uno::Sequence< beans::Property > ( aGenericProperties, nProps ); 1352 1353 } 1354 1355 uno::Sequence< ucb::CommandInfo > Content::getCommands( 1356 const uno::Reference< ucb::XCommandEnvironment > & xEnv ) 1357 { 1358 static ucb::CommandInfo aCommandInfoTable[] = { 1359 // Required commands 1360 ucb::CommandInfo 1361 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getCommandInfo" ) ), 1362 -1, getCppuVoidType() ), 1363 ucb::CommandInfo 1364 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertySetInfo" ) ), 1365 -1, getCppuVoidType() ), 1366 ucb::CommandInfo 1367 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertyValues" ) ), 1368 -1, getCppuType( static_cast<uno::Sequence< beans::Property > * >( 0 ) ) ), 1369 ucb::CommandInfo 1370 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "setPropertyValues" ) ), 1371 -1, getCppuType( static_cast<uno::Sequence< beans::PropertyValue > * >( 0 ) ) ), 1372 1373 // Optional standard commands 1374 ucb::CommandInfo 1375 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete" ) ), 1376 -1, getCppuBooleanType() ), 1377 ucb::CommandInfo 1378 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert" ) ), 1379 -1, getCppuType( static_cast<ucb::InsertCommandArgument * >( 0 ) ) ), 1380 ucb::CommandInfo 1381 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "open" ) ), 1382 -1, getCppuType( static_cast<ucb::OpenCommandArgument2 * >( 0 ) ) ), 1383 1384 // Folder Only, omitted if not a folder 1385 ucb::CommandInfo 1386 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "transfer" ) ), 1387 -1, getCppuType( static_cast<ucb::TransferInfo * >( 0 ) ) ), 1388 ucb::CommandInfo 1389 ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "createNewContent" ) ), 1390 -1, getCppuType( static_cast<ucb::ContentInfo * >( 0 ) ) ) 1391 }; 1392 1393 const int nProps 1394 = sizeof( aCommandInfoTable ) / sizeof( aCommandInfoTable[ 0 ] ); 1395 return uno::Sequence< ucb::CommandInfo >( 1396 aCommandInfoTable, isFolder( xEnv ) ? nProps : nProps - 2 ); 1397 } 1398 1399 rtl::OUString 1400 Content::getOUURI () 1401 { 1402 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1403 return m_xIdentifier->getContentIdentifier(); 1404 } 1405 1406 rtl::OString 1407 Content::getOURI () 1408 { 1409 return rtl::OUStringToOString( getOUURI(), RTL_TEXTENCODING_UTF8 ); 1410 } 1411 1412 char * 1413 Content::getURI () 1414 { 1415 return OUStringToGnome( getOUURI() ); 1416 } 1417 1418 void 1419 Content::copyData( uno::Reference< io::XInputStream > xIn, 1420 uno::Reference< io::XOutputStream > xOut ) 1421 { 1422 uno::Sequence< sal_Int8 > theData( TRANSFER_BUFFER_SIZE ); 1423 1424 g_return_if_fail( xIn.is() && xOut.is() ); 1425 1426 while ( xIn->readBytes( theData, TRANSFER_BUFFER_SIZE ) > 0 ) 1427 xOut->writeBytes( theData ); 1428 1429 xOut->closeOutput(); 1430 } 1431 1432 // Inherits an authentication context 1433 uno::Reference< io::XInputStream > 1434 Content::createTempStream( 1435 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1436 throw( uno::Exception ) 1437 { 1438 GnomeVFSResult result; 1439 GnomeVFSHandle *handle = NULL; 1440 ::rtl::OString aURI = getOURI(); 1441 1442 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1443 // Something badly wrong happened - can't seek => stream to a temporary file 1444 const rtl::OUString sServiceName ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.io.TempFile" ) ); 1445 uno::Reference < io::XOutputStream > xTempOut = 1446 uno::Reference < io::XOutputStream > 1447 ( m_xSMgr->createInstance( sServiceName ), uno::UNO_QUERY ); 1448 1449 if ( !xTempOut.is() ) 1450 cancelCommandExecution( GNOME_VFS_ERROR_IO, xEnv ); 1451 1452 result = gnome_vfs_open( &handle, aURI.getStr(), GNOME_VFS_OPEN_READ ); 1453 if (result != GNOME_VFS_OK) 1454 cancelCommandExecution( result, xEnv ); 1455 1456 uno::Reference < io::XInputStream > pStream = new ::gvfs::Stream( handle, &m_info ); 1457 copyData( pStream, xTempOut ); 1458 1459 return uno::Reference < io::XInputStream > ( xTempOut, uno::UNO_QUERY ); 1460 } 1461 1462 uno::Reference< io::XInputStream > 1463 Content::createInputStream( 1464 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1465 throw( uno::Exception ) 1466 { 1467 GnomeVFSHandle *handle = NULL; 1468 GnomeVFSResult result; 1469 uno::Reference<io::XInputStream > xIn; 1470 1471 Authentication aAuth( xEnv ); 1472 osl::Guard< osl::Mutex > aGuard( m_aMutex ); 1473 1474 getInfo( xEnv ); 1475 ::rtl::OString aURI = getOURI(); 1476 1477 if ( !(m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) ) 1478 return createTempStream( xEnv ); 1479 1480 result = gnome_vfs_open( &handle, aURI.getStr(), 1481 (GnomeVFSOpenMode) (GNOME_VFS_OPEN_READ | GNOME_VFS_OPEN_RANDOM ) ); 1482 1483 if (result == GNOME_VFS_ERROR_INVALID_OPEN_MODE || 1484 result == GNOME_VFS_ERROR_NOT_SUPPORTED) 1485 return createTempStream( xEnv ); 1486 1487 if (result != GNOME_VFS_OK) 1488 cancelCommandExecution( result, xEnv ); 1489 1490 // Try a seek just to make sure it's Random access: some lie. 1491 result = gnome_vfs_seek( handle, GNOME_VFS_SEEK_START, 0); 1492 if (result == GNOME_VFS_ERROR_NOT_SUPPORTED) { 1493 gnome_vfs_close( handle ); 1494 return createTempStream( xEnv ); 1495 } 1496 1497 if (result != GNOME_VFS_OK) 1498 cancelCommandExecution( result, xEnv ); 1499 1500 if (handle != NULL) 1501 xIn = new ::gvfs::Stream( handle, &m_info ); 1502 1503 return xIn; 1504 } 1505 1506 sal_Bool 1507 Content::feedSink( uno::Reference< uno::XInterface > aSink, 1508 const uno::Reference< ucb::XCommandEnvironment >& xEnv ) 1509 { 1510 if ( !aSink.is() ) 1511 return sal_False; 1512 1513 uno::Reference< io::XOutputStream > xOut 1514 = uno::Reference< io::XOutputStream >(aSink, uno::UNO_QUERY ); 1515 uno::Reference< io::XActiveDataSink > xDataSink 1516 = uno::Reference< io::XActiveDataSink >(aSink, uno::UNO_QUERY ); 1517 1518 if ( !xOut.is() && !xDataSink.is() ) 1519 return sal_False; 1520 1521 uno::Reference< io::XInputStream > xIn = createInputStream( xEnv ); 1522 if ( !xIn.is() ) 1523 return sal_False; 1524 1525 if ( xOut.is() ) 1526 copyData( xIn, xOut ); 1527 1528 if ( xDataSink.is() ) 1529 xDataSink->setInputStream( xIn ); 1530 1531 return sal_True; 1532 } 1533 1534 extern "C" { 1535 1536 #ifndef GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION 1537 # error "We require Gnome VFS 2.6.x to compile (will run fine with < 2.6)" 1538 #endif 1539 1540 static void 1541 vfs_authentication_callback (gconstpointer in_void, 1542 gsize in_size, 1543 gpointer out_void, 1544 gsize out_size, 1545 gpointer callback_data) 1546 { 1547 task::XInteractionHandler *xIH; 1548 1549 #ifdef DEBUG 1550 g_warning ("Full authentication callback (%p) ...", callback_data); 1551 #endif 1552 1553 if( !( xIH = (task::XInteractionHandler *) callback_data ) ) 1554 return; 1555 1556 const GnomeVFSModuleCallbackFullAuthenticationIn *in = 1557 (const GnomeVFSModuleCallbackFullAuthenticationIn *) in_void; 1558 GnomeVFSModuleCallbackFullAuthenticationOut *out = 1559 (GnomeVFSModuleCallbackFullAuthenticationOut *) out_void; 1560 1561 g_return_if_fail (in != NULL && out != NULL); 1562 g_return_if_fail (sizeof (GnomeVFSModuleCallbackFullAuthenticationIn) == in_size && 1563 sizeof (GnomeVFSModuleCallbackFullAuthenticationOut) == out_size); 1564 1565 #ifdef DEBUG 1566 # define NNIL(x) (x?x:"<Null>") 1567 g_warning (" InComing data 0x%x uri '%s' prot '%s' server '%s' object '%s' " 1568 "port %d auth_t '%s' user '%s' domain '%s' " 1569 "def user '%s', def domain '%s'", 1570 (int) in->flags, NNIL(in->uri), NNIL(in->protocol), 1571 NNIL(in->server), NNIL(in->object), 1572 (int) in->port, NNIL(in->authtype), NNIL(in->username), NNIL(in->domain), 1573 NNIL(in->default_user), NNIL(in->default_domain)); 1574 # undef NNIL 1575 #endif 1576 1577 ucbhelper::SimpleAuthenticationRequest::EntityType 1578 eDomain, eUserName, ePassword; 1579 ::rtl::OUString aHostName, aDomain, aUserName, aPassword; 1580 1581 aHostName = GnomeToOUString( in->server ); 1582 1583 if (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_DOMAIN) 1584 { 1585 aDomain = GnomeToOUString( in->domain ); 1586 eDomain = ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY; 1587 if (!aDomain.getLength()) 1588 aDomain = GnomeToOUString( in->default_domain ); 1589 } 1590 else // no underlying capability to display realm otherwise 1591 eDomain = ucbhelper::SimpleAuthenticationRequest::ENTITY_NA; 1592 1593 aUserName = GnomeToOUString( in->username ); 1594 if (!aUserName.getLength()) 1595 aUserName = GnomeToOUString( in->default_user ); 1596 eUserName = (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_USERNAME) ? 1597 ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY : 1598 (aUserName.getLength() ? 1599 ucbhelper::SimpleAuthenticationRequest::ENTITY_FIXED : 1600 ucbhelper::SimpleAuthenticationRequest::ENTITY_NA); 1601 1602 // No suggested password. 1603 ePassword = (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_PASSWORD) ? 1604 ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY : 1605 ucbhelper::SimpleAuthenticationRequest::ENTITY_FIXED; 1606 1607 // Really, really bad things happen if we don't provide 1608 // the same user/password as was entered last time if 1609 // we failed to authenticate - infinite looping / flickering 1610 // madness etc. [ nice infrastructure ! ] 1611 static rtl::OUString aLastUserName, aLastPassword; 1612 if (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_PREVIOUS_ATTEMPT_FAILED) 1613 { 1614 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); 1615 aUserName = aLastUserName; 1616 aPassword = aLastPassword; 1617 } 1618 1619 rtl::Reference< ucbhelper::SimpleAuthenticationRequest > xRequest 1620 = new ucbhelper::SimpleAuthenticationRequest (GnomeToOUString(in->uri), 1621 aHostName, eDomain, aDomain, 1622 eUserName, aUserName, 1623 ePassword, aPassword); 1624 1625 xIH->handle( xRequest.get() ); 1626 1627 rtl::Reference< ucbhelper::InteractionContinuation > xSelection 1628 = xRequest->getSelection(); 1629 1630 if ( xSelection.is() ) { 1631 // Handler handled the request. 1632 uno::Reference< task::XInteractionAbort > xAbort(xSelection.get(), uno::UNO_QUERY ); 1633 if ( !xAbort.is() ) { 1634 const rtl::Reference< 1635 ucbhelper::InteractionSupplyAuthentication > & xSupp 1636 = xRequest->getAuthenticationSupplier(); 1637 1638 aUserName = xSupp->getUserName(); 1639 aDomain = xSupp->getRealm(); 1640 aPassword = xSupp->getPassword(); 1641 1642 { 1643 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); 1644 aLastUserName = aUserName; 1645 aLastPassword = aPassword; 1646 } 1647 1648 out->username = OUStringToGnome( aUserName ); 1649 out->domain = OUStringToGnome( aDomain ); 1650 out->password = OUStringToGnome( aPassword ); 1651 out->save_password = xSupp->getRememberPasswordMode(); 1652 1653 #ifdef DEBUG 1654 g_warning ("Got valid user/domain/password '%s' '%s' '%s', %s password", 1655 out->username, out->domain, out->password, 1656 out->save_password ? "save" : "don't save"); 1657 #endif 1658 } 1659 else 1660 out->abort_auth = TRUE; 1661 } 1662 else 1663 out->abort_auth = TRUE; 1664 } 1665 1666 static void 1667 vfs_authentication_old_callback (gconstpointer in_void, 1668 gsize in_size, 1669 gpointer out_void, 1670 gsize out_size, 1671 gpointer callback_data) 1672 { 1673 #ifdef DEBUG 1674 g_warning ("Old authentication callback (%p) [ UNTESTED ] ...", callback_data); 1675 #endif 1676 const GnomeVFSModuleCallbackAuthenticationIn *in = 1677 (const GnomeVFSModuleCallbackAuthenticationIn *) in_void; 1678 GnomeVFSModuleCallbackAuthenticationOut *out = 1679 (GnomeVFSModuleCallbackAuthenticationOut *) out_void; 1680 1681 g_return_if_fail (in != NULL && out != NULL); 1682 g_return_if_fail (sizeof (GnomeVFSModuleCallbackAuthenticationIn) == in_size && 1683 sizeof (GnomeVFSModuleCallbackAuthenticationOut) == out_size); 1684 1685 GnomeVFSModuleCallbackFullAuthenticationIn mapped_in = { 1686 (GnomeVFSModuleCallbackFullAuthenticationFlags) 1687 (GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_PASSWORD | 1688 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_USERNAME | 1689 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_DOMAIN), 1690 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 1691 GnomeVFSModuleCallbackFullAuthenticationOut mapped_out = { 0, 0, 0, 0, 0, 0, 0, 0 }; 1692 1693 // Map the old style input auth. data to the new style structure. 1694 if (in->previous_attempt_failed) 1695 mapped_in.flags = (GnomeVFSModuleCallbackFullAuthenticationFlags) 1696 (mapped_in.flags | 1697 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_PREVIOUS_ATTEMPT_FAILED); 1698 1699 GnomeVFSURI *pURI = NULL; 1700 // Urk - parse all this from the URL ... 1701 mapped_in.uri = in->uri; 1702 if (in->uri) 1703 { 1704 pURI = gnome_vfs_uri_new( in->uri ); 1705 mapped_in.protocol = (char *) gnome_vfs_uri_get_scheme (pURI); 1706 mapped_in.server = (char *) gnome_vfs_uri_get_host_name (pURI); 1707 mapped_in.port = gnome_vfs_uri_get_host_port (pURI); 1708 mapped_in.username = (char *) gnome_vfs_uri_get_user_name (pURI); 1709 } 1710 mapped_in.domain = in->realm; 1711 mapped_in.default_user = mapped_in.username; 1712 mapped_in.default_domain = mapped_in.domain; 1713 1714 vfs_authentication_callback ((gconstpointer) &mapped_in, 1715 sizeof (mapped_in), 1716 (gpointer) &mapped_out, 1717 sizeof (mapped_out), 1718 callback_data); 1719 1720 if (pURI) 1721 gnome_vfs_uri_unref (pURI); 1722 1723 // Map the new style auth. out data to the old style out structure. 1724 out->username = mapped_out.username; 1725 out->password = mapped_out.password; 1726 g_free (mapped_out.domain); 1727 g_free (mapped_out.keyring); 1728 } 1729 1730 1731 static void 1732 auth_destroy (gpointer data) 1733 { 1734 task::XInteractionHandler *xIH; 1735 if( ( xIH = ( task::XInteractionHandler * )data ) ) 1736 xIH->release(); 1737 } 1738 1739 // This sucks, but gnome-vfs doesn't much like 1740 // repeated set / unsets - so we have to compensate. 1741 GPrivate *auth_queue = NULL; 1742 1743 void auth_queue_destroy( gpointer data ) 1744 { 1745 GList *l; 1746 GQueue *vq = (GQueue *) data; 1747 1748 for (l = vq->head; l; l = l->next) 1749 auth_destroy (l->data); 1750 g_queue_free (vq); 1751 } 1752 } 1753 1754 static void 1755 refresh_auth( GQueue *vq ) 1756 { 1757 GList *l; 1758 1759 gnome_vfs_module_callback_pop( GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION ); 1760 gnome_vfs_module_callback_pop( GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION ); 1761 1762 for (l = vq->head; l; l = l->next) { 1763 if (l->data) { 1764 gnome_vfs_module_callback_push 1765 ( GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION, 1766 vfs_authentication_old_callback, l->data, NULL ); 1767 gnome_vfs_module_callback_push 1768 ( GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION, 1769 vfs_authentication_callback, l->data, NULL ); 1770 break; 1771 } 1772 } 1773 } 1774 1775 gvfs::Authentication::Authentication( 1776 const uno::Reference< ucb::XCommandEnvironment > & xEnv ) 1777 { 1778 GQueue *vq; 1779 uno::Reference< task::XInteractionHandler > xIH; 1780 1781 if ( xEnv.is() ) 1782 xIH = xEnv->getInteractionHandler(); 1783 1784 if ( xIH.is() ) 1785 xIH->acquire(); 1786 1787 if( !(vq = (GQueue *)g_private_get( auth_queue ) ) ) { 1788 vq = g_queue_new(); 1789 g_private_set( auth_queue, vq ); 1790 } 1791 1792 g_queue_push_head( vq, (gpointer) xIH.get() ); 1793 refresh_auth( vq ); 1794 } 1795 1796 gvfs::Authentication::~Authentication() 1797 { 1798 GQueue *vq; 1799 gpointer data; 1800 1801 vq = (GQueue *)g_private_get( auth_queue ); 1802 1803 data = g_queue_pop_head( vq ); 1804 auth_destroy (data); 1805 1806 refresh_auth( vq ); 1807 } 1808