Use unsigned page indexes in CPDF_HintTables.

core/fpdfapi/fpdf_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/fpdf_parser/include/cpdf_data_avail.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 461 matching lines @@
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   m_PagesObjNum = pRef->GetRefObjNum();
   m_pCurrentParser = m_pDocument->GetParser();
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
 
-bool CPDF_DataAvail::IsFirstCheck(int iPage) {
-  return m_pageMapCheckState.insert(iPage).second;
+bool CPDF_DataAvail::IsFirstCheck(uint32_t dwPage) {
+  return m_pageMapCheckState.insert(dwPage).second;
 }
 
-void CPDF_DataAvail::ResetFirstCheck(int iPage) {
-  m_pageMapCheckState.erase(iPage);
+void CPDF_DataAvail::ResetFirstCheck(uint32_t dwPage) {
+  m_pageMapCheckState.erase(dwPage);
 }
 
 FX_BOOL CPDF_DataAvail::CheckPage(DownloadHints* pHints) {
   uint32_t iPageObjs = m_PageObjList.GetSize();
   CFX_ArrayTemplate<uint32_t> UnavailObjList;
   for (uint32_t i = 0; i < iPageObjs; ++i) {
     uint32_t dwPageObjNum = m_PageObjList.GetAt(i);
     FX_BOOL bExist = FALSE;
     CPDF_Object* pObj = GetObject(dwPageObjNum, pHints, &bExist);
     if (!pObj) {
@@ skipping 730 matching lines @@
       return TRUE;
     }
     m_dwPrevXRefOffset = 0;
     m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND;
     return TRUE;
   }
   pHints->AddSegment(m_Pos, iTrailerSize);
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckPage(int32_t iPage, DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPage(uint32_t dwPage, DownloadHints* pHints) {
   while (TRUE) {
     switch (m_docStatus) {
       case PDF_DATAAVAIL_PAGETREE:
         if (!LoadDocPages(pHints))
           return FALSE;
         break;
       case PDF_DATAAVAIL_PAGE:
-        if (!LoadDocPage(iPage, pHints))
+        if (!LoadDocPage(dwPage, pHints))
           return FALSE;
         break;
       case PDF_DATAAVAIL_ERROR:
         return LoadAllFile(pHints);
       default:
         m_bPagesTreeLoad = TRUE;
         m_bPagesLoad = TRUE;
         m_bCurPageDictLoadOK = TRUE;
         m_docStatus = PDF_DATAAVAIL_PAGE;
         return TRUE;
@@ skipping 156 matching lines @@
     }
 
     if (iPage == iCount) {
       m_docStatus = PDF_DATAAVAIL_DONE;
       return TRUE;
     }
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::LoadDocPage(int32_t iPage, DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadDocPage(uint32_t dwPage, DownloadHints* pHints) {
+  FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
+  int32_t iPage = safePage.ValueOrDie();

[Tom Sepez, 2016/09/01 16:16:27]

return false instead of segv? (several places).

[Lei Zhang, 2016/09/01 17:58:21]

I was trying to handle them, but I figured they are all protected methods deeper
inside CPDF_DataAvail, so:

- nobody is calling them directly
- the callers to these protected methods all originally received a non-negative
int32_t, thus the value should fit in an int32_t again and they should not fail.
Too fragile of an assumption?

   if (m_pDocument->GetPageCount() <= iPage ||
       m_pDocument->m_PageList.GetAt(iPage)) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
 
   if (m_pageNodes.m_type == PDF_PAGENODE_PAGE) {
     if (iPage == 0) {
       m_docStatus = PDF_DATAAVAIL_DONE;
       return TRUE;
@@ skipping 90 matching lines @@
     if (!PreparePageItem())
       return DataNotAvailable;
 
     m_bMainXRefLoadedOK = TRUE;
     m_bLinearedDataOK = TRUE;
   }
 
   return m_bLinearedDataOK ? DataAvailable : DataNotAvailable;
 }
 
-FX_BOOL CPDF_DataAvail::CheckPageAnnots(int32_t iPage, DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPageAnnots(uint32_t dwPage,
+                                        DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
 
-    CPDF_Dictionary* pPageDict = m_pDocument->GetPage(iPage);
+    FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
+    CPDF_Dictionary* pPageDict = m_pDocument->GetPage(safePage.ValueOrDie());
     if (!pPageDict)
       return TRUE;
 
     CPDF_Object* pAnnots = pPageDict->GetObjectBy("Annots");
     if (!pAnnots)
       return TRUE;
 
     CFX_ArrayTemplate<CPDF_Object*> obj_array;
     obj_array.Add(pAnnots);
 
     FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array);
     if (bRet)
       m_objs_array.RemoveAll();
 
     return bRet;
   }
 
   CFX_ArrayTemplate<CPDF_Object*> new_objs_array;
   FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
   m_objs_array.RemoveAll();
   if (!bRet)
     m_objs_array.Append(new_objs_array);
 
   return bRet;
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedFirstPage(
-    int32_t iPage,
+    uint32_t dwPage,
     DownloadHints* pHints) {
   if (!m_bAnnotsLoad) {
-    if (!CheckPageAnnots(iPage, pHints))
+    if (!CheckPageAnnots(dwPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = TRUE;
   }
 
   DocAvailStatus nRet = CheckLinearizedData(pHints);
   if (nRet == DataAvailable)
     m_bPageLoadedOK = FALSE;
   return nRet;
 }
 
@@ skipping 13 matching lines @@
   CPDF_Object* pRet = pParentDict->GetObjectBy("Resources");
   if (pRet) {
     m_pPageResource = pRet;
     return TRUE;
   }
 
   return HaveResourceAncestor(pParentDict);
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
-    int32_t iPage,
+    uint32_t dwPage,
     DownloadHints* pHints) {
   if (!m_pDocument)
     return DataError;
 
-  if (IsFirstCheck(iPage)) {
+  if (IsFirstCheck(dwPage)) {
     m_bCurPageDictLoadOK = FALSE;
     m_bPageLoadedOK = FALSE;
     m_bAnnotsLoad = FALSE;
     m_bNeedDownLoadResource = FALSE;
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
   }
 
-  if (pdfium::ContainsKey(m_pagesLoadState, iPage))
+  if (pdfium::ContainsKey(m_pagesLoadState, dwPage))
     return DataAvailable;
 
   if (m_bLinearized) {
-    if ((uint32_t)iPage == m_dwFirstPageNo) {
-      DocAvailStatus nRet = CheckLinearizedFirstPage(iPage, pHints);
+    if (dwPage == m_dwFirstPageNo) {
+      DocAvailStatus nRet = CheckLinearizedFirstPage(dwPage, pHints);
       if (nRet == DataAvailable)
-        m_pagesLoadState.insert(iPage);
+        m_pagesLoadState.insert(dwPage);
       return nRet;
     }
 
     DocAvailStatus nResult = CheckLinearizedData(pHints);
     if (nResult != DataAvailable)
       return nResult;
 
     if (m_pHintTables) {
-      nResult = m_pHintTables->CheckPage(iPage, pHints);
+      nResult = m_pHintTables->CheckPage(dwPage, pHints);
       if (nResult != DataAvailable)
         return nResult;
-      m_pagesLoadState.insert(iPage);
+      m_pagesLoadState.insert(dwPage);
       return DataAvailable;
     }
 
     if (m_bMainXRefLoadedOK) {
       if (m_bTotalLoadPageTree) {
         if (!LoadPages(pHints))
           return DataNotAvailable;
       } else {
-        if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints))
+        if (!m_bCurPageDictLoadOK && !CheckPage(dwPage, pHints))
           return DataNotAvailable;
       }
     } else {
       if (!LoadAllFile(pHints))
         return DataNotAvailable;
       m_pDocument->GetParser()->RebuildCrossRef();
-      ResetFirstCheck(iPage);
+      ResetFirstCheck(dwPage);
       return DataAvailable;
     }
   } else {
     if (!m_bTotalLoadPageTree && !m_bCurPageDictLoadOK &&
-        !CheckPage(iPage, pHints)) {
+        !CheckPage(dwPage, pHints)) {
       return DataNotAvailable;
     }
   }
 
   if (m_bHaveAcroForm && !m_bAcroFormLoad) {
     if (!CheckAcroFormSubObject(pHints))
       return DataNotAvailable;
     m_bAcroFormLoad = TRUE;
   }
 
   if (!m_bPageLoadedOK) {
     if (!m_objs_array.GetSize()) {
       m_objs_array.RemoveAll();
       m_ObjectSet.clear();
 
-      m_pPageDict = m_pDocument->GetPage(iPage);
+      FX_SAFE_INT32 safePage = pdfium::base::checked_cast<int32_t>(dwPage);
+      m_pPageDict = m_pDocument->GetPage(safePage.ValueOrDie());
       if (!m_pPageDict) {
-        ResetFirstCheck(iPage);
+        ResetFirstCheck(dwPage);
         return DataAvailable;
       }
 
       CFX_ArrayTemplate<CPDF_Object*> obj_array;
       obj_array.Add(m_pPageDict);
       FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array);
       if (!bRet)
         return DataNotAvailable;
 
       m_objs_array.RemoveAll();
     } else {
       CFX_ArrayTemplate<CPDF_Object*> new_objs_array;
       FX_BOOL bRet =
           IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
 
       m_objs_array.RemoveAll();
       if (!bRet) {
         m_objs_array.Append(new_objs_array);
         return DataNotAvailable;
       }
     }
     m_bPageLoadedOK = TRUE;
   }
 
   if (!m_bAnnotsLoad) {
-    if (!CheckPageAnnots(iPage, pHints))
+    if (!CheckPageAnnots(dwPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = TRUE;
   }
 
   if (m_pPageDict && !m_bNeedDownLoadResource) {
     m_pPageResource = m_pPageDict->GetObjectBy("Resources");
-    if (!m_pPageResource)
-      m_bNeedDownLoadResource = HaveResourceAncestor(m_pPageDict);
-    else
-      m_bNeedDownLoadResource = TRUE;
+    m_bNeedDownLoadResource =
+        m_pPageResource || HaveResourceAncestor(m_pPageDict);
   }
 
   if (m_bNeedDownLoadResource) {
-    FX_BOOL bRet = CheckResources(pHints);
-    if (!bRet)
+    if (!CheckResources(pHints))
       return DataNotAvailable;
     m_bNeedDownLoadResource = FALSE;
   }
 
   m_bPageLoadedOK = FALSE;
   m_bAnnotsLoad = FALSE;
   m_bCurPageDictLoadOK = FALSE;
 
-  ResetFirstCheck(iPage);
-  m_pagesLoadState.insert(iPage);
+  ResetFirstCheck(dwPage);
+  m_pagesLoadState.insert(dwPage);
   return DataAvailable;
 }
 
 FX_BOOL CPDF_DataAvail::CheckResources(DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     CFX_ArrayTemplate<CPDF_Object*> obj_array;
     obj_array.Add(m_pPageResource);
 
     FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array);
@@ skipping 95 matching lines @@
   return FormAvailable;
 }
 
 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();
 }