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 178 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 300 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 664 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_err()) {
            return var_result.error();
        }
 
        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));
}

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 245 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 606 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_err()) {
            return var_result.error();
        }
 
        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));
}

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 321 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");
        }
 
        // Subtract first to avoid pos + pdv_item_length wrapping on 32-bit
        // platforms when pdv_item_length is attacker-controlled.
        if (pdv_item_length > pdu_end - pos) {
            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 285 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 270 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 538 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. Compute in a
                    // wider type to avoid uint16_t overflow when uid_length is
                    // odd and near its maximum.
                    const size_t padded_uid_length =
                        static_cast<size_t>(uid_length) +
                        (static_cast<size_t>(uid_length) % 2);
                    // Bounds check: UID length field (2) + padded UID bytes +
                    // SCU role (1) + SCP role (1) must fit inside sub_length.
                    if (padded_uid_length + 4 <= 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 393 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) {
                    // Presentation Context RQ item body is:
                    //   context_id (1) + reserved (3) + sub-items
                    // Require at least the 4-byte fixed header before reading.
                    if (item_length < 4) {
                        return make_error<std::tuple<std::string,
                            std::vector<presentation_context_rq>,
                            std::vector<presentation_context_ac>,
                            user_information>>(pdu_decode_error::malformed_pdu,
                                "Presentation Context RQ item too small");
                    }
 
                    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 item body is:
                    //   context_id (1) + reserved (1) + result (1) + reserved (1)
                    //   + sub-items
                    // Require at least the 4-byte fixed header before reading.
                    if (item_length < 4) {
                        return make_error<std::tuple<std::string,
                            std::vector<presentation_context_rq>,
                            std::vector<presentation_context_ac>,
                            user_information>>(pdu_decode_error::malformed_pdu,
                                "Presentation Context AC item too small");
                    }
 
                    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 146 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 161 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.

                                                                               {
    if (offset + AE_TITLE_LENGTH > data.size()) {
        return {};
    }
    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 95 of file pdu_decoder.cpp.

                                                  {
    if (offset + length > data.size()) {
        return {};
    }
    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 108 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

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ decode()

◆ decode_abort()

◆ decode_associate_ac()

◆ decode_associate_rj()

◆ decode_associate_rq()

◆ decode_p_data_tf()

◆ decode_release_rp()

◆ decode_release_rq()

◆ decode_user_info_item()

◆ decode_variable_items()

◆ pdu_length()

◆ peek_pdu_type()

◆ read_ae_title()

◆ read_uid()

◆ read_uint16_be()

◆ read_uint32_be()

◆ validate_pdu_header()