TB9.2 Example Applications: examples/PIPS/antiword/src/wordole.c Source File

00001 /*
+00002  * wordole.c
+00003  * Copyright (C) 1998-2004 A.J. van Os; Released under GPL
+00004  *
+00005  * Description:
+00006  * Deal with the OLE internals of a MS Word file
+00007  */
+00008 
+00009 #include <string.h>
+00010 #include "antiword.h"
+00011 
+00012 /* Private type for Property Set Storage entries */
+00013 typedef struct pps_entry_tag {
+00014         ULONG   ulNext;
+00015         ULONG   ulPrevious;
+00016         ULONG   ulDir;
+00017         ULONG   ulSB;
+00018         ULONG   ulSize;
+00019         int     iLevel;
+00020         char    szName[32];
+00021         UCHAR   ucType;
+00022 } pps_entry_type;
+00023 
+00024 /* Show that a PPS number or index should not be used */
+00025 #define PPS_NUMBER_INVALID      0xffffffffUL
+00026 
+00027 
+00028 /* Macro to make sure all such statements will be identical */
+00029 #define FREE_ALL()              \
+00030         do {\
+00031                 vDestroySmallBlockList();\
+00032                 aulRootList = xfree(aulRootList);\
+00033                 aulSbdList = xfree(aulSbdList);\
+00034                 aulBbdList = xfree(aulBbdList);\
+00035                 aulSBD = xfree(aulSBD);\
+00036                 aulBBD = xfree(aulBBD);\
+00037         } while(0)
+00038 
+00039 
+00040 /*
+00041  * ulReadLong - read four bytes from the given file and offset
+00042  */
+00043 static ULONG
+00044 ulReadLong(FILE *pFile, ULONG ulOffset)
+00045 {
+00046         UCHAR   aucBytes[4];
+00047 
+00048         fail(pFile == NULL);
+00049 
+00050         if (!bReadBytes(aucBytes, 4, ulOffset, pFile)) {
+00051                 werr(1, "Read long 0x%lx not possible", ulOffset);
+00052         }
+00053         return ulGetLong(0, aucBytes);
+00054 } /* end of ulReadLong */
+00055 
+00056 /*
+00057  * vName2String - turn the name into a proper string.
+00058  */
+00059 static void
+00060 vName2String(char *szName, const UCHAR *aucBytes, size_t tNameSize)
+00061 {
+00062         char    *pcChar;
+00063         size_t  tIndex;
+00064 
+00065         fail(aucBytes == NULL || szName == NULL);
+00066 
+00067         if (tNameSize < 2) {
+00068                 szName[0] = '\0';
+00069                 return;
+00070         }
+00071         for (tIndex = 0, pcChar = szName;
+00072              tIndex < 2 * tNameSize;
+00073              tIndex += 2, pcChar++) {
+00074                 *pcChar = (char)aucBytes[tIndex];
+00075         }
+00076         szName[tNameSize - 1] = '\0';
+00077 } /* end of vName2String */
+00078 
+00079 /*
+00080  * tReadBlockIndices - read the Big/Small Block Depot indices
+00081  *
+00082  * Returns the number of indices read
+00083  */
+00084 static size_t
+00085 tReadBlockIndices(FILE *pFile, ULONG *aulBlockDepot,
+00086         size_t tMaxRec, ULONG ulOffset)
+00087 {
+00088         size_t  tDone;
+00089         int     iIndex;
+00090         UCHAR   aucBytes[BIG_BLOCK_SIZE];
+00091 
+00092         fail(pFile == NULL || aulBlockDepot == NULL);
+00093         fail(tMaxRec == 0);
+00094 
+00095         /* Read a big block with BBD or SBD indices */
+00096         if (!bReadBytes(aucBytes, BIG_BLOCK_SIZE, ulOffset, pFile)) {
+00097                 werr(0, "Reading big block from 0x%lx is not possible",
+00098                         ulOffset);
+00099                 return 0;
+00100         }
+00101         /* Split the big block into indices, an index is four bytes */
+00102         tDone = min(tMaxRec, (size_t)BIG_BLOCK_SIZE / 4);
+00103         for (iIndex = 0; iIndex < (int)tDone; iIndex++) {
+00104                 aulBlockDepot[iIndex] = ulGetLong(4 * iIndex, aucBytes);
+00105                 NO_DBG_DEC(aulBlockDepot[iIndex]);
+00106         }
+00107         return tDone;
+00108 } /* end of tReadBlockIndices */
+00109 
+00110 /*
+00111  * bGetBBD - get the Big Block Depot indices from the index-blocks
+00112  */
+00113 static BOOL
+00114 bGetBBD(FILE *pFile, const ULONG *aulDepot, size_t tDepotLen,
+00115         ULONG *aulBBD, size_t tBBDLen)
+00116 {
+00117         ULONG   ulBegin;
+00118         size_t  tToGo, tDone;
+00119         int     iIndex;
+00120 
+00121         fail(pFile == NULL || aulDepot == NULL || aulBBD == NULL);
+00122 
+00123         DBG_MSG("bGetBBD");
+00124 
+00125         tToGo = tBBDLen;
+00126         for (iIndex = 0; iIndex < (int)tDepotLen && tToGo != 0; iIndex++) {
+00127                 ulBegin = (aulDepot[iIndex] + 1) * BIG_BLOCK_SIZE;
+00128                 NO_DBG_HEX(ulBegin);
+00129                 tDone = tReadBlockIndices(pFile, aulBBD, tToGo, ulBegin);
+00130                 fail(tDone > tToGo);
+00131                 if (tDone == 0) {
+00132                         return FALSE;
+00133                 }
+00134                 aulBBD += tDone;
+00135                 tToGo -= tDone;
+00136         }
+00137         return tToGo == 0;
+00138 } /* end of bGetBBD */
+00139 
+00140 /*
+00141  * bGetSBD - get the Small Block Depot indices from the index-blocks
+00142  */
+00143 static BOOL
+00144 bGetSBD(FILE *pFile, const ULONG *aulDepot, size_t tDepotLen,
+00145         ULONG *aulSBD, size_t tSBDLen)
+00146 {
+00147         ULONG   ulBegin;
+00148         size_t  tToGo, tDone;
+00149         int     iIndex;
+00150 
+00151         fail(pFile == NULL || aulDepot == NULL || aulSBD == NULL);
+00152 
+00153         DBG_MSG("bGetSBD");
+00154 
+00155         tToGo = tSBDLen;
+00156         for (iIndex = 0; iIndex < (int)tDepotLen && tToGo != 0; iIndex++) {
+00157                 fail(aulDepot[iIndex] >= ULONG_MAX / BIG_BLOCK_SIZE);
+00158                 ulBegin = (aulDepot[iIndex] + 1) * BIG_BLOCK_SIZE;
+00159                 NO_DBG_HEX(ulBegin);
+00160                 tDone = tReadBlockIndices(pFile, aulSBD, tToGo, ulBegin);
+00161                 fail(tDone > tToGo);
+00162                 if (tDone == 0) {
+00163                         return FALSE;
+00164                 }
+00165                 aulSBD += tDone;
+00166                 tToGo -= tDone;
+00167         }
+00168         return tToGo == 0;
+00169 } /* end of bGetSBD */
+00170 
+00171 /*
+00172  * vComputePPSlevels - compute the levels of the Property Set Storage entries
+00173  */
+00174 static void
+00175 vComputePPSlevels(pps_entry_type *atPPSlist, pps_entry_type *pNode,
+00176                         int iLevel, int iRecursionLevel)
+00177 {
+00178         fail(atPPSlist == NULL || pNode == NULL);
+00179         fail(iLevel < 0 || iRecursionLevel < 0);
+00180 
+00181         if (iRecursionLevel > 25) {
+00182                 /* This removes the possibility of an infinite recursion */
+00183                 DBG_DEC(iRecursionLevel);
+00184                 return;
+00185         }
+00186         if (pNode->iLevel <= iLevel) {
+00187                 /* Avoid entering a loop */
+00188                 DBG_DEC(iLevel);
+00189                 DBG_DEC(pNode->iLevel);
+00190                 return;
+00191         }
+00192 
+00193         pNode->iLevel = iLevel;
+00194 
+00195         if (pNode->ulDir != PPS_NUMBER_INVALID) {
+00196                 vComputePPSlevels(atPPSlist,
+00197                                 &atPPSlist[pNode->ulDir],
+00198                                 iLevel + 1,
+00199                                 iRecursionLevel + 1);
+00200         }
+00201         if (pNode->ulNext != PPS_NUMBER_INVALID) {
+00202                 vComputePPSlevels(atPPSlist,
+00203                                 &atPPSlist[pNode->ulNext],
+00204                                 iLevel,
+00205                                 iRecursionLevel + 1);
+00206         }
+00207         if (pNode->ulPrevious != PPS_NUMBER_INVALID) {
+00208                 vComputePPSlevels(atPPSlist,
+00209                                 &atPPSlist[pNode->ulPrevious],
+00210                                 iLevel,
+00211                                 iRecursionLevel + 1);
+00212         }
+00213 } /* end of vComputePPSlevels */
+00214 
+00215 /*
+00216  * bGetPPS - search the Property Set Storage for three sets
+00217  *
+00218  * Return TRUE if the WordDocument PPS is found
+00219  */
+00220 static BOOL
+00221 bGetPPS(FILE *pFile,
+00222         const ULONG *aulRootList, size_t tRootListLen, pps_info_type *pPPS)
+00223 {
+00224         pps_entry_type  *atPPSlist;
+00225         ULONG   ulBegin, ulOffset, ulTmp;
+00226         size_t  tNbrOfPPS, tNameSize;
+00227         int     iIndex, iStartBlock, iRootIndex;
+00228         BOOL    bWord, bExcel;
+00229         UCHAR   aucBytes[PROPERTY_SET_STORAGE_SIZE];
+00230 
+00231         fail(pFile == NULL || aulRootList == NULL || pPPS == NULL);
+00232 
+00233         DBG_MSG("bGetPPS");
+00234 
+00235         NO_DBG_DEC(tRootListLen);
+00236 
+00237         bWord = FALSE;
+00238         bExcel = FALSE;
+00239         (void)memset(pPPS, 0, sizeof(*pPPS));
+00240 
+00241         /* Read and store all the Property Set Storage entries */
+00242 
+00243         tNbrOfPPS = tRootListLen * BIG_BLOCK_SIZE / PROPERTY_SET_STORAGE_SIZE;
+00244         atPPSlist = xcalloc(tNbrOfPPS, sizeof(pps_entry_type));
+00245         iRootIndex = 0;
+00246 
+00247         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
+00248                 ulTmp = (ULONG)iIndex * PROPERTY_SET_STORAGE_SIZE;
+00249                 iStartBlock = (int)(ulTmp / BIG_BLOCK_SIZE);
+00250                 ulOffset = ulTmp % BIG_BLOCK_SIZE;
+00251                 ulBegin = (aulRootList[iStartBlock] + 1) * BIG_BLOCK_SIZE +
+00252                                 ulOffset;
+00253                 NO_DBG_HEX(ulBegin);
+00254                 if (!bReadBytes(aucBytes, PROPERTY_SET_STORAGE_SIZE,
+00255                                                         ulBegin, pFile)) {
+00256                         werr(0, "Reading PPS %d is not possible", iIndex);
+00257                         atPPSlist = xfree(atPPSlist);
+00258                         return FALSE;
+00259                 }
+00260                 tNameSize = (size_t)usGetWord(0x40, aucBytes);
+00261                 tNameSize = (tNameSize + 1) / 2;
+00262                 vName2String(atPPSlist[iIndex].szName, aucBytes, tNameSize);
+00263                 atPPSlist[iIndex].ucType = ucGetByte(0x42, aucBytes);
+00264                 if (atPPSlist[iIndex].ucType == 5) {
+00265                         iRootIndex = iIndex;
+00266                 }
+00267                 atPPSlist[iIndex].ulPrevious = ulGetLong(0x44, aucBytes);
+00268                 atPPSlist[iIndex].ulNext = ulGetLong(0x48, aucBytes);
+00269                 atPPSlist[iIndex].ulDir = ulGetLong(0x4c, aucBytes);
+00270                 atPPSlist[iIndex].ulSB = ulGetLong(0x74, aucBytes);
+00271                 atPPSlist[iIndex].ulSize = ulGetLong(0x78, aucBytes);
+00272                 atPPSlist[iIndex].iLevel = INT_MAX;
+00273                 if ((atPPSlist[iIndex].ulPrevious >= (ULONG)tNbrOfPPS &&
+00274                      atPPSlist[iIndex].ulPrevious != PPS_NUMBER_INVALID) ||
+00275                     (atPPSlist[iIndex].ulNext >= (ULONG)tNbrOfPPS &&
+00276                      atPPSlist[iIndex].ulNext != PPS_NUMBER_INVALID) ||
+00277                     (atPPSlist[iIndex].ulDir >= (ULONG)tNbrOfPPS &&
+00278                      atPPSlist[iIndex].ulDir != PPS_NUMBER_INVALID)) {
+00279                         DBG_DEC(iIndex);
+00280                         DBG_DEC(atPPSlist[iIndex].ulPrevious);
+00281                         DBG_DEC(atPPSlist[iIndex].ulNext);
+00282                         DBG_DEC(atPPSlist[iIndex].ulDir);
+00283                         DBG_DEC(tNbrOfPPS);
+00284                         werr(0, "The Property Set Storage is damaged");
+00285                         atPPSlist = xfree(atPPSlist);
+00286                         return FALSE;
+00287                 }
+00288         }
+00289 
+00290 #if 0 /* defined(DEBUG) */
+00291         DBG_MSG("Before");
+00292         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
+00293                 DBG_MSG(atPPSlist[iIndex].szName);
+00294                 DBG_HEX(atPPSlist[iIndex].ulDir);
+00295                 DBG_HEX(atPPSlist[iIndex].ulPrevious);
+00296                 DBG_HEX(atPPSlist[iIndex].ulNext);
+00297                 DBG_DEC(atPPSlist[iIndex].ulSB);
+00298                 DBG_HEX(atPPSlist[iIndex].ulSize);
+00299                 DBG_DEC(atPPSlist[iIndex].iLevel);
+00300         }
+00301 #endif /* DEBUG */
+00302 
+00303         /* Add level information to each entry */
+00304         vComputePPSlevels(atPPSlist, &atPPSlist[iRootIndex], 0, 0);
+00305 
+00306         /* Check the entries on level 1 for the required information */
+00307         NO_DBG_MSG("After");
+00308         for (iIndex = 0; iIndex < (int)tNbrOfPPS; iIndex++) {
+00309 #if 0 /* defined(DEBUG) */
+00310                 DBG_MSG(atPPSlist[iIndex].szName);
+00311                 DBG_HEX(atPPSlist[iIndex].ulDir);
+00312                 DBG_HEX(atPPSlist[iIndex].ulPrevious);
+00313                 DBG_HEX(atPPSlist[iIndex].ulNext);
+00314                 DBG_DEC(atPPSlist[iIndex].ulSB);
+00315                 DBG_HEX(atPPSlist[iIndex].ulSize);
+00316                 DBG_DEC(atPPSlist[iIndex].iLevel);
+00317 #endif /* DEBUG */
+00318                 if (atPPSlist[iIndex].iLevel != 1 ||
+00319                     atPPSlist[iIndex].ucType != 2 ||
+00320                     atPPSlist[iIndex].szName[0] == '\0' ||
+00321                     atPPSlist[iIndex].ulSize == 0) {
+00322                         /* This entry can be ignored */
+00323                         continue;
+00324                 }
+00325                 if (pPPS->tWordDocument.ulSize == 0 &&
+00326                     STREQ(atPPSlist[iIndex].szName, "WordDocument")) {
+00327                         pPPS->tWordDocument.ulSB = atPPSlist[iIndex].ulSB;
+00328                         pPPS->tWordDocument.ulSize = atPPSlist[iIndex].ulSize;
+00329                         bWord = TRUE;
+00330                 } else if (pPPS->tData.ulSize == 0 &&
+00331                            STREQ(atPPSlist[iIndex].szName, "Data")) {
+00332                         pPPS->tData.ulSB = atPPSlist[iIndex].ulSB;
+00333                         pPPS->tData.ulSize = atPPSlist[iIndex].ulSize;
+00334                 } else if (pPPS->t0Table.ulSize == 0 &&
+00335                            STREQ(atPPSlist[iIndex].szName, "0Table")) {
+00336                         pPPS->t0Table.ulSB = atPPSlist[iIndex].ulSB;
+00337                         pPPS->t0Table.ulSize = atPPSlist[iIndex].ulSize;
+00338                 } else if (pPPS->t1Table.ulSize == 0 &&
+00339                            STREQ(atPPSlist[iIndex].szName, "1Table")) {
+00340                         pPPS->t1Table.ulSB = atPPSlist[iIndex].ulSB;
+00341                         pPPS->t1Table.ulSize = atPPSlist[iIndex].ulSize;
+00342                 } else if (pPPS->tSummaryInfo.ulSize == 0 &&
+00343                            STREQ(atPPSlist[iIndex].szName,
+00344                                                 "\005SummaryInformation")) {
+00345                         pPPS->tSummaryInfo.ulSB = atPPSlist[iIndex].ulSB;
+00346                         pPPS->tSummaryInfo.ulSize = atPPSlist[iIndex].ulSize;
+00347                 } else if (pPPS->tDocSummaryInfo.ulSize == 0 &&
+00348                            STREQ(atPPSlist[iIndex].szName,
+00349                                         "\005DocumentSummaryInformation")) {
+00350                         pPPS->tDocSummaryInfo.ulSB = atPPSlist[iIndex].ulSB;
+00351                         pPPS->tDocSummaryInfo.ulSize = atPPSlist[iIndex].ulSize;
+00352                 } else if (STREQ(atPPSlist[iIndex].szName, "Book") ||
+00353                            STREQ(atPPSlist[iIndex].szName, "Workbook")) {
+00354                         bExcel = TRUE;
+00355                 }
+00356         }
+00357 
+00358         /* Free the space for the Property Set Storage entries */
+00359         atPPSlist = xfree(atPPSlist);
+00360 
+00361         /* Draw your conclusions */
+00362         if (bWord) {
+00363                 return TRUE;
+00364         }
+00365 
+00366         if (bExcel) {
+00367                 werr(0, "Sorry, but this is an Excel spreadsheet");
+00368         } else {
+00369                 werr(0, "This OLE file does not contain a Word document");
+00370         }
+00371         return FALSE;
+00372 } /* end of bGetPPS */
+00373 
+00374 /*
+00375  * vGetBbdList - make a list of the places to find big blocks
+00376  */
+00377 static void
+00378 vGetBbdList(FILE *pFile, int iNbr, ULONG *aulBbdList, ULONG ulOffset)
+00379 {
+00380         int     iIndex;
+00381 
+00382         fail(pFile == NULL);
+00383         fail(iNbr > 127);
+00384         fail(aulBbdList == NULL);
+00385 
+00386         NO_DBG_DEC(iNbr);
+00387         for (iIndex = 0; iIndex < iNbr; iIndex++) {
+00388                 aulBbdList[iIndex] =
+00389                         ulReadLong(pFile, ulOffset + 4 * (ULONG)iIndex);
+00390                 NO_DBG_DEC(iIndex);
+00391                 NO_DBG_HEX(aulBbdList[iIndex]);
+00392         }
+00393 } /* end of vGetBbdList */
+00394 
+00395 /*
+00396  * bGetDocumentText - make a list of the text blocks of a Word document
+00397  *
+00398  * Return TRUE when succesful, otherwise FALSE
+00399  */
+00400 static BOOL
+00401 bGetDocumentText(FILE *pFile, const pps_info_type *pPPS,
+00402         const ULONG *aulBBD, size_t tBBDLen,
+00403         const ULONG *aulSBD, size_t tSBDLen,
+00404         const UCHAR *aucHeader, int iWordVersion)
+00405 {
+00406         ULONG   ulBeginOfText;
+00407         ULONG   ulTextLen, ulFootnoteLen, ulEndnoteLen;
+00408         ULONG   ulHdrFtrLen, ulMacroLen, ulAnnotationLen;
+00409         ULONG   ulTextBoxLen, ulHdrTextBoxLen;
+00410         UINT    uiQuickSaves;
+00411         BOOL    bFarEastWord, bTemplate, bFastSaved, bEncrypted, bSuccess;
+00412         USHORT  usIdent, usDocStatus;
+00413 
+00414         fail(pFile == NULL || pPPS == NULL);
+00415         fail(aulBBD == NULL);
+00416         fail(aulSBD == NULL);
+00417 
+00418         DBG_MSG("bGetDocumentText");
+00419 
+00420         /* Get the "magic number" from the header */
+00421         usIdent = usGetWord(0x00, aucHeader);
+00422         DBG_HEX(usIdent);
+00423         bFarEastWord = usIdent == 0x8098 || usIdent == 0x8099 ||
+00424                         usIdent == 0xa697 || usIdent == 0xa699;
+00425         /* Get the status flags from the header */
+00426         usDocStatus = usGetWord(0x0a, aucHeader);
+00427         DBG_HEX(usDocStatus);
+00428         bTemplate = (usDocStatus & BIT(0)) != 0;
+00429         DBG_MSG_C(bTemplate, "This document is a Template");
+00430         bFastSaved = (usDocStatus & BIT(2)) != 0;
+00431         uiQuickSaves = (UINT)(usDocStatus & 0x00f0) >> 4;
+00432         DBG_MSG_C(bFastSaved, "This document is Fast Saved");
+00433         DBG_DEC_C(bFastSaved, uiQuickSaves);
+00434         bEncrypted = (usDocStatus & BIT(8)) != 0;
+00435         if (bEncrypted) {
+00436                 werr(0, "Encrypted documents are not supported");
+00437                 return FALSE;
+00438         }
+00439 
+00440         /* Get length information */
+00441         ulBeginOfText = ulGetLong(0x18, aucHeader);
+00442         DBG_HEX(ulBeginOfText);
+00443         switch (iWordVersion) {
+00444         case 6:
+00445         case 7:
+00446                 ulTextLen = ulGetLong(0x34, aucHeader);
+00447                 ulFootnoteLen = ulGetLong(0x38, aucHeader);
+00448                 ulHdrFtrLen = ulGetLong(0x3c, aucHeader);
+00449                 ulMacroLen = ulGetLong(0x40, aucHeader);
+00450                 ulAnnotationLen = ulGetLong(0x44, aucHeader);
+00451                 ulEndnoteLen = ulGetLong(0x48, aucHeader);
+00452                 ulTextBoxLen = ulGetLong(0x4c, aucHeader);
+00453                 ulHdrTextBoxLen = ulGetLong(0x50, aucHeader);
+00454                 break;
+00455         case 8:
+00456                 ulTextLen = ulGetLong(0x4c, aucHeader);
+00457                 ulFootnoteLen = ulGetLong(0x50, aucHeader);
+00458                 ulHdrFtrLen = ulGetLong(0x54, aucHeader);
+00459                 ulMacroLen = ulGetLong(0x58, aucHeader);
+00460                 ulAnnotationLen = ulGetLong(0x5c, aucHeader);
+00461                 ulEndnoteLen = ulGetLong(0x60, aucHeader);
+00462                 ulTextBoxLen = ulGetLong(0x64, aucHeader);
+00463                 ulHdrTextBoxLen = ulGetLong(0x68, aucHeader);
+00464                 break;
+00465         default:
+00466                 werr(0, "This version of Word is not supported");
+00467                 return FALSE;
+00468         }
+00469         DBG_DEC(ulTextLen);
+00470         DBG_DEC(ulFootnoteLen);
+00471         DBG_DEC(ulHdrFtrLen);
+00472         DBG_DEC(ulMacroLen);
+00473         DBG_DEC(ulAnnotationLen);
+00474         DBG_DEC(ulEndnoteLen);
+00475         DBG_DEC(ulTextBoxLen);
+00476         DBG_DEC(ulHdrTextBoxLen);
+00477 
+00478         /* Make a list of the text blocks */
+00479         switch (iWordVersion) {
+00480         case 6:
+00481         case 7:
+00482                 if (bFastSaved) {
+00483                         bSuccess = bGet6DocumentText(pFile,
+00484                                         bFarEastWord,
+00485                                         pPPS->tWordDocument.ulSB,
+00486                                         aulBBD, tBBDLen,
+00487                                         aucHeader);
+00488                 } else {
+00489                         bSuccess = bAddTextBlocks(ulBeginOfText,
+00490                                 ulTextLen +
+00491                                 ulFootnoteLen +
+00492                                 ulHdrFtrLen +
+00493                                 ulMacroLen + ulAnnotationLen +
+00494                                 ulEndnoteLen +
+00495                                 ulTextBoxLen + ulHdrTextBoxLen,
+00496                                 bFarEastWord,
+00497                                 IGNORE_PROPMOD,
+00498                                 pPPS->tWordDocument.ulSB,
+00499                                 aulBBD, tBBDLen);
+00500                 }
+00501                 break;
+00502         case 8:
+00503                 bSuccess = bGet8DocumentText(pFile,
+00504                                 pPPS,
+00505                                 aulBBD, tBBDLen, aulSBD, tSBDLen,
+00506                                 aucHeader);
+00507                 break;
+00508         default:
+00509                 werr(0, "This version of Word is not supported");
+00510                 bSuccess = FALSE;
+00511                 break;
+00512         }
+00513 
+00514         if (bSuccess) {
+00515                 vSplitBlockList(pFile,
+00516                                 ulTextLen,
+00517                                 ulFootnoteLen,
+00518                                 ulHdrFtrLen,
+00519                                 ulMacroLen,
+00520                                 ulAnnotationLen,
+00521                                 ulEndnoteLen,
+00522                                 ulTextBoxLen,
+00523                                 ulHdrTextBoxLen,
+00524                                 !bFastSaved && iWordVersion == 8);
+00525         } else {
+00526                 vDestroyTextBlockList();
+00527                 werr(0, "I can't find the text of this document");
+00528         }
+00529         return bSuccess;
+00530 } /* end of bGetDocumentText */
+00531 
+00532 /*
+00533  * vGetDocumentData - make a list of the data blocks of a Word document
+00534  */
+00535 static void
+00536 vGetDocumentData(FILE *pFile, const pps_info_type *pPPS,
+00537         const ULONG *aulBBD, size_t tBBDLen,
+00538         const UCHAR *aucHeader, int iWordVersion)
+00539 {
+00540         options_type    tOptions;
+00541         ULONG   ulBeginOfText;
+00542         BOOL    bFastSaved, bHasImages, bSuccess;
+00543         USHORT  usDocStatus;
+00544 
+00545         fail(pFile == NULL);
+00546         fail(pPPS == NULL);
+00547         fail(aulBBD == NULL);
+00548 
+00549         /* Get the options */
+00550         vGetOptions(&tOptions);
+00551 
+00552         /* Get the status flags from the header */
+00553         usDocStatus = usGetWord(0x0a, aucHeader);
+00554         DBG_HEX(usDocStatus);
+00555         bFastSaved = (usDocStatus & BIT(2)) != 0;
+00556         bHasImages = (usDocStatus & BIT(3)) != 0;
+00557 
+00558         if (!bHasImages ||
+00559             tOptions.eConversionType == conversion_text ||
+00560             tOptions.eConversionType == conversion_fmt_text ||
+00561             tOptions.eConversionType == conversion_xml ||
+00562             tOptions.eImageLevel == level_no_images) {
+00563                 /*
+00564                  * No images in the document or text-only output or
+00565                  * no images wanted, so no data blocks will be needed
+00566                  */
+00567                 vDestroyDataBlockList();
+00568                 return;
+00569         }
+00570 
+00571         /* Get length information */
+00572         ulBeginOfText = ulGetLong(0x18, aucHeader);
+00573         DBG_HEX(ulBeginOfText);
+00574 
+00575         /* Make a list of the data blocks */
+00576         switch (iWordVersion) {
+00577         case 6:
+00578         case 7:
+00579                 /*
+00580                  * The data blocks are in the text stream. The text stream
+00581                  * is in "fast saved" format or "normal saved" format
+00582                  */
+00583                 if (bFastSaved) {
+00584                         bSuccess = bGet6DocumentData(pFile,
+00585                                         pPPS->tWordDocument.ulSB,
+00586                                         aulBBD, tBBDLen,
+00587                                         aucHeader);
+00588                 } else {
+00589                         bSuccess = bAddDataBlocks(ulBeginOfText,
+00590                                         (ULONG)LONG_MAX,
+00591                                         pPPS->tWordDocument.ulSB,
+00592                                         aulBBD, tBBDLen);
+00593                 }
+00594                 break;
+00595         case 8:
+00596                 /*
+00597                  * The data blocks are in the data stream. The data stream
+00598                  * is always in "normal saved" format
+00599                  */
+00600                 bSuccess = bAddDataBlocks(0, (ULONG)LONG_MAX,
+00601                                 pPPS->tData.ulSB, aulBBD, tBBDLen);
+00602                 break;
+00603         default:
+00604                 werr(0, "This version of Word is not supported");
+00605                 bSuccess = FALSE;
+00606                 break;
+00607         }
+00608 
+00609         if (!bSuccess) {
+00610                 vDestroyDataBlockList();
+00611                 werr(0, "I can't find the data of this document");
+00612         }
+00613 } /* end of vGetDocumentData */
+00614 
+00615 /*
+00616  * iInitDocumentOLE - initialize an OLE document
+00617  *
+00618  * Returns the version of Word that made the document or -1
+00619  */
+00620 int
+00621 iInitDocumentOLE(FILE *pFile, long lFilesize)
+00622 {
+00623         pps_info_type   PPS_info;
+00624         ULONG   *aulBBD, *aulSBD;
+00625         ULONG   *aulRootList, *aulBbdList, *aulSbdList;
+00626         ULONG   ulBdbListStart, ulAdditionalBBDlist;
+00627         ULONG   ulRootStartblock, ulSbdStartblock, ulSBLstartblock;
+00628         ULONG   ulStart, ulTmp;
+00629         long    lMaxBlock;
+00630         size_t  tBBDLen, tSBDLen, tNumBbdBlocks, tRootListLen;
+00631         int     iWordVersion, iIndex, iToGo;
+00632         BOOL    bSuccess;
+00633         USHORT  usIdent, usDocStatus;
+00634         UCHAR   aucHeader[HEADER_SIZE];
+00635 
+00636         fail(pFile == NULL);
+00637 
+00638         lMaxBlock = lFilesize / BIG_BLOCK_SIZE - 2;
+00639         DBG_DEC(lMaxBlock);
+00640         if (lMaxBlock < 1) {
+00641                 return -1;
+00642         }
+00643         tBBDLen = (size_t)(lMaxBlock + 1);
+00644         tNumBbdBlocks = (size_t)ulReadLong(pFile, 0x2c);
+00645         DBG_DEC(tNumBbdBlocks);
+00646         ulRootStartblock = ulReadLong(pFile, 0x30);
+00647         DBG_DEC(ulRootStartblock);
+00648         ulSbdStartblock = ulReadLong(pFile, 0x3c);
+00649         DBG_DEC(ulSbdStartblock);
+00650         ulAdditionalBBDlist = ulReadLong(pFile, 0x44);
+00651         DBG_HEX(ulAdditionalBBDlist);
+00652         ulSBLstartblock = ulReadLong(pFile,
+00653                         (ulRootStartblock + 1) * BIG_BLOCK_SIZE + 0x74);
+00654         DBG_DEC(ulSBLstartblock);
+00655         tSBDLen = (size_t)(ulReadLong(pFile,
+00656                         (ulRootStartblock + 1) * BIG_BLOCK_SIZE + 0x78) /
+00657                         SMALL_BLOCK_SIZE);
+00658         /* All to be xcalloc-ed pointers to NULL */
+00659         aulRootList = NULL;
+00660         aulSbdList = NULL;
+00661         aulBbdList = NULL;
+00662         aulSBD = NULL;
+00663         aulBBD = NULL;
+00664 /* Big Block Depot */
+00665         aulBbdList = xcalloc(tNumBbdBlocks, sizeof(ULONG));
+00666         aulBBD = xcalloc(tBBDLen, sizeof(ULONG));
+00667         iToGo = (int)tNumBbdBlocks;
+00668         vGetBbdList(pFile, min(iToGo, 109),  aulBbdList, 0x4c);
+00669         ulStart = 109;
+00670         iToGo -= 109;
+00671         while (ulAdditionalBBDlist != END_OF_CHAIN && iToGo > 0) {
+00672                 ulBdbListStart = (ulAdditionalBBDlist + 1) * BIG_BLOCK_SIZE;
+00673                 vGetBbdList(pFile, min(iToGo, 127),
+00674                                         aulBbdList + ulStart, ulBdbListStart);
+00675                 ulAdditionalBBDlist = ulReadLong(pFile,
+00676                                         ulBdbListStart + 4 * 127);
+00677                 DBG_DEC(ulAdditionalBBDlist);
+00678                 DBG_HEX(ulAdditionalBBDlist);
+00679                 ulStart += 127;
+00680                 iToGo -= 127;
+00681         }
+00682         if (!bGetBBD(pFile, aulBbdList, tNumBbdBlocks, aulBBD, tBBDLen)) {
+00683                 FREE_ALL();
+00684                 return -1;
+00685         }
+00686         aulBbdList = xfree(aulBbdList);
+00687 /* Small Block Depot */
+00688         aulSbdList = xcalloc(tBBDLen, sizeof(ULONG));
+00689         aulSBD = xcalloc(tSBDLen, sizeof(ULONG));
+00690         for (iIndex = 0, ulTmp = ulSbdStartblock;
+00691              iIndex < (int)tBBDLen && ulTmp != END_OF_CHAIN;
+00692              iIndex++, ulTmp = aulBBD[ulTmp]) {
+00693                 if (ulTmp >= (ULONG)tBBDLen) {
+00694                         DBG_DEC(ulTmp);
+00695                         DBG_DEC(tBBDLen);
+00696                         werr(1, "The Big Block Depot is damaged");
+00697                 }
+00698                 aulSbdList[iIndex] = ulTmp;
+00699                 NO_DBG_HEX(aulSbdList[iIndex]);
+00700         }
+00701         if (!bGetSBD(pFile, aulSbdList, tBBDLen, aulSBD, tSBDLen)) {
+00702                 FREE_ALL();
+00703                 return -1;
+00704         }
+00705         aulSbdList = xfree(aulSbdList);
+00706 /* Root list */
+00707         for (tRootListLen = 0, ulTmp = ulRootStartblock;
+00708              tRootListLen < tBBDLen && ulTmp != END_OF_CHAIN;
+00709              tRootListLen++, ulTmp = aulBBD[ulTmp]) {
+00710                 if (ulTmp >= (ULONG)tBBDLen) {
+00711                         DBG_DEC(ulTmp);
+00712                         DBG_DEC(tBBDLen);
+00713                         werr(1, "The Big Block Depot is damaged");
+00714                 }
+00715         }
+00716         if (tRootListLen == 0) {
+00717                 werr(0, "No Rootlist found");
+00718                 FREE_ALL();
+00719                 return -1;
+00720         }
+00721         aulRootList = xcalloc(tRootListLen, sizeof(ULONG));
+00722         for (iIndex = 0, ulTmp = ulRootStartblock;
+00723              iIndex < (int)tBBDLen && ulTmp != END_OF_CHAIN;
+00724              iIndex++, ulTmp = aulBBD[ulTmp]) {
+00725                 if (ulTmp >= (ULONG)tBBDLen) {
+00726                         DBG_DEC(ulTmp);
+00727                         DBG_DEC(tBBDLen);
+00728                         werr(1, "The Big Block Depot is damaged");
+00729                 }
+00730                 aulRootList[iIndex] = ulTmp;
+00731                 NO_DBG_DEC(aulRootList[iIndex]);
+00732         }
+00733         fail(tRootListLen != (size_t)iIndex);
+00734         bSuccess = bGetPPS(pFile, aulRootList, tRootListLen, &PPS_info);
+00735         aulRootList = xfree(aulRootList);
+00736         if (!bSuccess) {
+00737                 FREE_ALL();
+00738                 return -1;
+00739         }
+00740 /* Small block list */
+00741         if (!bCreateSmallBlockList(ulSBLstartblock, aulBBD, tBBDLen)) {
+00742                 FREE_ALL();
+00743                 return -1;
+00744         }
+00745 
+00746         if (PPS_info.tWordDocument.ulSize < MIN_SIZE_FOR_BBD_USE) {
+00747                 DBG_DEC(PPS_info.tWordDocument.ulSize);
+00748                 FREE_ALL();
+00749                 werr(0, "I'm afraid the text stream of this file "
+00750                         "is too small to handle.");
+00751                 return -1;
+00752         }
+00753         /* Read the headerblock */
+00754         if (!bReadBuffer(pFile, PPS_info.tWordDocument.ulSB,
+00755                         aulBBD, tBBDLen, BIG_BLOCK_SIZE,
+00756                         aucHeader, 0, HEADER_SIZE)) {
+00757                 FREE_ALL();
+00758                 return -1;
+00759         }
+00760         usIdent = usGetWord(0x00, aucHeader);
+00761         DBG_HEX(usIdent);
+00762         fail(usIdent != 0x8098 &&       /* Word 7 for oriental languages */
+00763              usIdent != 0x8099 &&       /* Word 7 for oriental languages */
+00764              usIdent != 0xa5dc &&       /* Word 6 & 7 */
+00765              usIdent != 0xa5ec &&       /* Word 7 & 97 & 98 */
+00766              usIdent != 0xa697 &&       /* Word 7 for oriental languages */
+00767              usIdent != 0xa699);        /* Word 7 for oriental languages */
+00768         iWordVersion = iGetVersionNumber(aucHeader);
+00769         if (iWordVersion < 6) {
+00770                 FREE_ALL();
+00771                 werr(0, "This file is from a version of Word before Word 6.");
+00772                 return -1;
+00773         }
+00774 
+00775         /* Get the status flags from the header */
+00776         usDocStatus = usGetWord(0x0a, aucHeader);
+00777         if (usDocStatus & BIT(9)) {
+00778                 PPS_info.tTable = PPS_info.t1Table;
+00779         } else {
+00780                 PPS_info.tTable = PPS_info.t0Table;
+00781         }
+00782         /* Clean the entries that should not be used */
+00783         memset(&PPS_info.t0Table, 0, sizeof(PPS_info.t0Table));
+00784         memset(&PPS_info.t1Table, 0, sizeof(PPS_info.t1Table));
+00785 
+00786         bSuccess = bGetDocumentText(pFile, &PPS_info,
+00787                         aulBBD, tBBDLen, aulSBD, tSBDLen,
+00788                         aucHeader, iWordVersion);
+00789         if (bSuccess) {
+00790                 vGetDocumentData(pFile, &PPS_info,
+00791                         aulBBD, tBBDLen, aucHeader, iWordVersion);
+00792                 vGetPropertyInfo(pFile, &PPS_info,
+00793                         aulBBD, tBBDLen, aulSBD, tSBDLen,
+00794                         aucHeader, iWordVersion);
+00795                 vSetDefaultTabWidth(pFile, &PPS_info,
+00796                         aulBBD, tBBDLen, aulSBD, tSBDLen,
+00797                         aucHeader, iWordVersion);
+00798                 vGetNotesInfo(pFile, &PPS_info,
+00799                         aulBBD, tBBDLen, aulSBD, tSBDLen,
+00800                         aucHeader, iWordVersion);
+00801         }
+00802         FREE_ALL();
+00803         return bSuccess ? iWordVersion : -1;
+00804 } /* end of iInitDocumentOLE */
+