xref: /trunk/main/ucb/source/ucp/gvfs/gvfs_content.cxx (revision 2f86921c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_ucb.hxx"
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

#include "osl/time.h"
#include <osl/diagnose.h>

#include "osl/doublecheckedlocking.h"

#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/beans/PropertySetInfoChange.hpp>
#include <com/sun/star/beans/PropertySetInfoChangeEvent.hpp>
#include <com/sun/star/io/XActiveDataSink.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/lang/IllegalAccessException.hpp>
#include <com/sun/star/ucb/ContentInfoAttribute.hpp>
#include <com/sun/star/ucb/InsertCommandArgument.hpp>
#include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
#include <com/sun/star/ucb/InteractiveNetworkConnectException.hpp>
#include <com/sun/star/ucb/InteractiveNetworkGeneralException.hpp>
#include <com/sun/star/ucb/InteractiveNetworkReadException.hpp>
#include <com/sun/star/ucb/InteractiveNetworkResolveNameException.hpp>
#include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp>
#include <com/sun/star/ucb/NameClash.hpp>
#include <com/sun/star/ucb/NameClashException.hpp>
#include <com/sun/star/ucb/OpenCommandArgument2.hpp>
#include <com/sun/star/ucb/OpenMode.hpp>
#include <com/sun/star/ucb/PostCommandArgument2.hpp>
#include <com/sun/star/ucb/TransferInfo.hpp>
#include <com/sun/star/ucb/XCommandInfo.hpp>
#include <com/sun/star/ucb/XPersistentPropertySet.hpp>
#include <com/sun/star/ucb/MissingInputStreamException.hpp>
#include <com/sun/star/ucb/MissingPropertiesException.hpp>
#include <com/sun/star/ucb/UnsupportedCommandException.hpp>
#include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
#include <com/sun/star/ucb/UnsupportedNameClashException.hpp>
#include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
#include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
#include <com/sun/star/ucb/NameClashException.hpp>
#include <ucbhelper/contentidentifier.hxx>
#include <ucbhelper/propertyvalueset.hxx>
#include <ucbhelper/interactionrequest.hxx>
#include <ucbhelper/cancelcommandexecution.hxx>
#include <ucbhelper/simpleauthenticationrequest.hxx>

const int TRANSFER_BUFFER_SIZE = 65536;

/*
 * NB. Name escaping is done only for URIs
 * the 'Title' property is unescaped on set/get
 */
#include <libgnomevfs/gnome-vfs-utils.h>
#include <libgnomevfs/gnome-vfs-result.h>
#include <libgnomevfs/gnome-vfs-standard-callbacks.h>
extern "C" { // missing in the header: doh.
#  include <libgnomevfs/gnome-vfs-module-callback.h>
}

#include "gvfs_content.hxx"
#include "gvfs_provider.hxx"
#include "gvfs_directory.hxx"
#include "gvfs_stream.hxx"

using namespace gvfs;
using namespace com::sun::star;

#define CLEAR_INFO(info) memset((info), 0, sizeof ((info)[0]))


static char *
OUStringToGnome( const rtl::OUString &str )
{
    rtl::OString aTempStr = rtl::OUStringToOString( str, RTL_TEXTENCODING_UTF8 );
    return g_strdup( (const sal_Char *) aTempStr );
}

static rtl::OUString
GnomeToOUString( const char *utf8_str)
{
    if (!utf8_str)
        return rtl::OUString();
    else
        return rtl::OUString( utf8_str, strlen( utf8_str ), RTL_TEXTENCODING_UTF8 );
}


Content::Content(
          const uno::Reference< lang::XMultiServiceFactory >& rxSMgr,
          ContentProvider* pProvider,
          const uno::Reference< ucb::XContentIdentifier >& Identifier)
  throw ( ucb::ContentCreationException )
    : ContentImplHelper( rxSMgr, pProvider, Identifier ),
      m_pProvider( pProvider ),
      m_bTransient( sal_False )
{
    CLEAR_INFO (&m_info);
#ifdef DEBUG
    g_warning ("New Content ('%s')", getURI());
#endif
}

Content::Content(
    const uno::Reference< lang::XMultiServiceFactory >& rxSMgr,
    ContentProvider                                   * pProvider,
    const uno::Reference< ucb::XContentIdentifier >&    Identifier,
    sal_Bool                                            IsFolder)
        throw ( ucb::ContentCreationException )
    : ContentImplHelper( rxSMgr, pProvider, Identifier ),
      m_pProvider( pProvider ),
      m_bTransient( sal_True )
{
    CLEAR_INFO (&m_info);

#ifdef DEBUG
    g_warning ("New Transient content ('%s') (%d)", getURI(), IsFolder);
#endif
//	m_info.name = FIXME: set name ?
    m_info.valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE;
    m_info.type = IsFolder ? GNOME_VFS_FILE_TYPE_DIRECTORY :
                         GNOME_VFS_FILE_TYPE_REGULAR;
}

// virtual
Content::~Content()
{
    gnome_vfs_file_info_clear( &m_info );
}

//
// XInterface methods.
//

void SAL_CALL Content::acquire()
    throw( )
{
    ContentImplHelper::acquire();
}
void SAL_CALL Content::release()
    throw( )
{
    ContentImplHelper::release();
}
uno::Any SAL_CALL Content::queryInterface( const uno::Type & rType )
    throw ( uno::RuntimeException )
{
    // Note: isFolder may require network activities! So call it only
    //       if it is really necessary!!!
    uno::Any aRet = cppu::queryInterface( rType,
                        static_cast< ucb::XContentCreator * >( this ) );
    if ( aRet.hasValue() )
            return isFolder( uno::Reference< ucb::XCommandEnvironment >() )
            ? aRet : uno::Any();
    else
        return aRet.hasValue() ? aRet : ContentImplHelper::queryInterface( rType );
}

//
// XTypeProvider methods.
//

XTYPEPROVIDER_COMMON_IMPL( Content );

uno::Sequence< uno::Type > SAL_CALL Content::getTypes()
    throw( uno::RuntimeException )
{
    static cppu::OTypeCollection *pFolderCollection = NULL;
    static cppu::OTypeCollection *pFileCollection = NULL;

    if (!pFolderCollection) {
        osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );

        if (!pFolderCollection) {
            static cppu::OTypeCollection aFolderCollection
                (CPPU_TYPE_REF( lang::XTypeProvider ),
                 CPPU_TYPE_REF( lang::XServiceInfo ),
                 CPPU_TYPE_REF( lang::XComponent ),
                 CPPU_TYPE_REF( ucb::XContent ),
                 CPPU_TYPE_REF( ucb::XCommandProcessor ),
                 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
                 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
                 CPPU_TYPE_REF( beans::XPropertyContainer ),
                 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
                 CPPU_TYPE_REF( container::XChild ),
                 CPPU_TYPE_REF( ucb::XContentCreator ) ); // !!
            static cppu::OTypeCollection aFileCollection
                (CPPU_TYPE_REF( lang::XTypeProvider ),
                 CPPU_TYPE_REF( lang::XServiceInfo ),
                 CPPU_TYPE_REF( lang::XComponent ),
                 CPPU_TYPE_REF( ucb::XContent ),
                 CPPU_TYPE_REF( ucb::XCommandProcessor ),
                 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
                 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
                 CPPU_TYPE_REF( beans::XPropertyContainer ),
                 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
                 CPPU_TYPE_REF( container::XChild ) );

            pFolderCollection = &aFolderCollection;
            pFileCollection = &aFileCollection;
            OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
        }
    }
    else {
        OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
    }

    if ( isFolder( uno::Reference< ucb::XCommandEnvironment >() ) )
        return pFolderCollection->getTypes();
    else
        return pFileCollection->getTypes();
}

//
// XServiceInfo methods.
//

rtl::OUString SAL_CALL Content::getImplementationName()
    throw( uno::RuntimeException )
{
    return rtl::OUString::createFromAscii("com.sun.star.comp.GnomeVFSContent" );
}

