• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2014 The PDFium Authors
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 "public/fpdf_dataavail.h"
8 
9 #include <memory>
10 #include <utility>
11 
12 #include "core/fpdfapi/page/cpdf_docpagedata.h"
13 #include "core/fpdfapi/parser/cpdf_data_avail.h"
14 #include "core/fpdfapi/parser/cpdf_document.h"
15 #include "core/fpdfapi/render/cpdf_docrenderdata.h"
16 #include "core/fxcrt/fx_safe_types.h"
17 #include "core/fxcrt/fx_stream.h"
18 #include "core/fxcrt/numerics/safe_conversions.h"
19 #include "core/fxcrt/retain_ptr.h"
20 #include "core/fxcrt/unowned_ptr.h"
21 #include "core/fxcrt/unowned_ptr_exclusion.h"
22 #include "fpdfsdk/cpdfsdk_helpers.h"
23 #include "public/fpdf_formfill.h"
24 
25 #ifdef PDF_ENABLE_XFA
26 #include "fpdfsdk/fpdfxfa/cpdfxfa_context.h"
27 #endif  // PDF_ENABLE_XFA
28 
29 // These checks are here because core/ and public/ cannot depend on each other.
30 static_assert(CPDF_DataAvail::kDataError == PDF_DATA_ERROR,
31               "CPDF_DataAvail::kDataError value mismatch");
32 static_assert(CPDF_DataAvail::kDataNotAvailable == PDF_DATA_NOTAVAIL,
33               "CPDF_DataAvail::kDataNotAvailable value mismatch");
34 static_assert(CPDF_DataAvail::kDataAvailable == PDF_DATA_AVAIL,
35               "CPDF_DataAvail::kDataAvailable value mismatch");
36 
37 static_assert(CPDF_DataAvail::kLinearizationUnknown ==
38                   PDF_LINEARIZATION_UNKNOWN,
39               "CPDF_DataAvail::kLinearizationUnknown value mismatch");
40 static_assert(CPDF_DataAvail::kNotLinearized == PDF_NOT_LINEARIZED,
41               "CPDF_DataAvail::kNotLinearized value mismatch");
42 static_assert(CPDF_DataAvail::kLinearized == PDF_LINEARIZED,
43               "CPDF_DataAvail::kLinearized value mismatch");
44 
45 static_assert(CPDF_DataAvail::kFormError == PDF_FORM_ERROR,
46               "CPDF_DataAvail::kFormError value mismatch");
47 static_assert(CPDF_DataAvail::kFormNotAvailable == PDF_FORM_NOTAVAIL,
48               "CPDF_DataAvail::kFormNotAvailable value mismatch");
49 static_assert(CPDF_DataAvail::kFormAvailable == PDF_FORM_AVAIL,
50               "CPDF_DataAvail::kFormAvailable value mismatch");
51 static_assert(CPDF_DataAvail::kFormNotExist == PDF_FORM_NOTEXIST,
52               "CPDF_DataAvail::kFormNotExist value mismatch");
53 
54 namespace {
55 
56 class FPDF_FileAvailContext final : public CPDF_DataAvail::FileAvail {
57  public:
FPDF_FileAvailContext(FX_FILEAVAIL * avail)58   explicit FPDF_FileAvailContext(FX_FILEAVAIL* avail) : avail_(avail) {}
59   ~FPDF_FileAvailContext() override = default;
60 
61   // CPDF_DataAvail::FileAvail:
IsDataAvail(FX_FILESIZE offset,size_t size)62   bool IsDataAvail(FX_FILESIZE offset, size_t size) override {
63     return !!avail_->IsDataAvail(avail_, pdfium::checked_cast<size_t>(offset),
64                                  size);
65   }
66 
67  private:
68   // TODO(tsepez): fix murky ownership in tests.
69   UNOWNED_PTR_EXCLUSION FX_FILEAVAIL* const avail_;
70 };
71 
72 class FPDF_FileAccessContext final : public IFX_SeekableReadStream {
73  public:
74   CONSTRUCT_VIA_MAKE_RETAIN;
75 
76   // IFX_SeekableReadStream:
GetSize()77   FX_FILESIZE GetSize() override { return file_->m_FileLen; }
78 
ReadBlockAtOffset(pdfium::span<uint8_t> buffer,FX_FILESIZE offset)79   bool ReadBlockAtOffset(pdfium::span<uint8_t> buffer,
80                          FX_FILESIZE offset) override {
81     if (buffer.empty() || offset < 0)
82       return false;
83 
84     if (!pdfium::IsValueInRangeForNumericType<FX_FILESIZE>(buffer.size())) {
85       return false;
86     }
87 
88     FX_SAFE_FILESIZE new_pos = buffer.size();
89     new_pos += offset;
90     return new_pos.IsValid() && new_pos.ValueOrDie() <= GetSize() &&
91            file_->m_GetBlock(
92                file_->m_Param, pdfium::checked_cast<unsigned long>(offset),
93                buffer.data(),
94                pdfium::checked_cast<unsigned long>(buffer.size()));
95   }
96 
97  private:
FPDF_FileAccessContext(FPDF_FILEACCESS * file)98   explicit FPDF_FileAccessContext(FPDF_FILEACCESS* file) : file_(file) {}
99   ~FPDF_FileAccessContext() override = default;
100 
101   // TODO(tsepez): fix murky ownership in tests.
102   UNOWNED_PTR_EXCLUSION FPDF_FILEACCESS* const file_;
103 };
104 
105 class FPDF_DownloadHintsContext final : public CPDF_DataAvail::DownloadHints {
106  public:
FPDF_DownloadHintsContext(FX_DOWNLOADHINTS * pDownloadHints)107   explicit FPDF_DownloadHintsContext(FX_DOWNLOADHINTS* pDownloadHints)
108       : m_pDownloadHints(pDownloadHints) {}
109   ~FPDF_DownloadHintsContext() override = default;
110 
111   // IFX_DownloadHints
AddSegment(FX_FILESIZE offset,size_t size)112   void AddSegment(FX_FILESIZE offset, size_t size) override {
113     if (m_pDownloadHints) {
114       m_pDownloadHints->AddSegment(m_pDownloadHints,
115                                    static_cast<size_t>(offset), size);
116     }
117   }
118 
119  private:
120   UnownedPtr<FX_DOWNLOADHINTS> m_pDownloadHints;
121 };
122 
123 class FPDF_AvailContext {
124  public:
FPDF_AvailContext(FX_FILEAVAIL * file_avail,FPDF_FILEACCESS * file)125   FPDF_AvailContext(FX_FILEAVAIL* file_avail, FPDF_FILEACCESS* file)
126       : file_avail_(std::make_unique<FPDF_FileAvailContext>(file_avail)),
127         file_read_(pdfium::MakeRetain<FPDF_FileAccessContext>(file)),
128         data_avail_(
129             std::make_unique<CPDF_DataAvail>(file_avail_.get(), file_read_)) {}
130   ~FPDF_AvailContext() = default;
131 
data_avail()132   CPDF_DataAvail* data_avail() { return data_avail_.get(); }
133 
134  private:
135   std::unique_ptr<FPDF_FileAvailContext> const file_avail_;
136   RetainPtr<FPDF_FileAccessContext> const file_read_;
137   std::unique_ptr<CPDF_DataAvail> const data_avail_;
138 };
139 
FPDFAvailContextFromFPDFAvail(FPDF_AVAIL avail)140 FPDF_AvailContext* FPDFAvailContextFromFPDFAvail(FPDF_AVAIL avail) {
141   return reinterpret_cast<FPDF_AvailContext*>(avail);
142 }
143 
FPDFAvailFromFPDFAvailContext(FPDF_AvailContext * pAvailContext)144 FPDF_AVAIL FPDFAvailFromFPDFAvailContext(FPDF_AvailContext* pAvailContext) {
145   return reinterpret_cast<FPDF_AVAIL>(pAvailContext);
146 }
147 
148 }  // namespace
149 
FPDFAvail_Create(FX_FILEAVAIL * file_avail,FPDF_FILEACCESS * file)150 FPDF_EXPORT FPDF_AVAIL FPDF_CALLCONV FPDFAvail_Create(FX_FILEAVAIL* file_avail,
151                                                       FPDF_FILEACCESS* file) {
152   auto pAvail = std::make_unique<FPDF_AvailContext>(file_avail, file);
153 
154   // Caller takes ownership.
155   return FPDFAvailFromFPDFAvailContext(pAvail.release());
156 }
157 
FPDFAvail_Destroy(FPDF_AVAIL avail)158 FPDF_EXPORT void FPDF_CALLCONV FPDFAvail_Destroy(FPDF_AVAIL avail) {
159   // Take ownership back from caller and destroy.
160   std::unique_ptr<FPDF_AvailContext>(FPDFAvailContextFromFPDFAvail(avail));
161 }
162 
FPDFAvail_IsDocAvail(FPDF_AVAIL avail,FX_DOWNLOADHINTS * hints)163 FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_IsDocAvail(FPDF_AVAIL avail,
164                                                    FX_DOWNLOADHINTS* hints) {
165   auto* avail_context = FPDFAvailContextFromFPDFAvail(avail);
166   if (!avail_context)
167     return PDF_DATA_ERROR;
168   FPDF_DownloadHintsContext hints_context(hints);
169   return avail_context->data_avail()->IsDocAvail(&hints_context);
170 }
171 
172 FPDF_EXPORT FPDF_DOCUMENT FPDF_CALLCONV
FPDFAvail_GetDocument(FPDF_AVAIL avail,FPDF_BYTESTRING password)173 FPDFAvail_GetDocument(FPDF_AVAIL avail, FPDF_BYTESTRING password) {
174   auto* avail_context = FPDFAvailContextFromFPDFAvail(avail);
175   if (!avail_context) {
176     return nullptr;
177   }
178 
179   auto [error, document] = avail_context->data_avail()->ParseDocument(
180       std::make_unique<CPDF_DocRenderData>(),
181       std::make_unique<CPDF_DocPageData>(), password);
182   if (error != CPDF_Parser::SUCCESS) {
183     ProcessParseError(error);
184     return nullptr;
185   }
186 
187   ReportUnsupportedFeatures(document.get());
188   return FPDFDocumentFromCPDFDocument(document.release());
189 }
190 
FPDFAvail_GetFirstPageNum(FPDF_DOCUMENT doc)191 FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_GetFirstPageNum(FPDF_DOCUMENT doc) {
192   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(doc);
193   return pDoc ? pDoc->GetParser()->GetFirstPageNo() : 0;
194 }
195 
FPDFAvail_IsPageAvail(FPDF_AVAIL avail,int page_index,FX_DOWNLOADHINTS * hints)196 FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_IsPageAvail(FPDF_AVAIL avail,
197                                                     int page_index,
198                                                     FX_DOWNLOADHINTS* hints) {
199   auto* avail_context = FPDFAvailContextFromFPDFAvail(avail);
200   if (!avail_context)
201     return PDF_DATA_ERROR;
202   if (page_index < 0)
203     return PDF_DATA_NOTAVAIL;
204   FPDF_DownloadHintsContext hints_context(hints);
205   return avail_context->data_avail()->IsPageAvail(page_index, &hints_context);
206 }
207 
FPDFAvail_IsFormAvail(FPDF_AVAIL avail,FX_DOWNLOADHINTS * hints)208 FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_IsFormAvail(FPDF_AVAIL avail,
209                                                     FX_DOWNLOADHINTS* hints) {
210   auto* avail_context = FPDFAvailContextFromFPDFAvail(avail);
211   if (!avail_context)
212     return PDF_FORM_ERROR;
213   FPDF_DownloadHintsContext hints_context(hints);
214   return avail_context->data_avail()->IsFormAvail(&hints_context);
215 }
216 
FPDFAvail_IsLinearized(FPDF_AVAIL avail)217 FPDF_EXPORT int FPDF_CALLCONV FPDFAvail_IsLinearized(FPDF_AVAIL avail) {
218   auto* avail_context = FPDFAvailContextFromFPDFAvail(avail);
219   if (!avail_context)
220     return PDF_LINEARIZATION_UNKNOWN;
221   return avail_context->data_avail()->IsLinearizedPDF();
222 }
223