AOO410/main/sw/source/filter/ww8/dump/msvbasic.cxx

/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"


#include <string.h> 	// memset(), ...
#ifndef UNX
#include <io.h> 		// access()
#endif
#include <msvbasic.hxx>

/* class VBA_Impl:
 * The VBA class provides a set of methods to handle Visual Basic For
 * Applications streams, the constructor is given the root ole2 stream
 * of the document, Open reads the VBA project file and figures out
 * the number of VBA streams, and the offset of the data within them.
 * Decompress decompresses a particular numbered stream, NoStreams returns
 * this number, and StreamName can give you the streams name. Decompress
 * will call Output when it has a 4096 byte collection of data to output,
 * and also with the final remainder of data if there is still some left
 * at the end of compression. Output is virtual to allow custom handling
 * of each chunk of decompressed data. So inherit from this to do something
 * useful with the data.
 *
 * cmc
 * */

sal_uInt8 VBA_Impl::ReadPString(SvStorageStreamRef &xVBAProject)
{
	sal_uInt16 idlen;
	sal_uInt8 type=0;
	*xVBAProject >> idlen;
	sal_uInt8 out;
	int i=0;
	if (idlen < 6)
	{
		type=0;
		xVBAProject->SeekRel(-2);
		return(type);
	}

	for(i=0;i<idlen/2;i++)
	{
		*xVBAProject >> out;
		xVBAProject->SeekRel(1);
		if (i==2)
		{
			type=out;
			if ((type != 'G') && (type != 'C'))
				type=0;
			if (type == 0)
			{
				xVBAProject->SeekRel(-8);
				break;
			}
		}
	}


	return(type);
}

void VBA_Impl::ConfirmFixedOctect(SvStorageStreamRef &xVBAProject)
{
	static const sal_uInt8 stest[8] =
		{
		0x06, 0x02, 0x01, 0x00, 0x08, 0x02, 0x00, 0x00
		};

	sal_uInt8 test[8];
	xVBAProject->Read(test,8);
	if (memcmp(stest,test,8) != 0)
		DBG_WARNING("Found a different octect, please report");
}

void VBA_Impl::Confirm12Zeros(SvStorageStreamRef &xVBAProject)
{
	static const sal_uInt8 stest[12]={0};
	sal_uInt8 test[12];
	xVBAProject->Read(test,12);
	if (memcmp(stest,test,12) != 0)
		DBG_WARNING("Found a Non Zero block, please report");
}

void VBA_Impl::ConfirmHalfWayMarker(SvStorageStreamRef &xVBAProject)
{
	static const sal_uInt8 stest[12]={0,0,0,0,0,0,0,0,0,0,1,0};
	sal_uInt8 test[12];
	xVBAProject->Read(test,12);
	if (memcmp(stest,test,12) != 0)
		DBG_WARNING("Found a different halfway marker, please report");
}

void VBA_Impl::ConfirmFixedMiddle(SvStorageStreamRef &xVBAProject)
{
	static const sal_uInt8 stest[20] =
	{
		0x00, 0x00, 0xe1, 0x2e, 0x45, 0x0d, 0x8f, 0xe0,
		0x1a, 0x10, 0x85, 0x2e, 0x02, 0x60, 0x8c, 0x4d,
		0x0b, 0xb4, 0x00, 0x00
	};

	sal_uInt8 test[20];
	xVBAProject->Read(test,20);
	if (memcmp(stest,test,20) != 0)
	{
		DBG_WARNING("Found a different middle marker, please report");
		xVBAProject->SeekRel(-20);
	}
}

void VBA_Impl::ConfirmFixedMiddle2(SvStorageStreamRef &xVBAProject)
{
	static const sal_uInt8 stest[20] =
	{
		0x00, 0x00, 0x2e, 0xc9, 0x27, 0x8e, 0x64, 0x12,
		0x1c, 0x10, 0x8a, 0x2f, 0x04, 0x02, 0x24, 0x00,
		0x9c, 0x02, 0x00, 0x00
	};

	sal_uInt8 test[20];
	xVBAProject->Read(test,20);
	if (memcmp(stest,test,20) != 0)
		{
		DBG_WARNING("Found a different middle2 marker, please report");
		xVBAProject->SeekRel(-20);
		}
}


