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