Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : // This file reflects the structure of MS file elements.
      21             : // It is very sensitive to alignment!
      22             : 
      23             : #ifndef INCLUDED_SOT_SOURCE_SDSTOR_STGELEM_HXX
      24             : #define INCLUDED_SOT_SOURCE_SDSTOR_STGELEM_HXX
      25             : 
      26             : #include <sot/stg.hxx>
      27             : 
      28             : class StgIo;
      29             : class SvStream;
      30             : 
      31             : SvStream& ReadClsId( SvStream&, ClsId& );
      32             : SvStream& WriteClsId( SvStream&, const ClsId& );
      33             : 
      34             : class StgHeader
      35             : {
      36             :     static const sal_uInt8 cFATPagesInHeader = 109;
      37             : 
      38             :     sal_uInt8   cSignature[ 8 ];            // 00 signature (see below)
      39             :     ClsId       aClsId;                     // 08 Class ID
      40             :     sal_Int32   nVersion;                   // 18 version number
      41             :     sal_uInt16  nByteOrder;                 // 1C Unicode byte order indicator
      42             :     sal_Int16   nPageSize;                  // 1E 1 << nPageSize = block size
      43             :     sal_Int16   nDataPageSize;              // 20 1 << this size == data block size
      44             :     sal_uInt8   bDirty;                     // 22 internal dirty flag
      45             :     sal_uInt8   cReserved[ 9 ];             // 23
      46             :     sal_Int32   nFATSize;                   // 2C total number of FAT pages
      47             :     sal_Int32   nTOCstrm;                   // 30 starting page for the TOC stream
      48             :     sal_Int32   nReserved;                  // 34
      49             :     sal_Int32   nThreshold;                 // 38 minimum file size for big data
      50             :     sal_Int32   nDataFAT;                   // 3C page # of 1st data FAT block
      51             :     sal_Int32   nDataFATSize;               // 40 # of data fat blocks
      52             :     sal_Int32   nMasterChain;               // 44 chain to the next master block
      53             :     sal_Int32   nMaster;                    // 48 # of additional master blocks
      54             :     sal_Int32   nMasterFAT[ cFATPagesInHeader ];            // 4C first [cFATPagesInHeader] master FAT pages
      55             : public:
      56             :     StgHeader();
      57             : 
      58             :     void  Init();                       // initialize the header
      59             :     bool      Load( StgIo& );
      60             :     bool      Load( SvStream& );
      61             :     bool      Store( StgIo& );
      62             :     bool      Check();                      // check the signature and version
      63             :     short     GetByteOrder() const          { return nByteOrder; }
      64        1270 :     sal_Int32 GetTOCStart() const           { return nTOCstrm; }
      65             :     void      SetTOCStart( sal_Int32 n );
      66        1262 :     sal_Int32 GetDataFATStart() const       { return nDataFAT; }
      67             :     void      SetDataFATStart( sal_Int32 n );
      68           0 :     sal_Int32 GetDataFATSize() const        { return nDataFATSize; }
      69             :     void      SetDataFATSize( sal_Int32 n );
      70       14932 :     sal_Int32 GetThreshold() const          { return nThreshold; }
      71        2532 :     short     GetPageSize() const           { return nPageSize; }
      72       14070 :     short     GetDataPageSize() const       { return nDataPageSize; }
      73        1270 :     sal_Int32 GetFATSize() const            { return nFATSize; }
      74             :     void      SetFATSize( sal_Int32 n );
      75         375 :     sal_Int32 GetFATChain() const           { return nMasterChain; }
      76             :     void      SetFATChain( sal_Int32 n );
      77         375 :     sal_Int32 GetMasters() const            { return nMaster; }
      78             :     void      SetMasters( sal_Int32 n );
      79      257025 :     short     GetFAT1Size() const           { return cFATPagesInHeader; }
      80             :     const ClsId& GetClassId() const         { return aClsId;        }
      81             :     sal_Int32 GetFATPage( short ) const;
      82             :     void      SetFATPage( short, sal_Int32 );
      83             : };
      84             : 
      85             : enum StgEntryType {                     // dir entry types:
      86             :     STG_EMPTY     = 0,
      87             :     STG_STORAGE   = 1,
      88             :     STG_STREAM    = 2,
      89             :     STG_LOCKBYTES = 3,
      90             :     STG_PROPERTY  = 4,
      91             :     STG_ROOT      = 5
      92             : };
      93             : 
      94             : enum StgEntryRef {                      // reference blocks:
      95             :     STG_LEFT      = 0,                  // left
      96             :     STG_RIGHT     = 1,                  // right
      97             :     STG_CHILD     = 2,                  // child
      98             :     STG_DATA      = 3                   // data start
      99             : };
     100             : 
     101             : enum StgEntryTime {                     // time codes:
     102             :     STG_MODIFIED  = 0,                  // last modification
     103             :     STG_ACCESSED  = 1                   // last access
     104             : };
     105             : 
     106             : #define STGENTRY_SIZE 128
     107             : 
     108             : //StructuredStorageDirectoryEntry
     109      296271 : class StgEntry
     110             : {                        // directory enty
     111             :     sal_uInt16  nName[ 32 ];                // 00 name as WCHAR
     112             :     sal_uInt16  nNameLen;                   // 40 size of name in bytes including 00H
     113             :     sal_uInt8   cType;                      // 42 entry type
     114             :     sal_uInt8   cFlags;                     // 43 0 or 1 (tree balance?)
     115             :     sal_Int32   nLeft;                      // 44 left node entry
     116             :     sal_Int32   nRight;                     // 48 right node entry
     117             :     sal_Int32   nChild;                     // 4C 1st child entry if storage
     118             :     ClsId       aClsId;                     // 50 class ID (optional)
     119             :     sal_Int32   nFlags;                     // 60 state flags(?)
     120             :     sal_Int32   nMtime[ 2 ];                // 64 modification time
     121             :     sal_Int32   nAtime[ 2 ];                // 6C creation and access time
     122             :     sal_Int32   nPage1;                     // 74 starting block (either direct or translated)
     123             :     sal_Int32   nSize;                      // 78 file size
     124             :     sal_Int32   nUnknown;                   // 7C unknown
     125             :     OUString    aName;                      // Name as Compare String (ascii, upper)
     126             : public:
     127             :     bool        Init();                     // initialize the data
     128             :     bool        SetName( const OUString& );   // store a name (ASCII, up to 32 chars)
     129             :     void        GetName( OUString& rName ) const;
     130             :                                         // fill in the name
     131             :     short       Compare( const StgEntry& ) const;   // compare two entries
     132             :     bool        Load( const void* pBuffer, sal_uInt32 nBufSize );
     133             :     void        Store( void* );
     134      102658 :     StgEntryType GetType() const            { return (StgEntryType) cType;  }
     135           0 :     sal_Int32   GetStartPage() const        { return nPage1; }
     136        5416 :     void        SetType( StgEntryType t )   { cType = (sal_uInt8) t; }
     137             :     sal_uInt8   GetFlags() const            { return cFlags; }
     138             :     void        SetFlags( sal_uInt8 c )     { cFlags = c; }
     139     3822394 :     sal_Int32   GetSize() const             { return nSize; }
     140       55248 :     void        SetSize( sal_Int32 n )      { nSize = n; }
     141         282 :     const ClsId& GetClassId() const         { return aClsId; }
     142             :     void        SetClassId( const ClsId& );
     143             :     sal_Int32   GetLeaf( StgEntryRef ) const;
     144             :     void        SetLeaf( StgEntryRef, sal_Int32 );
     145             : };
     146             : 
     147             : 
     148             : #define STG_FREE    -1L                 // page is free
     149             : #define STG_EOF     -2L                 // page is last page in chain
     150             : #define STG_FAT     -3L                 // page is FAT page
     151             : #define STG_MASTER  -4L                 // page is master FAT page
     152             : 
     153             : #endif
     154             : 
     155             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */