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