xistream.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <comphelper/docpasswordhelper.hxx>
#include <com/sun/star/beans/NamedValue.hpp>
#include <filter/msfilter/mscodec.hxx>
#include <tools/stream.hxx>
#include <memory>
#include "xlstream.hxx"
#include "xlconst.hxx"
 
class XclImpRoot;
 
/* ============================================================================
Input stream class for Excel import
- CONTINUE record handling
- Decryption
============================================================================ */
 
// Decryption
 
class XclImpDecrypter;
typedef std::shared_ptr< XclImpDecrypter > XclImpDecrypterRef;
 
class XclImpDecrypter : public ::comphelper::IDocPasswordVerifier
{
public:
    explicit            XclImpDecrypter();
    virtual             ~XclImpDecrypter() override;
 
    const ErrCode&      GetError() const { return mnError; }
    bool         IsValid() const { return mnError == ERRCODE_NONE; }
 
    XclImpDecrypterRef  Clone() const;
 
    virtual ::comphelper::DocPasswordVerifierResult verifyPassword( const OUString& rPassword, css::uno::Sequence< css::beans::NamedValue >& o_rEncryptionData ) override;
    virtual ::comphelper::DocPasswordVerifierResult verifyEncryptionData( const css::uno::Sequence< css::beans::NamedValue >& rEncryptionData ) override;
 
    void                Update( const SvStream& rStrm, sal_uInt16 nRecSize );
    sal_uInt16          Read( SvStream& rStrm, void* pData, sal_uInt16 nBytes );
 
protected:
    explicit            XclImpDecrypter( const XclImpDecrypter& rSrc );
 
private:
    virtual XclImpDecrypter* OnClone() const = 0;
    virtual css::uno::Sequence< css::beans::NamedValue >
        OnVerifyPassword( const OUString& rPassword ) = 0;
    virtual bool OnVerifyEncryptionData( const css::uno::Sequence< css::beans::NamedValue >& rEncryptionData ) = 0;
 
    virtual void        OnUpdate( std::size_t nOldStrmPos, std::size_t nNewStrmPos, sal_uInt16 nRecSize ) = 0;
    virtual sal_uInt16  OnRead( SvStream& rStrm, sal_uInt8* pnData, sal_uInt16 nBytes ) = 0;
 
private:
    ErrCode             mnError;        
    sal_uInt64          mnOldPos;       
    sal_uInt16          mnRecSize;      
};
 
class XclImpBiff5Decrypter : public XclImpDecrypter
{
public:
    explicit            XclImpBiff5Decrypter( sal_uInt16 nKey, sal_uInt16 nHash );
 
private:
    explicit            XclImpBiff5Decrypter( const XclImpBiff5Decrypter& rSrc );
 
    virtual XclImpBiff5Decrypter* OnClone() const override;
    virtual css::uno::Sequence< css::beans::NamedValue >
        OnVerifyPassword( const OUString& rPassword ) override;
    virtual bool OnVerifyEncryptionData( const css::uno::Sequence< css::beans::NamedValue >& rEncryptionData ) override;
    virtual void        OnUpdate( std::size_t nOldStrmPos, std::size_t nNewStrmPos, sal_uInt16 nRecSize ) override;
    virtual sal_uInt16  OnRead( SvStream& rStrm, sal_uInt8* pnData, sal_uInt16 nBytes ) override;
 
private:
    ::msfilter::MSCodec_XorXLS95 maCodec;       
    css::uno::Sequence< css::beans::NamedValue > maEncryptionData;
    sal_uInt16          mnKey;
    sal_uInt16          mnHash;
};
 
class XclImpBiff8Decrypter : public XclImpDecrypter
{
private:
    virtual css::uno::Sequence< css::beans::NamedValue >
        OnVerifyPassword( const OUString& rPassword ) override;
    virtual bool OnVerifyEncryptionData( const css::uno::Sequence< css::beans::NamedValue >& rEncryptionData ) override;
    virtual void        OnUpdate( std::size_t nOldStrmPos, std::size_t nNewStrmPos, sal_uInt16 nRecSize ) override;
    virtual sal_uInt16  OnRead( SvStream& rStrm, sal_uInt8* pnData, sal_uInt16 nBytes ) override;
 
    static sal_uInt32   GetBlock( std::size_t nStrmPos );
    static sal_uInt16   GetOffset( std::size_t nStrmPos );
 
protected:
    explicit  XclImpBiff8Decrypter( std::vector<sal_uInt8>&& rSalt,
                                    std::vector<sal_uInt8>&& rVerifier,
                                    std::vector<sal_uInt8>&& rVerifierHash);
 