uno::Sequence< rtl::OUString > SAL_CALL Content::getSupportedServiceNames()
    throw( uno::RuntimeException )
{
    uno::Sequence< rtl::OUString > aSNS( 1 );
    aSNS.getArray()[ 0 ] = rtl::OUString::createFromAscii(
        "com.sun.star.ucb.GnomeVFSContent" );
    return aSNS;
}

//
// XContent methods.
//

rtl::OUString SAL_CALL Content::getContentType()
    throw( uno::RuntimeException )
{
    if ( isFolder( uno::Reference< ucb::XCommandEnvironment >() ) )
        return rtl::OUString::createFromAscii( GVFS_FOLDER_TYPE );
    else
        return rtl::OUString::createFromAscii( GVFS_FILE_TYPE );
}

//
// XCommandProcessor methods.
//

uno::Any Content::getBadArgExcept()
{
    return uno::makeAny( lang::IllegalArgumentException
                 ( rtl::OUString::createFromAscii( "Wrong argument type!" ),
                   static_cast< cppu::OWeakObject * >( this ),
                   -1 ) );
}

#include <stdio.h>

uno::Any SAL_CALL Content::execute(
        const ucb::Command& aCommand,
        sal_Int32 /*CommandId*/,
        const uno::Reference< ucb::XCommandEnvironment >& xEnv )
    throw( uno::Exception,
           ucb::CommandAbortedException,
           uno::RuntimeException )
{
    uno::Any aRet;

#ifdef DEBUG
    {
        uno::Reference< task::XInteractionHandler > xIH;

        if ( xEnv.is() )
            xIH = xEnv->getInteractionHandler();
        g_warning( "Execute command: '%s' with %s interaction env",
               OUStringToGnome( aCommand.Name ),
               xIH.is() ? "" : "NO" );
    }
#endif

#define COMMAND_IS(cmd,name) ( (cmd).Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( name ) ) )

    if ( COMMAND_IS( aCommand, "getPropertyValues" ) ) {
        uno::Sequence< beans::Property > Properties;

        if ( !( aCommand.Argument >>= Properties ) )
            ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );

        aRet <<= getPropertyValues( Properties, xEnv );

    } else if ( COMMAND_IS( aCommand, "setPropertyValues" ) ) {
        uno::Sequence< beans::PropertyValue > aProperties;

        if ( !( aCommand.Argument >>= aProperties ) ||
             !aProperties.getLength() )
            ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );

        aRet <<= setPropertyValues( aProperties, xEnv );

    } else if ( COMMAND_IS( aCommand, "getPropertySetInfo" ) ) {
        aRet <<= getPropertySetInfo( xEnv, sal_False );

    } else if ( COMMAND_IS( aCommand, "getCommandInfo" ) ) {
        aRet <<= getCommandInfo( xEnv, sal_False );

    } else if ( COMMAND_IS( aCommand, "open" ) ) {
        rtl::OUString str = m_xIdentifier->getContentIdentifier();
        rtl::OString stra(
            str.getStr(),
            str.getLength(),
            RTL_TEXTENCODING_UTF8);

        ucb::OpenCommandArgument2 aOpenCommand;
        if ( !( aCommand.Argument >>= aOpenCommand ) )
            ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );

        sal_Bool bOpenFolder =
            ( ( aOpenCommand.Mode == ucb::OpenMode::ALL ) ||
              ( aOpenCommand.Mode == ucb::OpenMode::FOLDERS ) ||
              ( aOpenCommand.Mode == ucb::OpenMode::DOCUMENTS ) );

        if ( bOpenFolder && isFolder( xEnv ) ) {
            uno::Reference< ucb::XDynamicResultSet > xSet
                = new DynamicResultSet(m_xSMgr, this, aOpenCommand, xEnv );
            aRet <<= xSet;

        } else if ( aOpenCommand.Sink.is() ) {

            if ( ( aOpenCommand.Mode
                   == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) ||
                 ( aOpenCommand.Mode
                   == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE ) ) {
                ucbhelper::cancelCommandExecution
                    ( uno::makeAny ( ucb::UnsupportedOpenModeException
                             ( rtl::OUString(),
                               static_cast< cppu::OWeakObject * >( this ),
                               sal_Int16( aOpenCommand.Mode ) ) ),
                      xEnv );
            }
            if ( !feedSink( aOpenCommand.Sink, xEnv ) ) {
                // Note: aOpenCommand.Sink may contain an XStream
                //       implementation. Support for this type of
                //       sink is optional...
#ifdef DEBUG
                g_warning ("Failed to load data from '%s'", getURI());
#endif
                ucbhelper::cancelCommandExecution
                    ( uno::makeAny (ucb::UnsupportedDataSinkException
                            ( rtl::OUString(),
                              static_cast< cppu::OWeakObject * >( this ),
                              aOpenCommand.Sink ) ),
                      xEnv );
            }
        }
#ifdef DEBUG
        else
            g_warning ("Open falling through ...");
#endif

    } else if ( COMMAND_IS( aCommand, "createNewContent" ) && isFolder( xEnv ) ) {
        ucb::ContentInfo arg;
        if ( !( aCommand.Argument >>= arg ) )
            ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );

        aRet <<= createNewContent( arg );

    } else if ( COMMAND_IS( aCommand, "insert" ) ) {
        ucb::InsertCommandArgument arg;
        if ( !( aCommand.Argument >>= arg ) )
            ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );

        insert( arg.Data, arg.ReplaceExisting, xEnv );

    } else if ( COMMAND_IS( aCommand, "delete" ) ) {

        sal_Bool bDeletePhysical = sal_False;
        aCommand.Argument >>= bDeletePhysical;

        ::rtl::OString aURI = getOURI();
        GnomeVFSResult result = gnome_vfs_unlink ((const sal_Char *) aURI);

        if (result != GNOME_VFS_OK)
            cancelCommandExecution( result, xEnv, sal_True );

        destroy( bDeletePhysical );

    } else if ( COMMAND_IS( aCommand, "transfer" ) && isFolder( xEnv ) ) {
        ucb::TransferInfo transferArgs;

        if ( !( aCommand.Argument >>= transferArgs ) )
            ucbhelper::cancelCommandExecution( getBadArgExcept(), xEnv );

        transfer( transferArgs, xEnv );

    } else { // Unsuported
#ifdef DEBUG
        g_warning( "Unsupported command: '%s'",
               OUStringToGnome( aCommand.Name ) );
#endif
        ucbhelper::cancelCommandExecution
            ( uno::makeAny( ucb::UnsupportedCommandException
                    ( rtl::OUString(),
                      static_cast< cppu::OWeakObject * >( this ) ) ),
              xEnv );
    }
#undef COMMAND_IS

    return aRet;
}

void SAL_CALL Content::abort( sal_Int32 /*CommandId*/ )
    throw( uno::RuntimeException )
{
    // FIXME: we should use the GnomeVFSCancellation APIs here ...
}

//
// XContentCreator methods.
//

uno::Sequence< ucb::ContentInfo > Content::queryCreatableContentsInfo(
    const uno::Reference< ucb::XCommandEnvironment >& xEnv)
            throw( uno::RuntimeException )
{
    if ( isFolder( xEnv ) )
    {
        uno::Sequence< ucb::ContentInfo > seq(2);

        // Minimum set of props we really need
        uno::Sequence< beans::Property > props( 1 );
        props[0] = beans::Property(
            rtl::OUString::createFromAscii( "Title" ),
            -1,
            getCppuType( static_cast< rtl::OUString* >( 0 ) ),
            beans::PropertyAttribute::MAYBEVOID | beans::PropertyAttribute::BOUND );

        // file
        seq[0].Type       = rtl::OUString::createFromAscii( GVFS_FILE_TYPE );
        seq[0].Attributes = ( ucb::ContentInfoAttribute::INSERT_WITH_INPUTSTREAM |
                              ucb::ContentInfoAttribute::KIND_DOCUMENT );
        seq[0].Properties = props;

        // folder
        seq[1].Type       = rtl::OUString::createFromAscii( GVFS_FOLDER_TYPE );
        seq[1].Attributes = ucb::ContentInfoAttribute::KIND_FOLDER;
        seq[1].Properties = props;

        return seq;
    }
    else
    {
        return uno::Sequence< ucb::ContentInfo >();
    }
}

