form-net 0.9.0

//! # form_net
//!
//! Parses what a browser sends when a form is submitted:
//! `application/x-www-form-urlencoded` fields and `multipart/form-data`
//! uploads. It does no I/O: feed it bytes, get fields and parts.
//!
//! Every budget (field count, name and value length, part count, part
//! header size, file count and size, total size) is checked before the bytes
//! it governs are buffered. Input that two parsers could read differently is
//! refused with a precise error, never repaired. No error, `Debug`, or
//! `Display` output ever contains a field value or a file name.
//!
//! ## Tier 1
//!
//! ```
//! // A urlencoded body
//! let form = form_net::parse_urlencoded(b"email=a%40b.example&remember=on")?;
//! assert_eq!(form.get("email"), Some("a@b.example"));
//!
//! // A query string
//! let query = form_net::parse_query(b"?q=rust+forms&page=2")?;
//! assert_eq!(query.get("q"), Some("rust forms"));
//!
//! // Building one
//! assert_eq!(form_net::serialize_urlencoded([("q", "rust forms")]), "q=rust+forms");
//!
//! // A buffered multipart body
//! let body = b"--X\r\nContent-Disposition: form-data; name=\"title\"\r\n\r\nHoliday\r\n--X--";
//! let mp = form_net::parse_multipart(b"multipart/form-data; boundary=X", body)?;
//! assert_eq!(mp.field("title"), Some("Holiday"));
//! # Ok::<(), form_net::FormError>(())
//! ```
//!
//! A typed form, from either encoding:
//!
//! ```
//! use form_net::FromForm;
//!
//! form_net::form! {
//!     pub struct Login {
//!         pub email: String,
//!         pub password: form_net::Secret,
//!         pub remember: bool,
//!     }
//!     ignore = ["csrf_token"];
//! }
//!
//! let body = b"email=a%40b.example&password=pw&remember=on&csrf_token=t";
//! let login = Login::from_body(b"application/x-www-form-urlencoded", body)?;
//! assert_eq!((login.email.as_str(), login.remember), ("a@b.example", true));
//! # Ok::<(), form_net::FormError>(())
//! ```
//!
//! An upload read from any `std::io::Read`, large files spilled to private
//! temporary files that are deleted on drop (feature `fs`):
//!
//! ```
//! # #[cfg(feature = "fs")] {
//! let body = b"--X\r\nContent-Disposition: form-data; name=doc; filename=a.txt\r\n\r\nhello\r\n--X--";
//! let upload = form_net::read_multipart(b"multipart/form-data; boundary=X", &body[..])?;
//! assert_eq!(upload.file("doc").map(|f| f.len()), Some(5));
//! # }
//! # Ok::<(), form_net::FormError>(())
//! ```
//!
//! ## Tiers 2 and 3
//!
//! Explicit [`Limits`] and [`Policy`] per route (`parse_urlencoded_with`,
//! `parse_multipart_with`); an [`Inspector`] that sees every part head, the
//! first bytes of every file, and every field before anything is stored;
//! a [`Sink`] that decides where file bytes go, driven by the [`Driver`]; the
//! allocation-free core ([`raw_pairs`], [`decode_into`], [`encode_into`],
//! [`UrlencodedParser`], [`Boundary`], [`MultipartParser`],
//! [`encode_part_head`]), which builds without `alloc`.
//!
//! ## Features
//!
//! | Feature | Default | Adds |
//! |---|---|---|
//! | (none) | | the allocation-free core; `no_std` without `alloc` |
//! | `alloc` | | owned results, the Tier 1 functions, `form!`, `Driver`, `MemorySink` |
//! | `std` | yes | `MultipartReader`, `MultipartWriter`, `FormError::Io`, `FormError::Random`; implies `alloc` |
//! | `random` | | `Boundary::generate`, `MultipartWriter::new`; implies `std` |
//! | `fs` | | `Store`, `StoredFile`, `Upload`, `UploadSession`, `read_multipart`, `SpillQuota`, `sweep`, `FileName::sanitized`; implies `random` |
//! | `unicode` | | `FileName::nfc`, and NFC in `FileName::sanitized`; implies `alloc` |
//!
//! The full contract is `docs/API.md` in the
//! [repository](https://github.com/jamesgober/form-net), with
//! `docs/ARCHITECTURE.md`, `docs/PLATFORM-NOTES.md`, and
//! `docs/PERFORMANCE.md` (measurements against the other Rust form parsers).
//! This release (0.9) is feature complete, optimised, hardened, polished, and in beta.

#![no_std]
#![doc(html_root_url = "https://docs.rs/form-net")]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![forbid(unsafe_code)]
#![deny(missing_docs)]
#![cfg_attr(
    not(test),
    deny(
        clippy::unwrap_used,
        clippy::expect_used,
        clippy::panic,
        clippy::indexing_slicing,
        clippy::arithmetic_side_effects,
        clippy::todo,
        clippy::unimplemented,
        clippy::unreachable,
        clippy::dbg_macro,
        clippy::print_stdout,
        clippy::print_stderr
    )
)]

#[cfg(any(feature = "alloc", test))]
extern crate alloc;
#[cfg(any(feature = "std", test))]
extern crate std;

#[cfg(target_has_atomic = "32")]
mod digest;
mod error;
#[cfg(feature = "alloc")]
mod extract;
mod hook;
#[cfg(feature = "std")]
mod io;
mod kind;
mod limits;
mod multipart;
#[cfg(feature = "random")]
mod random;
mod scan;
#[cfg(feature = "fs")]
mod store;
mod urlencoded;
mod wipe;

