AOO410/main/basic/source/runtime/iosys.cxx

/**************************************************************
 * 
 * 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_basic.hxx"
#include <vcl/dialog.hxx>
#include <vcl/edit.hxx>
#ifndef _SV_BUTTON_HXX //autogen
#include <vcl/button.hxx>
#endif
#include <vcl/msgbox.hxx>
#include <vcl/svapp.hxx>
#include <osl/security.h>
#include <osl/file.hxx>
#include <tools/urlobj.hxx>
#include <vos/mutex.hxx>

#include "runtime.hxx"

#ifdef _USE_UNO

// <-- encoding
#include <sal/alloca.h>

#include <ctype.h>
#include <rtl/byteseq.hxx>
#include <rtl/textenc.h>
#include <rtl/ustrbuf.hxx>
#include <rtl/textenc.h>
#include <rtl/ustrbuf.hxx>
// encoding -->
#include <comphelper/processfactory.hxx>

#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
#include <com/sun/star/ucb/XContentProvider.hpp>
#include <com/sun/star/ucb/XContentProviderManager.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <com/sun/star/io/XStream.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/bridge/XBridge.hpp>
#include <com/sun/star/bridge/XBridgeFactory.hpp>

using namespace comphelper;
using namespace osl;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::ucb;
using namespace com::sun::star::io;
using namespace com::sun::star::bridge;

#endif /* _USE_UNO */

#include "iosys.hxx"
#include "sbintern.hxx"

// Der Input-Dialog:

class SbiInputDialog : public ModalDialog {
	Edit aInput;
	OKButton aOk;
	CancelButton aCancel;
	String aText;
	DECL_LINK( Ok, Window * );
	DECL_LINK( Cancel, Window * );
public:
	SbiInputDialog( Window*, const String& );
	const String& GetInput() { return aText; }
};

SbiInputDialog::SbiInputDialog( Window* pParent, const String& rPrompt )
			:ModalDialog( pParent, WB_3DLOOK | WB_MOVEABLE | WB_CLOSEABLE ),
			 aInput( this, WB_3DLOOK | WB_LEFT | WB_BORDER ),
			 aOk( this ), aCancel( this )
{
	SetText( rPrompt );
	aOk.SetClickHdl( LINK( this, SbiInputDialog, Ok ) );
	aCancel.SetClickHdl( LINK( this, SbiInputDialog, Cancel ) );
	SetMapMode( MapMode( MAP_APPFONT ) );

	Point aPt = LogicToPixel( Point( 50, 50 ) );
	Size  aSz = LogicToPixel( Size( 145, 65 ) );
	SetPosSizePixel( aPt, aSz );
	aPt = LogicToPixel( Point( 10, 10 ) );
	aSz = LogicToPixel( Size( 120, 12 ) );
	aInput.SetPosSizePixel( aPt, aSz );
	aPt = LogicToPixel( Point( 15, 30 ) );
	aSz = LogicToPixel( Size( 45, 15) );
	aOk.SetPosSizePixel( aPt, aSz );
	aPt = LogicToPixel( Point( 80, 30 ) );
	aSz = LogicToPixel( Size( 45, 15) );
	aCancel.SetPosSizePixel( aPt, aSz );

	aInput.Show();
	aOk.Show();
	aCancel.Show();
}

IMPL_LINK_INLINE_START( SbiInputDialog, Ok, Window *, pWindow )
{
    (void)pWindow;

	aText = aInput.GetText();
	EndDialog( 1 );
	return 0;
}
IMPL_LINK_INLINE_END( SbiInputDialog, Ok, Window *, pWindow )

IMPL_LINK_INLINE_START( SbiInputDialog, Cancel, Window *, pWindow )
{
    (void)pWindow;

	EndDialog( 0 );
	return 0;
}
IMPL_LINK_INLINE_END( SbiInputDialog, Cancel, Window *, pWindow )

//////////////////////////////////////////////////////////////////////////