uno::Sequence< ucb::ContentInfo > SAL_CALL Content::queryCreatableContentsInfo()
            throw( uno::RuntimeException )
{
    return queryCreatableContentsInfo( uno::Reference< ucb::XCommandEnvironment >() );
}

uno::Reference< ucb::XContent > SAL_CALL
Content::createNewContent( const ucb::ContentInfo& Info )
    throw( uno::RuntimeException )
{
    bool create_document;
    const char *name;

        if ( Info.Type.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( GVFS_FILE_TYPE ) ) )
        create_document = true;
    else if ( Info.Type.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( GVFS_FOLDER_TYPE ) ) )
        create_document = false;
    else {
#ifdef DEBUG
        g_warning( "Failed to create new content '%s'",
               OUStringToGnome( Info.Type ) );
#endif
        return uno::Reference< ucb::XContent >();
    }

#ifdef DEBUG
    g_warning( "createNewContent (%d)", (int) create_document );
#endif

        rtl::OUString aURL = getOUURI();

    if ( ( aURL.lastIndexOf( '/' ) + 1 ) != aURL.getLength() )
        aURL += rtl::OUString::createFromAscii( "/" );

    name = create_document ? "[New_Content]" : "[New_Collection]";
    // This looks problematic to me cf. webdav
    aURL += rtl::OUString::createFromAscii( name );

        uno::Reference< ucb::XContentIdentifier > xId
        ( new ::ucbhelper::ContentIdentifier( m_xSMgr, aURL ) );

        try {
        return new ::gvfs::Content( m_xSMgr, m_pProvider, xId, !create_document );
    } catch ( ucb::ContentCreationException & ) {
        return uno::Reference< ucb::XContent >();
        }
}

rtl::OUString Content::getParentURL()
{
    rtl::OUString aParentURL;
    // <scheme>://              -> ""
    // <scheme>://foo           -> ""
    // <scheme>://foo/          -> ""
    // <scheme>://foo/bar       -> <scheme>://foo/
    // <scheme>://foo/bar/      -> <scheme>://foo/
    // <scheme>://foo/bar/abc   -> <scheme>://foo/bar/

    rtl::OUString aURL = getOUURI();

    sal_Int32 nPos = aURL.lastIndexOf( '/' );
    if ( nPos == ( aURL.getLength() - 1 ) ) {
        // Trailing slash found. Skip.
        nPos = aURL.lastIndexOf( '/', nPos );
    }

    sal_Int32 nPos1 = aURL.lastIndexOf( '/', nPos );
    if ( nPos1 != -1 )
        nPos1 = aURL.lastIndexOf( '/', nPos1 );

    if ( nPos1 != -1 )
        aParentURL = rtl::OUString( aURL.copy( 0, nPos + 1 ) );

#ifdef DEBUG
    g_warning ("getParentURL '%s' -> '%s'",
           getURI(), (const sal_Char *) rtl::OUStringToOString
               ( aParentURL, RTL_TEXTENCODING_UTF8 ) );
#endif

    return aParentURL;
}

static util::DateTime
getDateFromUnix (time_t t)
{
    TimeValue tv;
    tv.Nanosec = 0;
    tv.Seconds = t;
    oslDateTime dt;

    if ( osl_getDateTimeFromTimeValue( &tv, &dt ) )
        return util::DateTime( 0, dt.Seconds, dt.Minutes, dt.Hours,
                               dt.Day, dt.Month, dt.Year);
    else
        return util::DateTime();
}

uno::Reference< sdbc::XRow > Content::getPropertyValues(
                const uno::Sequence< beans::Property >& rProperties,
                const uno::Reference< ucb::XCommandEnvironment >& xEnv )
{
    int nProps;
    GnomeVFSResult result;
    uno::Sequence< beans::Property > allProperties;

    if( ( result = getInfo( xEnv ) ) != GNOME_VFS_OK )
        cancelCommandExecution( result, xEnv, sal_False );

    const beans::Property* pProps;

    if( rProperties.getLength() ) {
        nProps = rProperties.getLength();
        pProps = rProperties.getConstArray();
    } else {
        allProperties = getPropertySetInfo( xEnv )->getProperties();
        nProps = allProperties.getLength();
        pProps = allProperties.getConstArray();
    }

    rtl::Reference< ::ucbhelper::PropertyValueSet > xRow
        = new ::ucbhelper::PropertyValueSet( m_xSMgr );

        osl::Guard< osl::Mutex > aGuard( m_aMutex );
    for( sal_Int32 n = 0; n < nProps; ++n ) {
        const beans::Property& rProp = pProps[ n ];

        if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) ) {
            if (m_info.name && m_info.name[0] == '/')
                g_warning ("Odd NFS title on item '%s' == '%s'",
                       getURI(), m_info.name);
            xRow->appendString( rProp, GnomeToOUString( m_info.name ) );
        }

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) )
            xRow->appendString( rProp, getContentType () );

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) ) {
            if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE)
                xRow->appendBoolean( rProp, ( m_info.type == GNOME_VFS_FILE_TYPE_REGULAR ||
                                  m_info.type == GNOME_VFS_FILE_TYPE_UNKNOWN ) );
            else
                xRow->appendVoid( rProp );
        }
        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) ) {
            if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE)
                xRow->appendBoolean( rProp, ( m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY ) );
            else
                xRow->appendVoid( rProp );
        }
        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsReadOnly" ) ) ) {

            GnomeVFSFileInfo* fileInfo = gnome_vfs_file_info_new ();

            ::rtl::OString aURI = getOURI();
            gnome_vfs_get_file_info
                ( (const sal_Char *)aURI, fileInfo,
                        GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS );

            if (fileInfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ACCESS) {
                bool read_only = true;

                if (fileInfo->permissions & GNOME_VFS_PERM_ACCESS_WRITABLE)
                                        read_only = false;

                xRow->appendBoolean( rProp, read_only );
            } else
                xRow->appendVoid( rProp );
            gnome_vfs_file_info_unref (fileInfo);
        }
        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Size" ) ) ) {
            if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE)
                xRow->appendLong( rProp, m_info.size );
            else
                xRow->appendVoid( rProp );
        }
        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsHidden" ) ) )
            xRow->appendBoolean( rProp, ( m_info.name && m_info.name[0] == '.' ) );

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsVolume" ) ) ||
             rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsCompactDisk" ) ) )
            xRow->appendBoolean( rProp, sal_False );

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateCreated" ) ) ) {
            if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_CTIME)
                xRow->appendTimestamp( rProp, getDateFromUnix( m_info.ctime ) );
            else
                xRow->appendVoid( rProp );
        }

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateModified" ) ) ) {
            if (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MTIME)
                xRow->appendTimestamp( rProp, getDateFromUnix( m_info.mtime ) );
            else
                xRow->appendVoid( rProp );
        }

        else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) ) {
            // We do this by sniffing in gnome-vfs; rather expensively.
#ifdef DEBUG
            g_warning ("FIXME: Requested mime-type - an expensive op. indeed!");
#endif
            xRow->appendVoid( rProp );
        } else if (rProp.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CreatableContentsInfo" ) ) )
            xRow->appendObject( rProp, uno::makeAny( queryCreatableContentsInfo( xEnv ) ) );

        else {
            xRow->appendVoid( rProp );
        }
    }
#ifdef DEBUG
    g_warning ("getPropertyValues on '%s' %d properties returned (of %d)",
           getURI(), (int)xRow->getLength(), (int)nProps);
