1 // Copyright 2014 PDFium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 6 7 #include "../../../include/fpdfapi/fpdf_parser.h" 8 #include "../../../include/fpdfapi/fpdf_module.h" 9 #include "../../../include/fpdfapi/fpdf_page.h" 10 #include "../fpdf_page/pageint.h" 11 #include <limits.h> 12 #define _PARSER_OBJECT_LEVLE_ 64 13 extern const FX_LPCSTR _PDF_CharType; 14 FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict) 15 { 16 CPDF_Object* pType = pDict->GetElementValue(FX_BSTRC("Type")); 17 if (!pType) { 18 pType = pDict->GetElementValue(FX_BSTRC("FT")); 19 if (!pType) { 20 return FALSE; 21 } 22 } 23 if (pType->GetString() == FX_BSTRC("Sig")) { 24 return TRUE; 25 } 26 return FALSE; 27 } 28 static FX_INT32 _CompareDWord(const void* p1, const void* p2) 29 { 30 return (*(FX_DWORD*)p1) - (*(FX_DWORD*)p2); 31 } 32 static int _CompareFileSize(const void* p1, const void* p2) 33 { 34 FX_FILESIZE ret = (*(FX_FILESIZE*)p1) - (*(FX_FILESIZE*)p2); 35 if (ret > 0) { 36 return 1; 37 } 38 if (ret < 0) { 39 return -1; 40 } 41 return 0; 42 } 43 CPDF_Parser::CPDF_Parser() 44 { 45 m_pDocument = NULL; 46 m_pTrailer = NULL; 47 m_pEncryptDict = NULL; 48 m_pSecurityHandler = NULL; 49 m_pLinearized = NULL; 50 m_dwFirstPageNo = 0; 51 m_dwXrefStartObjNum = 0; 52 m_bOwnFileRead = TRUE; 53 m_bForceUseSecurityHandler = FALSE; 54 } 55 CPDF_Parser::~CPDF_Parser() 56 { 57 CloseParser(FALSE); 58 } 59 FX_DWORD CPDF_Parser::GetLastObjNum() 60 { 61 FX_DWORD dwSize = m_CrossRef.GetSize(); 62 return dwSize ? dwSize - 1 : 0; 63 } 64 void CPDF_Parser::SetEncryptDictionary(CPDF_Dictionary* pDict) 65 { 66 m_pEncryptDict = pDict; 67 } 68 void CPDF_Parser::CloseParser(FX_BOOL bReParse) 69 { 70 m_bVersionUpdated = FALSE; 71 if (m_pDocument && !bReParse) { 72 delete m_pDocument; 73 m_pDocument = NULL; 74 } 75 if (m_pTrailer) { 76 m_pTrailer->Release(); 77 m_pTrailer = NULL; 78 } 79 ReleaseEncryptHandler(); 80 SetEncryptDictionary(NULL); 81 if (m_bOwnFileRead && m_Syntax.m_pFileAccess != NULL) { 82 m_Syntax.m_pFileAccess->Release(); 83 m_Syntax.m_pFileAccess = NULL; 84 } 85 FX_POSITION pos = m_ObjectStreamMap.GetStartPosition(); 86 while (pos) { 87 FX_LPVOID objnum; 88 CPDF_StreamAcc* pStream; 89 m_ObjectStreamMap.GetNextAssoc(pos, objnum, (void*&)pStream); 90 delete pStream; 91 } 92 m_ObjectStreamMap.RemoveAll(); 93 m_SortedOffset.RemoveAll(); 94 m_CrossRef.RemoveAll(); 95 m_V5Type.RemoveAll(); 96 m_ObjVersion.RemoveAll(); 97 FX_INT32 iLen = m_Trailers.GetSize(); 98 for (FX_INT32 i = 0; i < iLen; ++i) { 99 m_Trailers.GetAt(i)->Release(); 100 } 101 m_Trailers.RemoveAll(); 102 if (m_pLinearized) { 103 m_pLinearized->Release(); 104 m_pLinearized = NULL; 105 } 106 } 107 static FX_INT32 GetHeaderOffset(IFX_FileRead* pFile) 108 { 109 FX_DWORD tag = FXDWORD_FROM_LSBFIRST(0x46445025); 110 FX_BYTE buf[4]; 111 FX_INT32 offset = 0; 112 while (1) { 113 if (!pFile->ReadBlock(buf, offset, 4)) { 114 return -1; 115 } 116 if (*(FX_DWORD*)buf == tag) { 117 return offset; 118 } 119 offset ++; 120 if (offset > 1024) { 121 return -1; 122 } 123 } 124 return -1; 125 } 126 FX_DWORD CPDF_Parser::StartParse(FX_LPCSTR filename, FX_BOOL bReParse) 127 { 128 IFX_FileRead* pFileAccess = FX_CreateFileRead(filename); 129 if (!pFileAccess) { 130 return PDFPARSE_ERROR_FILE; 131 } 132 return StartParse(pFileAccess, bReParse); 133 } 134 FX_DWORD CPDF_Parser::StartParse(FX_LPCWSTR filename, FX_BOOL bReParse) 135 { 136 IFX_FileRead* pFileAccess = FX_CreateFileRead(filename); 137 if (!pFileAccess) { 138 return PDFPARSE_ERROR_FILE; 139 } 140 return StartParse(pFileAccess, bReParse); 141 } 142 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler(); 143 CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*); 144 FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX_BOOL bOwnFileRead) 145 { 146 CloseParser(bReParse); 147 m_bXRefStream = FALSE; 148 m_LastXRefOffset = 0; 149 m_bOwnFileRead = bOwnFileRead; 150 FX_INT32 offset = GetHeaderOffset(pFileAccess); 151 if (offset == -1) { 152 if (bOwnFileRead && pFileAccess) { 153 pFileAccess->Release(); 154 } 155 return PDFPARSE_ERROR_FORMAT; 156 } 157 m_Syntax.InitParser(pFileAccess, offset); 158 FX_BYTE ch; 159 m_Syntax.GetCharAt(5, ch); 160 m_FileVersion = (ch - '0') * 10; 161 m_Syntax.GetCharAt(7, ch); 162 m_FileVersion += ch - '0'; 163 m_Syntax.RestorePos(m_Syntax.m_FileLen - m_Syntax.m_HeaderOffset - 9); 164 if (!bReParse) { 165 m_pDocument = FX_NEW CPDF_Document(this); 166 } 167 FX_BOOL bXRefRebuilt = FALSE; 168 if (m_Syntax.SearchWord(FX_BSTRC("startxref"), TRUE, FALSE, 4096)) { 169 FX_FILESIZE startxref_offset = m_Syntax.SavePos(); 170 FX_LPVOID pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 171 if (pResult == NULL) { 172 m_SortedOffset.Add(startxref_offset); 173 } 174 m_Syntax.GetKeyword(); 175 FX_BOOL bNumber; 176 CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(bNumber); 177 if (!bNumber) { 178 return PDFPARSE_ERROR_FORMAT; 179 } 180 m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str); 181 if (!LoadAllCrossRefV4(m_LastXRefOffset) && !LoadAllCrossRefV5(m_LastXRefOffset)) { 182 if (!RebuildCrossRef()) { 183 return PDFPARSE_ERROR_FORMAT; 184 } 185 bXRefRebuilt = TRUE; 186 m_LastXRefOffset = 0; 187 } 188 } else { 189 if (!RebuildCrossRef()) { 190 return PDFPARSE_ERROR_FORMAT; 191 } 192 bXRefRebuilt = TRUE; 193 } 194 FX_DWORD dwRet = SetEncryptHandler(); 195 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 196 return dwRet; 197 } 198 m_pDocument->LoadDoc(); 199 if (m_pDocument->GetRoot() == NULL || m_pDocument->GetPageCount() == 0) { 200 if (bXRefRebuilt) { 201 return PDFPARSE_ERROR_FORMAT; 202 } 203 ReleaseEncryptHandler(); 204 if (!RebuildCrossRef()) { 205 return PDFPARSE_ERROR_FORMAT; 206 } 207 dwRet = SetEncryptHandler(); 208 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 209 return dwRet; 210 } 211 m_pDocument->LoadDoc(); 212 if (m_pDocument->GetRoot() == NULL) { 213 return PDFPARSE_ERROR_FORMAT; 214 } 215 } 216 FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 217 FX_DWORD RootObjNum = GetRootObjNum(); 218 if (RootObjNum == 0) { 219 ReleaseEncryptHandler(); 220 RebuildCrossRef(); 221 RootObjNum = GetRootObjNum(); 222 if (RootObjNum == 0) { 223 return PDFPARSE_ERROR_FORMAT; 224 } 225 dwRet = SetEncryptHandler(); 226 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 227 return dwRet; 228 } 229 } 230 if (m_pSecurityHandler && !m_pSecurityHandler->IsMetadataEncrypted()) { 231 CPDF_Reference* pMetadata = (CPDF_Reference*)m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata")); 232 if (pMetadata && pMetadata->GetType() == PDFOBJ_REFERENCE) { 233 m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum(); 234 } 235 } 236 return PDFPARSE_ERROR_SUCCESS; 237 } 238 FX_DWORD CPDF_Parser::SetEncryptHandler() 239 { 240 ReleaseEncryptHandler(); 241 SetEncryptDictionary(NULL); 242 if (m_pTrailer == NULL) { 243 return PDFPARSE_ERROR_FORMAT; 244 } 245 CPDF_Object* pEncryptObj = m_pTrailer->GetElement(FX_BSTRC("Encrypt")); 246 if (pEncryptObj) { 247 if (pEncryptObj->GetType() == PDFOBJ_DICTIONARY) { 248 SetEncryptDictionary((CPDF_Dictionary*)pEncryptObj); 249 } else if (pEncryptObj->GetType() == PDFOBJ_REFERENCE) { 250 pEncryptObj = m_pDocument->GetIndirectObject(((CPDF_Reference*)pEncryptObj)->GetRefObjNum()); 251 if (pEncryptObj) { 252 SetEncryptDictionary(pEncryptObj->GetDict()); 253 } 254 } 255 } 256 if (m_bForceUseSecurityHandler) { 257 FX_DWORD err = PDFPARSE_ERROR_HANDLER; 258 if (m_pSecurityHandler == NULL) { 259 return PDFPARSE_ERROR_HANDLER; 260 } 261 if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) { 262 return err; 263 } 264 CPDF_CryptoHandler* pCryptoHandler = m_pSecurityHandler->CreateCryptoHandler(); 265 if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler)) { 266 delete pCryptoHandler; 267 pCryptoHandler = NULL; 268 return PDFPARSE_ERROR_HANDLER; 269 } 270 m_Syntax.SetEncrypt(pCryptoHandler); 271 } else if (m_pEncryptDict) { 272 CFX_ByteString filter = m_pEncryptDict->GetString(FX_BSTRC("Filter")); 273 CPDF_SecurityHandler* pSecurityHandler = NULL; 274 FX_DWORD err = PDFPARSE_ERROR_HANDLER; 275 if (filter == FX_BSTRC("Standard")) { 276 pSecurityHandler = FPDF_CreateStandardSecurityHandler(); 277 err = PDFPARSE_ERROR_PASSWORD; 278 } 279 if (pSecurityHandler == NULL) { 280 return PDFPARSE_ERROR_HANDLER; 281 } 282 if (!pSecurityHandler->OnInit(this, m_pEncryptDict)) { 283 delete pSecurityHandler; 284 pSecurityHandler = NULL; 285 return err; 286 } 287 m_pSecurityHandler = pSecurityHandler; 288 CPDF_CryptoHandler* pCryptoHandler = pSecurityHandler->CreateCryptoHandler(); 289 if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler)) { 290 delete pCryptoHandler; 291 pCryptoHandler = NULL; 292 return PDFPARSE_ERROR_HANDLER; 293 } 294 m_Syntax.SetEncrypt(pCryptoHandler); 295 } 296 return PDFPARSE_ERROR_SUCCESS; 297 } 298 void CPDF_Parser::ReleaseEncryptHandler() 299 { 300 if (m_Syntax.m_pCryptoHandler) { 301 delete m_Syntax.m_pCryptoHandler; 302 m_Syntax.m_pCryptoHandler = NULL; 303 } 304 if (m_pSecurityHandler && !m_bForceUseSecurityHandler) { 305 delete m_pSecurityHandler; 306 m_pSecurityHandler = NULL; 307 } 308 } 309 FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) 310 { 311 if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) { 312 return 0; 313 } 314 if (m_V5Type[objnum] == 1) { 315 return m_CrossRef[objnum]; 316 } 317 if (m_V5Type[objnum] == 2) { 318 return m_CrossRef[(FX_INT32)m_CrossRef[objnum]]; 319 } 320 return 0; 321 } 322 static FX_INT32 GetDirectInteger(CPDF_Dictionary* pDict, FX_BSTR key) 323 { 324 CPDF_Object* pObj = pDict->GetElement(key); 325 if (pObj == NULL) { 326 return 0; 327 } 328 if (pObj->GetType() == PDFOBJ_NUMBER) { 329 return ((CPDF_Number*)pObj)->GetInteger(); 330 } 331 return 0; 332 } 333 static FX_BOOL CheckDirectType(CPDF_Dictionary* pDict, FX_BSTR key, FX_INT32 iType) 334 { 335 CPDF_Object* pObj = pDict->GetElement(key); 336 if (!pObj) { 337 return TRUE; 338 } 339 return pObj->GetType() == iType; 340 } 341 FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) 342 { 343 if (!LoadCrossRefV4(xrefpos, 0, TRUE, FALSE)) { 344 return FALSE; 345 } 346 m_pTrailer = LoadTrailerV4(); 347 if (m_pTrailer == NULL) { 348 return FALSE; 349 } 350 FX_INT32 xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size")); 351 if (xrefsize <= 0 || xrefsize > (1 << 20)) { 352 return FALSE; 353 } 354 m_CrossRef.SetSize(xrefsize); 355 m_V5Type.SetSize(xrefsize); 356 CFX_FileSizeArray CrossRefList, XRefStreamList; 357 CrossRefList.Add(xrefpos); 358 XRefStreamList.Add(GetDirectInteger(m_pTrailer, FX_BSTRC("XRefStm"))); 359 if (!CheckDirectType(m_pTrailer, FX_BSTRC("Prev"), PDFOBJ_NUMBER)) { 360 return FALSE; 361 } 362 FX_FILESIZE newxrefpos = GetDirectInteger(m_pTrailer, FX_BSTRC("Prev")); 363 if (newxrefpos == xrefpos) { 364 return FALSE; 365 } 366 xrefpos = newxrefpos; 367 while (xrefpos) { 368 CrossRefList.InsertAt(0, xrefpos); 369 LoadCrossRefV4(xrefpos, 0, TRUE, FALSE); 370 CPDF_Dictionary* pDict = LoadTrailerV4(); 371 if (pDict == NULL) { 372 return FALSE; 373 } 374 if (!CheckDirectType(pDict, FX_BSTRC("Prev"), PDFOBJ_NUMBER)) { 375 pDict->Release(); 376 return FALSE; 377 } 378 newxrefpos = GetDirectInteger(pDict, FX_BSTRC("Prev")); 379 if (newxrefpos == xrefpos) { 380 pDict->Release(); 381 return FALSE; 382 } 383 xrefpos = newxrefpos; 384 XRefStreamList.InsertAt(0, pDict->GetInteger(FX_BSTRC("XRefStm"))); 385 m_Trailers.Add(pDict); 386 } 387 for (FX_INT32 i = 0; i < CrossRefList.GetSize(); i ++) 388 if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) { 389 return FALSE; 390 } 391 return TRUE; 392 } 393 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos, FX_DWORD dwObjCount) 394 { 395 if (!LoadLinearizedCrossRefV4(xrefpos, dwObjCount)) { 396 return FALSE; 397 } 398 m_pTrailer = LoadTrailerV4(); 399 if (m_pTrailer == NULL) { 400 return FALSE; 401 } 402 FX_INT32 xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size")); 403 if (xrefsize == 0) { 404 return FALSE; 405 } 406 CFX_FileSizeArray CrossRefList, XRefStreamList; 407 CrossRefList.Add(xrefpos); 408 XRefStreamList.Add(GetDirectInteger(m_pTrailer, FX_BSTRC("XRefStm"))); 409 xrefpos = GetDirectInteger(m_pTrailer, FX_BSTRC("Prev")); 410 while (xrefpos) { 411 CrossRefList.InsertAt(0, xrefpos); 412 LoadCrossRefV4(xrefpos, 0, TRUE, FALSE); 413 CPDF_Dictionary* pDict = LoadTrailerV4(); 414 if (pDict == NULL) { 415 return FALSE; 416 } 417 xrefpos = GetDirectInteger(pDict, FX_BSTRC("Prev")); 418 XRefStreamList.InsertAt(0, pDict->GetInteger(FX_BSTRC("XRefStm"))); 419 m_Trailers.Add(pDict); 420 } 421 for (FX_INT32 i = 1; i < CrossRefList.GetSize(); i ++) 422 if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) { 423 return FALSE; 424 } 425 return TRUE; 426 } 427 FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount) 428 { 429 FX_FILESIZE dwStartPos = pos - m_Syntax.m_HeaderOffset; 430 m_Syntax.RestorePos(dwStartPos); 431 FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 432 if (pResult == NULL) { 433 m_SortedOffset.Add(pos); 434 } 435 FX_DWORD start_objnum = 0; 436 FX_DWORD count = dwObjCount; 437 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 438 FX_INT32 recordsize = 20; 439 char* pBuf = FX_Alloc(char, 1024 * recordsize + 1); 440 pBuf[1024 * recordsize] = '\0'; 441 FX_INT32 nBlocks = count / 1024 + 1; 442 for (FX_INT32 block = 0; block < nBlocks; block ++) { 443 FX_INT32 block_size = block == nBlocks - 1 ? count % 1024 : 1024; 444 FX_DWORD dwReadSize = block_size * recordsize; 445 if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_Syntax.m_FileLen) { 446 FX_Free(pBuf); 447 return FALSE; 448 } 449 if (!m_Syntax.ReadBlock((FX_LPBYTE)pBuf, dwReadSize)) { 450 FX_Free(pBuf); 451 return FALSE; 452 } 453 for (FX_INT32 i = 0; i < block_size; i ++) { 454 FX_DWORD objnum = start_objnum + block * 1024 + i; 455 char* pEntry = pBuf + i * recordsize; 456 if (pEntry[17] == 'f') { 457 m_CrossRef.SetAtGrow(objnum, 0); 458 m_V5Type.SetAtGrow(objnum, 0); 459 } else { 460 FX_INT32 offset = FXSYS_atoi(pEntry); 461 if (offset == 0) { 462 for (FX_INT32 c = 0; c < 10; c ++) { 463 if (pEntry[c] < '0' || pEntry[c] > '9') { 464 FX_Free(pBuf); 465 return FALSE; 466 } 467 } 468 } 469 m_CrossRef.SetAtGrow(objnum, offset); 470 FX_INT32 version = FXSYS_atoi(pEntry + 11); 471 if (version >= 1) { 472 m_bVersionUpdated = TRUE; 473 } 474 m_ObjVersion.SetAtGrow(objnum, version); 475 if (m_CrossRef[objnum] < m_Syntax.m_FileLen) { 476 FX_LPVOID pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 477 if (pResult == NULL) { 478 m_SortedOffset.Add(m_CrossRef[objnum]); 479 } 480 } 481 m_V5Type.SetAtGrow(objnum, 1); 482 } 483 } 484 } 485 FX_Free(pBuf); 486 m_Syntax.RestorePos(SavedPos + count * recordsize); 487 return TRUE; 488 } 489 FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_BOOL bSkip, FX_BOOL bFirst) 490 { 491 m_Syntax.RestorePos(pos); 492 if (m_Syntax.GetKeyword() != FX_BSTRC("xref")) { 493 return FALSE; 494 } 495 FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 496 if (pResult == NULL) { 497 m_SortedOffset.Add(pos); 498 } 499 if (streampos) { 500 FX_LPVOID pResult = FXSYS_bsearch(&streampos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 501 if (pResult == NULL) { 502 m_SortedOffset.Add(streampos); 503 } 504 } 505 while (1) { 506 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 507 FX_BOOL bIsNumber; 508 CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber); 509 if (word.IsEmpty()) { 510 return FALSE; 511 } 512 if (!bIsNumber) { 513 m_Syntax.RestorePos(SavedPos); 514 break; 515 } 516 FX_DWORD start_objnum = FXSYS_atoi(word); 517 if (start_objnum >= (1 << 20)) { 518 return FALSE; 519 } 520 FX_DWORD count = m_Syntax.GetDirectNum(); 521 m_Syntax.ToNextWord(); 522 SavedPos = m_Syntax.SavePos(); 523 FX_BOOL bFirstItem = FALSE; 524 FX_INT32 recordsize = 20; 525 if (bFirst) { 526 bFirstItem = TRUE; 527 } 528 m_dwXrefStartObjNum = start_objnum; 529 if (!bSkip) { 530 char* pBuf = FX_Alloc(char, 1024 * recordsize + 1); 531 pBuf[1024 * recordsize] = '\0'; 532 FX_INT32 nBlocks = count / 1024 + 1; 533 FX_BOOL bFirstBlock = TRUE; 534 for (FX_INT32 block = 0; block < nBlocks; block ++) { 535 FX_INT32 block_size = block == nBlocks - 1 ? count % 1024 : 1024; 536 m_Syntax.ReadBlock((FX_LPBYTE)pBuf, block_size * recordsize); 537 for (FX_INT32 i = 0; i < block_size; i ++) { 538 FX_DWORD objnum = start_objnum + block * 1024 + i; 539 char* pEntry = pBuf + i * recordsize; 540 if (pEntry[17] == 'f') { 541 if (bFirstItem) { 542 objnum = 0; 543 bFirstItem = FALSE; 544 } 545 if (bFirstBlock) { 546 FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry); 547 FX_INT32 version = FXSYS_atoi(pEntry + 11); 548 if (offset == 0 && version == 65535 && start_objnum != 0) { 549 start_objnum--; 550 objnum = 0; 551 } 552 } 553 m_CrossRef.SetAtGrow(objnum, 0); 554 m_V5Type.SetAtGrow(objnum, 0); 555 } else { 556 FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry); 557 if (offset == 0) { 558 for (FX_INT32 c = 0; c < 10; c ++) { 559 if (pEntry[c] < '0' || pEntry[c] > '9') { 560 FX_Free(pBuf); 561 return FALSE; 562 } 563 } 564 } 565 m_CrossRef.SetAtGrow(objnum, offset); 566 FX_INT32 version = FXSYS_atoi(pEntry + 11); 567 if (version >= 1) { 568 m_bVersionUpdated = TRUE; 569 } 570 m_ObjVersion.SetAtGrow(objnum, version); 571 if (m_CrossRef[objnum] < m_Syntax.m_FileLen) { 572 FX_LPVOID pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 573 if (pResult == NULL) { 574 m_SortedOffset.Add(m_CrossRef[objnum]); 575 } 576 } 577 m_V5Type.SetAtGrow(objnum, 1); 578 } 579 if (bFirstBlock) { 580 bFirstBlock = FALSE; 581 } 582 } 583 } 584 FX_Free(pBuf); 585 } 586 m_Syntax.RestorePos(SavedPos + count * recordsize); 587 } 588 if (streampos) 589 if (!LoadCrossRefV5(streampos, streampos, FALSE)) { 590 return FALSE; 591 } 592 return TRUE; 593 } 594 FX_BOOL CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos) 595 { 596 if (!LoadCrossRefV5(xrefpos, xrefpos, TRUE)) { 597 return FALSE; 598 } 599 while (xrefpos) 600 if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) { 601 return FALSE; 602 } 603 m_ObjectStreamMap.InitHashTable(101, FALSE); 604 m_bXRefStream = TRUE; 605 return TRUE; 606 } 607 FX_BOOL CPDF_Parser::RebuildCrossRef() 608 { 609 m_CrossRef.RemoveAll(); 610 m_V5Type.RemoveAll(); 611 m_SortedOffset.RemoveAll(); 612 m_ObjVersion.RemoveAll(); 613 if (m_pTrailer) { 614 m_pTrailer->Release(); 615 m_pTrailer = NULL; 616 } 617 FX_INT32 status = 0; 618 FX_INT32 inside_index = 0; 619 FX_DWORD objnum, gennum; 620 FX_INT32 depth = 0; 621 FX_LPBYTE buffer = FX_Alloc(FX_BYTE, 4096); 622 FX_FILESIZE pos = m_Syntax.m_HeaderOffset; 623 FX_FILESIZE start_pos, start_pos1; 624 FX_FILESIZE last_obj = -1, last_xref = -1, last_trailer = -1; 625 FX_BOOL bInUpdate = FALSE; 626 while (pos < m_Syntax.m_FileLen) { 627 FX_BOOL bOverFlow = FALSE; 628 FX_DWORD size = (FX_DWORD)(m_Syntax.m_FileLen - pos); 629 if (size > 4096) { 630 size = 4096; 631 } 632 if (!m_Syntax.m_pFileAccess->ReadBlock(buffer, pos, size)) { 633 break; 634 } 635 for (FX_DWORD i = 0; i < size; i ++) { 636 FX_BYTE byte = buffer[i]; 637 FX_LPBYTE pData = buffer + i; 638 switch (status) { 639 case 0: 640 if (_PDF_CharType[byte] == 'W') { 641 status = 1; 642 } 643 if (byte <= '9' && byte >= '0') { 644 --i; 645 status = 1; 646 } 647 if (byte == '%') { 648 inside_index = 0; 649 status = 9; 650 } 651 if (byte == '(') { 652 status = 10; 653 depth = 1; 654 } 655 if (byte == '<') { 656 inside_index = 1; 657 status = 11; 658 } 659 if (byte == '\\') { 660 status = 13; 661 } 662 if (byte == 't') { 663 status = 7; 664 inside_index = 1; 665 } 666 break; 667 case 1: 668 if (_PDF_CharType[byte] == 'W') { 669 break; 670 } else if (byte <= '9' && byte >= '0') { 671 start_pos = pos + i; 672 status = 2; 673 objnum = byte - '0'; 674 } else if (byte == 't') { 675 status = 7; 676 inside_index = 1; 677 } else if (byte == 'x') { 678 status = 8; 679 inside_index = 1; 680 } else { 681 --i; 682 status = 0; 683 } 684 break; 685 case 2: 686 if (byte <= '9' && byte >= '0') { 687 objnum = objnum * 10 + byte - '0'; 688 break; 689 } else if (_PDF_CharType[byte] == 'W') { 690 status = 3; 691 } else { 692 --i; 693 status = 14; 694 inside_index = 0; 695 } 696 break; 697 case 3: 698 if (byte <= '9' && byte >= '0') { 699 start_pos1 = pos + i; 700 status = 4; 701 gennum = byte - '0'; 702 } else if (_PDF_CharType[byte] == 'W') { 703 break; 704 } else if (byte == 't') { 705 status = 7; 706 inside_index = 1; 707 } else { 708 --i; 709 status = 0; 710 } 711 break; 712 case 4: 713 if (byte <= '9' && byte >= '0') { 714 gennum = gennum * 10 + byte - '0'; 715 break; 716 } else if (_PDF_CharType[byte] == 'W') { 717 status = 5; 718 } else { 719 --i; 720 status = 0; 721 } 722 break; 723 case 5: 724 if (byte == 'o') { 725 status = 6; 726 inside_index = 1; 727 } else if (_PDF_CharType[byte] == 'W') { 728 break; 729 } else if (byte <= '9' && byte >= '0') { 730 objnum = gennum; 731 gennum = byte - '0'; 732 start_pos = start_pos1; 733 start_pos1 = pos + i; 734 status = 4; 735 } else if (byte == 't') { 736 status = 7; 737 inside_index = 1; 738 } else { 739 --i; 740 status = 0; 741 } 742 break; 743 case 6: 744 switch (inside_index) { 745 case 1: 746 if (byte != 'b') { 747 --i; 748 status = 0; 749 } else { 750 inside_index ++; 751 } 752 break; 753 case 2: 754 if (byte != 'j') { 755 --i; 756 status = 0; 757 } else { 758 inside_index ++; 759 } 760 break; 761 case 3: 762 if (_PDF_CharType[byte] == 'W' || _PDF_CharType[byte] == 'D') { 763 if (objnum > 0x1000000) { 764 status = 0; 765 break; 766 } 767 FX_FILESIZE obj_pos = start_pos - m_Syntax.m_HeaderOffset; 768 last_obj = start_pos; 769 FX_LPVOID pResult = FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 770 if (pResult == NULL) { 771 m_SortedOffset.Add(obj_pos); 772 } 773 FX_FILESIZE obj_end = 0; 774 CPDF_Object *pObject = ParseIndirectObjectAtByStrict(m_pDocument, obj_pos, objnum, NULL, &obj_end); 775 if (pObject) { 776 int iType = pObject->GetType(); 777 if (iType == PDFOBJ_STREAM) { 778 CPDF_Stream* pStream = (CPDF_Stream*)pObject; 779 CPDF_Dictionary* pDict = pStream->GetDict(); 780 if (pDict) { 781 if (pDict->KeyExist(FX_BSTRC("Type"))) { 782 CFX_ByteString bsValue = pDict->GetString(FX_BSTRC("Type")); 783 if (bsValue == FX_BSTRC("XRef") && pDict->KeyExist(FX_BSTRC("Size"))) { 784 CPDF_Object* pRoot = pDict->GetElement(FX_BSTRC("Root")); 785 if (pRoot && pRoot->GetDict() && pRoot->GetDict()->GetElement(FX_BSTRC("Pages"))) { 786 if (m_pTrailer) { 787 m_pTrailer->Release(); 788 } 789 m_pTrailer = (CPDF_Dictionary*)pDict->Clone(); 790 } 791 } 792 } 793 } 794 } 795 } 796 FX_FILESIZE offset = 0; 797 m_Syntax.RestorePos(obj_pos); 798 offset = m_Syntax.FindTag(FX_BSTRC("obj"), 0); 799 if (offset == -1) { 800 offset = 0; 801 } else { 802 offset += 3; 803 } 804 FX_FILESIZE nLen = obj_end - obj_pos - offset; 805 if ((FX_DWORD)nLen > size - i) { 806 pos = obj_end + m_Syntax.m_HeaderOffset; 807 bOverFlow = TRUE; 808 } else { 809 i += (FX_DWORD)nLen; 810 } 811 if (m_CrossRef.GetSize() > (FX_INT32)objnum && m_CrossRef[objnum]) { 812 if (pObject) { 813 FX_DWORD oldgen = m_ObjVersion.GetAt(objnum); 814 m_CrossRef[objnum] = obj_pos; 815 m_ObjVersion.SetAt(objnum, (FX_SHORT)gennum); 816 if (oldgen != gennum) { 817 m_bVersionUpdated = TRUE; 818 } 819 } 820 } else { 821 m_CrossRef.SetAtGrow(objnum, obj_pos); 822 m_V5Type.SetAtGrow(objnum, 1); 823 m_ObjVersion.SetAtGrow(objnum, (FX_SHORT)gennum); 824 } 825 if (pObject) { 826 pObject->Release(); 827 } 828 } 829 --i; 830 status = 0; 831 break; 832 } 833 break; 834 case 7: 835 if (inside_index == 7) { 836 if (_PDF_CharType[byte] == 'W' || _PDF_CharType[byte] == 'D') { 837 last_trailer = pos + i - 7; 838 m_Syntax.RestorePos(pos + i - m_Syntax.m_HeaderOffset); 839 CPDF_Object* pObj = m_Syntax.GetObject(m_pDocument, 0, 0, 0); 840 if (pObj) { 841 if (pObj->GetType() != PDFOBJ_DICTIONARY && pObj->GetType() != PDFOBJ_STREAM) { 842 pObj->Release(); 843 } else { 844 CPDF_Dictionary* pTrailer = NULL; 845 if (pObj->GetType() == PDFOBJ_STREAM) { 846 pTrailer = ((CPDF_Stream*)pObj)->GetDict(); 847 } else { 848 pTrailer = (CPDF_Dictionary*)pObj; 849 } 850 if (pTrailer) { 851 if (m_pTrailer) { 852 CPDF_Object* pRoot = pTrailer->GetElement(FX_BSTRC("Root")); 853 if (pRoot == NULL || (pRoot->GetType() == PDFOBJ_REFERENCE && 854 (FX_DWORD)m_CrossRef.GetSize() > ((CPDF_Reference*)pRoot)->GetRefObjNum() && 855 m_CrossRef.GetAt(((CPDF_Reference*)pRoot)->GetRefObjNum()) != 0)) { 856 FX_POSITION pos = pTrailer->GetStartPos(); 857 while (pos) { 858 CFX_ByteString key; 859 CPDF_Object* pObj = pTrailer->GetNextElement(pos, key); 860 m_pTrailer->SetAt(key, pObj->Clone(), m_pDocument); 861 } 862 pObj->Release(); 863 } else { 864 pObj->Release(); 865 } 866 } else { 867 if (pObj->GetType() == PDFOBJ_STREAM) { 868 m_pTrailer = (CPDF_Dictionary*)pTrailer->Clone(); 869 pObj->Release(); 870 } else { 871 m_pTrailer = pTrailer; 872 } 873 FX_FILESIZE dwSavePos = m_Syntax.SavePos(); 874 CFX_ByteString strWord = m_Syntax.GetKeyword(); 875 if (!strWord.Compare(FX_BSTRC("startxref"))) { 876 FX_BOOL bNumber = FALSE; 877 CFX_ByteString bsOffset = m_Syntax.GetNextWord(bNumber); 878 if (bNumber) { 879 m_LastXRefOffset = FXSYS_atoi(bsOffset); 880 } 881 } 882 m_Syntax.RestorePos(dwSavePos); 883 } 884 } else { 885 pObj->Release(); 886 } 887 bInUpdate = TRUE; 888 } 889 } 890 } 891 --i; 892 status = 0; 893 } else if (byte == "trailer"[inside_index]) { 894 inside_index ++; 895 } else { 896 --i; 897 status = 0; 898 } 899 break; 900 case 8: 901 if (inside_index == 4) { 902 last_xref = pos + i - 4; 903 status = 1; 904 } else if (byte == "xref"[inside_index]) { 905 inside_index ++; 906 } else { 907 --i; 908 status = 0; 909 } 910 break; 911 case 9: 912 if (byte == '\r' || byte == '\n') { 913 status = 0; 914 } 915 break; 916 case 10: 917 if (byte == ')') { 918 if (depth > 0) { 919 depth--; 920 } 921 } else if (byte == '(') { 922 depth++; 923 } 924 if (!depth) { 925 status = 0; 926 } 927 break; 928 case 11: 929 if (byte == '<' && inside_index == 1) { 930 status = 12; 931 } else if (byte == '>') { 932 status = 0; 933 } 934 inside_index = 0; 935 break; 936 case 12: 937 --i; 938 status = 0; 939 break; 940 case 13: 941 if (_PDF_CharType[byte] == 'D' || _PDF_CharType[byte] == 'W') { 942 --i; 943 status = 0; 944 } 945 break; 946 case 14: 947 if (_PDF_CharType[byte] == 'W') { 948 status = 0; 949 } else if (byte == '%' || byte == '(' || byte == '<' || byte == '\\') { 950 status = 0; 951 --i; 952 } else if (inside_index == 6) { 953 status = 0; 954 --i; 955 } else if (byte == "endobj"[inside_index]) { 956 inside_index++; 957 } 958 break; 959 } 960 if (bOverFlow) { 961 size = 0; 962 break; 963 } 964 } 965 pos += size; 966 } 967 if (last_xref != -1 && last_xref > last_obj) { 968 last_trailer = last_xref; 969 } else if (last_trailer == -1 || last_xref < last_obj) { 970 last_trailer = m_Syntax.m_FileLen; 971 } 972 FX_FILESIZE offset = last_trailer - m_Syntax.m_HeaderOffset; 973 FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 974 if (pResult == NULL) { 975 m_SortedOffset.Add(offset); 976 } 977 FX_Free(buffer); 978 return TRUE; 979 } 980 static FX_DWORD _GetVarInt(FX_LPCBYTE p, FX_INT32 n) 981 { 982 FX_DWORD result = 0; 983 for (FX_INT32 i = 0; i < n; i ++) { 984 result = result * 256 + p[i]; 985 } 986 return result; 987 } 988 FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL bMainXRef) 989 { 990 CPDF_Stream* pStream = (CPDF_Stream*)ParseIndirectObjectAt(m_pDocument, pos, 0, NULL); 991 if (!pStream) { 992 return FALSE; 993 } 994 if (m_pDocument) { 995 m_pDocument->InsertIndirectObject(pStream->m_ObjNum, pStream); 996 } 997 if (pStream->GetType() != PDFOBJ_STREAM) { 998 return FALSE; 999 } 1000 prev = pStream->GetDict()->GetInteger(FX_BSTRC("Prev")); 1001 FX_INT32 size = pStream->GetDict()->GetInteger(FX_BSTRC("Size")); 1002 if (size < 0) { 1003 pStream->Release(); 1004 return FALSE; 1005 } 1006 if (bMainXRef) { 1007 m_pTrailer = (CPDF_Dictionary*)pStream->GetDict()->Clone(); 1008 m_CrossRef.SetSize(size); 1009 if (m_V5Type.SetSize(size)) { 1010 FXSYS_memset32(m_V5Type.GetData(), 0, size); 1011 } 1012 } else { 1013 m_Trailers.Add((CPDF_Dictionary*)pStream->GetDict()->Clone()); 1014 } 1015 CFX_DWordArray IndexArray, WidthArray; 1016 FX_DWORD nSegs = 0; 1017 CPDF_Array* pArray = pStream->GetDict()->GetArray(FX_BSTRC("Index")); 1018 if (pArray == NULL) { 1019 IndexArray.Add(0); 1020 IndexArray.Add(size); 1021 nSegs = 1; 1022 } else { 1023 for (FX_DWORD i = 0; i < pArray->GetCount(); i ++) { 1024 IndexArray.Add(pArray->GetInteger(i)); 1025 } 1026 nSegs = pArray->GetCount() / 2; 1027 } 1028 pArray = pStream->GetDict()->GetArray(FX_BSTRC("W")); 1029 if (pArray == NULL) { 1030 pStream->Release(); 1031 return FALSE; 1032 } 1033 FX_DWORD totalwidth = 0; 1034 FX_DWORD i; 1035 for (i = 0; i < pArray->GetCount(); i ++) { 1036 WidthArray.Add(pArray->GetInteger(i)); 1037 if (totalwidth + WidthArray[i] < totalwidth) { 1038 pStream->Release(); 1039 return FALSE; 1040 } 1041 totalwidth += WidthArray[i]; 1042 } 1043 if (totalwidth == 0 || WidthArray.GetSize() < 3) { 1044 pStream->Release(); 1045 return FALSE; 1046 } 1047 CPDF_StreamAcc acc; 1048 acc.LoadAllData(pStream); 1049 FX_LPCBYTE pData = acc.GetData(); 1050 FX_DWORD dwTotalSize = acc.GetSize(); 1051 FX_DWORD segindex = 0; 1052 for (i = 0; i < nSegs; i ++) { 1053 FX_INT32 startnum = IndexArray[i * 2]; 1054 if (startnum < 0) { 1055 continue; 1056 } 1057 m_dwXrefStartObjNum = startnum; 1058 FX_DWORD count = IndexArray[i * 2 + 1]; 1059 if (segindex + count < segindex || segindex + count == 0 || 1060 (FX_DWORD)totalwidth >= UINT_MAX / (segindex + count) || (segindex + count) * (FX_DWORD)totalwidth > dwTotalSize) { 1061 continue; 1062 } 1063 FX_LPCBYTE segstart = pData + segindex * (FX_DWORD)totalwidth; 1064 if ((FX_DWORD)startnum + count < (FX_DWORD)startnum || 1065 (FX_DWORD)startnum + count > (FX_DWORD)m_V5Type.GetSize()) { 1066 continue; 1067 } 1068 for (FX_DWORD j = 0; j < count; j ++) { 1069 FX_INT32 type = 1; 1070 FX_LPCBYTE entrystart = segstart + j * totalwidth; 1071 if (WidthArray[0]) { 1072 type = _GetVarInt(entrystart, WidthArray[0]); 1073 } 1074 if (m_V5Type[startnum + j] == 255) { 1075 FX_FILESIZE offset = _GetVarInt(entrystart + WidthArray[0], WidthArray[1]); 1076 m_CrossRef[startnum + j] = offset; 1077 FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1078 if (pResult == NULL) { 1079 m_SortedOffset.Add(offset); 1080 } 1081 continue; 1082 } 1083 if (m_V5Type[startnum + j]) { 1084 continue; 1085 } 1086 m_V5Type[startnum + j] = type; 1087 if (type == 0) { 1088 m_CrossRef[startnum + j] = 0; 1089 } else { 1090 FX_FILESIZE offset = _GetVarInt(entrystart + WidthArray[0], WidthArray[1]); 1091 m_CrossRef[startnum + j] = offset; 1092 if (type == 1) { 1093 FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1094 if (pResult == NULL) { 1095 m_SortedOffset.Add(offset); 1096 } 1097 } else { 1098 if (offset < 0 || offset >= m_V5Type.GetSize()) { 1099 pStream->Release(); 1100 return FALSE; 1101 } 1102 m_V5Type[offset] = 255; 1103 } 1104 } 1105 } 1106 segindex += count; 1107 } 1108 pStream->Release(); 1109 return TRUE; 1110 } 1111 CPDF_Array* CPDF_Parser::GetIDArray() 1112 { 1113 CPDF_Object* pID = m_pTrailer->GetElement(FX_BSTRC("ID")); 1114 if (pID == NULL) { 1115 return NULL; 1116 } 1117 if (pID->GetType() == PDFOBJ_REFERENCE) { 1118 pID = ParseIndirectObject(NULL, ((CPDF_Reference*)pID)->GetRefObjNum()); 1119 m_pTrailer->SetAt(FX_BSTRC("ID"), pID); 1120 } 1121 if (pID == NULL || pID->GetType() != PDFOBJ_ARRAY) { 1122 return NULL; 1123 } 1124 return (CPDF_Array*)pID; 1125 } 1126 FX_DWORD CPDF_Parser::GetRootObjNum() 1127 { 1128 CPDF_Reference* pRef = (CPDF_Reference*)m_pTrailer->GetElement(FX_BSTRC("Root")); 1129 if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) { 1130 return 0; 1131 } 1132 return pRef->GetRefObjNum(); 1133 } 1134 FX_DWORD CPDF_Parser::GetInfoObjNum() 1135 { 1136 CPDF_Reference* pRef = (CPDF_Reference*)m_pTrailer->GetElement(FX_BSTRC("Info")); 1137 if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) { 1138 return 0; 1139 } 1140 return pRef->GetRefObjNum(); 1141 } 1142 FX_BOOL CPDF_Parser::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) 1143 { 1144 bForm = FALSE; 1145 if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) { 1146 return TRUE; 1147 } 1148 if (m_V5Type[objnum] == 0) { 1149 return TRUE; 1150 } 1151 if (m_V5Type[objnum] == 2) { 1152 return TRUE; 1153 } 1154 FX_FILESIZE pos = m_CrossRef[objnum]; 1155 FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1156 if (pResult == NULL) { 1157 return TRUE; 1158 } 1159 if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1) { 1160 return FALSE; 1161 } 1162 FX_FILESIZE size = ((FX_FILESIZE*)pResult)[1] - pos; 1163 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 1164 m_Syntax.RestorePos(pos); 1165 bForm = m_Syntax.SearchMultiWord(FX_BSTRC("/Form\0stream"), TRUE, size) == 0; 1166 m_Syntax.RestorePos(SavedPos); 1167 return TRUE; 1168 } 1169 CPDF_Object* CPDF_Parser::ParseIndirectObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, PARSE_CONTEXT* pContext) 1170 { 1171 if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) { 1172 return NULL; 1173 } 1174 if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) { 1175 FX_FILESIZE pos = m_CrossRef[objnum]; 1176 if (pos <= 0) { 1177 return NULL; 1178 } 1179 return ParseIndirectObjectAt(pObjList, pos, objnum, pContext); 1180 } 1181 if (m_V5Type[objnum] == 2) { 1182 CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]); 1183 if (pObjStream == NULL) { 1184 return NULL; 1185 } 1186 FX_INT32 n = pObjStream->GetDict()->GetInteger(FX_BSTRC("N")); 1187 FX_INT32 offset = pObjStream->GetDict()->GetInteger(FX_BSTRC("First")); 1188 CPDF_SyntaxParser syntax; 1189 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((FX_LPBYTE)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE)); 1190 syntax.InitParser((IFX_FileStream*)file, 0); 1191 CPDF_Object* pRet = NULL; 1192 while (n) { 1193 FX_DWORD thisnum = syntax.GetDirectNum(); 1194 FX_DWORD thisoff = syntax.GetDirectNum(); 1195 if (thisnum == objnum) { 1196 syntax.RestorePos(offset + thisoff); 1197 pRet = syntax.GetObject(pObjList, 0, 0, 0, pContext); 1198 break; 1199 } 1200 n --; 1201 } 1202 return pRet; 1203 } 1204 return NULL; 1205 } 1206 CPDF_StreamAcc* CPDF_Parser::GetObjectStream(FX_DWORD objnum) 1207 { 1208 CPDF_StreamAcc* pStreamAcc = NULL; 1209 if (m_ObjectStreamMap.Lookup((void*)(FX_UINTPTR)objnum, (void*&)pStreamAcc)) { 1210 return pStreamAcc; 1211 } 1212 const CPDF_Stream* pStream = (CPDF_Stream*)m_pDocument->GetIndirectObject(objnum); 1213 if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) { 1214 return NULL; 1215 } 1216 pStreamAcc = FX_NEW CPDF_StreamAcc; 1217 pStreamAcc->LoadAllData(pStream); 1218 m_ObjectStreamMap.SetAt((void*)(FX_UINTPTR)objnum, pStreamAcc); 1219 return pStreamAcc; 1220 } 1221 FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) 1222 { 1223 if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) { 1224 return 0; 1225 } 1226 if (m_V5Type[objnum] == 2) { 1227 objnum = (FX_DWORD)m_CrossRef[objnum]; 1228 } 1229 if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) { 1230 FX_FILESIZE offset = m_CrossRef[objnum]; 1231 if (offset == 0) { 1232 return 0; 1233 } 1234 FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1235 if (pResult == NULL) { 1236 return 0; 1237 } 1238 if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1) { 1239 return 0; 1240 } 1241 return ((FX_FILESIZE*)pResult)[1] - offset; 1242 } 1243 return 0; 1244 } 1245 void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, FX_LPBYTE& pBuffer, FX_DWORD& size) 1246 { 1247 pBuffer = NULL; 1248 size = 0; 1249 if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) { 1250 return; 1251 } 1252 if (m_V5Type[objnum] == 2) { 1253 CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]); 1254 if (pObjStream == NULL) { 1255 return; 1256 } 1257 FX_INT32 n = pObjStream->GetDict()->GetInteger(FX_BSTRC("N")); 1258 FX_INT32 offset = pObjStream->GetDict()->GetInteger(FX_BSTRC("First")); 1259 CPDF_SyntaxParser syntax; 1260 FX_LPCBYTE pData = pObjStream->GetData(); 1261 FX_DWORD totalsize = pObjStream->GetSize(); 1262 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((FX_LPBYTE)pData, (size_t)totalsize, FALSE)); 1263 syntax.InitParser((IFX_FileStream*)file, 0); 1264 while (n) { 1265 FX_DWORD thisnum = syntax.GetDirectNum(); 1266 FX_DWORD thisoff = syntax.GetDirectNum(); 1267 if (thisnum == objnum) { 1268 if (n == 1) { 1269 size = totalsize - (thisoff + offset); 1270 } else { 1271 FX_DWORD nextnum = syntax.GetDirectNum(); 1272 FX_DWORD nextoff = syntax.GetDirectNum(); 1273 size = nextoff - thisoff; 1274 } 1275 pBuffer = FX_Alloc(FX_BYTE, size); 1276 FXSYS_memcpy32(pBuffer, pData + thisoff + offset, size); 1277 return; 1278 } 1279 n --; 1280 } 1281 return; 1282 } 1283 if (m_V5Type[objnum] == 1) { 1284 FX_FILESIZE pos = m_CrossRef[objnum]; 1285 if (pos == 0) { 1286 return; 1287 } 1288 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 1289 m_Syntax.RestorePos(pos); 1290 FX_BOOL bIsNumber; 1291 CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber); 1292 if (!bIsNumber) { 1293 m_Syntax.RestorePos(SavedPos); 1294 return; 1295 } 1296 FX_DWORD real_objnum = FXSYS_atoi(word); 1297 if (real_objnum && real_objnum != objnum) { 1298 m_Syntax.RestorePos(SavedPos); 1299 return; 1300 } 1301 word = m_Syntax.GetNextWord(bIsNumber); 1302 if (!bIsNumber) { 1303 m_Syntax.RestorePos(SavedPos); 1304 return; 1305 } 1306 if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) { 1307 m_Syntax.RestorePos(SavedPos); 1308 return; 1309 } 1310 FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1311 if (pResult == NULL) { 1312 m_Syntax.RestorePos(SavedPos); 1313 return; 1314 } 1315 FX_FILESIZE nextoff = ((FX_FILESIZE*)pResult)[1]; 1316 FX_BOOL bNextOffValid = FALSE; 1317 if (nextoff != pos) { 1318 m_Syntax.RestorePos(nextoff); 1319 word = m_Syntax.GetNextWord(bIsNumber); 1320 if (word == FX_BSTRC("xref")) { 1321 bNextOffValid = TRUE; 1322 } else if (bIsNumber) { 1323 word = m_Syntax.GetNextWord(bIsNumber); 1324 if (bIsNumber && m_Syntax.GetKeyword() == FX_BSTRC("obj")) { 1325 bNextOffValid = TRUE; 1326 } 1327 } 1328 } 1329 if (!bNextOffValid) { 1330 m_Syntax.RestorePos(pos); 1331 while (1) { 1332 if (m_Syntax.GetKeyword() == FX_BSTRC("endobj")) { 1333 break; 1334 } 1335 if (m_Syntax.SavePos() == m_Syntax.m_FileLen) { 1336 break; 1337 } 1338 } 1339 nextoff = m_Syntax.SavePos(); 1340 } 1341 size = (FX_DWORD)(nextoff - pos); 1342 pBuffer = FX_Alloc(FX_BYTE, size); 1343 m_Syntax.RestorePos(pos); 1344 m_Syntax.ReadBlock(pBuffer, size); 1345 m_Syntax.RestorePos(SavedPos); 1346 } 1347 } 1348 CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(CPDF_IndirectObjects* pObjList, FX_FILESIZE pos, FX_DWORD objnum, 1349 PARSE_CONTEXT* pContext) 1350 { 1351 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 1352 m_Syntax.RestorePos(pos); 1353 FX_BOOL bIsNumber; 1354 CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber); 1355 if (!bIsNumber) { 1356 m_Syntax.RestorePos(SavedPos); 1357 return NULL; 1358 } 1359 FX_FILESIZE objOffset = m_Syntax.SavePos(); 1360 objOffset -= word.GetLength(); 1361 FX_DWORD real_objnum = FXSYS_atoi(word); 1362 if (objnum && real_objnum != objnum) { 1363 m_Syntax.RestorePos(SavedPos); 1364 return NULL; 1365 } 1366 word = m_Syntax.GetNextWord(bIsNumber); 1367 if (!bIsNumber) { 1368 m_Syntax.RestorePos(SavedPos); 1369 return NULL; 1370 } 1371 FX_DWORD gennum = FXSYS_atoi(word); 1372 if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) { 1373 m_Syntax.RestorePos(SavedPos); 1374 return NULL; 1375 } 1376 CPDF_Object* pObj = m_Syntax.GetObject(pObjList, objnum, gennum, 0, pContext); 1377 FX_FILESIZE endOffset = m_Syntax.SavePos(); 1378 CFX_ByteString bsWord = m_Syntax.GetKeyword(); 1379 if (bsWord == FX_BSTRC("endobj")) { 1380 endOffset = m_Syntax.SavePos(); 1381 } 1382 FX_DWORD objSize = endOffset - objOffset; 1383 m_Syntax.RestorePos(SavedPos); 1384 if (pObj && !objnum) { 1385 pObj->m_ObjNum = real_objnum; 1386 } 1387 return pObj; 1388 } 1389 CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(CPDF_IndirectObjects* pObjList, FX_FILESIZE pos, FX_DWORD objnum, 1390 struct PARSE_CONTEXT* pContext, FX_FILESIZE *pResultPos) 1391 { 1392 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 1393 m_Syntax.RestorePos(pos); 1394 FX_BOOL bIsNumber; 1395 CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber); 1396 if (!bIsNumber) { 1397 m_Syntax.RestorePos(SavedPos); 1398 return NULL; 1399 } 1400 FX_DWORD real_objnum = FXSYS_atoi(word); 1401 if (objnum && real_objnum != objnum) { 1402 m_Syntax.RestorePos(SavedPos); 1403 return NULL; 1404 } 1405 word = m_Syntax.GetNextWord(bIsNumber); 1406 if (!bIsNumber) { 1407 m_Syntax.RestorePos(SavedPos); 1408 return NULL; 1409 } 1410 FX_DWORD gennum = FXSYS_atoi(word); 1411 if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) { 1412 m_Syntax.RestorePos(SavedPos); 1413 return NULL; 1414 } 1415 CPDF_Object* pObj = m_Syntax.GetObjectByStrict(pObjList, objnum, gennum, 0, pContext); 1416 if (pResultPos) { 1417 *pResultPos = m_Syntax.m_Pos; 1418 } 1419 m_Syntax.RestorePos(SavedPos); 1420 return pObj; 1421 } 1422 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() 1423 { 1424 if (m_Syntax.GetKeyword() != FX_BSTRC("trailer")) { 1425 return NULL; 1426 } 1427 CPDF_Object* pObj = m_Syntax.GetObject(m_pDocument, 0, 0, 0); 1428 if (pObj == NULL || pObj->GetType() != PDFOBJ_DICTIONARY) { 1429 if (pObj) { 1430 pObj->Release(); 1431 } 1432 return NULL; 1433 } 1434 return (CPDF_Dictionary*)pObj; 1435 } 1436 FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) 1437 { 1438 if (m_pSecurityHandler == NULL) { 1439 return (FX_DWORD) - 1; 1440 } 1441 FX_DWORD dwPermission = m_pSecurityHandler->GetPermissions(); 1442 if (m_pEncryptDict && m_pEncryptDict->GetString(FX_BSTRC("Filter")) == FX_BSTRC("Standard")) { 1443 dwPermission &= 0xFFFFFFFC; 1444 dwPermission |= 0xFFFFF0C0; 1445 if(bCheckRevision && m_pEncryptDict->GetInteger(FX_BSTRC("R")) == 2) { 1446 dwPermission &= 0xFFFFF0FF; 1447 } 1448 } 1449 return dwPermission; 1450 } 1451 FX_BOOL CPDF_Parser::IsOwner() 1452 { 1453 return m_pSecurityHandler == NULL ? TRUE : m_pSecurityHandler->IsOwner(); 1454 } 1455 void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler, FX_BOOL bForced) 1456 { 1457 ASSERT(m_pSecurityHandler == NULL); 1458 if (m_pSecurityHandler && !m_bForceUseSecurityHandler) { 1459 delete m_pSecurityHandler; 1460 m_pSecurityHandler = NULL; 1461 } 1462 m_bForceUseSecurityHandler = bForced; 1463 m_pSecurityHandler = pSecurityHandler; 1464 if (m_bForceUseSecurityHandler) { 1465 return; 1466 } 1467 m_Syntax.m_pCryptoHandler = pSecurityHandler->CreateCryptoHandler(); 1468 m_Syntax.m_pCryptoHandler->Init(NULL, pSecurityHandler); 1469 } 1470 FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset) 1471 { 1472 m_Syntax.InitParser(pFileAccess, offset); 1473 m_Syntax.RestorePos(m_Syntax.m_HeaderOffset + 9); 1474 FX_FILESIZE SavedPos = m_Syntax.SavePos(); 1475 FX_BOOL bIsNumber; 1476 CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber); 1477 if (!bIsNumber) { 1478 return FALSE; 1479 } 1480 FX_DWORD objnum = FXSYS_atoi(word); 1481 word = m_Syntax.GetNextWord(bIsNumber); 1482 if (!bIsNumber) { 1483 return FALSE; 1484 } 1485 FX_DWORD gennum = FXSYS_atoi(word); 1486 if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) { 1487 m_Syntax.RestorePos(SavedPos); 1488 return FALSE; 1489 } 1490 m_pLinearized = m_Syntax.GetObject(NULL, objnum, gennum, 0); 1491 if (!m_pLinearized) { 1492 return FALSE; 1493 } 1494 if (m_pLinearized->GetDict()->GetElement(FX_BSTRC("Linearized"))) { 1495 m_Syntax.GetNextWord(bIsNumber); 1496 CPDF_Object *pLen = m_pLinearized->GetDict()->GetElement(FX_BSTRC("L")); 1497 if (!pLen) { 1498 m_pLinearized->Release(); 1499 return FALSE; 1500 } 1501 if (pLen->GetInteger() != (int)pFileAccess->GetSize()) { 1502 return FALSE; 1503 } 1504 CPDF_Object *pNo = m_pLinearized->GetDict()->GetElement(FX_BSTRC("P")); 1505 if (pNo && pNo->GetType() == PDFOBJ_NUMBER) { 1506 m_dwFirstPageNo = pNo->GetInteger(); 1507 } 1508 CPDF_Object *pTable = m_pLinearized->GetDict()->GetElement(FX_BSTRC("T")); 1509 if (pTable && pTable->GetType() == PDFOBJ_NUMBER) { 1510 m_LastXRefOffset = pTable->GetInteger(); 1511 } 1512 return TRUE; 1513 } 1514 m_pLinearized->Release(); 1515 m_pLinearized = NULL; 1516 return FALSE; 1517 } 1518 FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX_BOOL bOwnFileRead) 1519 { 1520 CloseParser(bReParse); 1521 m_bXRefStream = FALSE; 1522 m_LastXRefOffset = 0; 1523 m_bOwnFileRead = bOwnFileRead; 1524 FX_INT32 offset = GetHeaderOffset(pFileAccess); 1525 if (offset == -1) { 1526 return PDFPARSE_ERROR_FORMAT; 1527 } 1528 if (!IsLinearizedFile(pFileAccess, offset)) { 1529 m_Syntax.m_pFileAccess = NULL; 1530 return StartParse(pFileAccess, bReParse, bOwnFileRead); 1531 } 1532 if (!bReParse) { 1533 m_pDocument = FX_NEW CPDF_Document(this); 1534 } 1535 FX_FILESIZE dwFirstXRefOffset = m_Syntax.SavePos(); 1536 FX_BOOL bXRefRebuilt = FALSE; 1537 FX_BOOL bLoadV4 = FALSE; 1538 if (!(bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE, FALSE)) && !LoadCrossRefV5(dwFirstXRefOffset, dwFirstXRefOffset, TRUE)) { 1539 if (!RebuildCrossRef()) { 1540 return PDFPARSE_ERROR_FORMAT; 1541 } 1542 bXRefRebuilt = TRUE; 1543 m_LastXRefOffset = 0; 1544 } 1545 if (bLoadV4) { 1546 m_pTrailer = LoadTrailerV4(); 1547 if (m_pTrailer == NULL) { 1548 return FALSE; 1549 } 1550 FX_INT32 xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size")); 1551 if (xrefsize == 0) { 1552 return FALSE; 1553 } 1554 m_CrossRef.SetSize(xrefsize); 1555 m_V5Type.SetSize(xrefsize); 1556 } 1557 FX_DWORD dwRet = SetEncryptHandler(); 1558 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 1559 return dwRet; 1560 } 1561 m_pDocument->LoadAsynDoc(m_pLinearized->GetDict()); 1562 if (m_pDocument->GetRoot() == NULL || m_pDocument->GetPageCount() == 0) { 1563 if (bXRefRebuilt) { 1564 return PDFPARSE_ERROR_FORMAT; 1565 } 1566 ReleaseEncryptHandler(); 1567 if (!RebuildCrossRef()) { 1568 return PDFPARSE_ERROR_FORMAT; 1569 } 1570 dwRet = SetEncryptHandler(); 1571 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 1572 return dwRet; 1573 } 1574 m_pDocument->LoadAsynDoc(m_pLinearized->GetDict()); 1575 if (m_pDocument->GetRoot() == NULL) { 1576 return PDFPARSE_ERROR_FORMAT; 1577 } 1578 } 1579 FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 1580 FX_DWORD RootObjNum = GetRootObjNum(); 1581 if (RootObjNum == 0) { 1582 ReleaseEncryptHandler(); 1583 RebuildCrossRef(); 1584 RootObjNum = GetRootObjNum(); 1585 if (RootObjNum == 0) { 1586 return PDFPARSE_ERROR_FORMAT; 1587 } 1588 dwRet = SetEncryptHandler(); 1589 if (dwRet != PDFPARSE_ERROR_SUCCESS) { 1590 return dwRet; 1591 } 1592 } 1593 if (m_pSecurityHandler && m_pSecurityHandler->IsMetadataEncrypted()) { 1594 CPDF_Reference* pMetadata = (CPDF_Reference*)m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata")); 1595 if (pMetadata && pMetadata->GetType() == PDFOBJ_REFERENCE) { 1596 m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum(); 1597 } 1598 } 1599 return PDFPARSE_ERROR_SUCCESS; 1600 } 1601 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) 1602 { 1603 if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) { 1604 return FALSE; 1605 } 1606 while (xrefpos) 1607 if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) { 1608 return FALSE; 1609 } 1610 m_ObjectStreamMap.InitHashTable(101, FALSE); 1611 m_bXRefStream = TRUE; 1612 return TRUE; 1613 } 1614 FX_DWORD CPDF_Parser::LoadLinearizedMainXRefTable() 1615 { 1616 FX_DWORD dwSaveMetadataObjnum = m_Syntax.m_MetadataObjnum; 1617 m_Syntax.m_MetadataObjnum = 0; 1618 if (m_pTrailer) { 1619 m_pTrailer->Release(); 1620 m_pTrailer = NULL; 1621 } 1622 m_Syntax.RestorePos(m_LastXRefOffset - m_Syntax.m_HeaderOffset); 1623 FX_FILESIZE dwSavedPos = m_Syntax.SavePos(); 1624 FX_BYTE ch = 0; 1625 FX_DWORD dwCount = 0; 1626 m_Syntax.GetNextChar(ch); 1627 FX_INT32 type = _PDF_CharType[ch]; 1628 while (type == 'W') { 1629 ++dwCount; 1630 if (m_Syntax.m_FileLen >= (FX_FILESIZE)(m_Syntax.SavePos() + m_Syntax.m_HeaderOffset)) { 1631 break; 1632 } 1633 m_Syntax.GetNextChar(ch); 1634 type = _PDF_CharType[ch]; 1635 } 1636 m_LastXRefOffset += dwCount; 1637 FX_POSITION pos = m_ObjectStreamMap.GetStartPosition(); 1638 while (pos) { 1639 FX_LPVOID objnum; 1640 CPDF_StreamAcc* pStream; 1641 m_ObjectStreamMap.GetNextAssoc(pos, objnum, (void*&)pStream); 1642 delete pStream; 1643 } 1644 m_ObjectStreamMap.RemoveAll(); 1645 if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) && !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) { 1646 m_LastXRefOffset = 0; 1647 m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum; 1648 return PDFPARSE_ERROR_FORMAT; 1649 } 1650 FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_DWORD), _CompareDWord); 1651 m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum; 1652 return PDFPARSE_ERROR_SUCCESS; 1653 } 1654 CPDF_SyntaxParser::CPDF_SyntaxParser() 1655 { 1656 m_pFileAccess = NULL; 1657 m_pCryptoHandler = NULL; 1658 m_pFileBuf = NULL; 1659 m_BufSize = CPDF_ModuleMgr::Get()->m_FileBufSize; 1660 m_pFileBuf = NULL; 1661 m_MetadataObjnum = 0; 1662 m_dwWordPos = 0; 1663 #if defined(_FPDFAPI_MINI_) 1664 m_bFileStream = TRUE; 1665 #else 1666 m_bFileStream = FALSE; 1667 #endif 1668 } 1669 CPDF_SyntaxParser::~CPDF_SyntaxParser() 1670 { 1671 if (m_pFileBuf) { 1672 FX_Free(m_pFileBuf); 1673 } 1674 } 1675 FX_BOOL CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, FX_BYTE& ch) 1676 { 1677 FX_FILESIZE save_pos = m_Pos; 1678 m_Pos = pos; 1679 FX_BOOL ret = GetNextChar(ch); 1680 m_Pos = save_pos; 1681 return ret; 1682 } 1683 FX_BOOL CPDF_SyntaxParser::GetNextChar(FX_BYTE& ch) 1684 { 1685 FX_FILESIZE pos = m_Pos + m_HeaderOffset; 1686 if (pos >= m_FileLen) { 1687 return FALSE; 1688 } 1689 if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) { 1690 FX_FILESIZE read_pos = pos; 1691 FX_DWORD read_size = m_BufSize; 1692 if ((FX_FILESIZE)read_size > m_FileLen) { 1693 read_size = (FX_DWORD)m_FileLen; 1694 } 1695 if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) { 1696 if (m_FileLen < (FX_FILESIZE)read_size) { 1697 read_pos = 0; 1698 read_size = (FX_DWORD)m_FileLen; 1699 } else { 1700 read_pos = m_FileLen - read_size; 1701 } 1702 } 1703 if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size)) { 1704 return FALSE; 1705 } 1706 m_BufOffset = read_pos; 1707 } 1708 ch = m_pFileBuf[pos - m_BufOffset]; 1709 m_Pos ++; 1710 return TRUE; 1711 } 1712 FX_BOOL CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, FX_BYTE& ch) 1713 { 1714 pos += m_HeaderOffset; 1715 if (pos >= m_FileLen) { 1716 return FALSE; 1717 } 1718 if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) { 1719 FX_FILESIZE read_pos; 1720 if (pos < (FX_FILESIZE)m_BufSize) { 1721 read_pos = 0; 1722 } else { 1723 read_pos = pos - m_BufSize + 1; 1724 } 1725 FX_DWORD read_size = m_BufSize; 1726 if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) { 1727 if (m_FileLen < (FX_FILESIZE)read_size) { 1728 read_pos = 0; 1729 read_size = (FX_DWORD)m_FileLen; 1730 } else { 1731 read_pos = m_FileLen - read_size; 1732 } 1733 } 1734 if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size)) { 1735 return FALSE; 1736 } 1737 m_BufOffset = read_pos; 1738 } 1739 ch = m_pFileBuf[pos - m_BufOffset]; 1740 return TRUE; 1741 } 1742 FX_BOOL CPDF_SyntaxParser::ReadBlock(FX_LPBYTE pBuf, FX_DWORD size) 1743 { 1744 if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size)) { 1745 return FALSE; 1746 } 1747 m_Pos += size; 1748 return TRUE; 1749 } 1750 #define MAX_WORD_BUFFER 256 1751 void CPDF_SyntaxParser::GetNextWord() 1752 { 1753 m_WordSize = 0; 1754 m_bIsNumber = TRUE; 1755 FX_BYTE ch; 1756 if (!GetNextChar(ch)) { 1757 return; 1758 } 1759 FX_BYTE type = _PDF_CharType[ch]; 1760 while (1) { 1761 while (type == 'W') { 1762 if (!GetNextChar(ch)) { 1763 return; 1764 } 1765 type = _PDF_CharType[ch]; 1766 } 1767 if (ch != '%') { 1768 break; 1769 } 1770 while (1) { 1771 if (!GetNextChar(ch)) { 1772 return; 1773 } 1774 if (ch == '\r' || ch == '\n') { 1775 break; 1776 } 1777 } 1778 type = _PDF_CharType[ch]; 1779 } 1780 if (type == 'D') { 1781 m_bIsNumber = FALSE; 1782 m_WordBuffer[m_WordSize++] = ch; 1783 if (ch == '/') { 1784 while (1) { 1785 if (!GetNextChar(ch)) { 1786 return; 1787 } 1788 type = _PDF_CharType[ch]; 1789 if (type != 'R' && type != 'N') { 1790 m_Pos --; 1791 return; 1792 } 1793 if (m_WordSize < MAX_WORD_BUFFER) { 1794 m_WordBuffer[m_WordSize++] = ch; 1795 } 1796 } 1797 } else if (ch == '<') { 1798 if (!GetNextChar(ch)) { 1799 return; 1800 } 1801 if (ch == '<') { 1802 m_WordBuffer[m_WordSize++] = ch; 1803 } else { 1804 m_Pos --; 1805 } 1806 } else if (ch == '>') { 1807 if (!GetNextChar(ch)) { 1808 return; 1809 } 1810 if (ch == '>') { 1811 m_WordBuffer[m_WordSize++] = ch; 1812 } else { 1813 m_Pos --; 1814 } 1815 } 1816 return; 1817 } 1818 while (1) { 1819 if (m_WordSize < MAX_WORD_BUFFER) { 1820 m_WordBuffer[m_WordSize++] = ch; 1821 } 1822 if (type != 'N') { 1823 m_bIsNumber = FALSE; 1824 } 1825 if (!GetNextChar(ch)) { 1826 return; 1827 } 1828 type = _PDF_CharType[ch]; 1829 if (type == 'D' || type == 'W') { 1830 m_Pos --; 1831 break; 1832 } 1833 } 1834 } 1835 CFX_ByteString CPDF_SyntaxParser::ReadString() 1836 { 1837 FX_BYTE ch; 1838 if (!GetNextChar(ch)) { 1839 return CFX_ByteString(); 1840 } 1841 CFX_ByteTextBuf buf; 1842 FX_INT32 parlevel = 0; 1843 FX_INT32 status = 0, iEscCode = 0; 1844 while (1) { 1845 switch (status) { 1846 case 0: 1847 if (ch == ')') { 1848 if (parlevel == 0) { 1849 return buf.GetByteString(); 1850 } 1851 parlevel --; 1852 buf.AppendChar(')'); 1853 } else if (ch == '(') { 1854 parlevel ++; 1855 buf.AppendChar('('); 1856 } else if (ch == '\\') { 1857 status = 1; 1858 } else { 1859 buf.AppendChar(ch); 1860 } 1861 break; 1862 case 1: 1863 if (ch >= '0' && ch <= '7') { 1864 iEscCode = ch - '0'; 1865 status = 2; 1866 break; 1867 } 1868 if (ch == 'n') { 1869 buf.AppendChar('\n'); 1870 } else if (ch == 'r') { 1871 buf.AppendChar('\r'); 1872 } else if (ch == 't') { 1873 buf.AppendChar('\t'); 1874 } else if (ch == 'b') { 1875 buf.AppendChar('\b'); 1876 } else if (ch == 'f') { 1877 buf.AppendChar('\f'); 1878 } else if (ch == '\r') { 1879 status = 4; 1880 break; 1881 } else if (ch == '\n') { 1882 } else { 1883 buf.AppendChar(ch); 1884 } 1885 status = 0; 1886 break; 1887 case 2: 1888 if (ch >= '0' && ch <= '7') { 1889 iEscCode = iEscCode * 8 + ch - '0'; 1890 status = 3; 1891 } else { 1892 buf.AppendChar(iEscCode); 1893 status = 0; 1894 continue; 1895 } 1896 break; 1897 case 3: 1898 if (ch >= '0' && ch <= '7') { 1899 iEscCode = iEscCode * 8 + ch - '0'; 1900 buf.AppendChar(iEscCode); 1901 status = 0; 1902 } else { 1903 buf.AppendChar(iEscCode); 1904 status = 0; 1905 continue; 1906 } 1907 break; 1908 case 4: 1909 status = 0; 1910 if (ch != '\n') { 1911 continue; 1912 } 1913 break; 1914 } 1915 if (!GetNextChar(ch)) { 1916 break; 1917 } 1918 } 1919 GetNextChar(ch); 1920 return buf.GetByteString(); 1921 } 1922 CFX_ByteString CPDF_SyntaxParser::ReadHexString() 1923 { 1924 FX_BYTE ch; 1925 if (!GetNextChar(ch)) { 1926 return CFX_ByteString(); 1927 } 1928 CFX_BinaryBuf buf; 1929 FX_BOOL bFirst = TRUE; 1930 FX_BYTE code = 0; 1931 while (1) { 1932 if (ch == '>') { 1933 break; 1934 } 1935 if (ch >= '0' && ch <= '9') { 1936 if (bFirst) { 1937 code = (ch - '0') * 16; 1938 } else { 1939 code += ch - '0'; 1940 buf.AppendByte((FX_BYTE)code); 1941 } 1942 bFirst = !bFirst; 1943 } else if (ch >= 'A' && ch <= 'F') { 1944 if (bFirst) { 1945 code = (ch - 'A' + 10) * 16; 1946 } else { 1947 code += ch - 'A' + 10; 1948 buf.AppendByte((FX_BYTE)code); 1949 } 1950 bFirst = !bFirst; 1951 } else if (ch >= 'a' && ch <= 'f') { 1952 if (bFirst) { 1953 code = (ch - 'a' + 10) * 16; 1954 } else { 1955 code += ch - 'a' + 10; 1956 buf.AppendByte((FX_BYTE)code); 1957 } 1958 bFirst = !bFirst; 1959 } 1960 if (!GetNextChar(ch)) { 1961 break; 1962 } 1963 } 1964 if (!bFirst) { 1965 buf.AppendByte((FX_BYTE)code); 1966 } 1967 return buf.GetByteString(); 1968 } 1969 void CPDF_SyntaxParser::ToNextLine() 1970 { 1971 FX_BYTE ch; 1972 while (1) { 1973 if (!GetNextChar(ch)) { 1974 return; 1975 } 1976 if (ch == '\n') { 1977 return; 1978 } 1979 if (ch == '\r') { 1980 GetNextChar(ch); 1981 if (ch == '\n') { 1982 return; 1983 } else { 1984 m_Pos --; 1985 return; 1986 } 1987 } 1988 } 1989 } 1990 void CPDF_SyntaxParser::ToNextWord() 1991 { 1992 FX_BYTE ch; 1993 if (!GetNextChar(ch)) { 1994 return; 1995 } 1996 FX_BYTE type = _PDF_CharType[ch]; 1997 while (1) { 1998 while (type == 'W') { 1999 m_dwWordPos = m_Pos; 2000 if (!GetNextChar(ch)) { 2001 return; 2002 } 2003 type = _PDF_CharType[ch]; 2004 } 2005 if (ch != '%') { 2006 break; 2007 } 2008 while (1) { 2009 if (!GetNextChar(ch)) { 2010 return; 2011 } 2012 if (ch == '\r' || ch == '\n') { 2013 break; 2014 } 2015 } 2016 type = _PDF_CharType[ch]; 2017 } 2018 m_Pos --; 2019 } 2020 CFX_ByteString CPDF_SyntaxParser::GetNextWord(FX_BOOL& bIsNumber) 2021 { 2022 GetNextWord(); 2023 bIsNumber = m_bIsNumber; 2024 return CFX_ByteString((FX_LPCSTR)m_WordBuffer, m_WordSize); 2025 } 2026 CFX_ByteString CPDF_SyntaxParser::GetKeyword() 2027 { 2028 GetNextWord(); 2029 return CFX_ByteString((FX_LPCSTR)m_WordBuffer, m_WordSize); 2030 } 2031 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, FX_INT32 level, PARSE_CONTEXT* pContext, FX_BOOL bDecrypt) 2032 { 2033 if (level > _PARSER_OBJECT_LEVLE_) { 2034 return NULL; 2035 } 2036 FX_FILESIZE SavedPos = m_Pos; 2037 FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY); 2038 FX_BOOL bIsNumber; 2039 CFX_ByteString word = GetNextWord(bIsNumber); 2040 CPDF_Object* pRet = NULL; 2041 if (word.GetLength() == 0) { 2042 if (bTypeOnly) { 2043 return (CPDF_Object*)PDFOBJ_INVALID; 2044 } 2045 return NULL; 2046 } 2047 FX_FILESIZE wordOffset = m_Pos - word.GetLength(); 2048 if (bIsNumber) { 2049 FX_FILESIZE SavedPos = m_Pos; 2050 CFX_ByteString nextword = GetNextWord(bIsNumber); 2051 if (bIsNumber) { 2052 CFX_ByteString nextword2 = GetNextWord(bIsNumber); 2053 if (nextword2 == FX_BSTRC("R")) { 2054 FX_DWORD objnum = FXSYS_atoi(word); 2055 if (bTypeOnly) { 2056 return (CPDF_Object*)PDFOBJ_REFERENCE; 2057 } 2058 pRet = CPDF_Reference::Create(pObjList, objnum); 2059 return pRet; 2060 } else { 2061 m_Pos = SavedPos; 2062 if (bTypeOnly) { 2063 return (CPDF_Object*)PDFOBJ_NUMBER; 2064 } 2065 pRet = CPDF_Number::Create(word); 2066 return pRet; 2067 } 2068 } else { 2069 m_Pos = SavedPos; 2070 if (bTypeOnly) { 2071 return (CPDF_Object*)PDFOBJ_NUMBER; 2072 } 2073 pRet = CPDF_Number::Create(word); 2074 return pRet; 2075 } 2076 } 2077 if (word == FX_BSTRC("true") || word == FX_BSTRC("false")) { 2078 if (bTypeOnly) { 2079 return (CPDF_Object*)PDFOBJ_BOOLEAN; 2080 } 2081 pRet = CPDF_Boolean::Create(word == FX_BSTRC("true")); 2082 return pRet; 2083 } 2084 if (word == FX_BSTRC("null")) { 2085 if (bTypeOnly) { 2086 return (CPDF_Object*)PDFOBJ_NULL; 2087 } 2088 pRet = CPDF_Null::Create(); 2089 return pRet; 2090 } 2091 if (word == FX_BSTRC("(")) { 2092 if (bTypeOnly) { 2093 return (CPDF_Object*)PDFOBJ_STRING; 2094 } 2095 FX_FILESIZE SavedPos = m_Pos - 1; 2096 CFX_ByteString str = ReadString(); 2097 if (m_pCryptoHandler && bDecrypt) { 2098 m_pCryptoHandler->Decrypt(objnum, gennum, str); 2099 } 2100 pRet = CPDF_String::Create(str, FALSE); 2101 return pRet; 2102 } 2103 if (word == FX_BSTRC("<")) { 2104 if (bTypeOnly) { 2105 return (CPDF_Object*)PDFOBJ_STRING; 2106 } 2107 FX_FILESIZE SavedPos = m_Pos - 1; 2108 CFX_ByteString str = ReadHexString(); 2109 if (m_pCryptoHandler && bDecrypt) { 2110 m_pCryptoHandler->Decrypt(objnum, gennum, str); 2111 } 2112 pRet = CPDF_String::Create(str, TRUE); 2113 return pRet; 2114 } 2115 if (word == FX_BSTRC("[")) { 2116 if (bTypeOnly) { 2117 return (CPDF_Object*)PDFOBJ_ARRAY; 2118 } 2119 CPDF_Array* pArray = CPDF_Array::Create(); 2120 FX_FILESIZE firstPos = m_Pos - 1; 2121 while (1) { 2122 FX_FILESIZE SavedPos = m_Pos; 2123 CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, level + 1); 2124 if (pObj == NULL) { 2125 return pArray; 2126 } 2127 pArray->Add(pObj); 2128 } 2129 } 2130 if (word[0] == '/') { 2131 if (bTypeOnly) { 2132 return (CPDF_Object*)PDFOBJ_NAME; 2133 } 2134 pRet = CPDF_Name::Create(PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1))); 2135 return pRet; 2136 } 2137 if (word == FX_BSTRC("<<")) { 2138 FX_FILESIZE saveDictOffset = m_Pos - 2; 2139 FX_DWORD dwDictSize = 0; 2140 if (bTypeOnly) { 2141 return (CPDF_Object*)PDFOBJ_DICTIONARY; 2142 } 2143 if (pContext) { 2144 pContext->m_DictStart = SavedPos; 2145 } 2146 CPDF_Dictionary* pDict = CPDF_Dictionary::Create(); 2147 FX_INT32 nKeys = 0; 2148 FX_FILESIZE dwSignValuePos = 0; 2149 while (1) { 2150 FX_BOOL bIsNumber; 2151 CFX_ByteString key = GetNextWord(bIsNumber); 2152 if (key.IsEmpty()) { 2153 pDict->Release(); 2154 return NULL; 2155 } 2156 FX_FILESIZE SavedPos = m_Pos - key.GetLength(); 2157 if (key == FX_BSTRC(">>")) { 2158 dwDictSize = m_Pos - saveDictOffset; 2159 break; 2160 } 2161 if (key == FX_BSTRC("endobj")) { 2162 dwDictSize = m_Pos - 6 - saveDictOffset; 2163 m_Pos = SavedPos; 2164 break; 2165 } 2166 if (key[0] != '/') { 2167 continue; 2168 } 2169 nKeys ++; 2170 key = PDF_NameDecode(key); 2171 if (key == FX_BSTRC("/Contents")) { 2172 dwSignValuePos = m_Pos; 2173 } 2174 CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, level + 1); 2175 if (pObj == NULL) { 2176 continue; 2177 } 2178 if (key.GetLength() == 1) { 2179 pDict->SetAt(CFX_ByteStringC(((FX_LPCSTR)key) + 1, key.GetLength() - 1), pObj); 2180 } else { 2181 if (nKeys < 32) { 2182 pDict->SetAt(CFX_ByteStringC(((FX_LPCSTR)key) + 1, key.GetLength() - 1), pObj); 2183 } else { 2184 pDict->AddValue(CFX_ByteStringC(((FX_LPCSTR)key) + 1, key.GetLength() - 1), pObj); 2185 } 2186 } 2187 } 2188 if (IsSignatureDict(pDict)) { 2189 FX_FILESIZE dwSavePos = m_Pos; 2190 m_Pos = dwSignValuePos; 2191 CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, level + 1, NULL, FALSE); 2192 pDict->SetAt(FX_BSTRC("Contents"), pObj); 2193 m_Pos = dwSavePos; 2194 } 2195 if (pContext) { 2196 pContext->m_DictEnd = m_Pos; 2197 if (pContext->m_Flags & PDFPARSE_NOSTREAM) { 2198 return pDict; 2199 } 2200 } 2201 FX_FILESIZE SavedPos = m_Pos; 2202 FX_BOOL bIsNumber; 2203 CFX_ByteString nextword = GetNextWord(bIsNumber); 2204 if (nextword == FX_BSTRC("stream")) { 2205 CPDF_Stream* pStream = ReadStream(pDict, pContext, objnum, gennum); 2206 if (pStream) { 2207 return pStream; 2208 } 2209 pDict->Release(); 2210 return NULL; 2211 } else { 2212 m_Pos = SavedPos; 2213 return pDict; 2214 } 2215 } 2216 if (word == FX_BSTRC(">>")) { 2217 m_Pos = SavedPos; 2218 return NULL; 2219 } 2220 if (bTypeOnly) { 2221 return (CPDF_Object*)PDFOBJ_INVALID; 2222 } 2223 return NULL; 2224 } 2225 CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, 2226 FX_INT32 level, struct PARSE_CONTEXT* pContext) 2227 { 2228 if (level > _PARSER_OBJECT_LEVLE_) { 2229 return NULL; 2230 } 2231 FX_FILESIZE SavedPos = m_Pos; 2232 FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY); 2233 FX_BOOL bIsNumber; 2234 CFX_ByteString word = GetNextWord(bIsNumber); 2235 if (word.GetLength() == 0) { 2236 if (bTypeOnly) { 2237 return (CPDF_Object*)PDFOBJ_INVALID; 2238 } 2239 return NULL; 2240 } 2241 if (bIsNumber) { 2242 FX_FILESIZE SavedPos = m_Pos; 2243 CFX_ByteString nextword = GetNextWord(bIsNumber); 2244 if (bIsNumber) { 2245 CFX_ByteString nextword2 = GetNextWord(bIsNumber); 2246 if (nextword2 == FX_BSTRC("R")) { 2247 FX_DWORD objnum = FXSYS_atoi(word); 2248 if (bTypeOnly) { 2249 return (CPDF_Object*)PDFOBJ_REFERENCE; 2250 } 2251 return CPDF_Reference::Create(pObjList, objnum); 2252 } else { 2253 m_Pos = SavedPos; 2254 if (bTypeOnly) { 2255 return (CPDF_Object*)PDFOBJ_NUMBER; 2256 } 2257 return CPDF_Number::Create(word); 2258 } 2259 } else { 2260 m_Pos = SavedPos; 2261 if (bTypeOnly) { 2262 return (CPDF_Object*)PDFOBJ_NUMBER; 2263 } 2264 return CPDF_Number::Create(word); 2265 } 2266 } 2267 if (word == FX_BSTRC("true") || word == FX_BSTRC("false")) { 2268 if (bTypeOnly) { 2269 return (CPDF_Object*)PDFOBJ_BOOLEAN; 2270 } 2271 return CPDF_Boolean::Create(word == FX_BSTRC("true")); 2272 } 2273 if (word == FX_BSTRC("null")) { 2274 if (bTypeOnly) { 2275 return (CPDF_Object*)PDFOBJ_NULL; 2276 } 2277 return CPDF_Null::Create(); 2278 } 2279 if (word == FX_BSTRC("(")) { 2280 if (bTypeOnly) { 2281 return (CPDF_Object*)PDFOBJ_STRING; 2282 } 2283 CFX_ByteString str = ReadString(); 2284 if (m_pCryptoHandler) { 2285 m_pCryptoHandler->Decrypt(objnum, gennum, str); 2286 } 2287 return CPDF_String::Create(str, FALSE); 2288 } 2289 if (word == FX_BSTRC("<")) { 2290 if (bTypeOnly) { 2291 return (CPDF_Object*)PDFOBJ_STRING; 2292 } 2293 CFX_ByteString str = ReadHexString(); 2294 if (m_pCryptoHandler) { 2295 m_pCryptoHandler->Decrypt(objnum, gennum, str); 2296 } 2297 return CPDF_String::Create(str, TRUE); 2298 } 2299 if (word == FX_BSTRC("[")) { 2300 if (bTypeOnly) { 2301 return (CPDF_Object*)PDFOBJ_ARRAY; 2302 } 2303 CPDF_Array* pArray = CPDF_Array::Create(); 2304 while (1) { 2305 CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, level + 1); 2306 if (pObj == NULL) { 2307 if (m_WordBuffer[0] == ']') { 2308 return pArray; 2309 } 2310 pArray->Release(); 2311 return NULL; 2312 } 2313 pArray->Add(pObj); 2314 } 2315 } 2316 if (word[0] == '/') { 2317 if (bTypeOnly) { 2318 return (CPDF_Object*)PDFOBJ_NAME; 2319 } 2320 return CPDF_Name::Create(PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1))); 2321 } 2322 if (word == FX_BSTRC("<<")) { 2323 if (bTypeOnly) { 2324 return (CPDF_Object*)PDFOBJ_DICTIONARY; 2325 } 2326 if (pContext) { 2327 pContext->m_DictStart = SavedPos; 2328 } 2329 CPDF_Dictionary* pDict = CPDF_Dictionary::Create(); 2330 while (1) { 2331 FX_BOOL bIsNumber; 2332 FX_FILESIZE SavedPos = m_Pos; 2333 CFX_ByteString key = GetNextWord(bIsNumber); 2334 if (key.IsEmpty()) { 2335 pDict->Release(); 2336 return NULL; 2337 } 2338 if (key == FX_BSTRC(">>")) { 2339 break; 2340 } 2341 if (key == FX_BSTRC("endobj")) { 2342 m_Pos = SavedPos; 2343 break; 2344 } 2345 if (key[0] != '/') { 2346 continue; 2347 } 2348 key = PDF_NameDecode(key); 2349 CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, level + 1); 2350 if (pObj == NULL) { 2351 pDict->Release(); 2352 FX_BYTE ch; 2353 while (1) { 2354 if (!GetNextChar(ch)) { 2355 break; 2356 } 2357 if (ch == 0x0A || ch == 0x0D) { 2358 break; 2359 } 2360 } 2361 return NULL; 2362 } 2363 if (key.GetLength() == 1) { 2364 pDict->SetAt(CFX_ByteStringC(((FX_LPCSTR)key) + 1, key.GetLength() - 1), pObj); 2365 } else { 2366 pDict->AddValue(CFX_ByteStringC(((FX_LPCSTR)key) + 1, key.GetLength() - 1), pObj); 2367 } 2368 } 2369 if (pContext) { 2370 pContext->m_DictEnd = m_Pos; 2371 if (pContext->m_Flags & PDFPARSE_NOSTREAM) { 2372 return pDict; 2373 } 2374 } 2375 FX_FILESIZE SavedPos = m_Pos; 2376 FX_BOOL bIsNumber; 2377 CFX_ByteString nextword = GetNextWord(bIsNumber); 2378 if (nextword == FX_BSTRC("stream")) { 2379 CPDF_Stream* pStream = ReadStream(pDict, pContext, objnum, gennum); 2380 if (pStream) { 2381 return pStream; 2382 } 2383 pDict->Release(); 2384 return NULL; 2385 } else { 2386 m_Pos = SavedPos; 2387 return pDict; 2388 } 2389 } 2390 if (word == FX_BSTRC(">>")) { 2391 m_Pos = SavedPos; 2392 return NULL; 2393 } 2394 if (bTypeOnly) { 2395 return (CPDF_Object*)PDFOBJ_INVALID; 2396 } 2397 return NULL; 2398 } 2399 CPDF_Stream* CPDF_SyntaxParser::ReadStream(CPDF_Dictionary* pDict, PARSE_CONTEXT* pContext, 2400 FX_DWORD objnum, FX_DWORD gennum) 2401 { 2402 CPDF_Object* pLenObj = pDict->GetElement(FX_BSTRC("Length")); 2403 FX_DWORD len = 0; 2404 if (pLenObj && (pLenObj->GetType() != PDFOBJ_REFERENCE || 2405 ((((CPDF_Reference*)pLenObj)->GetObjList() != NULL) && 2406 ((CPDF_Reference*)pLenObj)->GetRefObjNum() != objnum))) { 2407 FX_FILESIZE pos = m_Pos; 2408 if (pLenObj) { 2409 len = pLenObj->GetInteger(); 2410 } 2411 m_Pos = pos; 2412 if (len > 0x40000000) { 2413 return NULL; 2414 } 2415 } 2416 ToNextLine(); 2417 FX_FILESIZE StreamStartPos = m_Pos; 2418 if (pContext) { 2419 pContext->m_DataStart = m_Pos; 2420 } 2421 m_Pos += len; 2422 CPDF_CryptoHandler* pCryptoHandler = objnum == (FX_DWORD)m_MetadataObjnum ? NULL : m_pCryptoHandler; 2423 if (pCryptoHandler == NULL) { 2424 FX_FILESIZE SavedPos = m_Pos; 2425 GetNextWord(); 2426 if (m_WordSize < 9 || FXSYS_memcmp32(m_WordBuffer, "endstream", 9)) { 2427 m_Pos = StreamStartPos; 2428 FX_FILESIZE offset = FindTag(FX_BSTRC("endstream"), 0); 2429 if (offset >= 0) { 2430 FX_FILESIZE curPos = m_Pos; 2431 m_Pos = StreamStartPos; 2432 FX_FILESIZE endobjOffset = FindTag(FX_BSTRC("endobj"), 0); 2433 if (endobjOffset < offset && endobjOffset >= 0) { 2434 offset = endobjOffset; 2435 } else { 2436 m_Pos = curPos; 2437 } 2438 FX_BYTE byte1, byte2; 2439 GetCharAt(StreamStartPos + offset - 1, byte1); 2440 GetCharAt(StreamStartPos + offset - 2, byte2); 2441 if (byte1 == 0x0a && byte2 == 0x0d) { 2442 len -= 2; 2443 } else if (byte1 == 0x0a || byte1 == 0x0d) { 2444 len --; 2445 } 2446 len = (FX_DWORD)offset; 2447 pDict->SetAtInteger(FX_BSTRC("Length"), len); 2448 } else { 2449 m_Pos = StreamStartPos; 2450 if (FindTag(FX_BSTRC("endobj"), 0) < 0) { 2451 return NULL; 2452 } 2453 } 2454 } 2455 } 2456 m_Pos = StreamStartPos; 2457 CPDF_Stream* pStream; 2458 #if defined(_FPDFAPI_MINI_) && !defined(_FXCORE_FEATURE_ALL_) 2459 pStream = FX_NEW CPDF_Stream(m_pFileAccess, pCryptoHandler, m_HeaderOffset + m_Pos, len, pDict, gennum); 2460 m_Pos += len; 2461 #else 2462 FX_LPBYTE pData = FX_Alloc(FX_BYTE, len); 2463 if (!pData) { 2464 return NULL; 2465 } 2466 ReadBlock(pData, len); 2467 if (pCryptoHandler) { 2468 CFX_BinaryBuf dest_buf; 2469 dest_buf.EstimateSize(pCryptoHandler->DecryptGetSize(len)); 2470 FX_LPVOID context = pCryptoHandler->DecryptStart(objnum, gennum); 2471 pCryptoHandler->DecryptStream(context, pData, len, dest_buf); 2472 pCryptoHandler->DecryptFinish(context, dest_buf); 2473 FX_Free(pData); 2474 pData = dest_buf.GetBuffer(); 2475 len = dest_buf.GetSize(); 2476 dest_buf.DetachBuffer(); 2477 } 2478 pStream = FX_NEW CPDF_Stream(pData, len, pDict); 2479 #endif 2480 if (pContext) { 2481 pContext->m_DataEnd = pContext->m_DataStart + len; 2482 } 2483 StreamStartPos = m_Pos; 2484 GetNextWord(); 2485 if (m_WordSize == 6 && 0 == FXSYS_memcmp32(m_WordBuffer, "endobj", 6)) { 2486 m_Pos = StreamStartPos; 2487 } 2488 return pStream; 2489 } 2490 void CPDF_SyntaxParser::InitParser(IFX_FileRead* pFileAccess, FX_DWORD HeaderOffset) 2491 { 2492 if (m_pFileBuf) { 2493 FX_Free(m_pFileBuf); 2494 m_pFileBuf = NULL; 2495 } 2496 m_pFileBuf = FX_Alloc(FX_BYTE, m_BufSize); 2497 m_HeaderOffset = HeaderOffset; 2498 m_FileLen = pFileAccess->GetSize(); 2499 m_Pos = 0; 2500 m_pFileAccess = pFileAccess; 2501 m_BufOffset = 0; 2502 pFileAccess->ReadBlock(m_pFileBuf, 0, (size_t)((FX_FILESIZE)m_BufSize > m_FileLen ? m_FileLen : m_BufSize)); 2503 } 2504 FX_INT32 CPDF_SyntaxParser::GetDirectNum() 2505 { 2506 GetNextWord(); 2507 if (!m_bIsNumber) { 2508 return 0; 2509 } 2510 m_WordBuffer[m_WordSize] = 0; 2511 return FXSYS_atoi((FX_LPCSTR)m_WordBuffer); 2512 } 2513 FX_BOOL CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, FX_LPCBYTE tag, FX_DWORD taglen) 2514 { 2515 FX_BYTE type = _PDF_CharType[tag[0]]; 2516 FX_BOOL bCheckLeft = type != 'D' && type != 'W'; 2517 type = _PDF_CharType[tag[taglen - 1]]; 2518 FX_BOOL bCheckRight = type != 'D' || type != 'W'; 2519 FX_BYTE ch; 2520 if (bCheckRight && startpos + (FX_INT32)taglen <= limit && GetCharAt(startpos + (FX_INT32)taglen, ch)) { 2521 FX_BYTE type = _PDF_CharType[ch]; 2522 if (type == 'N' || type == 'R') { 2523 return FALSE; 2524 } 2525 } 2526 if (bCheckLeft && startpos > 0 && GetCharAt(startpos - 1, ch)) { 2527 FX_BYTE type = _PDF_CharType[ch]; 2528 if (type == 'N' || type == 'R') { 2529 return FALSE; 2530 } 2531 } 2532 return TRUE; 2533 } 2534 FX_BOOL CPDF_SyntaxParser::SearchWord(FX_BSTR tag, FX_BOOL bWholeWord, FX_BOOL bForward, FX_FILESIZE limit) 2535 { 2536 FX_INT32 taglen = tag.GetLength(); 2537 if (taglen == 0) { 2538 return FALSE; 2539 } 2540 FX_FILESIZE pos = m_Pos; 2541 FX_INT32 offset = 0; 2542 if (!bForward) { 2543 offset = taglen - 1; 2544 } 2545 FX_LPCBYTE tag_data = tag; 2546 FX_BYTE byte; 2547 while (1) { 2548 if (bForward) { 2549 if (limit) { 2550 if (pos >= m_Pos + limit) { 2551 return FALSE; 2552 } 2553 } 2554 if (!GetCharAt(pos, byte)) { 2555 return FALSE; 2556 } 2557 } else { 2558 if (limit) { 2559 if (pos <= m_Pos - limit) { 2560 return FALSE; 2561 } 2562 } 2563 if (!GetCharAtBackward(pos, byte)) { 2564 return FALSE; 2565 } 2566 } 2567 if (byte == tag_data[offset]) { 2568 if (bForward) { 2569 offset ++; 2570 if (offset < taglen) { 2571 pos ++; 2572 continue; 2573 } 2574 } else { 2575 offset --; 2576 if (offset >= 0) { 2577 pos --; 2578 continue; 2579 } 2580 } 2581 FX_FILESIZE startpos = bForward ? pos - taglen + 1 : pos; 2582 if (!bWholeWord || IsWholeWord(startpos, limit, tag, taglen)) { 2583 m_Pos = startpos; 2584 return TRUE; 2585 } 2586 } 2587 if (bForward) { 2588 offset = byte == tag_data[0] ? 1 : 0; 2589 pos ++; 2590 } else { 2591 offset = byte == tag_data[taglen - 1] ? taglen - 2 : taglen - 1; 2592 pos --; 2593 } 2594 if (pos < 0) { 2595 return FALSE; 2596 } 2597 } 2598 return FALSE; 2599 } 2600 struct _SearchTagRecord { 2601 FX_LPCBYTE m_pTag; 2602 FX_DWORD m_Len; 2603 FX_DWORD m_Offset; 2604 }; 2605 FX_INT32 CPDF_SyntaxParser::SearchMultiWord(FX_BSTR tags, FX_BOOL bWholeWord, FX_FILESIZE limit) 2606 { 2607 FX_INT32 ntags = 1, i; 2608 for (i = 0; i < tags.GetLength(); i ++) 2609 if (tags[i] == 0) { 2610 ntags ++; 2611 } 2612 _SearchTagRecord* pPatterns = FX_Alloc(_SearchTagRecord, ntags); 2613 FX_DWORD start = 0, itag = 0, max_len = 0; 2614 for (i = 0; i <= tags.GetLength(); i ++) { 2615 if (tags[i] == 0) { 2616 FX_DWORD len = i - start; 2617 if (len > max_len) { 2618 max_len = len; 2619 } 2620 pPatterns[itag].m_pTag = tags.GetPtr() + start; 2621 pPatterns[itag].m_Len = len; 2622 pPatterns[itag].m_Offset = 0; 2623 start = i + 1; 2624 itag ++; 2625 } 2626 } 2627 FX_FILESIZE pos = m_Pos; 2628 FX_BYTE byte; 2629 GetCharAt(pos++, byte); 2630 FX_INT32 found = -1; 2631 while (1) { 2632 for (i = 0; i < ntags; i ++) { 2633 if (pPatterns[i].m_pTag[pPatterns[i].m_Offset] == byte) { 2634 pPatterns[i].m_Offset ++; 2635 if (pPatterns[i].m_Offset == pPatterns[i].m_Len) { 2636 if (!bWholeWord || IsWholeWord(pos - pPatterns[i].m_Len, limit, pPatterns[i].m_pTag, pPatterns[i].m_Len)) { 2637 found = i; 2638 goto end; 2639 } else { 2640 if (pPatterns[i].m_pTag[0] == byte) { 2641 pPatterns[i].m_Offset = 1; 2642 } else { 2643 pPatterns[i].m_Offset = 0; 2644 } 2645 } 2646 } 2647 } else { 2648 if (pPatterns[i].m_pTag[0] == byte) { 2649 pPatterns[i].m_Offset = 1; 2650 } else { 2651 pPatterns[i].m_Offset = 0; 2652 } 2653 } 2654 } 2655 if (limit && pos >= m_Pos + limit) { 2656 goto end; 2657 } 2658 if (!GetCharAt(pos, byte)) { 2659 goto end; 2660 } 2661 pos ++; 2662 } 2663 end: 2664 FX_Free(pPatterns); 2665 return found; 2666 } 2667 FX_FILESIZE CPDF_SyntaxParser::FindTag(FX_BSTR tag, FX_FILESIZE limit) 2668 { 2669 FX_INT32 taglen = tag.GetLength(); 2670 FX_INT32 match = 0; 2671 limit += m_Pos; 2672 FX_FILESIZE startpos = m_Pos; 2673 while (1) { 2674 FX_BYTE ch; 2675 if (!GetNextChar(ch)) { 2676 return -1; 2677 } 2678 if (ch == tag[match]) { 2679 match ++; 2680 if (match == taglen) { 2681 return m_Pos - startpos - taglen; 2682 } 2683 } else { 2684 match = ch == tag[0] ? 1 : 0; 2685 } 2686 if (limit && m_Pos == limit) { 2687 return -1; 2688 } 2689 } 2690 return -1; 2691 } 2692 void CPDF_SyntaxParser::GetBinary(FX_BYTE* buffer, FX_DWORD size) 2693 { 2694 FX_DWORD offset = 0; 2695 FX_BYTE ch; 2696 while (1) { 2697 if (!GetNextChar(ch)) { 2698 return; 2699 } 2700 buffer[offset++] = ch; 2701 if (offset == size) { 2702 break; 2703 } 2704 } 2705 } 2706 CPDF_DataAvail::CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead) 2707 { 2708 m_pFileAvail = pFileAvail; 2709 m_pFileRead = pFileRead; 2710 m_Pos = 0; 2711 m_dwFileLen = 0; 2712 if (m_pFileRead) { 2713 m_dwFileLen = (FX_DWORD)m_pFileRead->GetSize(); 2714 } 2715 m_dwCurrentOffset = 0; 2716 m_WordSize = 0; 2717 m_dwXRefOffset = 0; 2718 m_bufferOffset = 0; 2719 m_dwFirstPageNo = 0; 2720 m_bufferSize = 0; 2721 m_PagesObjNum = 0; 2722 m_dwCurrentXRefSteam = 0; 2723 m_dwAcroFormObjNum = 0; 2724 m_dwInfoObjNum = 0; 2725 m_pDocument = 0; 2726 m_dwEncryptObjNum = 0; 2727 m_dwPrevXRefOffset = 0; 2728 m_dwLastXRefOffset = 0; 2729 m_bDocAvail = FALSE; 2730 m_bMainXRefLoad = FALSE; 2731 m_bDocAvail = FALSE; 2732 m_bLinearized = FALSE; 2733 m_bPagesLoad = FALSE; 2734 m_bPagesTreeLoad = FALSE; 2735 m_bMainXRefLoadedOK = FALSE; 2736 m_bAnnotsLoad = FALSE; 2737 m_bHaveAcroForm = FALSE; 2738 m_bAcroFormLoad = FALSE; 2739 m_bPageLoadedOK = FALSE; 2740 m_bNeedDownLoadResource = FALSE; 2741 m_bLinearizedFormParamLoad = FALSE; 2742 m_pLinearized = NULL; 2743 m_pRoot = NULL; 2744 m_pTrailer = NULL; 2745 m_pCurrentParser = NULL; 2746 m_pAcroForm = NULL; 2747 m_pPageDict = NULL; 2748 m_pPageResource = NULL; 2749 m_pageMapCheckState = NULL; 2750 m_docStatus = PDF_DATAAVAIL_HEADER; 2751 m_parser.m_bOwnFileRead = FALSE; 2752 m_bTotalLoadPageTree = FALSE; 2753 m_bCurPageDictLoadOK = FALSE; 2754 m_bLinearedDataOK = FALSE; 2755 m_pagesLoadState = NULL; 2756 } 2757 CPDF_DataAvail::~CPDF_DataAvail() 2758 { 2759 if (m_pLinearized) { 2760 m_pLinearized->Release(); 2761 } 2762 if (m_pRoot) { 2763 m_pRoot->Release(); 2764 } 2765 if (m_pTrailer) { 2766 m_pTrailer->Release(); 2767 } 2768 if (m_pageMapCheckState) { 2769 delete m_pageMapCheckState; 2770 } 2771 if (m_pagesLoadState) { 2772 delete m_pagesLoadState; 2773 } 2774 FX_INT32 i = 0; 2775 FX_INT32 iSize = m_arrayAcroforms.GetSize(); 2776 for (i = 0; i < iSize; ++i) { 2777 ((CPDF_Object *)m_arrayAcroforms.GetAt(i))->Release(); 2778 } 2779 } 2780 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) 2781 { 2782 m_pDocument = pDoc; 2783 } 2784 FX_DWORD CPDF_DataAvail::GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset) 2785 { 2786 CPDF_Parser *pParser = (CPDF_Parser *)(m_pDocument->GetParser()); 2787 if (pParser == NULL) { 2788 return 0; 2789 } 2790 if (objnum >= (FX_DWORD)pParser->m_CrossRef.GetSize()) { 2791 return 0; 2792 } 2793 if (pParser->m_V5Type[objnum] == 2) { 2794 objnum = (FX_DWORD)pParser->m_CrossRef[objnum]; 2795 } 2796 if (pParser->m_V5Type[objnum] == 1 || pParser->m_V5Type[objnum] == 255) { 2797 offset = pParser->m_CrossRef[objnum]; 2798 if (offset == 0) { 2799 return 0; 2800 } 2801 FX_LPVOID pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(), pParser->m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 2802 if (pResult == NULL) { 2803 return 0; 2804 } 2805 if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)pParser->m_SortedOffset.GetData() == pParser->m_SortedOffset.GetSize() - 1) { 2806 return 0; 2807 } 2808 return (FX_DWORD)(((FX_FILESIZE*)pResult)[1] - offset); 2809 } 2810 return 0; 2811 } 2812 FX_BOOL CPDF_DataAvail::IsObjectsAvail(CFX_PtrArray& obj_array, FX_BOOL bParsePage, IFX_DownloadHints* pHints, CFX_PtrArray &ret_array) 2813 { 2814 if (!obj_array.GetSize()) { 2815 return TRUE; 2816 } 2817 FX_DWORD count = 0; 2818 CFX_PtrArray new_obj_array; 2819 FX_INT32 i = 0; 2820 for (i = 0; i < obj_array.GetSize(); i++) { 2821 CPDF_Object *pObj = (CPDF_Object *)obj_array[i]; 2822 if (!pObj) { 2823 continue; 2824 } 2825 FX_INT32 type = pObj->GetType(); 2826 switch (type) { 2827 case PDFOBJ_ARRAY: { 2828 CPDF_Array *pArray = pObj->GetArray(); 2829 for (FX_DWORD k = 0; k < pArray->GetCount(); k++) { 2830 new_obj_array.Add(pArray->GetElement(k)); 2831 } 2832 } 2833 break; 2834 case PDFOBJ_STREAM: 2835 pObj = pObj->GetDict(); 2836 case PDFOBJ_DICTIONARY: { 2837 CPDF_Dictionary *pDict = pObj->GetDict(); 2838 if (pDict->GetString("Type") == "Page" && !bParsePage) { 2839 continue; 2840 } 2841 FX_POSITION pos = pDict->GetStartPos(); 2842 while (pos) { 2843 CPDF_Object *value; 2844 CFX_ByteString key; 2845 value = pDict->GetNextElement(pos, key); 2846 if (key != "Parent") { 2847 new_obj_array.Add(value); 2848 } 2849 } 2850 } 2851 break; 2852 case PDFOBJ_REFERENCE: { 2853 CPDF_Reference *pRef = (CPDF_Reference*)pObj; 2854 FX_DWORD dwNum = pRef->GetRefObjNum(); 2855 FX_FILESIZE offset; 2856 FX_DWORD size = GetObjectSize(pRef->GetRefObjNum(), offset); 2857 if (!size) { 2858 break; 2859 } 2860 size = (FX_DWORD)((FX_FILESIZE)(offset + size + 512) > m_dwFileLen ? m_dwFileLen - offset : size + 512); 2861 if (!m_pFileAvail->IsDataAvail(offset, size)) { 2862 pHints->AddSegment(offset, size); 2863 ret_array.Add(pObj); 2864 count++; 2865 } else if (!m_objnum_array.Find(dwNum)) { 2866 m_objnum_array.AddObjNum(dwNum); 2867 CPDF_Object *pReferred = m_pDocument->GetIndirectObject(pRef->GetRefObjNum(), NULL); 2868 if (pReferred) { 2869 new_obj_array.Add(pReferred); 2870 } 2871 } 2872 } 2873 break; 2874 } 2875 } 2876 if (count > 0) { 2877 FX_INT32 iSize = new_obj_array.GetSize(); 2878 for (i = 0; i < iSize; ++i) { 2879 CPDF_Object *pObj = (CPDF_Object *)new_obj_array[i]; 2880 FX_INT32 type = pObj->GetType(); 2881 if (type == PDFOBJ_REFERENCE) { 2882 CPDF_Reference *pRef = (CPDF_Reference *)pObj; 2883 FX_DWORD dwNum = pRef->GetRefObjNum(); 2884 if (!m_objnum_array.Find(dwNum)) { 2885 ret_array.Add(pObj); 2886 } 2887 } else { 2888 ret_array.Add(pObj); 2889 } 2890 } 2891 return FALSE; 2892 } 2893 obj_array.RemoveAll(); 2894 obj_array.Append(new_obj_array); 2895 return IsObjectsAvail(obj_array, FALSE, pHints, ret_array); 2896 } 2897 FX_BOOL CPDF_DataAvail::IsDocAvail(IFX_DownloadHints* pHints) 2898 { 2899 if (!m_dwFileLen && m_pFileRead) { 2900 m_dwFileLen = (FX_DWORD)m_pFileRead->GetSize(); 2901 if (!m_dwFileLen) { 2902 return TRUE; 2903 } 2904 } 2905 while (!m_bDocAvail) { 2906 if (!CheckDocStatus(pHints)) { 2907 return FALSE; 2908 } 2909 } 2910 return TRUE; 2911 } 2912 FX_BOOL CPDF_DataAvail::CheckAcroFormSubObject(IFX_DownloadHints* pHints) 2913 { 2914 if (!m_objs_array.GetSize()) { 2915 m_objs_array.RemoveAll(); 2916 m_objnum_array.RemoveAll(); 2917 CFX_PtrArray obj_array; 2918 obj_array.Append(m_arrayAcroforms); 2919 FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array); 2920 if (bRet) { 2921 m_objs_array.RemoveAll(); 2922 } 2923 return bRet; 2924 } else { 2925 CFX_PtrArray new_objs_array; 2926 FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array); 2927 if (bRet) { 2928 FX_INT32 iSize = m_arrayAcroforms.GetSize(); 2929 for (FX_INT32 i = 0; i < iSize; ++i) { 2930 ((CPDF_Object *)m_arrayAcroforms.GetAt(i))->Release(); 2931 } 2932 m_arrayAcroforms.RemoveAll(); 2933 } else { 2934 m_objs_array.RemoveAll(); 2935 m_objs_array.Append(new_objs_array); 2936 } 2937 return bRet; 2938 } 2939 } 2940 FX_BOOL CPDF_DataAvail::CheckAcroForm(IFX_DownloadHints* pHints) 2941 { 2942 FX_BOOL bExist = FALSE; 2943 m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist); 2944 if (!bExist) { 2945 m_docStatus = PDF_DATAAVAIL_PAGETREE; 2946 return TRUE; 2947 } 2948 if (!m_pAcroForm) { 2949 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 2950 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 2951 return TRUE; 2952 } 2953 return FALSE; 2954 } 2955 m_arrayAcroforms.Add(m_pAcroForm); 2956 m_docStatus = PDF_DATAAVAIL_PAGETREE; 2957 return TRUE; 2958 } 2959 FX_BOOL CPDF_DataAvail::CheckDocStatus(IFX_DownloadHints *pHints) 2960 { 2961 switch (m_docStatus) { 2962 case PDF_DATAAVAIL_HEADER: 2963 return CheckHeader(pHints); 2964 case PDF_DATAAVAIL_FIRSTPAGE: 2965 case PDF_DATAAVAIL_FIRSTPAGE_PREPARE: 2966 return CheckFirstPage(pHints); 2967 case PDF_DATAAVAIL_END: 2968 return CheckEnd(pHints); 2969 case PDF_DATAAVAIL_CROSSREF: 2970 return CheckCrossRef(pHints); 2971 case PDF_DATAAVAIL_CROSSREF_ITEM: 2972 return CheckCrossRefItem(pHints); 2973 case PDF_DATAAVAIL_CROSSREF_STREAM: 2974 return CheckAllCrossRefStream(pHints); 2975 case PDF_DATAAVAIL_TRAILER: 2976 return CheckTrailer(pHints); 2977 case PDF_DATAAVAIL_TRAILER_APPEND: 2978 return CheckTrailerAppend(pHints); 2979 case PDF_DATAAVAIL_LOADALLCRSOSSREF: 2980 return LoadAllXref(pHints); 2981 case PDF_DATAAVAIL_LOADALLFILE: 2982 return LoadAllFile(pHints); 2983 case PDF_DATAAVAIL_ROOT: 2984 return CheckRoot(pHints); 2985 case PDF_DATAAVAIL_INFO: 2986 return CheckInfo(pHints); 2987 case PDF_DATAAVAIL_ACROFORM: 2988 return CheckAcroForm(pHints); 2989 case PDF_DATAAVAIL_PAGETREE: 2990 if (m_bTotalLoadPageTree) { 2991 return CheckPages(pHints); 2992 } else { 2993 return LoadDocPages(pHints); 2994 } 2995 case PDF_DATAAVAIL_PAGE: 2996 if (m_bTotalLoadPageTree) { 2997 return CheckPage(pHints); 2998 } else { 2999 m_docStatus = PDF_DATAAVAIL_PAGE_LATERLOAD; 3000 return TRUE; 3001 } 3002 case PDF_DATAAVAIL_ERROR: 3003 return LoadAllFile(pHints); 3004 case PDF_DATAAVAIL_PAGE_LATERLOAD: 3005 m_docStatus = PDF_DATAAVAIL_PAGE; 3006 default: 3007 m_bDocAvail = TRUE; 3008 return TRUE; 3009 } 3010 } 3011 FX_BOOL CPDF_DataAvail::CheckPageStatus(IFX_DownloadHints* pHints) 3012 { 3013 switch (m_docStatus) { 3014 case PDF_DATAAVAIL_PAGETREE: 3015 return CheckPages(pHints); 3016 case PDF_DATAAVAIL_PAGE: 3017 return CheckPage(pHints); 3018 case PDF_DATAAVAIL_ERROR: 3019 return LoadAllFile(pHints); 3020 default: 3021 m_bPagesTreeLoad = TRUE; 3022 m_bPagesLoad = TRUE; 3023 return TRUE; 3024 } 3025 } 3026 FX_BOOL CPDF_DataAvail::LoadAllFile(IFX_DownloadHints* pHints) 3027 { 3028 if (m_pFileAvail->IsDataAvail(0, (FX_DWORD)m_dwFileLen)) { 3029 m_docStatus = PDF_DATAAVAIL_DONE; 3030 return TRUE; 3031 } 3032 pHints->AddSegment(0, (FX_DWORD)m_dwFileLen); 3033 return FALSE; 3034 } 3035 FX_BOOL CPDF_DataAvail::LoadAllXref(IFX_DownloadHints* pHints) 3036 { 3037 m_parser.m_Syntax.InitParser(m_pFileRead, (FX_DWORD)m_dwHeaderOffset); 3038 m_parser.m_bOwnFileRead = FALSE; 3039 if (!m_parser.LoadAllCrossRefV4(m_dwLastXRefOffset) && !m_parser.LoadAllCrossRefV5(m_dwLastXRefOffset)) { 3040 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3041 return FALSE; 3042 } 3043 FXSYS_qsort(m_parser.m_SortedOffset.GetData(), m_parser.m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize); 3044 m_dwRootObjNum = m_parser.GetRootObjNum(); 3045 m_dwInfoObjNum = m_parser.GetInfoObjNum(); 3046 m_pCurrentParser = &m_parser; 3047 m_docStatus = PDF_DATAAVAIL_ROOT; 3048 return TRUE; 3049 } 3050 CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, FX_BOOL *pExistInFile) 3051 { 3052 CPDF_Object *pRet = NULL; 3053 if (pExistInFile) { 3054 *pExistInFile = TRUE; 3055 } 3056 if (m_pDocument == NULL) { 3057 FX_FILESIZE offset = m_parser.GetObjectOffset(objnum); 3058 if (offset < 0) { 3059 *pExistInFile = FALSE; 3060 return NULL; 3061 } 3062 FX_DWORD size = (FX_DWORD)m_parser.GetObjectSize(objnum); 3063 size = (FX_DWORD)(((FX_FILESIZE)(offset + size + 512)) > m_dwFileLen ? m_dwFileLen - offset : size + 512); 3064 if (!m_pFileAvail->IsDataAvail(offset, size)) { 3065 pHints->AddSegment(offset, size); 3066 return NULL; 3067 } 3068 pRet = m_parser.ParseIndirectObject(NULL, objnum); 3069 if (!pRet && pExistInFile) { 3070 *pExistInFile = FALSE; 3071 } 3072 return pRet; 3073 } 3074 FX_FILESIZE offset; 3075 FX_DWORD size = GetObjectSize(objnum, offset); 3076 size = (FX_DWORD)((FX_FILESIZE)(offset + size + 512) > m_dwFileLen ? m_dwFileLen - offset : size + 512); 3077 if (!m_pFileAvail->IsDataAvail(offset, size)) { 3078 pHints->AddSegment(offset, size); 3079 return NULL; 3080 } 3081 CPDF_Parser *pParser = (CPDF_Parser *)(m_pDocument->GetParser()); 3082 pRet = pParser->ParseIndirectObject(NULL, objnum, NULL); 3083 if (!pRet && pExistInFile) { 3084 *pExistInFile = FALSE; 3085 } 3086 return pRet; 3087 } 3088 FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints) 3089 { 3090 FX_BOOL bExist = FALSE; 3091 CPDF_Object *pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist); 3092 if (!bExist) { 3093 if (m_bHaveAcroForm) { 3094 m_docStatus = PDF_DATAAVAIL_ACROFORM; 3095 } else { 3096 m_docStatus = PDF_DATAAVAIL_PAGETREE; 3097 } 3098 return TRUE; 3099 } 3100 if (!pInfo) { 3101 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3102 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3103 return TRUE; 3104 } 3105 if (m_Pos == m_dwFileLen) { 3106 m_docStatus = PDF_DATAAVAIL_ERROR; 3107 } 3108 return FALSE; 3109 } 3110 if (pInfo) { 3111 pInfo->Release(); 3112 } 3113 if (m_bHaveAcroForm) { 3114 m_docStatus = PDF_DATAAVAIL_ACROFORM; 3115 } else { 3116 m_docStatus = PDF_DATAAVAIL_PAGETREE; 3117 } 3118 return TRUE; 3119 } 3120 FX_BOOL CPDF_DataAvail::CheckRoot(IFX_DownloadHints* pHints) 3121 { 3122 FX_BOOL bExist = FALSE; 3123 m_pRoot = GetObject(m_dwRootObjNum, pHints, &bExist); 3124 if (!bExist) { 3125 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3126 return TRUE; 3127 } 3128 if (!m_pRoot) { 3129 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3130 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3131 return TRUE; 3132 } 3133 return FALSE; 3134 } 3135 CPDF_Reference* pRef = (CPDF_Reference*)m_pRoot->GetDict()->GetElement(FX_BSTRC("Pages")); 3136 if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) { 3137 m_docStatus = PDF_DATAAVAIL_ERROR; 3138 return FALSE; 3139 } 3140 m_PagesObjNum = pRef->GetRefObjNum(); 3141 CPDF_Reference* pAcroFormRef = (CPDF_Reference*)m_pRoot->GetDict()->GetElement(FX_BSTRC("AcroForm")); 3142 if (pAcroFormRef && pAcroFormRef->GetType() == PDFOBJ_REFERENCE) { 3143 m_bHaveAcroForm = TRUE; 3144 m_dwAcroFormObjNum = pAcroFormRef->GetRefObjNum(); 3145 } 3146 if (m_dwInfoObjNum) { 3147 m_docStatus = PDF_DATAAVAIL_INFO; 3148 } else { 3149 if (m_bHaveAcroForm) { 3150 m_docStatus = PDF_DATAAVAIL_ACROFORM; 3151 } else { 3152 m_docStatus = PDF_DATAAVAIL_PAGETREE; 3153 } 3154 } 3155 return TRUE; 3156 } 3157 FX_BOOL CPDF_DataAvail::PreparePageItem() 3158 { 3159 CPDF_Dictionary *pRoot = m_pDocument->GetRoot(); 3160 CPDF_Reference* pRef = (CPDF_Reference*)pRoot->GetElement(FX_BSTRC("Pages")); 3161 if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) { 3162 m_docStatus = PDF_DATAAVAIL_ERROR; 3163 return FALSE; 3164 } 3165 m_PagesObjNum = pRef->GetRefObjNum(); 3166 m_pCurrentParser = (CPDF_Parser *)m_pDocument->GetParser(); 3167 m_docStatus = PDF_DATAAVAIL_PAGETREE; 3168 return TRUE; 3169 } 3170 FX_BOOL CPDF_DataAvail::IsFirstCheck(int iPage) 3171 { 3172 if (NULL == m_pageMapCheckState) { 3173 m_pageMapCheckState = FX_NEW CFX_CMapDWordToDWord(); 3174 } 3175 FX_DWORD dwValue = 0; 3176 if (!m_pageMapCheckState->Lookup(iPage, dwValue)) { 3177 m_pageMapCheckState->SetAt(iPage, 1); 3178 return TRUE; 3179 } 3180 if (dwValue != 0) { 3181 return FALSE; 3182 } 3183 m_pageMapCheckState->SetAt(iPage, 1); 3184 return TRUE; 3185 } 3186 void CPDF_DataAvail::ResetFirstCheck(int iPage) 3187 { 3188 if (NULL == m_pageMapCheckState) { 3189 m_pageMapCheckState = FX_NEW CFX_CMapDWordToDWord(); 3190 } 3191 FX_DWORD dwValue = 1; 3192 if (!m_pageMapCheckState->Lookup(iPage, dwValue)) { 3193 return; 3194 } 3195 m_pageMapCheckState->SetAt(iPage, 0); 3196 } 3197 FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints) 3198 { 3199 FX_DWORD i = 0; 3200 FX_DWORD iLen = m_PageObjList.GetSize(); 3201 CFX_DWordArray UnavailObjList; 3202 for (; i < iLen; ++i) { 3203 FX_DWORD dwPageObjNum = m_PageObjList.GetAt(i); 3204 FX_BOOL bExist = FALSE; 3205 CPDF_Object *pObj = GetObject(dwPageObjNum, pHints, &bExist); 3206 if (!pObj) { 3207 if (bExist) { 3208 UnavailObjList.Add(dwPageObjNum); 3209 } 3210 continue; 3211 } 3212 if (pObj->GetType() == PDFOBJ_ARRAY) { 3213 CPDF_Array *pArray = pObj->GetArray(); 3214 if (pArray) { 3215 FX_INT32 iSize = pArray->GetCount(); 3216 CPDF_Object *pItem = NULL; 3217 for (FX_INT32 j = 0; j < iSize; ++j) { 3218 pItem = pArray->GetElement(j); 3219 if (pItem && pItem->GetType() == PDFOBJ_REFERENCE) { 3220 UnavailObjList.Add(((CPDF_Reference *)pItem)->GetRefObjNum()); 3221 } 3222 } 3223 } 3224 } 3225 if (pObj->GetType() != PDFOBJ_DICTIONARY) { 3226 pObj->Release(); 3227 continue; 3228 } 3229 CFX_ByteString type = pObj->GetDict()->GetString(FX_BSTRC("Type")); 3230 if (type == FX_BSTRC("Pages")) { 3231 m_PagesArray.Add(pObj); 3232 continue; 3233 } 3234 pObj->Release(); 3235 } 3236 m_PageObjList.RemoveAll(); 3237 if (UnavailObjList.GetSize()) { 3238 m_PageObjList.Append(UnavailObjList); 3239 return FALSE; 3240 } 3241 i = 0; 3242 iLen = m_PagesArray.GetSize(); 3243 for (; i < iLen; ++i) { 3244 CPDF_Object *pPages = (CPDF_Object *)m_PagesArray.GetAt(i); 3245 if (!pPages) { 3246 continue; 3247 } 3248 if (!GetPageKids(m_pCurrentParser, pPages)) { 3249 pPages->Release(); 3250 while (i++ < iLen) { 3251 pPages = (CPDF_Object *)m_PagesArray.GetAt(i); 3252 pPages->Release(); 3253 } 3254 m_PagesArray.RemoveAll(); 3255 m_docStatus = PDF_DATAAVAIL_ERROR; 3256 return FALSE; 3257 } 3258 pPages->Release(); 3259 } 3260 m_PagesArray.RemoveAll(); 3261 if (!m_PageObjList.GetSize()) { 3262 m_docStatus = PDF_DATAAVAIL_DONE; 3263 return TRUE; 3264 } 3265 return TRUE; 3266 } 3267 FX_BOOL CPDF_DataAvail::GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages) 3268 { 3269 if (!pParser) { 3270 m_docStatus = PDF_DATAAVAIL_ERROR; 3271 return FALSE; 3272 } 3273 CPDF_Object *pKids = pPages->GetDict()->GetElement(FX_BSTRC("Kids")); 3274 if (!pKids) { 3275 return TRUE; 3276 } 3277 switch (pKids->GetType()) { 3278 case PDFOBJ_REFERENCE: { 3279 CPDF_Reference *pKid = (CPDF_Reference *)pKids; 3280 m_PageObjList.Add(pKid->GetRefObjNum()); 3281 } 3282 break; 3283 case PDFOBJ_ARRAY: { 3284 CPDF_Array *pKidsArray = (CPDF_Array *)pKids; 3285 for (FX_DWORD i = 0; i < pKidsArray->GetCount(); ++i) { 3286 CPDF_Reference *pKid = (CPDF_Reference *)pKidsArray->GetElement(i); 3287 m_PageObjList.Add(pKid->GetRefObjNum()); 3288 } 3289 } 3290 break; 3291 default: 3292 m_docStatus = PDF_DATAAVAIL_ERROR; 3293 return FALSE; 3294 } 3295 return TRUE; 3296 } 3297 FX_BOOL CPDF_DataAvail::CheckPages(IFX_DownloadHints* pHints) 3298 { 3299 FX_BOOL bExist = FALSE; 3300 CPDF_Object *pPages = GetObject(m_PagesObjNum, pHints, &bExist); 3301 if (!bExist) { 3302 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3303 return TRUE; 3304 } 3305 if (!pPages) { 3306 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3307 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3308 return TRUE; 3309 } 3310 return FALSE; 3311 } 3312 FX_BOOL bNeedLoad = FALSE; 3313 if (!GetPageKids(m_pCurrentParser, pPages)) { 3314 pPages->Release(); 3315 m_docStatus = PDF_DATAAVAIL_ERROR; 3316 return FALSE; 3317 } 3318 pPages->Release(); 3319 m_docStatus = PDF_DATAAVAIL_PAGE; 3320 return TRUE; 3321 } 3322 FX_BOOL CPDF_DataAvail::CheckHeader(IFX_DownloadHints* pHints) 3323 { 3324 FX_DWORD req_size = 1024; 3325 if ((FX_FILESIZE)req_size > m_dwFileLen) { 3326 req_size = (FX_DWORD)m_dwFileLen; 3327 } 3328 if (m_pFileAvail->IsDataAvail(0, req_size)) { 3329 FX_BYTE buffer[1024]; 3330 m_pFileRead->ReadBlock(buffer, 0, req_size); 3331 if (IsLinearizedFile(buffer, req_size)) { 3332 m_docStatus = PDF_DATAAVAIL_FIRSTPAGE; 3333 } else { 3334 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3335 return FALSE; 3336 } 3337 m_docStatus = PDF_DATAAVAIL_END; 3338 } 3339 return TRUE; 3340 } 3341 pHints->AddSegment(0, req_size); 3342 return FALSE; 3343 } 3344 FX_BOOL CPDF_DataAvail::CheckFirstPage(IFX_DownloadHints *pHints) 3345 { 3346 FX_DWORD dwFirstPageEndOffset = 0; 3347 CPDF_Object *pEndOffSet = m_pLinearized->GetDict()->GetElement(FX_BSTRC("E")); 3348 if (!pEndOffSet) { 3349 m_docStatus = PDF_DATAAVAIL_ERROR; 3350 return FALSE; 3351 } 3352 CPDF_Object *pXRefOffset = m_pLinearized->GetDict()->GetElement(FX_BSTRC("T")); 3353 if (!pXRefOffset) { 3354 m_docStatus = PDF_DATAAVAIL_ERROR; 3355 return FALSE; 3356 } 3357 CPDF_Object *pFileLen = m_pLinearized->GetDict()->GetElement(FX_BSTRC("L")); 3358 if (!pFileLen) { 3359 m_docStatus = PDF_DATAAVAIL_ERROR; 3360 return FALSE; 3361 } 3362 FX_BOOL bNeedDownLoad = FALSE; 3363 if (pEndOffSet->GetType() == PDFOBJ_NUMBER) { 3364 FX_DWORD dwEnd = pEndOffSet->GetInteger(); 3365 dwEnd += 512; 3366 if ((FX_FILESIZE)dwEnd > m_dwFileLen) { 3367 dwEnd = (FX_DWORD)m_dwFileLen; 3368 } 3369 FX_INT32 iStartPos = (FX_INT32)(m_dwFileLen > 1024 ? 1024 : m_dwFileLen); 3370 FX_INT32 iSize = dwEnd > 1024 ? dwEnd - 1024 : 0; 3371 if (!m_pFileAvail->IsDataAvail(iStartPos, iSize)) { 3372 pHints->AddSegment(iStartPos, iSize); 3373 bNeedDownLoad = TRUE; 3374 } 3375 } 3376 m_dwLastXRefOffset = 0; 3377 FX_FILESIZE dwFileLen = 0; 3378 if (pXRefOffset->GetType() == PDFOBJ_NUMBER) { 3379 m_dwLastXRefOffset = pXRefOffset->GetInteger(); 3380 } 3381 if (pFileLen->GetType() == PDFOBJ_NUMBER) { 3382 dwFileLen = pFileLen->GetInteger(); 3383 } 3384 if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset, (FX_DWORD)(dwFileLen - m_dwLastXRefOffset))) { 3385 if (m_docStatus == PDF_DATAAVAIL_FIRSTPAGE) { 3386 FX_DWORD dwSize = (FX_DWORD)(dwFileLen - m_dwLastXRefOffset); 3387 FX_FILESIZE offset = m_dwLastXRefOffset; 3388 if (dwSize < 512 && dwFileLen > 512) { 3389 dwSize = 512; 3390 offset = dwFileLen - 512; 3391 } 3392 pHints->AddSegment(offset, dwSize); 3393 } 3394 } else { 3395 m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE; 3396 } 3397 if (!bNeedDownLoad && m_docStatus == PDF_DATAAVAIL_FIRSTPAGE_PREPARE) { 3398 m_docStatus = PDF_DATAAVAIL_DONE; 3399 return TRUE; 3400 } 3401 m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE; 3402 return FALSE; 3403 } 3404 CPDF_Object * CPDF_DataAvail::ParseIndirectObjectAt(FX_FILESIZE pos, FX_DWORD objnum) 3405 { 3406 FX_FILESIZE SavedPos = m_syntaxParser.SavePos(); 3407 m_syntaxParser.RestorePos(pos); 3408 FX_BOOL bIsNumber; 3409 CFX_ByteString word = m_syntaxParser.GetNextWord(bIsNumber); 3410 if (!bIsNumber) { 3411 return NULL; 3412 } 3413 FX_DWORD real_objnum = FXSYS_atoi(word); 3414 if (objnum && real_objnum != objnum) { 3415 return NULL; 3416 } 3417 word = m_syntaxParser.GetNextWord(bIsNumber); 3418 if (!bIsNumber) { 3419 return NULL; 3420 } 3421 FX_DWORD gennum = FXSYS_atoi(word); 3422 if (m_syntaxParser.GetKeyword() != FX_BSTRC("obj")) { 3423 m_syntaxParser.RestorePos(SavedPos); 3424 return NULL; 3425 } 3426 CPDF_Object* pObj = m_syntaxParser.GetObject(NULL, objnum, gennum, 0); 3427 m_syntaxParser.RestorePos(SavedPos); 3428 return pObj; 3429 } 3430 FX_INT32 CPDF_DataAvail::IsLinearizedPDF() 3431 { 3432 FX_DWORD req_size = 1024; 3433 if (!m_pFileAvail->IsDataAvail(0, req_size)) { 3434 return PDF_UNKNOW_LINEARIZED; 3435 } 3436 if (!m_pFileRead) { 3437 return PDF_NOT_LINEARIZED; 3438 } 3439 FX_FILESIZE dwSize = m_pFileRead->GetSize(); 3440 if (dwSize < (FX_FILESIZE)req_size) { 3441 return PDF_UNKNOW_LINEARIZED; 3442 } 3443 FX_BYTE buffer[1024]; 3444 m_pFileRead->ReadBlock(buffer, 0, req_size); 3445 if (IsLinearizedFile(buffer, req_size)) { 3446 return PDF_IS_LINEARIZED; 3447 } 3448 return PDF_NOT_LINEARIZED; 3449 } 3450 FX_BOOL CPDF_DataAvail::IsLinearizedFile(FX_LPBYTE pData, FX_DWORD dwLen) 3451 { 3452 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pData, (size_t)dwLen, FALSE)); 3453 FX_INT32 offset = GetHeaderOffset((IFX_FileStream*)file); 3454 if (offset == -1) { 3455 m_docStatus = PDF_DATAAVAIL_ERROR; 3456 return FALSE; 3457 } 3458 m_dwHeaderOffset = offset; 3459 m_syntaxParser.InitParser((IFX_FileStream*)file, offset); 3460 m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9); 3461 FX_BOOL bNumber = FALSE; 3462 FX_FILESIZE dwSavePos = m_syntaxParser.SavePos(); 3463 CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(bNumber); 3464 if (!bNumber) { 3465 return FALSE; 3466 } 3467 FX_DWORD objnum = FXSYS_atoi(wordObjNum); 3468 if (m_pLinearized) { 3469 m_pLinearized->Release(); 3470 m_pLinearized = NULL; 3471 } 3472 m_pLinearized = ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum); 3473 if (!m_pLinearized) { 3474 return FALSE; 3475 } 3476 if (m_pLinearized->GetDict()->GetElement(FX_BSTRC("Linearized"))) { 3477 CPDF_Object *pLen = m_pLinearized->GetDict()->GetElement(FX_BSTRC("L")); 3478 if (!pLen) { 3479 return FALSE; 3480 } 3481 if ((FX_FILESIZE)pLen->GetInteger() != m_pFileRead->GetSize()) { 3482 return FALSE; 3483 } 3484 m_bLinearized = TRUE; 3485 CPDF_Object *pNo = m_pLinearized->GetDict()->GetElement(FX_BSTRC("P")); 3486 if (pNo && pNo->GetType() == PDFOBJ_NUMBER) { 3487 m_dwFirstPageNo = pNo->GetInteger(); 3488 } 3489 return TRUE; 3490 } 3491 return FALSE; 3492 } 3493 FX_BOOL CPDF_DataAvail::CheckEnd(IFX_DownloadHints* pHints) 3494 { 3495 FX_DWORD req_pos = (FX_DWORD)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0); 3496 FX_DWORD dwSize = (FX_DWORD)(m_dwFileLen - req_pos); 3497 if (m_pFileAvail->IsDataAvail(req_pos, dwSize)) { 3498 FX_BYTE buffer[1024]; 3499 m_pFileRead->ReadBlock(buffer, req_pos, dwSize); 3500 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(buffer, (size_t)dwSize, FALSE)); 3501 m_syntaxParser.InitParser((IFX_FileStream*)file, 0); 3502 m_syntaxParser.RestorePos(dwSize - 1); 3503 if (m_syntaxParser.SearchWord(FX_BSTRC("startxref"), TRUE, FALSE, dwSize)) { 3504 FX_BOOL bNumber; 3505 m_syntaxParser.GetNextWord(bNumber); 3506 CFX_ByteString xrefpos_str = m_syntaxParser.GetNextWord(bNumber); 3507 if (!bNumber) { 3508 m_docStatus = PDF_DATAAVAIL_ERROR; 3509 return FALSE; 3510 } 3511 m_dwXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str); 3512 if (!m_dwXRefOffset || m_dwXRefOffset > m_dwFileLen) { 3513 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3514 return TRUE; 3515 } 3516 m_dwLastXRefOffset = m_dwXRefOffset; 3517 SetStartOffset(m_dwXRefOffset); 3518 m_docStatus = PDF_DATAAVAIL_CROSSREF; 3519 return TRUE; 3520 } else { 3521 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3522 return TRUE; 3523 } 3524 } 3525 pHints->AddSegment(req_pos, dwSize); 3526 return FALSE; 3527 } 3528 FX_DWORD CPDF_DataAvail::CheckCrossRefStream(IFX_DownloadHints* pHints, FX_FILESIZE &xref_offset) 3529 { 3530 xref_offset = 0; 3531 FX_DWORD req_size = (FX_DWORD)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512); 3532 if (m_pFileAvail->IsDataAvail(m_Pos, req_size)) { 3533 FX_INT32 iSize = (FX_INT32)(m_Pos + req_size - m_dwCurrentXRefSteam); 3534 CFX_BinaryBuf buf(iSize); 3535 FX_LPBYTE pBuf = buf.GetBuffer(); 3536 m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize); 3537 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE)); 3538 m_parser.m_Syntax.InitParser((IFX_FileStream*)file, 0); 3539 FX_BOOL bNumber = FALSE; 3540 FX_FILESIZE dwSavePos = m_parser.m_Syntax.SavePos(); 3541 CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(bNumber); 3542 if (!bNumber) { 3543 return -1; 3544 } 3545 FX_DWORD objNum = FXSYS_atoi(objnum); 3546 CPDF_Object *pObj = m_parser.ParseIndirectObjectAt(NULL, 0, objNum, NULL); 3547 if (!pObj) { 3548 m_Pos += m_parser.m_Syntax.SavePos(); 3549 return 0; 3550 } 3551 CPDF_Object *pName = pObj->GetDict()->GetElement(FX_BSTRC("Type")); 3552 if (pName && pName->GetType() == PDFOBJ_NAME) { 3553 if (pName->GetString() == FX_BSTRC("XRef")) { 3554 m_Pos += m_parser.m_Syntax.SavePos(); 3555 xref_offset = pObj->GetDict()->GetInteger(FX_BSTRC("Prev")); 3556 pObj->Release(); 3557 return 1; 3558 } else { 3559 pObj->Release(); 3560 return -1; 3561 } 3562 } 3563 pObj->Release(); 3564 return -1; 3565 } 3566 pHints->AddSegment(m_Pos, req_size); 3567 return 0; 3568 } 3569 inline void CPDF_DataAvail::SetStartOffset(FX_FILESIZE dwOffset) 3570 { 3571 m_Pos = dwOffset; 3572 } 3573 #define MAX_WORD_BUFFER 256 3574 FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token) 3575 { 3576 m_WordSize = 0; 3577 FX_BYTE ch; 3578 if (!GetNextChar(ch)) { 3579 return FALSE; 3580 } 3581 FX_BYTE type = _PDF_CharType[ch]; 3582 while (1) { 3583 while (type == 'W') { 3584 if (!GetNextChar(ch)) { 3585 return FALSE; 3586 } 3587 type = _PDF_CharType[ch]; 3588 } 3589 if (ch != '%') { 3590 break; 3591 } 3592 while (1) { 3593 if (!GetNextChar(ch)) { 3594 return FALSE; 3595 } 3596 if (ch == '\r' || ch == '\n') { 3597 break; 3598 } 3599 } 3600 type = _PDF_CharType[ch]; 3601 } 3602 if (type == 'D') { 3603 m_WordBuffer[m_WordSize++] = ch; 3604 if (ch == '/') { 3605 while (1) { 3606 if (!GetNextChar(ch)) { 3607 return FALSE; 3608 } 3609 type = _PDF_CharType[ch]; 3610 if (type != 'R' && type != 'N') { 3611 m_Pos --; 3612 CFX_ByteString ret(m_WordBuffer, m_WordSize); 3613 token = ret; 3614 return TRUE; 3615 } 3616 if (m_WordSize < MAX_WORD_BUFFER) { 3617 m_WordBuffer[m_WordSize++] = ch; 3618 } 3619 } 3620 } else if (ch == '<') { 3621 if (!GetNextChar(ch)) { 3622 return FALSE; 3623 } 3624 if (ch == '<') { 3625 m_WordBuffer[m_WordSize++] = ch; 3626 } else { 3627 m_Pos --; 3628 } 3629 } else if (ch == '>') { 3630 if (!GetNextChar(ch)) { 3631 return FALSE; 3632 } 3633 if (ch == '>') { 3634 m_WordBuffer[m_WordSize++] = ch; 3635 } else { 3636 m_Pos --; 3637 } 3638 } 3639 CFX_ByteString ret(m_WordBuffer, m_WordSize); 3640 token = ret; 3641 return TRUE; 3642 } 3643 while (1) { 3644 if (m_WordSize < MAX_WORD_BUFFER) { 3645 m_WordBuffer[m_WordSize++] = ch; 3646 } 3647 if (!GetNextChar(ch)) { 3648 return FALSE; 3649 } 3650 type = _PDF_CharType[ch]; 3651 if (type == 'D' || type == 'W') { 3652 m_Pos --; 3653 break; 3654 } 3655 } 3656 CFX_ByteString ret(m_WordBuffer, m_WordSize); 3657 token = ret; 3658 return TRUE; 3659 } 3660 FX_BOOL CPDF_DataAvail::GetNextChar(FX_BYTE &ch) 3661 { 3662 FX_FILESIZE pos = m_Pos; 3663 if (pos >= m_dwFileLen) { 3664 return FALSE; 3665 } 3666 if (m_bufferOffset >= pos || (FX_FILESIZE)(m_bufferOffset + m_bufferSize) <= pos) { 3667 FX_FILESIZE read_pos = pos; 3668 FX_DWORD read_size = 512; 3669 if ((FX_FILESIZE)read_size > m_dwFileLen) { 3670 read_size = (FX_DWORD)m_dwFileLen; 3671 } 3672 if ((FX_FILESIZE)(read_pos + read_size) > m_dwFileLen) { 3673 read_pos = m_dwFileLen - read_size; 3674 } 3675 if (!m_pFileRead->ReadBlock(m_bufferData, read_pos, read_size)) { 3676 return FALSE; 3677 } 3678 m_bufferOffset = read_pos; 3679 m_bufferSize = read_size; 3680 } 3681 ch = m_bufferData[pos - m_bufferOffset]; 3682 m_Pos ++; 3683 return TRUE; 3684 } 3685 FX_BOOL CPDF_DataAvail::CheckCrossRefItem(IFX_DownloadHints *pHints) 3686 { 3687 FX_INT32 iSize = 0; 3688 CFX_ByteString token; 3689 while (1) { 3690 if (!GetNextToken(token)) { 3691 iSize = (FX_INT32)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512); 3692 pHints->AddSegment(m_Pos, iSize); 3693 return FALSE; 3694 } 3695 if (token == "trailer") { 3696 m_dwTrailerOffset = m_Pos; 3697 m_docStatus = PDF_DATAAVAIL_TRAILER; 3698 return TRUE; 3699 } 3700 } 3701 } 3702 FX_BOOL CPDF_DataAvail::CheckAllCrossRefStream(IFX_DownloadHints *pHints) 3703 { 3704 FX_FILESIZE xref_offset = 0; 3705 FX_DWORD dwRet = CheckCrossRefStream(pHints, xref_offset); 3706 if (dwRet == 1) { 3707 if (!xref_offset) { 3708 m_docStatus = PDF_DATAAVAIL_LOADALLCRSOSSREF; 3709 } else { 3710 m_dwCurrentXRefSteam = xref_offset; 3711 m_Pos = xref_offset; 3712 } 3713 return TRUE; 3714 } else if (dwRet == -1) { 3715 m_docStatus = PDF_DATAAVAIL_ERROR; 3716 } 3717 return FALSE; 3718 } 3719 FX_BOOL CPDF_DataAvail::CheckCrossRef(IFX_DownloadHints* pHints) 3720 { 3721 FX_FILESIZE dwSavePos = m_Pos; 3722 FX_INT32 iSize = 0; 3723 CFX_ByteString token; 3724 if (!GetNextToken(token)) { 3725 iSize = (FX_INT32)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512); 3726 pHints->AddSegment(m_Pos, iSize); 3727 return FALSE; 3728 } 3729 if (token == "xref") { 3730 m_CrossOffset.InsertAt(0, m_dwXRefOffset); 3731 while (1) { 3732 if (!GetNextToken(token)) { 3733 iSize = (FX_INT32)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512); 3734 pHints->AddSegment(m_Pos, iSize); 3735 m_docStatus = PDF_DATAAVAIL_CROSSREF_ITEM; 3736 return FALSE; 3737 } 3738 if (token == "trailer") { 3739 m_dwTrailerOffset = m_Pos; 3740 m_docStatus = PDF_DATAAVAIL_TRAILER; 3741 return TRUE; 3742 } 3743 } 3744 } else { 3745 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3746 return TRUE; 3747 } 3748 return FALSE; 3749 } 3750 FX_BOOL CPDF_DataAvail::CheckTrailerAppend(IFX_DownloadHints* pHints) 3751 { 3752 if (m_Pos < m_dwFileLen) { 3753 FX_FILESIZE dwAppendPos = m_Pos + m_syntaxParser.SavePos(); 3754 FX_INT32 iSize = (FX_INT32)(dwAppendPos + 512 > m_dwFileLen ? m_dwFileLen - dwAppendPos : 512); 3755 if (!m_pFileAvail->IsDataAvail(dwAppendPos, iSize)) { 3756 pHints->AddSegment(dwAppendPos, iSize); 3757 return FALSE; 3758 } 3759 } 3760 if (m_dwPrevXRefOffset) { 3761 SetStartOffset(m_dwPrevXRefOffset); 3762 m_docStatus = PDF_DATAAVAIL_CROSSREF; 3763 } else { 3764 m_docStatus = PDF_DATAAVAIL_LOADALLCRSOSSREF; 3765 } 3766 return TRUE; 3767 } 3768 FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints) 3769 { 3770 FX_INT32 iTrailerSize = (FX_INT32)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512); 3771 if (m_pFileAvail->IsDataAvail(m_Pos, iTrailerSize)) { 3772 FX_INT32 iSize = (FX_INT32)(m_Pos + iTrailerSize - m_dwTrailerOffset); 3773 CFX_BinaryBuf buf(iSize); 3774 FX_LPBYTE pBuf = buf.GetBuffer(); 3775 if (!pBuf) { 3776 m_docStatus = PDF_DATAAVAIL_ERROR; 3777 return FALSE; 3778 } 3779 if (!m_pFileRead->ReadBlock(pBuf, m_dwTrailerOffset, iSize)) { 3780 return FALSE; 3781 } 3782 CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE)); 3783 m_syntaxParser.InitParser((IFX_FileStream*)file, 0); 3784 CPDF_Object *pTrailer = m_syntaxParser.GetObject(NULL, 0, 0, 0); 3785 if (!pTrailer) { 3786 m_Pos += m_syntaxParser.SavePos(); 3787 pHints->AddSegment(m_Pos, iTrailerSize); 3788 return FALSE; 3789 } 3790 CPDF_Dictionary *pTrailerDict = pTrailer->GetDict(); 3791 if (pTrailerDict) { 3792 CPDF_Object *pEncrypt = pTrailerDict->GetElement("Encrypt"); 3793 if (pEncrypt && pEncrypt->GetType() == PDFOBJ_REFERENCE) { 3794 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3795 pTrailer->Release(); 3796 return TRUE; 3797 } 3798 } 3799 FX_DWORD xrefpos = GetDirectInteger(pTrailer->GetDict(), FX_BSTRC("Prev")); 3800 if (xrefpos) { 3801 m_dwPrevXRefOffset = GetDirectInteger(pTrailer->GetDict(), FX_BSTRC("XRefStm")); 3802 pTrailer->Release(); 3803 if (m_dwPrevXRefOffset) { 3804 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3805 } else { 3806 m_dwPrevXRefOffset = xrefpos; 3807 if (m_dwPrevXRefOffset >= m_dwFileLen) { 3808 m_docStatus = PDF_DATAAVAIL_LOADALLFILE; 3809 } else { 3810 SetStartOffset(m_dwPrevXRefOffset); 3811 m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND; 3812 } 3813 } 3814 return TRUE; 3815 } else { 3816 m_dwPrevXRefOffset = 0; 3817 m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND; 3818 pTrailer->Release(); 3819 } 3820 return TRUE; 3821 } 3822 pHints->AddSegment(m_Pos, iTrailerSize); 3823 return FALSE; 3824 } 3825 FX_BOOL CPDF_DataAvail::CheckPage(FX_INT32 iPage, IFX_DownloadHints* pHints) 3826 { 3827 while (TRUE) { 3828 switch (m_docStatus) { 3829 case PDF_DATAAVAIL_PAGETREE: 3830 if (!LoadDocPages(pHints)) { 3831 return FALSE; 3832 } 3833 break; 3834 case PDF_DATAAVAIL_PAGE: 3835 if (!LoadDocPage(iPage, pHints)) { 3836 return FALSE; 3837 } 3838 break; 3839 case PDF_DATAAVAIL_ERROR: 3840 return LoadAllFile(pHints); 3841 default: 3842 m_bPagesTreeLoad = TRUE; 3843 m_bPagesLoad = TRUE; 3844 m_bCurPageDictLoadOK = TRUE; 3845 m_docStatus = PDF_DATAAVAIL_PAGE; 3846 return TRUE; 3847 } 3848 } 3849 } 3850 FX_BOOL CPDF_DataAvail::CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints) 3851 { 3852 FX_BOOL bExist = FALSE; 3853 CPDF_Object *pPages = GetObject(dwPageNo, pHints, &bExist); 3854 if (!bExist) { 3855 m_docStatus = PDF_DATAAVAIL_ERROR; 3856 return FALSE; 3857 } 3858 if (!pPages) { 3859 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3860 m_docStatus = PDF_DATAAVAIL_ERROR; 3861 return FALSE; 3862 } 3863 return FALSE; 3864 } 3865 if (pPages->GetType() != PDFOBJ_ARRAY) { 3866 pPages->Release(); 3867 m_docStatus = PDF_DATAAVAIL_ERROR; 3868 return FALSE; 3869 } 3870 pPageNode->m_type = PDF_PAGENODE_PAGES; 3871 CPDF_Array* pArray = (CPDF_Array*)pPages; 3872 for (FX_DWORD i = 0; i < pArray->GetCount(); ++i) { 3873 CPDF_Object *pKid = (CPDF_Object *)pArray->GetElement(i); 3874 if (!pKid || pKid->GetType() != PDFOBJ_REFERENCE) { 3875 continue; 3876 } 3877 CPDF_PageNode *pNode = FX_NEW CPDF_PageNode(); 3878 pPageNode->m_childNode.Add(pNode); 3879 pNode->m_dwPageNo = ((CPDF_Reference*)pKid)->GetRefObjNum(); 3880 } 3881 pPages->Release(); 3882 return TRUE; 3883 } 3884 FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints) 3885 { 3886 FX_BOOL bExist = FALSE; 3887 CPDF_Object *pPage = GetObject(dwPageNo, pHints, &bExist); 3888 if (!bExist) { 3889 m_docStatus = PDF_DATAAVAIL_ERROR; 3890 return FALSE; 3891 } 3892 if (!pPage) { 3893 if (m_docStatus == PDF_DATAAVAIL_ERROR) { 3894 m_docStatus = PDF_DATAAVAIL_ERROR; 3895 return FALSE; 3896 } 3897 return FALSE; 3898 } 3899 if (pPage->GetType() == PDFOBJ_ARRAY) { 3900 pPageNode->m_dwPageNo = dwPageNo; 3901 pPageNode->m_type = PDF_PAGENODE_ARRAY; 3902 pPage->Release(); 3903 return TRUE; 3904 } 3905 if (pPage->GetType() != PDFOBJ_DICTIONARY) { 3906 pPage->Release(); 3907 m_docStatus = PDF_DATAAVAIL_ERROR; 3908 return FALSE; 3909 } 3910 pPageNode->m_dwPageNo = dwPageNo; 3911 CFX_ByteString type = pPage->GetDict()->GetString(FX_BSTRC("Type")); 3912 if (type == FX_BSTRC("Pages")) { 3913 pPageNode->m_type = PDF_PAGENODE_PAGES; 3914 CPDF_Object *pKids = pPage->GetDict()->GetElement(FX_BSTRC("Kids")); 3915 if (!pKids) { 3916 m_docStatus = PDF_DATAAVAIL_PAGE; 3917 return TRUE; 3918 } 3919 switch (pKids->GetType()) { 3920 case PDFOBJ_REFERENCE: { 3921 CPDF_Reference *pKid = (CPDF_Reference *)pKids; 3922 CPDF_PageNode *pNode = FX_NEW CPDF_PageNode(); 3923 pPageNode->m_childNode.Add(pNode); 3924 pNode->m_dwPageNo = pKid->GetRefObjNum(); 3925 } 3926 break; 3927 case PDFOBJ_ARRAY: { 3928 CPDF_Array *pKidsArray = (CPDF_Array *)pKids; 3929 for (FX_DWORD i = 0; i < pKidsArray->GetCount(); ++i) { 3930 CPDF_Object *pKid = (CPDF_Object *)pKidsArray->GetElement(i); 3931 if (!pKid || pKid->GetType() != PDFOBJ_REFERENCE) { 3932 continue; 3933 } 3934 CPDF_PageNode *pNode = FX_NEW CPDF_PageNode(); 3935 pPageNode->m_childNode.Add(pNode); 3936 pNode->m_dwPageNo = ((CPDF_Reference*)pKid)->GetRefObjNum(); 3937 } 3938 } 3939 break; 3940 default: 3941 break; 3942 } 3943 } else if (type == FX_BSTRC("Page")) { 3944 pPageNode->m_type = PDF_PAGENODE_PAGE; 3945 } else { 3946 pPage->Release(); 3947 m_docStatus = PDF_DATAAVAIL_ERROR; 3948 return FALSE; 3949 } 3950 pPage->Release(); 3951 return TRUE; 3952 } 3953 FX_BOOL CPDF_DataAvail::CheckPageNode(CPDF_PageNode &pageNodes, FX_INT32 iPage, FX_INT32 &iCount, IFX_DownloadHints* pHints) 3954 { 3955 FX_INT32 iSize = pageNodes.m_childNode.GetSize(); 3956 if (!iSize) { 3957 m_docStatus = PDF_DATAAVAIL_ERROR; 3958 return FALSE; 3959 } 3960 for (FX_INT32 i = 0; i < iSize; ++i) { 3961 CPDF_PageNode *pNode = (CPDF_PageNode*)pageNodes.m_childNode.GetAt(i); 3962 if (!pNode) { 3963 continue; 3964 } 3965 switch (pNode->m_type) { 3966 case PDF_PAGENODE_UNKOWN: 3967 if (!CheckUnkownPageNode(pNode->m_dwPageNo, pNode, pHints)) { 3968 return FALSE; 3969 } 3970 --i; 3971 break; 3972 case PDF_PAGENODE_PAGE: 3973 iCount++; 3974 if (iPage == iCount && m_pDocument) { 3975 m_pDocument->m_PageList.SetAt(iPage, pNode->m_dwPageNo); 3976 } 3977 break; 3978 case PDF_PAGENODE_PAGES: 3979 if (!CheckPageNode(*pNode, iPage, iCount, pHints)) { 3980 return FALSE; 3981 } 3982 break; 3983 case PDF_PAGENODE_ARRAY: 3984 if (!CheckArrayPageNode(pNode->m_dwPageNo, pNode, pHints)) { 3985 return FALSE; 3986 } 3987 --i; 3988 break; 3989 } 3990 if (iPage == iCount) { 3991 m_docStatus = PDF_DATAAVAIL_DONE; 3992 return TRUE; 3993 } 3994 } 3995 return TRUE; 3996 } 3997 FX_BOOL CPDF_DataAvail::LoadDocPage(FX_INT32 iPage, IFX_DownloadHints* pHints) 3998 { 3999 if (m_pDocument->GetPageCount() <= iPage || m_pDocument->m_PageList.GetAt(iPage)) { 4000 m_docStatus = PDF_DATAAVAIL_DONE; 4001 return TRUE; 4002 } 4003 if (m_pageNodes.m_type == PDF_PAGENODE_PAGE) { 4004 if (iPage == 0) { 4005 m_docStatus = PDF_DATAAVAIL_DONE; 4006 return TRUE; 4007 } 4008 m_docStatus = PDF_DATAAVAIL_ERROR; 4009 return TRUE; 4010 } 4011 FX_INT32 iCount = -1; 4012 return CheckPageNode(m_pageNodes, iPage, iCount, pHints); 4013 } 4014 FX_BOOL CPDF_DataAvail::CheckPageCount(IFX_DownloadHints* pHints) 4015 { 4016 FX_BOOL bExist = FALSE; 4017 CPDF_Object *pPages = GetObject(m_PagesObjNum, pHints, &bExist); 4018 if (!bExist) { 4019 m_docStatus = PDF_DATAAVAIL_ERROR; 4020 return FALSE; 4021 } 4022 if (!pPages) { 4023 return FALSE; 4024 } 4025 CPDF_Dictionary* pPagesDict = pPages->GetDict(); 4026 if (!pPagesDict) { 4027 pPages->Release(); 4028 m_docStatus = PDF_DATAAVAIL_ERROR; 4029 return FALSE; 4030 } 4031 if (!pPagesDict->KeyExist(FX_BSTRC("Kids"))) { 4032 pPages->Release(); 4033 return TRUE; 4034 } 4035 int count = pPagesDict->GetInteger(FX_BSTRC("Count")); 4036 if (count > 0) { 4037 pPages->Release(); 4038 return TRUE; 4039 } 4040 pPages->Release(); 4041 return FALSE; 4042 } 4043 FX_BOOL CPDF_DataAvail::LoadDocPages(IFX_DownloadHints* pHints) 4044 { 4045 if (!CheckUnkownPageNode(m_PagesObjNum, &m_pageNodes, pHints)) { 4046 return FALSE; 4047 } 4048 if (CheckPageCount(pHints)) { 4049 m_docStatus = PDF_DATAAVAIL_PAGE; 4050 return TRUE; 4051 } else { 4052 m_bTotalLoadPageTree = TRUE; 4053 } 4054 return FALSE; 4055 } 4056 FX_BOOL CPDF_DataAvail::LoadPages(IFX_DownloadHints* pHints) 4057 { 4058 while (!m_bPagesTreeLoad) { 4059 if (!CheckPageStatus(pHints)) { 4060 return FALSE; 4061 } 4062 } 4063 if (m_bPagesLoad) { 4064 return TRUE; 4065 } 4066 m_pDocument->LoadPages(); 4067 return FALSE; 4068 } 4069 FX_BOOL CPDF_DataAvail::CheckLinearizedData(IFX_DownloadHints* pHints) 4070 { 4071 if (m_bLinearedDataOK) { 4072 return TRUE; 4073 } 4074 if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset, (FX_DWORD)(m_dwFileLen - m_dwLastXRefOffset))) { 4075 pHints->AddSegment(m_dwLastXRefOffset, (FX_DWORD)(m_dwFileLen - m_dwLastXRefOffset)); 4076 return FALSE; 4077 } 4078 FX_DWORD dwRet = 0; 4079 if (!m_bMainXRefLoad) { 4080 dwRet = ((CPDF_Parser *)m_pDocument->GetParser())->LoadLinearizedMainXRefTable(); 4081 if (dwRet == PDFPARSE_ERROR_SUCCESS) { 4082 if (!PreparePageItem()) { 4083 return FALSE; 4084 } 4085 m_bMainXRefLoadedOK = TRUE; 4086 } 4087 m_bMainXRefLoad = TRUE; 4088 } 4089 m_bLinearedDataOK = TRUE; 4090 return TRUE; 4091 } 4092 FX_BOOL CPDF_DataAvail::CheckPageAnnots(FX_INT32 iPage, IFX_DownloadHints* pHints) 4093 { 4094 if (!m_objs_array.GetSize()) { 4095 m_objs_array.RemoveAll(); 4096 m_objnum_array.RemoveAll(); 4097 CPDF_Dictionary *pPageDict = m_pDocument->GetPage(iPage); 4098 if (!pPageDict) { 4099 return TRUE; 4100 } 4101 CPDF_Object *pAnnots = pPageDict->GetElement(FX_BSTRC("Annots")); 4102 if (!pAnnots) { 4103 return TRUE; 4104 } 4105 CFX_PtrArray obj_array; 4106 obj_array.Add(pAnnots); 4107 FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array); 4108 if (bRet) { 4109 m_objs_array.RemoveAll(); 4110 } 4111 return bRet; 4112 } else { 4113 CFX_PtrArray new_objs_array; 4114 FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array); 4115 m_objs_array.RemoveAll(); 4116 if (!bRet) { 4117 m_objs_array.Append(new_objs_array); 4118 } 4119 return bRet; 4120 } 4121 } 4122 FX_BOOL CPDF_DataAvail::CheckLinearizedFirstPage(FX_INT32 iPage, IFX_DownloadHints* pHints) 4123 { 4124 if (!m_bAnnotsLoad) { 4125 if (!CheckPageAnnots(iPage, pHints)) { 4126 return FALSE; 4127 } 4128 m_bAnnotsLoad = TRUE; 4129 } 4130 if (m_bAnnotsLoad) 4131 if (!CheckLinearizedData(pHints)) { 4132 return FALSE; 4133 } 4134 m_bPageLoadedOK = FALSE; 4135 return TRUE; 4136 } 4137 FX_BOOL CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary *pDict) 4138 { 4139 CPDF_Object *pParent = pDict->GetElement("Parent"); 4140 if (!pParent) { 4141 return FALSE; 4142 } 4143 CPDF_Dictionary *pParentDict = pParent->GetDict(); 4144 if (!pParentDict) { 4145 return FALSE; 4146 } 4147 CPDF_Object *pRet = pParentDict->GetElement("Resource"); 4148 if (pRet) { 4149 m_pPageResource = pRet; 4150 return TRUE; 4151 } else { 4152 return HaveResourceAncestor(pParentDict); 4153 } 4154 } 4155 FX_BOOL CPDF_DataAvail::IsPageAvail(FX_INT32 iPage, IFX_DownloadHints* pHints) 4156 { 4157 if (!m_pDocument) { 4158 return FALSE; 4159 } 4160 if (IsFirstCheck(iPage)) { 4161 m_bCurPageDictLoadOK = FALSE; 4162 m_bPageLoadedOK = FALSE; 4163 m_bAnnotsLoad = FALSE; 4164 m_bNeedDownLoadResource = FALSE; 4165 m_objs_array.RemoveAll(); 4166 m_objnum_array.RemoveAll(); 4167 } 4168 if (m_pagesLoadState == NULL) { 4169 m_pagesLoadState = FX_NEW CFX_CMapDWordToDWord(); 4170 } 4171 FX_DWORD dwPageLoad = 0; 4172 if (m_pagesLoadState->Lookup(iPage, dwPageLoad) && dwPageLoad != 0) { 4173 return TRUE; 4174 } 4175 if (m_bLinearized) { 4176 if ((FX_DWORD)iPage == m_dwFirstPageNo) { 4177 m_pagesLoadState->SetAt(iPage, TRUE); 4178 return TRUE; 4179 } 4180 if (!CheckLinearizedData(pHints)) { 4181 return FALSE; 4182 } 4183 if (m_bMainXRefLoadedOK) { 4184 if (m_bTotalLoadPageTree) { 4185 if (!LoadPages(pHints)) { 4186 return FALSE; 4187 } 4188 } else { 4189 if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) { 4190 return FALSE; 4191 } 4192 } 4193 } else { 4194 if (!LoadAllFile(pHints)) { 4195 return FALSE; 4196 } 4197 ((CPDF_Parser *)m_pDocument->GetParser())->RebuildCrossRef(); 4198 ResetFirstCheck(iPage); 4199 return TRUE; 4200 } 4201 } else { 4202 if (!m_bTotalLoadPageTree) { 4203 if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) { 4204 return FALSE; 4205 } 4206 } 4207 } 4208 if (m_bHaveAcroForm && !m_bAcroFormLoad) { 4209 if (!CheckAcroFormSubObject(pHints)) { 4210 return FALSE; 4211 } 4212 m_bAcroFormLoad = TRUE; 4213 } 4214 if (!m_bPageLoadedOK) { 4215 if (!m_objs_array.GetSize()) { 4216 m_objs_array.RemoveAll(); 4217 m_objnum_array.RemoveAll(); 4218 m_pPageDict = m_pDocument->GetPage(iPage); 4219 if (!m_pPageDict) { 4220 ResetFirstCheck(iPage); 4221 return TRUE; 4222 } 4223 CFX_PtrArray obj_array; 4224 obj_array.Add(m_pPageDict); 4225 FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array); 4226 if (bRet) { 4227 m_objs_array.RemoveAll(); 4228 m_bPageLoadedOK = TRUE; 4229 } else { 4230 return bRet; 4231 } 4232 } else { 4233 CFX_PtrArray new_objs_array; 4234 FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array); 4235 m_objs_array.RemoveAll(); 4236 if (bRet) { 4237 m_bPageLoadedOK = TRUE; 4238 } else { 4239 m_objs_array.Append(new_objs_array); 4240 return bRet; 4241 } 4242 } 4243 } 4244 if (m_bPageLoadedOK) { 4245 if (!m_bAnnotsLoad) { 4246 if (!CheckPageAnnots(iPage, pHints)) { 4247 return FALSE; 4248 } 4249 m_bAnnotsLoad = TRUE; 4250 } 4251 } 4252 if (m_pPageDict && !m_bNeedDownLoadResource) { 4253 CPDF_Object *pRes = m_pPageDict->GetElement("Resource"); 4254 if (!pRes) { 4255 m_bNeedDownLoadResource = HaveResourceAncestor(m_pPageDict); 4256 } 4257 m_bNeedDownLoadResource = FALSE; 4258 } 4259 if (m_bNeedDownLoadResource) { 4260 FX_BOOL bRet = CheckResources(pHints); 4261 if (!bRet) { 4262 return FALSE; 4263 } 4264 m_bNeedDownLoadResource = FALSE; 4265 } 4266 m_bPageLoadedOK = FALSE; 4267 m_bAnnotsLoad = FALSE; 4268 m_bCurPageDictLoadOK = FALSE; 4269 ResetFirstCheck(iPage); 4270 m_pagesLoadState->SetAt(iPage, TRUE); 4271 return TRUE; 4272 } 4273 FX_BOOL CPDF_DataAvail::CheckResources(IFX_DownloadHints* pHints) 4274 { 4275 if (!m_objs_array.GetSize()) { 4276 m_objs_array.RemoveAll(); 4277 CFX_PtrArray obj_array; 4278 obj_array.Add(m_pPageResource); 4279 FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array); 4280 if (bRet) { 4281 m_objs_array.RemoveAll(); 4282 } 4283 return bRet; 4284 } else { 4285 CFX_PtrArray new_objs_array; 4286 FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array); 4287 m_objs_array.RemoveAll(); 4288 if (!bRet) { 4289 m_objs_array.Append(new_objs_array); 4290 } 4291 return bRet; 4292 } 4293 } 4294 void CPDF_DataAvail::GetLinearizedMainXRefInfo(FX_FILESIZE *pPos, FX_DWORD *pSize) 4295 { 4296 if (pPos) { 4297 *pPos = m_dwLastXRefOffset; 4298 } 4299 if (pSize) { 4300 *pSize = (FX_DWORD)(m_dwFileLen - m_dwLastXRefOffset); 4301 } 4302 } 4303 FX_INT32 CPDF_DataAvail::IsFormAvail(IFX_DownloadHints *pHints) 4304 { 4305 if (!m_pDocument) { 4306 return PDFFORM_AVAIL; 4307 } 4308 if (!m_bLinearizedFormParamLoad) { 4309 CPDF_Dictionary *pRoot = m_pDocument->GetRoot(); 4310 if (!pRoot) { 4311 return PDFFORM_AVAIL; 4312 } 4313 CPDF_Object *pAcroForm = pRoot->GetElement(FX_BSTRC("AcroForm")); 4314 if (!pAcroForm) { 4315 return PDFFORM_NOTEXIST; 4316 } 4317 if (!m_bMainXRefLoad && !CheckLinearizedData(pHints)) { 4318 return PDFFORM_NOTAVAIL; 4319 } 4320 if (!m_objs_array.GetSize()) { 4321 m_objs_array.Add(pAcroForm->GetDict()); 4322 } 4323 m_bLinearizedFormParamLoad = TRUE; 4324 } 4325 CFX_PtrArray new_objs_array; 4326 FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array); 4327 m_objs_array.RemoveAll(); 4328 if (!bRet) { 4329 m_objs_array.Append(new_objs_array); 4330 return PDFFORM_NOTAVAIL; 4331 } 4332 return PDFFORM_AVAIL; 4333 } 4334 void CPDF_SortObjNumArray::AddObjNum(FX_DWORD dwObjNum) 4335 { 4336 FX_INT32 iNext = 0; 4337 if (BinarySearch(dwObjNum, iNext)) { 4338 return; 4339 } 4340 m_number_array.InsertAt(iNext, dwObjNum); 4341 } 4342 FX_BOOL CPDF_SortObjNumArray::Find(FX_DWORD dwObjNum) 4343 { 4344 FX_INT32 iNext = 0; 4345 return BinarySearch(dwObjNum, iNext); 4346 } 4347 FX_BOOL CPDF_SortObjNumArray::BinarySearch(FX_DWORD value, FX_INT32 &iNext) 4348 { 4349 FX_INT32 iLen = m_number_array.GetSize(); 4350 FX_INT32 iLow = 0; 4351 FX_INT32 iHigh = iLen - 1; 4352 FX_INT32 iMid = 0; 4353 while (iLow <= iHigh) { 4354 iMid = (iLow + iHigh) / 2; 4355 FX_DWORD tt = m_number_array.GetAt(iMid); 4356 if (m_number_array.GetAt(iMid) == value) { 4357 iNext = iMid; 4358 return TRUE; 4359 } else if (m_number_array.GetAt(iMid) > value) { 4360 iHigh = iMid - 1; 4361 } else if (m_number_array.GetAt(iMid) < value) { 4362 iLow = iMid + 1; 4363 } 4364 } 4365 iNext = iLow; 4366 return FALSE; 4367 } 4368 CPDF_PageNode::~CPDF_PageNode() 4369 { 4370 FX_INT32 iSize = m_childNode.GetSize(); 4371 for (FX_INT32 i = 0; i < iSize; ++i) { 4372 CPDF_PageNode *pNode = (CPDF_PageNode*)m_childNode[i]; 4373 if (pNode) { 4374 delete pNode; 4375 } 4376 } 4377 m_childNode.RemoveAll(); 4378 } 4379
