Bridges network_system sessions with DICOM protocol handling. More...

#include <dicom_association_handler.h>

Inheritance diagram for kcenon::pacs::network::v2::dicom_association_handler:

Collaboration diagram for kcenon::pacs::network::v2::dicom_association_handler:

Public Types
using	session_ptr = std::shared_ptr<kcenon::network::interfaces::i_session>

using	service_map = std::map<std::string, services::scp_service*>

using	clock = std::chrono::steady_clock

using	time_point = clock::time_point

using	duration = std::chrono::milliseconds

Public Member Functions
	dicom_association_handler (session_ptr session, const server_config &config, const service_map &services)
	Construct a handler for a network session.

	~dicom_association_handler ()
	Destructor (stops handler if still running).

	dicom_association_handler (const dicom_association_handler &)=delete

dicom_association_handler &	operator= (const dicom_association_handler &)=delete

	dicom_association_handler (dicom_association_handler &&)=delete

dicom_association_handler &	operator= (dicom_association_handler &&)=delete

void	start ()
	Start processing the session.

void	stop (bool graceful=false)
	Stop the handler and close the session.

void	feed_data (const std::vector< uint8_t > &data)
	Feed received data to the handler.

void	handle_disconnect ()
	Handle session disconnection.

void	handle_error (std::error_code ec)
	Handle session error.

handler_state	state () const noexcept
	Get current handler state.

bool	is_established () const noexcept
	Check if the association is established.

bool	is_closed () const noexcept
	Check if the handler is closed.

std::string	session_id () const
	Get the session identifier.

std::string	calling_ae () const
	Get the calling AE title.

std::string	called_ae () const
	Get the called AE title.

Result< std::reference_wrapper< association > >	get_association ()
	Get the underlying association object.

Result< std::reference_wrapper< const association > >	get_association () const

time_point	last_activity () const noexcept
	Get time of last activity.

void	set_established_callback (association_established_callback callback)
	Set callback for association established event.

void	set_closed_callback (association_closed_callback callback)
	Set callback for association closed event.

void	set_error_callback (handler_error_callback callback)
	Set callback for error events.

uint64_t	pdus_received () const noexcept
	Get number of PDUs received.

uint64_t	pdus_sent () const noexcept
	Get number of PDUs sent.

uint64_t	messages_processed () const noexcept
	Get number of DIMSE messages processed.

void	set_access_control (std::shared_ptr< security::access_control_manager > acm)
	Set the access control manager for RBAC.

void	set_access_control_enabled (bool enabled)
	Enable or disable access control enforcement.

Static Public Attributes
static constexpr size_t	pdu_header_size = 6
	PDU header size (type + reserved + length)

static constexpr size_t	max_pdu_size = 64 * 1024 * 1024
	Maximum PDU size for safety checks.

Private Member Functions
void	on_data_received (const std::vector< uint8_t > &data)
	Handle data received from session.

void	on_disconnected (const std::string &session_id)
	Handle session disconnection.

void	on_error (std::error_code ec)
	Handle session error.

void	process_buffer ()
	Process accumulated buffer for complete PDUs.

void	process_pdu (const integration::pdu_data &pdu)
	Process a complete PDU.

void	handle_associate_rq (const std::vector< uint8_t > &payload)
	Handle A-ASSOCIATE-RQ PDU.

void	handle_p_data_tf (const std::vector< uint8_t > &payload)
	Handle P-DATA-TF PDU.

void	handle_release_rq ()
	Handle A-RELEASE-RQ PDU.

void	handle_abort (const std::vector< uint8_t > &payload)
	Handle A-ABORT PDU.

void	send_associate_ac ()
	Send A-ASSOCIATE-AC response.

void	send_associate_rj (reject_result result, uint8_t source, uint8_t reason)
	Send A-ASSOCIATE-RJ response.

void	send_p_data_tf (const std::vector< uint8_t > &payload)
	Send P-DATA-TF PDU.

void	send_release_rp ()
	Send A-RELEASE-RP response.

void	send_abort (abort_source source, abort_reason reason)
	Send A-ABORT PDU.

void	send_pdu (pdu_type type, const std::vector< uint8_t > &payload)
	Send raw PDU data.

Result< std::monostate >	dispatch_to_service (uint8_t context_id, const dimse::dimse_message &msg)
	Dispatch DIMSE message to appropriate service.

services::scp_service *	find_service (const std::string &sop_class_uid) const
	Find service for SOP Class UID.

void	transition_to (handler_state new_state)
	Transition to new state.

void	touch ()
	Update last activity timestamp.

void	report_error (const std::string &error)
	Report error through callback.

void	close_handler (bool graceful)
	Close and cleanup.

Private Attributes
session_ptr	session_
	Network session.

server_config	config_
	Server configuration.

service_map	services_
	Service registry (non-owning pointers)

association	association_
	DICOM association.

std::atomic< handler_state >	state_ {handler_state::idle}
	Current handler state.

std::vector< uint8_t >	receive_buffer_
	PDU receive buffer.

uint32_t	expected_pdu_length_ {0}
	Expected PDU length (0 if waiting for header)

pdu_type	current_pdu_type_ {pdu_type::abort}
	Current PDU type being received.

time_point	last_activity_
	Last activity timestamp.

std::atomic< uint64_t >	pdus_received_ {0}
	Statistics.

std::atomic< uint64_t >	pdus_sent_ {0}

std::atomic< uint64_t >	messages_processed_ {0}

association_established_callback	established_callback_
	Callbacks.

association_closed_callback	closed_callback_

handler_error_callback	error_callback_

