Struct ParserLimits 

pub struct ParserLimits {

    pub max_entries: usize,
    pub max_links_per_feed: usize,
    pub max_links_per_entry: usize,
    pub max_authors: usize,
    pub max_contributors: usize,
    pub max_tags: usize,
    pub max_content_blocks: usize,
    pub max_enclosures: usize,
    pub max_namespaces: usize,
    pub max_nesting_depth: usize,
    pub max_html_nesting_depth: usize,
    pub max_text_length: usize,
    pub max_feed_size_bytes: usize,
    pub max_attribute_length: usize,
    pub max_podcast_soundbites: usize,
    pub max_podcast_transcripts: usize,
    pub max_podcast_funding: usize,
    pub max_podcast_persons: usize,
    pub max_value_recipients: usize,
    pub max_podcast_alternate_enclosures: usize,
    pub max_podcast_alternate_enclosure_sources: usize,
    pub max_podcast_podroll: usize,
    pub max_podcast_social_interact: usize,
    pub max_podcast_txt: usize,
    pub max_podcast_follow: usize,
    pub max_podcast_chat: usize,
    pub max_podcast_value_time_splits: usize,
}

Parser limits for protecting against denial-of-service attacks

These limits prevent malicious or malformed feeds from causing excessive memory allocation, deep recursion, or other resource exhaustion issues.

Examples

use feedparser_rs::ParserLimits;

let limits = ParserLimits::default();
assert_eq!(limits.max_entries, 10_000);

// Custom limits for restricted environments
let strict = ParserLimits {
    max_entries: 1_000,
    max_feed_size_bytes: 10 * 1024 * 1024, // 10MB
    ..Default::default()
};

Fields

max_entries: usize

Maximum number of entries/items in a feed

Prevents memory exhaustion from feeds with millions of items. Typical feeds have 10-100 entries, large feeds may have up to 1000.

Default: 10,000 entries

max_links_per_feed: usize

Maximum number of links per feed (channel-level)

Prevents link bombing attacks.

Default: 100 links

max_links_per_entry: usize

Maximum number of links per entry

Prevents link bombing in individual entries.

Default: 50 links

max_authors: usize

Maximum number of authors per feed or entry

Default: 20 authors

max_contributors: usize

Maximum number of contributors per feed or entry

Default: 20 contributors

max_tags: usize

Maximum number of tags/categories per feed or entry

Default: 100 tags

max_content_blocks: usize

Maximum number of content blocks per entry

Atom feeds can have multiple content elements.

Default: 10 content blocks

max_enclosures: usize

Maximum number of enclosures per entry

Podcast feeds typically have 1 enclosure per episode.

Default: 20 enclosures

max_namespaces: usize

Maximum number of XML namespaces

Prevents namespace pollution attacks.

Default: 100 namespaces

max_nesting_depth: usize

Maximum XML nesting depth

Prevents stack overflow from deeply nested XML.

Default: 100 levels

max_html_nesting_depth: usize

Maximum HTML tag nesting depth accepted by HTML sanitization

sanitize_html’s underlying HTML5 tree builder exhibits quadratic-time behavior on pathologically deep tag nesting within a single text field (verified: multi-second slowdown from a single deeply nested <div> chain). Content nested deeper than this is escaped as plain text (</>) instead of being run through the sanitizer, bounding worst-case CPU cost to linear regardless of input shape.

This is a safety bound, not a compatibility ceiling to be tuned up to match “typical” content: exceeding it degrades gracefully (the field’s HTML formatting is lost, but its text content is fully preserved and still safely escaped) rather than dropping data or erroring, so it is safe to keep conservative. Legitimate feed content — even unusually deep block-quoted reply chains or nested tables — rarely exceeds a few dozen levels; 100 (50 under ParserLimits::strict) leaves headroom above that without leaving much headroom for abuse.

Default: 100 levels

max_text_length: usize

Maximum text field length in bytes

Prevents excessive memory from huge title/description fields.

