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

00001 /*
+00002  * findtext.c
+00003  * Copyright (C) 1998-2004 A.J. van Os; Released under GNU GPL
+00004  *
+00005  * Description:
+00006  * Find the blocks that contain the text of MS Word files
+00007  */
+00008 
+00009 #include <stdio.h>
+00010 #include <stdlib.h>
+00011 #include "antiword.h"
+00012 
+00013 
+00014 /*
+00015  * bAddTextBlocks - Add the blocks to the text block list
+00016  *
+00017  * Returns TRUE when successful, FALSE if not
+00018  */
+00019 BOOL
+00020 bAddTextBlocks(ULONG ulCharPosFirst, ULONG ulTotalLength,
+00021         BOOL bUsesUnicode, USHORT usPropMod,
+00022         ULONG ulStartBlock, const ULONG *aulBBD, size_t tBBDLen)
+00023 {
+00024         text_block_type tTextBlock;
+00025         ULONG   ulCharPos, ulOffset, ulIndex;
+00026         long    lToGo;
+00027 
+00028         fail(ulTotalLength > (ULONG)LONG_MAX / 2);
+00029         fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
+00030         fail(aulBBD == NULL);
+00031 
+00032         NO_DBG_HEX(ulCharPosFirst);
+00033         NO_DBG_DEC(ulTotalLength);
+00034 
+00035         if (bUsesUnicode) {
+00036                 /* One character equals two bytes */
+00037                 NO_DBG_MSG("Uses Unicode");
+00038                 lToGo = (long)ulTotalLength * 2;
+00039         } else {
+00040                 /* One character equals one byte */
+00041                 NO_DBG_MSG("Uses ASCII");
+00042                 lToGo = (long)ulTotalLength;
+00043         }
+00044 
+00045         ulCharPos = ulCharPosFirst;
+00046         ulOffset = ulCharPosFirst;
+00047         for (ulIndex = ulStartBlock;
+00048              ulIndex != END_OF_CHAIN && lToGo > 0;
+00049              ulIndex = aulBBD[ulIndex]) {
+00050                 if (ulIndex >= (ULONG)tBBDLen) {
+00051                         DBG_DEC(ulIndex);
+00052                         DBG_DEC(tBBDLen);
+00053                         werr(1, "The Big Block Depot is damaged");
+00054                 }
+00055                 if (ulOffset >= BIG_BLOCK_SIZE) {
+00056                         ulOffset -= BIG_BLOCK_SIZE;
+00057                         continue;
+00058                 }
+00059                 tTextBlock.ulFileOffset =
+00060                         (ulIndex + 1) * BIG_BLOCK_SIZE + ulOffset;
+00061                 tTextBlock.ulCharPos = ulCharPos;
+00062                 tTextBlock.ulLength = min(BIG_BLOCK_SIZE - ulOffset,
+00063                                                 (ULONG)lToGo);
+00064                 tTextBlock.bUsesUnicode = bUsesUnicode;
+00065                 tTextBlock.usPropMod = usPropMod;
+00066                 ulOffset = 0;
+00067                 if (!bAdd2TextBlockList(&tTextBlock)) {
+00068                         DBG_HEX(tTextBlock.ulFileOffset);
+00069                         DBG_HEX(tTextBlock.ulCharPos);
+00070                         DBG_DEC(tTextBlock.ulLength);
+00071                         DBG_DEC(tTextBlock.bUsesUnicode);
+00072                         DBG_DEC(tTextBlock.usPropMod);
+00073                         return FALSE;
+00074                 }
+00075                 ulCharPos += tTextBlock.ulLength;
+00076                 lToGo -= (long)tTextBlock.ulLength;
+00077         }
+00078         DBG_DEC_C(lToGo != 0, lToGo);
+00079         return lToGo == 0;
+00080 } /* end of bAddTextBlocks */
+00081 
+00082 /*
+00083  * bGet6DocumentText - make a list of the text blocks of Word 6/7 files
+00084  *
+00085  * Code for "fast saved" files.
+00086  *
+00087  * Returns TRUE when successful, FALSE if not
+00088  */
+00089 BOOL
+00090 bGet6DocumentText(FILE *pFile, BOOL bUsesUnicode, ULONG ulStartBlock,
+00091         const ULONG *aulBBD, size_t tBBDLen, const UCHAR *aucHeader)
+00092 {
+00093         UCHAR   *aucBuffer;
+00094         ULONG   ulBeginTextInfo, ulTextOffset, ulTotLength;
+00095         size_t  tTextInfoLen;
+00096         int     iIndex, iType, iOff, iLen, iPieces;
+00097         USHORT  usPropMod;
+00098 
+00099         DBG_MSG("bGet6DocumentText");
+00100 
+00101         fail(pFile == NULL);
+00102         fail(aulBBD == NULL);
+00103         fail(aucHeader == NULL);
+00104 
+00105         ulBeginTextInfo = ulGetLong(0x160, aucHeader);  /* fcClx */
+00106         DBG_HEX(ulBeginTextInfo);
+00107         tTextInfoLen = (size_t)ulGetLong(0x164, aucHeader);     /* lcbClx */
+00108         DBG_DEC(tTextInfoLen);
+00109 
+00110         aucBuffer = xmalloc(tTextInfoLen);
+00111         if (!bReadBuffer(pFile, ulStartBlock,
+00112                         aulBBD, tBBDLen, BIG_BLOCK_SIZE,
+00113                         aucBuffer, ulBeginTextInfo, tTextInfoLen)) {
+00114                 aucBuffer = xfree(aucBuffer);
+00115                 return FALSE;
+00116         }
+00117         NO_DBG_PRINT_BLOCK(aucBuffer, tTextInfoLen);
+00118 
+00119         iOff = 0;
+00120         while ((size_t)iOff < tTextInfoLen) {
+00121                 iType = (int)ucGetByte(iOff, aucBuffer);
+00122                 iOff++;
+00123                 if (iType == 0) {
+00124                         DBG_FIXME();
+00125                         iOff++;
+00126                         continue;
+00127                 }
+00128                 if (iType == 1) {
+00129                         iLen = (int)usGetWord(iOff, aucBuffer);
+00130                         vAdd2PropModList(aucBuffer + iOff);
+00131                         iOff += iLen + 2;
+00132                         continue;
+00133                 }
+00134                 if (iType != 2) {
+00135                         werr(0, "Unknown type of 'fastsaved' format");
+00136                         aucBuffer = xfree(aucBuffer);
+00137                         return FALSE;
+00138                 }
+00139                 /* Type 2 */
+00140                 iLen = (int)usGetWord(iOff, aucBuffer);
+00141                 NO_DBG_DEC(iLen);
+00142                 iOff += 4;
+00143                 iPieces = (iLen - 4) / 12;
+00144                 DBG_DEC(iPieces);
+00145                 for (iIndex = 0; iIndex < iPieces; iIndex++) {
+00146                         ulTextOffset = ulGetLong(
+00147                                 iOff + (iPieces + 1) * 4 + iIndex * 8 + 2,
+00148                                 aucBuffer);
+00149                         usPropMod = usGetWord(
+00150                                 iOff + (iPieces + 1) * 4 + iIndex * 8 + 6,
+00151                                 aucBuffer);
+00152                         ulTotLength = ulGetLong(iOff + (iIndex + 1) * 4,
+00153                                                 aucBuffer) -
+00154                                         ulGetLong(iOff + iIndex * 4,
+00155                                                 aucBuffer);
+00156                         NO_DBG_HEX_C(usPropMod != 0, usPropMod);
+00157                         if (!bAddTextBlocks(ulTextOffset, ulTotLength,
+00158                                         bUsesUnicode, usPropMod,
+00159                                         ulStartBlock,
+00160                                         aulBBD, tBBDLen)) {
+00161                                 aucBuffer = xfree(aucBuffer);
+00162                                 return FALSE;
+00163                         }
+00164                 }
+00165                 break;
+00166         }
+00167         aucBuffer = xfree(aucBuffer);
+00168         return TRUE;
+00169 } /* end of bGet6DocumentText */
+00170 
+00171 /*
+00172  * bGet8DocumentText - make a list of the text blocks of Word 8/97 files
+00173  *
+00174  * Returns TRUE when successful, FALSE if not
+00175  */
+00176 BOOL
+00177 bGet8DocumentText(FILE *pFile, const pps_info_type *pPPS,
+00178         const ULONG *aulBBD, size_t tBBDLen,
+00179         const ULONG *aulSBD, size_t tSBDLen,
+00180         const UCHAR *aucHeader)
+00181 {
+00182         const ULONG     *aulBlockDepot;
+00183         UCHAR   *aucBuffer;
+00184         ULONG   ulTextOffset, ulBeginTextInfo;
+00185         ULONG   ulTotLength, ulLen;
+00186         long    lIndex, lPieces, lOff;
+00187         size_t  tTextInfoLen, tBlockDepotLen, tBlockSize;
+00188         int     iType, iLen;
+00189         BOOL    bUsesUnicode;
+00190         USHORT  usPropMod;
+00191 
+00192         DBG_MSG("bGet8DocumentText");
+00193 
+00194         fail(pFile == NULL || pPPS == NULL);
+00195         fail(aulBBD == NULL || aulSBD == NULL);
+00196         fail(aucHeader == NULL);
+00197 
+00198         ulBeginTextInfo = ulGetLong(0x1a2, aucHeader);  /* fcClx */
+00199         DBG_HEX(ulBeginTextInfo);
+00200         tTextInfoLen = (size_t)ulGetLong(0x1a6, aucHeader);     /* lcbClx */
+00201         DBG_DEC(tTextInfoLen);
+00202 
+00203         DBG_DEC(pPPS->tTable.ulSB);
+00204         DBG_HEX(pPPS->tTable.ulSize);
+00205         if (pPPS->tTable.ulSize == 0) {
+00206                 return FALSE;
+00207         }
+00208 
+00209         if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
+00210                 /* Use the Small Block Depot */
+00211                 aulBlockDepot = aulSBD;
+00212                 tBlockDepotLen = tSBDLen;
+00213                 tBlockSize = SMALL_BLOCK_SIZE;
+00214         } else {
+00215                 /* Use the Big Block Depot */
+00216                 aulBlockDepot = aulBBD;
+00217                 tBlockDepotLen = tBBDLen;
+00218                 tBlockSize = BIG_BLOCK_SIZE;
+00219         }
+00220         aucBuffer = xmalloc(tTextInfoLen);
+00221         if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
+00222                         aulBlockDepot, tBlockDepotLen, tBlockSize,
+00223                         aucBuffer, ulBeginTextInfo, tTextInfoLen)) {
+00224                 aucBuffer = xfree(aucBuffer);
+00225                 return FALSE;
+00226         }
+00227         NO_DBG_PRINT_BLOCK(aucBuffer, tTextInfoLen);
+00228 
+00229         lOff = 0;
+00230         while (lOff < (long)tTextInfoLen) {
+00231                 iType = (int)ucGetByte(lOff, aucBuffer);
+00232                 lOff++;
+00233                 if (iType == 0) {
+00234                         DBG_FIXME();
+00235                         lOff++;
+00236                         continue;
+00237                 }
+00238                 if (iType == 1) {
+00239                         iLen = (int)usGetWord(lOff, aucBuffer);
+00240                         vAdd2PropModList(aucBuffer + lOff);
+00241                         lOff += (long)iLen + 2;
+00242                         continue;
+00243                 }
+00244                 if (iType != 2) {
+00245                         werr(0, "Unknown type of 'fastsaved' format");
+00246                         aucBuffer = xfree(aucBuffer);
+00247                         return FALSE;
+00248                 }
+00249                 /* Type 2 */
+00250                 ulLen = ulGetLong(lOff, aucBuffer);
+00251                 if (ulLen < 4) {
+00252                         DBG_DEC(ulLen);
+00253                         return FALSE;
+00254                 }
+00255                 lOff += 4;
+00256                 lPieces = (long)((ulLen - 4) / 12);
+00257                 DBG_DEC(lPieces);
+00258                 for (lIndex = 0; lIndex < lPieces; lIndex++) {
+00259                         ulTextOffset = ulGetLong(
+00260                                 lOff + (lPieces + 1) * 4 + lIndex * 8 + 2,
+00261                                 aucBuffer);
+00262                         usPropMod = usGetWord(
+00263                                 lOff + (lPieces + 1) * 4 + lIndex * 8 + 6,
+00264                                 aucBuffer);
+00265                         ulTotLength = ulGetLong(lOff + (lIndex + 1) * 4,
+00266                                                 aucBuffer) -
+00267                                         ulGetLong(lOff + lIndex * 4,
+00268                                                 aucBuffer);
+00269                         if ((ulTextOffset & BIT(30)) == 0) {
+00270                                 bUsesUnicode = TRUE;
+00271                         } else {
+00272                                 bUsesUnicode = FALSE;
+00273                                 ulTextOffset &= ~BIT(30);
+00274                                 ulTextOffset /= 2;
+00275                         }
+00276                         NO_DBG_HEX_C(usPropMod != 0, usPropMod);
+00277                         if (!bAddTextBlocks(ulTextOffset, ulTotLength,
+00278                                         bUsesUnicode, usPropMod,
+00279                                         pPPS->tWordDocument.ulSB,
+00280                                         aulBBD, tBBDLen)) {
+00281                                 aucBuffer = xfree(aucBuffer);
+00282                                 return FALSE;
+00283                         }
+00284                 }
+00285                 break;
+00286         }
+00287         aucBuffer = xfree(aucBuffer);
+00288         return TRUE;
+00289 } /* end of bGet8DocumentText */
+