std::mutex	mutex_
	Thread safety.

std::mutex	callback_mutex_

std::shared_ptr< security::access_control_manager >	access_control_
	Access control manager for RBAC.

std::optional< security::user_context >	user_context_
	User context for this association (set after A-ASSOCIATE negotiation)

bool	access_control_enabled_ {false}
	Whether access control is enabled.

Detailed Description

Bridges network_system sessions with DICOM protocol handling.

This class wraps a network_system messaging_session to provide DICOM-specific behavior including:

PDU Framing: Handles the 6-byte PDU header parsing and accumulation of fragmented PDUs from the TCP stream.
State Machine: Manages DICOM association states (idle, awaiting, established, releasing, closed).
Service Dispatching: Routes DIMSE messages to registered SCP services.
Association Negotiation: Handles A-ASSOCIATE-RQ/AC/RJ PDU processing.

Thread Safety

All public methods are thread-safe. The handler can be accessed from multiple threads (e.g., network I/O thread and service threads).

Lifecycle

Construct with a session and server configuration
Call start() to begin processing incoming PDUs
Handle association negotiation automatically
DIMSE messages are dispatched to registered services
Call stop() or let graceful release complete

Definition at line 148 of file dicom_association_handler.h.

Member Typedef Documentation

◆ clock

using kcenon::pacs::network::v2::dicom_association_handler::clock = std::chrono::steady_clock

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 157 of file dicom_association_handler.h.

◆ duration

using kcenon::pacs::network::v2::dicom_association_handler::duration = std::chrono::milliseconds

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 159 of file dicom_association_handler.h.

◆ service_map

using kcenon::pacs::network::v2::dicom_association_handler::service_map = std::map<std::string, services::scp_service*>

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 156 of file dicom_association_handler.h.

◆ session_ptr

using kcenon::pacs::network::v2::dicom_association_handler::session_ptr = std::shared_ptr<kcenon::network::interfaces::i_session>

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 155 of file dicom_association_handler.h.

◆ time_point

using kcenon::pacs::network::v2::dicom_association_handler::time_point = clock::time_point

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 158 of file dicom_association_handler.h.

Constructor & Destructor Documentation

◆ dicom_association_handler() [1/3]

kcenon::pacs::network::v2::dicom_association_handler::dicom_association_handler	(	session_ptr	session,
		const server_config &	config,
		const service_map &	services )

Construct a handler for a network session.

Parameters

session	The network_system session to wrap
config	Server configuration for association negotiation
services	Map from SOP Class UID to service implementation

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 37 of file dicom_association_handler.cpp.

    : session_(std::move(session))
    , config_(config)
    , services_(services)
    , last_activity_(clock::now()) {
}

◆ ~dicom_association_handler()

kcenon::pacs::network::v2::dicom_association_handler::~dicom_association_handler ( )

Destructor (stops handler if still running).

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 47 of file dicom_association_handler.cpp.

                                                      {
    try {
        // Ensure we're stopped
        if (!is_closed()) {
            stop(false);  // Force abort if still running
        }
    } catch (...) {
        // Suppress exceptions in destructor to prevent std::terminate
    }
}

References is_closed(), and stop().

Here is the call graph for this function:

◆ dicom_association_handler() [2/3]

kcenon::pacs::network::v2::dicom_association_handler::dicom_association_handler ( const dicom_association_handler & )

delete

◆ dicom_association_handler() [3/3]

kcenon::pacs::network::v2::dicom_association_handler::dicom_association_handler ( dicom_association_handler && )

delete

Member Function Documentation

◆ called_ae()

std::string kcenon::pacs::network::v2::dicom_association_handler::called_ae ( ) const

nodiscard

Get the called AE title.

Returns: Called AE title if negotiated, empty otherwise

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 132 of file dicom_association_handler.cpp.

                                                     {
    std::lock_guard<std::mutex> lock(mutex_);
    return std::string(association_.called_ae());
}

References association_, kcenon::pacs::network::association::called_ae(), and mutex_.

Here is the call graph for this function:

◆ calling_ae()

std::string kcenon::pacs::network::v2::dicom_association_handler::calling_ae ( ) const

nodiscard

Get the calling AE title.

Returns: Calling AE title if negotiated, empty otherwise

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 127 of file dicom_association_handler.cpp.

                                                      {
    std::lock_guard<std::mutex> lock(mutex_);
    return std::string(association_.calling_ae());
}

References association_, kcenon::pacs::network::association::calling_ae(), and mutex_.

Here is the call graph for this function:

◆ close_handler()

void kcenon::pacs::network::v2::dicom_association_handler::close_handler ( bool graceful )

private

Close and cleanup.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 769 of file dicom_association_handler.cpp.

                                                           {
    handler_state expected = state_.load();
    if (expected == handler_state::closed) {
        return;  // Already closed
    }
 
    transition_to(handler_state::closed);
 
#ifdef PACS_WITH_NETWORK_SYSTEM
    // Close the session
    try {
        std::lock_guard<std::mutex> lock(mutex_);
        if (session_) {
            session_->close();
        }
    } catch (...) {
        // Suppress exceptions during session cleanup
    }
#endif
 
    // Notify closed callback
    try {
        std::lock_guard<std::mutex> cb_lock(callback_mutex_);
        if (closed_callback_) {
            closed_callback_(session_id(), graceful);
        }
    } catch (...) {
        // Suppress exceptions during callback invocation
    }
}

References callback_mutex_, kcenon::pacs::network::v2::closed, closed_callback_, mutex_, session_, session_id(), state_, and transition_to().

