Coverage Report

Created: 2026-11-13 07:01

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qpdf/libqpdf/QPDFParser.cc
Line
Count
Source
1
#include <qpdf/QPDFParser.hh>
2
3
#include <qpdf/QPDF.hh>
4
#include <qpdf/QPDFObjGen.hh>
5
#include <qpdf/QPDFObjectHandle.hh>
6
#include <qpdf/QPDFObject_private.hh>
7
#include <qpdf/QPDFTokenizer_private.hh>
8
#include <qpdf/QTC.hh>
9
#include <qpdf/QUtil.hh>
10
11
#include <memory>
12
13
using namespace std::literals;
14
using namespace qpdf;
15
16
using ObjectPtr = std::shared_ptr<QPDFObject>;
17
18
static uint32_t const& max_nesting{global::Limits::parser_max_nesting()};
19
20
// The ParseGuard class allows QPDFParser to detect re-entrant parsing. It also provides
21
// special access to allow the parser to create unresolved objects and dangling references.
22
class QPDF::Doc::ParseGuard
23
{
24
  public:
25
    ParseGuard(QPDF* qpdf) :
26
31.2M
        objects(qpdf ? &qpdf->m->objects : nullptr)
27
31.2M
    {
28
31.2M
        if (objects) {
29
31.2M
            objects->inParse(true);
30
31.2M
        }
31
31.2M
    }
32
33
    static std::shared_ptr<QPDFObject>
34
    getObject(QPDF* qpdf, int id, int gen, bool parse_pdf)
35
5.03M
    {
36
5.03M
        return qpdf->m->objects.getObjectForParser(id, gen, parse_pdf);
37
5.03M
    }
38
39
    ~ParseGuard()
40
31.2M
    {
41
31.2M
        if (objects) {
42
31.2M
            objects->inParse(false);
43
31.2M
        }
44
31.2M
    }
45
    QPDF::Doc::Objects* objects;
46
};
47
48
using ParseGuard = QPDF::Doc::ParseGuard;
49
using Parser = qpdf::impl::Parser;
50
51
QPDFObjectHandle
52
Parser::parse(InputSource& input, std::string const& object_description, QPDF* context)
53
49.7k
{
54
49.7k
    qpdf::Tokenizer tokenizer;
55
49.7k
    if (auto result = Parser(
56
49.7k
                          input,
57
49.7k
                          make_description(input.getName(), object_description),
58
49.7k
                          object_description,
59
49.7k
                          tokenizer,
60
49.7k
                          nullptr,
61
49.7k
                          context,
62
49.7k
                          false)
63
49.7k
                          .parse()) {
64
49.0k
        return result;
65
49.0k
    }
66
633
    return {QPDFObject::create<QPDF_Null>()};
67
49.7k
}
68
69
std::pair<QPDFObjectHandle, bool>
70
Parser::parse_content(
71
    InputSource& input,
72
    std::shared_ptr<QPDFObject::Description> sp_description,
73
    qpdf::Tokenizer& tokenizer,
74
    QPDF* context)
75
29.0M
{
76
29.0M
    static const std::string content("content"); // GCC12 - make constexpr
77
29.0M
    auto p = Parser(
78
29.0M
        input,
79
29.0M
        std::move(sp_description),
80
29.0M
        content,
81
29.0M
        tokenizer,
82
29.0M
        nullptr,
83
29.0M
        context,
84
29.0M
        true,
85
29.0M
        0,
86
29.0M
        0,
87
29.0M
        context && context->doc().reconstructed_xref());
88
29.0M
    if (auto result = p.parse(true)) {
89
29.0M
        return {result, false};
90
29.0M
    }
91
24.3k
    return {{}, p.empty_};
92
29.0M
}
93
94
QPDFObjectHandle
95
Parser::parse(
96
    InputSource& input,
97
    std::string const& object_description,
98
    QPDFTokenizer& tokenizer,
99
    bool& empty,
100
    QPDFObjectHandle::StringDecrypter* decrypter,
101
    QPDF* context)
102
0
{
103
    // ABI: This parse overload is only used by the deprecated QPDFObjectHandle::parse. It is the
104
    // only user of the 'empty' member. When removing this overload also remove 'empty'.
105
0
    auto p = Parser(
106
0
        input,
107
0
        make_description(input.getName(), object_description),
108
0
        object_description,
109
0
        *tokenizer.m,
110
0
        decrypter,
111
0
        context,
112
0
        false);
113
0
    auto result = p.parse();
114
0
    empty = p.empty_;
115
0
    if (result) {
116
0
        return result;
117
0
    }
118
0
    return {QPDFObject::create<QPDF_Null>()};
119
0
}
120
121
QPDFObjectHandle
122
Parser::parse(
123
    InputSource& input,
124
    std::string const& object_description,
125
    qpdf::Tokenizer& tokenizer,
126
    QPDFObjectHandle::StringDecrypter* decrypter,
127
    QPDF& context,
128
    bool sanity_checks)
