xref: /trunk/main/filter/source/xsltdialog/xmlfilterjar.cxx (revision 2eda3cbf)

/**************************************************************
 *
 * 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_filter.hxx"
#include <com/sun/star/io/XActiveDataControl.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/frame/XConfigManager.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/io/XActiveDataSink.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/container/XChild.hpp>
#include <com/sun/star/util/XChangesBatch.hpp>


#include <comphelper/oslfile2streamwrap.hxx>
#include <comphelper/storagehelper.hxx>
#include <unotools/streamwrap.hxx>
#include <tools/stream.hxx>
#include <tools/urlobj.hxx>
#include <unotools/tempfile.hxx>
#include <svl/urihelper.hxx>
#include <osl/file.hxx>

#include <rtl/uri.hxx>

#include "xmlfilterjar.hxx"
#include "xmlfilterdialogstrings.hrc"
#include "xmlfiltersettingsdialog.hxx"
#include "typedetectionexport.hxx"
#include "typedetectionimport.hxx"

using namespace rtl;
using namespace osl;
using namespace comphelper;
using namespace com::sun::star;
using namespace com::sun::star::lang;
using namespace com::sun::star::frame;
using namespace com::sun::star::uno;
using namespace com::sun::star::util;
using namespace com::sun::star::container;
using namespace com::sun::star::beans;
using namespace com::sun::star::io;

XMLFilterJarHelper::XMLFilterJarHelper( Reference< XMultiServiceFactory >& xMSF )
: mxMSF( xMSF ),
	sVndSunStarPackage( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) ),
	sXSLTPath( RTL_CONSTASCII_USTRINGPARAM( "$(user)/xslt/" ) ),
	sDTDPath( RTL_CONSTASCII_USTRINGPARAM( "$(user)/dtd/" ) ),
	sTemplatePath( RTL_CONSTASCII_USTRINGPARAM( "$(user)/template/") ),
	sSpecialConfigManager( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.config.SpecialConfigManager" ) ),
	sPump( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.io.Pump" ) ),
	sProgPath( RTL_CONSTASCII_USTRINGPARAM( "$(prog)/" ) )
{
	try
	{
		Reference< XConfigManager > xCfgMgr( xMSF->createInstance(OUString::createFromAscii("com.sun.star.config.SpecialConfigManager")), UNO_QUERY );
		if( xCfgMgr.is() )
		{
			sProgPath = xCfgMgr->substituteVariables( sProgPath );
			sXSLTPath = xCfgMgr->substituteVariables( sXSLTPath );
			sDTDPath = xCfgMgr->substituteVariables( sDTDPath );
			sTemplatePath = xCfgMgr->substituteVariables( sTemplatePath );
		}
	}
	catch(Exception&)
	{
	}
}

static OUString encodeZipUri( const OUString& rURI )
{
	return Uri::encode( rURI, rtl_UriCharClassUric, rtl_UriEncodeCheckEscapes, RTL_TEXTENCODING_UTF8 );
}

static Reference< XInterface > addFolder( Reference< XInterface >& xRootFolder, Reference< XSingleServiceFactory >& xFactory, const OUString& rName ) throw( Exception )
{
	if ( rName.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( ".." ) ) )
	  || rName.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ) )
		throw lang::IllegalArgumentException();

	Sequence< Any > aArgs(1);
	aArgs[0] <<= (sal_Bool)sal_True;

	Reference< XInterface > xFolder( xFactory->createInstanceWithArguments(aArgs) );
	Reference< XNamed > xNamed( xFolder, UNO_QUERY );
	Reference< XChild > xChild( xFolder, UNO_QUERY );

	if( xNamed.is() && xChild.is() )
	{
		OUString aName( encodeZipUri( rName ) );
		xNamed->setName( aName );
		xChild->setParent( xRootFolder );
	}

	return xFolder;
}

static void _addFile( Reference< XInterface >& xRootFolder, Reference< XSingleServiceFactory >& xFactory, Reference< XInputStream >& xInput, OUString aName ) throw( Exception )
{

	Reference< XActiveDataSink > xSink( xFactory->createInstance(), UNO_QUERY );
	Reference< XUnoTunnel > xTunnel( xSink, UNO_QUERY );
	if( xSink.is() && xTunnel.is())
	{
		Reference< XNameContainer > xNameContainer(xRootFolder, UNO_QUERY );
		xNameContainer->insertByName(aName = encodeZipUri( aName ), makeAny(xTunnel));
		xSink->setInputStream( xInput );
	}
}

/*
static void addFile( Reference< XInterface > xRootFolder, Reference< XSingleServiceFactory > xFactory, const OUString& rSourceFile, const OUString& rName ) throw( Exception )
{
	Reference< XInputStream > xInput( new utl::OSeekableInputStreamWrapper( new SvFileStream(rSourceFile, STREAM_READ ), true ) );
	_addFile( xRootFolder, xFactory, xInput, rName );
}
*/

