diff --git a/include/qpdf/Constants.h b/include/qpdf/Constants.h index e6f7b3e..083c9fd 100644 --- a/include/qpdf/Constants.h +++ b/include/qpdf/Constants.h @@ -281,10 +281,10 @@ enum qpdf_param_e { /* global limits */ /* object - parser limits */ - qpdf_p_objects_max_nesting = 0x12000, - qpdf_p_objects_max_errors, - qpdf_p_objects_max_container_size, - qpdf_p_objects_max_container_size_damaged, + qpdf_p_parser_max_nesting = 0x13000, + qpdf_p_parser_max_errors, + qpdf_p_parser_max_container_size, + qpdf_p_parser_max_container_size_damaged, /* next section = 0x20000 */ qpdf_enum_max = 0x7fffffff, diff --git a/include/qpdf/global.hh b/include/qpdf/global.hh index 3ad2550..7801905 100644 --- a/include/qpdf/global.hh +++ b/include/qpdf/global.hh @@ -104,9 +104,9 @@ namespace qpdf::global /// @note The maximum nesting level cannot be disabled by calling `default_limit(false)`. /// /// @since 12.3 - uint32_t inline objects_max_nesting() + uint32_t inline parser_max_nesting() { - return get_uint32(qpdf_p_objects_max_nesting); + return get_uint32(qpdf_p_parser_max_nesting); } /// @brief Sets the maximum nesting level while parsing objects. @@ -116,9 +116,9 @@ namespace qpdf::global /// @note The maximum nesting level cannot be disabled by calling `default_limit(false)`. /// /// @since 12.3 - void inline objects_max_nesting(uint32_t value) + void inline parser_max_nesting(uint32_t value) { - set_uint32(qpdf_p_objects_max_nesting, value); + set_uint32(qpdf_p_parser_max_nesting, value); } /// @brief Retrieves the maximum number of errors allowed while parsing objects. @@ -128,9 +128,9 @@ namespace qpdf::global /// @return The maximum number of errors allowed while parsing objects. /// /// @since 12.3 - uint32_t inline objects_max_errors() + uint32_t inline parser_max_errors() { - return get_uint32(qpdf_p_objects_max_errors); + return get_uint32(qpdf_p_parser_max_errors); } /// Sets the maximum number of errors allowed while parsing objects. @@ -140,9 +140,9 @@ namespace qpdf::global /// @param value The maximum number of errors allowed while parsing objects to set. /// /// @since 12.3 - void inline objects_max_errors(uint32_t value) + void inline parser_max_errors(uint32_t value) { - set_uint32(qpdf_p_objects_max_errors, value); + set_uint32(qpdf_p_parser_max_errors, value); } /// @brief Retrieves the maximum number of objectstop-level allowed in a container while @@ -155,9 +155,9 @@ namespace qpdf::global /// objects. /// /// @since 12.3 - uint32_t inline objects_max_container_size() + uint32_t inline parser_max_container_size() { - return get_uint32(qpdf_p_objects_max_container_size); + return get_uint32(qpdf_p_parser_max_container_size); } /// @brief Sets the maximum number oftop-level objects allowed in a container while parsing. @@ -169,9 +169,9 @@ namespace qpdf::global /// parsing objects to set. /// /// @since 12.3 - void inline objects_max_container_size(uint32_t value) + void inline parser_max_container_size(uint32_t value) { - set_uint32(qpdf_p_objects_max_container_size, value); + set_uint32(qpdf_p_parser_max_container_size, value); } /// @brief Retrieves the maximum number of top-level objects allowed in a container while @@ -185,9 +185,9 @@ namespace qpdf::global /// objects. /// /// @since 12.3 - uint32_t inline objects_max_container_size_damaged() + uint32_t inline parser_max_container_size_damaged() { - return get_uint32(qpdf_p_objects_max_container_size_damaged); + return get_uint32(qpdf_p_parser_max_container_size_damaged); } /// @brief Sets the maximum number of top-level objects allowed in a container while @@ -201,9 +201,9 @@ namespace qpdf::global /// parsing objects to set. /// /// @since 12.3 - void inline objects_max_container_size_damaged(uint32_t value) + void inline parser_max_container_size_damaged(uint32_t value) { - set_uint32(qpdf_p_objects_max_container_size_damaged, value); + set_uint32(qpdf_p_parser_max_container_size_damaged, value); } } // namespace limits diff --git a/libqpdf/QPDFParser.cc b/libqpdf/QPDFParser.cc index 00dc52b..60ba7ab 100644 --- a/libqpdf/QPDFParser.cc +++ b/libqpdf/QPDFParser.cc @@ -15,7 +15,7 @@ using namespace qpdf; using ObjectPtr = std::shared_ptr; -static uint32_t const& max_nesting{global::Limits::objects_max_nesting()}; +static uint32_t const& max_nesting{global::Limits::parser_max_nesting()}; // The ParseGuard class allows QPDFParser to detect re-entrant parsing. It also provides // special access to allow the parser to create unresolved objects and dangling references. @@ -587,7 +587,7 @@ template void QPDFParser::addScalar(Args&&... args) { - auto limit = Limits::objects_max_container_size(bad_count || sanity_checks); + auto limit = Limits::parser_max_container_size(bad_count || sanity_checks); if (frame->olist.size() > limit || frame->dict.size() > limit) { // Stop adding scalars. We are going to abort when the close token or a bad token is // encountered. @@ -645,7 +645,7 @@ QPDFParser::fixMissingKeys() void QPDFParser::check_too_many_bad_tokens() { - auto limit = Limits::objects_max_container_size(bad_count || sanity_checks); + auto limit = Limits::parser_max_container_size(bad_count || sanity_checks); if (frame->olist.size() > limit || frame->dict.size() > limit) { if (bad_count) { Limits::error(); diff --git a/libqpdf/global.cc b/libqpdf/global.cc index ae49eb0..418a544 100644 --- a/libqpdf/global.cc +++ b/libqpdf/global.cc @@ -9,24 +9,24 @@ Limits Limits::l; Options Options::o; void -Limits::objects_max_container_size(bool damaged, uint32_t value) +Limits::parser_max_container_size(bool damaged, uint32_t value) { if (damaged) { - l.objects_max_container_size_damaged_set_ = true; - l.objects_max_container_size_damaged_ = value; + l.parser_max_container_size_damaged_set_ = true; + l.parser_max_container_size_damaged_ = value; } else { - l.objects_max_container_size_ = value; + l.parser_max_container_size_ = value; } } void Limits::disable_defaults() { - if (!l.objects_max_errors_set_) { - l.objects_max_errors_ = 0; + if (!l.parser_max_errors_set_) { + l.parser_max_errors_ = 0; } - if (!l.objects_max_container_size_damaged_set_) { - l.objects_max_container_size_damaged_ = std::numeric_limits::max(); + if (!l.parser_max_container_size_damaged_set_) { + l.parser_max_container_size_damaged_ = std::numeric_limits::max(); } } @@ -41,17 +41,17 @@ qpdf_global_get_uint32(qpdf_param_e param, uint32_t* value) case qpdf_p_limit_errors: *value = Limits::errors(); return qpdf_r_ok; - case qpdf_p_objects_max_nesting: - *value = Limits::objects_max_nesting(); + case qpdf_p_parser_max_nesting: + *value = Limits::parser_max_nesting(); return qpdf_r_ok; - case qpdf_p_objects_max_errors: - *value = Limits::objects_max_errors(); + case qpdf_p_parser_max_errors: + *value = Limits::parser_max_errors(); return qpdf_r_ok; - case qpdf_p_objects_max_container_size: - *value = Limits::objects_max_container_size(false); + case qpdf_p_parser_max_container_size: + *value = Limits::parser_max_container_size(false); return qpdf_r_ok; - case qpdf_p_objects_max_container_size_damaged: - *value = Limits::objects_max_container_size(true); + case qpdf_p_parser_max_container_size_damaged: + *value = Limits::parser_max_container_size(true); return qpdf_r_ok; default: return qpdf_r_bad_parameter; @@ -65,17 +65,17 @@ qpdf_global_set_uint32(qpdf_param_e param, uint32_t value) case qpdf_p_default_limits: Options::default_limits(value); return qpdf_r_ok; - case qpdf_p_objects_max_nesting: - Limits::objects_max_nesting(value); + case qpdf_p_parser_max_nesting: + Limits::parser_max_nesting(value); return qpdf_r_ok; - case qpdf_p_objects_max_errors: - Limits::objects_max_errors(value); + case qpdf_p_parser_max_errors: + Limits::parser_max_errors(value); return qpdf_r_ok; - case qpdf_p_objects_max_container_size: - Limits::objects_max_container_size(false, value); + case qpdf_p_parser_max_container_size: + Limits::parser_max_container_size(false, value); return qpdf_r_ok; - case qpdf_p_objects_max_container_size_damaged: - Limits::objects_max_container_size(true, value); + case qpdf_p_parser_max_container_size_damaged: + Limits::parser_max_container_size(true, value); return qpdf_r_ok; default: return qpdf_r_bad_parameter; diff --git a/libqpdf/qpdf/QPDFParser.hh b/libqpdf/qpdf/QPDFParser.hh index 062b315..0fb7935 100644 --- a/libqpdf/qpdf/QPDFParser.hh +++ b/libqpdf/qpdf/QPDFParser.hh @@ -149,7 +149,7 @@ class QPDFParser // it only gets incremented or reset when a bad token is encountered. int bad_count{0}; // Number of bad tokens (remaining) before giving up. - uint32_t max_bad_count{Limits::objects_max_errors()}; + uint32_t max_bad_count{Limits::parser_max_errors()}; // Number of good tokens since last bad token. Irrelevant if bad_count == 0. int good_count{0}; // Start offset including any leading whitespace. diff --git a/libqpdf/qpdf/global_private.hh b/libqpdf/qpdf/global_private.hh index 93e7522..66b5324 100644 --- a/libqpdf/qpdf/global_private.hh +++ b/libqpdf/qpdf/global_private.hh @@ -16,37 +16,37 @@ namespace qpdf::global Limits& operator=(Limits&&) = delete; static uint32_t const& - objects_max_nesting() + parser_max_nesting() { - return l.objects_max_nesting_; + return l.parser_max_nesting_; } static void - objects_max_nesting(uint32_t value) + parser_max_nesting(uint32_t value) { - l.objects_max_nesting_ = value; + l.parser_max_nesting_ = value; } static uint32_t const& - objects_max_errors() + parser_max_errors() { - return l.objects_max_errors_; + return l.parser_max_errors_; } static void - objects_max_errors(uint32_t value) + parser_max_errors(uint32_t value) { - l.objects_max_errors_set_ = true; - l.objects_max_errors_ = value; + l.parser_max_errors_set_ = true; + l.parser_max_errors_ = value; } static uint32_t const& - objects_max_container_size(bool damaged) + parser_max_container_size(bool damaged) { - return damaged ? l.objects_max_container_size_damaged_ : l.objects_max_container_size_; + return damaged ? l.parser_max_container_size_damaged_ : l.parser_max_container_size_; } - static void objects_max_container_size(bool damaged, uint32_t value); + static void parser_max_container_size(bool damaged, uint32_t value); /// Record a limit error. static void @@ -73,12 +73,12 @@ namespace qpdf::global uint32_t errors_{0}; - uint32_t objects_max_nesting_{499}; - uint32_t objects_max_errors_{15}; - bool objects_max_errors_set_{false}; - uint32_t objects_max_container_size_{std::numeric_limits::max()}; - uint32_t objects_max_container_size_damaged_{5'000}; - bool objects_max_container_size_damaged_set_{false}; + uint32_t parser_max_nesting_{499}; + uint32_t parser_max_errors_{15}; + bool parser_max_errors_set_{false}; + uint32_t parser_max_container_size_{std::numeric_limits::max()}; + uint32_t parser_max_container_size_damaged_{5'000}; + bool parser_max_container_size_damaged_set_{false}; }; class Options diff --git a/libtests/objects.cc b/libtests/objects.cc index a23c004..4335602 100644 --- a/libtests/objects.cc +++ b/libtests/objects.cc @@ -162,18 +162,18 @@ test_2(QPDF& pdf, char const* arg2) using namespace qpdf::global::limits; // Check default values - assert(objects_max_nesting() == 499); - assert(objects_max_errors() == 15); - assert(objects_max_container_size() == std::numeric_limits::max()); - assert(objects_max_container_size_damaged() == 5'000); + assert(parser_max_nesting() == 499); + assert(parser_max_errors() == 15); + assert(parser_max_container_size() == std::numeric_limits::max()); + assert(parser_max_container_size_damaged() == 5'000); assert(default_limits()); // Test disabling optional default limits default_limits(false); - assert(objects_max_nesting() == 499); - assert(objects_max_errors() == 0); - assert(objects_max_container_size() == std::numeric_limits::max()); - assert(objects_max_container_size_damaged() == std::numeric_limits::max()); + assert(parser_max_nesting() == 499); + assert(parser_max_errors() == 0); + assert(parser_max_container_size() == std::numeric_limits::max()); + assert(parser_max_container_size_damaged() == std::numeric_limits::max()); assert(!default_limits()); // Check disabling default limits is irreversible @@ -181,22 +181,22 @@ test_2(QPDF& pdf, char const* arg2) assert(!default_limits()); // Test setting limits - objects_max_nesting(11); - objects_max_errors(12); - objects_max_container_size(13); - objects_max_container_size_damaged(14); + parser_max_nesting(11); + parser_max_errors(12); + parser_max_container_size(13); + parser_max_container_size_damaged(14); - assert(objects_max_nesting() == 11); - assert(objects_max_errors() == 12); - assert(objects_max_container_size() == 13); - assert(objects_max_container_size_damaged() == 14); + assert(parser_max_nesting() == 11); + assert(parser_max_errors() == 12); + assert(parser_max_container_size() == 13); + assert(parser_max_container_size_damaged() == 14); // Check disabling default limits does not override explicit limits default_limits(false); - assert(objects_max_nesting() == 11); - assert(objects_max_errors() == 12); - assert(objects_max_container_size() == 13); - assert(objects_max_container_size_damaged() == 14); + assert(parser_max_nesting() == 11); + assert(parser_max_errors() == 12); + assert(parser_max_container_size() == 13); + assert(parser_max_container_size_damaged() == 14); // Test parameter checking QUtil::handle_result_code(qpdf_r_ok, ""); @@ -226,7 +226,7 @@ test_2(QPDF& pdf, char const* arg2) assert(qpdf::global::limit_errors() == 0); QPDFObjectHandle::parse("[[[[]]]]"); assert(qpdf::global::limit_errors() == 0); - objects_max_nesting(3); + parser_max_nesting(3); try { QPDFObjectHandle::parse("[[[[[]]]]]"); } catch (std::exception&) {