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