SbiStream::SbiStream()
	: pStrm( 0 )
{
}

SbiStream::~SbiStream()
{
	delete pStrm;
}

// Ummappen eines SvStream-Fehlers auf einen StarBASIC-Code

void SbiStream::MapError()
{
	if( pStrm )
	 switch( pStrm->GetError() )
	 {
		case SVSTREAM_OK:
			nError = 0; break;
		case SVSTREAM_FILE_NOT_FOUND:
			nError = SbERR_FILE_NOT_FOUND; break;
		case SVSTREAM_PATH_NOT_FOUND:
			nError = SbERR_PATH_NOT_FOUND; break;
		case SVSTREAM_TOO_MANY_OPEN_FILES:
			nError = SbERR_TOO_MANY_FILES; break;
		case SVSTREAM_ACCESS_DENIED:
			nError = SbERR_ACCESS_DENIED; break;
		case SVSTREAM_INVALID_PARAMETER:
			nError = SbERR_BAD_ARGUMENT; break;
		case SVSTREAM_OUTOFMEMORY:
			nError = SbERR_NO_MEMORY; break;
		default:
			nError = SbERR_IO_ERROR; break;
	}
}

#ifdef _USE_UNO

// TODO: Code is copied from daemons2/source/uno/asciiEncoder.cxx

::rtl::OUString findUserInDescription( const ::rtl::OUString& aDescription )
{
	::rtl::OUString user;

	sal_Int32 index;
	sal_Int32 lastIndex = 0;

	do
	{
		index = aDescription.indexOf((sal_Unicode) ',', lastIndex);
		::rtl::OUString token = (index == -1) ? aDescription.copy(lastIndex) : aDescription.copy(lastIndex, index - lastIndex);

		lastIndex = index + 1;

		sal_Int32 eindex = token.indexOf((sal_Unicode)'=');
		::rtl::OUString left = token.copy(0, eindex).toAsciiLowerCase().trim();
		::rtl::OUString right = INetURLObject::decode( token.copy(eindex + 1).trim(), '%',
							INetURLObject::DECODE_WITH_CHARSET );

		if(left.equals(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("user"))))
		{
			user = right;
			break;
		}
	}
	while(index != -1);

	return user;
}

#endif


// Hack for #83750
sal_Bool runsInSetup( void );

sal_Bool needSecurityRestrictions( void )
{
#ifdef _USE_UNO
	static sal_Bool bNeedInit = sal_True;
	static sal_Bool bRetVal = sal_True;

	if( bNeedInit )
	{
        // Hack for #83750, use internal flag until
        // setup provides own service manager
        if( runsInSetup() )
		{
			// Setup is not critical
			bRetVal = sal_False;
			return bRetVal;
		}

		bNeedInit = sal_False;

		// Get system user to compare to portal user
		oslSecurity aSecurity = osl_getCurrentSecurity();
		::rtl::OUString aSystemUser;
		sal_Bool bRet = osl_getUserName( aSecurity, &aSystemUser.pData );
		if( !bRet )
		{
			// No valid security! -> Secure mode!
			return sal_True;
		}

		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
		if( !xSMgr.is() )
			return sal_True;
		Reference< XBridgeFactory > xBridgeFac( xSMgr->createInstance
			( ::rtl::OUString::createFromAscii( "com.sun.star.bridge.BridgeFactory" ) ), UNO_QUERY );

		Sequence< Reference< XBridge > > aBridgeSeq;
		sal_Int32 nBridgeCount = 0;
		if( xBridgeFac.is() )
		{
			aBridgeSeq = xBridgeFac->getExistingBridges();
			nBridgeCount = aBridgeSeq.getLength();
		}

		if( nBridgeCount == 0 )
		{
			// No bridges -> local
			bRetVal = sal_False;
			return bRetVal;
		}

		// Iterate through all bridges to find (portal) user property
		const Reference< XBridge >* pBridges = aBridgeSeq.getConstArray();
		bRetVal = sal_False;	// Now only sal_True if user different from portal user is found
		sal_Int32 i;
		for( i = 0 ; i < nBridgeCount ; i++ )
		{
			const Reference< XBridge >& rxBridge = pBridges[ i ];
			::rtl::OUString aDescription = rxBridge->getDescription();
			::rtl::OUString aPortalUser = findUserInDescription( aDescription );
			if( !aPortalUser.isEmpty() )
			{
				// User Found, compare to system user
				if( aPortalUser == aSystemUser )
				{
					// Same user -> system security is ok, bRetVal stays FALSE
					break;
				}
				else
				{
					// Different user -> Secure mode!
					bRetVal = sal_True;
					break;
				}
			}
		}
		// No user found or PortalUser != SystemUser -> Secure mode! (Keep default value)
	}

	return bRetVal;
#else
	return sal_False;
#endif
}

