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