/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
*
|
* This file is part of xlslib -- A multiplatform, C/C++ library
|
* for dynamic generation of Excel(TM) files.
|
*
|
* Copyright 2004 Yeico S. A. de C. V. All Rights Reserved.
|
* Copyright 2008-2011 David Hoerl All Rights Reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without modification, are
|
* permitted provided that the following conditions are met:
|
*
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
* conditions and the following disclaimer.
|
*
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
#define OLE_DEBUG 0
|
|
#include "../xlslib/record.h"
|
#include "../xlslib/datast.h"
|
#include "../xlslib/extformat.h"
|
|
#include "../oledoc/oledoc.h"
|
|
using namespace std;
|
using namespace xlslib_core;
|
|
/*
|
***********************************
|
* COleDoc class implementation
|
***********************************
|
*/
|
const unsigned8_t COleDoc::OLE_FILETYPE[] = { 0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1};
|
|
COleDoc::COleDoc()
|
{
|
}
|
|
#if 0
|
COleDoc::COleDoc(const string& file_name)
|
{
|
Open(file_name);
|
}
|
#endif
|
|
|
COleDoc::~COleDoc()
|
{
|
}
|
|
int COleDoc::DumpHeader(blocks bks, size_t total_data_size)
|
{
|
size_t i;
|
size_t total_data_blocks;
|
size_t sectorID;
|
size_t msatID;
|
int errcode = NO_ERRORS;
|
|
total_data_blocks = total_data_size/BIG_BLOCK_SIZE;
|
|
#if OLE_DEBUG
|
std::cerr << "dataBlocks=" << total_data_blocks << std::endl;
|
#endif
|
// [00]FILETYPE
|
WriteByteArray(COleDoc::OLE_FILETYPE, sizeof(COleDoc::OLE_FILETYPE));
|
// [08]UK1
|
WriteSigned32(HEADVAL_DFLT_UK1);
|
// [0c]UK2
|
WriteSigned32(HEADVAL_DFLT_UK2);
|
// [10]UK2b
|
WriteSigned32(HEADVAL_DFLT_UK2b);
|
// [14]UK3
|
WriteSigned32(HEADVAL_DFLT_UK3);
|
// [18]UK4
|
WriteSigned16(HEADVAL_DFLT_UK4);
|
// [1a]UK5
|
WriteSigned16(HEADVAL_DFLT_UK5);
|
// [1c]UK6
|
WriteSigned16(HEADVAL_DFLT_UK6);
|
// [1e]LOG_2_BIG_BLOCK
|
WriteSigned16(HEADVAL_DFLT_LOG2_BIGBLOCK);
|
// [20]LOG_2_SMALL_BLOCK
|
WriteSigned32(HEADVAL_DFLT_LOG2_SMALLBLOCK);
|
// [24]UK7
|
WriteSigned32(HEADVAL_DFLT_UK7);
|
// [28]UK8
|
WriteSigned32(HEADVAL_DFLT_UK8);
|
|
// [2c] BAT_COUNT (BBDEPOT NUM BLOCKS)
|
WriteUnsigned32((unsigned32_t)bks.bat_count);
|
|
//[30] PROPERTIES_START_BLOCK
|
// Since the big block depot will go immediately after the data, I need
|
// to know the size of the data and the size of the BAT in blocks (prev)
|
WriteUnsigned32((unsigned32_t)(bks.msat_count+total_data_blocks+bks.bat_count));
|
#if OLE_DEBUG
|
std::cerr << "HEADER says directory at " << (bks.msat_count+total_data_blocks+bks.bat_count) << std::endl;
|
#endif
|
// [34] UK9
|
WriteSigned32(HEADVAL_DFLT_UK9);
|
// [38] UK10
|
WriteSigned32(HEADVAL_DFLT_UK10);
|
|
// [3c] SBAT_START
|
// No small blocks will be used, so this is set to the default empty value
|
WriteSigned32(HEADVAL_DFLT_SBAT_START);
|
|
// [40] SBAT_BLOCKCOUNT_NUMBER
|
// Use the default value
|
WriteSigned32(HEADVAL_DFLT_SBAT_COUNT);
|
|
// [44] XBAT_START
|
// we will use first and possibly additional blocks for large files
|
WriteSigned32(bks.msat_count ? 0 : HEADVAL_DFLT_XBAT_START);
|
#if OLE_DEBUG
|
std::cerr << "xbatStart=" << (bks.msat_count ? 0 : HEADVAL_DFLT_XBAT_START) << std::endl;
|
#endif
|
|
// [48] XBAT_COUNT
|
WriteUnsigned32((unsigned32_t)bks.msat_count); // was HEADVAL_DFLT_XBAT_COUNT (0)
|
#if OLE_DEBUG
|
std::cerr << "msat_count=" << bks.msat_count << std::endl;
|
#endif
|
|
// [4C] BAT_ARRAY
|
// The BAT_ARRAY shall be calculated from the number of BAT blocks and their position
|
|
// The additional blocks, if needed, are directly below the header block, so we can write
|
// them out contiguously. The special conditions are:
|
// * for each MSAT block, the last entry needs to be a pointer to the next block
|
// * the fill is -1 for all unused entries
|
// * if there are MSAT blocks, the very last entry in the last block is a special marker
|
// first sector ID
|
sectorID = bks.msat_count + total_data_blocks;
|
for(i=0; i<bks.header_bat_count; i++) {
|
#if OLE_DEBUG
|
std::cerr << "sectorID=" << sectorID << std::endl;
|
#endif
|
WriteUnsigned32((unsigned)sectorID++);
|
}
|
#if OLE_DEBUG
|
std::cerr << std::hex << Position() << std::dec << std::endl;
|
std::cerr << "SEC_ID[" << i << "]=" << (total_data_size/(BIG_BLOCK_SIZE) + i) << std::endl;
|
#endif
|
|
// if we don't fill the header table, zero out unused entries
|
for(i = 0; i<bks.header_fill; i++) {
|
WriteSigned32(BAT_NOT_USED);
|
}
|
|
#if OLE_DEBUG
|
std::cerr << "Position=0x" << std::hex << Position() << std::dec << std::endl;
|
#endif
|
|
// plow ahead, adding up to 127 entries per extra MSAT block
|
msatID = 1; // sector 0 is the first MSAT, if used
|
for(i=1; i<=bks.extra_bat_count; i++) {
|
WriteUnsigned32((unsigned)sectorID++);
|
if((i % BAT_BLOCKS_PER_MSAT_BLOCK) == 0) {
|
if(i == bks.extra_bat_count) {
|
WriteSigned32(BAT_END_CHAIN); // pointer to next MSAT
|
} else {
|
WriteUnsigned32((unsigned)msatID++); // pointer to next MSAT
|
}
|
}
|
}
|
if(bks.extra_fill) {
|
for(i = 0; i<bks.extra_fill; i++) {
|
WriteSigned32(BAT_NOT_USED);
|
}
|
WriteSigned32(BAT_END_CHAIN); // pointer to next MSAT
|
}
|
|
#if OLE_DEBUG
|
std::cerr << "Position=0x" << std::hex << Position() << std::dec << std::endl;
|
#endif
|
|
XL_ASSERT(Position() == (HEAD_SIZE + (bks.msat_count*BIG_BLOCK_SIZE)));
|
|
return errcode;
|
}
|
|
int COleDoc::DumpData(void)
|
{
|
int errcode = NO_ERRORS;
|
|
NodeList_t node_list;
|
GetAllNodes(node_list);
|
for(NodeList_Itor_t i = node_list.begin(); i != node_list.end(); i++) {
|
if((*i)->GetType() == PTYPE_FILE) {
|
for(StoreList_Itor_t j = (*i)->GetDataPointer()->begin();
|
j != (*i)->GetDataPointer()->end(); j++) {
|
//unsigned short *val = (unsigned short *)(j->GetBuffer());
|
//printf("POS=%u wrote=%lu HEX=0x%4.4x\n", Position(), j->GetDataSize(), *val);
|
XL_ASSERT(j->GetBuffer() != NULL);
|
//XL_ASSERT(j->GetDataSize() > 0);
|
errcode = WriteByteArray(j->GetBuffer(), j->GetDataSize());
|
if (errcode != NO_ERRORS) {
|
break;
|
}
|
}
|
}
|
}
|
|
return errcode;
|
}
|
|
int COleDoc::DumpDepots(blocks bks)
|
{
|
int errcode = NO_ERRORS;
|
|
NodeList_t node_list;
|
GetAllNodes(node_list);
|
signed32_t bat_index;
|
|
bat_index = 0;
|
|
// tells Excel that these are used by the MSAT
|
for(size_t i=0; i<bks.msat_count; ++i) {
|
WriteSigned32(BAT_MSAT_PLACE);
|
++bat_index;
|
++bks._bat_entries;
|
}
|
|
#if OLE_DEBUG
|
int foo=0;
|
#endif
|
for(NodeList_Itor_t node = node_list.begin(); node != node_list.end(); node++) {
|
size_t chain_len;
|
size_t data_size;
|
|
// The start block is set in the node.
|
(*node)->SetStartBlock(bat_index);
|
// Write the chain for this node element
|
data_size = (*node)->GetDataPointer()->GetDataSize();
|
chain_len = data_size/BIG_BLOCK_SIZE - 1;
|
#if OLE_DEBUG
|
std::cerr << "NODE[" << foo++ << "]: start_block=" << bat_index
|
<< " dataSize=" << data_size
|
<< " Sectors=" << chain_len + 1 /* directory_terminator */ << std::endl;
|
#endif
|
for(size_t i = 0; i < chain_len; i++) {
|
WriteSigned32(++bat_index);
|
++bks._bat_entries;
|
}
|
|
// Set the terminator number
|
WriteSigned32(BAT_END_CHAIN);
|
++bat_index;
|
++bks._bat_entries;
|
}
|
|
#if OLE_DEBUG
|
std::cerr << "BAT_SELF_PLACE=" << (bat_index+1)
|
<< " -> " << (bat_index+1+bks.bat_count+1)
|
<< " TOTAL=" << bks.bat_count << std::endl;
|
#endif
|
// Write the -3 number for every index in the BAT that references to some BAT block (uh!?)
|
for(size_t i=0; i<bks.bat_count; i++) {
|
WriteSigned32(BAT_SELF_PLACE);
|
++bat_index;
|
++bks._bat_entries;
|
}
|
#if OLE_DEBUG
|
std::cerr << "last write: left = " << (Position() % HEAD_SIZE) << std::endl;
|
#endif
|
|
// This is the entry for the directory chain, the very last block, saying directory is just one sector
|
WriteSigned32(BAT_END_CHAIN);
|
++bat_index;
|
++bks._bat_entries;
|
|
// Fill the rest of the _LAST_ BAT block, code appears to handle the 0 case (IT DID NOT - SEE addition of final % BIG_BLOCK_SIZE BELOW)
|
unsigned32_t num_indexes = (unsigned32_t)bat_index;
|
unsigned32_t to_fill_size = (BIG_BLOCK_SIZE - ((4*num_indexes) % BIG_BLOCK_SIZE)) % BIG_BLOCK_SIZE;
|
|
#if OLE_DEBUG
|
std::cerr << "num_indexes=" << num_indexes << " to_fill_size=" << to_fill_size << std::endl;
|
#endif
|
|
SerializeFixedArray(BAT_NOT_USED_BYTE, to_fill_size);
|
|
#if OLE_DEBUG
|
std::cerr << "last write: left = " << (Position() % HEAD_SIZE) << std::endl;
|
|
std::cerr << "Position=0x" << std::hex << Position() << std::dec << std::endl;
|
std::cerr << "bat_entries=" << bks.bat_entries << " actual=" << bks._bat_entries << std::endl;
|
#endif
|
|
XL_ASSERT(bks.bat_entries == bks._bat_entries);
|
|
return errcode;
|
}
|
|
int COleDoc::DumpFileSystem(void)
|
{
|
int errcode = NO_ERRORS;
|
|
|
NodeList_t node_list;
|
GetAllNodes(node_list);
|
|
#if OLE_DEBUG
|
std::cerr << "FILESYSTEM directory at SecID=" << (Position() - HEAD_SIZE)/BIG_BLOCK_SIZE
|
<< " (remain=" << (Position() % BIG_BLOCK_SIZE) << ")" << std::endl;
|
#endif
|
DumpNode(GetRootEntry());
|
|
for(NodeList_Itor_t node = node_list.begin(); node != node_list.end(); node++) {
|
DumpNode(*(*node));
|
}
|
|
return errcode;
|
}
|
|
int COleDoc::DumpOleFile(void)
|
{
|
blocks bks;
|
|
int errcode = NO_ERRORS;
|
|
bks = GetBATCount();
|
size_t total_data_size = GetTotalDataSize();
|
//printf("TOTAL %lu blocks=%lu mod=%lu\n", total_data_size, total_data_size/512, total_data_size % 512);
|
|
errcode |= DumpHeader(bks, total_data_size);
|
XL_ASSERT((Position() % 512) == 0 /*1*/);
|
|
errcode |= DumpData();
|
XL_ASSERT((Position() % 512) == 0 /*2*/);
|
|
errcode |= DumpDepots(bks);
|
XL_ASSERT((Position() % 512) == 0 /*3*/);
|
|
errcode |= DumpFileSystem();
|
XL_ASSERT((Position() % 512) == 0 /*3*/);
|
|
return errcode;
|
}
|
|
blocks COleDoc::GetBATCount()
|
{
|
blocks bks;
|
size_t bat_num_entries;
|
size_t data_bat_entries;
|
size_t bat_num_blocks, dir_bat_entries, bat_blocks_needed, bat_block_capacity;
|
size_t extra_bats, msat_blocks, msat_bats, last_block_extras;
|
|
memset(&bks, 0, sizeof(bks));
|
|
data_bat_entries = GetTotalDataSize()/BIG_BLOCK_SIZE; // + GetNumDataFiles(); //terminator???
|
XL_ASSERT(GetTotalDataSize() == (data_bat_entries * BIG_BLOCK_SIZE) );
|
|
// Block allocation strategy. Within the OLE header are 109 slots for BAT Sectors.
|
// But, when the file gets big, you run out (127 sectors in each BAT Sector). So,
|
// the 110th BAT has to go into a special block dedicated to hold these. One additional
|
// block gets you 127 more BAT entries, and so forth.
|
|
dir_bat_entries = 1; // Last block is directory, this is the terminator that says dir uses only one sector
|
bat_num_blocks = 1; // seed to enter loop below
|
bat_block_capacity = 0;
|
msat_blocks = 0;
|
//msat_bats = 0; // no affect
|
bat_num_entries = 0; // kch
|
bat_blocks_needed = data_bat_entries/BAT_ENTRIES_PER_BLOCK; // minimum
|
bat_blocks_needed += bat_blocks_needed/BAT_ENTRIES_PER_BLOCK; // for the BAT itself
|
|
// first loop assumes no MSATs involved
|
while(bat_num_blocks > bat_block_capacity || bat_num_blocks != bat_blocks_needed) {
|
bat_num_blocks = bat_blocks_needed;
|
if(bat_num_blocks > HEADER_SAT_SIZE) {
|
msat_bats = bat_num_blocks - HEADER_SAT_SIZE;
|
msat_blocks = msat_bats/BAT_BLOCKS_PER_MSAT_BLOCK;
|
if(msat_bats % BAT_BLOCKS_PER_MSAT_BLOCK) {++msat_blocks; }
|
}
|
|
bat_num_entries = msat_blocks + data_bat_entries + bat_num_blocks + dir_bat_entries; // bat_bat_entries
|
|
// based on what we know now, this is what we need
|
bat_blocks_needed = bat_num_entries/BAT_ENTRIES_PER_BLOCK;
|
if(bat_num_entries % BAT_ENTRIES_PER_BLOCK) {++bat_blocks_needed; }
|
|
// number of slots available
|
bat_block_capacity = HEADER_SAT_SIZE + BAT_BLOCKS_PER_MSAT_BLOCK*msat_blocks;
|
#if OLE_DEBUG
|
std::cerr << "bat_blocks=" << bat_num_blocks
|
<< " capacity=" << bat_block_capacity
|
<< " needed=" << bat_blocks_needed << std::endl;
|
#endif
|
}
|
|
if(bat_num_blocks > HEADER_SAT_SIZE) {
|
extra_bats = bat_num_blocks - HEADER_SAT_SIZE;
|
|
bks.msat_count = msat_blocks;
|
bks.header_bat_count = HEADER_SAT_SIZE;
|
bks.extra_bat_count = extra_bats;
|
|
last_block_extras = extra_bats % BAT_BLOCKS_PER_MSAT_BLOCK;
|
if(last_block_extras) {
|
bks.extra_fill = BAT_BLOCKS_PER_MSAT_BLOCK - last_block_extras;
|
}
|
} else {
|
bks.header_bat_count = bat_num_blocks;
|
bks.header_fill = HEADER_SAT_SIZE - bat_num_blocks;
|
}
|
bks.bat_entries = bat_num_entries;
|
bks.bat_count = bat_num_blocks;
|
|
#if OLE_DEBUG
|
std::cerr << "entries=" << bks.bat_entries << " bats=" << bks.bat_count
|
<< " msats=" << bks.msat_count << " headerBats=" << bks.header_bat_count
|
<< " extraBats=" << bks.extra_bat_count << " headFill=" << bks.header_fill
|
<< " extraFill=" << bks.extra_fill << std::endl;
|
#endif
|
|
return bks;
|
}
|
|
// NOTE: name_unicode has to be deleted after this function finishes.
|
// Ideally, this function should be implemented as part of a std::string
|
// derived class, so the array would be deleted automatically
|
|
|
size_t COleDoc::GetUnicodeName(const char* name, char** ppname_unicode)
|
{
|
size_t name_size = strlen(name);
|
if(name_size > PROPERTY_MAX_NAME_LENGTH) {
|
name_size = PROPERTY_MAX_NAME_LENGTH;
|
}
|
|
size_t size_unicode = (name_size+1)*2;
|
|
if(*ppname_unicode != NULL) { delete[] *ppname_unicode; }
|
*ppname_unicode = (char*)new unsigned8_t[size_unicode];
|
memset(*ppname_unicode, 0x00, size_unicode);
|
|
for(size_t i=0; i<(size_unicode/2-1); i++) {
|
(*ppname_unicode)[2*i] = name[i];
|
}
|
|
return size_unicode;
|
}
|
|
int COleDoc::DumpNode(COleProp& node)
|
{
|
int errcode = NO_ERRORS;
|
char* name_unicode = NULL;
|
|
// Get the unicode name and its size
|
size_t size_name = GetUnicodeName(node.GetName().c_str(), &name_unicode);
|
|
// [00] PROPERTY_NAME
|
WriteByteArray((const unsigned8_t*)name_unicode, size_name);
|
|
// Fill the rest of the name field with 0x00
|
XL_ASSERT(PPTPOS_NAMELENGTH > size_name);
|
SerializeFixedArray(PROPERTY_DFLT_NOTUSED, PPTPOS_NAMELENGTH - size_name);
|
|
// [40] NAME_SIZE
|
WriteSigned16((signed16_t)size_name);
|
|
// [42] PROPERTY_TYPE
|
WriteByte(node.GetType());
|
|
// [43] NODE_COLOR
|
WriteByte(node.GetColor());
|
|
// [44] PREVIOUS_PROP
|
WriteSigned32(node.GetPreviousIndex());
|
// [48] NEXT_PROP
|
WriteSigned32(node.GetNextIndex());
|
// [4c] CHILD_PROP
|
WriteSigned32(node.GetChildIndex());
|
|
// printf("NAME: %s TYPE=%d Color=%d Indexes: %4.4x %4.4x %4.4x\n", node.GetName().c_str(), node.GetType(), node.GetColor(), node.GetPreviousIndex(), node.GetNextIndex(), node.GetChildIndex() );
|
|
// Fill empty block
|
SerializeFixedArray(PROPERTY_DFLT_NOTUSED, (PPTPOS_SECS1 - PPTPOS_UNUSED_EMPTY0));
|
|
//[64]...[70]
|
// SECONDS_1, DAYS_2, SECONDS_2, DAYS_2
|
WriteSigned32(node.GetCreatedSecs());
|
WriteSigned32(node.GetCreatedDays());
|
WriteSigned32(node.GetModifiedDays());
|
WriteSigned32(node.GetModifiedSecs());
|
|
// [74] START_BLOCK
|
#if OLE_DEBUG
|
std::cerr << "START_BLOCK_1=" << node.GetStartBlock() << std::endl;
|
#endif
|
WriteSigned32(node.GetStartBlock());
|
|
// [78] SIZE
|
if(node.GetType() == PTYPE_FILE) {
|
WriteSigned32((signed32_t)node.GetSize());
|
} else {
|
WriteSigned32(0);
|
}
|
|
// A unused space:
|
WriteSigned32(PROPERTY_DFLT_NOTUSED);
|
|
delete[] name_unicode;
|
name_unicode = NULL;
|
|
return errcode;
|
}
|