Referenced by handle_abort(), handle_associate_rq(), handle_p_data_tf(), handle_release_rq(), on_disconnected(), on_error(), process_buffer(), process_pdu(), and stop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dispatch_to_service()

Result< std::monostate > kcenon::pacs::network::v2::dicom_association_handler::dispatch_to_service	(	uint8_t	context_id,
		const dimse::dimse_message &	msg )

private

Dispatch DIMSE message to appropriate service.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 657 of file dicom_association_handler.cpp.

                                   {
 
    // Find the abstract syntax for this context
    std::string abstract_syntax;
    for (const auto& ctx : association_.accepted_contexts()) {
        if (ctx.id == context_id) {
            abstract_syntax = ctx.abstract_syntax;
            break;
        }
    }
 
    if (abstract_syntax.empty()) {
        return error_info("Unknown presentation context ID");
    }
 
    // Find service for this SOP class
    auto* service = find_service(abstract_syntax);
    if (!service) {
        return error_info("No service registered for SOP Class: " + abstract_syntax);
    }
 
    // Perform access control check if enabled
    if (access_control_enabled_ && access_control_ && !user_context_) {
        return error_info("Access denied: unregistered AE title");
    }
    if (access_control_enabled_ && access_control_ && user_context_) {
        // Map DIMSE command to DICOM operation
        security::DicomOperation op = security::DicomOperation::CEcho;
        switch (msg.command()) {
            case dimse::command_field::c_store_rq:
                op = security::DicomOperation::CStore;
                break;
            case dimse::command_field::c_find_rq:
                op = security::DicomOperation::CFind;
                break;
            case dimse::command_field::c_move_rq:
                op = security::DicomOperation::CMove;
                break;
            case dimse::command_field::c_get_rq:
                op = security::DicomOperation::CGet;
                break;
            case dimse::command_field::c_echo_rq:
                op = security::DicomOperation::CEcho;
                break;
            case dimse::command_field::n_create_rq:
                op = security::DicomOperation::NCreate;
                break;
            case dimse::command_field::n_set_rq:
                op = security::DicomOperation::NSet;
                break;
            case dimse::command_field::n_get_rq:
                op = security::DicomOperation::NGet;
                break;
            case dimse::command_field::n_delete_rq:
                op = security::DicomOperation::NDelete;
                break;
            case dimse::command_field::n_action_rq:
                op = security::DicomOperation::NAction;
                break;
            case dimse::command_field::n_event_report_rq:
                op = security::DicomOperation::NEventReport;
                break;
            default:
                // Response messages don't need access control
                break;
        }
 
        // Check permission
        auto check_result = access_control_->check_dicom_operation(*user_context_, op);
        if (!check_result) {
            return error_info("Access denied: " + check_result.reason);
        }
    }
 
    // Dispatch to service
    return service->handle_message(association_, context_id, msg);
}

Referenced by handle_p_data_tf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ feed_data()

void kcenon::pacs::network::v2::dicom_association_handler::feed_data ( const std::vector< uint8_t > & data )

Feed received data to the handler.

Called by the server when data arrives for this handler's session. This replaces the session-level receive callback pattern used with messaging_session. In the i_protocol_server architecture, the server receives data via its receive callback and forwards it here.

Parameters

data	The received data bytes

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 216 of file dicom_association_handler.cpp.

                                                                        {
    on_data_received(data);
}

References on_data_received().

Here is the call graph for this function:

◆ find_service()

services::scp_service * kcenon::pacs::network::v2::dicom_association_handler::find_service ( const std::string & sop_class_uid ) const

nodiscardprivate

Find service for SOP Class UID.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 737 of file dicom_association_handler.cpp.

                                          {
    auto it = services_.find(sop_class_uid);
    if (it != services_.end()) {
        return it->second;
    }
    return nullptr;
}

References services_.

Referenced by dispatch_to_service().

Here is the caller graph for this function:

◆ get_association() [1/2]

Result< std::reference_wrapper< association > > kcenon::pacs::network::v2::dicom_association_handler::get_association ( )

nodiscard

Get the underlying association object.

Returns: Result containing reference to the association or error if not established

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 137 of file dicom_association_handler.cpp.

                                                                                     {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!is_established()) {
        return kcenon::pacs::error_info{kcenon::pacs::error_codes::invalid_association_state,
            "Association not established", "network"};
    }
    return std::ref(association_);
}

References association_, kcenon::pacs::error_codes::invalid_association_state, is_established(), and mutex_.

Here is the call graph for this function:

◆ get_association() [2/2]

Result< std::reference_wrapper< const association > > kcenon::pacs::network::v2::dicom_association_handler::get_association ( ) const

nodiscard

Definition at line 146 of file dicom_association_handler.cpp.

                                                                                                 {
    std::lock_guard<std::mutex> lock(mutex_);
    if (!is_established()) {
        return kcenon::pacs::error_info{kcenon::pacs::error_codes::invalid_association_state,
            "Association not established", "network"};
    }
    return std::cref(association_);
}

References association_, kcenon::pacs::error_codes::invalid_association_state, is_established(), and mutex_.

Here is the call graph for this function:

◆ handle_abort()

void kcenon::pacs::network::v2::dicom_association_handler::handle_abort ( const std::vector< uint8_t > & payload )

private

Handle A-ABORT PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 588 of file dicom_association_handler.cpp.

                                                                              {
    // Parse abort source and reason if present
    abort_source source = abort_source::service_user;
    abort_reason reason = abort_reason::not_specified;
 
    if (payload.size() >= 4) {
        // Reserved, Reserved, Source, Reason
        source = static_cast<abort_source>(payload[2]);
        reason = static_cast<abort_reason>(payload[3]);
    }
 
    association_.process_abort(source, reason);
 
    // Close immediately
    close_handler(false);
}

