kcenon::pacs::network::pdu_decoder Class Reference

Decoder for DICOM PDU (Protocol Data Unit) messages. More...

#include <pdu_decoder.h>

Collaboration diagram for kcenon::pacs::network::pdu_decoder:

Static Public Member Functions
General Decoding
static DecodeResult< pdu >	decode (std::span< const uint8_t > data)
	Decode any PDU from bytes.
static std::optional< size_t >	pdu_length (std::span< const uint8_t > data)
	Check if a complete PDU is available in the buffer.
static std::optional< pdu_type >	peek_pdu_type (std::span< const uint8_t > data)
	Get the PDU type from buffer without full decoding.
Specific Decoders
static DecodeResult< associate_rq >	decode_associate_rq (std::span< const uint8_t > data)
	Decode an A-ASSOCIATE-RQ PDU.
static DecodeResult< associate_ac >	decode_associate_ac (std::span< const uint8_t > data)
	Decode an A-ASSOCIATE-AC PDU.
static DecodeResult< associate_rj >	decode_associate_rj (std::span< const uint8_t > data)
	Decode an A-ASSOCIATE-RJ PDU.
static DecodeResult< p_data_tf_pdu >	decode_p_data_tf (std::span< const uint8_t > data)
	Decode a P-DATA-TF PDU.
static DecodeResult< release_rq_pdu >	decode_release_rq (std::span< const uint8_t > data)
	Decode an A-RELEASE-RQ PDU.
static DecodeResult< release_rp_pdu >	decode_release_rp (std::span< const uint8_t > data)
	Decode an A-RELEASE-RP PDU.
static DecodeResult< abort_pdu >	decode_abort (std::span< const uint8_t > data)
	Decode an A-ABORT PDU.

Static Private Member Functions
Helper Functions
static uint16_t	read_uint16_be (std::span< const uint8_t > data, size_t offset)
	Read a 16-bit unsigned integer in big-endian format.
static uint32_t	read_uint32_be (std::span< const uint8_t > data, size_t offset)
	Read a 32-bit unsigned integer in big-endian format.
static std::string	read_ae_title (std::span< const uint8_t > data, size_t offset)
	Read an AE Title (16 bytes, space-trimmed).
static std::string	read_uid (std::span< const uint8_t > data, size_t offset, size_t length)
	Read a UID string (trim trailing null/space padding).
static DecodeResult< uint32_t >	validate_pdu_header (std::span< const uint8_t > data, uint8_t expected_type=0)
	Validate PDU header and extract length.
static DecodeResult< std::tuple< std::string, std::vector< presentation_context_rq >, std::vector< presentation_context_ac >, user_information > >	decode_variable_items (std::span< const uint8_t > data, bool is_rq)
	Decode variable items from ASSOCIATE-RQ/AC PDUs.
static DecodeResult< user_information >	decode_user_info_item (std::span< const uint8_t > data)
	Decode User Information sub-items.

Detailed Description

Decoder for DICOM PDU (Protocol Data Unit) messages.

This class provides static methods to decode various PDU types according to DICOM PS3.8 Upper Layer Protocol.

PDU Structure:

┌─────────────────────────────────────┐
│ PDU Header                          │
├───────────┬───────────┬─────────────┤
│ Type      │ Reserved  │ Length      │
│ (1 byte)  │ (1 byte)  │ (4 bytes)   │
└───────────┴───────────┴─────────────┘
│ PDU Data (variable)                 │
└─────────────────────────────────────┘

See also

DICOM PS3.8 Section 9 - Upper Layer Protocol

Definition at line 127 of file pdu_decoder.h.

Member Function Documentation

decode()

DecodeResult< pdu > kcenon::pacs::network::pdu_decoder::decode ( std::span< const uint8_t > data )

staticnodiscard

Decode any PDU from bytes.

Parameters

data	Input byte buffer

Returns

Result containing decoded PDU or error

Automatically detects PDU type from the first byte and dispatches to the appropriate specific decoder.

