pdu_types.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_TYPES_HPP
#define PACS_NETWORK_PDU_TYPES_HPP
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace kcenon::pacs::network {
 
enum class pdu_type : uint8_t {
    associate_rq = 0x01,  
    associate_ac = 0x02,  
    associate_rj = 0x03,  
    p_data_tf = 0x04,     
    release_rq = 0x05,    
    release_rp = 0x06,    
    abort = 0x07,         
};
 
enum class item_type : uint8_t {
    application_context = 0x10,     
    presentation_context_rq = 0x20, 
    presentation_context_ac = 0x21, 
    user_information = 0x50,        
    abstract_syntax = 0x30,         
    transfer_syntax = 0x40,         
    maximum_length = 0x51,          
    implementation_class_uid = 0x52,    
    implementation_version_name = 0x55, 
    async_operations_window = 0x53,     
    scp_scu_role_selection = 0x54,      
    sop_class_extended_negotiation = 0x56,      
    sop_class_common_extended_negotiation = 0x57, 
    user_identity_rq = 0x58,        
    user_identity_ac = 0x59,        
};
 
enum class presentation_context_result : uint8_t {
    acceptance = 0,                   
    user_rejection = 1,               
    no_reason = 2,                    
    abstract_syntax_not_supported = 3,
    transfer_syntaxes_not_supported = 4, 
};
 
enum class abort_source : uint8_t {
    service_user = 0,       
    reserved = 1,           
    service_provider = 2,   
};
 
enum class abort_reason : uint8_t {
    not_specified = 0,          
    unrecognized_pdu = 1,       
    unexpected_pdu = 2,         
    reserved = 3,               
    unrecognized_pdu_parameter = 4, 
    unexpected_pdu_parameter = 5,   
    invalid_pdu_parameter = 6,      
};
 
enum class reject_result : uint8_t {
    rejected_permanent = 1,  
    rejected_transient = 2,  
};
 
enum class reject_source : uint8_t {
    service_user = 1,                   
    service_provider_acse = 2,          
    service_provider_presentation = 3,  
};
 
enum class reject_reason_user : uint8_t {
    no_reason = 1,           
    application_context_not_supported = 2, 
    calling_ae_not_recognized = 3, 
    called_ae_not_recognized = 7,  
};
 
enum class reject_reason_provider_acse : uint8_t {
    no_reason = 1,           
    protocol_version_not_supported = 2, 
};
 
enum class reject_reason_provider_presentation : uint8_t {
    temporary_congestion = 1, 
    local_limit_exceeded = 2, 
};
 
struct presentation_data_value {
    uint8_t context_id;          
    bool is_command;             
    bool is_last;                
    std::vector<uint8_t> data;   
 
    presentation_data_value() = default;
    presentation_data_value(uint8_t id, bool command, bool last, std::vector<uint8_t> d)
        : context_id(id), is_command(command), is_last(last), data(std::move(d)) {}
};
 
struct presentation_context_rq {
    uint8_t id;                           
    std::string abstract_syntax;          
    std::vector<std::string> transfer_syntaxes; 
 
    presentation_context_rq() : id(0) {}
    presentation_context_rq(uint8_t context_id, std::string abs_syntax,
                           std::vector<std::string> ts_list)
        : id(context_id)
        , abstract_syntax(std::move(abs_syntax))
        , transfer_syntaxes(std::move(ts_list)) {}
};
 
struct presentation_context_ac {
    uint8_t id;                              
    presentation_context_result result;       
    std::string transfer_syntax;              
 
    presentation_context_ac()
        : id(0), result(presentation_context_result::acceptance) {}
    presentation_context_ac(uint8_t context_id, presentation_context_result res,
                           std::string ts = "")
        : id(context_id), result(res), transfer_syntax(std::move(ts)) {}
};
 
struct scp_scu_role_selection {
    std::string sop_class_uid;  
    bool scu_role;              
    bool scp_role;              
 
    scp_scu_role_selection() : scu_role(false), scp_role(false) {}
    scp_scu_role_selection(std::string uid, bool scu, bool scp)
        : sop_class_uid(std::move(uid)), scu_role(scu), scp_role(scp) {}
};
 
struct user_information {
    uint32_t max_pdu_length;              
    std::string implementation_class_uid; 
    std::string implementation_version_name; 
    std::vector<scp_scu_role_selection> role_selections; 
 
    user_information() : max_pdu_length(0) {}
};
 
struct associate_rq {
    std::string called_ae_title;                  
    std::string calling_ae_title;                 
    std::string application_context;              
    std::vector<presentation_context_rq> presentation_contexts; 
    user_information user_info;                   
 
    associate_rq() = default;
};
 
struct associate_ac {
    std::string called_ae_title;                  
    std::string calling_ae_title;                 
    std::string application_context;              
    std::vector<presentation_context_ac> presentation_contexts; 
    user_information user_info;                   
 
    associate_ac() = default;
};
 
struct associate_rj {
    reject_result result;    
    uint8_t source;          
    uint8_t reason;          
 
    associate_rj()
        : result(reject_result::rejected_permanent), source(0), reason(0) {}
    associate_rj(reject_result res, uint8_t src, uint8_t rsn)
        : result(res), source(src), reason(rsn) {}
};
 
 
[[nodiscard]] constexpr const char* to_string(pdu_type type) noexcept {
    switch (type) {
        case pdu_type::associate_rq: return "A-ASSOCIATE-RQ";
        case pdu_type::associate_ac: return "A-ASSOCIATE-AC";
        case pdu_type::associate_rj: return "A-ASSOCIATE-RJ";
        case pdu_type::p_data_tf: return "P-DATA-TF";
        case pdu_type::release_rq: return "A-RELEASE-RQ";
        case pdu_type::release_rp: return "A-RELEASE-RP";
        case pdu_type::abort: return "A-ABORT";
        default: return "UNKNOWN";
    }
}
 
 
 
constexpr const char* DICOM_APPLICATION_CONTEXT = "1.2.840.10008.3.1.1.1";
 
constexpr uint16_t DICOM_PROTOCOL_VERSION = 0x0001;
 
constexpr size_t AE_TITLE_LENGTH = 16;
 
constexpr uint32_t DEFAULT_MAX_PDU_LENGTH = 16384;
 
constexpr uint32_t UNLIMITED_MAX_PDU_LENGTH = 0;
 
 
}  // namespace kcenon::pacs::network
 
#endif  // PACS_NETWORK_PDU_TYPES_HPP