|
Nokia N97 SDK Example Applications Guide |
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 */
|
© Nokia 2009 |