// Returns sal_True if UNO is available, otherwise the old file
// system implementation has to be used
// #89378 New semantic: Don't just ask for UNO but for UCB
sal_Bool hasUno( void )
{
#ifdef _USE_UNO
	static sal_Bool bNeedInit = sal_True;
	static sal_Bool bRetVal = sal_True;

	if( bNeedInit )
	{
		bNeedInit = sal_False;
		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
		if( !xSMgr.is() )
        {
            // No service manager at all
			bRetVal = sal_False;
        }
        else
        {
	        Reference< XContentProviderManager > xManager( xSMgr->createInstance( ::rtl::OUString::createFromAscii
                    ( "com.sun.star.ucb.UniversalContentBroker" ) ), UNO_QUERY );

	        if ( !( xManager.is() && xManager->queryContentProvider( ::rtl::OUString::createFromAscii( "file:///" ) ).is() ) )
            {
                // No UCB
                bRetVal = sal_False;
            }
        }
	}
	return bRetVal;
#else
	return sal_False;
#endif
}



#ifndef _OLD_FILE_IMPL

class OslStream : public SvStream
{
	File maFile;
	short mnStrmMode;

public:
					OslStream( const String& rName, short nStrmMode );
					~OslStream();
	virtual sal_uIntPtr	GetData( void* pData, sal_uIntPtr nSize );
	virtual sal_uIntPtr	PutData( const void* pData, sal_uIntPtr nSize );
	virtual sal_uIntPtr	SeekPos( sal_uIntPtr nPos );
	virtual void	FlushData();
	virtual void	SetSize( sal_uIntPtr nSize );
};

OslStream::OslStream( const String& rName, short nStrmMode )
	: maFile( rName )
	, mnStrmMode( nStrmMode )
{
	sal_uInt32 nFlags;

	if( (nStrmMode & (STREAM_READ | STREAM_WRITE)) == (STREAM_READ | STREAM_WRITE) )
	{
		nFlags = OpenFlag_Read | OpenFlag_Write;
	}
	else if( nStrmMode & STREAM_WRITE )
	{
		nFlags = OpenFlag_Write;
	}
	else //if( nStrmMode & STREAM_READ )
	{
		nFlags = OpenFlag_Read;
	}

    FileBase::RC nRet = maFile.open( nFlags );
	if( nRet == FileBase::E_NOENT && nFlags != OpenFlag_Read )
	{
		nFlags |= OpenFlag_Create;
	    nRet = maFile.open( nFlags );
	}

	if( nRet != FileBase::E_None )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
}


OslStream::~OslStream()
{
    maFile.close();
}

sal_uIntPtr OslStream::GetData( void* pData, sal_uIntPtr nSize )
{
	sal_uInt64 nBytesRead = nSize;
	FileBase::RC nRet = FileBase::E_None;
    nRet = maFile.read( pData, nBytesRead, nBytesRead );
	return (sal_uIntPtr)nBytesRead;
}

