424 lines
11 KiB
C++
424 lines
11 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "OleObject.h"
|
|
#include "WordDocument.h"
|
|
|
|
namespace DocFileFormat
|
|
{
|
|
OleObject::OleObject( const CharacterPropertyExceptions* chpx, WordDocument* document)
|
|
{
|
|
if (!document) return;
|
|
if (!chpx) return;
|
|
|
|
nWordVersion = document->nWordVersion;
|
|
|
|
ObjectId = getOleEntryName( chpx );
|
|
|
|
StructuredStorageReader* docStorage = document->GetStorage();
|
|
|
|
oleStorage = docStorage->GetStorage();
|
|
if (!oleStorage) return;
|
|
|
|
std::wstring sObjectId( ObjectId.begin(), ObjectId.end() );
|
|
|
|
std::wstring name = L"ObjectPool/" + sObjectId + L"/";
|
|
|
|
bool bOle = processOleStream( name + L"Ole" );
|
|
bool bCompObj = isLinked ? processLinkInfoStream( name + L"LinkInfo" ):
|
|
processCompObjStream( name + L"CompObj" );
|
|
if (bOle || bCompObj)
|
|
{
|
|
processPICStream( name + L"PIC" );
|
|
processMETAStream( name + L"META" );
|
|
processEquationNativeStream( name + L"Equation Native" );
|
|
processPackageStream(name + L"Package");
|
|
}
|
|
else if (nWordVersion > 0)
|
|
{
|
|
int fc = pictureDesciptor.GetFcPic( chpx );
|
|
|
|
if ( fc >= 0 )
|
|
{
|
|
POLE::Stream* pOleStream = document->GetDocumentStream();
|
|
pictureDesciptor.parse( pOleStream, fc, 0xffffff, nWordVersion);
|
|
|
|
VirtualStreamReader reader(pOleStream, pOleStream->tell(), nWordVersion);
|
|
|
|
int pos = reader.GetPosition();
|
|
|
|
short a1 = reader.ReadInt16();
|
|
short a2 = reader.ReadInt16();
|
|
short a3 = reader.ReadInt16();
|
|
|
|
int lcb = reader.ReadInt32();
|
|
//short a4 = reader.ReadInt16();
|
|
//short a5 = reader.ReadInt16();
|
|
//short a6 = reader.ReadInt16();
|
|
//short a7 = reader.ReadInt16();
|
|
int lcb1 = reader.ReadInt32();
|
|
|
|
ClipboardFormat = Program = reader.ReadLengthPrefixedAnsiString(0xffff);
|
|
|
|
short a10 = reader.ReadInt16();
|
|
short a11 = reader.ReadInt16();
|
|
short a12 = reader.ReadInt16();
|
|
short a14 = reader.ReadInt16();
|
|
|
|
//int lcb = 5000;//reader.ReadInt32();
|
|
|
|
int szHeader = reader.GetPosition() - pos;
|
|
size_t szData = reader.ReadInt32();
|
|
if (szData > lcb)
|
|
{
|
|
szData = szData >> 16;
|
|
}
|
|
char* bytes = (szData < 0xffff) ? (char*)reader.ReadBytes( szData, true ) : NULL;
|
|
if (bytes)
|
|
{
|
|
boost::shared_array<char> buffer(bytes);
|
|
embeddedData = std::make_pair(buffer, szData);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bool OleObject::processLinkInfoStream( const std::wstring& linkStream )
|
|
{
|
|
bool res = false;
|
|
try
|
|
{
|
|
POLE::Stream* pLinkStream = new POLE::Stream(oleStorage, linkStream);
|
|
|
|
if (( pLinkStream ) && (false == pLinkStream->fail()))
|
|
{
|
|
VirtualStreamReader reader( pLinkStream, 0, false);
|
|
processLinkInfoStream(reader);
|
|
|
|
res = true;
|
|
}
|
|
if (pLinkStream) delete pLinkStream;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void OleObject::processEquationNativeStream( const std::wstring& eqStream )
|
|
{
|
|
try
|
|
{
|
|
POLE::Stream* pCompStream = new POLE::Stream(oleStorage, eqStream);
|
|
|
|
if ((pCompStream) && (false == pCompStream->fail()))
|
|
{
|
|
VirtualStreamReader reader(pCompStream, 0, false);
|
|
|
|
int sz = reader.GetSize();
|
|
|
|
unsigned char *Buffer = reader.ReadBytes(sz, true);
|
|
|
|
if (Buffer && sz > 0)
|
|
{
|
|
isEquation = true;
|
|
delete[]Buffer;
|
|
}
|
|
}
|
|
if (pCompStream) delete pCompStream;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
}
|
|
bool OleObject::processPackageStream(const std::wstring& packageStream)
|
|
{
|
|
bool res = true;
|
|
try
|
|
{
|
|
POLE::Stream* pPackageStream = new POLE::Stream(oleStorage, packageStream);
|
|
|
|
if ((pPackageStream) && (false == pPackageStream->fail()))
|
|
{
|
|
// AVS_OFFICESTUDIO_FILE_OTHER_PACKAGE_IN_OLE
|
|
VirtualStreamReader reader(pPackageStream, 0, false);
|
|
|
|
size_t sz = reader.GetSize();
|
|
|
|
char* bytes = (sz < 0xffffff) ? (char*)reader.ReadBytes(sz, true) : NULL;
|
|
if (bytes)
|
|
{
|
|
boost::shared_array<char> buffer(bytes);
|
|
embeddedData = std::make_pair(buffer, sz);
|
|
}
|
|
|
|
isPackage = true;
|
|
}
|
|
if (pPackageStream) delete pPackageStream;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
return res;
|
|
}
|
|
void OleObject::processMETAStream( const std::wstring& metaStream )
|
|
{
|
|
try
|
|
{
|
|
POLE::Stream* pMETAStream = new POLE::Stream(oleStorage, metaStream);
|
|
|
|
if (( pMETAStream ) && (false == pMETAStream->fail()))
|
|
{
|
|
pictureDesciptor.Type = wmf;
|
|
VirtualStreamReader reader( pMETAStream, 0, false);
|
|
|
|
pictureDesciptor.mfp.mm = reader.ReadUInt16();
|
|
pictureDesciptor.mfp.xExt = reader.ReadUInt16();
|
|
pictureDesciptor.mfp.yExt = reader.ReadUInt16();
|
|
pictureDesciptor.mfp.hMf = reader.ReadUInt16();
|
|
|
|
pictureDesciptor.embeddedDataSize = reader.GetSize() - 8;
|
|
pictureDesciptor.embeddedData = reader.ReadBytes( pictureDesciptor.embeddedDataSize, true );
|
|
}
|
|
if (pMETAStream) delete pMETAStream;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
}
|
|
void OleObject::processPICStream( const std::wstring& picStream )
|
|
{
|
|
try
|
|
{
|
|
POLE::Stream* pPICStream = new POLE::Stream(oleStorage, picStream);
|
|
|
|
if ((pPICStream) && (false == pPICStream->fail()))
|
|
{
|
|
VirtualStreamReader reader( pPICStream, 0, false);
|
|
|
|
int sz = reader.GetSize();
|
|
|
|
int cbHeader = reader.ReadUInt32();
|
|
|
|
unsigned char* bytes = NULL;
|
|
|
|
pictureDesciptor.mfp.mm = reader.ReadInt16();
|
|
pictureDesciptor.mfp.xExt = reader.ReadInt16();
|
|
pictureDesciptor.mfp.yExt = reader.ReadInt16();
|
|
pictureDesciptor.mfp.hMf = reader.ReadInt16();
|
|
|
|
int x = reader.ReadUInt32();
|
|
int y = reader.ReadUInt32();
|
|
|
|
pictureDesciptor.dxaGoal = reader.ReadUInt32();
|
|
pictureDesciptor.dyaGoal = reader.ReadUInt32();
|
|
|
|
unsigned char* data = reader.ReadBytes(16, true);
|
|
delete []data;
|
|
|
|
pictureDesciptor.mx = reader.ReadUInt32();
|
|
pictureDesciptor.my = reader.ReadUInt32();
|
|
|
|
pictureDesciptor.dxaCropLeft = reader.ReadInt32();
|
|
pictureDesciptor.dyaCropTop = reader.ReadInt32();
|
|
pictureDesciptor.dxaCropRight = reader.ReadInt32();
|
|
pictureDesciptor.dyaCropBottom = reader.ReadInt32();
|
|
|
|
// borders
|
|
int bytesCount = (nWordVersion > 0) ? 2 : 4;
|
|
|
|
bytes = reader.ReadBytes( bytesCount, true );
|
|
pictureDesciptor.brcTop = new BorderCode( bytes, bytesCount );
|
|
RELEASEARRAYOBJECTS( bytes );
|
|
|
|
bytes = reader.ReadBytes( bytesCount, true );
|
|
pictureDesciptor.brcLeft = new BorderCode( bytes, bytesCount );
|
|
RELEASEARRAYOBJECTS( bytes );
|
|
|
|
bytes = reader.ReadBytes( bytesCount, true );
|
|
pictureDesciptor.brcBottom = new BorderCode( bytes, bytesCount );
|
|
RELEASEARRAYOBJECTS( bytes );
|
|
|
|
bytes = reader.ReadBytes( bytesCount, true );
|
|
pictureDesciptor.brcRight = new BorderCode( bytes, bytesCount );
|
|
RELEASEARRAYOBJECTS( bytes );
|
|
|
|
int etc = sz - reader.GetPosition();
|
|
unsigned char* data2 = reader.ReadBytes(etc, true);
|
|
delete []data2;
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
}
|
|
|
|
bool OleObject::processCompObjStream( const std::wstring& compStream )
|
|
{
|
|
bool res = false;
|
|
try
|
|
{
|
|
POLE::Stream* pCompStream = new POLE::Stream(oleStorage, compStream);
|
|
|
|
if ( (pCompStream) && (false == pCompStream->fail()) )
|
|
{
|
|
VirtualStreamReader reader( pCompStream, 0, false);
|
|
processCompObjStream(reader);
|
|
|
|
res = true;
|
|
}
|
|
if (pCompStream) delete pCompStream;
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool OleObject::processOleStream( const std::wstring& oleStreamName )
|
|
{
|
|
try
|
|
{
|
|
POLE::Stream* pOleStream;
|
|
HRESULT res = S_OK;
|
|
|
|
pOleStream = new POLE::Stream(oleStorage, oleStreamName);
|
|
|
|
if ( (pOleStream) && (!pOleStream->fail()))
|
|
{
|
|
VirtualStreamReader reader( pOleStream, 0, false );
|
|
processOleStream(reader);
|
|
|
|
delete pOleStream;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void OleObject::processOleStream( VirtualStreamReader& reader )
|
|
{
|
|
reader.ReadBytes( 4, false ); //skip version
|
|
|
|
//read the embedded/linked flag
|
|
int flag = reader.ReadInt32();
|
|
isLinked = FormatUtils::BitmaskToBool( flag, 0x1 );
|
|
|
|
//Link update option
|
|
this->updateMode = (LinkUpdateOption)reader.ReadInt32();
|
|
|
|
switch ( this->updateMode )
|
|
{
|
|
case NoLink: UpdateMode = L"NoLink"; break;
|
|
case Always: UpdateMode = L"Always"; break;
|
|
case OnCall: UpdateMode = L"OnCall"; break;
|
|
|
|
}
|
|
}
|
|
void OleObject::processLinkInfoStream( VirtualStreamReader& reader )
|
|
{
|
|
short cch = reader.ReadInt16();
|
|
unsigned char* str = reader.ReadBytes( cch, true );
|
|
FormatUtils::GetWStringFromBytes( this->Link, str, cch, ENCODING_WINDOWS_1250 );
|
|
RELEASEARRAYOBJECTS( str );
|
|
|
|
//skip the terminating zero of the ANSI string
|
|
//even if the characters are ANSI chars, the terminating zero has 2 bytes
|
|
reader.ReadBytes( 2, false );
|
|
|
|
//skip the next 4 bytes (flags?)
|
|
reader.ReadBytes( 4, false );
|
|
|
|
//Read the Unicode version
|
|
this->Link.clear();
|
|
|
|
cch = reader.ReadInt16();
|
|
str = reader.ReadBytes( ( cch * 2 ), true );
|
|
|
|
this->Link = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short*)(str), cch);
|
|
RELEASEARRAYOBJECTS( str );
|
|
|
|
//skip the terminating zero of the Unicode string
|
|
reader.ReadBytes( 2, false );
|
|
}
|
|
void OleObject::processCompObjStream( VirtualStreamReader& reader )
|
|
{
|
|
//skip the CompObjHeader
|
|
reader.ReadBytes( 28, false );
|
|
|
|
unsigned int sz_obj = reader.GetSize() - reader.GetPosition();
|
|
|
|
if (sz_obj > 4)
|
|
{
|
|
UserType = reader.ReadLengthPrefixedAnsiString(sz_obj);
|
|
|
|
sz_obj = reader.GetSize() - reader.GetPosition();
|
|
if (sz_obj > 4)
|
|
ClipboardFormat = reader.ReadLengthPrefixedAnsiString(sz_obj);
|
|
|
|
sz_obj = reader.GetSize() - reader.GetPosition();
|
|
if (sz_obj > 4)
|
|
Program = reader.ReadLengthPrefixedAnsiString(sz_obj);
|
|
}
|
|
}
|
|
|
|
std::wstring OleObject::getOleEntryName( const CharacterPropertyExceptions* chpx )
|
|
{
|
|
std::wstring ret;
|
|
|
|
if ( chpx != NULL )
|
|
{
|
|
for ( std::vector<SinglePropertyModifier>::const_iterator iter = chpx->grpprl->begin(); iter != chpx->grpprl->end(); iter++ )
|
|
{
|
|
if ( iter->OpCode == sprmCPicLocation || iter->OpCode == sprmOldCPicLocation)
|
|
{
|
|
ret = ( L"_" + FormatUtils::IntToWideString( FormatUtils::BytesToUInt32( iter->Arguments, 0, iter->argumentsSize ) ) );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
}
|