tools/source/stream/strmos2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: strmos2.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <string.h>
  32 #include <limits.h>
  33
  34 #define INCL_PM
  35 #define INCL_DOS
  36 #define INCL_DOSERRORS
  37 #include <svpm.h>
  38
  39 #include <tools/debug.hxx>
  40 #include <tools/fsys.hxx>
  41 #include <tools/stream.hxx>
  42
  43 // class FileBase
  44 #include <osl/file.hxx>
  45
  46 using namespace osl;
  47
  48 // class FileBase
  49 #ifndef _OSL_FILE_HXX_
  50 #include <osl/file.hxx>
  51 #endif
  52
  53 using namespace osl;
  54
  55 // -----------------------------------------------------------------------
  56
  57 // --------------
  58 // - StreamData -
  59 // --------------
  60
  61 class StreamData
  62 {
  63 public:
  64     HFILE   hFile;
  65     BOOL    bIsEof;
  66
  67             StreamData()
  68             {
  69                 hFile = 0;
  70                 bIsEof = TRUE;
  71             }
  72 };
  73
  74 // -----------------------------------------------------------------------
  75
  76 ULONG GetSvError( APIRET nPMError )
  77 {
  78     static struct { APIRET pm; ULONG sv; } errArr[] =
  79     {
  80         { ERROR_FILE_NOT_FOUND,         SVSTREAM_FILE_NOT_FOUND },
  81         { ERROR_PATH_NOT_FOUND,         SVSTREAM_PATH_NOT_FOUND },
  82         { ERROR_TOO_MANY_OPEN_FILES,    SVSTREAM_TOO_MANY_OPEN_FILES },
  83         { ERROR_ACCESS_DENIED,          SVSTREAM_ACCESS_DENIED },
  84         { ERROR_INVALID_ACCESS,         SVSTREAM_INVALID_ACCESS },
  85         { ERROR_SHARING_VIOLATION,      SVSTREAM_SHARING_VIOLATION },
  86         { ERROR_SHARING_BUFFER_EXCEEDED,SVSTREAM_SHARE_BUFF_EXCEEDED },
  87         { ERROR_CANNOT_MAKE,            SVSTREAM_CANNOT_MAKE },
  88         { ERROR_INVALID_PARAMETER,      SVSTREAM_INVALID_PARAMETER },
  89         { ERROR_DRIVE_LOCKED,           SVSTREAM_LOCKING_VIOLATION },
  90         { ERROR_LOCK_VIOLATION,      SVSTREAM_LOCKING_VIOLATION },
  91         { ERROR_FILENAME_EXCED_RANGE,   SVSTREAM_INVALID_PARAMETER },
  92         { ERROR_ATOMIC_LOCK_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER },
  93         { ERROR_READ_LOCKS_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER },
  94
  95
  96         { 0xFFFF, SVSTREAM_GENERALERROR }
  97     };
  98
  99     ULONG nRetVal = SVSTREAM_GENERALERROR;    // Standardfehler
 100     int i=0;
 101     do
 102     {
 103         if( errArr[i].pm == nPMError )
 104         {
 105             nRetVal = errArr[i].sv;
 106             break;
 107         }
 108         i++;
 109     }
 110     while( errArr[i].pm != 0xFFFF );
 111     return nRetVal;
 112 }
 113
 114 /*************************************************************************
 115 |*
 116 |*    SvFileStream::SvFileStream()
 117 |*
 118 |*    Beschreibung      STREAM.SDW
 119 |*    Ersterstellung    OV 15.06.94
 120 |*    Letzte Aenderung  OV 15.06.94
 121 |*
 122 *************************************************************************/
 123
 124 SvFileStream::SvFileStream( const String& rFileName, StreamMode nOpenMode )
 125 {
 126     bIsOpen             = FALSE;
 127     nLockCounter        = 0;
 128     bIsWritable         = FALSE;
 129     pInstanceData       = new StreamData;
 130
 131     SetBufferSize( 8192 );
 132     // convert URL to SystemPath, if necessary
 133     ::rtl::OUString aFileName, aNormPath;
 134
 135     if ( FileBase::getSystemPathFromFileURL( rFileName, aFileName ) != FileBase::E_None )
 136         aFileName = rFileName;
 137     Open( aFileName, nOpenMode );
 138 }
 139
 140 /*************************************************************************
 141 |*
 142 |*    SvFileStream::SvFileStream()
 143 |*
 144 |*    Beschreibung      STREAM.SDW
 145 |*    Ersterstellung    OV 22.11.94
 146 |*    Letzte Aenderung  OV 22.11.94
 147 |*
 148 *************************************************************************/
 149
 150 SvFileStream::SvFileStream()
 151 {
 152     bIsOpen             = FALSE;
 153     nLockCounter        = 0;
 154     bIsWritable         = FALSE;
 155     pInstanceData       = new StreamData;
 156     SetBufferSize( 8192 );
 157 }
 158
 159 /*************************************************************************
 160 |*
 161 |*    SvFileStream::~SvFileStream()
 162 |*
 163 |*    Beschreibung      STREAM.SDW
 164 |*    Ersterstellung    OV 14.06.94
 165 |*    Letzte Aenderung  OV 14.06.94
 166 |*
 167 *************************************************************************/
 168
 169 SvFileStream::~SvFileStream()
 170 {
 171     Close();
 172     if( pInstanceData )
 173         delete pInstanceData;
 174 }
 175
 176 /*************************************************************************
 177 |*
 178 |*    SvFileStream::GetFileHandle()
 179 |*
 180 |*    Beschreibung      STREAM.SDW
 181 |*    Ersterstellung    OV 14.06.94
 182 |*    Letzte Aenderung  OV 14.06.94
 183 |*
 184 *************************************************************************/
 185
 186 ULONG SvFileStream::GetFileHandle() const
 187 {
 188     return (ULONG)pInstanceData->hFile;
 189 }
 190
 191 /*************************************************************************
 192 |*
 193 |*    SvFileStream::IsA()
 194 |*
 195 |*    Beschreibung      STREAM.SDW
 196 |*    Ersterstellung    OV 14.06.94
 197 |*    Letzte Aenderung  OV 14.06.94
 198 |*
 199 *************************************************************************/
 200
 201 USHORT SvFileStream::IsA() const
 202 {
 203     return ID_FILESTREAM;
 204 }
 205
 206 /*************************************************************************
 207 |*
 208 |*    SvFileStream::GetData()
 209 |*
 210 |*    Beschreibung      STREAM.SDW, Prueft nicht Eof; IsEof danach rufbar
 211 |*    Ersterstellung    OV 15.06.94
 212 |*    Letzte Aenderung  OV 15.06.94
 213 |*
 214 *************************************************************************/
 215
 216 ULONG SvFileStream::GetData( void* pData, ULONG nSize )
 217 {
 218 #ifdef DBG_UTIL
 219     ByteString aTraceStr( "SvFileStream::GetData(): " );
 220     aTraceStr += ByteString::CreateFromInt64(nSize);
 221     aTraceStr += " Bytes from ";
 222     aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding());
 223     DBG_TRACE( aTraceStr.GetBuffer() );
 224 #endif
 225
 226     ULONG nCount = 0L;
 227     if( IsOpen() )
 228     {
 229         APIRET nResult;
 230         nResult = DosRead( pInstanceData->hFile,(PVOID)pData,nSize,&nCount );
 231         if( nResult )
 232             SetError(::GetSvError(nResult) );
 233     }
 234     return nCount;
 235 }
 236
 237 /*************************************************************************
 238 |*
 239 |*    SvFileStream::PutData()
 240 |*
 241 |*    Beschreibung      STREAM.SDW
 242 |*    Ersterstellung    OV 15.06.94
 243 |*    Letzte Aenderung  OV 15.06.94
 244 |*
 245 *************************************************************************/
 246
 247 ULONG SvFileStream::PutData( const void* pData, ULONG nSize )
 248 {
 249 #ifdef DBG_UTIL
 250     ByteString aTraceStr( "SvFileStrean::PutData: " );
 251     aTraceStr += ByteString::CreateFromInt64(nSize);
 252     aTraceStr += " Bytes to ";
 253     aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding());
 254     DBG_TRACE( aTraceStr.GetBuffer() );
 255 #endif
 256
 257     ULONG nCount = 0L;
 258     if( IsOpen() )
 259     {
 260         APIRET nResult;
 261         nResult = DosWrite( pInstanceData->hFile,(PVOID)pData,nSize,&nCount );
 262         if( nResult )
 263             SetError(::GetSvError(nResult) );
 264         else if( !nCount )
 265             SetError( SVSTREAM_DISK_FULL );
 266     }
 267     return nCount;
 268 }
 269
 270 /*************************************************************************
 271 |*
 272 |*    SvFileStream::SeekPos()
 273 |*
 274 |*    Beschreibung      STREAM.SDW
 275 |*    Ersterstellung    OV 15.06.94
 276 |*    Letzte Aenderung  OV 15.06.94
 277 |*
 278 *************************************************************************/
 279
 280 ULONG SvFileStream::SeekPos( ULONG nPos )
 281 {
 282     ULONG nNewPos = 0L;
 283     if( IsOpen() )
 284     {
 285         APIRET nResult;
 286
 287         if( nPos != STREAM_SEEK_TO_END )
 288             nResult = DosSetFilePtr( pInstanceData->hFile,(long)nPos,
 289                  FILE_BEGIN, &nNewPos );
 290         else
 291             nResult = DosSetFilePtr( pInstanceData->hFile,0L,
 292                  FILE_END, &nNewPos );
 293
 294         if( nResult )
 295             SetError(::GetSvError(nResult) );
 296     }
 297     else
 298         SetError( SVSTREAM_GENERALERROR );
 299     return nNewPos;
 300 }
 301
 302 /*************************************************************************
 303 |*
 304 |*    SvFileStream::Tell()
 305 |*
 306 |*    Beschreibung      STREAM.SDW
 307 |*    Ersterstellung    OV 15.06.94
 308 |*    Letzte Aenderung  OV 15.06.94
 309 |*
 310 *************************************************************************/
 311 /*
 312 ULONG SvFileStream::Tell()
 313 {
 314     ULONG nPos = 0L;
 315
 316     if( IsOpen() )
 317     {
 318         APIRET nResult;
 319         nResult = DosSetFilePtr(pInstanceData->hFile,0L,FILE_CURRENT,&nPos);
 320         if( nResult )
 321             SetError(::GetSvError(nResult) );
 322     }
 323     return nPos;
 324 }
 325 */
 326
 327 /*************************************************************************
 328 |*
 329 |*    SvFileStream::FlushData()
 330 |*
 331 |*    Beschreibung      STREAM.SDW
 332 |*    Ersterstellung    OV 15.06.94
 333 |*    Letzte Aenderung  OV 15.06.94
 334 |*
 335 *************************************************************************/
 336
 337 void SvFileStream::FlushData()
 338 {
 339     if( IsOpen() )
 340     {
 341         APIRET nResult;
 342         nResult = DosResetBuffer(pInstanceData->hFile );
 343         if( nResult )
 344             SetError(::GetSvError(nResult) );
 345     }
 346 }
 347
 348 /*************************************************************************
 349 |*
 350 |*    SvFileStream::LockRange()
 351 |*
 352 |*    Beschreibung      STREAM.SDW
 353 |*    Ersterstellung    OV 15.06.94
 354 |*    Letzte Aenderung  OV 15.06.94
 355 |*
 356 *************************************************************************/
 357
 358 sal_Bool SvFileStream::LockRange( ULONG nByteOffset, ULONG nBytes )
 359 {
 360     sal_Bool bRetVal = FALSE;
 361     if( IsOpen() )
 362     {
 363         APIRET   nResult;
 364         FILELOCK aLockArea, aUnlockArea;
 365         aUnlockArea.lOffset = 0L;
 366         aUnlockArea.lRange      = 0L;
 367         aLockArea.lOffset       = (long)nByteOffset;
 368         aLockArea.lRange        = (long)nBytes;
 369
 370         nResult = DosSetFileLocks(pInstanceData->hFile,
 371             &aUnlockArea, &aLockArea,
 372             1000UL,  // Zeit in ms bis Abbruch
 373             0L       // kein Atomic-Lock
 374         );
 375
 376         if( nResult )
 377             SetError(::GetSvError(nResult) );
 378         else
 379             bRetVal = TRUE;
 380     }
 381     return bRetVal;
 382 }
 383
 384 /*************************************************************************
 385 |*
 386 |*    SvFileStream::UnlockRange()
 387 |*
 388 |*    Beschreibung      STREAM.SDW
 389 |*    Ersterstellung    OV 15.06.94
 390 |*    Letzte Aenderung  OV 15.06.94
 391 |*
 392 *************************************************************************/
 393
 394 sal_Bool SvFileStream::UnlockRange( ULONG nByteOffset, ULONG nBytes )
 395 {
 396     sal_Bool bRetVal = FALSE;
 397     if( IsOpen() )
 398     {
 399         APIRET   nResult;
 400         FILELOCK aLockArea, aUnlockArea;
 401         aLockArea.lOffset       = 0L;
 402         aLockArea.lRange        = 0L;
 403         aUnlockArea.lOffset = (long)nByteOffset;
 404         aUnlockArea.lRange      = (long)nBytes;
 405
 406         nResult = DosSetFileLocks(pInstanceData->hFile,
 407             &aUnlockArea, &aLockArea,
 408             1000UL,  // Zeit in ms bis Abbruch
 409             0L       // kein Atomic-Lock
 410         );
 411
 412         if( nResult )
 413             SetError(::GetSvError(nResult) );
 414         else
 415             bRetVal = TRUE;
 416     }
 417     return bRetVal;
 418 }
 419
 420 /*************************************************************************
 421 |*
 422 |*    SvFileStream::LockFile()
 423 |*
 424 |*    Beschreibung      STREAM.SDW
 425 |*    Ersterstellung    OV 15.06.94
 426 |*    Letzte Aenderung  OV 15.06.94
 427 |*
 428 *************************************************************************/
 429
 430 sal_Bool SvFileStream::LockFile()
 431 {
 432     sal_Bool bRetVal = FALSE;
 433     if( !nLockCounter )
 434     {
 435         if( LockRange( 0L, LONG_MAX ) )
 436         {
 437             nLockCounter = 1;
 438             bRetVal = TRUE;
 439         }
 440     }
 441     else
 442     {
 443         nLockCounter++;
 444         bRetVal = TRUE;
 445     }
 446     return bRetVal;
 447 }
 448
 449 /*************************************************************************
 450 |*
 451 |*    SvFileStream::UnlockFile()
 452 |*
 453 |*    Beschreibung      STREAM.SDW
 454 |*    Ersterstellung    OV 15.06.94
 455 |*    Letzte Aenderung  OV 15.06.94
 456 |*
 457 *************************************************************************/
 458
 459 sal_Bool SvFileStream::UnlockFile()
 460 {
 461     sal_Bool bRetVal = FALSE;
 462     if( nLockCounter > 0)
 463     {
 464         if( nLockCounter == 1)
 465         {
 466             if( UnlockRange( 0L, LONG_MAX ) )
 467             {
 468                 nLockCounter = 0;
 469                 bRetVal = TRUE;
 470             }
 471         }
 472         else
 473         {
 474             nLockCounter--;
 475             bRetVal = TRUE;
 476         }
 477     }
 478     return bRetVal;
 479 }
 480
 481 /*************************************************************************
 482 |*
 483 |*    SvFileStream::Open()
 484 |*
 485 |*    Beschreibung      STREAM.SDW
 486 |*    Ersterstellung    OV 15.06.94
 487 |*    Letzte Aenderung  OV 15.06.94
 488 |*
 489 *************************************************************************/
 490
 491 #if 0
 492 BOOL createLongNameEA   ( const PCSZ pszPath, ULONG ulAttributes, const String& aLongName );
 493 #endif
 494
 495 void SvFileStream::Open( const String& rFilename, StreamMode nOpenMode )
 496 {
 497         String aParsedFilename;
 498
 499 #if 0
 500         if      ( Folder::IsAvailable() && (rFilename.Search('{') < 9) )
 501         {
 502                 String          aVirtualPart;
 503                 String          aRealPart;
 504                 String          aVirtualPath;
 505                 ItemIDPath      aVirtualURL;
 506                 ULONG           nDivider = 0;
 507
 508                 String          aVirtualString(rFilename);
 509
 510                 for (int x=aVirtualString.Len(); x>0; x--)
 511                 {
 512                         if (aVirtualString.Copy(x,1).Compare("}")==COMPARE_EQUAL)
 513                         {
 514                                 nDivider = x;
 515                                 break;
 516                         }
 517                 }
 518
 519                 aVirtualPart = aVirtualString.Copy(0,nDivider+1);
 520                 aRealPart = aVirtualString.Copy(nDivider+2);
 521
 522                 aVirtualURL  = aVirtualPart;
 523                 aVirtualPath = aVirtualURL.GetHostNotationPath();
 524
 525                 DirEntry aTempDirEntry(aVirtualPath);
 526
 527                 aTempDirEntry += aRealPart;
 528
 529                 aParsedFilename = aTempDirEntry.GetFull();
 530         }
 531         else
 532 #endif // 0
 533         {
 534                 aParsedFilename = rFilename;
 535         }
 536
 537     Close();
 538     SvStream::ClearBuffer();
 539
 540     ULONG   nActionTaken;
 541     ULONG   nOpenAction     = 0L;
 542     ULONG   nShareBits      = 0L;
 543     ULONG   nReadWriteBits  = 0L;
 544
 545     eStreamMode = nOpenMode;
 546     eStreamMode &= ~STREAM_TRUNC; // beim ReOpen nicht cutten
 547
 548     nOpenMode |= STREAM_SHARE_DENYNONE;  // definierten Zustand garantieren
 549
 550     // ********* Zugriffsflags ***********
 551     if( nOpenMode & STREAM_SHARE_DENYNONE)
 552         nShareBits = OPEN_SHARE_DENYNONE;
 553
 554     if( nOpenMode & STREAM_SHARE_DENYREAD)
 555         nShareBits = OPEN_SHARE_DENYREAD;
 556
 557     if( nOpenMode & STREAM_SHARE_DENYWRITE)
 558         nShareBits = OPEN_SHARE_DENYWRITE;
 559
 560     if( nOpenMode & STREAM_SHARE_DENYALL)
 561         nShareBits = OPEN_SHARE_DENYREADWRITE;
 562
 563         if( (nOpenMode & STREAM_READ) )
 564     {
 565         if( nOpenMode & STREAM_WRITE )
 566             nReadWriteBits |= OPEN_ACCESS_READWRITE;
 567         else
 568         {
 569             nReadWriteBits |= OPEN_ACCESS_READONLY;
 570             nOpenMode |= STREAM_NOCREATE;
 571         }
 572     }
 573     else
 574         nReadWriteBits |= OPEN_ACCESS_WRITEONLY;
 575
 576
 577     if( nOpenMode & STREAM_NOCREATE )
 578     {
 579         // Datei nicht erzeugen
 580         nOpenAction = OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
 581     }
 582     else
 583     {
 584         // Datei erzeugen, wenn nicht vorhanden
 585         nOpenAction = OPEN_ACTION_CREATE_IF_NEW;
 586         if( nOpenMode & STREAM_TRUNC )
 587             // Auf Nullaenge kuerzen, wenn existiert
 588             nOpenAction |= OPEN_ACTION_REPLACE_IF_EXISTS;
 589         else
 590             // Inhalt der Datei nicht wegwerfen
 591             nOpenAction |= OPEN_ACTION_OPEN_IF_EXISTS;
 592     }
 593
 594 #if 0 // YD
 595     //
 596     // resolves long FAT names used by OS2
 597     //
 598     BOOL bIsLongOS2=FALSE;
 599     if (Folder::IsAvailable())
 600     {
 601         DirEntry aDirEntry(rFilename);
 602         if  (aDirEntry.IsLongNameOnFAT())
 603         {
 604             // in kurzen Pfad wandeln
 605             ItemIDPath      aItemIDPath(rFilename);
 606             aParsedFilename = aItemIDPath.GetHostNotationPath();
 607             bIsLongOS2 = TRUE;
 608         }
 609     }
 610 #endif
 611
 612     aFilename = aParsedFilename;
 613     ByteString aFileNameA( aFilename, gsl_getSystemTextEncoding());
 614     FSysRedirector::DoRedirect( aFilename );
 615
 616 #ifdef DBG_UTIL
 617     ByteString aTraceStr( "SvFileStream::Open(): " );
 618     aTraceStr +=  aFileNameA;
 619     DBG_TRACE( aTraceStr.GetBuffer() );
 620 #endif
 621
 622     APIRET nRet = DosOpen( aFileNameA.GetBuffer(), &pInstanceData->hFile,
 623     &nActionTaken, 0L, FILE_NORMAL, nOpenAction,
 624     nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L);
 625
 626     if( nRet == ERROR_TOO_MANY_OPEN_FILES )
 627     {
 628         long nToAdd = 10;
 629         ULONG nCurMaxFH;
 630         nRet = DosSetRelMaxFH( &nToAdd, &nCurMaxFH );
 631         nRet = DosOpen( aFileNameA.GetBuffer(), &pInstanceData->hFile,
 632         &nActionTaken, 0L, FILE_NORMAL, nOpenAction,
 633         nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L);
 634     }
 635
 636     // Bei Fehler pruefen, ob wir lesen duerfen
 637     if( nRet==ERROR_ACCESS_DENIED || nRet==ERROR_SHARING_VIOLATION )
 638     {
 639         nReadWriteBits = OPEN_ACCESS_READONLY;
 640         nRet = DosOpen( aFileNameA.GetBuffer(), &pInstanceData->hFile,
 641             &nActionTaken, 0L, FILE_NORMAL, nOpenAction,
 642             nReadWriteBits | nShareBits | OPEN_FLAGS_NOINHERIT, 0L);
 643     }
 644
 645         if( nRet )
 646     {
 647         bIsOpen = FALSE;
 648         SetError(::GetSvError(nRet) );
 649     }
 650     else
 651     {
 652         bIsOpen     = TRUE;
 653         pInstanceData->bIsEof = FALSE;
 654         if( nReadWriteBits != OPEN_ACCESS_READONLY )
 655             bIsWritable = TRUE;
 656     }
 657
 658 #if 0
 659     if (bIsOpen && bIsLongOS2)
 660     {
 661         //file schließen, da sonst createLongName u.U. nicht möglich
 662         Close();
 663
 664         // erzeugtem File langen Namen geben
 665         DirEntry aDirEntry(rFilename);
 666         createLongNameEA(aFileNameA.GetBuffer(),  FILE_NORMAL, aDirEntry.GetName());
 667
 668         // und wieder oeffnen
 669         ReOpen();
 670     }
 671 #endif
 672
 673 }
 674
 675 /*************************************************************************
 676 |*
 677 |*    SvFileStream::ReOpen()
 678 |*
 679 |*    Beschreibung      STREAM.SDW
 680 |*    Ersterstellung    OV 15.06.94
 681 |*    Letzte Aenderung  OV 15.06.94
 682 |*
 683 *************************************************************************/
 684
 685 void SvFileStream::ReOpen()
 686 {
 687     if( !bIsOpen && aFilename.Len() )
 688         Open( aFilename, eStreamMode );
 689 }
 690
 691 /*************************************************************************
 692 |*
 693 |*    SvFileStream::Close()
 694 |*
 695 |*    Beschreibung      STREAM.SDW
 696 |*    Ersterstellung    OV 15.06.94
 697 |*    Letzte Aenderung  OV 15.06.94
 698 |*
 699 *************************************************************************/
 700
 701 void SvFileStream::Close()
 702 {
 703     if( IsOpen() )
 704     {
 705 #ifdef DBG_UTIL
 706         ByteString aTraceStr( "SvFileStream::Close(): " );
 707         aTraceStr += ByteString(aFilename, osl_getThreadTextEncoding());
 708         DBG_TRACE( aTraceStr.GetBuffer() );
 709 #endif
 710
 711         if( nLockCounter )
 712         {
 713             nLockCounter = 1;
 714             UnlockFile();
 715         }
 716         Flush();
 717         DosClose( pInstanceData->hFile );
 718     }
 719
 720     bIsOpen     = FALSE;
 721     nLockCounter= 0;
 722     bIsWritable = FALSE;
 723     pInstanceData->bIsEof = TRUE;
 724     SvStream::ClearBuffer();
 725     SvStream::ClearError();
 726 }
 727
 728 /*************************************************************************
 729 |*
 730 |*    SvFileStream::ResetError()
 731 |*
 732 |*    Beschreibung      STREAM.SDW; Setzt Filepointer auf Dateianfang
 733 |*    Ersterstellung    OV 15.06.94
 734 |*    Letzte Aenderung  OV 15.06.94
 735 |*
 736 *************************************************************************/
 737
 738 void SvFileStream::ResetError()
 739 {
 740     SvStream::ClearError();
 741 }
 742
 743 /*************************************************************************
 744 |*
 745 |*    SvFileStream::SetSize()
 746 |*
 747 |*    Beschreibung
 748 |*    Ersterstellung    OV 19.10.95
 749 |*    Letzte Aenderung  OV 19.10.95
 750 |*
 751 *************************************************************************/
 752
 753 void SvFileStream::SetSize( ULONG nSize )
 754 {
 755     if( IsOpen() )
 756     {
 757         APIRET nRet = DosSetFileSize( pInstanceData->hFile, nSize );
 758         if( nRet )
 759             SetError( ::GetSvError( nRet ) );
 760     }
 761 }
 762
 763 #if 0
 764 /*************************************************************************
 765 |*
 766 |*    SvSharedMemoryStream::AllocateMemory()
 767 |*
 768 |*    Beschreibung      STREAM.SDW
 769 |*    Ersterstellung    CL 05.05.95
 770 |*    Letzte Aenderung  CL 05.05.95
 771 |*
 772 *************************************************************************/
 773
 774 sal_Bool SvSharedMemoryStream::AllocateMemory( ULONG nNewSize )
 775 {
 776         DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2");
 777         DBG_ASSERT(nNewSize,"Cannot allocate zero Bytes");
 778         APIRET nRet = DosAllocSharedMem( (void**)&pBuf, (PSZ)NULL, nNewSize,
 779                                      PAG_READ | PAG_WRITE | PAG_COMMIT |
 780                                      OBJ_GIVEABLE | OBJ_GETTABLE | OBJ_ANY);
 781     return( nRet == 0 );
 782 }
 783
 784 /*************************************************************************
 785 |*
 786 |*    SvSharedMemoryStream::ReAllocateMemory()   (Bozo-Algorithmus)
 787 |*
 788 |*    Beschreibung      STREAM.SDW
 789 |*    Ersterstellung    CL 05.05.95
 790 |*    Letzte Aenderung  CL 05.05.95
 791 |*
 792 *************************************************************************/
 793
 794 sal_Bool SvSharedMemoryStream::ReAllocateMemory( long nDiff )
 795 {
 796     DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2");
 797     sal_Bool bRetVal    = FALSE;
 798     ULONG nNewSize  = nSize + nDiff;
 799         if( nNewSize )
 800         {
 801                 // neuen Speicher nicht ueber AllocateMemory holen, da wir den
 802                 // alten Speicher behalten wollen, falls nicht genuegend Platz
 803                 // fuer den neuen Block da ist
 804                 char* pNewBuf;
 805             APIRET nRet = DosAllocSharedMem( (void**)&pNewBuf,(PSZ)NULL,nNewSize,
 806                                 PAG_READ | PAG_WRITE | PAG_COMMIT |
 807                                 OBJ_GIVEABLE | OBJ_GETTABLE | OBJ_ANY);
 808             DBG_ASSERT(!nRet,"DosAllocSharedMem failed");
 809
 810             if( !nRet )
 811             {
 812                 bRetVal = TRUE; // Success!
 813                 if( nNewSize < nSize )      // Verkleinern ?
 814                 {
 815                     memcpy( pNewBuf, pBuf, (size_t)nNewSize );
 816                     if( nPos > nNewSize )
 817                         nPos = 0L;
 818                     if( nEndOfData >= nNewSize )
 819                         nEndOfData = nNewSize-1L;
 820                 }
 821                 else
 822                     memcpy( pNewBuf, pBuf, (size_t)nSize );
 823
 824                 FreeMemory(); // den alten Block loeschen ...
 825
 826                 // und den neuen Block in Dienst stellen
 827                 pBuf  = (sal_uInt8*)pNewBuf;
 828                 nSize = nNewSize;
 829             }
 830         }
 831         else
 832         {
 833                 bRetVal = TRUE;
 834                 FreeMemory();
 835                 pBuf = 0;
 836                 nSize = 0;
 837                 nEndOfData = 0;
 838         }
 839     return bRetVal;
 840 }
 841
 842 void SvSharedMemoryStream::FreeMemory()
 843 {
 844     DBG_ASSERT(aHandle==0,"Keine Handles unter OS/2");
 845     DosFreeMem( pBuf );
 846 }
 847
 848 /*************************************************************************
 849 |*
 850 |*    SvSharedMemoryStream::SetHandle()
 851 |*
 852 |*    Beschreibung      STREAM.SDW
 853 |*    Ersterstellung    OV 05.10.95
 854 |*    Letzte Aenderung  OV 05.10.95
 855 |*
 856 *************************************************************************/
 857
 858 void* SvSharedMemoryStream::SetHandle( void* aNewHandle, sal_Size nSize,
 859                                        sal_Bool bOwnsData, sal_Size nEOF )
 860 {
 861     DBG_ERROR("OS/2 does not support memory handles");
 862     // return SetBuffer(aNewHandle, nSize, bOwnsData, nEOF );
 863     return 0;
 864 }
 865
 866
 867 #endif // 0