sal_uIntPtr OslStream::PutData( const void* pData, sal_uIntPtr nSize )
{
	sal_uInt64 nBytesWritten;
	FileBase::RC nRet = FileBase::E_None;
    nRet = maFile.write( pData, (sal_uInt64)nSize, nBytesWritten );
	return (sal_uIntPtr)nBytesWritten;
}

sal_uIntPtr OslStream::SeekPos( sal_uIntPtr nPos )
{
	FileBase::RC nRet;
	if( nPos == STREAM_SEEK_TO_END )
	{
		nRet = maFile.setPos( Pos_End, 0 );
	}
	else
	{
		nRet = maFile.setPos( Pos_Absolut, (sal_uInt64)nPos );
	}
	sal_uInt64 nRealPos;
    nRet = maFile.getPos( nRealPos );
    return sal::static_int_cast<sal_uIntPtr>(nRealPos);
}

void OslStream::FlushData()
{
}

void OslStream::SetSize( sal_uIntPtr nSize )
{
	FileBase::RC nRet = FileBase::E_None;
    nRet = maFile.setSize( (sal_uInt64)nSize );
}

#endif


#ifdef _USE_UNO

class UCBStream : public SvStream
{
	Reference< XInputStream >	xIS;
	Reference< XOutputStream >	xOS;
	Reference< XStream >		xS;
	Reference< XSeekable >		xSeek;
public:
					UCBStream( Reference< XInputStream > & xIS );
					UCBStream( Reference< XOutputStream > & xOS );
					UCBStream( Reference< XStream > & xS );
					~UCBStream();
	virtual sal_uIntPtr	GetData( void* pData, sal_uIntPtr nSize );
	virtual sal_uIntPtr	PutData( const void* pData, sal_uIntPtr nSize );
	virtual sal_uIntPtr	SeekPos( sal_uIntPtr nPos );
	virtual void	FlushData();
	virtual void	SetSize( sal_uIntPtr nSize );
};

/*
sal_uIntPtr UCBErrorToSvStramError( ucb::IOErrorCode nError )
{
	sal_uIntPtr eReturn = ERRCODE_IO_GENERAL;
	switch( nError )
	{
		case ucb::IOErrorCode_ABORT:				eReturn = SVSTREAM_GENERALERROR; break;
		case ucb::IOErrorCode_NOT_EXISTING:			eReturn = SVSTREAM_FILE_NOT_FOUND; break;
		case ucb::IOErrorCode_NOT_EXISTING_PATH:	eReturn = SVSTREAM_PATH_NOT_FOUND; break;
		case ucb::IOErrorCode_OUT_OF_FILE_HANDLES:	eReturn = SVSTREAM_TOO_MANY_OPEN_FILES; break;
		case ucb::IOErrorCode_ACCESS_DENIED:		eReturn = SVSTREAM_ACCESS_DENIED; break;
		case ucb::IOErrorCode_LOCKING_VIOLATION:	eReturn = SVSTREAM_SHARING_VIOLATION; break;

		case ucb::IOErrorCode_INVALID_ACCESS:		eReturn = SVSTREAM_INVALID_ACCESS; break;
		case ucb::IOErrorCode_CANT_CREATE:			eReturn = SVSTREAM_CANNOT_MAKE; break;
		case ucb::IOErrorCode_INVALID_PARAMETER:	eReturn = SVSTREAM_INVALID_PARAMETER; break;

		case ucb::IOErrorCode_CANT_READ:			eReturn = SVSTREAM_READ_ERROR; break;
		case ucb::IOErrorCode_CANT_WRITE:			eReturn = SVSTREAM_WRITE_ERROR; break;
		case ucb::IOErrorCode_CANT_SEEK:			eReturn = SVSTREAM_SEEK_ERROR; break;
		case ucb::IOErrorCode_CANT_TELL:			eReturn = SVSTREAM_TELL_ERROR; break;

		case ucb::IOErrorCode_OUT_OF_MEMORY:		eReturn = SVSTREAM_OUTOFMEMORY; break;

		case SVSTREAM_FILEFORMAT_ERROR:				eReturn = SVSTREAM_FILEFORMAT_ERROR; break;
		case ucb::IOErrorCode_WRONG_VERSION:		eReturn = SVSTREAM_WRONGVERSION;
		case ucb::IOErrorCode_OUT_OF_DISK_SPACE:	eReturn = SVSTREAM_DISK_FULL; break;

		case ucb::IOErrorCode_BAD_CRC:				eReturn = ERRCODE_IO_BADCRC; break;
	}
	return eReturn;
}
*/