129
1.74M
{
130
1.74M
    return Parser(
131
1.74M
               input,
132
1.74M
               make_description(input.getName(), object_description),
133
1.74M
               object_description,
134
1.74M
               tokenizer,
135
1.74M
               decrypter,
136
1.74M
               &context,
137
1.74M
               true,
138
1.74M
               0,
139
1.74M
               0,
140
1.74M
               sanity_checks)
141
1.74M
        .parse();
142
1.74M
}
143
144
QPDFObjectHandle
145
Parser::parse(
146
    is::OffsetBuffer& input, int stream_id, int obj_id, qpdf::Tokenizer& tokenizer, QPDF& context)
147
420k
{
148
420k
    return Parser(
149
420k
               input,
150
420k
               std::make_shared<QPDFObject::Description>(
151
420k
                   QPDFObject::ObjStreamDescr(stream_id, obj_id)),
152
420k
               "",
153
420k
               tokenizer,
154
420k
               nullptr,
155
420k
               &context,
156
420k
               true,
157
420k
               stream_id,
158
420k
               obj_id)
159
420k
        .parse();
160
420k
}
161
162
QPDFObjectHandle
163
Parser::parse(bool content_stream)
164
31.2M
{
165
31.2M
    try {
166
31.2M
        return parse_first(content_stream);
167
31.2M
    } catch (Error&) {
168
112k
        return {};
169
112k
    } catch (QPDFExc& e) {
170
49.0k
        throw e;
171
49.0k
    } catch (std::logic_error& e) {
172
30
        throw e;
173
16.4k
    } catch (std::exception& e) {
174
16.4k
        warn("treating object as null because of error during parsing: "s + e.what());
175
16.4k
        return {};
176
16.4k
    }
177
31.2M
}
178
179
QPDFObjectHandle
180
Parser::parse_first(bool content_stream)
181
31.2M
{
182
    // This method must take care not to resolve any objects. Don't check the type of any object
183
    // without first ensuring that it is a direct object. Otherwise, doing so may have the side
184
    // effect of reading the object and changing the file pointer. If you do this, it will cause a
185
    // logic error to be thrown from QPDF::inParse().
186
187
31.2M
    QPDF::Doc::ParseGuard pg(context_);
188
31.2M
    start_ = input_.tell();
189
31.2M
    if (!tokenizer_.nextToken(input_, object_description_)) {
190
30.4k
        warn(tokenizer_.getErrorMessage());
191
30.4k
    }
192
193
31.2M
    switch (tokenizer_.getType()) {
194
16.7k
    case QPDFTokenizer::tt_eof:
195
16.7k
        if (content_stream) {
196
            // In content stream mode, leave object uninitialized to indicate EOF
197
11.1k
            empty_ = true;
198
11.1k
            return {};
199
11.1k
        }
200
5.52k
        warn("unexpected EOF");
201
5.52k
        return {};
202
203
28.3k
    case QPDFTokenizer::tt_bad:
204
28.3k
        return {};
205
206
2.80k
    case QPDFTokenizer::tt_brace_open:
207
5.12k
    case QPDFTokenizer::tt_brace_close:
208
5.12k
        warn("treating unexpected brace token as null");
209
5.12k
        return {};
210
211
8.23k
    case QPDFTokenizer::tt_array_close:
212
8.23k
        warn("treating unexpected array close token as null");
213
8.23k
        return {};
214
215
6.46k
    case QPDFTokenizer::tt_dict_close:
216
6.46k
        warn("unexpected dictionary close token");
217
6.46k
        return {};
218
219
228k
    case QPDFTokenizer::tt_array_open:
220
1.97M
    case QPDFTokenizer::tt_dict_open:
221
1.97M
        stack_.clear();
222
1.97M
        stack_.emplace_back(
223
1.97M
            input_,
224
1.97M
            (tokenizer_.getType() == QPDFTokenizer::tt_array_open) ? st_array : st_dictionary_key);
225
1.97M
        frame_ = &stack_.back();
226
1.97M
        return parse_remainder(content_stream);
227
228
8.52k
    case QPDFTokenizer::tt_bool:
229
8.52k
        return with_description<QPDF_Bool>(tokenizer_.getValue() == "true");
230
231
3.17k
    case QPDFTokenizer::tt_null:
232
3.17k
        return {QPDFObject::create<QPDF_Null>()};
233
234
1.15M
    case QPDFTokenizer::tt_integer:
235
1.15M
        return with_description<QPDF_Integer>(QUtil::string_to_ll(tokenizer_.getValue().c_str()));
236
237
510k
    case QPDFTokenizer::tt_real:
238
510k
        return with_description<QPDF_Real>(tokenizer_.getValue());
239
240
263k
    case QPDFTokenizer::tt_name:
241
263k
        return with_description<QPDF_Name>(tokenizer_.getValue());
242
243
27.1M
    case QPDFTokenizer::tt_word:
244
27.1M
        {
245
27.1M
            auto const& value = tokenizer_.getValue();
246
27.1M
            if (content_stream) {
247
27.0M
                return with_description<QPDF_Operator>(value);
248
27.0M
            } else if (value == "endobj") {
249
                // We just saw endobj without having read anything. Nothing in the PDF spec appears
250
                // to allow empty objects, but they have been encountered in actual PDF files and
251
                // Adobe Reader appears to ignore them. Treat this as a null and do not move the
252
                // input source's offset.
253
2.60k
                empty_ = true;
254
2.60k
                input_.seek(input_.getLastOffset(), SEEK_SET);
255
2.60k
                if (!content_stream) {
256
2.60k
                    warn("empty object treated as null");
257
2.60k
                }
258
2.60k
                return {};
259
96.2k
            } else {
260
96.2k
                warn("unknown token while reading object; treating as string");
261
96.2k
                return with_description<QPDF_String>(value);
262
96.2k
            }
263
27.1M
        }
264
265
109k
    case QPDFTokenizer::tt_string:
266
109k
        if (decrypter_) {
267
2.10k
            std::string s{tokenizer_.getValue()};
268
2.10k
            decrypter_->decryptString(s);
269
2.10k
            return with_description<QPDF_String>(s);
270
107k
        } else {
271
107k
            return with_description<QPDF_String>(tokenizer_.getValue());
272
107k
        }
273
274
0
    default:
275
0
        warn("treating unknown token type as null while reading object");
276
0
        return {};
277
31.2M
    }
278
31.2M
}
279
280
QPDFObjectHandle
281
Parser::parse_remainder(bool content_stream)
282
1.97M
{
283
    // This method must take care not to resolve any objects. Don't check the type of any object
284
    // without first ensuring that it is a direct object. Otherwise, doing so may have the side
285
    // effect of reading the object and changing the file pointer. If you do this, it will cause a
286
    // logic error to be thrown from QPDF::inParse().
287
288
1.97M
    bad_count_ = 0;
289
1.97M
    bool b_contents = false;
290
291
134M
    while (true) {
292
134M
        if (!tokenizer_.nextToken(input_, object_description_)) {
293
504k
            warn(tokenizer_.getErrorMessage());
294
504k
        }
295
134M
        ++good_count_; // optimistically
296
297
134M
        if (int_count_ != 0) {
298
            // Special handling of indirect references. Treat integer tokens as part of an indirect
299
            // reference until proven otherwise.
300
44.6M
            if (tokenizer_.getType() == QPDFTokenizer::tt_integer) {
301
36.3M
                if (++int_count_ > 2) {
302
                    // Process the oldest buffered integer.
303
30.4M
                    add_int(int_count_);
304
30.4M
                }
305
36.3M
                last_offset_buffer_[int_count_ % 2] = input_.getLastOffset();
306
36.3M
                int_buffer_[int_count_ % 2] = QUtil::string_to_ll(tokenizer_.getValue().c_str());
307
36.3M
                continue;
308
309
36.3M
            } else if (
310
8.28M
                int_count_ >= 2 && tokenizer_.getType() == QPDFTokenizer::tt_word &&
311
5.34M
                tokenizer_.getValue() == "R") {
312
5.06M
                if (!context_) {
313
0
                    throw std::logic_error(
314
0
                        "Parser::parse called without context on an object with indirect "
315
0
                        "references");
316
0
                }
317
5.06M
                auto id = QIntC::to_int(int_buffer_[(int_count_ - 1) % 2]);
318
5.06M
                auto gen = QIntC::to_int(int_buffer_[(int_count_) % 2]);
319
5.06M
                if (!(id < 1 || gen < 0 || gen >= 65535)) {
320
5.03M
                    add(ParseGuard::getObject(context_, id, gen, parse_pdf_));
321
5.03M
                } else {
322
35.1k
                    add_bad_null(
323
35.1k
                        "treating bad indirect reference (" + std::to_string(id) + " " +
324
35.1k
                        std::to_string(gen) + " R) as null");
325
35.1k
                }
326
5.06M
                int_count_ = 0;
327
5.06M
                continue;
328
329
5.06M
            } else if (int_count_ > 0) {
330
                // Process the buffered integers before processing the current token.
331
3.21M
                if (int_count_ > 1) {
332
881k
                    add_int(int_count_ - 1);
333
881k
                }
334
3.21M
                add_int(int_count_);
335
3.21M
                int_count_ = 0;
336
3.21M
            }
337
44.6M
        }
338
339
93.3M
        switch (tokenizer_.getType()) {
340
85.8k
        case QPDFTokenizer::tt_eof:
341
85.8k
            warn("parse error while reading object");
342
85.8k
            if (content_stream) {
343
                // In content stream mode, leave object uninitialized to indicate EOF
344
706
                return {};
345
706
            }
346
85.1k
            warn("unexpected EOF");
347
85.1k
            return {};
348
349
411k
        case QPDFTokenizer::tt_bad:
350
411k
            check_too_many_bad_tokens();
351
411k
            add_null();
352
411k
            continue;
353
354
29.2k
        case QPDFTokenizer::tt_brace_open:
355
54.1k
        case QPDFTokenizer::tt_brace_close:
356
54.1k
            add_bad_null("treating unexpected brace token as null");
357
54.1k
            continue;
358
359
1.53M
        case QPDFTokenizer::tt_array_close:
360
1.53M
            if (frame_->state == st_array) {
361
1.50M
                auto object = frame_->null_count > 100
362
1.50M
                    ? QPDFObject::create<QPDF_Array>(std::move(frame_->olist), true)
363
1.50M
                    : QPDFObject::create<QPDF_Array>(std::move(frame_->olist));
364
1.50M
                set_description(object, frame_->offset - 1);
365
                // The `offset` points to the next of "[".  Set the rewind offset to point to the
366
                // beginning of "[". This has been explicitly tested with whitespace surrounding the
367
                // array start delimiter. getLastOffset points to the array end token and therefore
368
                // can't be used here.
369
1.50M
                if (stack_.size() <= 1) {
370
127k
                    return object;
371
127k
                }
372
1.38M
                stack_.pop_back();
373
1.38M
                frame_ = &stack_.back();
374
1.38M
                add(std::move(object));
375
1.38M
            } else {
376
28.2k
                if (sanity_checks_) {
377
                    // During sanity checks, assume nesting of containers is corrupt and object is
378
                    // unusable.
379
18.2k
                    warn("unexpected array close token; giving up on reading object");
380
18.2k
                    return {};
381
18.2k
                }
382
9.99k
                add_bad_null("treating unexpected array close token as null");
383
9.99k
            }
384
1.39M
            continue;
385
386
2.36M
        case QPDFTokenizer::tt_dict_close:
387
2.36M
            if (frame_->state <= st_dictionary_value) {
388
                // Attempt to recover more or less gracefully from invalid dictionaries.
389
2.34M
                auto& dict = frame_->dict;
390
391
2.34M
                if (frame_->state == st_dictionary_value) {
392
127k
                    warn(
393
127k
                        frame_->offset,
394
127k
                        "dictionary ended prematurely; using null as value for last key");
395
127k
                    dict[frame_->key] = QPDFObject::create<QPDF_Null>();
396
127k
                }
397
2.34M
                if (!frame_->olist.empty()) {
398
604k
                    if (sanity_checks_) {
399
565k
                        warn(
400
565k
                            frame_->offset,
401
565k
                            "expected dictionary keys but found non-name objects; ignoring");
402
565k
                    } else {
403
38.5k
                        fix_missing_keys();
404
38.5k
                    }
405
604k
                }
406
407
2.34M
                if (!frame_->contents_string.empty() && dict.contains("/Type") &&
408
1.60k
                    dict["/Type"].isNameAndEquals("/Sig") && dict.contains("/ByteRange") &&
409
568
                    dict.contains("/Contents") && dict["/Contents"].isString()) {
410
487
                    dict["/Contents"] = QPDFObjectHandle::newString(frame_->contents_string);
411
487
                    dict["/Contents"].setParsedOffset(frame_->contents_offset);
412
487
                }
413
2.34M
                auto object = QPDFObject::create<QPDF_Dictionary>(std::move(dict));
414
2.34M
                set_description(object, frame_->offset - 2);
415
                // The `offset` points to the next of "<<". Set the rewind offset to point to the
416
                // beginning of "<<". This has been explicitly tested with whitespace surrounding
417
                // the dictionary start delimiter. getLastOffset points to the dictionary end token
418
                // and therefore can't be used here.
419
2.34M
                if (stack_.size() <= 1) {
420
1.54M
                    return object;
421
1.54M
                }
422
799k
                stack_.pop_back();
423
799k
                frame_ = &stack_.back();
424
799k
                add(std::move(object));
425
799k
            } else {
426
22.1k
                if (sanity_checks_) {
427
                    // During sanity checks, assume nesting of containers is corrupt and object is
428
                    // unusable.
429
14.8k
                    warn("unexpected dictionary close token; giving up on reading object");
430
14.8k
                    return {};
431
14.8k
                }
432
7.36k
                add_bad_null("unexpected dictionary close token");
433
7.36k
            }
434
807k
            continue;
435
436
2.45M
        case QPDFTokenizer::tt_array_open:
437
3.66M
        case QPDFTokenizer::tt_dict_open:
438
3.66M
            if (stack_.size() > max_nesting) {
439
1.11k
                limits_error(
440
1.11k
                    "parser-max-nesting", "ignoring excessively deeply nested data structure");
441
1.11k
            }
442
3.66M
            b_contents = false;
443
3.66M
            stack_.emplace_back(
444
3.66M
                input_,
445
3.66M
                (tokenizer_.getType() == QPDFTokenizer::tt_array_open) ? st_array
446
3.66M
                                                                       : st_dictionary_key);
447
3.66M
            frame_ = &stack_.back();
448
3.66M
            continue;
449
450
134k
        case QPDFTokenizer::tt_bool:
451
134k
            add_scalar<QPDF_Bool>(tokenizer_.getValue() == "true");
452
134k
            continue;
453
454
1.01M
        case QPDFTokenizer::tt_null:
455
1.01M
            add_null();
456
1.01M
            continue;
457
458
9.19M
        case QPDFTokenizer::tt_integer:
459
9.19M
            if (!content_stream) {
460
                // Buffer token in case it is part of an indirect reference.
461
8.28M
                last_offset_buffer_[1] = input_.getLastOffset();
462
8.28M
                int_buffer_[1] = QUtil::string_to_ll(tokenizer_.getValue().c_str());
463
8.28M
                int_count_ = 1;
464
8.28M
            } else {
465
912k
                add_scalar<QPDF_Integer>(QUtil::string_to_ll(tokenizer_.getValue().c_str()));
466
912k
            }
467
9.19M
            continue;
468
469
1.08M
        case QPDFTokenizer::tt_real:
470
1.08M
            add_scalar<QPDF_Real>(tokenizer_.getValue());
471
1.08M
            continue;
472
473
67.9M
        case QPDFTokenizer::tt_name:
474
67.9M
            if (frame_->state == st_dictionary_key) {
475
9.76M
                frame_->key = tokenizer_.getValue();
476
9.76M
                frame_->state = st_dictionary_value;
477
9.76M
                b_contents = decrypter_ && frame_->key == "/Contents";
478
9.76M
                continue;
479
58.1M
            } else {
480
58.1M
                add_scalar<QPDF_Name>(tokenizer_.getValue());
481
58.1M
            }
482
58.1M
            continue;
483
484
58.1M
        case QPDFTokenizer::tt_word:
485
3.50M
            if (content_stream) {
486
913k
                add_scalar<QPDF_Operator>(tokenizer_.getValue());
487
913k
                continue;
488
913k
            }
489
490
2.59M
            if (sanity_checks_) {
491
2.48M
                if (tokenizer_.getValue() == "endobj" || tokenizer_.getValue() == "endstream") {
492
                    // During sanity checks, assume an unexpected endobj or endstream indicates that
493
                    // we are parsing past the end of the object.
494
29.0k
                    warn(
495
29.0k
                        "unexpected 'endobj' or 'endstream' while reading object; giving up on "
496
29.0k
                        "reading object");
497
29.0k
                    return {};
498
29.0k
                }
499
500
2.45M
                add_bad_null("unknown token while reading object; treating as null");
501
2.45M
                continue;
502
2.48M
            }
503
504
107k
            warn("unknown token while reading object; treating as string");
505
107k
            check_too_many_bad_tokens();
506
107k
            add_scalar<QPDF_String>(tokenizer_.getValue());
507
508
107k
            continue;
509
510
2.38M
        case QPDFTokenizer::tt_string:
511
2.38M
            {
512
2.38M
                auto const& val = tokenizer_.getValue();
513
2.38M
                if (decrypter_) {
514
267k
                    if (b_contents) {
515
8.99k
                        frame_->contents_string = val;
516
8.99k
                        frame_->contents_offset = input_.getLastOffset();
517
8.99k
                        b_contents = false;
518
8.99k
                    }
519
267k
                    std::string s{val};
520
267k
                    decrypter_->decryptString(s);
521
267k
                    add_scalar<QPDF_String>(s);
522
2.11M
                } else {
523
2.11M
                    add_scalar<QPDF_String>(val);
524
2.11M
                }
525
2.38M
            }
526
2.38M
            continue;
527
528
0
        default:
529
0
            add_bad_null("treating unknown token type as null while reading object");
530
93.3M
        }
531
93.3M
    }
532
1.97M
}
533
534
void
535
Parser::add(std::shared_ptr<QPDFObject>&& obj)
536
105M
{
537
105M
    if (frame_->state != st_dictionary_value) {
538
        // If state is st_dictionary_key then there is a missing key. Push onto olist for
539
        // processing once the tt_dict_close token has been found.
540
96.2M
        frame_->olist.emplace_back(std::move(obj));
541
96.2M
    } else {
542
9.11M
        if (auto res = frame_->dict.insert_or_assign(frame_->key, std::move(obj)); !res.second) {
543
93.2k
            warn_duplicate_key();
544
93.2k
        }
545
9.11M
        frame_->state = st_dictionary_key;
546
9.11M
    }
547
105M
}
548
549
void
550
Parser::add_null()
551
3.86M
{
552
3.86M
    const static ObjectPtr null_obj = QPDFObject::create<QPDF_Null>();
553
554
3.86M
    if (frame_->state != st_dictionary_value) {
555
        // If state is st_dictionary_key then there is a missing key. Push onto olist for
556
        // processing once the tt_dict_close token has been found.
557
3.46M
        frame_->olist.emplace_back(null_obj);
558
3.46M
    } else {
559
400k
        if (auto res = frame_->dict.insert_or_assign(frame_->key, null_obj); !res.second) {
560
19.4k
            warn_duplicate_key();
561
19.4k
        }
562
400k
        frame_->state = st_dictionary_key;
563
400k
    }
564
3.86M
    ++frame_->null_count;
565
3.86M
}
566
567
void
568
Parser::add_bad_null(std::string const& msg)
569
2.55M
{
570
2.55M
    warn(msg);
571
2.55M
    check_too_many_bad_tokens();
572
2.55M
    add_null();
573
2.55M
}
574
575
void
576
Parser::add_int(int count)
577
34.5M
{
578
34.5M
    auto obj = QPDFObject::create<QPDF_Integer>(int_buffer_[count % 2]);
579
34.5M
    obj->setDescription(context_, description_, last_offset_buffer_[count % 2]);
580
34.5M
    add(std::move(obj));
581
34.5M
}
582
583
template <typename T, typename... Args>
584
void
585
Parser::add_scalar(Args&&... args)
586
63.6M
{
587
63.6M
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
63.6M
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
4.98k
        max_bad_count_ = 1;
592
4.98k
        check_too_many_bad_tokens(); // always throws Error()
593
4.98k
    }