void XMLFilterJarHelper::addFile( Reference< XInterface > xRootFolder, Reference< XSingleServiceFactory > xFactory, const OUString& rSourceFile ) throw( Exception )
{
	if( rSourceFile.getLength() &&
		(rSourceFile.compareToAscii( RTL_CONSTASCII_STRINGPARAM("http:") ) != 0) &&
		(rSourceFile.compareToAscii( RTL_CONSTASCII_STRINGPARAM("shttp:") ) != 0) &&
		(rSourceFile.compareToAscii( RTL_CONSTASCII_STRINGPARAM("jar:") ) != 0) &&
		(rSourceFile.compareToAscii( RTL_CONSTASCII_STRINGPARAM("ftp:") ) != 0))
	{
		OUString aFileURL( rSourceFile );

		if( !aFileURL.matchIgnoreAsciiCase( OUString( RTL_CONSTASCII_USTRINGPARAM("file://") ) ) )
		{
			aFileURL = URIHelper::SmartRel2Abs( sProgPath, aFileURL, Link(), false );
		}

		INetURLObject aURL( aFileURL );
		OUString aName( aURL.getName() );

		SvFileStream* pStream = new SvFileStream(aFileURL, STREAM_READ );
		Reference< XInputStream > xInput( new utl::OSeekableInputStreamWrapper( pStream, true ) );
		_addFile( xRootFolder, xFactory, xInput, aName );
	}
}

bool XMLFilterJarHelper::savePackage( const OUString& rPackageURL, const XMLFilterVector& rFilters )
{
	try
	{
		osl::File::remove( rPackageURL );

		// create the package jar file

		Sequence< Any > aArguments( 2 );
		aArguments[ 0 ] <<= rPackageURL;

		// let ZipPackage be used ( no manifest.xml is required )
		beans::NamedValue aArg;
		aArg.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) );
		aArg.Value <<= ZIP_STORAGE_FORMAT_STRING;
		aArguments[ 1 ] <<= aArg;

		Reference< XHierarchicalNameAccess > xIfc(
			mxMSF->createInstanceWithArguments(
				rtl::OUString::createFromAscii(
								"com.sun.star.packages.comp.ZipPackage" ),
				aArguments ), UNO_QUERY );

		if( xIfc.is() )
		{
			Reference< XSingleServiceFactory > xFactory( xIfc, UNO_QUERY );

			// get root zip folder
			Reference< XInterface > xRootFolder;
			OUString szRootFolder( RTL_CONSTASCII_USTRINGPARAM("/") );
			xIfc->getByHierarchicalName( szRootFolder ) >>= xRootFolder;

			// export filters files
			XMLFilterVector::const_iterator aIter( rFilters.begin() );
			while( aIter != rFilters.end() )
			{
				const filter_info_impl* pFilter = (*aIter);

				Reference< XInterface > xFilterRoot( addFolder( xRootFolder, xFactory, pFilter->maFilterName ) );

				if( xFilterRoot.is() )
				{
					if( pFilter->maDTD.getLength() )
						addFile( xFilterRoot, xFactory, pFilter->maDTD );

					if( pFilter->maExportXSLT.getLength() )
						addFile( xFilterRoot, xFactory, pFilter->maExportXSLT );
					try
					{
						if( pFilter->maImportXSLT.getLength() )
							addFile( xFilterRoot, xFactory, pFilter->maImportXSLT );
					}
					catch( com::sun::star::container::ElementExistException&)
					{
					// in case of same named import / export XSLT the latter
					// is ignored
						DBG_ERROR( "XMLFilterJarHelper::same named xslt filter exception!" );
					}

					if( pFilter->maImportTemplate.getLength() )
						addFile( xFilterRoot, xFactory, pFilter->maImportTemplate );
				}

				aIter++;
			}

			// create TypeDetection.xcu
			utl::TempFile aTempFile;
			aTempFile.EnableKillingFile();
			OUString aTempFileURL( aTempFile.GetURL() );

			{
				osl::File aOutputFile( aTempFileURL );
				/* osl::File::RC rc = */ aOutputFile.open( OpenFlag_Write );
				Reference< XOutputStream > xOS( new OSLOutputStreamWrapper( aOutputFile ) );

				TypeDetectionExporter aExporter( mxMSF );
				aExporter.doExport(xOS,rFilters);
			}

			Reference< XInputStream > XIS( new utl::OSeekableInputStreamWrapper( new SvFileStream(aTempFileURL, STREAM_READ ), true ) );
			OUString szTypeDetection( RTL_CONSTASCII_USTRINGPARAM( "TypeDetection.xcu" ) );
			_addFile( xRootFolder, xFactory, XIS, szTypeDetection );

			Reference< XChangesBatch > xBatch( xIfc, UNO_QUERY );
			if( xBatch.is() )
				xBatch->commitChanges();

			return true;
		}
	}
	catch( Exception& )
	{
		DBG_ERROR( "XMLFilterJarHelper::savePackage exception caught!" );
	}

	osl::File::remove( rPackageURL );

	return false;
}



//