UCBStream::UCBStream( Reference< XInputStream > & rStm )
	: xIS( rStm )
	, xSeek( rStm, UNO_QUERY )
{
}

UCBStream::UCBStream( Reference< XOutputStream > & rStm )
	: xOS( rStm )
	, xSeek( rStm, UNO_QUERY )
{
}

UCBStream::UCBStream( Reference< XStream > & rStm )
	: xS( rStm )
	, xSeek( rStm, UNO_QUERY )
{
}


UCBStream::~UCBStream()
{
	try
	{
		if( xIS.is() )
			xIS->closeInput();
		else if( xOS.is() )
			xOS->closeOutput();
		else if( xS.is() )
		{
			Reference< XInputStream > xIS_ = xS->getInputStream();
			if( xIS_.is() )
				xIS_->closeInput();
		}
	}
	catch( Exception & )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
}

sal_uIntPtr	UCBStream::GetData( void* pData, sal_uIntPtr nSize )
{
	try
	{
		Reference< XInputStream > xISFromS;
		if( xIS.is() )
		{
			Sequence<sal_Int8> aData;
			nSize = xIS->readBytes( aData, nSize );
			rtl_copyMemory( pData, aData.getConstArray(), nSize );
			return nSize;
		}
		else if( xS.is() && (xISFromS = xS->getInputStream()).is() )
		{
			Sequence<sal_Int8> aData;
			nSize = xISFromS->readBytes( aData, nSize );
			rtl_copyMemory( pData, aData.getConstArray(), nSize );
			return nSize;
		}
		else
			SetError( ERRCODE_IO_GENERAL );
	}
	catch( Exception & )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
	return 0;
}

sal_uIntPtr	UCBStream::PutData( const void* pData, sal_uIntPtr nSize )
{
	try
	{
		Reference< XOutputStream > xOSFromS;
		if( xOS.is() )
		{
			Sequence<sal_Int8> aData( (const sal_Int8 *)pData, nSize );
			xOS->writeBytes( aData );
			return nSize;
		}
		else if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
		{
			Sequence<sal_Int8> aData( (const sal_Int8 *)pData, nSize );
			xOSFromS->writeBytes( aData );
			return nSize;
		}
		else
			SetError( ERRCODE_IO_GENERAL );
	}
	catch( Exception & )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
	return 0;
}

sal_uIntPtr	UCBStream::SeekPos( sal_uIntPtr nPos )
{
	try
	{
		if( xSeek.is() )
		{
			sal_uIntPtr nLen = sal::static_int_cast<sal_uIntPtr>( xSeek->getLength() );
			if( nPos > nLen )
				nPos = nLen;
			xSeek->seek( nPos );
			return nPos;
		}
		else
			SetError( ERRCODE_IO_GENERAL );
	}
	catch( Exception & )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
	return 0;
}

void	UCBStream::FlushData()
{
	try
	{
		Reference< XOutputStream > xOSFromS;
		if( xOS.is() )
			xOS->flush();
		else if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
			xOSFromS->flush();
		else
			SetError( ERRCODE_IO_GENERAL );
	}
	catch( Exception & )
	{
		SetError( ERRCODE_IO_GENERAL );
	}
}

void	UCBStream::SetSize( sal_uIntPtr nSize )
{
    (void)nSize;

	DBG_ERROR( "not allowed to call from basic" );
	SetError( ERRCODE_IO_GENERAL );
}

#endif