#endif

    return uno::Reference< sdbc::XRow >( xRow.get() );
}

static lang::IllegalAccessException
getReadOnlyException( Content *ctnt )
{
    return lang::IllegalAccessException
        ( rtl::OUString::createFromAscii( "Property is read-only!" ),
          static_cast< cppu::OWeakObject * >( ctnt ) );
}

rtl::OUString
Content::makeNewURL( const char */*newName*/ )
{
    rtl::OUString aNewURL = getParentURL();
    if ( aNewURL.lastIndexOf( '/' ) != ( aNewURL.getLength() - 1 ) )
        aNewURL += rtl::OUString::createFromAscii( "/" );

    char *name = gnome_vfs_escape_string( m_info.name );
    aNewURL += GnomeToOUString( name );
    g_free( name );

    return aNewURL;
}

// This is slightly complicated by needing to support either 'move' or 'setname'
GnomeVFSResult
Content::doSetFileInfo( const GnomeVFSFileInfo *newInfo,
            GnomeVFSSetFileInfoMask setMask,
            const uno::Reference< ucb::XCommandEnvironment >& /*xEnv*/ )
{
    GnomeVFSResult result = GNOME_VFS_OK;

    g_assert (!m_bTransient);

    ::rtl::OString aURI = getOURI();

        osl::Guard< osl::Mutex > aGuard( m_aMutex );

    // The simple approach:
    if( setMask != GNOME_VFS_SET_FILE_INFO_NONE )
        result = gnome_vfs_set_file_info // missed a const in the API there
            ( (const sal_Char *) aURI, (GnomeVFSFileInfo *)newInfo, setMask );

    if ( result == GNOME_VFS_ERROR_NOT_SUPPORTED &&
         ( setMask & GNOME_VFS_SET_FILE_INFO_NAME ) ) {
        // Try a move instead
#ifdef DEBUG
        g_warning( "SetFileInfo not supported on '%s'", getURI() );
#endif

        char *newURI = OUStringToGnome( makeNewURL( newInfo->name ) );

        result = gnome_vfs_move ((const sal_Char *)aURI, newURI, FALSE);

        g_free (newURI);
    }

    return result;
}


uno::Sequence< uno::Any > Content::setPropertyValues(
                const uno::Sequence< beans::PropertyValue >& rValues,
                const uno::Reference< ucb::XCommandEnvironment >& xEnv )
{
    rtl::OUString    aNewTitle;
    GnomeVFSFileInfo newInfo;
    int              setMask = GNOME_VFS_SET_FILE_INFO_NONE;

    getInfo( xEnv );

    osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );

    gnome_vfs_file_info_copy( &newInfo, &m_info );

    Authentication aAuth( xEnv );

    int nChanged = 0, nTitlePos = 0;
    uno::Sequence< uno::Any > aRet( rValues.getLength() );
    uno::Sequence< beans::PropertyChangeEvent > aChanges( rValues.getLength() );

    beans::PropertyChangeEvent aEvent;
    aEvent.Source         = static_cast< cppu::OWeakObject * >( this );
    aEvent.Further        = sal_False;
    aEvent.PropertyHandle = -1;
    // aEvent.PropertyName = fill in later ...
    // aEvent.OldValue     =
    // aEvent.NewValue     =

    int nCount = rValues.getLength();
    const beans::PropertyValue* pValues = rValues.getConstArray();

    for ( sal_Int32 n = 0; n < nCount; ++n ) {
        const beans::PropertyValue& rValue = pValues[ n ];

#ifdef DEBUG
        g_warning( "Set prop '%s'", OUStringToGnome( rValue.Name ) );
#endif
        if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "ContentType" ) ) ||
             rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MediaType" ) ) ||
             rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsDocument" ) ) ||
             rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "IsFolder" ) ) ||
             rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Size" ) ) ||
             rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CreatableContentsInfo" ) ) )
            aRet[ n ] <<= getReadOnlyException( this );

        else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) ) {
            if ( rValue.Value >>= aNewTitle ) {
                if ( aNewTitle.getLength() <= 0 )
                    aRet[ n ] <<= lang::IllegalArgumentException
                        ( rtl::OUString::createFromAscii( "Empty title not allowed!" ),
                          static_cast< cppu::OWeakObject * >( this ), -1 );
                else {
                    char *newName = OUStringToGnome( aNewTitle );

                    if( !newName || !m_info.name || strcmp( newName, m_info.name ) ) {
#ifdef DEBUG
                        g_warning ("Set new name to '%s'", newName);
#endif

                        aEvent.PropertyName = rtl::OUString::createFromAscii( "Title" );
                        aEvent.OldValue     = uno::makeAny( GnomeToOUString( newInfo.name ) );
                        aEvent.NewValue     = uno::makeAny( aNewTitle );
                        aChanges.getArray()[ nChanged ] = aEvent;
                        nTitlePos = nChanged++;

                        newInfo.name = newName;
                        setMask |= GNOME_VFS_SET_FILE_INFO_NAME;
                    } else // same name
                        g_free (newName);
                }
            } else
                aRet[ n ] <<= beans::IllegalTypeException
                    ( rtl::OUString::createFromAscii( "Property value has wrong type!" ),
                      static_cast< cppu::OWeakObject * >( this ) );

        } else if ( rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateCreated" ) ) ||
                rValue.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateModified" ) ) ) {
            // FIXME: should be able to set the timestamps
            aRet[ n ] <<= getReadOnlyException( this );
        } else {
#ifdef DEBUG
            g_warning( "Unhandled property '%s'", OUStringToGnome( rValue.Name ) );
#endif
            aRet[ n ] <<= getReadOnlyException( this );
        }
    }

    GnomeVFSResult result = GNOME_VFS_OK;

    if ( !m_bTransient &&
         ( result = doSetFileInfo( &newInfo,
                       (GnomeVFSSetFileInfoMask) setMask,
                       xEnv ) ) != GNOME_VFS_OK ) {
        for (int i = 0; i < nChanged; i++)
            aRet[ i ] <<= mapVFSException( result, sal_True );

    }

    if ( result == GNOME_VFS_OK) {
        gnome_vfs_file_info_copy( &m_info, &newInfo );

        if ( setMask & GNOME_VFS_SET_FILE_INFO_NAME ) {
            uno::Reference< ucb::XContentIdentifier > xNewId
                = new ::ucbhelper::ContentIdentifier(
                    m_xSMgr, makeNewURL( newInfo.name ) );

            aGuard.clear();
            if (!exchangeIdentity( xNewId ) )
                aRet[ nTitlePos ] <<= uno::Exception
                    ( rtl::OUString::createFromAscii( "Exchange failed!" ),
                      static_cast< cppu::OWeakObject * >( this ) );
        }
    }

    gnome_vfs_file_info_clear( &newInfo );

    if ( nChanged > 0 ) {
            aGuard.clear();
        aChanges.realloc( nChanged );
        notifyPropertiesChange( aChanges );
    }

    return aRet;
}

void Content::queryChildren( ContentRefList& rChildren )
{
    // Obtain a list with a snapshot of all currently instanciated contents
    // from provider and extract the contents which are direct children
    // of this content.

    ::ucbhelper::ContentRefList aAllContents;
    m_xProvider->queryExistingContents( aAllContents );

    rtl::OUString aURL = getOUURI();
    sal_Int32 nURLPos = aURL.lastIndexOf( '/' );

    if ( nURLPos != ( aURL.getLength() - 1 ) )
        aURL += rtl::OUString::createFromAscii( "/" );

    sal_Int32 nLen = aURL.getLength();

    ::ucbhelper::ContentRefList::const_iterator it  = aAllContents.begin();
    ::ucbhelper::ContentRefList::const_iterator end = aAllContents.end();

    while ( it != end ) {
        ::ucbhelper::ContentImplHelperRef xChild = (*it);
        rtl::OUString aChildURL
            = xChild->getIdentifier()->getContentIdentifier();

        // Is aURL a prefix of aChildURL?
        if ( ( aChildURL.getLength() > nLen ) &&
             ( aChildURL.compareTo( aURL, nLen ) == 0 ) ) {
            sal_Int32 nPos = nLen;
            nPos = aChildURL.indexOf( '/', nPos );

            if ( ( nPos == -1 ) ||
                 ( nPos == ( aChildURL.getLength() - 1 ) ) ) {
                // No further slashes / only a final slash. It's a child!
                rChildren.push_back( ::gvfs::Content::ContentRef
                             (static_cast< ::gvfs::Content * >(xChild.get() ) ) );
            }
        }
        ++it;
    }
}