#[cfg(feature = "alloc")]
#[doc(hidden)]
pub use alloc::vec::Vec as __Vec;
#[cfg(target_has_atomic = "32")]
#[cfg_attr(docsrs, doc(cfg(target_has_atomic = "32")))]
pub use digest::RefusalDigest;
pub use error::{
    EncodingError, ExtractError, FormError, Limit, Location, PolicyRefusal, SyntaxError,
};
#[cfg(feature = "alloc")]
#[doc(hidden)]
pub use extract::{__push_field_error, __unknown, __value_error};
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use extract::{
    FileData, FileValue, FormBuilder, FormErrors, FromField, FromForm, Secret, ValueError,
};
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use hook::MemorySink;
pub use hook::{DiscardSink, Inspector, NoInspector, Refusal, Sink, TokenCheck, Verdict};
pub use kind::FormKind;
pub use limits::{
    EmptyFilePolicy, ExtendedFilenamePolicy, HeaderPolicy, Limits, PercentPolicy, Policy,
    TokenField, TokenPlacement,
};
pub use multipart::boundary::{Boundary, MAX_BOUNDARY_LEN, MAX_DELIMITER_LEN};
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use multipart::driver::{Driver, Progress};
pub use multipart::filename::{FileName, FileNameSource};
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use multipart::owned_head::OwnedPartHead;
pub use multipart::parser::{
    Charset, ContentType, Event, Headers, MultipartParser, PartHead, PartKind, PartSummary, Step,
};
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub use multipart::writer::MultipartWriter;
pub use multipart::writer::encode_part_head;
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use multipart::{
    Multipart, Part, parse_multipart, parse_multipart_inspected, parse_multipart_with,
};
pub use urlencoded::decode::decode_into;
pub use urlencoded::encode::encode_into;
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use urlencoded::encode::{Serializer, serialize_urlencoded};
pub use urlencoded::raw::{RawPair, RawPairs, raw_pairs};
pub use urlencoded::stream::{UrlencodedEvent, UrlencodedParser, UrlencodedStep};
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub use urlencoded::{
    Form, Pairs, pairs, parse_query, parse_urlencoded, parse_urlencoded_inspected,
    parse_urlencoded_with,
};

#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub use io::{MultipartReader, PartReader};
#[cfg(feature = "fs")]
#[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
pub use store::{
    SpillBudget, SpillMode, SpillQuota, Store, StoreError, StoreSink, StoreStats, StoredFile,
    StoredReader, Upload, UploadSession, read_multipart, sweep,
};

/// Crate version string, populated by Cargo at build time.
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

#[cfg(test)]
mod tests {
    use super::VERSION;

    #[test]
    fn test_version_matches_manifest() {
        assert_eq!(VERSION, env!("CARGO_PKG_VERSION"));
        assert_eq!(VERSION.split('.').count(), 3, "expected MAJOR.MINOR.PATCH");
    }

    /// The size table of `docs/API.md` (64-bit targets), held by a test.
    #[test]
    #[cfg(target_pointer_width = "64")]
    fn test_the_api_size_table_holds() {
        use core::mem::size_of;
        assert_eq!(size_of::<super::Boundary>(), 149);
        assert!(size_of::<super::FormError>() <= 48);
        assert_eq!(size_of::<super::Limits>(), 72);
        assert_eq!(size_of::<super::RawPair<'static>>(), 48);
        assert!(size_of::<super::MultipartParser<&mut [u8]>>() <= 384);
        // `Limits::memory_bound` counts 1 KiB of per-request state.
        #[cfg(feature = "alloc")]
        assert!(size_of::<super::MultipartParser<alloc::vec::Vec<u8>>>() <= 1024);
        #[cfg(feature = "fs")]
        assert!(size_of::<super::UploadSession>() <= 1024);
    }

    #[test]
    fn test_public_types_are_send_and_sync() {
        fn send_sync<T: Send + Sync>() {}
        send_sync::<super::Limits>();
        send_sync::<super::Policy>();
        send_sync::<super::Boundary>();
        send_sync::<super::FormError>();
        send_sync::<super::RefusalDigest<2>>();
        send_sync::<super::MultipartParser<&mut [u8]>>();
        #[cfg(feature = "alloc")]
        {
            send_sync::<super::MultipartParser<alloc::vec::Vec<u8>>>();
            send_sync::<super::Form>();
            send_sync::<super::Multipart<'static>>();
            send_sync::<super::OwnedPartHead>();
            send_sync::<super::MemorySink>();
            send_sync::<super::Driver<alloc::vec::Vec<u8>, super::MemorySink>>();
            send_sync::<super::FileData>();
            send_sync::<super::Secret>();
        }
        #[cfg(feature = "std")]
        send_sync::<super::MultipartReader<std::fs::File>>();
        #[cfg(feature = "fs")]
        {
            send_sync::<super::Store>();
            send_sync::<super::StoreSink>();
            send_sync::<super::StoredFile>();
            send_sync::<super::Upload>();
            send_sync::<super::UploadSession>();
        }
    }
}

/// Every example of `docs/API.md`, compiled and run as a doctest (D-100).
/// They use every feature, so they run with `--all-features`.
#[cfg(all(doctest, feature = "fs", feature = "unicode"))]
#[doc = include_str!("../docs/API.md")]
struct ApiExamples;