void VBA_Impl::Output( int nLen, const sal_uInt8 *pData)
{
	sVBAString += String( (const sal_Char *)pData, nLen );
/*
//For debugging purposes
	for(int i=0;i<len;i++)
		*pOut << data[i];
*/
}


int VBA_Impl::ReadVBAProject(const SvStorageRef &rxVBAStorage)
	{
	SvStorageStreamRef xVBAProject;
	xVBAProject = rxVBAStorage->OpenStream(
					String::CreateFromAscii( "_VBA_PROJECT" ),
					STREAM_STD_READ | STREAM_NOCREATE );

	if( !xVBAProject.Is() || SVSTREAM_OK != xVBAProject->GetError() )
	{
		DBG_WARNING("Not able to find vba project, cannot find macros");
		return(0);
	}
	xVBAProject->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );

	//*pOut << hex;
	sal_uInt8 header[30] =
	{
		0xcc, 0x61, 0x5e, 0x00, 0x00, 0x01, 0x00, 0xff,
		0x07, 0x04, 0x00, 0x00, 0x09, 0x04, 0x00, 0x00,
		0xe4, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x01, 0x00
	};
	sal_uInt8 headerin[30];

	xVBAProject->Read(headerin,30);
	if (memcmp(header,headerin,30) != 0)
		DBG_WARNING("Warning VBA header is different, please report");
	sal_uInt16 value;
	*xVBAProject >> value;
	//*pOut << "Trigger value 1 is " << value << endl;
	sal_uInt16 svalue;
	*xVBAProject >> svalue;
	if (svalue != 0x02)
		DBG_WARNING("Warning VBA number is different, please report");

	int count=0;
	sal_uInt8 testc=0;

	//*pOut << "Other strings after the middle are..." << endl;
	//There appears to be almost any number of strings acceptable
	//most begin with */G , and sometimes with
	//*/C. Those with G always have a trailer of 12 bytes, those
	//with C come in pairs, the first with no trailer, and the
	//second with one of 12 bytes. The following code attemts
	//to read these strings and ends when it reaches a sequence of
	//bytes which fails a test to be a valid string. So this
	//while loop here is the particular piece of code which is
	//very suspect and likely to be the cause of any crashes and
	//problems.
	while ((testc = ReadPString(xVBAProject)) != 0)
	{
		//*pOut << endl;
		//*pOut << "testcharacter is " << testc << endl;
		switch (testc)
		{
			case 'C':
				count++;
				if (count == 2)
				{
					Confirm12Zeros(xVBAProject);
					count=0;
				}
				break;
			default:
			case 'G':
				Confirm12Zeros(xVBAProject);
				break;
		}
	}

	//appears to be a fixed 20 byte sequence here, and then the strings
	//continue
	ConfirmFixedMiddle(xVBAProject);

	count=0;
	testc=0;

	while ((testc = ReadPString(xVBAProject)) != 0)
	{
		//*pOut << endl;
		//*pOut << "testcharacter is " << testc << endl;
		switch (testc)
		{
			case 'C':
				count++;
				if (count == 2)
				{
					Confirm12Zeros(xVBAProject);
					count=0;
				}
				break;
			default:
			case 'G':
				Confirm12Zeros(xVBAProject);
				break;
		}
	}

	//there *may* be another different 20byte fixed string
	ConfirmFixedMiddle2(xVBAProject);

	//*pOut << "testc is " << testc << endl;
	//*pOut << "position is " << xVBAProject->Tell() << endl;

	sal_uInt16 nModules;
	*xVBAProject >> nModules;

	//begin section, this section isn't really 100% correct
	//*pOut << nModules << hex << " vba modules" << endl;
	xVBAProject->SeekRel(2*nModules);
	xVBAProject->SeekRel(4);
	//*pOut << "position is " << xVBAProject->Tell() << endl;
	ConfirmFixedOctect(xVBAProject);

	sal_uInt16 junksize;
	while(junksize != 0xFFFF)
	{
		xVBAProject->Read(&junksize,2); // usually 18 02, sometimes 1e 02
		//but sometimes its a run of numbers until 0xffff, gagh!!!
		//*pOut << "position is " << xVBAProject->Tell() << "len is "
		//	<< junksize << endl;
	}

	sal_uInt16 ftest;
	*xVBAProject >> ftest;
	if (ftest != 0xFFFF)
		xVBAProject->SeekRel(ftest);
	*xVBAProject >> ftest;
	if (ftest != 0xFFFF)
		xVBAProject->SeekRel(ftest);

	xVBAProject->SeekRel(100);
	//*pOut << "position is " << xVBAProject->Tell() << endl;
	//end section


	*xVBAProject >> nOffsets;
	pOffsets = new VBAOffset_Impl[nOffsets];
	int i;
	for (i=0;i<nOffsets;i++)
		{
		sal_uInt8 discard;
		sal_uInt16 len;
		*xVBAProject >> len;
		int j;
		for (j=0;j<len/2;j++)
			{
			*xVBAProject >> discard;
			pOffsets[i].sName += discard;
			*xVBAProject >> discard;
			}
		*xVBAProject >> len;
		xVBAProject->SeekRel(len);

		//begin section, another problem area
		*xVBAProject >> len;
		if (len == 0xFFFF)
		{
			xVBAProject->SeekRel(2);
			*xVBAProject >> len;
			xVBAProject->SeekRel(len);
		}
		else
			xVBAProject->SeekRel(len+2);
		//
		/* I have a theory that maybe you read a 16bit len, and
		 * if it has 0x02 for the second byte then it is a special
		 * token of its own that affects nothing else, otherwise
		 * it is a len of the following data. C. I must test this
		 * theory later.
		 */
		//end section

		xVBAProject->SeekRel(8);
		sal_uInt8 no_of_octects;
		*xVBAProject >> no_of_octects;
		for(j=0;j<no_of_octects;j++)
			xVBAProject->SeekRel(8);
		xVBAProject->SeekRel(6);

		*xVBAProject >> pOffsets[i].nOffset;
		//*pOut << pOffsets[i].pName.GetStr() << " at 0x" << hex << pOffsets[i].nOffset << endl;
		xVBAProject->SeekRel(2);
		}

	//*pOut << endl;
	return(nOffsets);
	}

