1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
//========================================================================
//
// XRef.h
//
// Copyright 1996-2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2005 Brad Hards <bradh@frogmouth.net>
// Copyright (C) 2006, 2008, 2010-2012 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2007-2008 Julien Rebetez <julienr@svn.gnome.org>
// Copyright (C) 2007 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2010 Ilya Gorenbein <igorenbein@finjan.com>
// Copyright (C) 2010 Hib Eris <hib@hiberis.nl>
// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@kabelmail.de>
// Copyright (C) 2012 Fabio D'Urso <fabiodurso@hotmail.it>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#ifndef XREF_H
#define XREF_H
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include "goo/gtypes.h"
#include "Object.h"
#include "Stream.h"
#include <vector>
class Dict;
class Stream;
class Parser;
class PopplerCache;
//------------------------------------------------------------------------
// XRef
//------------------------------------------------------------------------
enum XRefEntryType {
xrefEntryFree,
xrefEntryUncompressed,
xrefEntryCompressed,
xrefEntryNone
};
struct XRefEntry {
Guint offset;
int gen;
XRefEntryType type;
int flags;
Object obj; //if this entry was updated, obj will contains the updated object
enum Flag {
// Regular flags
Updated, // Entry was modified
// Special flags -- available only after xref->scanSpecialFlags() is run
Unencrypted, // Entry is stored in unencrypted form (meaningless in unencrypted documents)
DontRewrite // Entry must not be written back in case of full rewrite
};
inline GBool getFlag(Flag flag) {
const int mask = (1 << (int)flag);
return (flags & mask) != 0;
}
inline void setFlag(Flag flag, GBool value) {
const int mask = (1 << (int)flag);
if (value) {
flags |= mask;
} else {
flags &= ~mask;
}
}
};
class XRef {
public:
// Constructor, create an empty XRef, used for PDF writing
XRef();
// Constructor, create an empty XRef but with info dict, used for PDF writing
XRef(Object *trailerDictA);
// Constructor. Read xref table from stream.
XRef(BaseStream *strA, Guint pos, Guint mainXRefEntriesOffsetA = 0, GBool *wasReconstructed = NULL, GBool reconstruct = false);
// Destructor.
~XRef();
// Is xref table valid?
GBool isOk() { return ok; }
// Is the last XRef section a stream or a table?
GBool isXRefStream() { return xRefStream; }
// Get the error code (if isOk() returns false).
int getErrorCode() { return errCode; }
// Set the encryption parameters.
void setEncryption(int permFlagsA, GBool ownerPasswordOkA,
Guchar *fileKeyA, int keyLengthA,
int encVersionA, int encRevisionA,
CryptAlgorithm encAlgorithmA);
// Mark Encrypt entry as Unencrypted
void markUnencrypted();
void getEncryptionParameters(Guchar **fileKeyA, CryptAlgorithm *encAlgorithmA, int *keyLengthA);
// Is the file encrypted?
GBool isEncrypted() { return encrypted; }
// Check various permissions.
GBool okToPrint(GBool ignoreOwnerPW = gFalse);
GBool okToPrintHighRes(GBool ignoreOwnerPW = gFalse);
GBool okToChange(GBool ignoreOwnerPW = gFalse);
GBool okToCopy(GBool ignoreOwnerPW = gFalse);
GBool okToAddNotes(GBool ignoreOwnerPW = gFalse);
GBool okToFillForm(GBool ignoreOwnerPW = gFalse);
GBool okToAccessibility(GBool ignoreOwnerPW = gFalse);
GBool okToAssemble(GBool ignoreOwnerPW = gFalse);
int getPermFlags() { return permFlags; }
// Get catalog object.
Object *getCatalog(Object *obj);
// Fetch an indirect reference.
Object *fetch(int num, int gen, Object *obj, int recursion = 0);
// Return the document's Info dictionary (if any).
Object *getDocInfo(Object *obj);
Object *getDocInfoNF(Object *obj);
// Return the number of objects in the xref table.
int getNumObjects() { return size; }
// Return the catalog object reference.
int getRootNum() { return rootNum; }
int getRootGen() { return rootGen; }
// Get end position for a stream in a damaged file.
// Returns false if unknown or file is not damaged.
GBool getStreamEnd(Guint streamStart, Guint *streamEnd);
// Retuns the entry that belongs to the offset
int getNumEntry(Guint offset);
// Scans the document and sets special flags in all xref entries. One of those
// flags is Unencrypted, which affects how the object is fetched. Therefore,
// this function must be called before fetching unencrypted objects (e.g.
// Encrypt dictionary, XRef streams). Note that the code that initializes
// decryption doesn't need to call this function, because it runs before
// decryption is enabled, and therefore the Unencrypted flag is ignored.
void scanSpecialFlags();
// Direct access.
XRefEntry *getEntry(int i, GBool complainIfMissing = gTrue);
Object *getTrailerDict() { return &trailerDict; }
// Write access
void setModifiedObject(Object* o, Ref r);
Ref addIndirectObject (Object* o);
void removeIndirectObject(Ref r);
void add(int num, int gen, Guint offs, GBool used);
// Output XRef table to stream
void writeTableToFile(OutStream* outStr, GBool writeAllEntries);
// Output XRef stream contents to GooString and fill trailerDict fields accordingly
void writeStreamToBuffer(GooString *stmBuf, Dict *xrefDict, XRef *xref);
private:
BaseStream *str; // input stream
Guint start; // offset in file (to allow for garbage
// at beginning of file)
XRefEntry *entries; // xref entries
int capacity; // size of <entries> array
int size; // number of entries
int rootNum, rootGen; // catalog dict
GBool ok; // true if xref table is valid
int errCode; // error code (if <ok> is false)
Object trailerDict; // trailer dictionary
Guint *streamEnds; // 'endstream' positions - only used in
// damaged files
int streamEndsLen; // number of valid entries in streamEnds
PopplerCache *objStrs; // cached object streams
GBool encrypted; // true if file is encrypted
int encRevision;
int encVersion; // encryption algorithm
CryptAlgorithm encAlgorithm; // encryption algorithm
int keyLength; // length of key, in bytes
int permFlags; // permission bits
Guchar fileKey[32]; // file decryption key
GBool ownerPasswordOk; // true if owner password is correct
Guint prevXRefOffset; // position of prev XRef section (= next to read)
Guint mainXRefEntriesOffset; // offset of entries in main XRef table
GBool xRefStream; // true if last XRef section is a stream
Guint mainXRefOffset; // position of the main XRef table/stream
GBool scannedSpecialFlags; // true if scanSpecialFlags has been called
void init();
int reserve(int newSize);
int resize(int newSize);
GBool readXRef(Guint *pos, std::vector<Guint> *followedXRefStm, std::vector<int> *xrefStreamObjsNum);
GBool readXRefTable(Parser *parser, Guint *pos, std::vector<Guint> *followedXRefStm, std::vector<int> *xrefStreamObjsNum);
GBool readXRefStreamSection(Stream *xrefStr, int *w, int first, int n);
GBool readXRefStream(Stream *xrefStr, Guint *pos);
GBool constructXRef(GBool *wasReconstructed, GBool needCatalogDict = gFalse);
GBool parseEntry(Guint offset, XRefEntry *entry);
void readXRefUntil(int untilEntryNum, std::vector<int> *xrefStreamObjsNum = NULL);
void markUnencrypted(Object *obj);
class XRefWriter {
public:
virtual void startSection(int first, int count) = 0;
virtual void writeEntry(Guint offset, int gen, XRefEntryType type) = 0;
virtual ~XRefWriter() {};
};
class XRefTableWriter: public XRefWriter {
public:
XRefTableWriter(OutStream* outStrA);
void startSection(int first, int count);
void writeEntry(Guint offset, int gen, XRefEntryType type);
private:
OutStream* outStr;
};
class XRefStreamWriter: public XRefWriter {
public:
XRefStreamWriter(Object *index, GooString *stmBuf);
void startSection(int first, int count);
void writeEntry(Guint offset, int gen, XRefEntryType type);
private:
Object *index;
GooString *stmBuf;
};
void writeXRef(XRefWriter *writer, GBool writeAllEntries);
};
#endif
|