    explicit  XclImpBiff8Decrypter(const XclImpBiff8Decrypter& rSrc);
 
    css::uno::Sequence< css::beans::NamedValue > maEncryptionData;
    std::vector< sal_uInt8 > maSalt;
    std::vector< sal_uInt8 > maVerifier;
    std::vector< sal_uInt8 > maVerifierHash;
    msfilter::MSCodec97* mpCodec;       
};
 
class XclImpBiff8StdDecrypter : public XclImpBiff8Decrypter
{
public:
    explicit XclImpBiff8StdDecrypter( std::vector<sal_uInt8>&& rSalt,
                                      std::vector<sal_uInt8>&& rVerifier,
                                      std::vector<sal_uInt8>&& rVerifierHash)
        : XclImpBiff8Decrypter(std::move(rSalt), std::move(rVerifier), std::move(rVerifierHash))
    {
        mpCodec = &maCodec;
    }
 
private:
    explicit XclImpBiff8StdDecrypter(const XclImpBiff8StdDecrypter& rSrc);
 
    virtual XclImpBiff8StdDecrypter* OnClone() const override;
 
private:
    ::msfilter::MSCodec_Std97 maCodec;       
};
 
class XclImpBiff8CryptoAPIDecrypter : public XclImpBiff8Decrypter
{
public:
    explicit XclImpBiff8CryptoAPIDecrypter( std::vector<sal_uInt8>&& rSalt,
                                            std::vector<sal_uInt8>&& rVerifier,
                                            std::vector<sal_uInt8>&& rVerifierHash)
        : XclImpBiff8Decrypter(std::move(rSalt), std::move(rVerifier), std::move(rVerifierHash))
    {
        mpCodec = &maCodec;
    }
 
private:
    explicit XclImpBiff8CryptoAPIDecrypter(const XclImpBiff8CryptoAPIDecrypter& rSrc);
 
    virtual XclImpBiff8CryptoAPIDecrypter* OnClone() const override;
 
private:
    ::msfilter::MSCodec_CryptoAPI maCodec;       
};
 
// Stream
 
class XclImpStreamPos
{
public:
    explicit            XclImpStreamPos();
 
    void                Set( const SvStream& rStrm, std::size_t nNextPos, std::size_t nCurrSize,
                            sal_uInt16 nRawRecId, sal_uInt16 nRawRecSize, sal_uInt16 nRawRecLeft,
                            bool bValid );
 
    void                Get( SvStream& rStrm, std::size_t& rnNextPos, std::size_t& rnCurrSize,
                            sal_uInt16& rnRawRecId, sal_uInt16& rnRawRecSize, sal_uInt16& rnRawRecLeft,
                            bool& rbValid ) const;
 
    std::size_t  GetPos() const { return mnPos; }
 
private:
    std::size_t         mnPos;          
    std::size_t         mnNextPos;      
    std::size_t         mnCurrSize;     
    sal_uInt16          mnRawRecId;     
    sal_uInt16          mnRawRecSize;   
    sal_uInt16          mnRawRecLeft;   
    bool                mbValid;        
};
 
class XclImpStream
{
public:
    static XclBiff      DetectBiffVersion( SvStream& rStrm );
 
    explicit            XclImpStream(
                            SvStream& rInStrm,
                            const XclImpRoot& rRoot );
 
                        ~XclImpStream();
 
    const XclImpRoot& GetRoot() const { return mrRoot; }
 
    bool                StartNextRecord();
    bool                StartNextRecord( std::size_t nNextRecPos );
    void                ResetRecord( bool bContLookup,
                            sal_uInt16 nAltContId = EXC_ID_UNKNOWN );
    void                RewindRecord();
 
    void                SetDecrypter( XclImpDecrypterRef const & xDecrypter );
    void                CopyDecrypterFrom( const XclImpStream& rStrm );
    void                EnableDecryption( bool bEnable = true );
    void         DisableDecryption() { EnableDecryption( false ); }
 
    void                PushPosition();
    void                PopPosition();
 
    void                StoreGlobalPosition();
    void                SeekGlobalPosition();
 
    bool         IsValid() const { return mbValid; }
    sal_uInt16   GetRecId() const { return mnRecId; }
    std::size_t         GetRecPos() const;
    std::size_t         GetRecSize();
    std::size_t         GetRecLeft();
    sal_uInt16          GetNextRecId();
 
    sal_uInt16          PeekRecId( std::size_t nPos );
 
    [[nodiscard]]
    sal_uInt8           ReaduInt8();
    [[nodiscard]]
    sal_Int16           ReadInt16();
    [[nodiscard]]
    sal_uInt16          ReaduInt16();
    [[nodiscard]]
    sal_Int32           ReadInt32();
    [[nodiscard]]
    sal_uInt32          ReaduInt32();
    [[nodiscard]]
    double              ReadDouble();
 