void Content::insert(
        const uno::Reference< io::XInputStream >               &xInputStream,
        sal_Bool                                                bReplaceExisting,
        const uno::Reference< ucb::XCommandEnvironment > &xEnv )
        throw( uno::Exception )
{
    osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );

#ifdef DEBUG
    g_warning( "Insert '%s' (%d) (0x%x:%d)", getURI(), bReplaceExisting,
           m_info.valid_fields, m_info.type );
#endif

    GnomeVFSResult result = getInfo( xEnv );
    // a racy design indeed.
    if( !bReplaceExisting && !m_bTransient &&
        result != GNOME_VFS_ERROR_NOT_FOUND) {
#ifdef DEBUG
        g_warning ("Nasty error inserting to '%s' ('%s')",
               getURI(), gnome_vfs_result_to_string( result ));
#endif
        cancelCommandExecution( GNOME_VFS_ERROR_FILE_EXISTS, xEnv, sal_True );
    }

    if ( m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE &&
         m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY ) {
        ::rtl::OString aURI = getOURI();
        int perm;

        perm = ( GNOME_VFS_PERM_USER_ALL |
             GNOME_VFS_PERM_GROUP_READ |
             GNOME_VFS_PERM_OTHER_READ );

#ifdef DEBUG
        g_warning ("Make directory");
#endif
        result = gnome_vfs_make_directory( (const sal_Char *) aURI, perm );

        if( result != GNOME_VFS_OK )
            cancelCommandExecution( result, xEnv, sal_True );

        return;
    }

    if ( !xInputStream.is() ) {
        // FIXME: slightly unclear whether to accept this and create an empty file
        ucbhelper::cancelCommandExecution
            ( uno::makeAny
              ( ucb::MissingInputStreamException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ) ) ),
              xEnv );
    }

    GnomeVFSHandle *handle = NULL;
    ::rtl::OString aURI = getOURI();

    result = GNOME_VFS_OK;
    if ( bReplaceExisting ) {
        Authentication aAuth( xEnv );
        result = gnome_vfs_open( &handle, (const sal_Char *)aURI,
                     GNOME_VFS_OPEN_WRITE );
    }

    if ( result != GNOME_VFS_OK ) {
        int perm;
        Authentication aAuth( xEnv );

        perm = ( ( GNOME_VFS_PERM_USER_WRITE | GNOME_VFS_PERM_USER_READ ) |
             ( GNOME_VFS_PERM_GROUP_WRITE | GNOME_VFS_PERM_GROUP_READ ) );

        result = gnome_vfs_create
            ( &handle, (const sal_Char *)aURI, GNOME_VFS_OPEN_WRITE, TRUE, perm );
    }

    if( result != GNOME_VFS_OK )
        cancelCommandExecution( result, xEnv, sal_True );

    if ( !xInputStream.is() ) {
        result = gnome_vfs_close( handle );
        if (result != GNOME_VFS_OK)
            cancelCommandExecution( result, xEnv, sal_True );

    } else { // copy it over
        uno::Reference < io::XOutputStream > xOutput =
            new gvfs::Stream( handle, &m_info );

        copyData( xInputStream, xOutput );
    }

    if (m_bTransient) {
        m_bTransient = sal_False;
        aGuard.clear();
        inserted();
    }
}

void Content::transfer(const ucb::TransferInfo & /*rArgs*/,
               const uno::Reference< ucb::XCommandEnvironment >& xEnv )
    throw( uno::Exception )
{
    // FIXME: see gnome-vfs-xfer.h - but we need to be able to easily
    // detect which are gnome-vfs owned URI types ...
    ucbhelper::cancelCommandExecution
        ( uno::makeAny
            ( ucb::InteractiveBadTransferURLException
                ( rtl::OUString::createFromAscii( "Unsupported URL scheme!" ),
                  static_cast< cppu::OWeakObject * >( this ) ) ),
          xEnv );
}

void Content::destroy( sal_Bool bDeletePhysical )
    throw( uno::Exception )
{
    // @@@ take care about bDeletePhysical -> trashcan support
    rtl::OUString aURL = getOUURI();

    uno::Reference< ucb::XContent > xThis = this;

    deleted();

    osl::Guard< osl::Mutex > aGuard( m_aMutex );

    // Process instanciated children...
    ::gvfs::Content::ContentRefList aChildren;
    queryChildren( aChildren );

    ContentRefList::const_iterator it  = aChildren.begin();
    ContentRefList::const_iterator end = aChildren.end();

    while ( it != end ) {
        (*it)->destroy( bDeletePhysical );
        ++it;
    }
}

// Used by the 'setPropertyValues' method for
// propagating the renaming of a Content.
sal_Bool Content::exchangeIdentity(
    const uno::Reference< ucb::XContentIdentifier >& xNewId )
{
    if ( !xNewId.is() )
        return sal_False;

    uno::Reference< ucb::XContent > xThis = this;

#ifdef DEBUG
    g_warning( "exchangeIdentity from '%s' to '%s'",
           getURI(), OUStringToGnome( xNewId->getContentIdentifier() ) );
#endif

    if ( m_bTransient ) {
        osl::Guard< osl::Mutex > aGuard( m_aMutex );
        /* FIXME: can we not screw up an identically named
         * Content pointing to ourself here ? */
        m_xIdentifier = xNewId;
        return sal_False;
    }

    rtl::OUString aOldURL = getOUURI();

    // Exchange own identitity.
    if ( exchange( xNewId ) ) {

        // Process instanciated children...
        ContentRefList aChildren;
        queryChildren( aChildren );

        ContentRefList::const_iterator it  = aChildren.begin();
        ContentRefList::const_iterator end = aChildren.end();

        while ( it != end ) {
            ContentRef xChild = (*it);

            // Create new content identifier for the child...
            uno::Reference< ucb::XContentIdentifier >
                xOldChildId = xChild->getIdentifier();
            rtl::OUString aOldChildURL
                = xOldChildId->getContentIdentifier();
            rtl::OUString aNewChildURL
                = aOldChildURL.replaceAt(
                             0,
                             aOldURL.getLength(),
                             xNewId->getContentIdentifier() );
            uno::Reference< ucb::XContentIdentifier >
                xNewChildId
                = new ::ucbhelper::ContentIdentifier( m_xSMgr, aNewChildURL );

            if ( !xChild->exchangeIdentity( xNewChildId ) )
                return sal_False;

            ++it;
        }
        return sal_True;
    }

    return sal_False;
}

GnomeVFSResult
Content::getInfo( const uno::Reference< ucb::XCommandEnvironment >& xEnv )
{
    GnomeVFSResult result;
        osl::Guard< osl::Mutex > aGuard( m_aMutex );

    if (m_bTransient)
        result = GNOME_VFS_OK;

    else if ( !m_info.valid_fields ) {
        ::rtl::OString aURI = getOURI();
        Authentication aAuth( xEnv );
        result = gnome_vfs_get_file_info
            ( (const sal_Char *)aURI, &m_info, GNOME_VFS_FILE_INFO_DEFAULT );
        if (result != GNOME_VFS_OK)
            gnome_vfs_file_info_clear( &m_info );
    } else
        result = GNOME_VFS_OK;
#ifdef DEBUG
    g_warning( "getInfo on '%s' returns '%s' (%d) (0x%x)",
           getURI(), gnome_vfs_result_to_string( result ),
           result, m_info.valid_fields );
#endif
    return result;
}

sal_Bool
Content::isFolder(const uno::Reference< ucb::XCommandEnvironment >& xEnv )
{
        osl::Guard< osl::Mutex > aGuard( m_aMutex );
    getInfo( xEnv );
    return (m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE &&
        m_info.type == GNOME_VFS_FILE_TYPE_DIRECTORY);
}

uno::Any Content::mapVFSException( const GnomeVFSResult result, sal_Bool bWrite )
{
    uno::Any aException;
    const char *gvfs_message;
    rtl::OUString message;
    uno::Sequence< uno::Any > aArgs( 1 );

#ifdef DEBUG
    g_warning ("Map VFS exception '%s' (%d)",
           gnome_vfs_result_to_string( result ), result );
#endif

    if ((gvfs_message = gnome_vfs_result_to_string (result)))
        message = GnomeToOUString( gvfs_message );

    switch (result) {
    case GNOME_VFS_OK:
        g_warning("VFS_OK mapped to exception.");
        break;
    case GNOME_VFS_ERROR_EOF:
        g_warning ("VFS_EOF not handled somewhere.");
        break;
    case GNOME_VFS_ERROR_NOT_FOUND:
        aArgs[ 0 ] <<= m_xIdentifier->getContentIdentifier();
        aException <<=
            ucb::InteractiveAugmentedIOException
            ( rtl::OUString::createFromAscii( "Not found!" ),
              static_cast< cppu::OWeakObject * >( this ),
              task::InteractionClassification_ERROR,
              ucb::IOErrorCode_NOT_EXISTING,
              aArgs );
        break;
    case GNOME_VFS_ERROR_BAD_PARAMETERS:
        aException <<=
            lang::IllegalArgumentException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ),
                  -1 );
        break;
    case GNOME_VFS_ERROR_GENERIC:
    case GNOME_VFS_ERROR_INTERNAL:
    case GNOME_VFS_ERROR_NOT_SUPPORTED:
#ifdef DEBUG
        g_warning ("Internal - un-mapped error");
#endif
        aException <<= io::IOException();
        break;
    case GNOME_VFS_ERROR_IO:
        if ( bWrite )
            aException <<=
                ucb::InteractiveNetworkWriteException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ),
                  task::InteractionClassification_ERROR,
                  message );
        else
            aException <<=
                ucb::InteractiveNetworkReadException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ),
                  task::InteractionClassification_ERROR,
                  message );
        break;
    case GNOME_VFS_ERROR_HOST_NOT_FOUND:
    case GNOME_VFS_ERROR_INVALID_HOST_NAME:
        aException <<=
            ucb::InteractiveNetworkResolveNameException
            ( rtl::OUString(),
              static_cast< cppu::OWeakObject * >( this ),
              task::InteractionClassification_ERROR,
              message );
        break;
    case GNOME_VFS_ERROR_SERVICE_NOT_AVAILABLE:
    case GNOME_VFS_ERROR_SERVICE_OBSOLETE:
    case GNOME_VFS_ERROR_PROTOCOL_ERROR:
    case GNOME_VFS_ERROR_NO_MASTER_BROWSER:
        aException <<=
            ucb::InteractiveNetworkConnectException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ),
                  task::InteractionClassification_ERROR,
                  message );
        break;

    case GNOME_VFS_ERROR_FILE_EXISTS:
        aException <<= ucb::NameClashException
                ( rtl::OUString(),
                  static_cast< cppu::OWeakObject * >( this ),
                  task::InteractionClassification_ERROR,
                  message );
        break;

    case GNOME_VFS_ERROR_INVALID_OPEN_MODE:
        aException <<= ucb::UnsupportedOpenModeException();
        break;

    case GNOME_VFS_ERROR_CORRUPTED_DATA:
    case GNOME_VFS_ERROR_WRONG_FORMAT:
    case GNOME_VFS_ERROR_BAD_FILE:
    case GNOME_VFS_ERROR_TOO_BIG:
    case GNOME_VFS_ERROR_NO_SPACE:
    case GNOME_VFS_ERROR_READ_ONLY:
    case GNOME_VFS_ERROR_INVALID_URI:
    case GNOME_VFS_ERROR_NOT_OPEN:
    case GNOME_VFS_ERROR_ACCESS_DENIED:
    case GNOME_VFS_ERROR_TOO_MANY_OPEN_FILES:
    case GNOME_VFS_ERROR_NOT_A_DIRECTORY:
    case GNOME_VFS_ERROR_IN_PROGRESS:
    case GNOME_VFS_ERROR_INTERRUPTED:
    case GNOME_VFS_ERROR_LOOP:
    case GNOME_VFS_ERROR_NOT_PERMITTED:
    case GNOME_VFS_ERROR_IS_DIRECTORY:
    case GNOME_VFS_ERROR_NO_MEMORY:
    case GNOME_VFS_ERROR_HOST_HAS_NO_ADDRESS:
    case GNOME_VFS_ERROR_LOGIN_FAILED:
    case GNOME_VFS_ERROR_CANCELLED:
    case GNOME_VFS_ERROR_DIRECTORY_BUSY:
    case GNOME_VFS_ERROR_DIRECTORY_NOT_EMPTY:
    case GNOME_VFS_ERROR_TOO_MANY_LINKS:
    case GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM:
    case GNOME_VFS_ERROR_NOT_SAME_FILE_SYSTEM:
    case GNOME_VFS_ERROR_NAME_TOO_LONG:
#ifdef DEBUG
        g_warning( "FIXME: Un-mapped VFS exception '%s' (%d)",
               gnome_vfs_result_to_string( result ), result );
#endif
    default:
        aException <<= ucb::InteractiveNetworkGeneralException
            ( rtl::OUString(),
              static_cast< cppu::OWeakObject * >( this ),
              task::InteractionClassification_ERROR );
        break;
    }

    return aException;
}

void Content::cancelCommandExecution(
    GnomeVFSResult result,
    const uno::Reference< ucb::XCommandEnvironment > & xEnv,
    sal_Bool bWrite /* = sal_False */ )
    throw ( uno::Exception )
{
    ucbhelper::cancelCommandExecution( mapVFSException( result, bWrite ), xEnv );
    // Unreachable
}

uno::Sequence< beans::Property > Content::getProperties(
    const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
{
    static const beans::Property aGenericProperties[] = {
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ContentType" ) ),
                 -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsDocument" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsFolder" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ),
                 -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
                 beans::PropertyAttribute::BOUND ),
        // Optional ...
        beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DateCreated" ) ),
                 -1, getCppuType( static_cast< const util::DateTime * >( 0 ) ),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DateModified" ) ),
                 -1, getCppuType( static_cast< const util::DateTime * >( 0 ) ),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
// FIXME: Too expensive for now (?)
//                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ),
//                 -1, getCppuType( static_cast< const rtl::OUString * >( 0 ) ),
//                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Size" ) ),
                 -1, getCppuType( static_cast< const sal_Int64 * >( 0 ) ),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsReadOnly" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsVolume" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsCompactDisk" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsHidden" ) ),
                 -1, getCppuBooleanType(),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
                beans::Property( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CreatableContentsInfo" ) ),
                 -1, getCppuType( static_cast< const uno::Sequence< ucb::ContentInfo > * >( 0 ) ),
                 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY )
    };

    const int nProps = sizeof (aGenericProperties) / sizeof (aGenericProperties[0]);

    return uno::Sequence< beans::Property > ( aGenericProperties, nProps );

}