594
63.6M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
63.6M
    obj->setDescription(context_, description_, input_.getLastOffset());
596
63.6M
    add(std::move(obj));
597
63.6M
}
void qpdf::impl::Parser::add_scalar<QPDF_Bool, bool>(bool&&)
Line
Count
Source
586
134k
{
587
134k
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
134k
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
557
        max_bad_count_ = 1;
592
557
        check_too_many_bad_tokens(); // always throws Error()
593
557
    }
594
134k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
134k
    obj->setDescription(context_, description_, input_.getLastOffset());
596
134k
    add(std::move(obj));
597
134k
}
void qpdf::impl::Parser::add_scalar<QPDF_Integer, long long>(long long&&)
Line
Count
Source
586
912k
{
587
912k
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
912k
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
36
        max_bad_count_ = 1;
592
36
        check_too_many_bad_tokens(); // always throws Error()
593
36
    }
594
912k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
912k
    obj->setDescription(context_, description_, input_.getLastOffset());
596
912k
    add(std::move(obj));
597
912k
}
void qpdf::impl::Parser::add_scalar<QPDF_Real, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
586
1.08M
{
587
1.08M
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
1.08M
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
924
        max_bad_count_ = 1;
592
924
        check_too_many_bad_tokens(); // always throws Error()
593
924
    }
594
1.08M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
1.08M
    obj->setDescription(context_, description_, input_.getLastOffset());
596
1.08M
    add(std::move(obj));
597
1.08M
}
void qpdf::impl::Parser::add_scalar<QPDF_Name, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
586
58.1M
{
587
58.1M
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
58.1M
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
2.47k
        max_bad_count_ = 1;
592
2.47k
        check_too_many_bad_tokens(); // always throws Error()
593
2.47k
    }
594
58.1M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
58.1M
    obj->setDescription(context_, description_, input_.getLastOffset());
596
58.1M
    add(std::move(obj));
597
58.1M
}
void qpdf::impl::Parser::add_scalar<QPDF_Operator, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
586
913k
{
587
913k
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
913k
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
115
        max_bad_count_ = 1;
592
115
        check_too_many_bad_tokens(); // always throws Error()
593
115
    }
594
913k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
913k
    obj->setDescription(context_, description_, input_.getLastOffset());
596
913k
    add(std::move(obj));
597
913k
}
void qpdf::impl::Parser::add_scalar<QPDF_String, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
586
2.21M
{
587
2.21M
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
2.21M
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
744
        max_bad_count_ = 1;
592
744
        check_too_many_bad_tokens(); // always throws Error()
593
744
    }
594
2.21M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
2.21M
    obj->setDescription(context_, description_, input_.getLastOffset());