    std::size_t         Read( void* pData, std::size_t nBytes );
    std::size_t         CopyToStream( SvStream& rOutStrm, std::size_t nBytes );
 
    void            CopyRecordToStream( SvStream& rOutStrm );
 
    void                Seek( std::size_t nPos );
    void                Ignore( std::size_t nBytes );
 
    // *** special string functions *** ---------------------------------------
 
    // *** read/ignore unicode strings *** ------------------------------------
    /*  - look for CONTINUE records even if CONTINUE handling disabled
          (only if inside of a CONTINUE record - for TXO import)
        - no overread assertions (for Applix wrong string length export bug)
 
        structure of an Excel unicode string:
        (1) 2 byte character count
        (2) 1 byte flags (16-bit-characters, rich string, far east string)
        (3) [2 byte rich string format run count]
        (4) [4 byte far east data size]
        (5) character array
        (6) [4 * (rich string format run count) byte]
        (7) [(far east data size) byte]
        header = (1), (2)
        ext. header = (3), (4)
        ext. data = (6), (7)
     */
 
    std::size_t         ReadUniStringExtHeader(
                            bool& rb16Bit, bool& rbRich, bool& rbFareast,
                            sal_uInt16& rnFormatRuns, sal_uInt32& rnExtInf, sal_uInt8 nFlags );
    std::size_t         ReadUniStringExtHeader( bool& rb16Bit, sal_uInt8 nFlags );
 
    void         SetNulSubstChar( sal_Unicode cNulSubst = '?' ) { mcNulSubst = cNulSubst; }
 
    OUString            ReadRawUniString( sal_uInt16 nChars, bool b16Bit );
    OUString            ReadUniString( sal_uInt16 nChars, sal_uInt8 nFlags );
    OUString            ReadUniString( sal_uInt16 nChars );
    OUString            ReadUniString();
 
    void                IgnoreRawUniString( sal_uInt16 nChars, bool b16Bit );
    void                IgnoreUniString( sal_uInt16 nChars, sal_uInt8 nFlags );
    void                IgnoreUniString( sal_uInt16 nChars );
 
    // *** read/ignore 8-bit-strings, store in String *** ---------------------
 
    OUString            ReadRawByteString( sal_uInt16 nChars );
    OUString            ReadByteString( bool b16BitLen );
 
    // *** SvStream functions *** ---------------------------------------------
 
    std::size_t  GetSvStreamPos() const { return mrStrm.Tell(); }
    std::size_t  GetSvStreamSize() const { return mnStreamSize; }
 
    void                StorePosition( XclImpStreamPos& rPos );
    void                RestorePosition( const XclImpStreamPos& rPos );
 
    void                SetSvStreamError( const ErrCode& rErrCode )
                            { mrStrm.SetError( rErrCode ); }
 
private:
    bool                ReadNextRawRecHeader();
 
    void                SetupDecrypter();
    void                SetupRawRecord();
    void                SetupRecord();
 
    bool                IsContinueId( sal_uInt16 nRecId ) const;
 
    bool                JumpToNextContinue();
    bool                JumpToNextStringContinue( bool& rb16Bit );
 
    bool                EnsureRawReadSize( sal_uInt16 nBytes );
    sal_uInt16          GetMaxRawReadSize( std::size_t nBytes ) const;
 
    sal_uInt16          ReadRawData( void* pData, sal_uInt16 nBytes );
 
private:
    SvStream&           mrStrm;         
    const XclImpRoot&   mrRoot;         
 
    XclImpDecrypterRef  mxDecrypter;    
 
    XclImpStreamPos     maFirstRec;     
    std::vector< XclImpStreamPos >
                        maPosStack;    
 
    XclImpStreamPos     maGlobPos;      
    sal_uInt16          mnGlobRecId;    
    bool                mbGlobValidRec; 
    bool                mbHasGlobPos;   
 
    std::size_t         mnStreamSize;   
    std::size_t         mnNextRecPos;   
    std::size_t         mnCurrRecSize;  
    std::size_t         mnComplRecSize; 
    bool                mbHasComplRec;  
 
    sal_uInt16          mnRecId;        
    sal_uInt16          mnAltContId;    
 
    sal_uInt16          mnRawRecId;     
    sal_uInt16          mnRawRecSize;   
    sal_uInt16          mnRawRecLeft;   
 
    sal_Unicode         mcNulSubst;     
 
    bool                mbCont;         
    bool                mbUseDecr;      
    bool                mbValidRec;     
    bool                mbValid;        
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */