sot/source/sdstor/stgio.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: stgio.cxx,v $
  10  * $Revision: 1.7 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sot.hxx"
  33
  34 #include "stg.hxx"
  35 #include "stgelem.hxx"
  36 #include "stgcache.hxx"
  37 #include "stgstrms.hxx"
  38 #include "stgdir.hxx"
  39 #include "stgio.hxx"
  40 #include <rtl/instance.hxx>
  41
  42 ///////////////////////////// class StgIo //////////////////////////////
  43
  44 // This class holds the storage header and all internal streams.
  45
  46 StgIo::StgIo() : StgCache()
  47 {
  48     pTOC      = NULL;
  49     pDataFAT  = NULL;
  50     pDataStrm = NULL;
  51     pFAT      = NULL;
  52     bCopied   = FALSE;
  53 }
  54
  55 StgIo::~StgIo()
  56 {
  57     delete pTOC;
  58     delete pDataFAT;
  59     delete pDataStrm;
  60     delete pFAT;
  61 }
  62
  63 // Load the header. Do not set an error code if the header is invalid.
  64
  65 BOOL StgIo::Load()
  66 {
  67     if( pStrm )
  68     {
  69         if( aHdr.Load( *this ) )
  70         {
  71             if( aHdr.Check() )
  72                 SetupStreams();
  73             else
  74                 return FALSE;
  75         }
  76     }
  77     return Good();
  78 }
  79
  80 // Set up an initial, empty storage
  81
  82 BOOL StgIo::Init()
  83 {
  84     aHdr.Init();
  85     SetupStreams();
  86     return CommitAll();
  87 }
  88
  89 void StgIo::SetupStreams()
  90 {
  91     delete pTOC;
  92     delete pDataFAT;
  93     delete pDataStrm;
  94     delete pFAT;
  95     pTOC      = NULL;
  96     pDataFAT  = NULL;
  97     pDataStrm = NULL;
  98     pFAT      = NULL;
  99     ResetError();
 100     SetPhysPageSize( 1 << aHdr.GetPageSize() );
 101     pFAT = new StgFATStrm( *this );
 102     pTOC = new StgDirStrm( *this );
 103     if( !GetError() )
 104     {
 105         StgDirEntry* pRoot = pTOC->GetRoot();
 106         if( pRoot )
 107         {
 108             pDataFAT = new StgDataStrm( *this, aHdr.GetDataFATStart(), -1 );
 109             pDataStrm = new StgDataStrm( *this, pRoot );
 110             pDataFAT->SetIncrement( 1 << aHdr.GetPageSize() );
 111             pDataStrm->SetIncrement( GetDataPageSize() );
 112             pDataStrm->SetEntry( *pRoot );
 113         }
 114         else
 115             SetError( SVSTREAM_FILEFORMAT_ERROR );
 116     }
 117 }
 118
 119 // get the logical data page size
 120
 121 short StgIo::GetDataPageSize()
 122 {
 123     return 1 << aHdr.GetDataPageSize();
 124 }
 125
 126 // Commit everything
 127
 128 BOOL StgIo::CommitAll()
 129 {
 130     // Store the data (all streams and the TOC)
 131     if( pTOC->Store() )
 132     {
 133         if( Commit( NULL ) )
 134         {
 135             aHdr.SetDataFATStart( pDataFAT->GetStart() );
 136             aHdr.SetDataFATSize( pDataFAT->GetPages() );
 137             aHdr.SetTOCStart( pTOC->GetStart() );
 138             if( aHdr.Store( *this ) )
 139             {
 140                 pStrm->Flush();
 141                 ULONG n = pStrm->GetError();
 142                 SetError( n );
 143 #ifdef DBG_UTIL
 144                 if( n==0 ) ValidateFATs();
 145 #endif
 146                 return BOOL( n == 0 );
 147             }
 148         }
 149     }
 150     SetError( SVSTREAM_WRITE_ERROR );
 151     return FALSE;
 152 }
 153
 154
 155 class EasyFat
 156 {
 157     INT32 *pFat;
 158     BOOL  *pFree;
 159     INT32 nPages;
 160     INT32 nPageSize;
 161
 162 public:
 163     EasyFat( StgIo & rIo, StgStrm *pFatStream, INT32 nPSize );
 164     ~EasyFat() { delete pFat; delete pFree; }
 165     INT32 GetPageSize() { return nPageSize; }
 166     INT32 Count() { return nPages; }
 167     INT32 operator[]( INT32 nOffset ) { return pFat[ nOffset ]; }
 168
 169     ULONG Mark( INT32 nPage, INT32 nCount, INT32 nExpect );
 170     BOOL HasUnrefChains();
 171 };
 172
 173 EasyFat::EasyFat( StgIo& rIo, StgStrm* pFatStream, INT32 nPSize )
 174 {
 175     nPages = pFatStream->GetSize() >> 2;
 176     nPageSize = nPSize;
 177     pFat = new INT32[ nPages ];
 178     pFree = new BOOL[ nPages ];
 179
 180     StgPage *pPage = NULL;
 181     INT32 nFatPageSize = (1 << rIo.aHdr.GetPageSize()) - 2;
 182
 183     for( INT32 nPage = 0; nPage < nPages; nPage++ )
 184     {
 185         if( ! (nPage % nFatPageSize) )
 186         {
 187             pFatStream->Pos2Page( nPage << 2 );
 188             INT32 nPhysPage = pFatStream->GetPage();
 189             pPage = rIo.Get( nPhysPage, TRUE );
 190         }
 191
 192         pFat[ nPage ] = pPage->GetPage( short( nPage % nFatPageSize ) );
 193         pFree[ nPage ] = TRUE;
 194     }
 195 }
 196
 197 BOOL EasyFat::HasUnrefChains()
 198 {
 199     for( INT32 nPage = 0; nPage < nPages; nPage++ )
 200     {
 201         if( pFree[ nPage ] && pFat[ nPage ] != -1 )
 202             return TRUE;
 203     }
 204     return FALSE;
 205 }
 206
 207 ULONG EasyFat::Mark( INT32 nPage, INT32 nCount, INT32 nExpect )
 208 {
 209     if( nCount > 0 )
 210         --nCount /= GetPageSize(), nCount++;
 211
 212     INT32 nCurPage = nPage;
 213     while( nCount != 0 )
 214     {
 215         pFree[ nCurPage ] = FALSE;
 216         nCurPage = pFat[ nCurPage ];
 217         //Stream zu lang
 218         if( nCurPage != nExpect && nCount == 1 )
 219             return FAT_WRONGLENGTH;
 220         //Stream zu kurz
 221         if( nCurPage == nExpect && nCount != 1 && nCount != -1 )
 222             return FAT_WRONGLENGTH;
 223         // letzter Block bei Stream ohne Laenge
 224         if( nCurPage == nExpect && nCount == -1 )
 225             nCount = 1;
 226         if( nCount != -1 )
 227             nCount--;
 228         // Naechster Block nicht in der FAT
 229         if( nCount && ( nCurPage < 0 || nCurPage >= nPages ) )
 230             return FAT_OUTOFBOUNDS;
 231     }
 232     return FAT_OK;
 233 }
 234
 235 class Validator
 236 {
 237     ULONG nError;
 238
 239     EasyFat aSmallFat;
 240     EasyFat aFat;
 241
 242     StgIo &rIo;
 243
 244     ULONG ValidateMasterFATs();
 245     ULONG ValidateDirectoryEntries();
 246     ULONG FindUnrefedChains();
 247     ULONG MarkAll( StgDirEntry *pEntry );
 248
 249 public:
 250
 251     Validator( StgIo &rIo );
 252     BOOL IsError() { return nError != 0; }
 253 };
 254
 255 Validator::Validator( StgIo &rIoP )
 256     : aSmallFat( rIoP, rIoP.pDataFAT, 1 << rIoP.aHdr.GetDataPageSize() ),
 257       aFat( rIoP, rIoP.pFAT, 1 << rIoP.aHdr.GetPageSize() ),
 258       rIo( rIoP )
 259 {
 260     ULONG nErr = nError = FAT_OK;
 261
 262     if( ( nErr = ValidateMasterFATs() ) != FAT_OK )
 263         nError = nErr;
 264     else if(    ( nErr = ValidateDirectoryEntries() ) != FAT_OK )
 265         nError = nErr;
 266     else if(    ( nErr = FindUnrefedChains()) != FAT_OK )
 267         nError = nErr;
 268 }
 269
 270 ULONG Validator::ValidateMasterFATs()
 271 {
 272     INT32 nCount = rIo.aHdr.GetFATSize();
 273     ULONG nErr;
 274     for( INT32 i = 0; i < nCount; i++ )
 275     {
 276         if( ( nErr = aFat.Mark(rIo.pFAT->GetPage( short(i), FALSE ), aFat.GetPageSize(), -3 )) != FAT_OK )
 277             return nErr;
 278     }
 279     if( rIo.aHdr.GetMasters() )
 280         if( ( nErr = aFat.Mark(rIo.aHdr.GetFATChain( ), aFat.GetPageSize(), -4 )) != FAT_OK )
 281             return nErr;
 282     return FAT_OK;
 283 }
 284
 285 ULONG Validator::MarkAll( StgDirEntry *pEntry )
 286 {
 287     StgIterator aIter( *pEntry );
 288     ULONG nErr = FAT_OK;
 289     for( StgDirEntry* p = aIter.First(); p ; p = aIter.Next() )
 290     {
 291         if( p->aEntry.GetType() == STG_STORAGE )
 292         {
 293             nErr = MarkAll( p );
 294             if( nErr != FAT_OK )
 295                 return nErr;
 296         }
 297         else
 298         {
 299             INT32 nSize = p->aEntry.GetSize();
 300             if( nSize < rIo.aHdr.GetThreshold()  )
 301                 nErr = aSmallFat.Mark( p->aEntry.GetStartPage(),nSize, -2 );
 302             else
 303                 nErr = aFat.Mark( p->aEntry.GetStartPage(),nSize, -2 );
 304             if( nErr != FAT_OK )
 305                 return nErr;
 306         }
 307     }
 308     return FAT_OK;
 309 }
 310
 311 ULONG Validator::ValidateDirectoryEntries()
 312 {
 313     // Normale DirEntries
 314     ULONG nErr = MarkAll( rIo.pTOC->GetRoot() );
 315     if( nErr != FAT_OK )
 316         return nErr;
 317     // Small Data
 318     nErr = aFat.Mark( rIo.pTOC->GetRoot()->aEntry.GetStartPage(),
 319                  rIo.pTOC->GetRoot()->aEntry.GetSize(), -2 );
 320     if( nErr != FAT_OK )
 321         return nErr;
 322     // Small Data FAT
 323     nErr = aFat.Mark(
 324         rIo.aHdr.GetDataFATStart(),
 325         rIo.aHdr.GetDataFATSize() * aFat.GetPageSize(), -2 );
 326     if( nErr != FAT_OK )
 327         return nErr;
 328     // TOC
 329     nErr = aFat.Mark(
 330         rIo.aHdr.GetTOCStart(), -1, -2 );
 331     return nErr;
 332 }
 333
 334 ULONG Validator::FindUnrefedChains()
 335 {
 336     if( aSmallFat.HasUnrefChains() ||
 337         aFat.HasUnrefChains() )
 338         return FAT_UNREFCHAIN;
 339     else
 340         return FAT_OK;
 341 }
 342
 343 namespace { struct ErrorLink : public rtl::Static<Link, ErrorLink > {}; }
 344
 345 void StgIo::SetErrorLink( const Link& rLink )
 346 {
 347     ErrorLink::get() = rLink;
 348 }
 349
 350 const Link& StgIo::GetErrorLink()
 351 {
 352     return ErrorLink::get();
 353 }
 354
 355 ULONG StgIo::ValidateFATs()
 356 {
 357     if( bFile )
 358     {
 359         Validator *pV = new Validator( *this );
 360         BOOL bRet1 = !pV->IsError(), bRet2 = TRUE ;
 361         delete pV;
 362         SvFileStream *pFileStrm = ( SvFileStream *) GetStrm();
 363         StgIo aIo;
 364         if( aIo.Open( pFileStrm->GetFileName(),
 365                       STREAM_READ  | STREAM_SHARE_DENYNONE) &&
 366             aIo.Load() )
 367         {
 368             pV = new Validator( aIo );
 369             bRet2 = !pV->IsError();
 370             delete pV;
 371         }
 372
 373         ULONG nErr;
 374         if( bRet1 != bRet2 )
 375             nErr = bRet1 ? FAT_ONFILEERROR : FAT_INMEMORYERROR;
 376         else nErr = bRet1 ? FAT_OK : FAT_BOTHERROR;
 377         if( nErr != FAT_OK && !bCopied )
 378         {
 379             StgLinkArg aArg;
 380             aArg.aFile = pFileStrm->GetFileName();
 381             aArg.nErr = nErr;
 382             ErrorLink::get().Call( &aArg );
 383             bCopied = TRUE;
 384         }
 385 //              DBG_ASSERT( nErr == FAT_OK ,"Storage kaputt");
 386         return nErr;
 387     }
 388 //      DBG_ERROR("Validiere nicht (kein FileStorage)");
 389     return FAT_OK;
 390 }
 391
 392