kcenon::pacs::web::dicomweb::multipart_parser Class Reference

Parser for multipart/related request bodies. More...

#include <dicomweb_endpoints.h>

Collaboration diagram for kcenon::pacs::web::dicomweb::multipart_parser:

Classes
struct	parse_error
	Parse error information. More...
struct	parse_result
	Parse result - either parts or error. More...

Static Public Member Functions
static auto	parse (std::string_view content_type, std::string_view body) -> parse_result
	Parse a multipart/related request body.
static auto	extract_boundary (std::string_view content_type) -> std::optional< std::string >
	Extract boundary from Content-Type header.
static auto	extract_type (std::string_view content_type) -> std::optional< std::string >
	Extract type parameter from Content-Type header.

Static Private Member Functions
static auto	parse_part_headers (std::string_view header_section) -> std::vector< std::pair< std::string, std::string > >
	Parse headers from a part's header section.

Detailed Description

Parser for multipart/related request bodies.

Parses incoming multipart/related requests as used by STOW-RS for uploading DICOM instances.

Example

auto parts = multipart_parser::parse(content_type_header, request_body);
for (const auto& part : parts) {
    if (part.content_type == "application/dicom") {
        // Process DICOM data
    }
}

Definition at line 232 of file dicomweb_endpoints.h.

Member Function Documentation

extract_boundary()

auto kcenon::pacs::web::dicomweb::multipart_parser::extract_boundary ( std::string_view content_type ) -> std::optional<std::string>

staticnodiscard

Extract boundary from Content-Type header.

Parameters

content_type

The Content-Type header value

Returns

Boundary string or nullopt if not found

Definition at line 332 of file dicomweb_endpoints.cpp.

                              {
    // Find boundary parameter in Content-Type header
    // Example: multipart/related; type="application/dicom"; boundary=----=_Part_123
    auto boundary_pos = content_type.find("boundary=");
    if (boundary_pos == std::string_view::npos) {
        return std::nullopt;
    }
 
    auto value_start = boundary_pos + 9; // length of "boundary="
    if (value_start >= content_type.size()) {
        return std::nullopt;
    }
 
    // Check if boundary is quoted
    if (content_type[value_start] == '"') {
        auto end_quote = content_type.find('"', value_start + 1);
        if (end_quote == std::string_view::npos) {
            return std::nullopt;
        }
        return std::string(content_type.substr(value_start + 1,
                                               end_quote - value_start - 1));
    }
 
    // Unquoted boundary - find end (semicolon, space, or end of string)
    auto end_pos = content_type.find_first_of("; \t", value_start);
    if (end_pos == std::string_view::npos) {
        end_pos = content_type.size();
    }
    return std::string(content_type.substr(value_start, end_pos - value_start));
}

extract_type()

auto kcenon::pacs::web::dicomweb::multipart_parser::extract_type ( std::string_view content_type ) -> std::optional<std::string>

staticnodiscard

Extract type parameter from Content-Type header.

Parameters

content_type

The Content-Type header value

Returns

Type value or nullopt if not found

Definition at line 364 of file dicomweb_endpoints.cpp.

                              {
    // Find type parameter in Content-Type header
    // Example: multipart/related; type="application/dicom"
    auto type_pos = content_type.find("type=");
    if (type_pos == std::string_view::npos) {
        return std::nullopt;
    }
 
    auto value_start = type_pos + 5; // length of "type="
    if (value_start >= content_type.size()) {
        return std::nullopt;
    }
 
    // Check if type is quoted
    if (content_type[value_start] == '"') {
        auto end_quote = content_type.find('"', value_start + 1);
        if (end_quote == std::string_view::npos) {
            return std::nullopt;
        }
        return std::string(content_type.substr(value_start + 1,
                                               end_quote - value_start - 1));
    }
 
    // Unquoted type
    auto end_pos = content_type.find_first_of("; \t", value_start);
    if (end_pos == std::string_view::npos) {
        end_pos = content_type.size();
    }
    return std::string(content_type.substr(value_start, end_pos - value_start));
}

parse()

auto kcenon::pacs::web::dicomweb::multipart_parser::parse ( std::string_view content_type, std::string_view body ) -> parse_result

staticnodiscard

Parse a multipart/related request body.

Parameters

content_type	The Content-Type header value (must include boundary)
body	The raw request body

Returns

Parse result containing parts or error