596
2.21M
    add(std::move(obj));
597
2.21M
}
void qpdf::impl::Parser::add_scalar<QPDF_String, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
586
266k
{
587
266k
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
588
266k
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
589
        // Stop adding scalars. We are going to abort when the close token or a bad token is
590
        // encountered.
591
138
        max_bad_count_ = 1;
592
138
        check_too_many_bad_tokens(); // always throws Error()
593
138
    }
594
266k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
595
266k
    obj->setDescription(context_, description_, input_.getLastOffset());
596
266k
    add(std::move(obj));
597
266k
}
598
599
template <typename T, typename... Args>
600
QPDFObjectHandle
601
Parser::with_description(Args&&... args)
602
29.1M
{
603
29.1M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
29.1M
    obj->setDescription(context_, description_, start_);
605
29.1M
    return {obj};
606
29.1M
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_Bool, bool>(bool&&)
Line
Count
Source
602
8.52k
{
603
8.52k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
8.52k
    obj->setDescription(context_, description_, start_);
605
8.52k
    return {obj};
606
8.52k
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_Integer, long long>(long long&&)
Line
Count
Source
602
1.15M
{
603
1.15M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
1.15M
    obj->setDescription(context_, description_, start_);
605
1.15M
    return {obj};
606
1.15M
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_Real, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
602
510k
{
603
510k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
510k
    obj->setDescription(context_, description_, start_);
605
510k
    return {obj};
606
510k
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_Name, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
602
263k
{
603
263k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
263k
    obj->setDescription(context_, description_, start_);
605
263k
    return {obj};
606
263k
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_Operator, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
602
27.0M
{
603
27.0M
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
27.0M
    obj->setDescription(context_, description_, start_);
605
27.0M
    return {obj};
606
27.0M
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_String, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
602
199k
{
603
199k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
199k
    obj->setDescription(context_, description_, start_);
605
199k
    return {obj};
606
199k
}
QPDFObjectHandle qpdf::impl::Parser::with_description<QPDF_String, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
602
1.96k
{
603
1.96k
    auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
604
1.96k
    obj->setDescription(context_, description_, start_);
605
1.96k
    return {obj};
606
1.96k
}
607
608
void
609
Parser::set_description(ObjectPtr& obj, qpdf_offset_t parsed_offset)
610
3.85M
{
611
3.85M
    if (obj) {
612
3.85M
        obj->setDescription(context_, description_, parsed_offset);
613
3.85M
    }
614
3.85M
}
615
616
void
617
Parser::fix_missing_keys()
618
38.5k
{
619
38.5k
    std::set<std::string> names;
620
232k
    for (auto& obj: frame_->olist) {
621
232k
        if (obj.raw_type_code() == ::ot_name) {
622
7.08k
            names.insert(obj.getName());
623
7.08k
        }
624
232k
    }
625
38.5k
    int next_fake_key = 1;
626
225k
    for (auto const& item: frame_->olist) {
627
226k
        while (true) {
628
226k
            const std::string key = "/QPDFFake" + std::to_string(next_fake_key++);
629
226k
            const bool found_fake = !frame_->dict.contains(key) && !names.contains(key);
630
226k
            QTC::TC("qpdf", "QPDFParser found fake", (found_fake ? 0 : 1));
631
226k
            if (found_fake) {
632
225k
                warn(
633
225k
                    frame_->offset,
634
225k
                    "expected dictionary key but found non-name object; inserting key " + key);
635
225k
                frame_->dict[key] = item;
636
225k
                break;
637
225k
            }
638
226k
        }
639
225k
    }
640
38.5k
}
641
642
void
643
Parser::check_too_many_bad_tokens()
644
3.16M
{
645
3.16M
    auto limit = Limits::parser_max_container_size(bad_count_ || sanity_checks_);
646
3.16M
    if (frame_->olist.size() >= limit || frame_->dict.size() >= limit) {
647
5.13k
        if (bad_count_) {
648
3.99k
            limits_error(
649
3.99k
                "parser-max-container-size-damaged",
650
3.99k
                "encountered errors while parsing an array or dictionary with more than " +
651
3.99k
                    std::to_string(limit) + " elements; giving up on reading object");
652
3.99k
        }
653
5.13k
        limits_error(
654
5.13k
            "parser-max-container-size",
655
5.13k
            "encountered an array or dictionary with more than " + std::to_string(limit) +
656
5.13k
                " elements during xref recovery; giving up on reading object");
657
5.13k
    }
658
3.16M
    if (max_bad_count_ && --max_bad_count_ == 0) {
659
22.0k
        limits_error(
660
22.0k
            "parser-max-errors", "too many errors during parsing; treating object as null");
661
22.0k
    }
662
3.16M
    if (good_count_ > 4) {
663
1.11M
        good_count_ = 0;
664
1.11M
        bad_count_ = 1;
665
1.11M
        return;
666
1.11M
    }
667
2.04M
    if (++bad_count_ > 5 ||
668
1.95M
        (frame_->state != st_array && std::cmp_less(max_bad_count_, frame_->olist.size()))) {
669
        // Give up after 5 errors in close proximity or if the number of missing dictionary keys
670
        // exceeds the remaining number of allowable total errors.
671
85.2k
        warn("too many errors; giving up on reading object");
672
85.2k
        throw Error();
673
85.2k
    }
674
1.96M
    good_count_ = 0;
675
1.96M
}
676
677
void
678
Parser::limits_error(std::string const& limit, std::string const& msg)
679
28.3k
{
680
28.3k
    Limits::error();
681
28.3k
    warn("limits error("s + limit + "): " + msg);
682
28.3k
    throw Error();
683
28.3k
}
684
685
void
686
Parser::warn(QPDFExc const& e) const
687
4.71M
{
688
    // If parsing on behalf of a QPDF object and want to give a warning, we can warn through the
689
    // object. If parsing for some other reason, such as an explicit creation of an object from a
690
    // string, then just throw the exception.
691
4.71M
    if (context_) {
692
4.71M
        context_->warn(e);
693
4.71M
    } else {
694
633
        throw e;
695
633
    }
696
4.71M
}
697
698
void
699
Parser::warn_duplicate_key()
700
112k
{
701
112k
    warn(
702
112k
        frame_->offset,
703
112k
        "dictionary has duplicated key " + frame_->key +
704
112k
            "; last occurrence overrides earlier ones");
705
112k
    check_too_many_bad_tokens();
706
112k
}
707
708
void
709
Parser::warn(qpdf_offset_t offset, std::string const& msg) const
710
4.71M
{
711
4.71M
    if (stream_id_) {
712
362k
        std::string descr = "object "s + std::to_string(obj_id_) + " 0";
713
362k
        std::string name = context_->getFilename() + " object stream " + std::to_string(stream_id_);
714
362k
        warn(QPDFExc(qpdf_e_damaged_pdf, name, descr, offset, msg));
715
4.35M
    } else {
716
4.35M
        warn(QPDFExc(qpdf_e_damaged_pdf, input_.getName(), object_description_, offset, msg));
717
4.35M
    }
718
4.71M
}
719
720
void
721
Parser::warn(std::string const& msg) const
722
3.68M
{
723
3.68M
    warn(input_.getLastOffset(), msg);
724
3.68M
}