void XMLFilterJarHelper::openPackage( const OUString& rPackageURL, XMLFilterVector& rFilters )
{
	try
	{
		// create the package jar file

		Sequence< Any > aArguments( 2 );
		aArguments[ 0 ] <<= rPackageURL;

		// let ZipPackage be used ( no manifest.xml is required )
		beans::NamedValue aArg;
		aArg.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StorageFormat" ) );
		aArg.Value <<= ZIP_STORAGE_FORMAT_STRING;
		aArguments[ 1 ] <<= aArg;

		Reference< XHierarchicalNameAccess > xIfc(
			mxMSF->createInstanceWithArguments(
				rtl::OUString::createFromAscii(
								"com.sun.star.packages.comp.ZipPackage" ),
				aArguments ), UNO_QUERY );

		if( xIfc.is() )
		{
			Reference< XSingleServiceFactory > xFactory( xIfc, UNO_QUERY );

			// get root zip folder
			Reference< XInterface > xRootFolder;
			OUString szRootFolder( RTL_CONSTASCII_USTRINGPARAM("/") );
			xIfc->getByHierarchicalName( szRootFolder ) >>= xRootFolder;

			OUString szTypeDetection( RTL_CONSTASCII_USTRINGPARAM("TypeDetection.xcu") );
			if( xIfc->hasByHierarchicalName( szTypeDetection ) )
			{
				Reference< XActiveDataSink > xTypeDetection;
				xIfc->getByHierarchicalName( szTypeDetection ) >>= xTypeDetection;

				if( xTypeDetection.is() )
				{
					Reference< XInputStream > xIS( xTypeDetection->getInputStream() );

					XMLFilterVector aFilters;
					TypeDetectionImporter::doImport( mxMSF, xIS, aFilters );

					// copy all files used by the filters imported from the
					// typedetection to office/user/xslt
					XMLFilterVector::iterator aIter( aFilters.begin() );
					while( aIter != aFilters.end() )
					{
						if( copyFiles( xIfc, (*aIter) ) )
						{
							rFilters.push_back( (*aIter) );
						}
						else
						{
							// failed to copy all files
							delete (*aIter);
						}
						aIter++;
					}
				}
			}
		}
	}
	catch( Exception& )
	{
		DBG_ERROR( "XMLFilterJarHelper::savePackage exception caught!" );
	}
}

bool XMLFilterJarHelper::copyFiles( Reference< XHierarchicalNameAccess > xIfc, filter_info_impl* pFilter )
{
	bool bOk = copyFile( xIfc, pFilter->maDTD, sDTDPath );

	if( bOk )
		bOk = copyFile( xIfc, pFilter->maExportXSLT, sXSLTPath );

	if( bOk )
		bOk = copyFile( xIfc, pFilter->maImportXSLT, sXSLTPath );

	if( bOk )
		bOk = copyFile( xIfc, pFilter->maImportTemplate, sTemplatePath );

	return bOk;
}

bool XMLFilterJarHelper::copyFile( Reference< XHierarchicalNameAccess > xIfc, OUString& rURL, const OUString& rTargetURL )
{
	if( !rURL.matchIgnoreAsciiCase( sVndSunStarPackage ) )
		return true;

	try
	{
		OUString szPackagePath( encodeZipUri( rURL.copy( sVndSunStarPackage.getLength() ) ) );

		if ( ::comphelper::OStorageHelper::PathHasSegment( szPackagePath, OUString( RTL_CONSTASCII_USTRINGPARAM( ".." ) ) )
		  || ::comphelper::OStorageHelper::PathHasSegment( szPackagePath, OUString( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ) )
			throw lang::IllegalArgumentException();

		if( xIfc->hasByHierarchicalName( szPackagePath ) )
		{
			Reference< XActiveDataSink > xFileEntry;
			xIfc->getByHierarchicalName( szPackagePath ) >>= xFileEntry;

			if( xFileEntry.is() )
			{
				Reference< XInputStream > xIS( xFileEntry->getInputStream() );

				INetURLObject aBaseURL( rTargetURL );

				rURL = URIHelper::SmartRel2Abs( aBaseURL, szPackagePath, Link(), false );

				if( rURL.getLength() )
				{
					// create output directory if needed
					if( !createDirectory( rURL ) )
						return false;

					::osl::File file(rURL);
					::osl::FileBase::RC rc =
						file.open(OpenFlag_Write|OpenFlag_Create);
					if (::osl::FileBase::E_EXIST == rc) {
						rc = file.open(OpenFlag_Write);
						if (::osl::FileBase::E_None == rc) {
							file.setSize(0); // #i97170# truncate
						}
					}
					if (::osl::FileBase::E_None != rc) {
						throw RuntimeException();
					}
					Reference< XOutputStream > const xOS(
							new comphelper::OSLOutputStreamWrapper(file));

					return copyStreams( xIS, xOS );
				}
			}
		}
	}
	catch( Exception& )
	{
		DBG_ERROR( "XMLFilterJarHelper::copyFile exception caught" );
	}
	return false;
}