Default: 10 MB

max_feed_size_bytes: usize

Maximum total feed size in bytes

The entire feed must fit within this limit.

Default: 100 MB

max_attribute_length: usize

Maximum attribute value length in bytes

XML attributes should be reasonably sized.

Default: 64 KB

max_podcast_soundbites: usize

Maximum number of podcast soundbites per entry

Podcast 2.0 soundbite elements for shareable clips.

Default: 10 soundbites

max_podcast_transcripts: usize

Maximum number of podcast transcripts per entry

Podcast 2.0 transcript elements.

Default: 20 transcripts

max_podcast_funding: usize

Maximum number of podcast funding elements per feed

Podcast 2.0 funding elements for donation links.

Default: 20 funding elements

max_podcast_persons: usize

Maximum number of podcast person elements per entry

Podcast 2.0 person elements for hosts, guests, etc.

Default: 50 persons

max_value_recipients: usize

Maximum number of podcast value recipients per feed

Podcast 2.0 value recipients for payment splitting. Prevents DoS from feeds with excessive recipient lists.

Default: 20 recipients

max_podcast_alternate_enclosures: usize

Maximum number of alternate enclosures per entry

Default: 20

max_podcast_alternate_enclosure_sources: usize

Maximum number of sources per alternate enclosure

Default: 10

max_podcast_podroll: usize

Maximum number of podroll entries per feed

Default: 50

max_podcast_social_interact: usize

Maximum number of socialInteract elements per entry

Default: 20

max_podcast_txt: usize

Maximum number of txt records per feed or entry

Default: 20

max_podcast_follow: usize

Maximum number of follow links per feed or entry

Default: 20

max_podcast_chat: usize

Maximum number of chat references per feed or entry

Podcast 2.0 chat elements pointing to chat rooms/servers.

Default: 20

max_podcast_value_time_splits: usize

Maximum number of value time splits per podcast:value element

Podcast 2.0 valueTimeSplit elements for routing payments over time ranges. Prevents DoS from feeds with excessive split lists.

Default: 20

Implementations

impl ParserLimits

pub const fn strict() -> Self

Creates strict limits for resource-constrained environments

Use this for embedded systems or when parsing untrusted feeds with minimal resources.

Examples

use feedparser_rs::ParserLimits;

let limits = ParserLimits::strict();
assert_eq!(limits.max_entries, 1_000);

pub const fn permissive() -> Self

Creates permissive limits for trusted feeds

Use this only for feeds from trusted sources where you expect large data volumes (e.g., feed archives).

Examples

use feedparser_rs::ParserLimits;

let limits = ParserLimits::permissive();
assert_eq!(limits.max_entries, 100_000);

pub const fn check_feed_size(&self, size: usize) -> Result<(), LimitError>

Validates that a feed size is within limits

Call this before starting to parse a feed.

Errors

Returns an error if the feed exceeds max_feed_size_bytes.

pub const fn check_collection_size( &self, current: usize, limit: usize, name: &'static str, ) -> Result<(), LimitError>

Validates that a collection size is within limits

Use this during parsing to check collection sizes.

Errors

Returns an error if the collection size exceeds the specified limit.

pub const fn check_nesting_depth(&self, depth: usize) -> Result<(), LimitError>

Validates XML nesting depth

Errors

Returns an error if nesting depth exceeds max_nesting_depth.

pub const fn check_text_length(&self, length: usize) -> Result<(), LimitError>

Validates text field length

Errors

Returns an error if text length exceeds max_text_length.

Trait Implementations

impl Clone for ParserLimits

fn clone(&self) -> ParserLimits

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ParserLimits

impl Debug for ParserLimits

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParserLimits

fn default() -> Self

Creates default parser limits suitable for general use

These defaults are conservative and should work for most feeds, including large podcast feeds and news aggregators.

impl Eq for ParserLimits

impl PartialEq for ParserLimits

fn eq(&self, other: &ParserLimits) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ParserLimits