Do not load main cross refs for first page in linearized pdf.

core/fpdfapi/parser/cpdf_data_avail.cpp

 // Copyright 2016 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fpdfapi/parser/cpdf_data_avail.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 233 matching lines @@
   m_arrayAcroforms.push_back(m_pAcroForm);
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return true;
 }
 
 bool CPDF_DataAvail::CheckDocStatus(DownloadHints* pHints) {
   switch (m_docStatus) {
     case PDF_DATAAVAIL_HEADER:
       return CheckHeader(pHints);
     case PDF_DATAAVAIL_FIRSTPAGE:
-    case PDF_DATAAVAIL_FIRSTPAGE_PREPARE:
       return CheckFirstPage(pHints);
     case PDF_DATAAVAIL_HINTTABLE:
       return CheckHintTables(pHints);
     case PDF_DATAAVAIL_END:
       return CheckEnd(pHints);
     case PDF_DATAAVAIL_CROSSREF:
       return CheckCrossRef(pHints);
     case PDF_DATAAVAIL_CROSSREF_ITEM:
       return CheckCrossRefItem(pHints);
     case PDF_DATAAVAIL_CROSSREF_STREAM:
@@ skipping 322 matching lines @@
   return false;
 }
 
 bool CPDF_DataAvail::CheckFirstPage(DownloadHints* pHints) {
   if (!m_pLinearized->GetFirstPageEndOffset() ||
       !m_pLinearized->GetFileSize() || !m_pLinearized->GetLastXRefOffset()) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  bool bNeedDownLoad = false;
   uint32_t dwEnd = m_pLinearized->GetFirstPageEndOffset();
   dwEnd += 512;
   if ((FX_FILESIZE)dwEnd > m_dwFileLen)
     dwEnd = (uint32_t)m_dwFileLen;
 
   int32_t iStartPos = (int32_t)(m_dwFileLen > 1024 ? 1024 : m_dwFileLen);
   int32_t iSize = dwEnd > 1024 ? dwEnd - 1024 : 0;
   if (!m_pFileAvail->IsDataAvail(iStartPos, iSize)) {
     pHints->AddSegment(iStartPos, iSize);
-    bNeedDownLoad = true;
-  }
-
-  m_dwLastXRefOffset = m_pLinearized->GetLastXRefOffset();
-  FX_FILESIZE dwFileLen = m_pLinearized->GetFileSize();
-  if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset,
-                                 (uint32_t)(dwFileLen - m_dwLastXRefOffset))) {
-    if (m_docStatus == PDF_DATAAVAIL_FIRSTPAGE) {
-      uint32_t dwSize = (uint32_t)(dwFileLen - m_dwLastXRefOffset);
-      FX_FILESIZE offset = m_dwLastXRefOffset;
-      if (dwSize < 512 && dwFileLen > 512) {
-        dwSize = 512;
-        offset = dwFileLen - 512;
-      }
-      pHints->AddSegment(offset, dwSize);
-    }
-  } else {
-    m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
-  }
-
-  if (bNeedDownLoad || m_docStatus != PDF_DATAAVAIL_FIRSTPAGE_PREPARE) {
-    m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
     return false;
   }
 
   m_docStatus =
       m_bSupportHintTable ? PDF_DATAAVAIL_HINTTABLE : PDF_DATAAVAIL_DONE;
   return true;
 }
 
 bool CPDF_DataAvail::IsDataAvail(FX_FILESIZE offset,
                                  uint32_t size,
                                  DownloadHints* pHints) {
   if (offset < 0 || offset > m_dwFileLen)
     return true;
 
   FX_SAFE_FILESIZE safeSize = offset;
   safeSize += size;
   safeSize += 512;
   if (!safeSize.IsValid() || safeSize.ValueOrDie() > m_dwFileLen)
     size = m_dwFileLen - offset;
   else
     size += 512;
 
   if (!m_pFileAvail->IsDataAvail(offset, size)) {
-    pHints->AddSegment(offset, size);
+    if (pHints)
+      pHints->AddSegment(offset, size);
     return false;
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckHintTables(DownloadHints* pHints) {
   if (m_pLinearized->GetPageCount() <= 1) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return true;
   }
@@ skipping 702 matching lines @@
     return true;
 
   m_pDocument->LoadPages();
   return false;
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedData(
     DownloadHints* pHints) {
   if (m_bLinearedDataOK)
     return DataAvailable;
+  ASSERT(m_pLinearized);
+  if (!m_pLinearized->GetLastXRefOffset())
+    return DataError;
 
   if (!m_bMainXRefLoadTried) {
     FX_SAFE_UINT32 data_size = m_dwFileLen;
-    data_size -= m_dwLastXRefOffset;
+    data_size -= m_pLinearized->GetLastXRefOffset();
     if (!data_size.IsValid())
       return DataError;
 
-    if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset,
+    if (!m_pFileAvail->IsDataAvail(m_pLinearized->GetLastXRefOffset(),
                                    data_size.ValueOrDie())) {
-      pHints->AddSegment(m_dwLastXRefOffset, data_size.ValueOrDie());
+      pHints->AddSegment(m_pLinearized->GetLastXRefOffset(),
+                         data_size.ValueOrDie());
       return DataNotAvailable;
     }
 
     CPDF_Parser::Error eRet =
         m_pDocument->GetParser()->LoadLinearizedMainXRefTable();
     m_bMainXRefLoadTried = true;
     if (eRet != CPDF_Parser::SUCCESS)
       return DataError;
 
     if (!PreparePageItem())
@@ skipping 38 matching lines @@
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedFirstPage(
     uint32_t dwPage,
     DownloadHints* pHints) {
   if (!m_bAnnotsLoad) {
     if (!CheckPageAnnots(dwPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = true;
   }
-
-  DocAvailStatus nRet = CheckLinearizedData(pHints);
-  if (nRet == DataAvailable)
-    m_bPageLoadedOK = false;
-  return nRet;
+  const bool is_page_valid = ValidatePage(dwPage);
+  (void)is_page_valid;
+  ASSERT(is_page_valid);
+  return DataAvailable;
 }
 
 bool CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary* pDict) {
   CFX_AutoRestorer<int> restorer(&s_CurrentDataAvailRecursionDepth);
   if (++s_CurrentDataAvailRecursionDepth > kMaxDataAvailRecursionDepth)
     return false;
 
   CPDF_Object* pParent = pDict->GetObjectFor("Parent");
   if (!pParent)
     return false;
@@ skipping 78 matching lines @@
   }
 
   if (!m_bPageLoadedOK) {
     if (m_objs_array.empty()) {
       m_ObjectSet.clear();
 
       FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
       m_pPageDict = m_pDocument->GetPage(safePage.ValueOrDie());
       if (!m_pPageDict) {
         ResetFirstCheck(dwPage);
+        // This is XFA page.
         return DataAvailable;
       }
 
       std::vector<CPDF_Object*> obj_array;
       obj_array.push_back(m_pPageDict);
       if (!AreObjectsAvailable(obj_array, true, pHints, m_objs_array))
         return DataNotAvailable;
 
       m_objs_array.clear();
     } else {
@@ skipping 24 matching lines @@
       return DataNotAvailable;
     m_bNeedDownLoadResource = false;
   }
 
   m_bPageLoadedOK = false;
   m_bAnnotsLoad = false;
   m_bCurPageDictLoadOK = false;
 
   ResetFirstCheck(dwPage);
   m_pagesLoadState.insert(dwPage);
+  const bool is_page_valid = ValidatePage(dwPage);
+  (void)is_page_valid;
+  ASSERT(is_page_valid);
   return DataAvailable;
 }
 
 bool CPDF_DataAvail::CheckResources(DownloadHints* pHints) {
   if (m_objs_array.empty()) {
     std::vector<CPDF_Object*> obj_array;
     obj_array.push_back(m_pPageResource);
     if (!AreObjectsAvailable(obj_array, true, pHints, m_objs_array))
       return false;
 
@@ skipping 43 matching lines @@
     return nullptr;
   // We should say to the document, which object is the page.
   m_pDocument->SetPageObjNum(index, dwObjNum);
   // Page object already can be parsed in document.
   if (!m_pDocument->GetIndirectObject(dwObjNum)) {
     m_syntaxParser.InitParser(
         m_pFileRead, pdfium::base::checked_cast<uint32_t>(szPageStartPos));
     m_pDocument->ReplaceIndirectObjectIfHigherGeneration(
         dwObjNum, ParseIndirectObjectAt(0, dwObjNum, m_pDocument));
   }
+  const bool is_page_valid = ValidatePage(index);
+  (void)is_page_valid;
+  ASSERT(is_page_valid);
   return m_pDocument->GetPage(index);
 }
 
 CPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
     DownloadHints* pHints) {
   if (!m_pDocument)
     return FormAvailable;
+  if (m_pLinearized) {
+    DocAvailStatus nDocStatus = CheckLinearizedData(pHints);
+    if (nDocStatus == DataError)
+      return FormError;
+    if (nDocStatus == DataNotAvailable)
+      return FormNotAvailable;
+  }
 
   if (!m_bLinearizedFormParamLoad) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot)
       return FormAvailable;
 
     CPDF_Object* pAcroForm = pRoot->GetObjectFor("AcroForm");
     if (!pAcroForm)
       return FormNotExist;
 
-    DocAvailStatus nDocStatus = CheckLinearizedData(pHints);
-    if (nDocStatus == DataError)
-      return FormError;
-    if (nDocStatus == DataNotAvailable)
-      return FormNotAvailable;
-
-    if (m_objs_array.empty())
-      m_objs_array.push_back(pAcroForm->GetDict());
+    m_objs_array.push_back(pAcroForm->GetDict());
     m_bLinearizedFormParamLoad = true;
   }
 
   std::vector<CPDF_Object*> new_objs_array;
   if (!AreObjectsAvailable(m_objs_array, false, pHints, new_objs_array)) {
     m_objs_array = new_objs_array;
     return FormNotAvailable;
   }
 
   m_objs_array.clear();
+  const bool is_form_valid = ValidateForm();
+  (void)is_form_valid;
+  ASSERT(is_form_valid);
   return FormAvailable;
 }
 
+bool CPDF_DataAvail::ValidatePage(uint32_t dwPage) {
+  FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
+  CPDF_Dictionary* pPageDict = m_pDocument->GetPage(safePage.ValueOrDie());
+  if (!pPageDict)
+    return false;
+  std::vector<CPDF_Object*> obj_array;
+  obj_array.push_back(pPageDict);
+  std::vector<CPDF_Object*> dummy;
+  return AreObjectsAvailable(obj_array, true, nullptr, dummy);
+}
+
+bool CPDF_DataAvail::ValidateForm() {
+  CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
+  if (!pRoot)
+    return true;
+  CPDF_Object* pAcroForm = pRoot->GetObjectFor("AcroForm");
+  if (!pAcroForm)
+    return false;
+  std::vector<CPDF_Object*> obj_array;
+  obj_array.push_back(pAcroForm);
+  std::vector<CPDF_Object*> dummy;
+  return AreObjectsAvailable(obj_array, true, nullptr, dummy);
+}
+
 CPDF_DataAvail::PageNode::PageNode() : m_type(PDF_PAGENODE_UNKNOWN) {}
 
 CPDF_DataAvail::PageNode::~PageNode() {
   for (int32_t i = 0; i < m_childNode.GetSize(); ++i)
     delete m_childNode[i];
   m_childNode.RemoveAll();
 }