Enum MultipartError 

pub enum MultipartError {
    InvalidBoundary,
    FieldTooLarge {
        field_name: String,
        max_size: usize,
    },
    TooManyFields {
        max_fields: usize,
    },
    RequestTooLarge {
        max_size: usize,
    },
    InvalidField(String),
    Io(Error),
    InvalidUtf8(Utf8Error),
    Parse(String),
}

Errors that can occur during multipart form data parsing.

This enum covers all possible error conditions that may arise when processing multipart/form-data requests, from validation issues to resource limit violations.

Error Categories

Validation Errors

• InvalidBoundary: The boundary parameter is malformed
• InvalidField: A field has invalid format or headers
• InvalidUtf8: Text field contains invalid UTF-8 sequences

Size Limit Errors

• FieldTooLarge: An individual field exceeds the configured size limit
• TooManyFields: The request contains more fields than allowed
• RequestTooLarge: The entire request exceeds the size limit

System Errors

• Io: File system or network I/O errors
• Parse: Low-level parsing errors from the multipart library

Examples

use ignitia::multipart::MultipartError;

match error {
    MultipartError::FieldTooLarge { field_name, max_size } => {
        println!("Field '{}' is too large (max: {} bytes)", field_name, max_size);
    }
    MultipartError::TooManyFields { max_fields } => {
        println!("Too many fields (max: {})", max_fields);
    }
    MultipartError::InvalidBoundary => {
        println!("Invalid multipart boundary");
    }
    _ => {
        println!("Other multipart error: {}", error);
    }
}

Variants

InvalidBoundary

The multipart boundary parameter is invalid or malformed.

This occurs when the Content-Type header contains an invalid boundary parameter, or when the boundary is not properly formatted according to RFC 2046 specifications.

HTTP Status

This error maps to HTTP 400 Bad Request.

FieldTooLarge

A field exceeds the maximum allowed size.

This error is thrown when an individual field’s content exceeds the max_field_size limit configured in MultipartConfig.

Fields

• field_name: The name of the field that exceeded the limit
• max_size: The maximum allowed size in bytes

HTTP Status

This error maps to HTTP 413 Payload Too Large.

Examples

use ignitia::multipart::MultipartError;

let error = MultipartError::FieldTooLarge {
    field_name: "upload_file".to_string(),
    max_size: 1024 * 1024, // 1MB
};

Fields

field_name: String

Name of the field that exceeded the size limit

max_size: usize

Maximum allowed size in bytes

TooManyFields

The request contains too many fields.

This error occurs when the number of fields in the multipart request exceeds the max_fields limit configured in MultipartConfig.

Fields

• max_fields: The maximum number of fields allowed

HTTP Status

This error maps to HTTP 413 Payload Too Large.

Fields

max_fields: usize

Maximum number of fields allowed

RequestTooLarge

The entire request size exceeds the configured limit.

This error is thrown when the total size of all fields combined exceeds the max_request_size limit configured in MultipartConfig.

Fields

• max_size: The maximum allowed request size in bytes

HTTP Status

This error maps to HTTP 413 Payload Too Large.

Fields

max_size: usize

Maximum allowed request size in bytes

InvalidField(String)

A field has invalid format or headers.

This error occurs when a multipart field is malformed, has missing required headers, or contains invalid header values.

HTTP Status

This error maps to HTTP 400 Bad Request.

Io(Error)

An I/O error occurred during parsing.

This wraps standard I/O errors that may occur when reading from the request stream, writing temporary files, or performing other file system operations.

HTTP Status

This error maps to HTTP 400 Bad Request (though it could indicate a server-side issue in some cases).

InvalidUtf8(Utf8Error)

A text field contains invalid UTF-8 sequences.

This error occurs when attempting to parse a field as text, but the field content is not valid UTF-8.

HTTP Status

This error maps to HTTP 400 Bad Request.

Parse(String)

A low-level parsing error occurred.

This wraps errors from the underlying multipart parsing library, typically indicating malformed multipart data that doesn’t conform to RFC standards.

HTTP Status

This error maps to HTTP 400 Bad Request.

Trait Implementations

impl CustomError for MultipartError

fn status_code(&self) -> StatusCode

Returns the appropriate HTTP status code for this error.

Size-related errors return 413 Payload Too Large, while validation and parsing errors return 400 Bad Request.

fn error_type(&self) -> &'static str

Returns a string identifier for the error type.

This is used in structured error responses to help clients programmatically identify and handle different error types.

fn metadata(&self) -> Option<Value>

Returns additional metadata for structured error responses.

For size-related errors, this includes the limits that were exceeded.

fn error_code(&self) -> Option<String>

Returns an optional application-specific error code.

impl Debug for MultipartError

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

Formats the value using the given formatter.

impl Display for MultipartError

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

Formats the value using the given formatter.

impl Error for MultipartError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for MultipartError

fn from(err: Error) -> Self

Converts standard I/O errors into MultipartError::Io.

This provides automatic conversion for file system and network errors that may occur during multipart processing.

impl From<MultipartError> for Error

fn from(err: MultipartError) -> Self

Converts a MultipartError into the framework’s main Error type.

This allows multipart errors to be seamlessly integrated with Ignitia’s error handling and response generation system.

impl From<MultipartError> for MultipartRejection

fn from(err: MultipartError) -> Self

Converts a MultipartError into a MultipartRejection.

impl From<Utf8Error> for MultipartError

fn from(err: Utf8Error) -> Self

Converts UTF-8 validation errors into MultipartError::InvalidUtf8.

This provides automatic conversion when attempting to parse binary field data as UTF-8 text.