sal_Bool VBA_Impl::Open( const String &rToplevel,const String &rSublevel )
{
	/* beginning test for vba stuff */
	sal_Bool bRet = sal_False;
	SvStorageRef xMacros= xStor->OpenStorage(rToplevel);
	if( !xMacros.Is() || SVSTREAM_OK != xMacros->GetError() )
	{
		DBG_WARNING("No Macros Storage");
	}
	else
	{
		xVBA = xMacros->OpenStorage(rSublevel);
		if( !xVBA.Is() || SVSTREAM_OK != xVBA->GetError() )
		{
			DBG_WARNING("No Visual Basic in Storage");
		}
		else
		{
			if (ReadVBAProject(xVBA))
				bRet = sal_True;
		}
	}
	/* end test for vba stuff */
	return bRet;
}

const String &VBA_Impl::Decompress( sal_uInt16 nIndex, int *pOverflow)
{
	SvStorageStreamRef xVBAStream;
	sVBAString.Erase();

	DBG_ASSERT( nIndex < nOffsets, "Index out of range" );
	xVBAStream = xVBA->OpenStream( pOffsets[nIndex].sName,
						STREAM_STD_READ | STREAM_NOCREATE );
	if (pOverflow)
		*pOverflow=0;
	if( !xVBAStream.Is() || SVSTREAM_OK !=
		xVBAStream->GetError() )
	{
		DBG_WARNING("Not able to open vb module ");
//		DBG_WARNING((pOffsets[nIndex].sName).GetStr());
	}
	else
	{
		xVBAStream->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
		DecompressVBA(nIndex,xVBAStream);
		/*
		 * if len was too big for a single string set that variable ?
		 *	if ((len > XX) && (pOverflow))
				*pOverflow=1;
		 */
		if (bCommented)
		{
			String sTempStringa(String::CreateFromAscii( "\x0D\x0A"));
			String sTempStringb(String::CreateFromAscii( "\x0D\x0ARem "));
			sVBAString.SearchAndReplaceAll(sTempStringa,sTempStringb);
			sVBAString.InsertAscii("Rem ",0);
		}
	}
	return sVBAString;
}