References association_, close_handler(), kcenon::pacs::network::not_specified, kcenon::pacs::network::association::process_abort(), and kcenon::pacs::network::service_user.

Referenced by process_pdu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_associate_rq()

void kcenon::pacs::network::v2::dicom_association_handler::handle_associate_rq ( const std::vector< uint8_t > & payload )

private

Handle A-ASSOCIATE-RQ PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 368 of file dicom_association_handler.cpp.

                                                                                     {
    // Build full PDU for decoder (add header back)
    std::vector<uint8_t> full_pdu;
    full_pdu.reserve(pdu_header_size + payload.size());
 
    // PDU type
    full_pdu.push_back(static_cast<uint8_t>(pdu_type::associate_rq));
    // Reserved
    full_pdu.push_back(0x00);
    // Length (big-endian)
    uint32_t length = static_cast<uint32_t>(payload.size());
    full_pdu.push_back(static_cast<uint8_t>((length >> 24) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>((length >> 16) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>((length >> 8) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>(length & 0xFF));
    // Payload
    full_pdu.insert(full_pdu.end(), payload.begin(), payload.end());
 
    // Decode the A-ASSOCIATE-RQ
    auto result = pdu_decoder::decode_associate_rq(full_pdu);
    if (!result.is_ok()) {
        report_error("Failed to decode A-ASSOCIATE-RQ");
        send_associate_rj(reject_result::rejected_permanent,
                          static_cast<uint8_t>(reject_source::service_provider_acse),
                          static_cast<uint8_t>(reject_reason_provider_acse::no_reason));
        close_handler(false);
        return;
    }
 
    const associate_rq& rq = result.value();
 
    // Validate called AE title
    if (rq.called_ae_title != config_.ae_title) {
        report_error("Called AE title mismatch: expected '" + config_.ae_title +
                     "', got '" + rq.called_ae_title + "'");
        send_associate_rj(reject_result::rejected_permanent,
                          static_cast<uint8_t>(reject_source::service_user),
                          static_cast<uint8_t>(reject_reason_user::called_ae_not_recognized));
        close_handler(false);
        return;
    }
 
    // Validate calling AE title against whitelist
    if (!config_.ae_whitelist.empty() && !config_.accept_unknown_calling_ae) {
        bool found = false;
        for (const auto& allowed : config_.ae_whitelist) {
            if (allowed == rq.calling_ae_title) {
                found = true;
                break;
            }
        }
        if (!found) {
            report_error("Calling AE title not in whitelist: " + rq.calling_ae_title);
            send_associate_rj(reject_result::rejected_permanent,
                              static_cast<uint8_t>(reject_source::service_user),
                              static_cast<uint8_t>(reject_reason_user::calling_ae_not_recognized));
            close_handler(false);
            return;
        }
    }
 
    // Build SCP config for association negotiation
    scp_config scp_cfg;
    scp_cfg.ae_title = config_.ae_title;
    scp_cfg.max_pdu_length = config_.max_pdu_size;
    scp_cfg.implementation_class_uid = config_.implementation_class_uid;
    scp_cfg.implementation_version_name = config_.implementation_version_name;
 
    // Collect supported abstract syntaxes from services
    for (const auto& [uid, _] : services_) {
        scp_cfg.supported_abstract_syntaxes.push_back(uid);
    }
 
    // Accept compressed and uncompressed transfer syntaxes
    scp_cfg.supported_transfer_syntaxes = {
        "1.2.840.10008.1.2.4.201", // HTJ2K Lossless Only
        "1.2.840.10008.1.2.4.202", // HTJ2K RPCL Lossless Only
        "1.2.840.10008.1.2.4.203", // HTJ2K (Lossless or Lossy)
        "1.2.840.10008.1.2.4.90",  // JPEG 2000 Lossless
        "1.2.840.10008.1.2.4.91",  // JPEG 2000 Lossy
        "1.2.840.10008.1.2.4.80",  // JPEG-LS Lossless
        "1.2.840.10008.1.2.4.81",  // JPEG-LS Near-Lossless
        "1.2.840.10008.1.2.4.70",  // JPEG Lossless
        "1.2.840.10008.1.2.4.50",  // JPEG Baseline
        "1.2.840.10008.1.2.5",     // RLE Lossless
        "1.2.840.10008.1.2.1",     // Explicit VR Little Endian
        "1.2.840.10008.1.2",       // Implicit VR Little Endian
    };
 
    // Perform association negotiation
    association_ = association::accept(rq, scp_cfg);
 
    // Check if any presentation contexts were accepted
    if (association_.accepted_contexts().empty()) {
        report_error("No presentation contexts accepted");
        send_associate_rj(reject_result::rejected_permanent,
                          static_cast<uint8_t>(reject_source::service_user),
                          static_cast<uint8_t>(reject_reason_user::no_reason));
        close_handler(false);
        return;
    }
 
    // Send A-ASSOCIATE-AC
    send_associate_ac();
 
    // Transition to established state
    association_.set_state(association_state::established);
    transition_to(handler_state::established);
 
    // Set up user context for access control
    if (access_control_enabled_ && access_control_) {
        user_context_ = access_control_->get_context_for_ae(
            rq.calling_ae_title, session_id());
    }
 
    // Notify callback
    {
        std::lock_guard<std::mutex> cb_lock(callback_mutex_);
        if (established_callback_) {
            established_callback_(session_id(),
                                  rq.calling_ae_title,
                                  rq.called_ae_title);
        }
    }
}

Referenced by process_pdu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_disconnect()

void kcenon::pacs::network::v2::dicom_association_handler::handle_disconnect ( )

Handle session disconnection.

Called by the server when the session disconnects.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 220 of file dicom_association_handler.cpp.

                                                  {
    on_disconnected(session_id());
}

References on_disconnected(), and session_id().

Here is the call graph for this function:

◆ handle_error()

void kcenon::pacs::network::v2::dicom_association_handler::handle_error ( std::error_code ec )

Handle session error.

Called by the server when an error occurs on the session.

Parameters

ec	The error code

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 224 of file dicom_association_handler.cpp.

                                                             {
    on_error(ec);
}

References on_error().

Here is the call graph for this function:

◆ handle_p_data_tf()

void kcenon::pacs::network::v2::dicom_association_handler::handle_p_data_tf ( const std::vector< uint8_t > & payload )

private

Handle P-DATA-TF PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 494 of file dicom_association_handler.cpp.

                                                                                  {
    // Build full PDU for decoder
    std::vector<uint8_t> full_pdu;
    full_pdu.reserve(pdu_header_size + payload.size());
 
    full_pdu.push_back(static_cast<uint8_t>(pdu_type::p_data_tf));
    full_pdu.push_back(0x00);
    uint32_t length = static_cast<uint32_t>(payload.size());
    full_pdu.push_back(static_cast<uint8_t>((length >> 24) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>((length >> 16) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>((length >> 8) & 0xFF));
    full_pdu.push_back(static_cast<uint8_t>(length & 0xFF));
    full_pdu.insert(full_pdu.end(), payload.begin(), payload.end());
 
    // Decode P-DATA-TF
    auto result = pdu_decoder::decode_p_data_tf(full_pdu);
    if (!result.is_ok()) {
        report_error("Failed to decode P-DATA-TF");
        send_abort(abort_source::service_provider, abort_reason::invalid_pdu_parameter);
        close_handler(false);
        return;
    }
 
    const p_data_tf_pdu& p_data = result.value();
 
    // Process each PDV
    for (const auto& pdv : p_data.pdvs) {
        // Get abstract syntax for this presentation context
        std::string abstract_syntax;
        for (const auto& ctx : association_.accepted_contexts()) {
            if (ctx.id == pdv.context_id) {
                abstract_syntax = ctx.abstract_syntax;
                break;
            }
        }
 
        if (abstract_syntax.empty()) {
            report_error("Unknown presentation context ID: " +
                         std::to_string(pdv.context_id));
            continue;
        }
 
        // If this is a complete command, decode DIMSE message
        // Note: For simplicity, we're handling command-only messages here.
        // Full DIMSE message handling with dataset fragmentation would require
        // accumulating PDVs until is_last is true for both command and data.
        if (pdv.is_last && pdv.is_command) {
            // For command-only messages (like C-ECHO), dataset is empty
            std::vector<uint8_t> empty_dataset;
 
            // Get transfer syntax for the context
            auto ts_result = association_.context_transfer_syntax(pdv.context_id);
            if (ts_result.is_err()) {
                report_error("Invalid presentation context: " +
                             ts_result.error().message);
                continue;
            }
 
            // Decode DIMSE command
            auto dimse_result = dimse::dimse_message::decode(
                std::span<const uint8_t>(pdv.data),
                std::span<const uint8_t>(empty_dataset),
                ts_result.value());
 
            if (dimse_result.is_err()) {
                report_error("Failed to decode DIMSE message: " +
                             dimse_result.error().message);
                continue;
            }
 
            messages_processed_.fetch_add(1, std::memory_order_relaxed);
 
            // Dispatch to service
            auto dispatch_result = dispatch_to_service(pdv.context_id, dimse_result.value());
            if (dispatch_result.is_err()) {
                report_error("Service dispatch failed: " + dispatch_result.error().message);
            }
        }
    }
}

Referenced by process_pdu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_release_rq()

void kcenon::pacs::network::v2::dicom_association_handler::handle_release_rq ( )

private

Handle A-RELEASE-RQ PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 575 of file dicom_association_handler.cpp.

                                                  {
    transition_to(handler_state::releasing);
 
    // Process release on the association
    association_.process_release_rq();
 
    // Send A-RELEASE-RP
    send_release_rp();
 
    // Close gracefully
    close_handler(true);
}

References association_, close_handler(), kcenon::pacs::network::association::process_release_rq(), kcenon::pacs::network::v2::releasing, send_release_rp(), and transition_to().

Referenced by process_pdu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_closed()

bool kcenon::pacs::network::v2::dicom_association_handler::is_closed ( ) const

nodiscardnoexcept

Check if the handler is closed.

Returns: true if handler is in closed state

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 113 of file dicom_association_handler.cpp.

                                                         {
    return state_.load(std::memory_order_acquire) == handler_state::closed;
}

References kcenon::pacs::network::v2::closed, and state_.

Referenced by on_data_received(), and ~dicom_association_handler().

Here is the caller graph for this function:

◆ is_established()

bool kcenon::pacs::network::v2::dicom_association_handler::is_established ( ) const

nodiscardnoexcept

Check if the association is established.

Returns: true if association is in established state

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 109 of file dicom_association_handler.cpp.

                                                              {
    return state_.load(std::memory_order_acquire) == handler_state::established;
}

References kcenon::pacs::network::v2::established, and state_.

Referenced by get_association(), and get_association().

Here is the caller graph for this function:

◆ last_activity()

dicom_association_handler::time_point kcenon::pacs::network::v2::dicom_association_handler::last_activity ( ) const

nodiscardnoexcept

Get time of last activity.

Returns: Time point of last PDU received/sent

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 155 of file dicom_association_handler.cpp.

                                                                                            {
    std::lock_guard<std::mutex> lock(mutex_);
    return last_activity_;
}

References last_activity_, and mutex_.

◆ messages_processed()

uint64_t kcenon::pacs::network::v2::dicom_association_handler::messages_processed ( ) const

nodiscardnoexcept

Get number of DIMSE messages processed.

Returns: Count of DIMSE messages handled

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 193 of file dicom_association_handler.cpp.

                                                                      {
    return messages_processed_.load(std::memory_order_relaxed);
}

References messages_processed_.

◆ on_data_received()

void kcenon::pacs::network::v2::dicom_association_handler::on_data_received ( const std::vector< uint8_t > & data )

private

Handle data received from session.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 232 of file dicom_association_handler.cpp.

                                                                               {
    if (is_closed()) {
        return;
    }
 
    {
        std::lock_guard<std::mutex> lock(mutex_);
        // Append to receive buffer
        receive_buffer_.insert(receive_buffer_.end(), data.begin(), data.end());
        touch();
    }
 
    // Process any complete PDUs
    process_buffer();
}

References is_closed(), mutex_, process_buffer(), receive_buffer_, and touch().

Referenced by feed_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_disconnected()

void kcenon::pacs::network::v2::dicom_association_handler::on_disconnected ( const std::string & session_id )

private

Handle session disconnection.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 248 of file dicom_association_handler.cpp.

                                                                  {
    close_handler(true);
}

References close_handler().

Referenced by handle_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_error()

void kcenon::pacs::network::v2::dicom_association_handler::on_error ( std::error_code ec )

private

Handle session error.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 252 of file dicom_association_handler.cpp.

                                                         {
    std::ostringstream oss;
    oss << "Network error: " << ec.message() << " (" << ec.value() << ")";
    report_error(oss.str());
 
    close_handler(false);
}

References close_handler(), and report_error().

Referenced by handle_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

dicom_association_handler & kcenon::pacs::network::v2::dicom_association_handler::operator= ( const dicom_association_handler & )

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

◆ operator=() [2/2]

dicom_association_handler & kcenon::pacs::network::v2::dicom_association_handler::operator= ( dicom_association_handler && )

delete

◆ pdus_received()

uint64_t kcenon::pacs::network::v2::dicom_association_handler::pdus_received ( ) const

nodiscardnoexcept

Get number of PDUs received.

Returns: Count of PDUs received

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 185 of file dicom_association_handler.cpp.

                                                                 {
    return pdus_received_.load(std::memory_order_relaxed);
}

References pdus_received_.

◆ pdus_sent()

uint64_t kcenon::pacs::network::v2::dicom_association_handler::pdus_sent ( ) const

nodiscardnoexcept

Get number of PDUs sent.

Returns: Count of PDUs sent

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 189 of file dicom_association_handler.cpp.

                                                             {
    return pdus_sent_.load(std::memory_order_relaxed);
}

References pdus_sent_.

◆ process_buffer()

void kcenon::pacs::network::v2::dicom_association_handler::process_buffer ( )

private

Process accumulated buffer for complete PDUs.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 264 of file dicom_association_handler.cpp.

                                               {
    std::lock_guard<std::mutex> lock(mutex_);
 
    while (receive_buffer_.size() >= pdu_header_size) {
        // Check if we have a complete PDU
        auto length_opt = pdu_decoder::pdu_length(receive_buffer_);
        if (!length_opt) {
            // Not enough data yet
            break;
        }
 
        size_t pdu_total_length = *length_opt;
        if (receive_buffer_.size() < pdu_total_length) {
            // Not enough data for complete PDU
            break;
        }
 
        // Extract the complete PDU
        std::vector<uint8_t> pdu_data(
            receive_buffer_.begin(),
            receive_buffer_.begin() + static_cast<std::ptrdiff_t>(pdu_total_length));
 
        // Remove from buffer
        receive_buffer_.erase(
            receive_buffer_.begin(),
            receive_buffer_.begin() + static_cast<std::ptrdiff_t>(pdu_total_length));
 
        // Parse PDU type
        auto type_opt = pdu_decoder::peek_pdu_type(pdu_data);
        if (!type_opt) {
            report_error("Invalid PDU type received");
            send_abort(abort_source::service_provider, abort_reason::unrecognized_pdu);
            close_handler(false);
            return;
        }
 
        pdus_received_.fetch_add(1, std::memory_order_relaxed);
 
        // Extract payload (skip 6-byte header)
        std::vector<uint8_t> payload(
            pdu_data.begin() + pdu_header_size,
            pdu_data.end());
 
        // Create pdu_data structure for processing
        integration::pdu_data pdu(*type_opt, std::move(payload));
        process_pdu(pdu);
    }
}

References close_handler(), mutex_, pdu_header_size, kcenon::pacs::network::pdu_decoder::pdu_length(), pdus_received_, kcenon::pacs::network::pdu_decoder::peek_pdu_type(), process_pdu(), receive_buffer_, report_error(), send_abort(), kcenon::pacs::network::service_provider, and kcenon::pacs::network::unrecognized_pdu.

Referenced by on_data_received().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_pdu()

void kcenon::pacs::network::v2::dicom_association_handler::process_pdu ( const integration::pdu_data & pdu )

private

Process a complete PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 313 of file dicom_association_handler.cpp.

                                                                          {
    // Note: mutex_ is already held by caller (process_buffer)
 
    switch (pdu.type) {
        case pdu_type::associate_rq:
            if (state_ == handler_state::idle) {
                handle_associate_rq(pdu.payload);
            } else {
                report_error("Unexpected A-ASSOCIATE-RQ in current state");
                send_abort(abort_source::service_provider, abort_reason::unexpected_pdu);
                close_handler(false);
            }
            break;
 
        case pdu_type::p_data_tf:
            if (state_ == handler_state::established) {
                handle_p_data_tf(pdu.payload);
            } else {
                report_error("Unexpected P-DATA-TF in current state");
                send_abort(abort_source::service_provider, abort_reason::unexpected_pdu);
                close_handler(false);
            }
            break;
 
        case pdu_type::release_rq:
            if (state_ == handler_state::established) {
                handle_release_rq();
            } else {
                report_error("Unexpected A-RELEASE-RQ in current state");
                send_abort(abort_source::service_provider, abort_reason::unexpected_pdu);
                close_handler(false);
            }
            break;
 
        case pdu_type::abort:
            handle_abort(pdu.payload);
            break;
 
        case pdu_type::associate_ac:
        case pdu_type::associate_rj:
        case pdu_type::release_rp:
            // These are responses, SCP should not receive them in normal flow
            report_error("Unexpected PDU type for SCP: " + std::string(to_string(pdu.type)));
            send_abort(abort_source::service_provider, abort_reason::unexpected_pdu);
            close_handler(false);
            break;
 
        default:
            report_error("Unknown PDU type");
            send_abort(abort_source::service_provider, abort_reason::unrecognized_pdu);
            close_handler(false);
            break;
    }
}

Referenced by process_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ report_error()

void kcenon::pacs::network::v2::dicom_association_handler::report_error ( const std::string & error )

private

Report error through callback.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 762 of file dicom_association_handler.cpp.

                                                                   {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    if (error_callback_) {
        error_callback_(session_id(), error);
    }
}

References callback_mutex_, error_callback_, and session_id().

Referenced by handle_associate_rq(), handle_p_data_tf(), on_error(), process_buffer(), process_pdu(), and start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_abort()

void kcenon::pacs::network::v2::dicom_association_handler::send_abort	(	abort_source	source,
		abort_reason	reason )

private

Send A-ABORT PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 632 of file dicom_association_handler.cpp.

                                                                                   {
    auto encoded = pdu_encoder::encode_abort(source, reason);
    send_pdu(pdu_type::abort, encoded);
}

References kcenon::pacs::network::abort, kcenon::pacs::network::pdu_encoder::encode_abort(), and send_pdu().

Referenced by handle_p_data_tf(), process_buffer(), and process_pdu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_associate_ac()

void kcenon::pacs::network::v2::dicom_association_handler::send_associate_ac ( )

private

Send A-ASSOCIATE-AC response.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 609 of file dicom_association_handler.cpp.

                                                  {
    associate_ac ac = association_.build_associate_ac();
    auto encoded = pdu_encoder::encode_associate_ac(ac);
    send_pdu(pdu_type::associate_ac, encoded);
}

References kcenon::pacs::network::associate_ac, association_, kcenon::pacs::network::association::build_associate_ac(), kcenon::pacs::network::pdu_encoder::encode_associate_ac(), and send_pdu().

Referenced by handle_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_associate_rj()

void kcenon::pacs::network::v2::dicom_association_handler::send_associate_rj	(	reject_result	result,
		uint8_t	source,
		uint8_t	reason )

private

Send A-ASSOCIATE-RJ response.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 615 of file dicom_association_handler.cpp.

                                                          {
    associate_rj rj(result, source, reason);
    auto encoded = pdu_encoder::encode_associate_rj(rj);
    send_pdu(pdu_type::associate_rj, encoded);
}

References kcenon::pacs::network::associate_rj, kcenon::pacs::network::pdu_encoder::encode_associate_rj(), and send_pdu().

Referenced by handle_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_p_data_tf()

void kcenon::pacs::network::v2::dicom_association_handler::send_p_data_tf ( const std::vector< uint8_t > & payload )

private

Send P-DATA-TF PDU.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 622 of file dicom_association_handler.cpp.

                                                                                {
    // Payload should already be a complete P-DATA-TF PDU
    send_pdu(pdu_type::p_data_tf, payload);
}

References kcenon::pacs::network::p_data_tf, and send_pdu().

Here is the call graph for this function:

◆ send_pdu()

void kcenon::pacs::network::v2::dicom_association_handler::send_pdu	(	pdu_type	type,
		const std::vector< uint8_t > &	payload )

private

Send raw PDU data.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 637 of file dicom_association_handler.cpp.

                                                                                          {
#ifdef PACS_WITH_NETWORK_SYSTEM
    if (session_ && session_->is_connected()) {
        // encoded_pdu already includes header for most PDU types
        // For encode_associate_ac, encode_associate_rj, etc., the encoder returns full PDU
 
        // We need to make a copy for the async send
        std::vector<uint8_t> data_copy = encoded_pdu;
        (void)session_->send(std::move(data_copy));
        pdus_sent_.fetch_add(1, std::memory_order_relaxed);
    }
#else
    (void)encoded_pdu;
#endif
}

References pdus_sent_, and session_.

Referenced by send_abort(), send_associate_ac(), send_associate_rj(), send_p_data_tf(), and send_release_rp().

Here is the caller graph for this function:

◆ send_release_rp()

void kcenon::pacs::network::v2::dicom_association_handler::send_release_rp ( )

private

Send A-RELEASE-RP response.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 627 of file dicom_association_handler.cpp.

                                                {
    auto encoded = pdu_encoder::encode_release_rp();
    send_pdu(pdu_type::release_rp, encoded);
}

References kcenon::pacs::network::pdu_encoder::encode_release_rp(), kcenon::pacs::network::release_rp, and send_pdu().

Referenced by handle_release_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ session_id()

std::string kcenon::pacs::network::v2::dicom_association_handler::session_id ( ) const

nodiscard

Get the session identifier.

Returns: Unique session ID string

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 117 of file dicom_association_handler.cpp.

                                                      {
#ifdef PACS_WITH_NETWORK_SYSTEM
    std::lock_guard<std::mutex> lock(mutex_);
    if (session_) {
        return std::string(session_->id());
    }
#endif
    return {};
}

References mutex_, and session_.

Referenced by close_handler(), handle_associate_rq(), handle_disconnect(), and report_error().

Here is the caller graph for this function:

◆ set_access_control()

void kcenon::pacs::network::v2::dicom_association_handler::set_access_control ( std::shared_ptr< security::access_control_manager > acm )

Set the access control manager for RBAC.

Parameters

acm	Shared pointer to access control manager

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 201 of file dicom_association_handler.cpp.

                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    access_control_ = std::move(acm);
}

References access_control_, and mutex_.

◆ set_access_control_enabled()

void kcenon::pacs::network::v2::dicom_association_handler::set_access_control_enabled ( bool enabled )

Enable or disable access control enforcement.

Parameters

enabled If true, access control is enforced

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 207 of file dicom_association_handler.cpp.

                                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    access_control_enabled_ = enabled;
}

References access_control_enabled_, and mutex_.

◆ set_closed_callback()

void kcenon::pacs::network::v2::dicom_association_handler::set_closed_callback ( association_closed_callback callback )

Set callback for association closed event.

Parameters

callback Function called when association is closed

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 170 of file dicom_association_handler.cpp.

                                          {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    closed_callback_ = std::move(callback);
}

References callback_mutex_, and closed_callback_.

◆ set_error_callback()

void kcenon::pacs::network::v2::dicom_association_handler::set_error_callback ( handler_error_callback callback )

Set callback for error events.

Parameters

callback Function called on errors

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 176 of file dicom_association_handler.cpp.

                                                                                  {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    error_callback_ = std::move(callback);
}

References callback_mutex_, and error_callback_.

◆ set_established_callback()

void kcenon::pacs::network::v2::dicom_association_handler::set_established_callback ( association_established_callback callback )

Set callback for association established event.

Parameters

callback Function called when association is established

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 164 of file dicom_association_handler.cpp.

                                               {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    established_callback_ = std::move(callback);
}

References callback_mutex_, and established_callback_.

◆ start()

void kcenon::pacs::network::v2::dicom_association_handler::start ( )

Start processing the session.

Sets up receive callbacks and begins handling incoming PDUs. The handler will automatically process association negotiation.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 62 of file dicom_association_handler.cpp.

                                      {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ != handler_state::idle) {
        report_error("Cannot start: handler not in idle state");
        return;
    }
 
    if (!session_) {
        report_error("Cannot start: no session available");
        return;
    }
 
#ifdef PACS_WITH_NETWORK_SYSTEM
    // In the i_protocol_server architecture, the server forwards events
    // to the handler via feed_data(), handle_disconnect(), and handle_error().
    // No session-level callback setup needed.
#endif
 
    touch();
}

References kcenon::pacs::network::v2::idle, mutex_, report_error(), session_, state_, and touch().

Here is the call graph for this function:

◆ state()

handler_state kcenon::pacs::network::v2::dicom_association_handler::state ( ) const

nodiscardnoexcept

Get current handler state.

Returns: Current state of the handler

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 105 of file dicom_association_handler.cpp.

                                                              {
    return state_.load(std::memory_order_acquire);
}

References state_.

◆ stop()

void kcenon::pacs::network::v2::dicom_association_handler::stop ( bool graceful = false )

Stop the handler and close the session.

Sends an A-ABORT if the association is established and forces immediate closure of the underlying network session.

Parameters

graceful If true, attempt graceful release before aborting

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 84 of file dicom_association_handler.cpp.

                                                  {
    handler_state expected = state_.load();
    if (expected == handler_state::closed) {
        return;  // Already closed
    }
 
    if (graceful && expected == handler_state::established) {
        // Try graceful release first
        transition_to(handler_state::releasing);
 
        // Send A-RELEASE-RQ would go here if we were initiating release
        // For now, just close
    }
 
    close_handler(graceful);
}

References close_handler(), kcenon::pacs::network::v2::closed, kcenon::pacs::network::v2::established, kcenon::pacs::network::v2::releasing, state_, and transition_to().

Referenced by ~dicom_association_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ touch()

void kcenon::pacs::network::v2::dicom_association_handler::touch ( )

private

Update last activity timestamp.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 757 of file dicom_association_handler.cpp.

                                      {
    // Note: mutex_ should be held by caller
    last_activity_ = clock::now();
}

References last_activity_.

Referenced by on_data_received(), and start().

Here is the caller graph for this function:

◆ transition_to()

void kcenon::pacs::network::v2::dicom_association_handler::transition_to ( handler_state new_state )

private

Transition to new state.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/network/v2/dicom_association_handler.h.

Definition at line 750 of file dicom_association_handler.cpp.

                                                                     {
    handler_state old_state = state_.exchange(new_state, std::memory_order_acq_rel);
 
    // Log state transition if needed
    (void)old_state;
}