uno::Sequence< ucb::CommandInfo > Content::getCommands(
    const uno::Reference< ucb::XCommandEnvironment > & xEnv )
{
    static ucb::CommandInfo aCommandInfoTable[] = {
        // Required commands
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getCommandInfo" ) ),
          -1, getCppuVoidType() ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertySetInfo" ) ),
          -1, getCppuVoidType() ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "getPropertyValues" ) ),
          -1, getCppuType( static_cast<uno::Sequence< beans::Property > * >( 0 ) ) ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "setPropertyValues" ) ),
          -1, getCppuType( static_cast<uno::Sequence< beans::PropertyValue > * >( 0 ) ) ),

        // Optional standard commands
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete" ) ),
          -1, getCppuBooleanType() ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert" ) ),
          -1, getCppuType( static_cast<ucb::InsertCommandArgument * >( 0 ) ) ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "open" ) ),
          -1, getCppuType( static_cast<ucb::OpenCommandArgument2 * >( 0 ) ) ),

        // Folder Only, omitted if not a folder
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "transfer" ) ),
          -1, getCppuType( static_cast<ucb::TransferInfo * >( 0 ) ) ),
        ucb::CommandInfo
        ( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "createNewContent" ) ),
          -1, getCppuType( static_cast<ucb::ContentInfo * >( 0 ) ) )
    };

    const int nProps
        = sizeof( aCommandInfoTable ) / sizeof( aCommandInfoTable[ 0 ] );
    return uno::Sequence< ucb::CommandInfo >(
        aCommandInfoTable, isFolder( xEnv ) ? nProps : nProps - 2 );
}

rtl::OUString
Content::getOUURI ()
{
        osl::Guard< osl::Mutex > aGuard( m_aMutex );
    return m_xIdentifier->getContentIdentifier();
}

rtl::OString
Content::getOURI ()
{
    return rtl::OUStringToOString( getOUURI(), RTL_TEXTENCODING_UTF8 );
}

char *
Content::getURI ()
{
    return OUStringToGnome( getOUURI() );
}

void
Content::copyData( uno::Reference< io::XInputStream > xIn,
                   uno::Reference< io::XOutputStream > xOut )
{
    uno::Sequence< sal_Int8 > theData( TRANSFER_BUFFER_SIZE );

    g_return_if_fail( xIn.is() && xOut.is() );

    while ( xIn->readBytes( theData, TRANSFER_BUFFER_SIZE ) > 0 )
        xOut->writeBytes( theData );

    xOut->closeOutput();
}

// Inherits an authentication context
uno::Reference< io::XInputStream >
Content::createTempStream(
    const uno::Reference< ucb::XCommandEnvironment >& xEnv )
        throw( uno::Exception )
{
    GnomeVFSResult result;
    GnomeVFSHandle *handle = NULL;
    ::rtl::OString aURI = getOURI();

        osl::Guard< osl::Mutex > aGuard( m_aMutex );
    // Something badly wrong happened - can't seek => stream to a temporary file
    const rtl::OUString sServiceName ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.io.TempFile" ) );
    uno::Reference < io::XOutputStream > xTempOut =
        uno::Reference < io::XOutputStream >
            ( m_xSMgr->createInstance( sServiceName ), uno::UNO_QUERY );

    if ( !xTempOut.is() )
        cancelCommandExecution( GNOME_VFS_ERROR_IO, xEnv );

    result = gnome_vfs_open
        ( &handle, (const sal_Char *)aURI, GNOME_VFS_OPEN_READ );
    if (result != GNOME_VFS_OK)
        cancelCommandExecution( result, xEnv );

    uno::Reference < io::XInputStream > pStream = new ::gvfs::Stream( handle, &m_info );
    copyData( pStream, xTempOut );

    return uno::Reference < io::XInputStream > ( xTempOut, uno::UNO_QUERY );
}

uno::Reference< io::XInputStream >
Content::createInputStream(
    const uno::Reference< ucb::XCommandEnvironment >& xEnv )
        throw( uno::Exception )
{
    GnomeVFSHandle *handle = NULL;
    GnomeVFSResult  result;
    uno::Reference<io::XInputStream > xIn;

    Authentication aAuth( xEnv );
        osl::Guard< osl::Mutex > aGuard( m_aMutex );

    getInfo( xEnv );
    ::rtl::OString aURI = getOURI();

    if ( !(m_info.valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) )
        return createTempStream( xEnv );

    result = gnome_vfs_open
        ( &handle, (const sal_Char *)aURI,
          (GnomeVFSOpenMode) (GNOME_VFS_OPEN_READ | GNOME_VFS_OPEN_RANDOM ) );

    if (result == GNOME_VFS_ERROR_INVALID_OPEN_MODE ||
        result == GNOME_VFS_ERROR_NOT_SUPPORTED)
        return createTempStream( xEnv );

    if (result != GNOME_VFS_OK)
        cancelCommandExecution( result, xEnv );

    // Try a seek just to make sure it's Random access: some lie.
    result = gnome_vfs_seek( handle, GNOME_VFS_SEEK_START, 0);
    if (result == GNOME_VFS_ERROR_NOT_SUPPORTED) {
        gnome_vfs_close( handle );
        return createTempStream( xEnv );
    }

    if (result != GNOME_VFS_OK)
        cancelCommandExecution( result, xEnv );

    if (handle != NULL)
        xIn = new ::gvfs::Stream( handle, &m_info );

    return xIn;
}

sal_Bool
Content::feedSink( uno::Reference< uno::XInterface > aSink,
                   const uno::Reference< ucb::XCommandEnvironment >& xEnv )
{
    if ( !aSink.is() )
        return sal_False;

    uno::Reference< io::XOutputStream > xOut
        = uno::Reference< io::XOutputStream >(aSink, uno::UNO_QUERY );
    uno::Reference< io::XActiveDataSink > xDataSink
        = uno::Reference< io::XActiveDataSink >(aSink, uno::UNO_QUERY );

    if ( !xOut.is() && !xDataSink.is() )
        return sal_False;

    uno::Reference< io::XInputStream > xIn = createInputStream( xEnv );
    if ( !xIn.is() )
        return sal_False;

    if ( xOut.is() )
        copyData( xIn, xOut );

    if ( xDataSink.is() )
        xDataSink->setInputStream( xIn );

    return sal_True;
}

