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_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,
}

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_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

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 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 PartialEq for ParserLimits

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ParserLimits

impl Eq for ParserLimits

impl StructuralPartialEq for ParserLimits