32509eb837a7766cbab2248e9a77bd2b5093c146
[pdfium.git] / core / include / fpdfapi / fpdf_parser.h
1 // Copyright 2014 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
7 #ifndef CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_
8 #define CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_
9
10 #include "../../../third_party/base/nonstd_unique_ptr.h"
11 #include "../fxcrt/fx_system.h"
12 #include "fpdf_objects.h"
13
14 class CPDF_Document;
15 class CPDF_Parser;
16 class CPDF_SecurityHandler;
17 class CPDF_StandardSecurityHandler;
18 class CPDF_CryptoHandler;
19 class CPDF_Object;
20 class IFX_FileRead;
21 class CFDF_Document;
22 class CFDF_Parser;
23 class CFX_Font;
24 class CFX_AffineMatrix;
25 class CFX_FloatRect;
26 class CPDF_Point;
27 class CPDF_DocPageData;
28 class CPDF_DocRenderData;
29 class CPDF_ModuleMgr;
30 class CFX_DIBSource;
31 class CPDF_Font;
32 class CPDF_Image;
33 class CPDF_ColorSpace;
34 class CPDF_Pattern;
35 class CPDF_FontEncoding;
36 class CPDF_IccProfile;
37 class CFX_PrivateData;
38 #define FPDFPERM_PRINT 0x0004
39 #define FPDFPERM_MODIFY 0x0008
40 #define FPDFPERM_EXTRACT 0x0010
41 #define FPDFPERM_ANNOT_FORM 0x0020
42 #define FPDFPERM_FILL_FORM 0x0100
43 #define FPDFPERM_EXTRACT_ACCESS 0x0200
44 #define FPDFPERM_ASSEMBLE 0x0400
45 #define FPDFPERM_PRINT_HIGH 0x0800
46 #define FPDF_PAGE_MAX_NUM 0xFFFFF
47
48 // Use the accessors below instead of directly accessing PDF_CharType.
49 extern const char PDF_CharType[256];
50
51 inline bool PDFCharIsWhitespace(uint8_t c) {
52   return PDF_CharType[c] == 'W';
53 }
54 inline bool PDFCharIsNumeric(uint8_t c) {
55   return PDF_CharType[c] == 'N';
56 }
57 inline bool PDFCharIsDelimiter(uint8_t c) {
58   return PDF_CharType[c] == 'D';
59 }
60 inline bool PDFCharIsOther(uint8_t c) {
61   return PDF_CharType[c] == 'R';
62 }
63
64 inline bool PDFCharIsLineEnding(uint8_t c) {
65   return c == '\r' || c == '\n';
66 }
67
68 // Indexed by 8-bit char code, contains unicode code points.
69 extern const FX_WORD PDFDocEncoding[256];
70
71 class CPDF_Document : public CFX_PrivateData, public CPDF_IndirectObjects {
72  public:
73   CPDF_Document();
74   explicit CPDF_Document(CPDF_Parser* pParser);
75
76   ~CPDF_Document();
77
78   CPDF_Parser* GetParser() const { return m_pParser; }
79
80   CPDF_Dictionary* GetRoot() const { return m_pRootDict; }
81
82   CPDF_Dictionary* GetInfo() const { return m_pInfoDict; }
83
84   void GetID(CFX_ByteString& id1, CFX_ByteString& id2) const {
85     id1 = m_ID1;
86     id2 = m_ID2;
87   }
88
89   int GetPageCount() const;
90
91   CPDF_Dictionary* GetPage(int iPage);
92
93   int GetPageIndex(FX_DWORD objnum);
94
95   FX_DWORD GetUserPermissions(FX_BOOL bCheckRevision = FALSE) const;
96
97   FX_BOOL IsOwner() const;
98
99   CPDF_DocPageData* GetPageData() { return GetValidatePageData(); }
100
101   void ClearPageData();
102
103   void RemoveColorSpaceFromPageData(CPDF_Object* pObject);
104
105   CPDF_DocRenderData* GetRenderData() { return GetValidateRenderData(); }
106
107   void ClearRenderData();
108
109   void ClearRenderFont();
110
111   FX_BOOL IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) const;
112
113   // |pFontDict| must not be null.
114   CPDF_Font* LoadFont(CPDF_Dictionary* pFontDict);
115
116   CPDF_ColorSpace* LoadColorSpace(CPDF_Object* pCSObj,
117                                   CPDF_Dictionary* pResources = NULL);
118
119   CPDF_Pattern* LoadPattern(CPDF_Object* pObj,
120                             FX_BOOL bShading,
121                             const CFX_AffineMatrix* matrix = NULL);
122
123   CPDF_Image* LoadImageF(CPDF_Object* pObj);
124
125   CPDF_StreamAcc* LoadFontFile(CPDF_Stream* pStream);
126
127   CPDF_IccProfile* LoadIccProfile(CPDF_Stream* pStream);
128
129 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
130
131   CPDF_Font* AddWindowsFont(LOGFONTA* pLogFont,
132                             FX_BOOL bVert,
133                             FX_BOOL bTranslateName = FALSE);
134   CPDF_Font* AddWindowsFont(LOGFONTW* pLogFont,
135                             FX_BOOL bVert,
136                             FX_BOOL bTranslateName = FALSE);
137 #endif
138 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
139   CPDF_Font* AddMacFont(CTFontRef pFont,
140                         FX_BOOL bVert,
141                         FX_BOOL bTranslateName = FALSE);
142 #endif
143
144   CPDF_Font* AddStandardFont(const FX_CHAR* font, CPDF_FontEncoding* pEncoding);
145
146   CPDF_Font* AddFont(CFX_Font* pFont, int charset, FX_BOOL bVert);
147
148   void CreateNewDoc();
149
150   CPDF_Dictionary* CreateNewPage(int iPage);
151
152   void DeletePage(int iPage);
153
154   void LoadDoc();
155   void LoadAsynDoc(CPDF_Dictionary* pLinearized);
156   void LoadPages();
157
158  protected:
159   CPDF_Dictionary* m_pRootDict;
160
161   CPDF_Dictionary* m_pInfoDict;
162
163   CFX_ByteString m_ID1;
164
165   CFX_ByteString m_ID2;
166
167   FX_BOOL m_bLinearized;
168
169   FX_DWORD m_dwFirstPageNo;
170
171   FX_DWORD m_dwFirstPageObjNum;
172
173   CFX_DWordArray m_PageList;
174
175   int _GetPageCount() const;
176   CPDF_Dictionary* _FindPDFPage(CPDF_Dictionary* pPages,
177                                 int iPage,
178                                 int nPagesToGo,
179                                 int level);
180   int _FindPageIndex(CPDF_Dictionary* pNode,
181                      FX_DWORD& skip_count,
182                      FX_DWORD objnum,
183                      int& index,
184                      int level = 0);
185   FX_BOOL IsContentUsedElsewhere(FX_DWORD objnum, CPDF_Dictionary* pPageDict);
186   FX_BOOL CheckOCGVisible(CPDF_Dictionary* pOCG, FX_BOOL bPrinting);
187   CPDF_DocPageData* GetValidatePageData();
188   CPDF_DocRenderData* GetValidateRenderData();
189   friend class CPDF_Creator;
190   friend class CPDF_Parser;
191   friend class CPDF_DataAvail;
192   friend class CPDF_OCContext;
193
194   CPDF_DocPageData* m_pDocPage;
195
196   CPDF_DocRenderData* m_pDocRender;
197 };
198
199 #define PDFWORD_EOF 0
200 #define PDFWORD_NUMBER 1
201 #define PDFWORD_TEXT 2
202 #define PDFWORD_DELIMITER 3
203 #define PDFWORD_NAME 4
204 class CPDF_SimpleParser {
205  public:
206   CPDF_SimpleParser(const uint8_t* pData, FX_DWORD dwSize);
207
208   CPDF_SimpleParser(const CFX_ByteStringC& str);
209
210   CFX_ByteStringC GetWord();
211
212   FX_BOOL SearchToken(const CFX_ByteStringC& token);
213
214   FX_BOOL SkipWord(const CFX_ByteStringC& token);
215
216   FX_BOOL FindTagPair(const CFX_ByteStringC& start_token,
217                       const CFX_ByteStringC& end_token,
218                       FX_DWORD& start_pos,
219                       FX_DWORD& end_pos);
220
221   FX_BOOL FindTagParam(const CFX_ByteStringC& token, int nParams);
222
223   FX_DWORD GetPos() { return m_dwCurPos; }
224
225   void SetPos(FX_DWORD pos) {
226     ASSERT(pos <= m_dwSize);
227     m_dwCurPos = pos;
228   }
229
230  private:
231   void ParseWord(const uint8_t*& pStart, FX_DWORD& dwSize, int& type);
232
233   const uint8_t* m_pData;
234
235   FX_DWORD m_dwSize;
236
237   FX_DWORD m_dwCurPos;
238 };
239 class CPDF_SyntaxParser {
240  public:
241   CPDF_SyntaxParser();
242   virtual ~CPDF_SyntaxParser();
243
244   void InitParser(IFX_FileRead* pFileAccess, FX_DWORD HeaderOffset);
245
246   FX_FILESIZE SavePos() { return m_Pos; }
247
248   void RestorePos(FX_FILESIZE pos) { m_Pos = pos; }
249
250   CPDF_Object* GetObject(CPDF_IndirectObjects* pObjList,
251                          FX_DWORD objnum,
252                          FX_DWORD gennum,
253                          struct PARSE_CONTEXT* pContext = NULL,
254                          FX_BOOL bDecrypt = TRUE);
255
256   CPDF_Object* GetObjectByStrict(CPDF_IndirectObjects* pObjList,
257                                  FX_DWORD objnum,
258                                  FX_DWORD gennum,
259                                  struct PARSE_CONTEXT* pContext = NULL);
260
261   int GetDirectNum();
262
263   CFX_ByteString GetString(FX_DWORD objnum, FX_DWORD gennum);
264
265   CFX_ByteString GetName();
266
267   CFX_ByteString GetKeyword();
268
269   void GetBinary(uint8_t* buffer, FX_DWORD size);
270
271   void ToNextLine();
272
273   void ToNextWord();
274
275   FX_BOOL SearchWord(const CFX_ByteStringC& word,
276                      FX_BOOL bWholeWord,
277                      FX_BOOL bForward,
278                      FX_FILESIZE limit);
279
280   int SearchMultiWord(const CFX_ByteStringC& words,
281                       FX_BOOL bWholeWord,
282                       FX_FILESIZE limit);
283
284   FX_FILESIZE FindTag(const CFX_ByteStringC& tag, FX_FILESIZE limit);
285
286   void SetEncrypt(CPDF_CryptoHandler* pCryptoHandler) {
287     m_pCryptoHandler.reset(pCryptoHandler);
288   }
289
290   FX_BOOL IsEncrypted() { return m_pCryptoHandler != NULL; }
291
292   FX_BOOL GetCharAt(FX_FILESIZE pos, uint8_t& ch);
293
294   FX_BOOL ReadBlock(uint8_t* pBuf, FX_DWORD size);
295
296   CFX_ByteString GetNextWord(FX_BOOL& bIsNumber);
297
298  protected:
299   static const int kParserMaxRecursionDepth = 64;
300   static int s_CurrentRecursionDepth;
301
302   virtual FX_BOOL GetNextChar(uint8_t& ch);
303
304   FX_BOOL GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch);
305
306   void GetNextWord();
307
308   FX_BOOL IsWholeWord(FX_FILESIZE startpos,
309                       FX_FILESIZE limit,
310                       const uint8_t* tag,
311                       FX_DWORD taglen,
312                       FX_BOOL checkKeyword);
313
314   CFX_ByteString ReadString();
315
316   CFX_ByteString ReadHexString();
317
318   unsigned int ReadEOLMarkers(FX_FILESIZE pos);
319
320   CPDF_Stream* ReadStream(CPDF_Dictionary* pDict,
321                           PARSE_CONTEXT* pContext,
322                           FX_DWORD objnum,
323                           FX_DWORD gennum);
324
325   FX_FILESIZE m_Pos;
326
327   FX_BOOL m_bFileStream;
328
329   int m_MetadataObjnum;
330
331   IFX_FileRead* m_pFileAccess;
332
333   FX_DWORD m_HeaderOffset;
334
335   FX_FILESIZE m_FileLen;
336
337   uint8_t* m_pFileBuf;
338
339   FX_DWORD m_BufSize;
340
341   FX_FILESIZE m_BufOffset;
342
343   nonstd::unique_ptr<CPDF_CryptoHandler> m_pCryptoHandler;
344
345   uint8_t m_WordBuffer[257];
346
347   FX_DWORD m_WordSize;
348
349   FX_BOOL m_bIsNumber;
350
351   FX_FILESIZE m_dwWordPos;
352   friend class CPDF_Parser;
353   friend class CPDF_DataAvail;
354 };
355
356 #define PDFPARSE_TYPEONLY 1
357 #define PDFPARSE_NOSTREAM 2
358 struct PARSE_CONTEXT {
359   uint32_t m_Flags;
360   FX_FILESIZE m_DictStart;
361   FX_FILESIZE m_DictEnd;
362   FX_FILESIZE m_DataStart;
363   FX_FILESIZE m_DataEnd;
364 };
365
366 #define PDFPARSE_ERROR_SUCCESS 0
367 #define PDFPARSE_ERROR_FILE 1
368 #define PDFPARSE_ERROR_FORMAT 2
369 #define PDFPARSE_ERROR_PASSWORD 3
370 #define PDFPARSE_ERROR_HANDLER 4
371 #define PDFPARSE_ERROR_CERT 5
372
373 class CPDF_Parser {
374  public:
375   CPDF_Parser();
376   ~CPDF_Parser();
377
378   FX_DWORD StartParse(IFX_FileRead* pFile,
379                       FX_BOOL bReParse = FALSE,
380                       FX_BOOL bOwnFileRead = TRUE);
381
382   void CloseParser(FX_BOOL bReParse = FALSE);
383
384   FX_DWORD GetPermissions(FX_BOOL bCheckRevision = FALSE);
385
386   FX_BOOL IsOwner();
387
388   void SetPassword(const FX_CHAR* password) { m_Password = password; }
389
390   CFX_ByteString GetPassword() { return m_Password; }
391
392   CPDF_SecurityHandler* GetSecurityHandler() {
393     return m_pSecurityHandler.get();
394   }
395
396   CPDF_CryptoHandler* GetCryptoHandler() {
397     return m_Syntax.m_pCryptoHandler.get();
398   }
399
400   void SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler,
401                           FX_BOOL bForced = FALSE);
402
403   CFX_ByteString GetRecipient() { return m_bsRecipient; }
404
405   CPDF_Dictionary* GetTrailer() { return m_pTrailer; }
406
407   FX_FILESIZE GetLastXRefOffset() { return m_LastXRefOffset; }
408
409   CPDF_Document* GetDocument() { return m_pDocument; }
410
411   CFX_ArrayTemplate<CPDF_Dictionary*>* GetOtherTrailers() {
412     return &m_Trailers;
413   }
414
415   FX_DWORD GetRootObjNum();
416   FX_DWORD GetInfoObjNum();
417   CPDF_Array* GetIDArray();
418
419   CPDF_Dictionary* GetEncryptDict() { return m_pEncryptDict; }
420
421   FX_BOOL IsEncrypted() { return GetEncryptDict() != NULL; }
422
423   CPDF_Object* ParseIndirectObject(CPDF_IndirectObjects* pObjList,
424                                    FX_DWORD objnum,
425                                    PARSE_CONTEXT* pContext = NULL);
426   FX_DWORD GetLastObjNum();
427   FX_BOOL IsFormStream(FX_DWORD objnum, FX_BOOL& bForm);
428
429   FX_FILESIZE GetObjectOffset(FX_DWORD objnum);
430
431   FX_FILESIZE GetObjectSize(FX_DWORD objnum);
432
433   int GetObjectVersion(FX_DWORD objnum) { return m_ObjVersion[objnum]; }
434
435   void GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD& size);
436
437   FX_BOOL GetFileStreamOption() { return m_Syntax.m_bFileStream; }
438
439   void SetFileStreamOption(FX_BOOL b) { m_Syntax.m_bFileStream = b; }
440
441   IFX_FileRead* GetFileAccess() const { return m_Syntax.m_pFileAccess; }
442
443   int GetFileVersion() const { return m_FileVersion; }
444
445   FX_BOOL IsXRefStream() const { return m_bXRefStream; }
446   CPDF_Object* ParseIndirectObjectAt(CPDF_IndirectObjects* pObjList,
447                                      FX_FILESIZE pos,
448                                      FX_DWORD objnum,
449                                      struct PARSE_CONTEXT* pContext);
450
451   CPDF_Object* ParseIndirectObjectAtByStrict(CPDF_IndirectObjects* pObjList,
452                                              FX_FILESIZE pos,
453                                              FX_DWORD objnum,
454                                              struct PARSE_CONTEXT* pContext,
455                                              FX_FILESIZE* pResultPos);
456
457   FX_DWORD StartAsynParse(IFX_FileRead* pFile,
458                           FX_BOOL bReParse = FALSE,
459                           FX_BOOL bOwnFileRead = TRUE);
460
461   FX_DWORD GetFirstPageNo() { return m_dwFirstPageNo; }
462
463  protected:
464   CPDF_Document* m_pDocument;
465
466   CPDF_SyntaxParser m_Syntax;
467   FX_BOOL m_bOwnFileRead;
468   CPDF_Object* ParseDirect(CPDF_Object* pObj);
469
470   FX_BOOL LoadAllCrossRefV4(FX_FILESIZE pos);
471
472   FX_BOOL LoadAllCrossRefV5(FX_FILESIZE pos);
473
474   bool LoadCrossRefV4(FX_FILESIZE pos,
475                       FX_FILESIZE streampos,
476                       FX_BOOL bSkip,
477                       FX_BOOL bFirst);
478
479   FX_BOOL LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL bMainXRef);
480
481   CPDF_Dictionary* LoadTrailerV4();
482
483   FX_BOOL RebuildCrossRef();
484
485   FX_DWORD SetEncryptHandler();
486
487   void ReleaseEncryptHandler();
488
489   FX_BOOL LoadLinearizedAllCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount);
490
491   FX_BOOL LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount);
492
493   FX_BOOL LoadLinearizedAllCrossRefV5(FX_FILESIZE pos);
494
495   FX_DWORD LoadLinearizedMainXRefTable();
496
497   CFX_MapPtrToPtr m_ObjectStreamMap;
498
499   CPDF_StreamAcc* GetObjectStream(FX_DWORD number);
500
501   FX_BOOL IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset);
502
503   bool FindPosInOffsets(FX_FILESIZE pos) const;
504
505   int m_FileVersion;
506
507   CPDF_Dictionary* m_pTrailer;
508
509   CPDF_Dictionary* m_pEncryptDict;
510   void SetEncryptDictionary(CPDF_Dictionary* pDict);
511
512   FX_FILESIZE m_LastXRefOffset;
513
514   FX_BOOL m_bXRefStream;
515
516   nonstd::unique_ptr<CPDF_SecurityHandler> m_pSecurityHandler;
517
518   FX_BOOL m_bForceUseSecurityHandler;
519
520   CFX_ByteString m_bsRecipient;
521
522   CFX_ByteString m_FilePath;
523
524   CFX_ByteString m_Password;
525
526   CFX_FileSizeArray m_CrossRef;
527
528   CFX_ByteArray m_V5Type;
529
530   CFX_FileSizeArray m_SortedOffset;
531
532   CFX_WordArray m_ObjVersion;
533   CFX_ArrayTemplate<CPDF_Dictionary*> m_Trailers;
534
535   FX_BOOL m_bVersionUpdated;
536
537   CPDF_Object* m_pLinearized;
538
539   FX_DWORD m_dwFirstPageNo;
540
541   FX_DWORD m_dwXrefStartObjNum;
542   friend class CPDF_Creator;
543   friend class CPDF_DataAvail;
544 };
545 #define FXCIPHER_NONE 0
546 #define FXCIPHER_RC4 1
547 #define FXCIPHER_AES 2
548 #define FXCIPHER_AES2 3
549 class CPDF_SecurityHandler {
550  public:
551   virtual ~CPDF_SecurityHandler() {}
552
553   virtual FX_BOOL OnInit(CPDF_Parser* pParser,
554                          CPDF_Dictionary* pEncryptDict) = 0;
555
556   virtual FX_DWORD GetPermissions() = 0;
557
558   virtual FX_BOOL IsOwner() = 0;
559
560   virtual FX_BOOL GetCryptInfo(int& cipher,
561                                const uint8_t*& buffer,
562                                int& keylen) = 0;
563
564   virtual FX_BOOL IsMetadataEncrypted() { return TRUE; }
565
566   virtual CPDF_CryptoHandler* CreateCryptoHandler() = 0;
567
568   virtual CPDF_StandardSecurityHandler* GetStandardHandler() { return NULL; }
569 };
570 #define PDF_ENCRYPT_CONTENT 0
571 class CPDF_StandardSecurityHandler : public CPDF_SecurityHandler {
572  public:
573   CPDF_StandardSecurityHandler();
574   ~CPDF_StandardSecurityHandler() override;
575
576   // CPDF_SecurityHandler
577   FX_BOOL OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict) override;
578   FX_DWORD GetPermissions() override;
579   FX_BOOL IsOwner() override { return m_bOwner; }
580   FX_BOOL GetCryptInfo(int& cipher,
581                        const uint8_t*& buffer,
582                        int& keylen) override;
583   FX_BOOL IsMetadataEncrypted() override;
584   CPDF_CryptoHandler* CreateCryptoHandler() override;
585   CPDF_StandardSecurityHandler* GetStandardHandler() override { return this; }
586
587   void OnCreate(CPDF_Dictionary* pEncryptDict,
588                 CPDF_Array* pIdArray,
589                 const uint8_t* user_pass,
590                 FX_DWORD user_size,
591                 const uint8_t* owner_pass,
592                 FX_DWORD owner_size,
593                 FX_DWORD type = PDF_ENCRYPT_CONTENT);
594
595   void OnCreate(CPDF_Dictionary* pEncryptDict,
596                 CPDF_Array* pIdArray,
597                 const uint8_t* user_pass,
598                 FX_DWORD user_size,
599                 FX_DWORD type = PDF_ENCRYPT_CONTENT);
600
601   CFX_ByteString GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size);
602   CFX_ByteString GetUserPassword(const uint8_t* owner_pass,
603                                  FX_DWORD pass_size,
604                                  int32_t key_len);
605   int GetVersion() { return m_Version; }
606   int GetRevision() { return m_Revision; }
607
608   int CheckPassword(const uint8_t* password,
609                     FX_DWORD pass_size,
610                     FX_BOOL bOwner,
611                     uint8_t* key);
612   int CheckPassword(const uint8_t* password,
613                     FX_DWORD pass_size,
614                     FX_BOOL bOwner,
615                     uint8_t* key,
616                     int key_len);
617
618  private:
619   int m_Version;
620
621   int m_Revision;
622
623   CPDF_Parser* m_pParser;
624
625   CPDF_Dictionary* m_pEncryptDict;
626
627   FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict);
628   FX_BOOL LoadDict(CPDF_Dictionary* pEncryptDict,
629                    FX_DWORD type,
630                    int& cipher,
631                    int& key_len);
632
633   FX_BOOL CheckUserPassword(const uint8_t* password,
634                             FX_DWORD pass_size,
635                             FX_BOOL bIgnoreEncryptMeta,
636                             uint8_t* key,
637                             int32_t key_len);
638
639   FX_BOOL CheckOwnerPassword(const uint8_t* password,
640                              FX_DWORD pass_size,
641                              uint8_t* key,
642                              int32_t key_len);
643   FX_BOOL AES256_CheckPassword(const uint8_t* password,
644                                FX_DWORD size,
645                                FX_BOOL bOwner,
646                                uint8_t* key);
647   void AES256_SetPassword(CPDF_Dictionary* pEncryptDict,
648                           const uint8_t* password,
649                           FX_DWORD size,
650                           FX_BOOL bOwner,
651                           const uint8_t* key);
652   void AES256_SetPerms(CPDF_Dictionary* pEncryptDict,
653                        FX_DWORD permission,
654                        FX_BOOL bEncryptMetadata,
655                        const uint8_t* key);
656   void OnCreate(CPDF_Dictionary* pEncryptDict,
657                 CPDF_Array* pIdArray,
658                 const uint8_t* user_pass,
659                 FX_DWORD user_size,
660                 const uint8_t* owner_pass,
661                 FX_DWORD owner_size,
662                 FX_BOOL bDefault,
663                 FX_DWORD type);
664   FX_BOOL CheckSecurity(int32_t key_len);
665
666   FX_BOOL m_bOwner;
667
668   FX_DWORD m_Permissions;
669
670   int m_Cipher;
671
672   uint8_t m_EncryptKey[32];
673
674   int m_KeyLen;
675 };
676 class CPDF_CryptoHandler {
677  public:
678   virtual ~CPDF_CryptoHandler() {}
679
680   virtual FX_BOOL Init(CPDF_Dictionary* pEncryptDict,
681                        CPDF_SecurityHandler* pSecurityHandler) = 0;
682
683   virtual FX_DWORD DecryptGetSize(FX_DWORD src_size) = 0;
684
685   virtual void* DecryptStart(FX_DWORD objnum, FX_DWORD gennum) = 0;
686
687   virtual FX_BOOL DecryptStream(void* context,
688                                 const uint8_t* src_buf,
689                                 FX_DWORD src_size,
690                                 CFX_BinaryBuf& dest_buf) = 0;
691
692   virtual FX_BOOL DecryptFinish(void* context, CFX_BinaryBuf& dest_buf) = 0;
693
694   virtual FX_DWORD EncryptGetSize(FX_DWORD objnum,
695                                   FX_DWORD version,
696                                   const uint8_t* src_buf,
697                                   FX_DWORD src_size) = 0;
698
699   virtual FX_BOOL EncryptContent(FX_DWORD objnum,
700                                  FX_DWORD version,
701                                  const uint8_t* src_buf,
702                                  FX_DWORD src_size,
703                                  uint8_t* dest_buf,
704                                  FX_DWORD& dest_size) = 0;
705
706   void Decrypt(FX_DWORD objnum, FX_DWORD version, CFX_ByteString& str);
707 };
708 class CPDF_StandardCryptoHandler : public CPDF_CryptoHandler {
709  public:
710   CPDF_StandardCryptoHandler();
711   ~CPDF_StandardCryptoHandler() override;
712
713   // CPDF_CryptoHandler
714   FX_BOOL Init(CPDF_Dictionary* pEncryptDict,
715                CPDF_SecurityHandler* pSecurityHandler) override;
716   FX_DWORD DecryptGetSize(FX_DWORD src_size) override;
717   void* DecryptStart(FX_DWORD objnum, FX_DWORD gennum) override;
718   FX_BOOL DecryptStream(void* context,
719                         const uint8_t* src_buf,
720                         FX_DWORD src_size,
721                         CFX_BinaryBuf& dest_buf) override;
722   FX_BOOL DecryptFinish(void* context, CFX_BinaryBuf& dest_buf) override;
723   FX_DWORD EncryptGetSize(FX_DWORD objnum,
724                           FX_DWORD version,
725                           const uint8_t* src_buf,
726                           FX_DWORD src_size) override;
727   FX_BOOL EncryptContent(FX_DWORD objnum,
728                          FX_DWORD version,
729                          const uint8_t* src_buf,
730                          FX_DWORD src_size,
731                          uint8_t* dest_buf,
732                          FX_DWORD& dest_size) override;
733
734   FX_BOOL Init(int cipher, const uint8_t* key, int keylen);
735
736  protected:
737   virtual void CryptBlock(FX_BOOL bEncrypt,
738                           FX_DWORD objnum,
739                           FX_DWORD gennum,
740                           const uint8_t* src_buf,
741                           FX_DWORD src_size,
742                           uint8_t* dest_buf,
743                           FX_DWORD& dest_size);
744   virtual void* CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt);
745   virtual FX_BOOL CryptStream(void* context,
746                               const uint8_t* src_buf,
747                               FX_DWORD src_size,
748                               CFX_BinaryBuf& dest_buf,
749                               FX_BOOL bEncrypt);
750   virtual FX_BOOL CryptFinish(void* context,
751                               CFX_BinaryBuf& dest_buf,
752                               FX_BOOL bEncrypt);
753
754   uint8_t m_EncryptKey[32];
755
756   int m_KeyLen;
757
758   int m_Cipher;
759
760   uint8_t* m_pAESContext;
761 };
762 class CPDF_Point {
763  public:
764   CPDF_Point(FX_FLOAT xx, FX_FLOAT yy) {
765     x = xx;
766     y = yy;
767   }
768
769   FX_FLOAT x;
770
771   FX_FLOAT y;
772 };
773
774 #define CPDF_Rect CFX_FloatRect
775 #define CPDF_Matrix CFX_AffineMatrix
776 CFX_ByteString PDF_NameDecode(const CFX_ByteStringC& orig);
777 CFX_ByteString PDF_NameDecode(const CFX_ByteString& orig);
778 CFX_ByteString PDF_NameEncode(const CFX_ByteString& orig);
779 CFX_ByteString PDF_EncodeString(const CFX_ByteString& src,
780                                 FX_BOOL bHex = FALSE);
781 CFX_WideString PDF_DecodeText(const uint8_t* pData,
782                               FX_DWORD size,
783                               CFX_CharMap* pCharMap = NULL);
784 inline CFX_WideString PDF_DecodeText(const CFX_ByteString& bstr,
785                                      CFX_CharMap* pCharMap = NULL) {
786   return PDF_DecodeText((const uint8_t*)bstr.c_str(), bstr.GetLength(),
787                         pCharMap);
788 }
789 CFX_ByteString PDF_EncodeText(const FX_WCHAR* pString,
790                               int len = -1,
791                               CFX_CharMap* pCharMap = NULL);
792 inline CFX_ByteString PDF_EncodeText(const CFX_WideString& str,
793                                      CFX_CharMap* pCharMap = NULL) {
794   return PDF_EncodeText(str.c_str(), str.GetLength(), pCharMap);
795 }
796 FX_FLOAT PDF_ClipFloat(FX_FLOAT f);
797 class CFDF_Document : public CPDF_IndirectObjects {
798  public:
799   static CFDF_Document* CreateNewDoc();
800   static CFDF_Document* ParseFile(IFX_FileRead* pFile,
801                                   FX_BOOL bOwnFile = FALSE);
802   static CFDF_Document* ParseMemory(const uint8_t* pData, FX_DWORD size);
803
804   ~CFDF_Document();
805
806   FX_BOOL WriteBuf(CFX_ByteTextBuf& buf) const;
807
808   CPDF_Dictionary* GetRoot() const { return m_pRootDict; }
809
810   CFX_WideString GetWin32Path() const;
811
812  protected:
813   CFDF_Document();
814   void ParseStream(IFX_FileRead* pFile, FX_BOOL bOwnFile);
815   CPDF_Dictionary* m_pRootDict;
816   IFX_FileRead* m_pFile;
817   FX_BOOL m_bOwnFile;
818 };
819
820 CFX_WideString FPDF_FileSpec_GetWin32Path(const CPDF_Object* pFileSpec);
821 void FPDF_FileSpec_SetWin32Path(CPDF_Object* pFileSpec,
822                                 const CFX_WideString& fullpath);
823
824 void FlateEncode(const uint8_t* src_buf,
825                  FX_DWORD src_size,
826                  uint8_t*& dest_buf,
827                  FX_DWORD& dest_size);
828 void FlateEncode(const uint8_t* src_buf,
829                  FX_DWORD src_size,
830                  int predictor,
831                  int Colors,
832                  int BitsPerComponent,
833                  int Columns,
834                  uint8_t*& dest_buf,
835                  FX_DWORD& dest_size);
836 FX_DWORD FlateDecode(const uint8_t* src_buf,
837                      FX_DWORD src_size,
838                      uint8_t*& dest_buf,
839                      FX_DWORD& dest_size);
840 FX_DWORD RunLengthDecode(const uint8_t* src_buf,
841                          FX_DWORD src_size,
842                          uint8_t*& dest_buf,
843                          FX_DWORD& dest_size);
844 FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict);
845
846 class CPDF_NumberTree {
847  public:
848   CPDF_NumberTree(CPDF_Dictionary* pRoot) { m_pRoot = pRoot; }
849
850   CPDF_Object* LookupValue(int num);
851
852  protected:
853   CPDF_Dictionary* m_pRoot;
854 };
855
856 class IFX_FileAvail {
857  public:
858   virtual ~IFX_FileAvail() {}
859   virtual FX_BOOL IsDataAvail(FX_FILESIZE offset, FX_DWORD size) = 0;
860 };
861 class IFX_DownloadHints {
862  public:
863   virtual ~IFX_DownloadHints() {}
864   virtual void AddSegment(FX_FILESIZE offset, FX_DWORD size) = 0;
865 };
866 #define PDF_IS_LINEARIZED 1
867 #define PDF_NOT_LINEARIZED 0
868 #define PDF_UNKNOW_LINEARIZED -1
869 #define PDFFORM_NOTAVAIL 0
870 #define PDFFORM_AVAIL 1
871 #define PDFFORM_NOTEXIST 2
872 class IPDF_DataAvail {
873  public:
874   static IPDF_DataAvail* Create(IFX_FileAvail* pFileAvail,
875                                 IFX_FileRead* pFileRead);
876   virtual ~IPDF_DataAvail() {}
877
878   IFX_FileAvail* GetFileAvail() const { return m_pFileAvail; }
879   IFX_FileRead* GetFileRead() const { return m_pFileRead; }
880
881   virtual FX_BOOL IsDocAvail(IFX_DownloadHints* pHints) = 0;
882   virtual void SetDocument(CPDF_Document* pDoc) = 0;
883   virtual FX_BOOL IsPageAvail(int iPage, IFX_DownloadHints* pHints) = 0;
884   virtual FX_BOOL IsLinearized() = 0;
885   virtual int32_t IsFormAvail(IFX_DownloadHints* pHints) = 0;
886   virtual int32_t IsLinearizedPDF() = 0;
887   virtual void GetLinearizedMainXRefInfo(FX_FILESIZE* pPos,
888                                          FX_DWORD* pSize) = 0;
889
890  protected:
891   IPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
892
893   IFX_FileAvail* m_pFileAvail;
894   IFX_FileRead* m_pFileRead;
895 };
896 class CPDF_SortObjNumArray {
897  public:
898   void AddObjNum(FX_DWORD dwObjNum);
899
900   FX_BOOL Find(FX_DWORD dwObjNum);
901
902   void RemoveAll() { m_number_array.RemoveAll(); }
903
904  protected:
905   FX_BOOL BinarySearch(FX_DWORD value, int& iNext);
906
907  protected:
908   CFX_DWordArray m_number_array;
909 };
910 enum PDF_PAGENODE_TYPE {
911   PDF_PAGENODE_UNKOWN = 0,
912   PDF_PAGENODE_PAGE,
913   PDF_PAGENODE_PAGES,
914   PDF_PAGENODE_ARRAY,
915 };
916 class CPDF_PageNode {
917  public:
918   CPDF_PageNode() : m_type(PDF_PAGENODE_UNKOWN) {}
919   ~CPDF_PageNode();
920   PDF_PAGENODE_TYPE m_type;
921   FX_DWORD m_dwPageNo;
922   CFX_PtrArray m_childNode;
923 };
924 enum PDF_DATAAVAIL_STATUS {
925   PDF_DATAAVAIL_HEADER = 0,
926   PDF_DATAAVAIL_FIRSTPAGE,
927   PDF_DATAAVAIL_FIRSTPAGE_PREPARE,
928   PDF_DATAAVAIL_END,
929   PDF_DATAAVAIL_CROSSREF,
930   PDF_DATAAVAIL_CROSSREF_ITEM,
931   PDF_DATAAVAIL_CROSSREF_STREAM,
932   PDF_DATAAVAIL_TRAILER,
933   PDF_DATAAVAIL_LOADALLCRSOSSREF,
934   PDF_DATAAVAIL_ROOT,
935   PDF_DATAAVAIL_INFO,
936   PDF_DATAAVAIL_ACROFORM,
937   PDF_DATAAVAIL_ACROFORM_SUBOBJECT,
938   PDF_DATAAVAIL_PAGETREE,
939   PDF_DATAAVAIL_PAGE,
940   PDF_DATAAVAIL_PAGE_LATERLOAD,
941   PDF_DATAAVAIL_RESOURCES,
942   PDF_DATAAVAIL_DONE,
943   PDF_DATAAVAIL_ERROR,
944   PDF_DATAAVAIL_LOADALLFILE,
945   PDF_DATAAVAIL_TRAILER_APPEND
946 };
947
948 FX_BOOL PDF_DataDecode(const uint8_t* src_buf,
949                        FX_DWORD src_size,
950                        const CPDF_Dictionary* pDict,
951                        uint8_t*& dest_buf,
952                        FX_DWORD& dest_size,
953                        CFX_ByteString& ImageEncoding,
954                        CPDF_Dictionary*& pImageParms,
955                        FX_DWORD estimated_size,
956                        FX_BOOL bImageAcc);
957
958 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_