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