Definition at line 436 of file dicomweb_endpoints.cpp.

                                                                  {
    parse_result result;
 
    // Extract boundary from Content-Type
    auto boundary_opt = extract_boundary(content_type);
    if (!boundary_opt) {
        result.error = parse_error{
            "INVALID_BOUNDARY",
            "Missing or invalid boundary in Content-Type header"};
        return result;
    }
 
    const std::string& boundary = *boundary_opt;
    std::string delimiter = "--" + boundary;
    std::string end_delimiter = "--" + boundary + "--";
 
    // Find first boundary
    auto pos = body.find(delimiter);
    if (pos == std::string_view::npos) {
        result.error = parse_error{
            "NO_PARTS",
            "No parts found in multipart body"};
        return result;
    }
 
    // Skip to after first boundary and CRLF
    pos += delimiter.size();
    if (pos < body.size() && body.substr(pos, 2) == "\r\n") {
        pos += 2;
    }
 
    // Parse each part
    while (pos < body.size()) {
        // Check for end delimiter
        if (body.substr(pos).starts_with("--")) {
            break; // End of multipart
        }
 
        // Find next boundary
        auto next_boundary = body.find(delimiter, pos);
        if (next_boundary == std::string_view::npos) {
            // No more parts
            break;
        }
 
        // Extract part content (excluding trailing CRLF before boundary)
        auto part_content = body.substr(pos, next_boundary - pos);
        if (part_content.size() >= 2 &&
            part_content.substr(part_content.size() - 2) == "\r\n") {
            part_content = part_content.substr(0, part_content.size() - 2);
        }
 
        // Split part into headers and body
        auto header_end = part_content.find("\r\n\r\n");
        if (header_end == std::string_view::npos) {
            // Malformed part - skip
            pos = next_boundary + delimiter.size();
            if (pos < body.size() && body.substr(pos, 2) == "\r\n") {
                pos += 2;
            }
            continue;
        }
 
        auto header_section = part_content.substr(0, header_end);
        auto body_section = part_content.substr(header_end + 4);
 
        // Parse headers
        auto headers = parse_part_headers(header_section);
 
        // Create multipart_part
        multipart_part part;
        for (const auto& [name, value] : headers) {
            if (name == "content-type") {
                part.content_type = value;
            } else if (name == "content-location") {
                part.content_location = value;
            } else if (name == "content-id") {
                part.content_id = value;
            }
        }
 
        // Default content type if not specified
        if (part.content_type.empty()) {
            part.content_type = std::string(media_type::dicom);
        }
 
        // Copy body data
        part.data.assign(
            reinterpret_cast<const uint8_t*>(body_section.data()),
            reinterpret_cast<const uint8_t*>(body_section.data() +
                                             body_section.size()));
 
        result.parts.push_back(std::move(part));
 
        // Move to next part
        pos = next_boundary + delimiter.size();
        if (pos < body.size() && body.substr(pos, 2) == "\r\n") {
            pos += 2;
        }
    }
 
    if (result.parts.empty()) {
        result.error = parse_error{
            "NO_VALID_PARTS",
            "No valid parts found in multipart body"};
    }
 
    return result;
}

References kcenon::pacs::web::dicomweb::multipart_part::content_id, kcenon::pacs::web::dicomweb::multipart_part::content_location, kcenon::pacs::web::dicomweb::multipart_part::content_type, kcenon::pacs::web::dicomweb::multipart_part::data, kcenon::pacs::web::dicomweb::media_type::dicom, kcenon::pacs::web::dicomweb::multipart_parser::parse_result::error, name, and kcenon::pacs::web::dicomweb::multipart_parser::parse_result::parts.

parse_part_headers()

auto kcenon::pacs::web::dicomweb::multipart_parser::parse_part_headers ( std::string_view header_section ) -> std::vector<std::pair<std::string, std::string>>

staticnodiscardprivate

Parse headers from a part's header section.

Parameters

header_section

The raw header section

Returns

Map of header name to value

Definition at line 396 of file dicomweb_endpoints.cpp.

                                                {
    std::vector<std::pair<std::string, std::string>> headers;
 
    size_t pos = 0;
    while (pos < header_section.size()) {
        // Find end of line
        auto line_end = header_section.find("\r\n", pos);
        if (line_end == std::string_view::npos) {
            line_end = header_section.size();
        }
 
        auto line = header_section.substr(pos, line_end - pos);
        if (line.empty()) {
            break;
        }
 
        // Parse header: name: value
        auto colon_pos = line.find(':');
        if (colon_pos != std::string_view::npos) {
            auto name = trim(line.substr(0, colon_pos));
            auto value = trim(line.substr(colon_pos + 1));
 
            // Convert header name to lowercase for case-insensitive matching
            std::string name_lower;
            name_lower.reserve(name.size());
            for (char c : name) {
                name_lower += static_cast<char>(std::tolower(
                    static_cast<unsigned char>(c)));
            }
 
            headers.emplace_back(std::move(name_lower), std::string(value));
        }
 
        pos = line_end + 2; // Skip \r\n
    }
 
    return headers;
}

References name.

---

The documentation for this class was generated from the following files:

• include/kcenon/pacs/web/endpoints/dicomweb_endpoints.h
• src/web/endpoints/dicomweb_endpoints.cpp