// Oeffnen eines Streams
SbError SbiStream::Open
( short nCh, const ByteString& rName, short nStrmMode, short nFlags, short nL )
{
	nMode   = nFlags;
	nLen    = nL;
	nChan   = nCh;
	nLine   = 0;
	nExpandOnWriteTo = 0;
	if( ( nStrmMode & ( STREAM_READ|STREAM_WRITE ) ) == STREAM_READ )
		nStrmMode |= STREAM_NOCREATE;
	String aStr( rName, gsl_getSystemTextEncoding() );
	String aNameStr = getFullPath( aStr );

#ifdef _USE_UNO
	if( hasUno() )
	{
		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
		if( xSMgr.is() )
		{
			Reference< XSimpleFileAccess >
				xSFI( xSMgr->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY );
			if( xSFI.is() )
			{
				try
				{

				// #??? For write access delete file if it already exists (not for appending)
				if( (nStrmMode & STREAM_WRITE) != 0 && !IsAppend() && !IsBinary() &&
                    xSFI->exists( aNameStr ) && !xSFI->isFolder( aNameStr ) )
				{
					xSFI->kill( aNameStr );
				}

				if( (nStrmMode & (STREAM_READ | STREAM_WRITE)) == (STREAM_READ | STREAM_WRITE) )
				{
					Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
					pStrm = new UCBStream( xIS );
				}
				else if( nStrmMode & STREAM_WRITE )
				{
					Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
					pStrm = new UCBStream( xIS );
					// Open for writing is not implemented in ucb yet!!!
					//Reference< XOutputStream > xIS = xSFI->openFileWrite( aNameStr );
					//pStrm = new UCBStream( xIS );
				}
				else //if( nStrmMode & STREAM_READ )
				{
					Reference< XInputStream > xIS = xSFI->openFileRead( aNameStr );
					pStrm = new UCBStream( xIS );
				}

				}
				catch( Exception & )
				{
            		nError = ERRCODE_IO_GENERAL;
				}
			}
		}
	}

#endif
	if( !pStrm )
	{
#ifdef _OLD_FILE_IMPL
		pStrm = new SvFileStream( aNameStr, nStrmMode );
#else
		pStrm = new OslStream( aNameStr, nStrmMode );
#endif
	}
	if( IsAppend() )
		pStrm->Seek( STREAM_SEEK_TO_END );
	MapError();
	if( nError )
		delete pStrm, pStrm = NULL;
	return nError;
}

SbError SbiStream::Close()
{
	if(	pStrm )
	{
		if( !hasUno() )
		{
#ifdef _OLD_FILE_IMPL
			((SvFileStream *)pStrm)->Close();
#endif
		}
		MapError();
		delete pStrm;
		pStrm = NULL;
	}
	nChan = 0;
	return nError;
}

SbError SbiStream::Read( ByteString& rBuf, sal_uInt16 n, bool bForceReadingPerByte )
{
	nExpandOnWriteTo = 0;
	if( !bForceReadingPerByte && IsText() )
	{
		pStrm->ReadLine( rBuf );
		nLine++;
	}
	else
	{
		if( !n ) n = nLen;
		if( !n )
			return nError = SbERR_BAD_RECORD_LENGTH;
		rBuf.Fill( n, ' ' );
		pStrm->Read( (void*)rBuf.GetBuffer(), n );
	}
	MapError();
	if( !nError && pStrm->IsEof() )
		nError = SbERR_READ_PAST_EOF;
	return nError;
}

SbError SbiStream::Read( char& ch )
{
	nExpandOnWriteTo = 0;
	if( !aLine.Len() )
	{
		Read( aLine, 0 );
		aLine += '\n';
	}
	ch = aLine.GetBuffer()[0];
	aLine.Erase( 0, 1 );
	return nError;
}