Definition at line 172 of file pdu_decoder.cpp.

                                                                 {
    if (data.size() < PDU_HEADER_SIZE) {
        return make_error<pdu>(pdu_decode_error::incomplete_header);
    }
 
    const uint8_t type = data[0];
 
    switch (type) {
        case 0x01: {
            auto result = decode_associate_rq(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x02: {
            auto result = decode_associate_ac(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x03: {
            auto result = decode_associate_rj(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x04: {
            auto result = decode_p_data_tf(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x05: {
            auto result = decode_release_rq(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x06: {
            auto result = decode_release_rp(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        case 0x07: {
            auto result = decode_abort(data);
            if (result.is_ok()) {
                return make_ok<pdu>(std::move(result.value()));
            }
            return result.error();
        }
        default:
            return make_error<pdu>(pdu_decode_error::invalid_pdu_type,
                "Unknown PDU type: " + std::to_string(type));
    }
}

References decode_abort(), decode_associate_ac(), decode_associate_rj(), decode_associate_rq(), decode_p_data_tf(), decode_release_rp(), decode_release_rq(), kcenon::pacs::network::incomplete_header, and kcenon::pacs::network::invalid_pdu_type.

Here is the call graph for this function:

decode_abort()

DecodeResult< abort_pdu > kcenon::pacs::network::pdu_decoder::decode_abort ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-ABORT PDU.

Parameters

data	Input byte buffer

Returns

Result containing abort_pdu or error

Definition at line 294 of file pdu_decoder.cpp.

                                                                             {
    auto header_result = validate_pdu_header(data, 0x07);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    if (data.size() < FIXED_PDU_SIZE) {
        return make_error<abort_pdu>(pdu_decode_error::incomplete_pdu);
    }
 
    abort_pdu abort;
    abort.source = static_cast<abort_source>(data[8]);
    abort.reason = static_cast<abort_reason>(data[9]);
 
    return make_ok(std::move(abort));
}

References kcenon::pacs::network::abort, kcenon::pacs::network::incomplete_pdu, kcenon::pacs::network::abort_pdu::source, and validate_pdu_header().

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_associate_ac()

DecodeResult< associate_ac > kcenon::pacs::network::pdu_decoder::decode_associate_ac ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-ASSOCIATE-AC PDU.

Parameters

data	Input byte buffer

Returns

Result containing associate_ac or error

Definition at line 626 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x02);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    const uint32_t pdu_length = header_result.value();
 
    // Check minimum size
    if (pdu_length < ASSOCIATE_HEADER_SIZE) {
        return make_error<associate_ac>(pdu_decode_error::malformed_pdu,
            "PDU too short for ASSOCIATE-AC");
    }
 
    // Check protocol version
    const uint16_t protocol_version = read_uint16_be(data, 6);
    if (protocol_version != DICOM_PROTOCOL_VERSION) {
        return make_error<associate_ac>(pdu_decode_error::invalid_protocol_version,
            "Expected version 1, got " + std::to_string(protocol_version));
    }
 
    associate_ac ac;
 
    // Called AE Title
    ac.called_ae_title = read_ae_title(data, 10);
 
    // Calling AE Title
    ac.calling_ae_title = read_ae_title(data, 26);
 
    // Variable items
    const size_t variable_start = PDU_HEADER_SIZE + ASSOCIATE_HEADER_SIZE;
    const size_t variable_length = pdu_length - ASSOCIATE_HEADER_SIZE;
 
    if (variable_length > 0 && variable_start + variable_length <= data.size()) {
        auto var_result = decode_variable_items(
            data.subspan(variable_start, variable_length), false);
 
        if (var_result.is_ok()) {
            auto& [app_ctx, pcs_rq, pcs_ac, user_info] = var_result.value();
            ac.application_context = std::move(app_ctx);
            ac.presentation_contexts = std::move(pcs_ac);
            ac.user_info = std::move(user_info);
        }
    }
 
    return make_ok(std::move(ac));
}

References kcenon::pacs::network::associate_ac::application_context, kcenon::pacs::network::associate_ac::called_ae_title, kcenon::pacs::network::associate_ac::calling_ae_title, decode_variable_items(), kcenon::pacs::network::DICOM_PROTOCOL_VERSION, kcenon::pacs::network::invalid_protocol_version, kcenon::pacs::network::malformed_pdu, pdu_length(), kcenon::pacs::network::associate_ac::presentation_contexts, read_ae_title(), read_uint16_be(), kcenon::pacs::network::associate_ac::user_info, and validate_pdu_header().

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_associate_rj()

DecodeResult< associate_rj > kcenon::pacs::network::pdu_decoder::decode_associate_rj ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-ASSOCIATE-RJ PDU.

Parameters

data	Input byte buffer

Returns

Result containing associate_rj or error

Definition at line 239 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x03);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    // A-ASSOCIATE-RJ is always 10 bytes
    if (data.size() < FIXED_PDU_SIZE) {
        return make_error<associate_rj>(pdu_decode_error::incomplete_pdu);
    }
 
    associate_rj rj;
    rj.result = static_cast<reject_result>(data[7]);
    rj.source = data[8];
    rj.reason = data[9];
 
    return make_ok(std::move(rj));
}

References kcenon::pacs::network::incomplete_pdu, kcenon::pacs::network::associate_rj::reason, kcenon::pacs::network::associate_rj::result, kcenon::pacs::network::associate_rj::source, and validate_pdu_header().

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_associate_rq()

DecodeResult< associate_rq > kcenon::pacs::network::pdu_decoder::decode_associate_rq ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-ASSOCIATE-RQ PDU.

Parameters

data	Input byte buffer

Returns

Result containing associate_rq or error

Definition at line 570 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x01);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    const uint32_t pdu_length = header_result.value();
 
    // Check minimum size for ASSOCIATE header
    if (pdu_length < ASSOCIATE_HEADER_SIZE) {
        return make_error<associate_rq>(pdu_decode_error::malformed_pdu,
            "PDU too short for ASSOCIATE-RQ");
    }
 
    // Check protocol version (bytes 6-7)
    const uint16_t protocol_version = read_uint16_be(data, 6);
    if (protocol_version != DICOM_PROTOCOL_VERSION) {
        return make_error<associate_rq>(pdu_decode_error::invalid_protocol_version,
            "Expected version 1, got " + std::to_string(protocol_version));
    }
 
    associate_rq rq;
 
    // Called AE Title (bytes 10-25)
    rq.called_ae_title = read_ae_title(data, 10);
 
    // Calling AE Title (bytes 26-41)
    rq.calling_ae_title = read_ae_title(data, 26);
 
    // Reserved bytes 42-73 (32 bytes)
    // Variable items start at byte 74
 
    const size_t variable_start = PDU_HEADER_SIZE + ASSOCIATE_HEADER_SIZE;
    const size_t variable_length = pdu_length - ASSOCIATE_HEADER_SIZE;
 
    if (variable_length > 0 && variable_start + variable_length <= data.size()) {
        auto var_result = decode_variable_items(
            data.subspan(variable_start, variable_length), true);
 
        if (var_result.is_ok()) {
            auto& [app_ctx, pcs_rq, pcs_ac, user_info] = var_result.value();
            rq.application_context = std::move(app_ctx);
            rq.presentation_contexts = std::move(pcs_rq);
            rq.user_info = std::move(user_info);
        }
    }
 
    return make_ok(std::move(rq));
}

References kcenon::pacs::network::associate_rq::application_context, kcenon::pacs::network::associate_rq::called_ae_title, kcenon::pacs::network::associate_rq::calling_ae_title, decode_variable_items(), kcenon::pacs::network::DICOM_PROTOCOL_VERSION, kcenon::pacs::network::invalid_protocol_version, kcenon::pacs::network::malformed_pdu, pdu_length(), kcenon::pacs::network::associate_rq::presentation_contexts, read_ae_title(), read_uint16_be(), kcenon::pacs::network::associate_rq::user_info, and validate_pdu_header().

Referenced by decode(), and kcenon::pacs::network::v2::dicom_association_handler::handle_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_p_data_tf()

DecodeResult< p_data_tf_pdu > kcenon::pacs::network::pdu_decoder::decode_p_data_tf ( std::span< const uint8_t > data )

staticnodiscard

Decode a P-DATA-TF PDU.

Parameters

data	Input byte buffer

Returns

Result containing p_data_tf_pdu or error

Definition at line 315 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x04);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    const uint32_t pdu_length = header_result.value();
    const size_t pdu_end = PDU_HEADER_SIZE + pdu_length;
 
    p_data_tf_pdu result;
    size_t pos = PDU_HEADER_SIZE;
 
    while (pos < pdu_end) {
        // Each PDV item has:
        // - 4-byte length
        // - 1-byte presentation context ID
        // - 1-byte message control header
        // - variable data
 
        if (pos + 4 > pdu_end) {
            return make_error<p_data_tf_pdu>(pdu_decode_error::malformed_pdu,
                "Incomplete PDV item length");
        }
 
        const uint32_t pdv_item_length = read_uint32_be(data, pos);
        pos += 4;
 
        if (pdv_item_length < 2) {
            return make_error<p_data_tf_pdu>(pdu_decode_error::malformed_pdu,
                "PDV item length too small");
        }
 
        if (pos + pdv_item_length > pdu_end) {
            return make_error<p_data_tf_pdu>(pdu_decode_error::buffer_overflow,
                "PDV item exceeds PDU bounds");
        }
 
        presentation_data_value pdv;
        pdv.context_id = data[pos];
        pos += 1;
 
        const uint8_t control = data[pos];
        pos += 1;
 
        pdv.is_command = (control & 0x01) != 0;
        pdv.is_last = (control & 0x02) != 0;
 
        // Data length = item length - context_id (1) - control (1)
        const size_t data_length = pdv_item_length - 2;
        pdv.data.assign(data.begin() + static_cast<ptrdiff_t>(pos),
                        data.begin() + static_cast<ptrdiff_t>(pos + data_length));
        pos += data_length;
 
        result.pdvs.push_back(std::move(pdv));
    }
 
    return make_ok(std::move(result));
}

References kcenon::pacs::network::buffer_overflow, kcenon::pacs::network::presentation_data_value::context_id, kcenon::pacs::network::presentation_data_value::data, kcenon::pacs::network::presentation_data_value::is_command, kcenon::pacs::network::presentation_data_value::is_last, kcenon::pacs::network::malformed_pdu, pdu_length(), kcenon::pacs::network::p_data_tf_pdu::pdvs, read_uint32_be(), and validate_pdu_header().

Referenced by decode(), and kcenon::pacs::network::v2::dicom_association_handler::handle_p_data_tf().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_release_rp()

DecodeResult< release_rp_pdu > kcenon::pacs::network::pdu_decoder::decode_release_rp ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-RELEASE-RP PDU.

Parameters

data	Input byte buffer

Returns

Result containing release_rp_pdu or error

Definition at line 279 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x06);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    return make_ok(release_rp_pdu{});
}

References validate_pdu_header().

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_release_rq()

DecodeResult< release_rq_pdu > kcenon::pacs::network::pdu_decoder::decode_release_rq ( std::span< const uint8_t > data )

staticnodiscard

Decode an A-RELEASE-RQ PDU.

Parameters

data	Input byte buffer

Returns

Result containing release_rq_pdu or error

Definition at line 264 of file pdu_decoder.cpp.

                                 {
 
    auto header_result = validate_pdu_header(data, 0x05);
    if (header_result.is_err()) {
        return header_result.error();
    }
 
    return make_ok(release_rq_pdu{});
}

References validate_pdu_header().

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_user_info_item()

DecodeResult< user_information > kcenon::pacs::network::pdu_decoder::decode_user_info_item ( std::span< const uint8_t > data )

staticnodiscardprivate

Decode User Information sub-items.

Definition at line 508 of file pdu_decoder.cpp.

                                 {
 
    user_information ui;
    size_t pos = 0;
 
    while (pos < data.size()) {
        if (pos + 4 > data.size()) break;
 
        const uint8_t sub_type = data[pos];
        // Reserved byte at pos + 1
        const uint16_t sub_length = read_uint16_be(data, pos + 2);
        pos += 4;
 
        if (pos + sub_length > data.size()) break;
 
        switch (sub_type) {
            case 0x51:  // Maximum Length
                if (sub_length >= 4) {
                    ui.max_pdu_length = read_uint32_be(data, pos);
                }
                break;
 
            case 0x52:  // Implementation Class UID
                ui.implementation_class_uid = read_uid(data, pos, sub_length);
                break;
 
            case 0x55:  // Implementation Version Name
                ui.implementation_version_name = read_uid(data, pos, sub_length);
                break;
 
            case 0x54: {  // SCP/SCU Role Selection
                if (sub_length >= 4) {
                    const uint16_t uid_length = read_uint16_be(data, pos);
                    // UID is padded to even length in encoder
                    const uint16_t padded_uid_length = uid_length + (uid_length % 2);
                    if (pos + 2 + padded_uid_length + 2 <= pos + sub_length) {
                        scp_scu_role_selection role;
                        role.sop_class_uid = read_uid(data, pos + 2, uid_length);
                        role.scu_role = (data[pos + 2 + padded_uid_length] != 0);
                        role.scp_role = (data[pos + 2 + padded_uid_length + 1] != 0);
                        ui.role_selections.push_back(std::move(role));
                    }
                }
                break;
            }
 
            default:
                // Skip unknown sub-items
                break;
        }
 
        pos += sub_length;
    }
 
    return make_ok(std::move(ui));
}

References kcenon::pacs::network::user_information::implementation_class_uid, kcenon::pacs::network::user_information::implementation_version_name, kcenon::pacs::network::user_information::max_pdu_length, read_uid(), read_uint16_be(), read_uint32_be(), kcenon::pacs::network::user_information::role_selections, and kcenon::pacs::network::scp_scu_role_selection::sop_class_uid.

Referenced by decode_variable_items().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_variable_items()

DecodeResult< std::tuple< std::string, std::vector< presentation_context_rq >, std::vector< presentation_context_ac >, user_information > > kcenon::pacs::network::pdu_decoder::decode_variable_items ( std::span< const uint8_t > data, bool is_rq )

staticnodiscardprivate

Decode variable items from ASSOCIATE-RQ/AC PDUs.

Definition at line 385 of file pdu_decoder.cpp.

                                                                             {
    std::string application_context;
    std::vector<presentation_context_rq> pcs_rq;
    std::vector<presentation_context_ac> pcs_ac;
    user_information user_info;
 
    size_t pos = 0;
 
    while (pos < data.size()) {
        if (pos + 4 > data.size()) {
            return make_error<std::tuple<std::string,
                std::vector<presentation_context_rq>,
                std::vector<presentation_context_ac>,
                user_information>>(pdu_decode_error::malformed_pdu,
                    "Incomplete item header");
        }
 
        const uint8_t item_type_byte = data[pos];
        // Reserved byte at pos + 1
        const uint16_t item_length = read_uint16_be(data, pos + 2);
        pos += 4;
 
        if (pos + item_length > data.size()) {
            return make_error<std::tuple<std::string,
                std::vector<presentation_context_rq>,
                std::vector<presentation_context_ac>,
                user_information>>(pdu_decode_error::buffer_overflow,
                    "Item length exceeds buffer");
        }
 
        switch (item_type_byte) {
            case 0x10:  // Application Context
                application_context = read_uid(data, pos, item_length);
                break;
 
            case 0x20:  // Presentation Context (RQ)
                if (is_rq) {
                    // Parse presentation context RQ
                    presentation_context_rq pc;
                    pc.id = data[pos];
                    // 3 reserved bytes
 
                    size_t sub_pos = pos + 4;
                    const size_t pc_end = pos + item_length;
 
                    while (sub_pos < pc_end) {
                        if (sub_pos + 4 > pc_end) break;
 
                        const uint8_t sub_type = data[sub_pos];
                        const uint16_t sub_length = read_uint16_be(data, sub_pos + 2);
                        sub_pos += 4;
 
                        if (sub_pos + sub_length > pc_end) break;
 
                        if (sub_type == 0x30) {  // Abstract Syntax
                            pc.abstract_syntax = read_uid(data, sub_pos, sub_length);
                        } else if (sub_type == 0x40) {  // Transfer Syntax
                            pc.transfer_syntaxes.push_back(
                                read_uid(data, sub_pos, sub_length));
                        }
                        sub_pos += sub_length;
                    }
                    pcs_rq.push_back(std::move(pc));
                }
                break;
 
            case 0x21:  // Presentation Context (AC)
                if (!is_rq) {
                    presentation_context_ac pc;
                    pc.id = data[pos];
                    // Reserved byte at pos + 1
                    pc.result = static_cast<presentation_context_result>(data[pos + 2]);
                    // Reserved byte at pos + 3
 
                    size_t sub_pos = pos + 4;
                    const size_t pc_end = pos + item_length;
 
                    while (sub_pos < pc_end) {
                        if (sub_pos + 4 > pc_end) break;
 
                        const uint8_t sub_type = data[sub_pos];
                        const uint16_t sub_length = read_uint16_be(data, sub_pos + 2);
                        sub_pos += 4;
 
                        if (sub_pos + sub_length > pc_end) break;
 
                        if (sub_type == 0x40) {  // Transfer Syntax
                            pc.transfer_syntax = read_uid(data, sub_pos, sub_length);
                        }
                        sub_pos += sub_length;
                    }
                    pcs_ac.push_back(std::move(pc));
                }
                break;
 
            case 0x50: {  // User Information
                auto ui_result = decode_user_info_item(
                    data.subspan(pos, item_length));
                if (ui_result.is_ok()) {
                    user_info = std::move(ui_result.value());
                }
                break;
            }
 
            default:
                // Skip unknown item types
                break;
        }
 
        pos += item_length;
    }
 
    return make_ok(std::make_tuple(
        std::move(application_context),
        std::move(pcs_rq),
        std::move(pcs_ac),
        std::move(user_info)));
}

References kcenon::pacs::network::presentation_context_rq::abstract_syntax, kcenon::pacs::network::application_context, kcenon::pacs::network::buffer_overflow, decode_user_info_item(), kcenon::pacs::network::presentation_context_ac::id, kcenon::pacs::network::presentation_context_rq::id, kcenon::pacs::network::malformed_pdu, read_uid(), read_uint16_be(), kcenon::pacs::network::presentation_context_ac::result, kcenon::pacs::network::presentation_context_ac::transfer_syntax, and kcenon::pacs::network::presentation_context_rq::transfer_syntaxes.

Referenced by decode_associate_ac(), and decode_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

pdu_length()

std::optional< size_t > kcenon::pacs::network::pdu_decoder::pdu_length ( std::span< const uint8_t > data )

staticnodiscard

Check if a complete PDU is available in the buffer.

Parameters

data	Input byte buffer

Returns

PDU length if complete PDU available, std::nullopt otherwise

Returns the total PDU length (header + data) if at least one complete PDU is present in the buffer. Useful for streaming protocols where data arrives in chunks.

Definition at line 140 of file pdu_decoder.cpp.

                                                                       {
    if (data.size() < PDU_HEADER_SIZE) {
        return std::nullopt;
    }
 
    const uint32_t length = read_uint32_be(data, 2);
    const size_t total = PDU_HEADER_SIZE + length;
 
    if (data.size() < total) {
        return std::nullopt;
    }
 
    return total;
}

References read_uint32_be().

Referenced by decode_associate_ac(), decode_associate_rq(), decode_p_data_tf(), kcenon::pacs::network::v2::dicom_association_handler::process_buffer(), and validate_pdu_header().

Here is the call graph for this function:

Here is the caller graph for this function:

peek_pdu_type()

std::optional< pdu_type > kcenon::pacs::network::pdu_decoder::peek_pdu_type ( std::span< const uint8_t > data )

staticnodiscard

Get the PDU type from buffer without full decoding.

Parameters

data	Input byte buffer (must have at least 1 byte)

Returns

PDU type if valid, std::nullopt if invalid or insufficient data

Definition at line 155 of file pdu_decoder.cpp.

                                                                            {
    if (data.empty()) {
        return std::nullopt;
    }
 
    switch (data[0]) {
        case 0x01: return pdu_type::associate_rq;
        case 0x02: return pdu_type::associate_ac;
        case 0x03: return pdu_type::associate_rj;
        case 0x04: return pdu_type::p_data_tf;
        case 0x05: return pdu_type::release_rq;
        case 0x06: return pdu_type::release_rp;
        case 0x07: return pdu_type::abort;
        default: return std::nullopt;
    }
}

References kcenon::pacs::network::abort, kcenon::pacs::network::associate_ac, kcenon::pacs::network::associate_rj, kcenon::pacs::network::associate_rq, kcenon::pacs::network::p_data_tf, kcenon::pacs::network::release_rp, and kcenon::pacs::network::release_rq.

Referenced by kcenon::pacs::network::v2::dicom_association_handler::process_buffer().

Here is the caller graph for this function:

read_ae_title()

std::string kcenon::pacs::network::pdu_decoder::read_ae_title ( std::span< const uint8_t > data, size_t offset )

staticnodiscardprivate

Read an AE Title (16 bytes, space-trimmed).

Definition at line 79 of file pdu_decoder.cpp.

                                                                               {
    std::string ae_title(reinterpret_cast<const char*>(data.data() + offset),
                         AE_TITLE_LENGTH);
    // Trim trailing spaces
    auto end = ae_title.find_last_not_of(' ');
    if (end != std::string::npos) {
        ae_title.resize(end + 1);
    } else if (ae_title.find_first_not_of(' ') == std::string::npos) {
        ae_title.clear();  // All spaces
    }
    return ae_title;
}

References kcenon::pacs::network::AE_TITLE_LENGTH.

Referenced by decode_associate_ac(), and decode_associate_rq().

Here is the caller graph for this function:

read_uid()

std::string kcenon::pacs::network::pdu_decoder::read_uid ( std::span< const uint8_t > data, size_t offset, size_t length )

staticnodiscardprivate

Read a UID string (trim trailing null/space padding).

Definition at line 92 of file pdu_decoder.cpp.

                                                  {
    std::string uid(reinterpret_cast<const char*>(data.data() + offset), length);
    // Trim trailing nulls and spaces
    while (!uid.empty() && (uid.back() == '\0' || uid.back() == ' ')) {
        uid.pop_back();
    }
    return uid;
}

References uid.

Referenced by decode_user_info_item(), and decode_variable_items().

Here is the caller graph for this function:

read_uint16_be()

uint16_t kcenon::pacs::network::pdu_decoder::read_uint16_be ( std::span< const uint8_t > data, size_t offset )

staticnodiscardprivate

Read a 16-bit unsigned integer in big-endian format.

Definition at line 66 of file pdu_decoder.cpp.

                                                                               {
    return static_cast<uint16_t>(
        (static_cast<uint16_t>(data[offset]) << 8) |
        static_cast<uint16_t>(data[offset + 1]));
}

Referenced by decode_associate_ac(), decode_associate_rq(), decode_user_info_item(), and decode_variable_items().

Here is the caller graph for this function:

read_uint32_be()

uint32_t kcenon::pacs::network::pdu_decoder::read_uint32_be ( std::span< const uint8_t > data, size_t offset )

staticnodiscardprivate

Read a 32-bit unsigned integer in big-endian format.

Definition at line 72 of file pdu_decoder.cpp.

                                                                               {
    return (static_cast<uint32_t>(data[offset]) << 24) |
           (static_cast<uint32_t>(data[offset + 1]) << 16) |
           (static_cast<uint32_t>(data[offset + 2]) << 8) |
           static_cast<uint32_t>(data[offset + 3]);
}

Referenced by decode_p_data_tf(), decode_user_info_item(), pdu_length(), and validate_pdu_header().

Here is the caller graph for this function:

validate_pdu_header()

DecodeResult< uint32_t > kcenon::pacs::network::pdu_decoder::validate_pdu_header ( std::span< const uint8_t > data, uint8_t expected_type = 0 )

staticnodiscardprivate

Validate PDU header and extract length.

Parameters

data	Input data
expected_type	Expected PDU type (0 for any)

Returns

Pair of (is_valid, pdu_length) or error

Definition at line 102 of file pdu_decoder.cpp.

                                                        {
 
    if (data.size() < PDU_HEADER_SIZE) {
        return make_error<uint32_t>(pdu_decode_error::incomplete_header);
    }
 
    if (expected_type != 0 && data[0] != expected_type) {
        return make_error<uint32_t>(pdu_decode_error::invalid_pdu_type,
            "Expected type " + std::to_string(expected_type) +
            ", got " + std::to_string(data[0]));
    }
 
    const uint32_t pdu_length = read_uint32_be(data, 2);
 
    // Reject unreasonably large PDUs to prevent memory exhaustion attacks
    constexpr uint32_t MAX_PDU_LENGTH = 16 * 1024 * 1024; // 16 MB
    if (pdu_length > MAX_PDU_LENGTH) {
        return make_error<uint32_t>(pdu_decode_error::malformed_pdu,
            "PDU length " + std::to_string(pdu_length) +
            " exceeds maximum allowed " + std::to_string(MAX_PDU_LENGTH));
    }
 
    const size_t total_length = PDU_HEADER_SIZE + pdu_length;
 
    if (data.size() < total_length) {
        return make_error<uint32_t>(pdu_decode_error::incomplete_pdu,
            "Need " + std::to_string(total_length) +
            " bytes, have " + std::to_string(data.size()));
    }
 
    return make_ok(pdu_length);
}

References kcenon::pacs::network::incomplete_header, kcenon::pacs::network::incomplete_pdu, kcenon::pacs::network::invalid_pdu_type, kcenon::pacs::network::malformed_pdu, pdu_length(), and read_uint32_be().

Referenced by decode_abort(), decode_associate_ac(), decode_associate_rj(), decode_associate_rq(), decode_p_data_tf(), decode_release_rp(), and decode_release_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• include/kcenon/pacs/network/pdu_decoder.h
• src/network/pdu_decoder.cpp