Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 1 | // Copyright 2018 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 | |
Dan Sinclair | 00d47a6 | 2018-03-28 18:39:04 +0000 | [diff] [blame] | 7 | #include "fpdfsdk/cpdfsdk_helpers.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 8 | |
Lei Zhang | bc10648 | 2019-05-30 23:55:19 +0000 | [diff] [blame] | 9 | #include "build/build_config.h" |
Lei Zhang | 865ffb1 | 2019-02-26 20:18:19 +0000 | [diff] [blame] | 10 | #include "constants/form_fields.h" |
Lei Zhang | 2617056 | 2018-04-17 17:01:52 +0000 | [diff] [blame] | 11 | #include "constants/stream_dict_common.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 12 | #include "core/fpdfapi/cpdf_modulemgr.h" |
Tom Sepez | a1d3442 | 2018-04-24 20:54:41 +0000 | [diff] [blame] | 13 | #include "core/fpdfapi/page/cpdf_page.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 14 | #include "core/fpdfapi/parser/cpdf_array.h" |
Lei Zhang | 8153561 | 2018-10-09 21:15:17 +0000 | [diff] [blame] | 15 | #include "core/fpdfapi/parser/cpdf_dictionary.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 16 | #include "core/fpdfapi/parser/cpdf_document.h" |
Artem Strygin | eababa1 | 2018-06-06 12:31:18 +0000 | [diff] [blame] | 17 | #include "core/fpdfapi/parser/cpdf_stream_acc.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 18 | #include "core/fpdfdoc/cpdf_annot.h" |
Lei Zhang | c345065 | 2018-10-11 16:54:42 +0000 | [diff] [blame] | 19 | #include "core/fpdfdoc/cpdf_interactiveform.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 20 | #include "core/fpdfdoc/cpdf_metadata.h" |
Lei Zhang | e6fcdfa | 2019-02-14 04:07:09 +0000 | [diff] [blame] | 21 | #include "fpdfsdk/cpdfsdk_formfillenvironment.h" |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 22 | #include "public/fpdf_ext.h" |
| 23 | |
Tom Sepez | a1d3442 | 2018-04-24 20:54:41 +0000 | [diff] [blame] | 24 | #ifdef PDF_ENABLE_XFA |
| 25 | #include "fpdfsdk/fpdfxfa/cpdfxfa_context.h" |
| 26 | #endif |
| 27 | |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 28 | namespace { |
| 29 | |
Ralf Sippl | 1638179 | 2018-04-12 21:20:26 +0000 | [diff] [blame] | 30 | constexpr char kQuadPoints[] = "QuadPoints"; |
| 31 | |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 32 | // 0 bit: FPDF_POLICY_MACHINETIME_ACCESS |
Lei Zhang | bc10648 | 2019-05-30 23:55:19 +0000 | [diff] [blame] | 33 | uint32_t g_sandbox_policy = 0xFFFFFFFF; |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 34 | |
Lei Zhang | bc10648 | 2019-05-30 23:55:19 +0000 | [diff] [blame] | 35 | #if !defined(OS_WIN) |
| 36 | int g_last_error = 0; |
| 37 | #endif |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 38 | |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 39 | bool RaiseUnsupportedError(int nError) { |
| 40 | auto* pAdapter = CPDF_ModuleMgr::Get()->GetUnsupportInfoAdapter(); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 41 | if (!pAdapter) |
| 42 | return false; |
| 43 | |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 44 | UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(pAdapter->info()); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 45 | if (info && info->FSDK_UnSupport_Handler) |
| 46 | info->FSDK_UnSupport_Handler(info, nError); |
| 47 | return true; |
| 48 | } |
| 49 | |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 50 | #ifdef PDF_ENABLE_XFA |
Tom Sepez | 5586545 | 2018-08-27 20:18:04 +0000 | [diff] [blame] | 51 | class FPDF_FileHandlerContext final : public IFX_SeekableStream { |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 52 | public: |
| 53 | template <typename T, typename... Args> |
| 54 | friend RetainPtr<T> pdfium::MakeRetain(Args&&... args); |
| 55 | |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 56 | // IFX_SeekableStream: |
| 57 | FX_FILESIZE GetSize() override; |
| 58 | bool IsEOF() override; |
| 59 | FX_FILESIZE GetPosition() override; |
Lei Zhang | f6a7921 | 2018-11-15 20:17:49 +0000 | [diff] [blame] | 60 | bool ReadBlockAtOffset(void* buffer, |
| 61 | FX_FILESIZE offset, |
| 62 | size_t size) override; |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 63 | size_t ReadBlock(void* buffer, size_t size) override; |
Lei Zhang | 59f7623 | 2018-11-15 20:22:59 +0000 | [diff] [blame] | 64 | bool WriteBlockAtOffset(const void* buffer, |
| 65 | FX_FILESIZE offset, |
| 66 | size_t size) override; |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 67 | bool Flush() override; |
| 68 | |
| 69 | void SetPosition(FX_FILESIZE pos) { m_nCurPos = pos; } |
| 70 | |
Tom Sepez | cb79825 | 2018-09-17 18:25:32 +0000 | [diff] [blame] | 71 | private: |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 72 | explicit FPDF_FileHandlerContext(FPDF_FILEHANDLER* pFS); |
Lei Zhang | 86688de | 2018-05-22 22:06:49 +0000 | [diff] [blame] | 73 | ~FPDF_FileHandlerContext() override; |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 74 | |
| 75 | FPDF_FILEHANDLER* m_pFS; |
| 76 | FX_FILESIZE m_nCurPos; |
| 77 | }; |
| 78 | |
| 79 | FPDF_FileHandlerContext::FPDF_FileHandlerContext(FPDF_FILEHANDLER* pFS) { |
| 80 | m_pFS = pFS; |
| 81 | m_nCurPos = 0; |
| 82 | } |
| 83 | |
| 84 | FPDF_FileHandlerContext::~FPDF_FileHandlerContext() { |
| 85 | if (m_pFS && m_pFS->Release) |
| 86 | m_pFS->Release(m_pFS->clientData); |
| 87 | } |
| 88 | |
| 89 | FX_FILESIZE FPDF_FileHandlerContext::GetSize() { |
| 90 | if (m_pFS && m_pFS->GetSize) |
| 91 | return (FX_FILESIZE)m_pFS->GetSize(m_pFS->clientData); |
| 92 | return 0; |
| 93 | } |
| 94 | |
| 95 | bool FPDF_FileHandlerContext::IsEOF() { |
| 96 | return m_nCurPos >= GetSize(); |
| 97 | } |
| 98 | |
| 99 | FX_FILESIZE FPDF_FileHandlerContext::GetPosition() { |
| 100 | return m_nCurPos; |
| 101 | } |
| 102 | |
Lei Zhang | f6a7921 | 2018-11-15 20:17:49 +0000 | [diff] [blame] | 103 | bool FPDF_FileHandlerContext::ReadBlockAtOffset(void* buffer, |
| 104 | FX_FILESIZE offset, |
| 105 | size_t size) { |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 106 | if (!buffer || !size || !m_pFS->ReadBlock) |
| 107 | return false; |
| 108 | |
| 109 | if (m_pFS->ReadBlock(m_pFS->clientData, (FPDF_DWORD)offset, buffer, |
| 110 | (FPDF_DWORD)size) == 0) { |
| 111 | m_nCurPos = offset + size; |
| 112 | return true; |
| 113 | } |
| 114 | return false; |
| 115 | } |
| 116 | |
| 117 | size_t FPDF_FileHandlerContext::ReadBlock(void* buffer, size_t size) { |
| 118 | if (!buffer || !size || !m_pFS->ReadBlock) |
| 119 | return 0; |
| 120 | |
| 121 | FX_FILESIZE nSize = GetSize(); |
| 122 | if (m_nCurPos >= nSize) |
| 123 | return 0; |
| 124 | FX_FILESIZE dwAvail = nSize - m_nCurPos; |
| 125 | if (dwAvail < (FX_FILESIZE)size) |
| 126 | size = static_cast<size_t>(dwAvail); |
| 127 | if (m_pFS->ReadBlock(m_pFS->clientData, (FPDF_DWORD)m_nCurPos, buffer, |
| 128 | (FPDF_DWORD)size) == 0) { |
| 129 | m_nCurPos += size; |
| 130 | return size; |
| 131 | } |
| 132 | |
| 133 | return 0; |
| 134 | } |
| 135 | |
Lei Zhang | 59f7623 | 2018-11-15 20:22:59 +0000 | [diff] [blame] | 136 | bool FPDF_FileHandlerContext::WriteBlockAtOffset(const void* buffer, |
| 137 | FX_FILESIZE offset, |
| 138 | size_t size) { |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 139 | if (!m_pFS || !m_pFS->WriteBlock) |
| 140 | return false; |
| 141 | |
| 142 | if (m_pFS->WriteBlock(m_pFS->clientData, (FPDF_DWORD)offset, buffer, |
| 143 | (FPDF_DWORD)size) == 0) { |
| 144 | m_nCurPos = offset + size; |
| 145 | return true; |
| 146 | } |
| 147 | return false; |
| 148 | } |
| 149 | |
| 150 | bool FPDF_FileHandlerContext::Flush() { |
| 151 | if (!m_pFS || !m_pFS->Flush) |
| 152 | return true; |
| 153 | |
| 154 | return m_pFS->Flush(m_pFS->clientData) == 0; |
| 155 | } |
| 156 | #endif // PDF_ENABLE_XFA |
| 157 | |
| 158 | } // namespace |
| 159 | |
Tom Sepez | 101535f | 2018-06-12 13:36:05 +0000 | [diff] [blame] | 160 | IPDF_Page* IPDFPageFromFPDFPage(FPDF_PAGE page) { |
| 161 | return reinterpret_cast<IPDF_Page*>(page); |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 162 | } |
| 163 | |
Tom Sepez | 101535f | 2018-06-12 13:36:05 +0000 | [diff] [blame] | 164 | FPDF_PAGE FPDFPageFromIPDFPage(IPDF_Page* page) { |
Tom Sepez | 3f3c39d | 2018-05-01 17:46:34 +0000 | [diff] [blame] | 165 | return reinterpret_cast<FPDF_PAGE>(page); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | CPDF_Document* CPDFDocumentFromFPDFDocument(FPDF_DOCUMENT doc) { |
Tom Sepez | fe06d51 | 2018-05-01 17:25:25 +0000 | [diff] [blame] | 169 | return reinterpret_cast<CPDF_Document*>(doc); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | FPDF_DOCUMENT FPDFDocumentFromCPDFDocument(CPDF_Document* doc) { |
Tom Sepez | fe06d51 | 2018-05-01 17:25:25 +0000 | [diff] [blame] | 173 | return reinterpret_cast<FPDF_DOCUMENT>(doc); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page) { |
Tom Sepez | 101535f | 2018-06-12 13:36:05 +0000 | [diff] [blame] | 177 | return page ? IPDFPageFromFPDFPage(page)->AsPDFPage() : nullptr; |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 178 | } |
| 179 | |
Lei Zhang | e6fcdfa | 2019-02-14 04:07:09 +0000 | [diff] [blame] | 180 | CPDFSDK_InteractiveForm* FormHandleToInteractiveForm(FPDF_FORMHANDLE hHandle) { |
| 181 | CPDFSDK_FormFillEnvironment* pFormFillEnv = |
| 182 | CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle); |
| 183 | return pFormFillEnv ? pFormFillEnv->GetInteractiveForm() : nullptr; |
| 184 | } |
| 185 | |
Lei Zhang | b46a763 | 2019-01-09 02:56:16 +0000 | [diff] [blame] | 186 | ByteString ByteStringFromFPDFWideString(FPDF_WIDESTRING wide_string) { |
| 187 | return WideStringFromFPDFWideString(wide_string).ToUTF8(); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 188 | } |
| 189 | |
Lei Zhang | f5fcd9e | 2018-12-23 03:11:50 +0000 | [diff] [blame] | 190 | WideString WideStringFromFPDFWideString(FPDF_WIDESTRING wide_string) { |
| 191 | return WideString::FromUTF16LE(wide_string, |
| 192 | WideString::WStringLength(wide_string)); |
| 193 | } |
| 194 | |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 195 | #ifdef PDF_ENABLE_XFA |
| 196 | RetainPtr<IFX_SeekableStream> MakeSeekableStream( |
| 197 | FPDF_FILEHANDLER* pFilehandler) { |
| 198 | return pdfium::MakeRetain<FPDF_FileHandlerContext>(pFilehandler); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 199 | } |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 200 | #endif // PDF_ENABLE_XFA |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 201 | |
Lei Zhang | 5cee3f2 | 2018-05-25 21:48:49 +0000 | [diff] [blame] | 202 | const CPDF_Array* GetQuadPointsArrayFromDictionary( |
| 203 | const CPDF_Dictionary* dict) { |
Lei Zhang | d934c64 | 2019-03-04 19:42:00 +0000 | [diff] [blame] | 204 | return dict->GetArrayFor("QuadPoints"); |
Lei Zhang | 5cee3f2 | 2018-05-25 21:48:49 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | CPDF_Array* GetQuadPointsArrayFromDictionary(CPDF_Dictionary* dict) { |
Lei Zhang | d934c64 | 2019-03-04 19:42:00 +0000 | [diff] [blame] | 208 | return dict->GetArrayFor("QuadPoints"); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 209 | } |
| 210 | |
Ralf Sippl | 1638179 | 2018-04-12 21:20:26 +0000 | [diff] [blame] | 211 | CPDF_Array* AddQuadPointsArrayToDictionary(CPDF_Dictionary* dict) { |
Ralf Sippl | 1638179 | 2018-04-12 21:20:26 +0000 | [diff] [blame] | 212 | return dict->SetNewFor<CPDF_Array>(kQuadPoints); |
| 213 | } |
| 214 | |
| 215 | bool IsValidQuadPointsIndex(const CPDF_Array* array, size_t index) { |
Lei Zhang | f40380f | 2018-10-12 18:31:51 +0000 | [diff] [blame] | 216 | return array && index < array->size() / 8; |
Ralf Sippl | 1638179 | 2018-04-12 21:20:26 +0000 | [diff] [blame] | 217 | } |
| 218 | |
| 219 | bool GetQuadPointsAtIndex(const CPDF_Array* array, |
| 220 | size_t quad_index, |
| 221 | FS_QUADPOINTSF* quad_points) { |
| 222 | ASSERT(quad_points); |
| 223 | ASSERT(array); |
| 224 | |
| 225 | if (!IsValidQuadPointsIndex(array, quad_index)) |
| 226 | return false; |
| 227 | |
| 228 | quad_index *= 8; |
| 229 | quad_points->x1 = array->GetNumberAt(quad_index); |
| 230 | quad_points->y1 = array->GetNumberAt(quad_index + 1); |
| 231 | quad_points->x2 = array->GetNumberAt(quad_index + 2); |
| 232 | quad_points->y2 = array->GetNumberAt(quad_index + 3); |
| 233 | quad_points->x3 = array->GetNumberAt(quad_index + 4); |
| 234 | quad_points->y3 = array->GetNumberAt(quad_index + 5); |
| 235 | quad_points->x4 = array->GetNumberAt(quad_index + 6); |
| 236 | quad_points->y4 = array->GetNumberAt(quad_index + 7); |
| 237 | return true; |
| 238 | } |
| 239 | |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 240 | CFX_FloatRect CFXFloatRectFromFSRECTF(const FS_RECTF& rect) { |
| 241 | return CFX_FloatRect(rect.left, rect.bottom, rect.right, rect.top); |
Dan Sinclair | 7aba472 | 2018-03-28 17:04:16 +0000 | [diff] [blame] | 242 | } |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 243 | |
| 244 | void FSRECTFFromCFXFloatRect(const CFX_FloatRect& rect, FS_RECTF* out_rect) { |
| 245 | out_rect->left = rect.left; |
| 246 | out_rect->top = rect.top; |
| 247 | out_rect->right = rect.right; |
| 248 | out_rect->bottom = rect.bottom; |
| 249 | } |
| 250 | |
Lei Zhang | 6fef1e4 | 2018-12-20 19:14:02 +0000 | [diff] [blame] | 251 | CFX_Matrix CFXMatrixFromFSMatrix(const FS_MATRIX& matrix) { |
| 252 | return CFX_Matrix(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f); |
| 253 | } |
| 254 | |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 255 | unsigned long Utf16EncodeMaybeCopyAndReturnLength(const WideString& text, |
| 256 | void* buffer, |
| 257 | unsigned long buflen) { |
| 258 | ByteString encoded_text = text.ToUTF16LE(); |
| 259 | unsigned long len = encoded_text.GetLength(); |
| 260 | if (buffer && len <= buflen) |
| 261 | memcpy(buffer, encoded_text.c_str(), len); |
| 262 | return len; |
| 263 | } |
| 264 | |
| 265 | unsigned long DecodeStreamMaybeCopyAndReturnLength(const CPDF_Stream* stream, |
| 266 | void* buffer, |
| 267 | unsigned long buflen) { |
| 268 | ASSERT(stream); |
| 269 | auto stream_acc = pdfium::MakeRetain<CPDF_StreamAcc>(stream); |
| 270 | stream_acc->LoadAllDataFiltered(); |
| 271 | const auto stream_data_size = stream_acc->GetSize(); |
| 272 | if (!buffer || buflen < stream_data_size) |
| 273 | return stream_data_size; |
| 274 | |
| 275 | memcpy(buffer, stream_acc->GetData(), stream_data_size); |
| 276 | return stream_data_size; |
| 277 | } |
| 278 | |
| 279 | void FSDK_SetSandBoxPolicy(FPDF_DWORD policy, FPDF_BOOL enable) { |
| 280 | switch (policy) { |
| 281 | case FPDF_POLICY_MACHINETIME_ACCESS: { |
| 282 | if (enable) |
| 283 | g_sandbox_policy |= 0x01; |
| 284 | else |
| 285 | g_sandbox_policy &= 0xFFFFFFFE; |
| 286 | } break; |
| 287 | default: |
| 288 | break; |
| 289 | } |
| 290 | } |
| 291 | |
| 292 | FPDF_BOOL FSDK_IsSandBoxPolicyEnabled(FPDF_DWORD policy) { |
| 293 | switch (policy) { |
| 294 | case FPDF_POLICY_MACHINETIME_ACCESS: |
| 295 | return !!(g_sandbox_policy & 0x01); |
| 296 | default: |
| 297 | return false; |
| 298 | } |
| 299 | } |
| 300 | |
| 301 | void ReportUnsupportedFeatures(CPDF_Document* pDoc) { |
| 302 | const CPDF_Dictionary* pRootDict = pDoc->GetRoot(); |
| 303 | if (pRootDict) { |
| 304 | // Portfolios and Packages |
| 305 | if (pRootDict->KeyExist("Collection")) { |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 306 | RaiseUnsupportedError(FPDF_UNSP_DOC_PORTABLECOLLECTION); |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 307 | return; |
| 308 | } |
| 309 | if (pRootDict->KeyExist("Names")) { |
| 310 | const CPDF_Dictionary* pNameDict = pRootDict->GetDictFor("Names"); |
| 311 | if (pNameDict && pNameDict->KeyExist("EmbeddedFiles")) { |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 312 | RaiseUnsupportedError(FPDF_UNSP_DOC_ATTACHMENT); |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 313 | return; |
| 314 | } |
| 315 | if (pNameDict && pNameDict->KeyExist("JavaScript")) { |
| 316 | const CPDF_Dictionary* pJSDict = pNameDict->GetDictFor("JavaScript"); |
| 317 | const CPDF_Array* pArray = |
| 318 | pJSDict ? pJSDict->GetArrayFor("Names") : nullptr; |
| 319 | if (pArray) { |
| 320 | for (size_t i = 0; i < pArray->size(); i++) { |
| 321 | ByteString cbStr = pArray->GetStringAt(i); |
| 322 | if (cbStr.Compare("com.adobe.acrobat.SharedReview.Register") == 0) { |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 323 | RaiseUnsupportedError(FPDF_UNSP_DOC_SHAREDREVIEW); |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 324 | return; |
| 325 | } |
| 326 | } |
| 327 | } |
| 328 | } |
| 329 | } |
| 330 | |
| 331 | // SharedForm |
| 332 | const CPDF_Stream* pStream = pRootDict->GetStreamFor("Metadata"); |
| 333 | if (pStream) { |
| 334 | CPDF_Metadata metaData(pStream); |
| 335 | for (const auto& err : metaData.CheckForSharedForm()) |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 336 | RaiseUnsupportedError(static_cast<int>(err)); |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 337 | } |
| 338 | } |
| 339 | |
| 340 | // XFA Forms |
| 341 | if (!pDoc->GetExtension() && CPDF_InteractiveForm(pDoc).HasXFAForm()) |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 342 | RaiseUnsupportedError(FPDF_UNSP_DOC_XFAFORM); |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 343 | } |
| 344 | |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 345 | void CheckForUnsupportedAnnot(const CPDF_Annot* pAnnot) { |
| 346 | switch (pAnnot->GetSubtype()) { |
| 347 | case CPDF_Annot::Subtype::FILEATTACHMENT: |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 348 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_ATTACHMENT); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 349 | break; |
| 350 | case CPDF_Annot::Subtype::MOVIE: |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 351 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_MOVIE); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 352 | break; |
| 353 | case CPDF_Annot::Subtype::RICHMEDIA: |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 354 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 355 | break; |
| 356 | case CPDF_Annot::Subtype::SCREEN: { |
| 357 | const CPDF_Dictionary* pAnnotDict = pAnnot->GetAnnotDict(); |
Lei Zhang | 6c71502 | 2019-02-26 20:16:09 +0000 | [diff] [blame] | 358 | ByteString cbString = pAnnotDict->GetStringFor("IT"); |
| 359 | if (cbString != "Img") |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 360 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_SCREEN_MEDIA); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 361 | break; |
| 362 | } |
| 363 | case CPDF_Annot::Subtype::SOUND: |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 364 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_SOUND); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 365 | break; |
| 366 | case CPDF_Annot::Subtype::THREED: |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 367 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_3DANNOT); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 368 | break; |
| 369 | case CPDF_Annot::Subtype::WIDGET: { |
| 370 | const CPDF_Dictionary* pAnnotDict = pAnnot->GetAnnotDict(); |
Lei Zhang | 865ffb1 | 2019-02-26 20:18:19 +0000 | [diff] [blame] | 371 | ByteString cbString = pAnnotDict->GetStringFor(pdfium::form_fields::kFT); |
Lei Zhang | f496e25 | 2019-02-26 20:20:19 +0000 | [diff] [blame] | 372 | if (cbString == pdfium::form_fields::kSig) |
Lei Zhang | b7d09ca | 2019-02-27 23:50:44 +0000 | [diff] [blame] | 373 | RaiseUnsupportedError(FPDF_UNSP_ANNOT_SIG); |
Lei Zhang | 4efdb51 | 2019-02-26 19:48:39 +0000 | [diff] [blame] | 374 | break; |
| 375 | } |
| 376 | default: |
| 377 | break; |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 378 | } |
| 379 | } |
| 380 | |
Lei Zhang | bc10648 | 2019-05-30 23:55:19 +0000 | [diff] [blame] | 381 | #if !defined(OS_WIN) |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 382 | void SetLastError(int err) { |
| 383 | g_last_error = err; |
| 384 | } |
| 385 | |
| 386 | int GetLastError() { |
| 387 | return g_last_error; |
| 388 | } |
Lei Zhang | bc10648 | 2019-05-30 23:55:19 +0000 | [diff] [blame] | 389 | #endif |
Lei Zhang | 65a8d5e | 2018-12-20 19:13:21 +0000 | [diff] [blame] | 390 | |
| 391 | void ProcessParseError(CPDF_Parser::Error err) { |
| 392 | uint32_t err_code = FPDF_ERR_SUCCESS; |
| 393 | // Translate FPDFAPI error code to FPDFVIEW error code |
| 394 | switch (err) { |
| 395 | case CPDF_Parser::SUCCESS: |
| 396 | err_code = FPDF_ERR_SUCCESS; |
| 397 | break; |
| 398 | case CPDF_Parser::FILE_ERROR: |
| 399 | err_code = FPDF_ERR_FILE; |
| 400 | break; |
| 401 | case CPDF_Parser::FORMAT_ERROR: |
| 402 | err_code = FPDF_ERR_FORMAT; |
| 403 | break; |
| 404 | case CPDF_Parser::PASSWORD_ERROR: |
| 405 | err_code = FPDF_ERR_PASSWORD; |
| 406 | break; |
| 407 | case CPDF_Parser::HANDLER_ERROR: |
| 408 | err_code = FPDF_ERR_SECURITY; |
| 409 | break; |
| 410 | } |
| 411 | SetLastError(err_code); |
| 412 | } |