void SbiStream::ExpandFile()
{
	if ( nExpandOnWriteTo )
	{
		sal_uIntPtr nCur = pStrm->Seek(STREAM_SEEK_TO_END);
		if( nCur < nExpandOnWriteTo )
		{
			sal_uIntPtr nDiff = nExpandOnWriteTo - nCur;
			char c = 0;
			while( nDiff-- )
				*pStrm << c;
		}
		else
		{
			pStrm->Seek( nExpandOnWriteTo );
		}
		nExpandOnWriteTo = 0;
	}
}

SbError SbiStream::Write( const ByteString& rBuf, sal_uInt16 n )
{
	ExpandFile();
	if( IsAppend() )
		pStrm->Seek( STREAM_SEEK_TO_END );

	if( IsText() )
	{
		aLine += rBuf;
		// Raus damit, wenn das Ende ein LF ist, aber CRLF vorher
		// strippen, da der SvStrm ein CRLF anfuegt!
		sal_uInt16 nLineLen = aLine.Len();
		if( nLineLen && aLine.GetBuffer()[ --nLineLen ] == 0x0A )
		{
			aLine.Erase( nLineLen );
			if( nLineLen && aLine.GetBuffer()[ --nLineLen ] == 0x0D )
				aLine.Erase( nLineLen );
			pStrm->WriteLines( aLine );
			aLine.Erase();
		}
	}
	else
	{
		if( !n ) n = nLen;
		if( !n )
			return nError = SbERR_BAD_RECORD_LENGTH;
		pStrm->Write( rBuf.GetBuffer(), n );
		MapError();
	}
	return nError;
}

//////////////////////////////////////////////////////////////////////////

// Zugriff auf das aktuelle I/O-System:

SbiIoSystem* SbGetIoSystem()
{
	SbiInstance* pInst = pINST;
	return pInst ? pInst->GetIoSystem() : NULL;
}

//////////////////////////////////////////////////////////////////////////

SbiIoSystem::SbiIoSystem()
{
	for( short i = 0; i < CHANNELS; i++ )
		pChan[ i ] = NULL;
	nChan  = 0;
	nError = 0;
}

SbiIoSystem::~SbiIoSystem()
{
	Shutdown();
}

SbError SbiIoSystem::GetError()
{
	SbError n = nError; nError = 0;
	return n;
}

void SbiIoSystem::Open
	( short nCh, const ByteString& rName, short nMode, short nFlags, short nLen )
{
	nError = 0;
	if( nCh >= CHANNELS || !nCh )
		nError = SbERR_BAD_CHANNEL;
	else if( pChan[ nCh ] )
		nError = SbERR_FILE_ALREADY_OPEN;
	else
	{
		pChan[ nCh ] = new SbiStream;
		nError = pChan[ nCh ]->Open( nCh, rName, nMode, nFlags, nLen );
		if( nError )
			delete pChan[ nCh ], pChan[ nCh ] = NULL;
	}
	nChan = 0;
}

// Aktuellen Kanal schliessen

void SbiIoSystem::Close()
{
	if( !nChan )
		nError = SbERR_BAD_CHANNEL;
	else if( !pChan[ nChan ] )
		nError = SbERR_BAD_CHANNEL;
	else
	{
		nError = pChan[ nChan ]->Close();
		delete pChan[ nChan ];
		pChan[ nChan ] = NULL;
	}
	nChan = 0;
}

// Shutdown nach Programmlauf

void SbiIoSystem::Shutdown()
{
	for( short i = 1; i < CHANNELS; i++ )
	{
		if( pChan[ i ] )
		{
			SbError n = pChan[ i ]->Close();
			delete pChan[ i ];
			pChan[ i ] = NULL;
			if( n && !nError )
				nError = n;
		}
	}
	nChan = 0;
	// Noch was zu PRINTen?
	if( aOut.Len() )
	{
		String aOutStr( aOut, gsl_getSystemTextEncoding() );
#if defined GCC
		Window* pParent = Application::GetDefDialogParent();
		MessBox( pParent, WinBits( WB_OK ), String(), aOutStr ).Execute();
#else
		MessBox( GetpApp()->GetDefDialogParent(), WinBits( WB_OK ), String(), aOutStr ).Execute();
#endif
	}
	aOut.Erase();
}