int VBA_Impl::DecompressVBA( int nIndex, SvStorageStreamRef &xVBAStream )
{
	sal_uInt8 leadbyte;
	unsigned int pos = 0;

	//*pOut << "jumping to " << hex << offsets[nIndex].offset << endl;
	xVBAStream->Seek(pOffsets[nIndex].nOffset+3);

	int len;
	sal_uInt16 token;
	int distance, shift, clean=1;

	while(xVBAStream->Read(&leadbyte,1))
		{
		//*pOut << "reading 8 data unit block beginning with " << leadbyte << int(leadbyte) << " at pos " << xVBAStream->Tell() << " real pos " << pos << endl;
		for(int position=0x01;position < 0x100;position=position<<1)
			{
			//we see if the leadbyte has flagged this location as a dataunit
			//which is actually a token which must be looked up in the history
			if (leadbyte & position)
				{
				*xVBAStream >> token;

				if (clean == 0)
					clean=1;

				//For some reason the division of the token into the length
				//field of the data to be inserted, and the distance back into
				//the history differs depending on how full the history is
				int pos2 = pos%WINDOWLEN;
				if (pos2 <= 0x10)
					shift = 12;
				else if (pos2 <= 0x20)
					shift = 11;
				else if (pos2 <= 0x40)
					shift = 10;
				else if (pos2 <= 0x80)
					shift = 9;
				else if (pos2 <= 0x100)
					shift = 8;
				else if (pos2 <= 0x200)
					shift = 7;
				else if (pos2 <= 0x400)
					shift = 6;
				else if (pos2 <= 0x800)
					shift = 5;
				else
					shift = 4;

				int i;
				len=0;
				for(i=0;i<shift;i++)
					len |= token & (1<<i);

				//*pOut << endl << "match lookup token " << int(token) << "len " << int(len) << endl;

				len += 3;
				//*pOut << endl << "len is " << len << "shift is " << shift << endl;

				distance = token >> shift;
				//*pOut << "distance token shift is " << distance << " " << int(token) << " " << shift << "pos is " << pos << " " << xVBAStream->Tell() << endl;

				//read the len of data from the history, wrapping around the
				//WINDOWLEN boundary if necessary
				//data read from the history is also copied into the recent
				//part of the history as well.
				for (i = 0; i < len; i++)
					{
					unsigned char c;
					//*pOut << endl << (pos%WINDOWLEN)-distance-1 << " " << pos << " " << distance << endl;
					c = aHistory[(pos-distance-1)%WINDOWLEN];
					aHistory[pos%WINDOWLEN] = c;
					pos++;
					//*pOut << "real pos is " << pos << endl;
					//
					//temp removed
					//*pOut << c ;
					}
				}
			else
				{
				// special boundary case code, not guarantueed to be correct
				// seems to work though, there is something wrong with the
				// compression scheme (or maybe a feature) where when
				// the data ends on a WINDOWLEN boundary and the excess
				// bytes in the 8 dataunit list are discarded, and not
				// interpreted as tokens or normal data.
				if ((pos != 0) && ((pos%WINDOWLEN) == 0) && (clean))
					{
					//*pOut << "at boundary position is " << position << " " << xVBAStream->Tell() << " pos is " << pos << endl;
					//if (position != 0x01)
					//*pOut << "must restart by eating remainder single byte data units" << endl;
					xVBAStream->SeekRel(2);
					clean=0;
					Output(WINDOWLEN,aHistory);
					break;
					}
				//This is the normal case for when the data unit is not a
				//token to be looked up, but instead some normal data which
				//can be output, and placed in the history.
				if (xVBAStream->Read(&aHistory[pos%WINDOWLEN],1))
				{
					pos++;
					//temp removed
					//*pOut << aHistory[pos++%WINDOWLEN];
				}
				if (clean == 0)
					clean=1;
				//*pOut << "pos is " << pos << " " << xVBAStream->Tell() << endl;
				}
			}
		}
	if (pos%WINDOWLEN)
		Output(pos%WINDOWLEN,aHistory);
	return(pos);
}