tools/source/stream/strmwnt.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: strmwnt.cxx,v $
  10  * $Revision: 1.9 $
  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 // no include "precompiled_tools.hxx" because this file is included in strmsys.cxx
  32
  33 /*
  34     Todo: StreamMode <-> AllocateMemory
  35 */
  36
  37 #include <string.h>
  38 #include <limits.h>
  39
  40 #include <tools/svwin.h>
  41
  42 #include <tools/debug.hxx>
  43 #include <tools/fsys.hxx>
  44 #include <tools/stream.hxx>
  45
  46 // class FileBase
  47 #include <osl/file.hxx>
  48 using namespace osl;
  49
  50 // -----------------------------------------------------------------------
  51
  52 // --------------
  53 // - StreamData -
  54 // --------------
  55
  56 class StreamData
  57 {
  58 public:
  59     HANDLE      hFile;
  60
  61                 StreamData()
  62                 {
  63                     hFile = 0;
  64                 }
  65 };
  66
  67 // -----------------------------------------------------------------------
  68
  69 static ULONG GetSvError( DWORD nWntError )
  70 {
  71     static struct { DWORD wnt; ULONG sv; } errArr[] =
  72     {
  73         { ERROR_SUCCESS,                SVSTREAM_OK },
  74         { ERROR_ACCESS_DENIED,          SVSTREAM_ACCESS_DENIED },
  75         { ERROR_ACCOUNT_DISABLED,       SVSTREAM_ACCESS_DENIED },
  76         { ERROR_ACCOUNT_EXPIRED,        SVSTREAM_ACCESS_DENIED },
  77         { ERROR_ACCOUNT_RESTRICTION,    SVSTREAM_ACCESS_DENIED },
  78         { ERROR_ATOMIC_LOCKS_NOT_SUPPORTED, SVSTREAM_INVALID_PARAMETER },
  79         { ERROR_BAD_PATHNAME,           SVSTREAM_PATH_NOT_FOUND },
  80         // Filename too long
  81         { ERROR_BUFFER_OVERFLOW,        SVSTREAM_INVALID_PARAMETER },
  82         { ERROR_DIRECTORY,              SVSTREAM_INVALID_PARAMETER },
  83         { ERROR_DRIVE_LOCKED,           SVSTREAM_LOCKING_VIOLATION },
  84         { ERROR_FILE_NOT_FOUND,         SVSTREAM_FILE_NOT_FOUND },
  85         { ERROR_FILENAME_EXCED_RANGE,   SVSTREAM_INVALID_PARAMETER },
  86         { ERROR_INVALID_ACCESS,         SVSTREAM_INVALID_ACCESS },
  87         { ERROR_INVALID_DRIVE,          SVSTREAM_PATH_NOT_FOUND },
  88         { ERROR_INVALID_HANDLE,         SVSTREAM_INVALID_HANDLE },
  89         { ERROR_INVALID_NAME,           SVSTREAM_PATH_NOT_FOUND },
  90         { ERROR_INVALID_PARAMETER,      SVSTREAM_INVALID_PARAMETER },
  91         { ERROR_IS_SUBST_PATH,          SVSTREAM_INVALID_PARAMETER },
  92         { ERROR_IS_SUBST_TARGET,        SVSTREAM_INVALID_PARAMETER },
  93         { ERROR_LOCK_FAILED,            SVSTREAM_LOCKING_VIOLATION },
  94         { ERROR_LOCK_VIOLATION,         SVSTREAM_LOCKING_VIOLATION },
  95         { ERROR_NEGATIVE_SEEK,          SVSTREAM_SEEK_ERROR },
  96         { ERROR_PATH_NOT_FOUND,         SVSTREAM_PATH_NOT_FOUND },
  97         { ERROR_READ_FAULT,             SVSTREAM_READ_ERROR },
  98         { ERROR_SEEK,                   SVSTREAM_SEEK_ERROR },
  99         { ERROR_SEEK_ON_DEVICE,         SVSTREAM_SEEK_ERROR },
 100         { ERROR_SHARING_BUFFER_EXCEEDED,SVSTREAM_SHARE_BUFF_EXCEEDED },
 101         { ERROR_SHARING_PAUSED,         SVSTREAM_SHARING_VIOLATION },
 102         { ERROR_SHARING_VIOLATION,      SVSTREAM_SHARING_VIOLATION },
 103         { ERROR_TOO_MANY_OPEN_FILES,    SVSTREAM_TOO_MANY_OPEN_FILES },
 104         { ERROR_WRITE_FAULT,            SVSTREAM_WRITE_ERROR },
 105         { ERROR_WRITE_PROTECT,          SVSTREAM_ACCESS_DENIED },
 106         { ERROR_DISK_FULL,              SVSTREAM_DISK_FULL },
 107
 108         { (DWORD)0xFFFFFFFF, SVSTREAM_GENERALERROR }
 109     };
 110
 111     ULONG nRetVal = SVSTREAM_GENERALERROR;    // Standardfehler
 112     int i=0;
 113     do
 114     {
 115         if( errArr[i].wnt == nWntError )
 116         {
 117             nRetVal = errArr[i].sv;
 118             break;
 119         }
 120         i++;
 121     } while( errArr[i].wnt != (DWORD)0xFFFFFFFF );
 122     return nRetVal;
 123 }
 124
 125 /*************************************************************************
 126 |*
 127 |*    SvFileStream::SvFileStream()
 128 |*
 129 |*    Beschreibung      STREAM.SDW
 130 |*    Ersterstellung    OV 17.06.94
 131 |*    Letzte Aenderung  TPF 15.07.98
 132 |*
 133 *************************************************************************/
 134
 135 SvFileStream::SvFileStream( const String& rFileName, StreamMode nMode )
 136 {
 137     bIsOpen             = FALSE;
 138     nLockCounter        = 0;
 139     bIsWritable         = FALSE;
 140     pInstanceData       = new StreamData;
 141
 142     SetBufferSize( 8192 );
 143     // convert URL to SystemPath, if necessary
 144     ::rtl::OUString aFileName, aNormPath;
 145
 146     if ( FileBase::getSystemPathFromFileURL( rFileName, aFileName ) != FileBase::E_None )
 147         aFileName = rFileName;
 148     Open( aFileName, nMode );
 149 }
 150
 151 /*************************************************************************
 152 |*
 153 |*    SvFileStream::SvFileStream()
 154 |*
 155 |*    Beschreibung      STREAM.SDW
 156 |*    Ersterstellung    OV 22.11.94
 157 |*    Letzte Aenderung  TPF 15.07.98
 158 |*
 159 *************************************************************************/
 160
 161 SvFileStream::SvFileStream()
 162 {
 163     bIsOpen             = FALSE;
 164     nLockCounter        = 0;
 165     bIsWritable         = FALSE;
 166     pInstanceData       = new StreamData;
 167
 168     SetBufferSize( 8192 );
 169 }
 170
 171 /*************************************************************************
 172 |*
 173 |*    SvFileStream::~SvFileStream()
 174 |*
 175 |*    Beschreibung      STREAM.SDW
 176 |*    Ersterstellung    OV 14.06.94
 177 |*    Letzte Aenderung  OV 14.06.94
 178 |*
 179 *************************************************************************/
 180
 181 SvFileStream::~SvFileStream()
 182 {
 183     Close();
 184     if (pInstanceData)
 185         delete pInstanceData;
 186 }
 187
 188 /*************************************************************************
 189 |*
 190 |*    SvFileStream::GetFileHandle()
 191 |*
 192 |*    Beschreibung      STREAM.SDW
 193 |*    Ersterstellung    OV 14.06.94
 194 |*    Letzte Aenderung  OV 14.06.94
 195 |*
 196 *************************************************************************/
 197
 198 ULONG SvFileStream::GetFileHandle() const
 199 {
 200     return (ULONG)pInstanceData->hFile;
 201 }
 202
 203 /*************************************************************************
 204 |*
 205 |*    SvFileStream::IsA()
 206 |*
 207 |*    Beschreibung      STREAM.SDW
 208 |*    Ersterstellung    OV 14.06.94
 209 |*    Letzte Aenderung  OV 14.06.94
 210 |*
 211 *************************************************************************/
 212
 213 USHORT SvFileStream::IsA() const
 214 {
 215     return ID_FILESTREAM;
 216 }
 217
 218 /*************************************************************************
 219 |*
 220 |*    SvFileStream::GetData()
 221 |*
 222 |*    Beschreibung      STREAM.SDW, Prueft nicht Eof; IsEof danach rufbar
 223 |*    Ersterstellung    OV 15.06.94
 224 |*    Letzte Aenderung  TPF 15.07.98
 225 |*
 226 *************************************************************************/
 227
 228 ULONG SvFileStream::GetData( void* pData, ULONG nSize )
 229 {
 230     DWORD nCount = 0;
 231     if( IsOpen() )
 232     {
 233         bool bResult = ReadFile(pInstanceData->hFile,(LPVOID)pData,nSize,&nCount,NULL);
 234         if( !bResult )
 235         {
 236             ULONG nTestError = GetLastError();
 237             SetError(::GetSvError( nTestError ) );
 238         }
 239     }
 240     return (DWORD)nCount;
 241 }
 242
 243 /*************************************************************************
 244 |*
 245 |*    SvFileStream::PutData()
 246 |*
 247 |*    Beschreibung      STREAM.SDW
 248 |*    Ersterstellung    OV 15.06.94
 249 |*    Letzte Aenderung  TPF 15.07.98
 250 |*
 251 *************************************************************************/
 252
 253 ULONG SvFileStream::PutData( const void* pData, ULONG nSize )
 254 {
 255     DWORD nCount = 0;
 256     if( IsOpen() )
 257     {
 258         if(!WriteFile(pInstanceData->hFile,(LPVOID)pData,nSize,&nCount,NULL))
 259             SetError(::GetSvError( GetLastError() ) );
 260     }
 261     return nCount;
 262 }
 263
 264 /*************************************************************************
 265 |*
 266 |*    SvFileStream::SeekPos()
 267 |*
 268 |*    Beschreibung      STREAM.SDW
 269 |*    Ersterstellung    OV 15.06.94
 270 |*    Letzte Aenderung  TPF 15.07.98
 271 |*
 272 *************************************************************************/
 273
 274 ULONG SvFileStream::SeekPos( ULONG nPos )
 275 {
 276     DWORD nNewPos = 0;
 277     if( IsOpen() )
 278     {
 279         if( nPos != STREAM_SEEK_TO_END )
 280             // 64-Bit files werden nicht unterstuetzt
 281             nNewPos=SetFilePointer(pInstanceData->hFile,nPos,NULL,FILE_BEGIN);
 282         else
 283             nNewPos=SetFilePointer(pInstanceData->hFile,0L,NULL,FILE_END);
 284
 285         if( nNewPos == 0xFFFFFFFF )
 286         {
 287             SetError(::GetSvError( GetLastError() ) );
 288             nNewPos = 0L;
 289         }
 290     }
 291     else
 292         SetError( SVSTREAM_GENERALERROR );
 293     return (ULONG)nNewPos;
 294 }
 295
 296 /*************************************************************************
 297 |*
 298 |*    SvFileStream::Tell()
 299 |*
 300 |*    Beschreibung      STREAM.SDW
 301 |*    Ersterstellung    OV 15.06.94
 302 |*    Letzte Aenderung  OV 15.06.94
 303 |*
 304 *************************************************************************/
 305 /*
 306 ULONG SvFileStream::Tell()
 307 {
 308     ULONG nPos = 0L;
 309
 310     if( IsOpen() )
 311     {
 312         DWORD nPos;
 313         nPos = SetFilePointer(pInstanceData->hFile,0L,NULL,FILE_CURRENT);
 314         if( nPos = 0xFFFFFFFF )
 315         {
 316             SetError( ::GetSvError( GetLastError() ) );
 317             nPos = 0L;
 318         }
 319     }
 320     return nPos;
 321 }
 322 */
 323
 324 /*************************************************************************
 325 |*
 326 |*    SvFileStream::FlushData()
 327 |*
 328 |*    Beschreibung      STREAM.SDW
 329 |*    Ersterstellung    OV 15.06.94
 330 |*    Letzte Aenderung  TPF 15.07.98
 331 |*
 332 *************************************************************************/
 333
 334 void SvFileStream::FlushData()
 335 {
 336     if( IsOpen() )
 337     {
 338         if( !FlushFileBuffers(pInstanceData->hFile) )
 339             SetError(::GetSvError(GetLastError()));
 340     }
 341 }
 342
 343 /*************************************************************************
 344 |*
 345 |*    SvFileStream::LockRange()
 346 |*
 347 |*    Beschreibung      STREAM.SDW
 348 |*    Ersterstellung    OV 15.06.94
 349 |*    Letzte Aenderung  TPF 15.07.98
 350 |*
 351 *************************************************************************/
 352
 353 BOOL SvFileStream::LockRange( ULONG nByteOffset, ULONG nBytes )
 354 {
 355     bool bRetVal = false;
 356     if( IsOpen() )
 357     {
 358         bRetVal = ::LockFile(pInstanceData->hFile,nByteOffset,0L,nBytes,0L );
 359         if( !bRetVal )
 360             SetError(::GetSvError(GetLastError()));
 361     }
 362     return bRetVal;
 363 }
 364
 365 /*************************************************************************
 366 |*
 367 |*    SvFileStream::UnlockRange()
 368 |*
 369 |*    Beschreibung      STREAM.SDW
 370 |*    Ersterstellung    OV 15.06.94
 371 |*    Letzte Aenderung  TPF 15.07.98
 372 |*
 373 *************************************************************************/
 374
 375 BOOL SvFileStream::UnlockRange( ULONG nByteOffset, ULONG nBytes )
 376 {
 377     bool bRetVal = false;
 378     if( IsOpen() )
 379     {
 380         bRetVal = ::UnlockFile(pInstanceData->hFile,nByteOffset,0L,nBytes,0L );
 381         if( !bRetVal )
 382             SetError(::GetSvError(GetLastError()));
 383     }
 384     return bRetVal;
 385 }
 386
 387 /*************************************************************************
 388 |*
 389 |*    SvFileStream::LockFile()
 390 |*
 391 |*    Beschreibung      STREAM.SDW
 392 |*    Ersterstellung    OV 15.06.94
 393 |*    Letzte Aenderung  OV 15.06.94
 394 |*
 395 *************************************************************************/
 396
 397 BOOL SvFileStream::LockFile()
 398 {
 399     BOOL bRetVal = FALSE;
 400     if( !nLockCounter )
 401     {
 402         if( LockRange( 0L, LONG_MAX ) )
 403         {
 404             nLockCounter = 1;
 405             bRetVal = TRUE;
 406         }
 407     }
 408     else
 409     {
 410         nLockCounter++;
 411         bRetVal = TRUE;
 412     }
 413     return bRetVal;
 414 }
 415
 416 /*************************************************************************
 417 |*
 418 |*    SvFileStream::UnlockFile()
 419 |*
 420 |*    Beschreibung      STREAM.SDW
 421 |*    Ersterstellung    OV 15.06.94
 422 |*    Letzte Aenderung  OV 15.06.94
 423 |*
 424 *************************************************************************/
 425
 426 BOOL SvFileStream::UnlockFile()
 427 {
 428     BOOL bRetVal = FALSE;
 429     if( nLockCounter > 0)
 430     {
 431         if( nLockCounter == 1)
 432         {
 433             if( UnlockRange( 0L, LONG_MAX ) )
 434             {
 435                 nLockCounter = 0;
 436                 bRetVal = TRUE;
 437             }
 438         }
 439         else
 440         {
 441             nLockCounter--;
 442             bRetVal = TRUE;
 443         }
 444     }
 445     return bRetVal;
 446 }
 447
 448
 449 /*************************************************************************
 450 |*
 451 |*    SvFileStream::Open()
 452 |*
 453 |*    Beschreibung      STREAM.SDW
 454 |*    Ersterstellung    OV 15.06.94
 455 |*    Letzte Aenderung  TPF 15.07.98
 456 |*
 457 *************************************************************************/
 458 /*
 459       NOCREATE       TRUNC   NT-Action
 460       ----------------------------------------------
 461          0 (Create)    0     OPEN_ALWAYS
 462          0 (Create)    1     CREATE_ALWAYS
 463          1             0     OPEN_EXISTING
 464          1             1     TRUNCATE_EXISTING
 465 */
 466
 467 void SvFileStream::Open( const String& rFilename, StreamMode nMode )
 468 {
 469     String aParsedFilename(rFilename);
 470
 471     SetLastError( ERROR_SUCCESS );
 472     Close();
 473     SvStream::ClearBuffer();
 474
 475     eStreamMode = nMode;
 476     eStreamMode &= ~STREAM_TRUNC; // beim ReOpen nicht cutten
 477
 478     //    !!! NoOp: Ansonsten ToAbs() verwendern
 479     //    !!! DirEntry aDirEntry( rFilename );
 480     //    !!! aFilename = aDirEntry.GetFull();
 481     aFilename = aParsedFilename;
 482 #ifdef BOOTSTRAP
 483     ByteString aFileNameA( aFilename, gsl_getSystemTextEncoding());
 484 #else
 485     ByteString aFileNameA( aFilename, osl_getThreadTextEncoding());
 486     FSysRedirector::DoRedirect( aFilename );
 487 #endif
 488     SetLastError( ERROR_SUCCESS );      // ggf. durch Redirector geaendert!
 489
 490     /*
 491     #ifdef DBG_UTIL
 492     String aTraceStr( "SvFileStream::Open(): " );
 493     aTraceStr += aFilename;
 494     DBG_TRACE( aTraceStr );
 495     #endif
 496     */
 497
 498     DWORD   nOpenAction;
 499     DWORD   nShareMode      = FILE_SHARE_READ | FILE_SHARE_WRITE;
 500     DWORD   nAccessMode     = 0L;
 501     UINT    nOldErrorMode = SetErrorMode( SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX );
 502
 503     if( nMode & STREAM_SHARE_DENYREAD)
 504         nShareMode &= ~FILE_SHARE_READ;
 505
 506     if( nMode & STREAM_SHARE_DENYWRITE)
 507         nShareMode &= ~FILE_SHARE_WRITE;
 508
 509     if( nMode & STREAM_SHARE_DENYALL)
 510         nShareMode = 0;
 511
 512     if( (nMode & STREAM_READ) )
 513         nAccessMode |= GENERIC_READ;
 514     if( (nMode & STREAM_WRITE) )
 515         nAccessMode |= GENERIC_WRITE;
 516
 517     if( nAccessMode == GENERIC_READ )       // ReadOnly ?
 518         nMode |= STREAM_NOCREATE;   // wenn ja, nicht erzeugen
 519
 520     // Zuordnung siehe obige Wahrheitstafel
 521     if( !(nMode & STREAM_NOCREATE) )
 522     {
 523         if( nMode & STREAM_TRUNC )
 524             nOpenAction = CREATE_ALWAYS;
 525         else
 526             nOpenAction = OPEN_ALWAYS;
 527     }
 528     else
 529     {
 530         if( nMode & STREAM_TRUNC )
 531             nOpenAction = TRUNCATE_EXISTING;
 532         else
 533             nOpenAction = OPEN_EXISTING;
 534     }
 535
 536     pInstanceData->hFile = CreateFile(
 537         aFileNameA.GetBuffer(),
 538         nAccessMode,
 539         nShareMode,
 540         (LPSECURITY_ATTRIBUTES)NULL,
 541         nOpenAction,
 542         FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
 543         (HANDLE) NULL
 544     );
 545
 546     if(  pInstanceData->hFile!=INVALID_HANDLE_VALUE && (
 547         // Hat Create Always eine existierende Datei ueberschrieben ?
 548         GetLastError() == ERROR_ALREADY_EXISTS ||
 549         // Hat Open Always eine neue Datei angelegt ?
 550         GetLastError() == ERROR_FILE_NOT_FOUND  ))
 551     {
 552         // wenn ja, dann alles OK
 553         if( nOpenAction == OPEN_ALWAYS || nOpenAction == CREATE_ALWAYS )
 554             SetLastError( ERROR_SUCCESS );
 555     }
 556
 557     // Bei Fehler pruefen, ob wir lesen duerfen
 558     if( (pInstanceData->hFile==INVALID_HANDLE_VALUE) &&
 559          (nAccessMode & GENERIC_WRITE))
 560     {
 561         ULONG nErr = ::GetSvError( GetLastError() );
 562         if(nErr==SVSTREAM_ACCESS_DENIED || nErr==SVSTREAM_SHARING_VIOLATION)
 563         {
 564             nMode &= (~STREAM_WRITE);
 565             nAccessMode = GENERIC_READ;
 566             // OV, 28.1.97: Win32 setzt die Datei auf 0-Laenge, wenn
 567             // die Openaction CREATE_ALWAYS ist!!!!
 568             nOpenAction = OPEN_EXISTING;
 569             SetLastError( ERROR_SUCCESS );
 570             pInstanceData->hFile = CreateFile(
 571                 aFileNameA.GetBuffer(),
 572                 GENERIC_READ,
 573                 nShareMode,
 574                 (LPSECURITY_ATTRIBUTES)NULL,
 575                 nOpenAction,
 576                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
 577                 (HANDLE) NULL
 578             );
 579             if( GetLastError() == ERROR_ALREADY_EXISTS )
 580                 SetLastError( ERROR_SUCCESS );
 581         }
 582     }
 583
 584     if( GetLastError() != ERROR_SUCCESS )
 585     {
 586         bIsOpen = FALSE;
 587         SetError(::GetSvError( GetLastError() ) );
 588     }
 589     else
 590     {
 591         bIsOpen     = TRUE;
 592         // pInstanceData->bIsEof = FALSE;
 593         if( nAccessMode & GENERIC_WRITE )
 594             bIsWritable = TRUE;
 595     }
 596     SetErrorMode( nOldErrorMode );
 597 }
 598
 599 /*************************************************************************
 600 |*
 601 |*    SvFileStream::ReOpen()
 602 |*
 603 |*    Beschreibung      STREAM.SDW
 604 |*    Ersterstellung    OV 15.06.94
 605 |*    Letzte Aenderung  OV 15.06.94
 606 |*
 607 *************************************************************************/
 608
 609 void SvFileStream::ReOpen()
 610 {
 611     if( !bIsOpen && aFilename.Len() )
 612         Open( aFilename, eStreamMode );
 613 }
 614
 615 /*************************************************************************
 616 |*
 617 |*    SvFileStream::Close()
 618 |*
 619 |*    Beschreibung      STREAM.SDW
 620 |*    Ersterstellung    OV 15.06.94
 621 |*    Letzte Aenderung  TPF 15.07.98
 622 |*
 623 *************************************************************************/
 624
 625 void SvFileStream::Close()
 626 {
 627     if( IsOpen() )
 628     {
 629         if( nLockCounter )
 630         {
 631             nLockCounter = 1;
 632             UnlockFile();
 633         }
 634         Flush();
 635         CloseHandle( pInstanceData->hFile );
 636     }
 637     bIsOpen     = FALSE;
 638     nLockCounter= 0;
 639     bIsWritable = FALSE;
 640     SvStream::ClearBuffer();
 641     SvStream::ClearError();
 642 }
 643
 644 /*************************************************************************
 645 |*
 646 |*    SvFileStream::ResetError()
 647 |*
 648 |*    Beschreibung      STREAM.SDW; Setzt Filepointer auf Dateianfang
 649 |*    Ersterstellung    OV 15.06.94
 650 |*    Letzte Aenderung  OV 15.06.94
 651 |*
 652 *************************************************************************/
 653
 654 void SvFileStream::ResetError()
 655 {
 656     SvStream::ClearError();
 657 }
 658
 659 /*************************************************************************
 660 |*
 661 |*    SvFileStream::SetSize()
 662 |*
 663 |*    Beschreibung      STREAM.SDW
 664 |*    Ersterstellung    OV 19.10.95
 665 |*    Letzte Aenderung  TPF 15.07.98
 666 |*
 667 *************************************************************************/
 668
 669 void SvFileStream::SetSize( ULONG nSize )
 670 {
 671
 672     if( IsOpen() )
 673     {
 674         int bError = FALSE;
 675         HANDLE hFile = pInstanceData->hFile;
 676         ULONG nOld = SetFilePointer( hFile, 0L, NULL, FILE_CURRENT );
 677         if( nOld != 0xffffffff )
 678         {
 679             if( SetFilePointer(hFile,nSize,NULL,FILE_BEGIN ) != 0xffffffff)
 680             {
 681                 bool bSucc = SetEndOfFile( hFile );
 682                 if( !bSucc )
 683                     bError = TRUE;
 684             }
 685             if( SetFilePointer( hFile,nOld,NULL,FILE_BEGIN ) == 0xffffffff)
 686                 bError = TRUE;
 687         }
 688         if( bError )
 689             SetError(::GetSvError( GetLastError() ) );
 690     }
 691 }
 692