xref: /aoo42x/main/basic/source/runtime/iosys.cxx (revision 950617a0)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_basic.hxx"
26 #include <vcl/dialog.hxx>
27 #include <vcl/edit.hxx>
28 #ifndef _SV_BUTTON_HXX //autogen
29 #include <vcl/button.hxx>
30 #endif
31 #include <vcl/msgbox.hxx>
32 #include <vcl/svapp.hxx>
33 #include <osl/security.h>
34 #include <osl/file.hxx>
35 #include <tools/urlobj.hxx>
36 #include <vos/mutex.hxx>
37 
38 #include "runtime.hxx"
39 
40 #ifdef _USE_UNO
41 
42 // <-- encoding
43 #include <sal/alloca.h>
44 
45 #include <ctype.h>
46 #include <rtl/byteseq.hxx>
47 #include <rtl/textenc.h>
48 #include <rtl/ustrbuf.hxx>
49 #include <rtl/textenc.h>
50 #include <rtl/ustrbuf.hxx>
51 // encoding -->
52 #include <comphelper/processfactory.hxx>
53 
54 #include <com/sun/star/uno/Sequence.hxx>
55 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
56 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
57 #include <com/sun/star/ucb/XContentProvider.hpp>
58 #include <com/sun/star/ucb/XContentProviderManager.hpp>
59 #include <com/sun/star/io/XInputStream.hpp>
60 #include <com/sun/star/io/XOutputStream.hpp>
61 #include <com/sun/star/io/XStream.hpp>
62 #include <com/sun/star/io/XSeekable.hpp>
63 #include <com/sun/star/bridge/XBridge.hpp>
64 #include <com/sun/star/bridge/XBridgeFactory.hpp>
65 
66 using namespace comphelper;
67 using namespace osl;
68 using namespace com::sun::star::uno;
69 using namespace com::sun::star::lang;
70 using namespace com::sun::star::ucb;
71 using namespace com::sun::star::io;
72 using namespace com::sun::star::bridge;
73 
74 #endif /* _USE_UNO */
75 
76 #include "iosys.hxx"
77 #include "sbintern.hxx"
78 
79 // Der Input-Dialog:
80 
81 class SbiInputDialog : public ModalDialog {
82 	Edit aInput;
83 	OKButton aOk;
84 	CancelButton aCancel;
85 	String aText;
86 	DECL_LINK( Ok, Window * );
87 	DECL_LINK( Cancel, Window * );
88 public:
89 	SbiInputDialog( Window*, const String& );
90 	const String& GetInput() { return aText; }
91 };
92 
93 SbiInputDialog::SbiInputDialog( Window* pParent, const String& rPrompt )
94 			:ModalDialog( pParent, WB_3DLOOK | WB_MOVEABLE | WB_CLOSEABLE ),
95 			 aInput( this, WB_3DLOOK | WB_LEFT | WB_BORDER ),
96 			 aOk( this ), aCancel( this )
97 {
98 	SetText( rPrompt );
99 	aOk.SetClickHdl( LINK( this, SbiInputDialog, Ok ) );
100 	aCancel.SetClickHdl( LINK( this, SbiInputDialog, Cancel ) );
101 	SetMapMode( MapMode( MAP_APPFONT ) );
102 
103 	Point aPt = LogicToPixel( Point( 50, 50 ) );
104 	Size  aSz = LogicToPixel( Size( 145, 65 ) );
105 	SetPosSizePixel( aPt, aSz );
106 	aPt = LogicToPixel( Point( 10, 10 ) );
107 	aSz = LogicToPixel( Size( 120, 12 ) );
108 	aInput.SetPosSizePixel( aPt, aSz );
109 	aPt = LogicToPixel( Point( 15, 30 ) );
110 	aSz = LogicToPixel( Size( 45, 15) );
111 	aOk.SetPosSizePixel( aPt, aSz );
112 	aPt = LogicToPixel( Point( 80, 30 ) );
113 	aSz = LogicToPixel( Size( 45, 15) );
114 	aCancel.SetPosSizePixel( aPt, aSz );
115 
116 	aInput.Show();
117 	aOk.Show();
118 	aCancel.Show();
119 }
120 
121 IMPL_LINK_INLINE_START( SbiInputDialog, Ok, Window *, pWindow )
122 {
123     (void)pWindow;
124 
125 	aText = aInput.GetText();
126 	EndDialog( 1 );
127 	return 0;
128 }
129 IMPL_LINK_INLINE_END( SbiInputDialog, Ok, Window *, pWindow )
130 
131 IMPL_LINK_INLINE_START( SbiInputDialog, Cancel, Window *, pWindow )
132 {
133     (void)pWindow;
134 
135 	EndDialog( 0 );
136 	return 0;
137 }
138 IMPL_LINK_INLINE_END( SbiInputDialog, Cancel, Window *, pWindow )
139 
140 //////////////////////////////////////////////////////////////////////////
141 
142 SbiStream::SbiStream()
143 	: pStrm( 0 )
144 {
145 }
146 
147 SbiStream::~SbiStream()
148 {
149 	delete pStrm;
150 }
151 
152 // Ummappen eines SvStream-Fehlers auf einen StarBASIC-Code
153 
154 void SbiStream::MapError()
155 {
156 	if( pStrm )
157 	 switch( pStrm->GetError() )
158 	 {
159 		case SVSTREAM_OK:
160 			nError = 0; break;
161 		case SVSTREAM_FILE_NOT_FOUND:
162 			nError = SbERR_FILE_NOT_FOUND; break;
163 		case SVSTREAM_PATH_NOT_FOUND:
164 			nError = SbERR_PATH_NOT_FOUND; break;
165 		case SVSTREAM_TOO_MANY_OPEN_FILES:
166 			nError = SbERR_TOO_MANY_FILES; break;
167 		case SVSTREAM_ACCESS_DENIED:
168 			nError = SbERR_ACCESS_DENIED; break;
169 		case SVSTREAM_INVALID_PARAMETER:
170 			nError = SbERR_BAD_ARGUMENT; break;
171 		case SVSTREAM_OUTOFMEMORY:
172 			nError = SbERR_NO_MEMORY; break;
173 		default:
174 			nError = SbERR_IO_ERROR; break;
175 	}
176 }
177 
178 #ifdef _USE_UNO
179 
180 // TODO: Code is copied from daemons2/source/uno/asciiEncoder.cxx
181 
182 ::rtl::OUString findUserInDescription( const ::rtl::OUString& aDescription )
183 {
184 	::rtl::OUString user;
185 
186 	sal_Int32 index;
187 	sal_Int32 lastIndex = 0;
188 
189 	do
190 	{
191 		index = aDescription.indexOf((sal_Unicode) ',', lastIndex);
192 		::rtl::OUString token = (index == -1) ? aDescription.copy(lastIndex) : aDescription.copy(lastIndex, index - lastIndex);
193 
194 		lastIndex = index + 1;
195 
196 		sal_Int32 eindex = token.indexOf((sal_Unicode)'=');
197 		::rtl::OUString left = token.copy(0, eindex).toAsciiLowerCase().trim();
198 		::rtl::OUString right = INetURLObject::decode( token.copy(eindex + 1).trim(), '%',
199 							INetURLObject::DECODE_WITH_CHARSET );
200 
201 		if(left.equals(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("user"))))
202 		{
203 			user = right;
204 			break;
205 		}
206 	}
207 	while(index != -1);
208 
209 	return user;
210 }
211 
212 #endif
213 
214 
215 // Hack for #83750
216 sal_Bool runsInSetup( void );
217 
218 sal_Bool needSecurityRestrictions( void )
219 {
220 #ifdef _USE_UNO
221 	static sal_Bool bNeedInit = sal_True;
222 	static sal_Bool bRetVal = sal_True;
223 
224 	if( bNeedInit )
225 	{
226         // Hack for #83750, use internal flag until
227         // setup provides own service manager
228         if( runsInSetup() )
229 		{
230 			// Setup is not critical
231 			bRetVal = sal_False;
232 			return bRetVal;
233 		}
234 
235 		bNeedInit = sal_False;
236 
237 		// Get system user to compare to portal user
238 		oslSecurity aSecurity = osl_getCurrentSecurity();
239 		::rtl::OUString aSystemUser;
240 		sal_Bool bRet = osl_getUserName( aSecurity, &aSystemUser.pData );
241 		if( !bRet )
242 		{
243 			// No valid security! -> Secure mode!
244 			return sal_True;
245 		}
246 
247 		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
248 		if( !xSMgr.is() )
249 			return sal_True;
250 		Reference< XBridgeFactory > xBridgeFac( xSMgr->createInstance
251 			( ::rtl::OUString::createFromAscii( "com.sun.star.bridge.BridgeFactory" ) ), UNO_QUERY );
252 
253 		Sequence< Reference< XBridge > > aBridgeSeq;
254 		sal_Int32 nBridgeCount = 0;
255 		if( xBridgeFac.is() )
256 		{
257 			aBridgeSeq = xBridgeFac->getExistingBridges();
258 			nBridgeCount = aBridgeSeq.getLength();
259 		}
260 
261 		if( nBridgeCount == 0 )
262 		{
263 			// No bridges -> local
264 			bRetVal = sal_False;
265 			return bRetVal;
266 		}
267 
268 		// Iterate through all bridges to find (portal) user property
269 		const Reference< XBridge >* pBridges = aBridgeSeq.getConstArray();
270 		bRetVal = sal_False;	// Now only sal_True if user different from portal user is found
271 		sal_Int32 i;
272 		for( i = 0 ; i < nBridgeCount ; i++ )
273 		{
274 			const Reference< XBridge >& rxBridge = pBridges[ i ];
275 			::rtl::OUString aDescription = rxBridge->getDescription();
276 			::rtl::OUString aPortalUser = findUserInDescription( aDescription );
277 			if( !aPortalUser.isEmpty() )
278 			{
279 				// User Found, compare to system user
280 				if( aPortalUser == aSystemUser )
281 				{
282 					// Same user -> system security is ok, bRetVal stays FALSE
283 					break;
284 				}
285 				else
286 				{
287 					// Different user -> Secure mode!
288 					bRetVal = sal_True;
289 					break;
290 				}
291 			}
292 		}
293 		// No user found or PortalUser != SystemUser -> Secure mode! (Keep default value)
294 	}
295 
296 	return bRetVal;
297 #else
298 	return sal_False;
299 #endif
300 }
301 
302 // Returns sal_True if UNO is available, otherwise the old file
303 // system implementation has to be used
304 // #89378 New semantic: Don't just ask for UNO but for UCB
305 sal_Bool hasUno( void )
306 {
307 #ifdef _USE_UNO
308 	static sal_Bool bNeedInit = sal_True;
309 	static sal_Bool bRetVal = sal_True;
310 
311 	if( bNeedInit )
312 	{
313 		bNeedInit = sal_False;
314 		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
315 		if( !xSMgr.is() )
316         {
317             // No service manager at all
318 			bRetVal = sal_False;
319         }
320         else
321         {
322 	        Reference< XContentProviderManager > xManager( xSMgr->createInstance( ::rtl::OUString::createFromAscii
323                     ( "com.sun.star.ucb.UniversalContentBroker" ) ), UNO_QUERY );
324 
325 	        if ( !( xManager.is() && xManager->queryContentProvider( ::rtl::OUString::createFromAscii( "file:///" ) ).is() ) )
326             {
327                 // No UCB
328                 bRetVal = sal_False;
329             }
330         }
331 	}
332 	return bRetVal;
333 #else
334 	return sal_False;
335 #endif
336 }
337 
338 
339 
340 #ifndef _OLD_FILE_IMPL
341 
342 class OslStream : public SvStream
343 {
344 	File maFile;
345 	short mnStrmMode;
346 
347 public:
348 					OslStream( const String& rName, short nStrmMode );
349 					~OslStream();
350 	virtual sal_uIntPtr	GetData( void* pData, sal_uIntPtr nSize );
351 	virtual sal_uIntPtr	PutData( const void* pData, sal_uIntPtr nSize );
352 	virtual sal_uIntPtr	SeekPos( sal_uIntPtr nPos );
353 	virtual void	FlushData();
354 	virtual void	SetSize( sal_uIntPtr nSize );
355 };
356 
357 OslStream::OslStream( const String& rName, short nStrmMode )
358 	: maFile( rName )
359 	, mnStrmMode( nStrmMode )
360 {
361 	sal_uInt32 nFlags;
362 
363 	if( (nStrmMode & (STREAM_READ | STREAM_WRITE)) == (STREAM_READ | STREAM_WRITE) )
364 	{
365 		nFlags = OpenFlag_Read | OpenFlag_Write;
366 	}
367 	else if( nStrmMode & STREAM_WRITE )
368 	{
369 		nFlags = OpenFlag_Write;
370 	}
371 	else //if( nStrmMode & STREAM_READ )
372 	{
373 		nFlags = OpenFlag_Read;
374 	}
375 
376     FileBase::RC nRet = maFile.open( nFlags );
377 	if( nRet == FileBase::E_NOENT && nFlags != OpenFlag_Read )
378 	{
379 		nFlags |= OpenFlag_Create;
380 	    nRet = maFile.open( nFlags );
381 	}
382 
383 	if( nRet != FileBase::E_None )
384 	{
385 		SetError( ERRCODE_IO_GENERAL );
386 	}
387 }
388 
389 
390 OslStream::~OslStream()
391 {
392     maFile.close();
393 }
394 
395 sal_uIntPtr OslStream::GetData( void* pData, sal_uIntPtr nSize )
396 {
397 	sal_uInt64 nBytesRead = nSize;
398 	FileBase::RC nRet = FileBase::E_None;
399     nRet = maFile.read( pData, nBytesRead, nBytesRead );
400 	return (sal_uIntPtr)nBytesRead;
401 }
402 
403 sal_uIntPtr OslStream::PutData( const void* pData, sal_uIntPtr nSize )
404 {
405 	sal_uInt64 nBytesWritten;
406 	FileBase::RC nRet = FileBase::E_None;
407     nRet = maFile.write( pData, (sal_uInt64)nSize, nBytesWritten );
408 	return (sal_uIntPtr)nBytesWritten;
409 }
410 
411 sal_uIntPtr OslStream::SeekPos( sal_uIntPtr nPos )
412 {
413 	FileBase::RC nRet;
414 	if( nPos == STREAM_SEEK_TO_END )
415 	{
416 		nRet = maFile.setPos( Pos_End, 0 );
417 	}
418 	else
419 	{
420 		nRet = maFile.setPos( Pos_Absolut, (sal_uInt64)nPos );
421 	}
422 	sal_uInt64 nRealPos;
423     nRet = maFile.getPos( nRealPos );
424     return sal::static_int_cast<sal_uIntPtr>(nRealPos);
425 }
426 
427 void OslStream::FlushData()
428 {
429 }
430 
431 void OslStream::SetSize( sal_uIntPtr nSize )
432 {
433 	FileBase::RC nRet = FileBase::E_None;
434     nRet = maFile.setSize( (sal_uInt64)nSize );
435 }
436 
437 #endif
438 
439 
440 #ifdef _USE_UNO
441 
442 class UCBStream : public SvStream
443 {
444 	Reference< XInputStream >	xIS;
445 	Reference< XOutputStream >	xOS;
446 	Reference< XStream >		xS;
447 	Reference< XSeekable >		xSeek;
448 public:
449 					UCBStream( Reference< XInputStream > & xIS );
450 					UCBStream( Reference< XOutputStream > & xOS );
451 					UCBStream( Reference< XStream > & xS );
452 					~UCBStream();
453 	virtual sal_uIntPtr	GetData( void* pData, sal_uIntPtr nSize );
454 	virtual sal_uIntPtr	PutData( const void* pData, sal_uIntPtr nSize );
455 	virtual sal_uIntPtr	SeekPos( sal_uIntPtr nPos );
456 	virtual void	FlushData();
457 	virtual void	SetSize( sal_uIntPtr nSize );
458 };
459 
460 /*
461 sal_uIntPtr UCBErrorToSvStramError( ucb::IOErrorCode nError )
462 {
463 	sal_uIntPtr eReturn = ERRCODE_IO_GENERAL;
464 	switch( nError )
465 	{
466 		case ucb::IOErrorCode_ABORT:				eReturn = SVSTREAM_GENERALERROR; break;
467 		case ucb::IOErrorCode_NOT_EXISTING:			eReturn = SVSTREAM_FILE_NOT_FOUND; break;
468 		case ucb::IOErrorCode_NOT_EXISTING_PATH:	eReturn = SVSTREAM_PATH_NOT_FOUND; break;
469 		case ucb::IOErrorCode_OUT_OF_FILE_HANDLES:	eReturn = SVSTREAM_TOO_MANY_OPEN_FILES; break;
470 		case ucb::IOErrorCode_ACCESS_DENIED:		eReturn = SVSTREAM_ACCESS_DENIED; break;
471 		case ucb::IOErrorCode_LOCKING_VIOLATION:	eReturn = SVSTREAM_SHARING_VIOLATION; break;
472 
473 		case ucb::IOErrorCode_INVALID_ACCESS:		eReturn = SVSTREAM_INVALID_ACCESS; break;
474 		case ucb::IOErrorCode_CANT_CREATE:			eReturn = SVSTREAM_CANNOT_MAKE; break;
475 		case ucb::IOErrorCode_INVALID_PARAMETER:	eReturn = SVSTREAM_INVALID_PARAMETER; break;
476 
477 		case ucb::IOErrorCode_CANT_READ:			eReturn = SVSTREAM_READ_ERROR; break;
478 		case ucb::IOErrorCode_CANT_WRITE:			eReturn = SVSTREAM_WRITE_ERROR; break;
479 		case ucb::IOErrorCode_CANT_SEEK:			eReturn = SVSTREAM_SEEK_ERROR; break;
480 		case ucb::IOErrorCode_CANT_TELL:			eReturn = SVSTREAM_TELL_ERROR; break;
481 
482 		case ucb::IOErrorCode_OUT_OF_MEMORY:		eReturn = SVSTREAM_OUTOFMEMORY; break;
483 
484 		case SVSTREAM_FILEFORMAT_ERROR:				eReturn = SVSTREAM_FILEFORMAT_ERROR; break;
485 		case ucb::IOErrorCode_WRONG_VERSION:		eReturn = SVSTREAM_WRONGVERSION;
486 		case ucb::IOErrorCode_OUT_OF_DISK_SPACE:	eReturn = SVSTREAM_DISK_FULL; break;
487 
488 		case ucb::IOErrorCode_BAD_CRC:				eReturn = ERRCODE_IO_BADCRC; break;
489 	}
490 	return eReturn;
491 }
492 */
493 
494 UCBStream::UCBStream( Reference< XInputStream > & rStm )
495 	: xIS( rStm )
496 	, xSeek( rStm, UNO_QUERY )
497 {
498 }
499 
500 UCBStream::UCBStream( Reference< XOutputStream > & rStm )
501 	: xOS( rStm )
502 	, xSeek( rStm, UNO_QUERY )
503 {
504 }
505 
506 UCBStream::UCBStream( Reference< XStream > & rStm )
507 	: xS( rStm )
508 	, xSeek( rStm, UNO_QUERY )
509 {
510 }
511 
512 
513 UCBStream::~UCBStream()
514 {
515 	try
516 	{
517 		if( xIS.is() )
518 			xIS->closeInput();
519 		else if( xOS.is() )
520 			xOS->closeOutput();
521 		else if( xS.is() )
522 		{
523 			Reference< XInputStream > xIS_ = xS->getInputStream();
524 			if( xIS_.is() )
525 				xIS_->closeInput();
526 		}
527 	}
528 	catch( Exception & )
529 	{
530 		SetError( ERRCODE_IO_GENERAL );
531 	}
532 }
533 
534 sal_uIntPtr	UCBStream::GetData( void* pData, sal_uIntPtr nSize )
535 {
536 	try
537 	{
538 		Reference< XInputStream > xISFromS;
539 		if( xIS.is() )
540 		{
541 			Sequence<sal_Int8> aData;
542 			nSize = xIS->readBytes( aData, nSize );
543 			rtl_copyMemory( pData, aData.getConstArray(), nSize );
544 			return nSize;
545 		}
546 		else if( xS.is() && (xISFromS = xS->getInputStream()).is() )
547 		{
548 			Sequence<sal_Int8> aData;
549 			nSize = xISFromS->readBytes( aData, nSize );
550 			rtl_copyMemory( pData, aData.getConstArray(), nSize );
551 			return nSize;
552 		}
553 		else
554 			SetError( ERRCODE_IO_GENERAL );
555 	}
556 	catch( Exception & )
557 	{
558 		SetError( ERRCODE_IO_GENERAL );
559 	}
560 	return 0;
561 }
562 
563 sal_uIntPtr	UCBStream::PutData( const void* pData, sal_uIntPtr nSize )
564 {
565 	try
566 	{
567 		Reference< XOutputStream > xOSFromS;
568 		if( xOS.is() )
569 		{
570 			Sequence<sal_Int8> aData( (const sal_Int8 *)pData, nSize );
571 			xOS->writeBytes( aData );
572 			return nSize;
573 		}
574 		else if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
575 		{
576 			Sequence<sal_Int8> aData( (const sal_Int8 *)pData, nSize );
577 			xOSFromS->writeBytes( aData );
578 			return nSize;
579 		}
580 		else
581 			SetError( ERRCODE_IO_GENERAL );
582 	}
583 	catch( Exception & )
584 	{
585 		SetError( ERRCODE_IO_GENERAL );
586 	}
587 	return 0;
588 }
589 
590 sal_uIntPtr	UCBStream::SeekPos( sal_uIntPtr nPos )
591 {
592 	try
593 	{
594 		if( xSeek.is() )
595 		{
596 			sal_uIntPtr nLen = sal::static_int_cast<sal_uIntPtr>( xSeek->getLength() );
597 			if( nPos > nLen )
598 				nPos = nLen;
599 			xSeek->seek( nPos );
600 			return nPos;
601 		}
602 		else
603 			SetError( ERRCODE_IO_GENERAL );
604 	}
605 	catch( Exception & )
606 	{
607 		SetError( ERRCODE_IO_GENERAL );
608 	}
609 	return 0;
610 }
611 
612 void	UCBStream::FlushData()
613 {
614 	try
615 	{
616 		Reference< XOutputStream > xOSFromS;
617 		if( xOS.is() )
618 			xOS->flush();
619 		else if( xS.is() && (xOSFromS = xS->getOutputStream()).is() )
620 			xOSFromS->flush();
621 		else
622 			SetError( ERRCODE_IO_GENERAL );
623 	}
624 	catch( Exception & )
625 	{
626 		SetError( ERRCODE_IO_GENERAL );
627 	}
628 }
629 
630 void	UCBStream::SetSize( sal_uIntPtr nSize )
631 {
632     (void)nSize;
633 
634 	DBG_ERROR( "not allowed to call from basic" );
635 	SetError( ERRCODE_IO_GENERAL );
636 }
637 
638 #endif
639 
640 // Oeffnen eines Streams
641 SbError SbiStream::Open
642 ( short nCh, const ByteString& rName, short nStrmMode, short nFlags, short nL )
643 {
644 	nMode   = nFlags;
645 	nLen    = nL;
646 	nChan   = nCh;
647 	nLine   = 0;
648 	nExpandOnWriteTo = 0;
649 	if( ( nStrmMode & ( STREAM_READ|STREAM_WRITE ) ) == STREAM_READ )
650 		nStrmMode |= STREAM_NOCREATE;
651 	String aStr( rName, gsl_getSystemTextEncoding() );
652 	String aNameStr = getFullPath( aStr );
653 
654 #ifdef _USE_UNO
655 	if( hasUno() )
656 	{
657 		Reference< XMultiServiceFactory > xSMgr = getProcessServiceFactory();
658 		if( xSMgr.is() )
659 		{
660 			Reference< XSimpleFileAccess >
661 				xSFI( xSMgr->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ) ), UNO_QUERY );
662 			if( xSFI.is() )
663 			{
664 				try
665 				{
666 
667 				// #??? For write access delete file if it already exists (not for appending)
668 				if( (nStrmMode & STREAM_WRITE) != 0 && !IsAppend() && !IsBinary() && !IsRandom() &&
669                     xSFI->exists( aNameStr ) && !xSFI->isFolder( aNameStr ) )
670 				{
671 					xSFI->kill( aNameStr );
672 				}
673 
674 				if( (nStrmMode & (STREAM_READ | STREAM_WRITE)) == (STREAM_READ | STREAM_WRITE) )
675 				{
676 					Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
677 					pStrm = new UCBStream( xIS );
678 				}
679 				else if( nStrmMode & STREAM_WRITE )
680 				{
681 					Reference< XStream > xIS = xSFI->openFileReadWrite( aNameStr );
682 					pStrm = new UCBStream( xIS );
683 					// Open for writing is not implemented in ucb yet!!!
684 					//Reference< XOutputStream > xIS = xSFI->openFileWrite( aNameStr );
685 					//pStrm = new UCBStream( xIS );
686 				}
687 				else //if( nStrmMode & STREAM_READ )
688 				{
689 					Reference< XInputStream > xIS = xSFI->openFileRead( aNameStr );
690 					pStrm = new UCBStream( xIS );
691 				}
692 
693 				}
694 				catch( Exception & )
695 				{
696             		nError = ERRCODE_IO_GENERAL;
697 				}
698 			}
699 		}
700 	}
701 
702 #endif
703 	if( !pStrm )
704 	{
705 #ifdef _OLD_FILE_IMPL
706 		pStrm = new SvFileStream( aNameStr, nStrmMode );
707 #else
708 		pStrm = new OslStream( aNameStr, nStrmMode );
709 #endif
710 	}
711 	if( IsAppend() )
712 		pStrm->Seek( STREAM_SEEK_TO_END );
713 	MapError();
714 	if( nError )
715 		delete pStrm, pStrm = NULL;
716 	return nError;
717 }
718 
719 SbError SbiStream::Close()
720 {
721 	if(	pStrm )
722 	{
723 		if( !hasUno() )
724 		{
725 #ifdef _OLD_FILE_IMPL
726 			((SvFileStream *)pStrm)->Close();
727 #endif
728 		}
729 		MapError();
730 		delete pStrm;
731 		pStrm = NULL;
732 	}
733 	nChan = 0;
734 	return nError;
735 }
736 
737 SbError SbiStream::Read( ByteString& rBuf, sal_uInt16 n, bool bForceReadingPerByte )
738 {
739 	nExpandOnWriteTo = 0;
740 	if( !bForceReadingPerByte && IsText() )
741 	{
742 		pStrm->ReadLine( rBuf );
743 		nLine++;
744 	}
745 	else
746 	{
747 		if( !n ) n = nLen;
748 		if( !n )
749 			return nError = SbERR_BAD_RECORD_LENGTH;
750 		rBuf.Fill( n, ' ' );
751 		pStrm->Read( (void*)rBuf.GetBuffer(), n );
752 	}
753 	MapError();
754 	if( !nError && pStrm->IsEof() )
755 		nError = SbERR_READ_PAST_EOF;
756 	return nError;
757 }
758 
759 SbError SbiStream::Read( char& ch )
760 {
761 	nExpandOnWriteTo = 0;
762 	if( !aLine.Len() )
763 	{
764 		Read( aLine, 0 );
765 		aLine += '\n';
766 	}
767 	ch = aLine.GetBuffer()[0];
768 	aLine.Erase( 0, 1 );
769 	return nError;
770 }
771 
772 void SbiStream::ExpandFile()
773 {
774 	if ( nExpandOnWriteTo )
775 	{
776 		sal_uIntPtr nCur = pStrm->Seek(STREAM_SEEK_TO_END);
777 		if( nCur < nExpandOnWriteTo )
778 		{
779 			sal_uIntPtr nDiff = nExpandOnWriteTo - nCur;
780 			char c = 0;
781 			while( nDiff-- )
782 				*pStrm << c;
783 		}
784 		else
785 		{
786 			pStrm->Seek( nExpandOnWriteTo );
787 		}
788 		nExpandOnWriteTo = 0;
789 	}
790 }
791 
792 SbError SbiStream::Write( const ByteString& rBuf, sal_uInt16 n )
793 {
794 	ExpandFile();
795 	if( IsAppend() )
796 		pStrm->Seek( STREAM_SEEK_TO_END );
797 
798 	if( IsText() )
799 	{
800 		aLine += rBuf;
801 		// Raus damit, wenn das Ende ein LF ist, aber CRLF vorher
802 		// strippen, da der SvStrm ein CRLF anfuegt!
803 		sal_uInt16 nLineLen = aLine.Len();
804 		if( nLineLen && aLine.GetBuffer()[ --nLineLen ] == 0x0A )
805 		{
806 			aLine.Erase( nLineLen );
807 			if( nLineLen && aLine.GetBuffer()[ --nLineLen ] == 0x0D )
808 				aLine.Erase( nLineLen );
809 			pStrm->WriteLines( aLine );
810 			aLine.Erase();
811 		}
812 	}
813 	else
814 	{
815 		if( !n ) n = nLen;
816 		if( !n )
817 			return nError = SbERR_BAD_RECORD_LENGTH;
818 		pStrm->Write( rBuf.GetBuffer(), n );
819 		MapError();
820 	}
821 	return nError;
822 }
823 
824 //////////////////////////////////////////////////////////////////////////
825 
826 // Zugriff auf das aktuelle I/O-System:
827 
828 SbiIoSystem* SbGetIoSystem()
829 {
830 	SbiInstance* pInst = pINST;
831 	return pInst ? pInst->GetIoSystem() : NULL;
832 }
833 
834 //////////////////////////////////////////////////////////////////////////
835 
836 SbiIoSystem::SbiIoSystem()
837 {
838 	for( short i = 0; i < CHANNELS; i++ )
839 		pChan[ i ] = NULL;
840 	nChan  = 0;
841 	nError = 0;
842 }
843 
844 SbiIoSystem::~SbiIoSystem()
845 {
846 	Shutdown();
847 }
848 
849 SbError SbiIoSystem::GetError()
850 {
851 	SbError n = nError; nError = 0;
852 	return n;
853 }
854 
855 void SbiIoSystem::Open
856 	( short nCh, const ByteString& rName, short nMode, short nFlags, short nLen )
857 {
858 	nError = 0;
859 	if( nCh >= CHANNELS || !nCh )
860 		nError = SbERR_BAD_CHANNEL;
861 	else if( pChan[ nCh ] )
862 		nError = SbERR_FILE_ALREADY_OPEN;
863 	else
864 	{
865 		pChan[ nCh ] = new SbiStream;
866 		nError = pChan[ nCh ]->Open( nCh, rName, nMode, nFlags, nLen );
867 		if( nError )
868 			delete pChan[ nCh ], pChan[ nCh ] = NULL;
869 	}
870 	nChan = 0;
871 }
872 
873 // Aktuellen Kanal schliessen
874 
875 void SbiIoSystem::Close()
876 {
877 	if( !nChan )
878 		nError = SbERR_BAD_CHANNEL;
879 	else if( !pChan[ nChan ] )
880 		nError = SbERR_BAD_CHANNEL;
881 	else
882 	{
883 		nError = pChan[ nChan ]->Close();
884 		delete pChan[ nChan ];
885 		pChan[ nChan ] = NULL;
886 	}
887 	nChan = 0;
888 }
889 
890 // Shutdown nach Programmlauf
891 
892 void SbiIoSystem::Shutdown()
893 {
894 	for( short i = 1; i < CHANNELS; i++ )
895 	{
896 		if( pChan[ i ] )
897 		{
898 			SbError n = pChan[ i ]->Close();
899 			delete pChan[ i ];
900 			pChan[ i ] = NULL;
901 			if( n && !nError )
902 				nError = n;
903 		}
904 	}
905 	nChan = 0;
906 	// Noch was zu PRINTen?
907 	if( aOut.Len() )
908 	{
909 		String aOutStr( aOut, gsl_getSystemTextEncoding() );
910 #if defined GCC
911 		Window* pParent = Application::GetDefDialogParent();
912 		MessBox( pParent, WinBits( WB_OK ), String(), aOutStr ).Execute();
913 #else
914 		MessBox( GetpApp()->GetDefDialogParent(), WinBits( WB_OK ), String(), aOutStr ).Execute();
915 #endif
916 	}
917 	aOut.Erase();
918 }
919 
920 // Aus aktuellem Kanal lesen
921 
922 void SbiIoSystem::Read( ByteString& rBuf, short n )
923 {
924 	if( !nChan )
925 		ReadCon( rBuf );
926 	else if( !pChan[ nChan ] )
927 		nError = SbERR_BAD_CHANNEL;
928 	else
929 		nError = pChan[ nChan ]->Read( rBuf, n );
930 }
931 
932 char SbiIoSystem::Read()
933 {
934 	char ch = ' ';
935 	if( !nChan )
936 	{
937 		if( !aIn.Len() )
938 		{
939 			ReadCon( aIn );
940 			aIn += '\n';
941 		}
942 		ch = aIn.GetBuffer()[0];
943 		aIn.Erase( 0, 1 );
944 	}
945 	else if( !pChan[ nChan ] )
946 		nError = SbERR_BAD_CHANNEL;
947 	else
948 		nError = pChan[ nChan ]->Read( ch );
949 	return ch;
950 }
951 
952 void SbiIoSystem::Write( const ByteString& rBuf, short n )
953 {
954 	if( !nChan )
955 		WriteCon( rBuf );
956 	else if( !pChan[ nChan ] )
957 		nError = SbERR_BAD_CHANNEL;
958 	else
959 		nError = pChan[ nChan ]->Write( rBuf, n );
960 }
961 
962 short SbiIoSystem::NextChannel()
963 {
964 	for( short i = 1; i < CHANNELS; i++ )
965 	{
966 		if( !pChan[ i ] )
967 			return i;
968 	}
969 	nError = SbERR_TOO_MANY_FILES;
970 	return CHANNELS;
971 }
972 
973 // nChannel == 0..CHANNELS-1
974 
975 SbiStream* SbiIoSystem::GetStream( short nChannel ) const
976 {
977 	SbiStream* pRet = 0;
978 	if( nChannel >= 0 && nChannel < CHANNELS )
979 		pRet = pChan[ nChannel ];
980 	return pRet;
981 }
982 
983 void SbiIoSystem::CloseAll(void)
984 {
985 	for( short i = 1; i < CHANNELS; i++ )
986 	{
987 		if( pChan[ i ] )
988 		{
989 			SbError n = pChan[ i ]->Close();
990 			delete pChan[ i ];
991 			pChan[ i ] = NULL;
992 			if( n && !nError )
993 				nError = n;
994 		}
995 	}
996 }
997 
998 /***************************************************************************
999 *
1000 *	Console Support
1001 *
1002 ***************************************************************************/
1003 
1004 // Einlesen einer Zeile von der Console
1005 
1006 void SbiIoSystem::ReadCon( ByteString& rIn )
1007 {
1008 	String aPromptStr( aPrompt, gsl_getSystemTextEncoding() );
1009 	SbiInputDialog aDlg( NULL, aPromptStr );
1010 	if( aDlg.Execute() )
1011 		rIn = ByteString( aDlg.GetInput(), gsl_getSystemTextEncoding() );
1012 	else
1013 		nError = SbERR_USER_ABORT;
1014 	aPrompt.Erase();
1015 }
1016 
1017 // Ausgabe einer MessageBox, wenn im Console-Puffer ein CR ist
1018 
1019 void SbiIoSystem::WriteCon( const ByteString& rText )
1020 {
1021 	aOut += rText;
1022 	sal_uInt16 n1 = aOut.Search( '\n' );
1023 	sal_uInt16 n2 = aOut.Search( '\r' );
1024 	if( n1 != STRING_NOTFOUND || n2 != STRING_NOTFOUND )
1025 	{
1026 		if( n1 == STRING_NOTFOUND ) n1 = n2;
1027 		else
1028 		if( n2 == STRING_NOTFOUND ) n2 = n1;
1029 		if( n1 > n2 ) n1 = n2;
1030 		ByteString s( aOut.Copy( 0, n1 ) );
1031 		aOut.Erase( 0, n1 );
1032 		while( aOut.GetBuffer()[0] == '\n' || aOut.GetBuffer()[0] == '\r' )
1033 			aOut.Erase( 0, 1 );
1034 		String aStr( s, gsl_getSystemTextEncoding() );
1035         {
1036             vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1037 		    if( !MessBox( GetpApp()->GetDefDialogParent(),
1038 					    WinBits( WB_OK_CANCEL | WB_DEF_OK ),
1039 					    String(), aStr ).Execute() )
1040 			    nError = SbERR_USER_ABORT;
1041         }
1042 	}
1043 }
1044 
1045