sys/src/cmd/aux/antiword/wordole.c

   1 /*
   2  * wordole.c
   3  * Copyright (C) 1998-2004 A.J. van Os; Released under GPL
   4  *
   5  * Description:
   6  * Deal with the OLE internals of a MS Word file
   7  */
   8
   9 #include <string.h>
  10 #include "antiword.h"
  11
  12 /* Private type for Property Set Storage entries */
  13 typedef struct pps_entry_tag {
  14         ULONG   ulNext;
  15         ULONG   ulPrevious;
  16         ULONG   ulDir;
  17         ULONG   ulSB;
  18         ULONG   ulSize;
  19         int     iLevel;
  20         char    szName[32];
  21         UCHAR   ucType;
  22 } pps_entry_type;
  23
  24 /* Show that a PPS number or index should not be used */
  25 #define PPS_NUMBER_INVALID      0xffffffffUL
  26
  27
  28 /* Macro to make sure all such statements will be identical */
  29 #define FREE_ALL()              \
  30         do {\
  31                 vDestroySmallBlockList();\
  32                 aulRootList = xfree(aulRootList);\
  33                 aulSbdList = xfree(aulSbdList);\
  34                 aulBbdList = xfree(aulBbdList);\
  35                 aulSBD = xfree(aulSBD);\
  36                 aulBBD = xfree(aulBBD);\
  37         } while(0)
  38
  39
  40 /*
  41  * ulReadLong - read four bytes from the given file and offset
  42  */
  43 static ULONG
  44 ulReadLong(FILE *pFile, ULONG ulOffset)
  45 {
  46         UCHAR   aucBytes[4];
  47
  48         fail(pFile == NULL);
  49
  50         if (!bReadBytes(aucBytes, 4, ulOffset, pFile)) {
  51                 werr(1, "Read long 0x%lx not possible", ulOffset);
  52         }
  53         return ulGetLong(0, aucBytes);
  54 } /* end of ulReadLong */
  55
  56 /*
  57  * vName2String - turn the name into a proper string.
  58  */
  59 static void
  60 vName2String(char *szName, const UCHAR *aucBytes, size_t tNameSize)
  61 {
  62         char    *pcChar;
  63         size_t  tIndex;
  64
  65         fail(aucBytes == NULL || szName == NULL);
  66
  67         if (tNameSize < 2) {
  68                 szName[0] = '\0';
  69                 return;
  70         }
  71         for (tIndex = 0, pcChar = szName;
  72              tIndex < 2 * tNameSize;
  73              tIndex += 2, pcChar++) {
  74                 *pcChar = (char)aucBytes[tIndex];
  75         }
  76         szName[tNameSize - 1] = '\0';
  77 } /* end of vName2String */
  78
  79 /*
  80  * tReadBlockIndices - read the Big/Small Block Depot indices
  81  *
  82  * Returns the number of indices read
  83  */
  84 static size_t
  85 tReadBlockIndices(FILE *pFile, ULONG *aulBlockDepot,
  86         size_t tMaxRec, ULONG ulOffset)
  87 {
  88         size_t  tDone;
  89         int     iIndex;
  90         UCHAR   aucBytes[BIG_BLOCK_SIZE];
  91
  92         fail(pFile == NULL || aulBlockDepot == NULL);
  93         fail(tMaxRec == 0);
  94
  95         /* Read a big block with BBD or SBD indices */
  96         if (!bReadBytes(aucBytes, BIG_BLOCK_SIZE, ulOffset, pFile)) {
  97                 werr(0, "Reading big block from 0x%lx is not possible",
  98                         ulOffset);
  99                 return 0;
 100         }
 101         /* Split the big block into indices, an index is four bytes */
 102         tDone = min(tMaxRec, (size_t)BIG_BLOCK_SIZE / 4);
 103         for (iIndex = 0; iIndex < (int)tDone; iIndex++) {
 104                 aulBlockDepot[iIndex] = ulGetLong(4 * iIndex, aucBytes);
 105                 NO_DBG_DEC(aulBlockDepot[iIndex]);
 106         }
 107         return tDone;
 108 } /* end of tReadBlockIndices */
 109
 110 /*
 111  * bGetBBD - get the Big Block Depot indices from the index-blocks
 112  */
 113 static BOOL
 114 bGetBBD(FILE *pFile, const ULONG *aulDepot, size_t tDepotLen,
 115         ULONG *aulBBD, size_t tBBDLen)
 116 {
 117         ULONG   ulBegin;
 118         size_t  tToGo, tDone;
 119         int     iIndex;
 120
 121         fail(pFile == NULL || aulDepot == NULL || aulBBD == NULL);
 122
 123         DBG_MSG("bGetBBD");
 124
 125         tToGo = tBBDLen;
 126         for (iIndex = 0; iIndex < (int)tDepotLen && tToGo != 0; iIndex++) {
 127                 ulBegin = (aulDepot[iIndex] + 1) * BIG_BLOCK_SIZE;
 128                 NO_DBG_HEX(ulBegin);
 129                 tDone = tReadBlockIndices(pFile, aulBBD, tToGo, ulBegin);
 130                 fail(tDone > tToGo);
 131                 if (tDone == 0) {
 132                         return FALSE;
 133                 }
 134                 aulBBD += tDone;
 135                 tToGo -= tDone;
 136         }
 137         return tToGo == 0;
 138 } /* end of bGetBBD */
 139
 140 /*
 141  * bGetSBD - get the Small Block Depot indices from the index-blocks
 142  */
 143 static BOOL
 144 bGetSBD(FILE *pFile, const ULONG *aulDepot, size_t tDepotLen,
 145         ULONG *aulSBD, size_t tSBDLen)
 146 {
 147         ULONG   ulBegin;
 148         size_t  tToGo, tDone;
 149         int     iIndex;
 150
 151         fail(pFile == NULL || aulDepot == NULL || aulSBD == NULL);
 152
 153         DBG_MSG("bGetSBD");
 154
 155         tToGo = tSBDLen;
 156         for (iIndex = 0; iIndex < (int)tDepotLen && tToGo != 0; iIndex++) {
 157                 fail(aulDepot[iIndex] >= ULONG_MAX / BIG_BLOCK_SIZE);
 158                 ulBegin = (aulDepot[iIndex] + 1) * BIG_BLOCK_SIZE;
 159                 NO_DBG_HEX(ulBegin);
 160                 tDone = tReadBlockIndices(pFile, aulSBD, tToGo, ulBegin);
 161                 fail(tDone > tToGo);
 162                 if (tDone == 0) {
 163                         return FALSE;
 164                 }
 165                 aulSBD += tDone;
 166                 tToGo -= tDone;
 167         }
 168         return tToGo == 0;
 169 } /* end of bGetSBD */
 170
 171 /*
 172  * vComputePPSlevels - compute the levels of the Property Set Storage entries
 173  */
 174 static void
 175 vComputePPSlevels(pps_entry_type *atPPSlist, pps_entry_type *pNode,
 176                         int iLevel, int iRecursionLevel)
 177 {
 178         fail(atPPSlist == NULL || pNode == NULL);
 179         fail(iLevel < 0 || iRecursionLevel < 0);
 180
 181         if (iRecursionLevel > 25) {
 182                 /* This removes the possibility of an infinite recursion */
 183                 DBG_DEC(iRecursionLevel);
 184                 return;
 185         }
 186         if (pNode->iLevel <= iLevel) {
 187                 /* Avoid entering a loop */
 188                 DBG_DEC(iLevel);
 189                 DBG_DEC(pNode->iLevel);
 190                 return;
 191         }
 192
 193         pNode->iLevel = iLevel;
 194
 195         if (pNode->ulDir != PPS_NUMBER_INVALID) {
 196                 vComputePPSlevels(atPPSlist,
 197                                 &atPPSlist[pNode->ulDir],
 198                                 iLevel + 1,
 199                                 iRecursionLevel + 1);
 200         }
 201         if (pNode->ulNext != PPS_NUMBER_INVALID) {
 202                 vComputePPSlevels(atPPSlist,
 203                                 &atPPSlist[pNode->ulNext],
 204                                 iLevel,
 205                                 iRecursionLevel + 1);
 206         }
 207         if (pNode->ulPrevious != PPS_NUMBER_INVALID) {
 208                 vComputePPSlevels(atPPSlist,
 209                                 &atPPSlist[pNode->ulPrevious],
 210                                 iLevel,
 211                                 iRecursionLevel + 1);
 212         }
 213 } /* end of vComputePPSlevels */
 214
 215 /*
 216  * bGetPPS - search the Property Set Storage for three sets
 217  *
 218  * Return TRUE if the WordDocument PPS is found
 219  */
 220 static BOOL
 221 bGetPPS(FILE *pFile,
 222         const ULONG *aulRootList, size_t tRootListLen, pps_info_type *pPPS)
 223 {
 224         pps_entry_type  *atPPSlist;
 225         ULONG   ulBegin, ulOffset, ulTmp;
 226         size_t  tNbrOfPPS, tNameSize;
 227         int     iIndex, iStartBlock, iRootIndex;
 228         BOOL    bWord, bExcel;
 229         UCHAR   aucBytes[PROPERTY_SET_STORAGE_SIZE];
 230
 231         fail(pFile == NULL || aulRootList == NULL || pPPS == NULL);
 232
 233         DBG_MSG("bGetPPS");
 234
 235         NO_DBG_DEC(tRootListLen);
 236
 237         bWord = FALSE;
 238         bExcel = FALSE;
 239         (void)memset(pPPS, 0, sizeof(*pPPS));
 240
 241         /* Read and store all the Property Set Storage entries */
 242
 243         tNbrOfPPS = tRootListLen * BIG_BLOCK_SIZE / PROPERTY_SET_STORAGE_SIZE;
 244         atPPSlist = xcalloc(tNbrOfPPS, sizeof(pps_entry_type));
 245         iRootIndex = 0;
 246
 247         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
 248                 ulTmp = (ULONG)iIndex * PROPERTY_SET_STORAGE_SIZE;
 249                 iStartBlock = (int)(ulTmp / BIG_BLOCK_SIZE);
 250                 ulOffset = ulTmp % BIG_BLOCK_SIZE;
 251                 ulBegin = (aulRootList[iStartBlock] + 1) * BIG_BLOCK_SIZE +
 252                                 ulOffset;
 253                 NO_DBG_HEX(ulBegin);
 254                 if (!bReadBytes(aucBytes, PROPERTY_SET_STORAGE_SIZE,
 255                                                         ulBegin, pFile)) {
 256                         werr(0, "Reading PPS %d is not possible", iIndex);
 257                         atPPSlist = xfree(atPPSlist);
 258                         return FALSE;
 259                 }
 260                 tNameSize = (size_t)usGetWord(0x40, aucBytes);
 261                 tNameSize = (tNameSize + 1) / 2;
 262                 vName2String(atPPSlist[iIndex].szName, aucBytes, tNameSize);
 263                 atPPSlist[iIndex].ucType = ucGetByte(0x42, aucBytes);
 264                 if (atPPSlist[iIndex].ucType == 5) {
 265                         iRootIndex = iIndex;
 266                 }
 267                 atPPSlist[iIndex].ulPrevious = ulGetLong(0x44, aucBytes);
 268                 atPPSlist[iIndex].ulNext = ulGetLong(0x48, aucBytes);
 269                 atPPSlist[iIndex].ulDir = ulGetLong(0x4c, aucBytes);
 270                 atPPSlist[iIndex].ulSB = ulGetLong(0x74, aucBytes);
 271                 atPPSlist[iIndex].ulSize = ulGetLong(0x78, aucBytes);
 272                 atPPSlist[iIndex].iLevel = INT_MAX;
 273                 if ((atPPSlist[iIndex].ulPrevious >= (ULONG)tNbrOfPPS &&
 274                      atPPSlist[iIndex].ulPrevious != PPS_NUMBER_INVALID) ||
 275                     (atPPSlist[iIndex].ulNext >= (ULONG)tNbrOfPPS &&
 276                      atPPSlist[iIndex].ulNext != PPS_NUMBER_INVALID) ||
 277                     (atPPSlist[iIndex].ulDir >= (ULONG)tNbrOfPPS &&
 278                      atPPSlist[iIndex].ulDir != PPS_NUMBER_INVALID)) {
 279                         DBG_DEC(iIndex);
 280                         DBG_DEC(atPPSlist[iIndex].ulPrevious);
 281                         DBG_DEC(atPPSlist[iIndex].ulNext);
 282                         DBG_DEC(atPPSlist[iIndex].ulDir);
 283                         DBG_DEC(tNbrOfPPS);
 284                         werr(0, "The Property Set Storage is damaged");
 285                         atPPSlist = xfree(atPPSlist);
 286                         return FALSE;
 287                 }
 288         }
 289
 290 #if 0 /* defined(DEBUG) */
 291         DBG_MSG("Before");
 292         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
 293                 DBG_MSG(atPPSlist[iIndex].szName);
 294                 DBG_HEX(atPPSlist[iIndex].ulDir);
 295                 DBG_HEX(atPPSlist[iIndex].ulPrevious);
 296                 DBG_HEX(atPPSlist[iIndex].ulNext);
 297                 DBG_DEC(atPPSlist[iIndex].ulSB);
 298                 DBG_HEX(atPPSlist[iIndex].ulSize);
 299                 DBG_DEC(atPPSlist[iIndex].iLevel);
 300         }
 301 #endif /* DEBUG */
 302
 303         /* Add level information to each entry */
 304         vComputePPSlevels(atPPSlist, &atPPSlist[iRootIndex], 0, 0);
 305
 306         /* Check the entries on level 1 for the required information */
 307         NO_DBG_MSG("After");
 308         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
 309 #if 0 /* defined(DEBUG) */
 310                 DBG_MSG(atPPSlist[iIndex].szName);
 311                 DBG_HEX(atPPSlist[iIndex].ulDir);
 312                 DBG_HEX(atPPSlist[iIndex].ulPrevious);
 313                 DBG_HEX(atPPSlist[iIndex].ulNext);
 314                 DBG_DEC(atPPSlist[iIndex].ulSB);
 315                 DBG_HEX(atPPSlist[iIndex].ulSize);
 316                 DBG_DEC(atPPSlist[iIndex].iLevel);
 317 #endif /* DEBUG */
 318                 if (atPPSlist[iIndex].iLevel != 1 ||
 319                     atPPSlist[iIndex].ucType != 2 ||
 320                     atPPSlist[iIndex].szName[0] == '\0' ||
 321                     atPPSlist[iIndex].ulSize == 0) {
 322                         /* This entry can be ignored */
 323                         continue;
 324                 }
 325                 if (pPPS->tWordDocument.ulSize == 0 &&
 326                     STREQ(atPPSlist[iIndex].szName, "WordDocument")) {
 327                         pPPS->tWordDocument.ulSB = atPPSlist[iIndex].ulSB;
 328                         pPPS->tWordDocument.ulSize = atPPSlist[iIndex].ulSize;
 329                         bWord = TRUE;
 330                 } else if (pPPS->tData.ulSize == 0 &&
 331                            STREQ(atPPSlist[iIndex].szName, "Data")) {
 332                         pPPS->tData.ulSB = atPPSlist[iIndex].ulSB;
 333                         pPPS->tData.ulSize = atPPSlist[iIndex].ulSize;
 334                 } else if (pPPS->t0Table.ulSize == 0 &&
 335                            STREQ(atPPSlist[iIndex].szName, "0Table")) {
 336                         pPPS->t0Table.ulSB = atPPSlist[iIndex].ulSB;
 337                         pPPS->t0Table.ulSize = atPPSlist[iIndex].ulSize;
 338                 } else if (pPPS->t1Table.ulSize == 0 &&
 339                            STREQ(atPPSlist[iIndex].szName, "1Table")) {
 340                         pPPS->t1Table.ulSB = atPPSlist[iIndex].ulSB;
 341                         pPPS->t1Table.ulSize = atPPSlist[iIndex].ulSize;
 342                 } else if (pPPS->tSummaryInfo.ulSize == 0 &&
 343                            STREQ(atPPSlist[iIndex].szName,
 344                                                 "\005SummaryInformation")) {
 345                         pPPS->tSummaryInfo.ulSB = atPPSlist[iIndex].ulSB;
 346                         pPPS->tSummaryInfo.ulSize = atPPSlist[iIndex].ulSize;
 347                 } else if (pPPS->tDocSummaryInfo.ulSize == 0 &&
 348                            STREQ(atPPSlist[iIndex].szName,
 349                                         "\005DocumentSummaryInformation")) {
 350                         pPPS->tDocSummaryInfo.ulSB = atPPSlist[iIndex].ulSB;
 351                         pPPS->tDocSummaryInfo.ulSize = atPPSlist[iIndex].ulSize;
 352                 } else if (STREQ(atPPSlist[iIndex].szName, "Book") ||
 353                            STREQ(atPPSlist[iIndex].szName, "Workbook")) {
 354                         bExcel = TRUE;
 355                 }
 356         }
 357
 358         /* Free the space for the Property Set Storage entries */
 359         atPPSlist = xfree(atPPSlist);
 360
 361         /* Draw your conclusions */
 362         if (bWord) {
 363                 return TRUE;
 364         }
 365
 366         if (bExcel) {
 367                 werr(0, "Sorry, but this is an Excel spreadsheet");
 368         } else {
 369                 werr(0, "This OLE file does not contain a Word document");
 370         }
 371         return FALSE;
 372 } /* end of bGetPPS */
 373
 374 /*
 375  * vGetBbdList - make a list of the places to find big blocks
 376  */
 377 static void
 378 vGetBbdList(FILE *pFile, int iNbr, ULONG *aulBbdList, ULONG ulOffset)
 379 {
 380         int     iIndex;
 381
 382         fail(pFile == NULL);
 383         fail(iNbr > 127);
 384         fail(aulBbdList == NULL);
 385
 386         NO_DBG_DEC(iNbr);
 387         for (iIndex = 0; iIndex < iNbr; iIndex++) {
 388                 aulBbdList[iIndex] =
 389                         ulReadLong(pFile, ulOffset + 4 * (ULONG)iIndex);
 390                 NO_DBG_DEC(iIndex);
 391                 NO_DBG_HEX(aulBbdList[iIndex]);
 392         }
 393 } /* end of vGetBbdList */
 394
 395 /*
 396  * bGetDocumentText - make a list of the text blocks of a Word document
 397  *
 398  * Return TRUE when succesful, otherwise FALSE
 399  */
 400 static BOOL
 401 bGetDocumentText(FILE *pFile, const pps_info_type *pPPS,
 402         const ULONG *aulBBD, size_t tBBDLen,
 403         const ULONG *aulSBD, size_t tSBDLen,
 404         const UCHAR *aucHeader, int iWordVersion)
 405 {
 406         ULONG   ulBeginOfText;
 407         ULONG   ulTextLen, ulFootnoteLen, ulEndnoteLen;
 408         ULONG   ulHdrFtrLen, ulMacroLen, ulAnnotationLen;
 409         ULONG   ulTextBoxLen, ulHdrTextBoxLen;
 410         UINT    uiQuickSaves;
 411         BOOL    bFarEastWord, bTemplate, bFastSaved, bEncrypted, bSuccess;
 412         USHORT  usIdent, usDocStatus;
 413
 414         fail(pFile == NULL || pPPS == NULL);
 415         fail(aulBBD == NULL);
 416         fail(aulSBD == NULL);
 417
 418         DBG_MSG("bGetDocumentText");
 419
 420         /* Get the "magic number" from the header */
 421         usIdent = usGetWord(0x00, aucHeader);
 422         DBG_HEX(usIdent);
 423         bFarEastWord = usIdent == 0x8098 || usIdent == 0x8099 ||
 424                         usIdent == 0xa697 || usIdent == 0xa699;
 425         /* Get the status flags from the header */
 426         usDocStatus = usGetWord(0x0a, aucHeader);
 427         DBG_HEX(usDocStatus);
 428         bTemplate = (usDocStatus & BIT(0)) != 0;
 429         DBG_MSG_C(bTemplate, "This document is a Template");
 430         bFastSaved = (usDocStatus & BIT(2)) != 0;
 431         uiQuickSaves = (UINT)(usDocStatus & 0x00f0) >> 4;
 432         DBG_MSG_C(bFastSaved, "This document is Fast Saved");
 433         DBG_DEC_C(bFastSaved, uiQuickSaves);
 434         bEncrypted = (usDocStatus & BIT(8)) != 0;
 435         if (bEncrypted) {
 436                 werr(0, "Encrypted documents are not supported");
 437                 return FALSE;
 438         }
 439
 440         /* Get length information */
 441         ulBeginOfText = ulGetLong(0x18, aucHeader);
 442         DBG_HEX(ulBeginOfText);
 443         switch (iWordVersion) {
 444         case 6:
 445         case 7:
 446                 ulTextLen = ulGetLong(0x34, aucHeader);
 447                 ulFootnoteLen = ulGetLong(0x38, aucHeader);
 448                 ulHdrFtrLen = ulGetLong(0x3c, aucHeader);
 449                 ulMacroLen = ulGetLong(0x40, aucHeader);
 450                 ulAnnotationLen = ulGetLong(0x44, aucHeader);
 451                 ulEndnoteLen = ulGetLong(0x48, aucHeader);
 452                 ulTextBoxLen = ulGetLong(0x4c, aucHeader);
 453                 ulHdrTextBoxLen = ulGetLong(0x50, aucHeader);
 454                 break;
 455         case 8:
 456                 ulTextLen = ulGetLong(0x4c, aucHeader);
 457                 ulFootnoteLen = ulGetLong(0x50, aucHeader);
 458                 ulHdrFtrLen = ulGetLong(0x54, aucHeader);
 459                 ulMacroLen = ulGetLong(0x58, aucHeader);
 460                 ulAnnotationLen = ulGetLong(0x5c, aucHeader);
 461                 ulEndnoteLen = ulGetLong(0x60, aucHeader);
 462                 ulTextBoxLen = ulGetLong(0x64, aucHeader);
 463                 ulHdrTextBoxLen = ulGetLong(0x68, aucHeader);
 464                 break;
 465         default:
 466                 werr(0, "This version of Word is not supported");
 467                 return FALSE;
 468         }
 469         DBG_DEC(ulTextLen);
 470         DBG_DEC(ulFootnoteLen);
 471         DBG_DEC(ulHdrFtrLen);
 472         DBG_DEC(ulMacroLen);
 473         DBG_DEC(ulAnnotationLen);
 474         DBG_DEC(ulEndnoteLen);
 475         DBG_DEC(ulTextBoxLen);
 476         DBG_DEC(ulHdrTextBoxLen);
 477
 478         /* Make a list of the text blocks */
 479         switch (iWordVersion) {
 480         case 6:
 481         case 7:
 482                 if (bFastSaved) {
 483                         bSuccess = bGet6DocumentText(pFile,
 484                                         bFarEastWord,
 485                                         pPPS->tWordDocument.ulSB,
 486                                         aulBBD, tBBDLen,
 487                                         aucHeader);
 488                 } else {
 489                         bSuccess = bAddTextBlocks(ulBeginOfText,
 490                                 ulTextLen +
 491                                 ulFootnoteLen +
 492                                 ulHdrFtrLen +
 493                                 ulMacroLen + ulAnnotationLen +
 494                                 ulEndnoteLen +
 495                                 ulTextBoxLen + ulHdrTextBoxLen,
 496                                 bFarEastWord,
 497                                 IGNORE_PROPMOD,
 498                                 pPPS->tWordDocument.ulSB,
 499                                 aulBBD, tBBDLen);
 500                 }
 501                 break;
 502         case 8:
 503                 bSuccess = bGet8DocumentText(pFile,
 504                                 pPPS,
 505                                 aulBBD, tBBDLen, aulSBD, tSBDLen,
 506                                 aucHeader);
 507                 break;
 508         default:
 509                 werr(0, "This version of Word is not supported");
 510                 bSuccess = FALSE;
 511                 break;
 512         }
 513
 514         if (bSuccess) {
 515                 vSplitBlockList(pFile,
 516                                 ulTextLen,
 517                                 ulFootnoteLen,
 518                                 ulHdrFtrLen,
 519                                 ulMacroLen,
 520                                 ulAnnotationLen,
 521                                 ulEndnoteLen,
 522                                 ulTextBoxLen,
 523                                 ulHdrTextBoxLen,
 524                                 !bFastSaved && iWordVersion == 8);
 525         } else {
 526                 vDestroyTextBlockList();
 527                 werr(0, "I can't find the text of this document");
 528         }
 529         return bSuccess;
 530 } /* end of bGetDocumentText */
 531
 532 /*
 533  * vGetDocumentData - make a list of the data blocks of a Word document
 534  */
 535 static void
 536 vGetDocumentData(FILE *pFile, const pps_info_type *pPPS,
 537         const ULONG *aulBBD, size_t tBBDLen,
 538         const UCHAR *aucHeader, int iWordVersion)
 539 {
 540         options_type    tOptions;
 541         ULONG   ulBeginOfText;
 542         BOOL    bFastSaved, bHasImages, bSuccess;
 543         USHORT  usDocStatus;
 544
 545         fail(pFile == NULL);
 546         fail(pPPS == NULL);
 547         fail(aulBBD == NULL);
 548
 549         /* Get the options */
 550         vGetOptions(&tOptions);
 551
 552         /* Get the status flags from the header */
 553         usDocStatus = usGetWord(0x0a, aucHeader);
 554         DBG_HEX(usDocStatus);
 555         bFastSaved = (usDocStatus & BIT(2)) != 0;
 556         bHasImages = (usDocStatus & BIT(3)) != 0;
 557
 558         if (!bHasImages ||
 559             tOptions.eConversionType == conversion_text ||
 560             tOptions.eConversionType == conversion_fmt_text ||
 561             tOptions.eConversionType == conversion_xml ||
 562             tOptions.eImageLevel == level_no_images) {
 563                 /*
 564                  * No images in the document or text-only output or
 565                  * no images wanted, so no data blocks will be needed
 566                  */
 567                 vDestroyDataBlockList();
 568                 return;
 569         }
 570
 571         /* Get length information */
 572         ulBeginOfText = ulGetLong(0x18, aucHeader);
 573         DBG_HEX(ulBeginOfText);
 574
 575         /* Make a list of the data blocks */
 576         switch (iWordVersion) {
 577         case 6:
 578         case 7:
 579                 /*
 580                  * The data blocks are in the text stream. The text stream
 581                  * is in "fast saved" format or "normal saved" format
 582                  */
 583                 if (bFastSaved) {
 584                         bSuccess = bGet6DocumentData(pFile,
 585                                         pPPS->tWordDocument.ulSB,
 586                                         aulBBD, tBBDLen,
 587                                         aucHeader);
 588                 } else {
 589                         bSuccess = bAddDataBlocks(ulBeginOfText,
 590                                         (ULONG)LONG_MAX,
 591                                         pPPS->tWordDocument.ulSB,
 592                                         aulBBD, tBBDLen);
 593                 }
 594                 break;
 595         case 8:
 596                 /*
 597                  * The data blocks are in the data stream. The data stream
 598                  * is always in "normal saved" format
 599                  */
 600                 bSuccess = bAddDataBlocks(0, (ULONG)LONG_MAX,
 601                                 pPPS->tData.ulSB, aulBBD, tBBDLen);
 602                 break;
 603         default:
 604                 werr(0, "This version of Word is not supported");
 605                 bSuccess = FALSE;
 606                 break;
 607         }
 608
 609         if (!bSuccess) {
 610                 vDestroyDataBlockList();
 611                 werr(0, "I can't find the data of this document");
 612         }
 613 } /* end of vGetDocumentData */
 614
 615 /*
 616  * iInitDocumentOLE - initialize an OLE document
 617  *
 618  * Returns the version of Word that made the document or -1
 619  */
 620 int
 621 iInitDocumentOLE(FILE *pFile, long lFilesize)
 622 {
 623         pps_info_type   PPS_info;
 624         ULONG   *aulBBD, *aulSBD;
 625         ULONG   *aulRootList, *aulBbdList, *aulSbdList;
 626         ULONG   ulBdbListStart, ulAdditionalBBDlist;
 627         ULONG   ulRootStartblock, ulSbdStartblock, ulSBLstartblock;
 628         ULONG   ulStart, ulTmp;
 629         long    lMaxBlock;
 630         size_t  tBBDLen, tSBDLen, tNumBbdBlocks, tRootListLen;
 631         int     iWordVersion, iIndex, iToGo;
 632         BOOL    bSuccess;
 633         USHORT  usIdent, usDocStatus;
 634         UCHAR   aucHeader[HEADER_SIZE];
 635
 636         fail(pFile == NULL);
 637
 638         lMaxBlock = lFilesize / BIG_BLOCK_SIZE - 2;
 639         DBG_DEC(lMaxBlock);
 640         if (lMaxBlock < 1) {
 641                 return -1;
 642         }
 643         tBBDLen = (size_t)(lMaxBlock + 1);
 644         tNumBbdBlocks = (size_t)ulReadLong(pFile, 0x2c);
 645         DBG_DEC(tNumBbdBlocks);
 646         ulRootStartblock = ulReadLong(pFile, 0x30);
 647         DBG_DEC(ulRootStartblock);
 648         ulSbdStartblock = ulReadLong(pFile, 0x3c);
 649         DBG_DEC(ulSbdStartblock);
 650         ulAdditionalBBDlist = ulReadLong(pFile, 0x44);
 651         DBG_HEX(ulAdditionalBBDlist);
 652         ulSBLstartblock = ulReadLong(pFile,
 653                         (ulRootStartblock + 1) * BIG_BLOCK_SIZE + 0x74);
 654         DBG_DEC(ulSBLstartblock);
 655         tSBDLen = (size_t)(ulReadLong(pFile,
 656                         (ulRootStartblock + 1) * BIG_BLOCK_SIZE + 0x78) /
 657                         SMALL_BLOCK_SIZE);
 658         /* All to be xcalloc-ed pointers to NULL */
 659         aulRootList = NULL;
 660         aulSbdList = NULL;
 661         aulBbdList = NULL;
 662         aulSBD = NULL;
 663         aulBBD = NULL;
 664 /* Big Block Depot */
 665         aulBbdList = xcalloc(tNumBbdBlocks, sizeof(ULONG));
 666         aulBBD = xcalloc(tBBDLen, sizeof(ULONG));
 667         iToGo = (int)tNumBbdBlocks;
 668         vGetBbdList(pFile, min(iToGo, 109),  aulBbdList, 0x4c);
 669         ulStart = 109;
 670         iToGo -= 109;
 671         while (ulAdditionalBBDlist != END_OF_CHAIN && iToGo > 0) {
 672                 ulBdbListStart = (ulAdditionalBBDlist + 1) * BIG_BLOCK_SIZE;
 673                 vGetBbdList(pFile, min(iToGo, 127),
 674                                         aulBbdList + ulStart, ulBdbListStart);
 675                 ulAdditionalBBDlist = ulReadLong(pFile,
 676                                         ulBdbListStart + 4 * 127);
 677                 DBG_DEC(ulAdditionalBBDlist);
 678                 DBG_HEX(ulAdditionalBBDlist);
 679                 ulStart += 127;
 680                 iToGo -= 127;
 681         }
 682         if (!bGetBBD(pFile, aulBbdList, tNumBbdBlocks, aulBBD, tBBDLen)) {
 683                 FREE_ALL();
 684                 return -1;
 685         }
 686         aulBbdList = xfree(aulBbdList);
 687 /* Small Block Depot */
 688         aulSbdList = xcalloc(tBBDLen, sizeof(ULONG));
 689         aulSBD = xcalloc(tSBDLen, sizeof(ULONG));
 690         for (iIndex = 0, ulTmp = ulSbdStartblock;
 691              iIndex < (int)tBBDLen && ulTmp != END_OF_CHAIN;
 692              iIndex++, ulTmp = aulBBD[ulTmp]) {
 693                 if (ulTmp >= (ULONG)tBBDLen) {
 694                         DBG_DEC(ulTmp);
 695                         DBG_DEC(tBBDLen);
 696                         werr(1, "The Big Block Depot is damaged");
 697                 }
 698                 aulSbdList[iIndex] = ulTmp;
 699                 NO_DBG_HEX(aulSbdList[iIndex]);
 700         }
 701         if (!bGetSBD(pFile, aulSbdList, tBBDLen, aulSBD, tSBDLen)) {
 702                 FREE_ALL();
 703                 return -1;
 704         }
 705         aulSbdList = xfree(aulSbdList);
 706 /* Root list */
 707         for (tRootListLen = 0, ulTmp = ulRootStartblock;
 708              tRootListLen < tBBDLen && ulTmp != END_OF_CHAIN;
 709              tRootListLen++, ulTmp = aulBBD[ulTmp]) {
 710                 if (ulTmp >= (ULONG)tBBDLen) {
 711                         DBG_DEC(ulTmp);
 712                         DBG_DEC(tBBDLen);
 713                         werr(1, "The Big Block Depot is damaged");
 714                 }
 715         }
 716         if (tRootListLen == 0) {
 717                 werr(0, "No Rootlist found");
 718                 FREE_ALL();
 719                 return -1;
 720         }
 721         aulRootList = xcalloc(tRootListLen, sizeof(ULONG));
 722         for (iIndex = 0, ulTmp = ulRootStartblock;
 723              iIndex < (int)tBBDLen && ulTmp != END_OF_CHAIN;
 724              iIndex++, ulTmp = aulBBD[ulTmp]) {
 725                 if (ulTmp >= (ULONG)tBBDLen) {
 726                         DBG_DEC(ulTmp);
 727                         DBG_DEC(tBBDLen);
 728                         werr(1, "The Big Block Depot is damaged");
 729                 }
 730                 aulRootList[iIndex] = ulTmp;
 731                 NO_DBG_DEC(aulRootList[iIndex]);
 732         }
 733         fail(tRootListLen != (size_t)iIndex);
 734         bSuccess = bGetPPS(pFile, aulRootList, tRootListLen, &PPS_info);
 735         aulRootList = xfree(aulRootList);
 736         if (!bSuccess) {
 737                 FREE_ALL();
 738                 return -1;
 739         }
 740 /* Small block list */
 741         if (!bCreateSmallBlockList(ulSBLstartblock, aulBBD, tBBDLen)) {
 742                 FREE_ALL();
 743                 return -1;
 744         }
 745
 746         if (PPS_info.tWordDocument.ulSize < MIN_SIZE_FOR_BBD_USE) {
 747                 DBG_DEC(PPS_info.tWordDocument.ulSize);
 748                 FREE_ALL();
 749                 werr(0, "I'm afraid the text stream of this file "
 750                         "is too small to handle.");
 751                 return -1;
 752         }
 753         /* Read the headerblock */
 754         if (!bReadBuffer(pFile, PPS_info.tWordDocument.ulSB,
 755                         aulBBD, tBBDLen, BIG_BLOCK_SIZE,
 756                         aucHeader, 0, HEADER_SIZE)) {
 757                 FREE_ALL();
 758                 return -1;
 759         }
 760         usIdent = usGetWord(0x00, aucHeader);
 761         DBG_HEX(usIdent);
 762         fail(usIdent != 0x8098 &&       /* Word 7 for oriental languages */
 763              usIdent != 0x8099 &&       /* Word 7 for oriental languages */
 764              usIdent != 0xa5dc &&       /* Word 6 & 7 */
 765              usIdent != 0xa5ec &&       /* Word 7 & 97 & 98 */
 766              usIdent != 0xa697 &&       /* Word 7 for oriental languages */
 767              usIdent != 0xa699);        /* Word 7 for oriental languages */
 768         iWordVersion = iGetVersionNumber(aucHeader);
 769         if (iWordVersion < 6) {
 770                 FREE_ALL();
 771                 werr(0, "This file is from a version of Word before Word 6.");
 772                 return -1;
 773         }
 774
 775         /* Get the status flags from the header */
 776         usDocStatus = usGetWord(0x0a, aucHeader);
 777         if (usDocStatus & BIT(9)) {
 778                 PPS_info.tTable = PPS_info.t1Table;
 779         } else {
 780                 PPS_info.tTable = PPS_info.t0Table;
 781         }
 782         /* Clean the entries that should not be used */
 783         memset(&PPS_info.t0Table, 0, sizeof(PPS_info.t0Table));
 784         memset(&PPS_info.t1Table, 0, sizeof(PPS_info.t1Table));
 785
 786         bSuccess = bGetDocumentText(pFile, &PPS_info,
 787                         aulBBD, tBBDLen, aulSBD, tSBDLen,
 788                         aucHeader, iWordVersion);
 789         if (bSuccess) {
 790                 vGetDocumentData(pFile, &PPS_info,
 791                         aulBBD, tBBDLen, aucHeader, iWordVersion);
 792                 vGetPropertyInfo(pFile, &PPS_info,
 793                         aulBBD, tBBDLen, aulSBD, tSBDLen,
 794                         aucHeader, iWordVersion);
 795                 vSetDefaultTabWidth(pFile, &PPS_info,
 796                         aulBBD, tBBDLen, aulSBD, tSBDLen,
 797                         aucHeader, iWordVersion);
 798                 vGetNotesInfo(pFile, &PPS_info,
 799                         aulBBD, tBBDLen, aulSBD, tSBDLen,
 800                         aucHeader, iWordVersion);
 801         }
 802         FREE_ALL();
 803         return bSuccess ? iWordVersion : -1;
 804 } /* end of iInitDocumentOLE */