in the attempt to fix 627393, changed IFX_FileRead's readBlock to return the length it reads

fpdfsdk/fpdfview.cpp

 // Copyright 2014 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 "public/fpdfview.h"
 
 #include <memory>
 #include <utility>
@@ skipping 102 matching lines @@
 }
 
 bool CFPDF_FileStream::IsEOF() {
   return m_nCurPos >= GetSize();
 }
 
 FX_FILESIZE CFPDF_FileStream::GetPosition() {
   return m_nCurPos;
 }
 
-bool CFPDF_FileStream::ReadBlock(void* buffer,
-                                 FX_FILESIZE offset,
-                                 size_t size) {
+size_t CFPDF_FileStream::ReadBlock(void* buffer,
+                                   FX_FILESIZE offset,
+                                   size_t size) {
   if (!buffer || !size || !m_pFS->ReadBlock)
-    return false;
+    return 0;
 
   if (m_pFS->ReadBlock(m_pFS->clientData, (FPDF_DWORD)offset, buffer,
                        (FPDF_DWORD)size) == 0) {
     m_nCurPos = offset + size;
-    return true;
+    return size;
   }
-  return false;
+  return 0;
 }
 
 size_t CFPDF_FileStream::ReadBlock(void* buffer, size_t size) {
   if (!buffer || !size || !m_pFS->ReadBlock)
     return 0;
 
   FX_FILESIZE nSize = GetSize();
   if (m_nCurPos >= nSize)
     return 0;
   FX_FILESIZE dwAvail = nSize - m_nCurPos;
@@ skipping 24 matching lines @@
 
 bool CFPDF_FileStream::Flush() {
   if (!m_pFS || !m_pFS->Flush)
     return true;
 
   return m_pFS->Flush(m_pFS->clientData) == 0;
 }
 #endif  // PDF_ENABLE_XFA
 
 CPDF_CustomAccess::CPDF_CustomAccess(FPDF_FILEACCESS* pFileAccess)
-    : m_FileAccess(*pFileAccess) {}
+    : m_FileAccess(*pFileAccess), m_nCurPos(0) {}
 
 FX_FILESIZE CPDF_CustomAccess::GetSize() {
   return m_FileAccess.m_FileLen;
 }
 
 void CPDF_CustomAccess::Release() {
   delete this;
 }
 
-bool CPDF_CustomAccess::ReadBlock(void* buffer,
-                                  FX_FILESIZE offset,
-                                  size_t size) {
-  if (offset < 0)
-    return false;
+bool CPDF_CustomAccess::IsEOF() {
+  return m_nCurPos >= static_cast<FX_FILESIZE>(m_FileAccess.m_FileLen);
+}
 
-  FX_SAFE_FILESIZE newPos = pdfium::base::checked_cast<FX_FILESIZE>(size);
+size_t CPDF_CustomAccess::ReadBlock(void* buffer,
+                                    FX_FILESIZE offset,
+                                    size_t size) {
+  if (offset < 0) {
+    return 0;
+  }
+  FX_SAFE_FILESIZE newPos =
+      pdfium::base::checked_cast<FX_FILESIZE, size_t>(size);
   newPos += offset;
   if (!newPos.IsValid() ||
       newPos.ValueOrDie() > static_cast<FX_FILESIZE>(m_FileAccess.m_FileLen)) {
-    return false;
+    return 0;
   }
-  return !!m_FileAccess.m_GetBlock(m_FileAccess.m_Param, offset,
-                                   reinterpret_cast<uint8_t*>(buffer), size);
+  m_FileAccess.m_GetBlock(m_FileAccess.m_Param, offset, (uint8_t*)buffer, size);

[Tom Sepez, 2016/11/16 18:32:01]

We probably still need to check the error status of this call?

+  m_nCurPos = newPos.ValueOrDie();
+  return size;
 }
 
 // 0 bit: FPDF_POLICY_MACHINETIME_ACCESS
 static uint32_t foxit_sandbox_policy = 0xFFFFFFFF;
 
 void FSDK_SetSandBoxPolicy(FPDF_DWORD policy, FPDF_BOOL enable) {
   switch (policy) {
     case FPDF_POLICY_MACHINETIME_ACCESS: {
       if (enable)
         foxit_sandbox_policy |= 0x01;
@@ skipping 159 matching lines @@
   return true;
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_LoadXFA(FPDF_DOCUMENT document) {
   return document && (static_cast<CPDFXFA_Context*>(document))->LoadXFADoc();
 }
 #endif  // PDF_ENABLE_XFA
 
 class CMemFile final : public IFX_SeekableReadStream {
  public:
-  CMemFile(uint8_t* pBuf, FX_FILESIZE size) : m_pBuf(pBuf), m_size(size) {}
+  CMemFile(uint8_t* pBuf, FX_FILESIZE size)
+      : m_pBuf(pBuf), m_size(size), m_nCurPos(0) {}
 
   void Release() override { delete this; }
+  bool IsEOF() override { return m_nCurPos >= m_size; }
   FX_FILESIZE GetSize() override { return m_size; }
-  bool ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override {
+  size_t ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override {
     if (offset < 0) {
-      return false;
+      return 0;
     }
     FX_SAFE_FILESIZE newPos = pdfium::base::checked_cast<FX_FILESIZE>(size);
     newPos += offset;
     if (!newPos.IsValid() || newPos.ValueOrDie() > m_size) {
-      return false;
+      return 0;
     }
     FXSYS_memcpy(buffer, m_pBuf + offset, size);
-    return true;
+    m_nCurPos = offset + size;
+    return size;
   }
 
  private:
   ~CMemFile() override {}
 
   uint8_t* const m_pBuf;
   const FX_FILESIZE m_size;
+  FX_FILESIZE m_nCurPos;
 };
 
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
                                                      int size,
                                                      FPDF_BYTESTRING password) {
   CMemFile* pMemFile = new CMemFile((uint8_t*)data_buf, size);
   std::unique_ptr<CPDF_Parser> pParser(new CPDF_Parser);
   pParser->SetPassword(password);
 
   std::unique_ptr<CPDF_Document> pDocument(
@@ skipping 694 matching lines @@
   if (!buffer) {
     *buflen = len;
   } else if (*buflen >= len) {
     memcpy(buffer, utf16Name.c_str(), len);
     *buflen = len;
   } else {
     *buflen = -1;
   }
   return (FPDF_DEST)pDestObj;
 }