extern "C" {

#ifndef GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION
#  error "We require Gnome VFS 2.6.x to compile (will run fine with < 2.6)"
#endif

    static void
    vfs_authentication_callback (gconstpointer in_void,
                     gsize         in_size,
                     gpointer      out_void,
                     gsize         out_size,
                     gpointer      callback_data)
    {
        task::XInteractionHandler *xIH;

#ifdef DEBUG
        g_warning ("Full authentication callback (%p) ...", callback_data);
#endif

        if( !( xIH = (task::XInteractionHandler *) callback_data ) )
            return;

        const GnomeVFSModuleCallbackFullAuthenticationIn *in =
            (const GnomeVFSModuleCallbackFullAuthenticationIn *) in_void;
        GnomeVFSModuleCallbackFullAuthenticationOut *out =
            (GnomeVFSModuleCallbackFullAuthenticationOut *) out_void;

        g_return_if_fail (in != NULL && out != NULL);
        g_return_if_fail (sizeof (GnomeVFSModuleCallbackFullAuthenticationIn) == in_size &&
                  sizeof (GnomeVFSModuleCallbackFullAuthenticationOut) == out_size);

#ifdef DEBUG
#  define NNIL(x) (x?x:"<Null>")
        g_warning (" InComing data 0x%x uri '%s' prot '%s' server '%s' object '%s' "
                   "port %d auth_t '%s' user '%s' domain '%s' "
                   "def user '%s', def domain '%s'",
                   (int) in->flags, NNIL(in->uri), NNIL(in->protocol),
                   NNIL(in->server), NNIL(in->object),
                   (int) in->port, NNIL(in->authtype), NNIL(in->username), NNIL(in->domain),
                   NNIL(in->default_user), NNIL(in->default_domain));
#  undef NNIL
#endif

        ucbhelper::SimpleAuthenticationRequest::EntityType
                                   eDomain, eUserName, ePassword;
        ::rtl::OUString aHostName, aDomain, aUserName, aPassword;

        aHostName = GnomeToOUString( in->server );

        if (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_DOMAIN)
        {
            aDomain = GnomeToOUString( in->domain );
            eDomain = ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY;
            if (!aDomain.getLength())
                aDomain = GnomeToOUString( in->default_domain );
        }
        else // no underlying capability to display realm otherwise
            eDomain = ucbhelper::SimpleAuthenticationRequest::ENTITY_NA;

        aUserName = GnomeToOUString( in->username );
        if (!aUserName.getLength())
            aUserName = GnomeToOUString( in->default_user );
        eUserName = (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_USERNAME) ?
            ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY :
                (aUserName.getLength() ?
                    ucbhelper::SimpleAuthenticationRequest::ENTITY_FIXED :
                    ucbhelper::SimpleAuthenticationRequest::ENTITY_NA);

        // No suggested password.
        ePassword = (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_PASSWORD) ?
            ucbhelper::SimpleAuthenticationRequest::ENTITY_MODIFY :
            ucbhelper::SimpleAuthenticationRequest::ENTITY_FIXED;

        // Really, really bad things happen if we don't provide
        // the same user/password as was entered last time if
        // we failed to authenticate - infinite looping / flickering
        // madness etc. [ nice infrastructure ! ]
        static rtl::OUString aLastUserName, aLastPassword;
        if (in->flags & GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_PREVIOUS_ATTEMPT_FAILED)
        {
            osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
            aUserName = aLastUserName;
            aPassword = aLastPassword;
        }

        rtl::Reference< ucbhelper::SimpleAuthenticationRequest > xRequest
            = new ucbhelper::SimpleAuthenticationRequest (GnomeToOUString(in->uri),
                                                          aHostName, eDomain, aDomain,
                                                          eUserName, aUserName,
                                                          ePassword, aPassword);

        xIH->handle( xRequest.get() );

        rtl::Reference< ucbhelper::InteractionContinuation > xSelection
            = xRequest->getSelection();

        if ( xSelection.is() ) {
            // Handler handled the request.
            uno::Reference< task::XInteractionAbort > xAbort(xSelection.get(), uno::UNO_QUERY );
            if ( !xAbort.is() ) {
                const rtl::Reference<
                    ucbhelper::InteractionSupplyAuthentication > & xSupp
                    = xRequest->getAuthenticationSupplier();

                aUserName = xSupp->getUserName();
                aDomain   = xSupp->getRealm();
                aPassword = xSupp->getPassword();

                {
                    osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
                    aLastUserName = aUserName;
                    aLastPassword = aPassword;
                }

                out->username = OUStringToGnome( aUserName );
                out->domain   = OUStringToGnome( aDomain );
                out->password = OUStringToGnome( aPassword );
                out->save_password = xSupp->getRememberPasswordMode();

#ifdef DEBUG
                g_warning ("Got valid user/domain/password '%s' '%s' '%s', %s password",
                           out->username, out->domain, out->password,
                           out->save_password ? "save" : "don't save");
#endif
            }
            else
                out->abort_auth = TRUE;
        }
        else
            out->abort_auth = TRUE;
    }

    static void
    vfs_authentication_old_callback (gconstpointer in_void,
                                     gsize         in_size,
                                     gpointer      out_void,
                                     gsize         out_size,
                                     gpointer      callback_data)
    {
#ifdef DEBUG
        g_warning ("Old authentication callback (%p) [ UNTESTED ] ...", callback_data);
#endif
        const GnomeVFSModuleCallbackAuthenticationIn *in =
            (const GnomeVFSModuleCallbackAuthenticationIn *) in_void;
        GnomeVFSModuleCallbackAuthenticationOut *out =
            (GnomeVFSModuleCallbackAuthenticationOut *) out_void;

        g_return_if_fail (in != NULL && out != NULL);
        g_return_if_fail (sizeof (GnomeVFSModuleCallbackAuthenticationIn) == in_size &&
                  sizeof (GnomeVFSModuleCallbackAuthenticationOut) == out_size);

        GnomeVFSModuleCallbackFullAuthenticationIn mapped_in = {
                (GnomeVFSModuleCallbackFullAuthenticationFlags)
                (GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_PASSWORD |
                 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_USERNAME |
                 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_NEED_DOMAIN),
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        GnomeVFSModuleCallbackFullAuthenticationOut mapped_out = { 0, 0, 0, 0, 0, 0, 0, 0 };

        // Map the old style input auth. data to the new style structure.
        if (in->previous_attempt_failed)
            mapped_in.flags = (GnomeVFSModuleCallbackFullAuthenticationFlags)
                (mapped_in.flags |
                 GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION_PREVIOUS_ATTEMPT_FAILED);

        GnomeVFSURI *pURI = NULL;
        // Urk - parse all this from the URL ...
        mapped_in.uri = in->uri;
        if (in->uri)
        {
            pURI = gnome_vfs_uri_new( in->uri );
            mapped_in.protocol = (char *) gnome_vfs_uri_get_scheme (pURI);
            mapped_in.server   = (char *) gnome_vfs_uri_get_host_name (pURI);
            mapped_in.port     = gnome_vfs_uri_get_host_port (pURI);
            mapped_in.username = (char *) gnome_vfs_uri_get_user_name (pURI);
        }
        mapped_in.domain = in->realm;
        mapped_in.default_user = mapped_in.username;
        mapped_in.default_domain = mapped_in.domain;

        vfs_authentication_callback ((gconstpointer) &mapped_in,
                                     sizeof (mapped_in),
                                     (gpointer) &mapped_out,
                                     sizeof (mapped_out),
                                     callback_data);

        if (pURI)
            gnome_vfs_uri_unref (pURI);

        // Map the new style auth. out data to the old style out structure.
        out->username = mapped_out.username;
        out->password = mapped_out.password;
        g_free (mapped_out.domain);
        g_free (mapped_out.keyring);
    }


    static void
    auth_destroy (gpointer data)
    {
        task::XInteractionHandler *xIH;
        if( ( xIH = ( task::XInteractionHandler * )data ) )
            xIH->release();
    }

    // This sucks, but gnome-vfs doesn't much like
    // repeated set / unsets - so we have to compensate.
    GPrivate *auth_queue = NULL;

    void auth_queue_destroy( gpointer data )
    {
        GList  *l;
        GQueue *vq = (GQueue *) data;

        for (l = vq->head; l; l = l->next)
            auth_destroy (l->data);
        g_queue_free (vq);
    }
}

static void
refresh_auth( GQueue *vq )
{
    GList *l;

    gnome_vfs_module_callback_pop( GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION );
    gnome_vfs_module_callback_pop( GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION );

    for (l = vq->head; l; l = l->next) {
        if (l->data) {
            gnome_vfs_module_callback_push
                ( GNOME_VFS_MODULE_CALLBACK_AUTHENTICATION,
                  vfs_authentication_old_callback, l->data, NULL );
            gnome_vfs_module_callback_push
                ( GNOME_VFS_MODULE_CALLBACK_FULL_AUTHENTICATION,
                  vfs_authentication_callback, l->data, NULL );
            break;
        }
    }
}

gvfs::Authentication::Authentication(
    const uno::Reference< ucb::XCommandEnvironment > & xEnv )
{
    GQueue *vq;
    uno::Reference< task::XInteractionHandler > xIH;

    if ( xEnv.is() )
        xIH = xEnv->getInteractionHandler();

    if ( xIH.is() )
        xIH->acquire();

    if( !(vq = (GQueue *)g_private_get( auth_queue ) ) ) {
        vq = g_queue_new();
        g_private_set( auth_queue, vq );
    }

    g_queue_push_head( vq, (gpointer) xIH.get() );
    refresh_auth( vq );
}

gvfs::Authentication::~Authentication()
{
    GQueue *vq;
    gpointer data;

    vq = (GQueue *)g_private_get( auth_queue );

    data = g_queue_pop_head( vq );
    auth_destroy (data);

    refresh_auth( vq );
}