// Aus aktuellem Kanal lesen

void SbiIoSystem::Read( ByteString& rBuf, short n )
{
	if( !nChan )
		ReadCon( rBuf );
	else if( !pChan[ nChan ] )
		nError = SbERR_BAD_CHANNEL;
	else
		nError = pChan[ nChan ]->Read( rBuf, n );
}

char SbiIoSystem::Read()
{
	char ch = ' ';
	if( !nChan )
	{
		if( !aIn.Len() )
		{
			ReadCon( aIn );
			aIn += '\n';
		}
		ch = aIn.GetBuffer()[0];
		aIn.Erase( 0, 1 );
	}
	else if( !pChan[ nChan ] )
		nError = SbERR_BAD_CHANNEL;
	else
		nError = pChan[ nChan ]->Read( ch );
	return ch;
}

void SbiIoSystem::Write( const ByteString& rBuf, short n )
{
	if( !nChan )
		WriteCon( rBuf );
	else if( !pChan[ nChan ] )
		nError = SbERR_BAD_CHANNEL;
	else
		nError = pChan[ nChan ]->Write( rBuf, n );
}

short SbiIoSystem::NextChannel()
{
	for( short i = 1; i < CHANNELS; i++ )
	{
		if( !pChan[ i ] )
			return i;
	}
	nError = SbERR_TOO_MANY_FILES;
	return CHANNELS;
}

// nChannel == 0..CHANNELS-1

SbiStream* SbiIoSystem::GetStream( short nChannel ) const
{
	SbiStream* pRet = 0;
	if( nChannel >= 0 && nChannel < CHANNELS )
		pRet = pChan[ nChannel ];
	return pRet;
}

void SbiIoSystem::CloseAll(void)
{
	for( short i = 1; i < CHANNELS; i++ )
	{
		if( pChan[ i ] )
		{
			SbError n = pChan[ i ]->Close();
			delete pChan[ i ];
			pChan[ i ] = NULL;
			if( n && !nError )
				nError = n;
		}
	}
}

/***************************************************************************
*
*	Console Support
*
***************************************************************************/

// Einlesen einer Zeile von der Console

void SbiIoSystem::ReadCon( ByteString& rIn )
{
	String aPromptStr( aPrompt, gsl_getSystemTextEncoding() );
	SbiInputDialog aDlg( NULL, aPromptStr );
	if( aDlg.Execute() )
		rIn = ByteString( aDlg.GetInput(), gsl_getSystemTextEncoding() );
	else
		nError = SbERR_USER_ABORT;
	aPrompt.Erase();
}

// Ausgabe einer MessageBox, wenn im Console-Puffer ein CR ist

void SbiIoSystem::WriteCon( const ByteString& rText )
{
	aOut += rText;
	sal_uInt16 n1 = aOut.Search( '\n' );
	sal_uInt16 n2 = aOut.Search( '\r' );
	if( n1 != STRING_NOTFOUND || n2 != STRING_NOTFOUND )
	{
		if( n1 == STRING_NOTFOUND ) n1 = n2;
		else
		if( n2 == STRING_NOTFOUND ) n2 = n1;
		if( n1 > n2 ) n1 = n2;
		ByteString s( aOut.Copy( 0, n1 ) );
		aOut.Erase( 0, n1 );
		while( aOut.GetBuffer()[0] == '\n' || aOut.GetBuffer()[0] == '\r' )
			aOut.Erase( 0, 1 );
		String aStr( s, gsl_getSystemTextEncoding() );
        {
            vos::OGuard aSolarGuard( Application::GetSolarMutex() );
		    if( !MessBox( GetpApp()->GetDefDialogParent(),
					    WinBits( WB_OK_CANCEL | WB_DEF_OK ),
					    String(), aStr ).Execute() )
			    nError = SbERR_USER_ABORT;
        }
	}
}