pdu_decoder.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#ifndef PACS_NETWORK_PDU_DECODER_HPP
#define PACS_NETWORK_PDU_DECODER_HPP
 
#include "pdu_types.h"
#include "kcenon/pacs/core/result.h"
 
#include <cstdint>
#include <optional>
#include <span>
#include <variant>
#include <vector>
 
namespace kcenon::pacs::network {
 
struct release_rq_pdu {};  
struct release_rp_pdu {};  
 
struct abort_pdu {
    abort_source source;   
    abort_reason reason;   
 
    abort_pdu() : source(abort_source::service_user),
                  reason(abort_reason::not_specified) {}
    abort_pdu(abort_source src, abort_reason rsn)
        : source(src), reason(rsn) {}
};
 
struct p_data_tf_pdu {
    std::vector<presentation_data_value> pdvs;  
 
    p_data_tf_pdu() = default;
    explicit p_data_tf_pdu(std::vector<presentation_data_value> values)
        : pdvs(std::move(values)) {}
};
 
using pdu = std::variant<
    associate_rq,
    associate_ac,
    associate_rj,
    p_data_tf_pdu,
    release_rq_pdu,
    release_rp_pdu,
    abort_pdu
>;
 
enum class pdu_decode_error : int {
    success = 0,
    incomplete_header = 1,      
    incomplete_pdu = 2,         
    invalid_pdu_type = 3,       
    invalid_protocol_version = 4, 
    invalid_item_type = 5,      
    malformed_pdu = 6,          
    buffer_overflow = 7,        
};
 
[[nodiscard]] constexpr const char* to_string(pdu_decode_error err) noexcept {
    switch (err) {
        case pdu_decode_error::success: return "Success";
        case pdu_decode_error::incomplete_header: return "Incomplete PDU header";
        case pdu_decode_error::incomplete_pdu: return "Incomplete PDU data";
        case pdu_decode_error::invalid_pdu_type: return "Invalid PDU type";
        case pdu_decode_error::invalid_protocol_version: return "Invalid protocol version";
        case pdu_decode_error::invalid_item_type: return "Invalid item type";
        case pdu_decode_error::malformed_pdu: return "Malformed PDU";
        case pdu_decode_error::buffer_overflow: return "Buffer overflow";
        default: return "Unknown error";
    }
}
 
template<typename T>
using DecodeResult = kcenon::pacs::Result<T>;
 
class pdu_decoder {
public:
 
    [[nodiscard]] static DecodeResult<pdu> decode(std::span<const uint8_t> data);
 
    [[nodiscard]] static std::optional<size_t> pdu_length(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static std::optional<pdu_type> peek_pdu_type(
        std::span<const uint8_t> data);
 
 
 
    [[nodiscard]] static DecodeResult<associate_rq> decode_associate_rq(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<associate_ac> decode_associate_ac(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<associate_rj> decode_associate_rj(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<p_data_tf_pdu> decode_p_data_tf(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<release_rq_pdu> decode_release_rq(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<release_rp_pdu> decode_release_rp(
        std::span<const uint8_t> data);
 
    [[nodiscard]] static DecodeResult<abort_pdu> decode_abort(
        std::span<const uint8_t> data);
 
 
private:
 
    [[nodiscard]] static uint16_t read_uint16_be(
        std::span<const uint8_t> data, size_t offset);
 
    [[nodiscard]] static uint32_t read_uint32_be(
        std::span<const uint8_t> data, size_t offset);
 
    [[nodiscard]] static std::string read_ae_title(
        std::span<const uint8_t> data, size_t offset);
 
    [[nodiscard]] static std::string read_uid(
        std::span<const uint8_t> data, size_t offset, size_t length);
 
    [[nodiscard]] static DecodeResult<uint32_t> validate_pdu_header(
        std::span<const uint8_t> data, uint8_t expected_type = 0);
 
    [[nodiscard]] static DecodeResult<std::tuple<
        std::string,                           // application_context
        std::vector<presentation_context_rq>,  // presentation_contexts_rq
        std::vector<presentation_context_ac>,  // presentation_contexts_ac
        user_information                       // user_info
    >> decode_variable_items(std::span<const uint8_t> data, bool is_rq);
 
    [[nodiscard]] static DecodeResult<user_information> decode_user_info_item(
        std::span<const uint8_t> data);
 
};
 
}  // namespace kcenon::pacs::network
 
#endif  // PACS_NETWORK_PDU_DECODER_HPP