lotuswordpro/source/filter/tocread.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56 #include "first.hxx"
  57 #include "assert.h"
  58 namespace OpenStormBento
  59 {
  60
  61 BenError
  62 CBenTOCReader::ReadLabelAndTOC()
  63 {
  64     BenError Err;
  65
  66     unsigned long TOCOffset;
  67     if ((Err = ReadLabel(&TOCOffset, &cTOCSize)) != BenErr_OK)
  68         return Err;
  69
  70     sal_uLong nLength;
  71     if ((Err = cpContainer->GetSize(&nLength)) != BenErr_OK)
  72         return Err;
  73
  74     if (TOCOffset > nLength)
  75         return BenErr_ReadPastEndOfTOC;
  76
  77     if (cTOCSize > nLength - TOCOffset)
  78         return BenErr_ReadPastEndOfTOC;
  79
  80     if ((Err = cpContainer->SeekToPosition(TOCOffset)) != BenErr_OK)
  81         return Err;
  82
  83     cpTOC.reset( new BenByte[cTOCSize] );
  84     if ((Err = cpContainer->ReadKnownSize(cpTOC.get(), cTOCSize)) != BenErr_OK)
  85         return Err;
  86
  87     if ((Err = ReadTOC()) != BenErr_OK)
  88         return Err;
  89
  90     return BenErr_OK;
  91 }
  92
  93 BenError
  94 CBenTOCReader::ReadLabel(unsigned long * pTOCOffset, unsigned long * pTOCSize)
  95 {
  96     // If seek fails, then probably because stream is smaller than
  97     // BEN_LABEL_SIZE and thus can't be Bento container
  98     BenError Err;
  99     if ((Err = cpContainer->SeekFromEnd(-BEN_LABEL_SIZE)) != BenErr_OK)
 100         return BenErr_NotBentoContainer;
 101
 102     BenByte Label[BEN_LABEL_SIZE];
 103     if ((Err = cpContainer->ReadKnownSize(Label, BEN_LABEL_SIZE)) != BenErr_OK)
 104         return Err;
 105
 106     if (memcmp(Label, gsBenMagicBytes, BEN_MAGIC_BYTES_SIZE) != 0)
 107         if ((Err = SearchForLabel(Label)) != BenErr_OK)
 108             return Err;
 109
 110     BenByte * pCurrLabel = Label + BEN_MAGIC_BYTES_SIZE;
 111
 112     BenWord Flags =
 113         UtGetIntelWord(pCurrLabel); pCurrLabel += 2; // Flags
 114     // Newer files are 0x0101--indicates if big or little endian.  Older
 115     // files are 0x0 for flags
 116     if (Flags != 0x0101 && Flags != 0x0)
 117         return BenErr_UnknownBentoFormatVersion;
 118
 119     cBlockSize = UtGetIntelWord(pCurrLabel) * 1024; pCurrLabel += 2;
 120     if (cBlockSize == 0)
 121         return BenErr_NotBentoContainer;
 122
 123     // Check major version
 124     if (UtGetIntelWord(pCurrLabel) != BEN_CURR_MAJOR_VERSION)
 125         return BenErr_UnknownBentoFormatVersion;
 126     pCurrLabel += 2;
 127
 128     pCurrLabel += 2;    // Minor version
 129
 130     *pTOCOffset = UtGetIntelDWord(pCurrLabel); pCurrLabel += 4;
 131     *pTOCSize = UtGetIntelDWord(pCurrLabel);
 132
 133     assert(pCurrLabel + 4 == Label + BEN_LABEL_SIZE);
 134
 135     return BenErr_OK;
 136 }
 137
 138 #define LABEL_READ_BUFFER_SIZE 500
 139 #define MAX_SEARCH_AMOUNT 1024 * 1024
 140
 141 BenError
 142 CBenTOCReader::SearchForLabel(BenByte * pLabel)
 143 {
 144     BenError Err;
 145
 146     sal_uLong Length;
 147     if ((Err = cpContainer->GetSize(&Length)) != BenErr_OK)
 148         return Err;
 149
 150     // Always ready to check for MagicBytes from
 151     // CurrOffset - BEN_MAGIC_BYTES_SIZE to CurrOffset - 1
 152     unsigned long CurrOffset = Length - BEN_LABEL_SIZE + BEN_MAGIC_BYTES_SIZE -
 153       1;
 154
 155     char Buffer[LABEL_READ_BUFFER_SIZE] = {0};
 156
 157     unsigned long BufferStartOffset = Length;   // Init to big value
 158
 159     while (CurrOffset >= BEN_MAGIC_BYTES_SIZE)
 160     {
 161         // Don't search backwards more than 1 meg
 162         if (Length - CurrOffset > MAX_SEARCH_AMOUNT)
 163             break;
 164
 165         // If before beginning of buffer
 166         if (CurrOffset - BEN_MAGIC_BYTES_SIZE < BufferStartOffset)
 167         {
 168             unsigned long UsedBufferSize;
 169             if (CurrOffset < LABEL_READ_BUFFER_SIZE)
 170                 UsedBufferSize = CurrOffset;
 171             else UsedBufferSize = LABEL_READ_BUFFER_SIZE;
 172
 173             if ((Err = cpContainer->SeekToPosition(CurrOffset - UsedBufferSize))
 174               != BenErr_OK)
 175                 return Err;
 176
 177             if ((Err = cpContainer->ReadKnownSize(Buffer, UsedBufferSize)) !=
 178               BenErr_OK)
 179                 return Err;
 180
 181             BufferStartOffset = CurrOffset - UsedBufferSize;
 182         }
 183
 184         if (memcmp(Buffer + (CurrOffset - BEN_MAGIC_BYTES_SIZE -
 185           BufferStartOffset), gsBenMagicBytes, BEN_MAGIC_BYTES_SIZE) == 0)
 186         {
 187             if ((Err = cpContainer->SeekToPosition(CurrOffset -
 188               BEN_MAGIC_BYTES_SIZE)) != BenErr_OK)
 189                 return Err;
 190
 191             return cpContainer->ReadKnownSize(pLabel, BEN_LABEL_SIZE);
 192         }
 193
 194         --CurrOffset;
 195     }
 196
 197     return BenErr_NotBentoContainer;    // Didn't find magic bytes
 198 }
 199
 200 BenError
 201 CBenTOCReader::ReadTOC()
 202 {
 203     BenError Err;
 204     BenByte LookAhead = GetCode();
 205     BenGeneration Generation = 0;
 206
 207     // Read in all objects
 208     while (LookAhead == BEN_NEW_OBJECT)
 209     {
 210         BenObjectID ObjectID;
 211         if ((Err = GetDWord(&ObjectID)) != BenErr_OK)
 212             return Err;
 213         pCBenObject pObject = nullptr;
 214
 215         // Read in all properties for object
 216         do
 217         {
 218             BenObjectID PropertyID;
 219
 220             if ((Err = GetDWord(&PropertyID)) != BenErr_OK)
 221                 return Err;
 222             pCBenProperty pProperty = nullptr;
 223
 224             // Read in all values for property
 225             do
 226             {
 227                 BenObjectID ReferencedListID = 0;
 228
 229                 BenObjectID TypeID;
 230                 if ((Err = GetDWord(&TypeID)) != BenErr_OK)
 231                     return Err;
 232                 LookAhead = GetCode();
 233
 234                 if (LookAhead == BEN_EXPLICIT_GEN)
 235                 {
 236                     if ((Err = GetDWord(&Generation)) != BenErr_OK)
 237                         return Err;
 238                     LookAhead = GetCode();
 239                 }
 240
 241                 if (LookAhead == BEN_REFERENCE_LIST_ID)
 242                 {
 243                     if ((Err = GetDWord(&ReferencedListID)) != BenErr_OK)
 244                         return Err;
 245                     LookAhead = GetCode();
 246                 }
 247
 248                 if (PropertyID == BEN_PROPID_GLOBAL_PROPERTY_NAME ||
 249                     PropertyID == BEN_PROPID_GLOBAL_TYPE_NAME)
 250                 {
 251                     // Read property or type name
 252
 253                     if (pObject != nullptr || TypeID != BEN_TYPEID_7_BIT_ASCII ||
 254                       LookAhead != BEN_OFFSET4_LEN4)
 255                         return BenErr_NamedObjectError;
 256
 257                     BenContainerPos Pos;
 258                     unsigned long Length;
 259
 260                     if ((Err = GetDWord(&Pos)) != BenErr_OK)
 261                         return Err;
 262                     if ((Err = GetDWord(&Length)) != BenErr_OK)
 263                         return Err;
 264                     LookAhead = GetCode();
 265
 266                     if ((Err = cpContainer->SeekToPosition(Pos)) != BenErr_OK)
 267                         return Err;
 268
 269                     #define STACK_BUFFER_SIZE 256
 270                     char sStackBuffer[STACK_BUFFER_SIZE];
 271                     char * sAllocBuffer;
 272                     char * sBuffer;
 273                     if (Length > STACK_BUFFER_SIZE)
 274                     {
 275                         sBuffer = new char[Length];
 276                         sAllocBuffer = sBuffer;
 277                     }
 278                     else
 279                     {
 280                         sBuffer = sStackBuffer;
 281                         sAllocBuffer = nullptr;
 282                     }
 283
 284                     if ((Err = cpContainer->ReadKnownSize(sBuffer, Length)) !=
 285                       BenErr_OK)
 286                     {
 287                         delete[] sAllocBuffer;
 288                         return Err;
 289                     }
 290
 291                     OString sName(sBuffer, Length);
 292
 293                     pCUtListElmt pPrevNamedObjectListElmt;
 294                     if (FindNamedObject(&cpContainer->GetNamedObjects(),
 295                       sName, &pPrevNamedObjectListElmt) != nullptr)
 296                     {
 297                         delete[] sAllocBuffer;
 298                         return BenErr_DuplicateName;
 299                     }
 300
 301                     pCBenObject pPrevObject = static_cast<pCBenObject>( cpContainer->
 302                       GetObjects().GetLast());
 303
 304                     if (PropertyID == BEN_PROPID_GLOBAL_PROPERTY_NAME)
 305                         pObject = new CBenPropertyName(cpContainer, ObjectID,
 306                           pPrevObject, sName, pPrevNamedObjectListElmt);
 307                     else pObject = new CBenTypeName(cpContainer, ObjectID,
 308                       pPrevObject, sName, pPrevNamedObjectListElmt);
 309
 310                     delete[] sAllocBuffer;
 311                 }
 312                 else if (PropertyID == BEN_PROPID_OBJ_REFERENCES)
 313                 {
 314                     // Don't need to read in references object--we assume
 315                     // that all references use object ID as key
 316                     if ((Err = ReadSegments(nullptr, &LookAhead)) != BenErr_OK)
 317                         return Err;
 318                 }
 319                 else if (ObjectID == BEN_OBJID_TOC)
 320                 {
 321                     if (PropertyID == BEN_PROPID_TOC_SEED)
 322                     {
 323                         if (TypeID != BEN_TYPEID_TOC_TYPE ||
 324                           LookAhead !=  BEN_IMMEDIATE4)
 325                             return BenErr_TOCSeedError;
 326
 327                         BenDWord Data;
 328                         if ((Err = GetDWord(&Data)) != BenErr_OK)
 329                             return Err;
 330                         LookAhead = GetCode();
 331
 332                         cpContainer->SetNextAvailObjectID(Data);
 333                     }
 334                     else
 335                     {
 336                         // Ignore the other BEN_OBJID_TOC properties
 337                         if ((Err = ReadSegments(nullptr, &LookAhead)) != BenErr_OK)
 338                             return Err;
 339                     }
 340                 }
 341                 else
 342                 {
 343                     if (pProperty != nullptr)
 344                         return BenErr_PropertyWithMoreThanOneValue;
 345
 346                     if (pObject == nullptr)
 347                         pObject = new CBenObject(cpContainer, ObjectID,
 348                           cpContainer->GetObjects().GetLast());
 349
 350                     pProperty = new CBenProperty(pObject, PropertyID, TypeID,
 351                       pObject->GetProperties().GetLast());
 352
 353                     if ((Err = ReadSegments(&pProperty->UseValue(),
 354                       &LookAhead)) != BenErr_OK)
 355                         return Err;
 356                 }
 357             } while (LookAhead == BEN_NEW_TYPE);
 358         } while (LookAhead == BEN_NEW_PROPERTY);
 359     }
 360
 361     if (LookAhead == BEN_READ_PAST_END_OF_TOC)
 362         return BenErr_OK;
 363     else return BenErr_InvalidTOC;
 364 }
 365
 366 BenError
 367 CBenTOCReader::ReadSegments(pCBenValue pValue, BenByte * pLookAhead)
 368 {
 369     BenError Err;
 370
 371     while (*pLookAhead >= BEN_SEGMENT_CODE_START &&
 372       *pLookAhead <= BEN_SEGMENT_CODE_END)
 373     {
 374         if ((Err = ReadSegment(pValue, pLookAhead)) !=
 375           BenErr_OK)
 376             return Err;
 377     }
 378
 379     return BenErr_OK;
 380 }
 381
 382 BenError
 383 CBenTOCReader::ReadSegment(pCBenValue pValue, BenByte * pLookAhead)
 384 {
 385     BenError Err;
 386
 387     bool Immediate = false;
 388     bool EightByteOffset = false;
 389     unsigned long Offset(0), Length(0);
 390
 391     switch (*pLookAhead)
 392     {
 393         case BEN_CONT_OFFSET4_LEN4:
 394         case BEN_OFFSET4_LEN4:
 395             if ((Err = GetDWord(&Offset))  != BenErr_OK)
 396                 return Err;
 397             if ((Err = GetDWord(&Length))  != BenErr_OK)
 398                 return Err;
 399             break;
 400
 401         case BEN_IMMEDIATE0:
 402             Length = 0; Immediate = true;
 403             break;
 404
 405         case BEN_IMMEDIATE1:
 406             Length = 1; Immediate = true;
 407             break;
 408
 409         case BEN_IMMEDIATE2:
 410             Length = 2; Immediate = true;
 411             break;
 412
 413         case BEN_IMMEDIATE3:
 414             Length = 3; Immediate = true;
 415             break;
 416
 417         case BEN_CONT_IMMEDIATE4:
 418         case BEN_IMMEDIATE4:
 419             Length = 4; Immediate = true;
 420             break;
 421
 422         case BEN_CONT_OFFSET8_LEN4:
 423         case BEN_OFFSET8_LEN4:
 424             EightByteOffset = true;
 425             break;
 426
 427         default:
 428             return BenErr_OK;
 429     }
 430
 431     BenByte ImmData[4];
 432     if (Immediate && Length != 0)
 433         if ((Err = GetData(ImmData, 4)) != BenErr_OK)
 434             return Err;
 435
 436     *pLookAhead = GetCode();
 437
 438     if (EightByteOffset)
 439         return BenErr_64BitOffsetNotSupported;
 440
 441     if (pValue != nullptr)
 442     {
 443         if (! Immediate)
 444             new CBenValueSegment(pValue, Offset, Length);
 445         else if (Length != 0)
 446         {
 447             assert(Length <= 4);
 448             new CBenValueSegment(pValue, ImmData, (unsigned short) Length);
 449         }
 450     }
 451
 452     return BenErr_OK;
 453 }
 454
 455 bool
 456 CBenTOCReader::CanGetData(unsigned long Amt)
 457 {
 458     return cCurr + Amt <= cTOCSize;
 459 }
 460
 461 BenError
 462 CBenTOCReader::GetByte(BenByte * pByte)
 463 {
 464     if (! CanGetData(1))
 465         return BenErr_ReadPastEndOfTOC;
 466
 467     *pByte = UtGetIntelByte(cpTOC.get() + cCurr);
 468     ++cCurr;
 469     return BenErr_OK;
 470 }
 471
 472 BenError
 473 CBenTOCReader::GetDWord(BenDWord * pDWord)
 474 {
 475     if (! CanGetData(4))
 476         return BenErr_ReadPastEndOfTOC;
 477
 478     *pDWord = UtGetIntelDWord(cpTOC.get() + cCurr);
 479     cCurr += 4;
 480     return BenErr_OK;
 481 }
 482
 483 BenByte
 484 CBenTOCReader::GetCode()
 485 {
 486     BenByte Code;
 487     do
 488     {
 489         if (GetByte(&Code) != BenErr_OK)
 490             return BEN_READ_PAST_END_OF_TOC;
 491
 492         if (Code == BEN_END_OF_BUFFER)
 493             // Advance to next block
 494             cCurr = cBlockSize * ((cCurr + (cBlockSize - 1)) /
 495               cBlockSize);
 496     }
 497     while (Code == BEN_NOOP || Code == BEN_END_OF_BUFFER);
 498     return Code;
 499 }
 500
 501 BenError
 502 CBenTOCReader::GetData(void * pBuffer, unsigned long Amt)
 503 {
 504     if (! CanGetData(Amt))
 505         return BenErr_ReadPastEndOfTOC;
 506
 507     UtHugeMemcpy(pBuffer, cpTOC.get() + cCurr, Amt);
 508     cCurr += Amt;
 509     return BenErr_OK;
 510 }
 511 }//end OpenStormBento namespace
 512
 513 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */