hdds-c 1.0.11

High-performance DDS (Data Distribution Service) implementation in pure Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// SPDX-License-Identifier: Apache-2.0 OR MIT
// Copyright (c) 2025-2026 naskel.com

//! Participant and entity information getters for HDDS C FFI

use std::ffi::CString;
use std::os::raw::c_char;
use std::ptr;
use std::sync::Arc;

use hdds::api::{DataReader, DataWriter, Participant};

use super::{BytePayload, HddsDataReader, HddsDataWriter, HddsError, HddsParticipant};

// =============================================================================
// Participant Information
// =============================================================================

/// Get the participant name
///
/// # Safety
/// - `participant` must be a valid pointer returned from `hdds_participant_create`
/// - Returns a pointer to an internal string, valid until participant is destroyed
///
/// # Returns
/// Pointer to null-terminated participant name, or NULL on error
#[no_mangle]
pub unsafe extern "C" fn hdds_participant_name(participant: *mut HddsParticipant) -> *const c_char {
    if participant.is_null() {
        return ptr::null();
    }

    let participant_ref = &*participant.cast::<Arc<Participant>>();

    // We need to return a stable pointer, so we leak a CString
    // This is acceptable since participant names are typically static
    match CString::new(participant_ref.name()) {
        Ok(cstr) => {
            let ptr = cstr.as_ptr();
            std::mem::forget(cstr); // Leak intentionally - freed when participant destroyed
            ptr
        }
        Err(_) => ptr::null(),
    }
}

/// Get the participant domain ID
///
/// # Safety
/// - `participant` must be a valid pointer returned from `hdds_participant_create`
///
/// # Returns
/// Domain ID (default 0), or 0xFFFFFFFF on error
#[no_mangle]
pub unsafe extern "C" fn hdds_participant_domain_id(participant: *mut HddsParticipant) -> u32 {
    if participant.is_null() {
        return 0xFFFF_FFFF;
    }

    let participant_ref = &*participant.cast::<Arc<Participant>>();
    participant_ref.domain_id()
}

/// Get the participant ID (unique within domain)
///
/// # Safety
/// - `participant` must be a valid pointer
///
/// # Returns
/// Participant ID, or 0xFF on error
#[no_mangle]
pub unsafe extern "C" fn hdds_participant_id(participant: *mut HddsParticipant) -> u8 {
    if participant.is_null() {
        return 0xFF;
    }

    let participant_ref = &*participant.cast::<Arc<Participant>>();
    participant_ref.participant_id()
}

// =============================================================================
// DataWriter Information
// =============================================================================

/// Get the topic name for a writer
///
/// # Safety
/// - `writer` must be a valid pointer
/// - `buf` must point to a buffer of at least `buf_len` bytes
/// - `out_len` must be a valid pointer
///
/// # Returns
/// `HddsError::HddsOk` on success, writes topic name to buffer
#[no_mangle]
pub unsafe extern "C" fn hdds_writer_topic_name(
    writer: *mut HddsDataWriter,
    buf: *mut c_char,
    buf_len: usize,
    out_len: *mut usize,
) -> HddsError {
    if writer.is_null() || buf.is_null() || out_len.is_null() {
        return HddsError::HddsInvalidArgument;
    }

    let writer_ref = &*writer.cast::<DataWriter<BytePayload>>();
    let name = writer_ref.topic_name();

    let name_len = name.len();
    *out_len = name_len;

    if buf_len < name_len + 1 {
        return HddsError::HddsOutOfMemory;
    }

    ptr::copy_nonoverlapping(name.as_ptr(), buf.cast::<u8>(), name_len);
    *buf.add(name_len) = 0; // Null terminator

    HddsError::HddsOk
}

// =============================================================================
// DataReader Information
// =============================================================================

/// Get the topic name for a reader
///
/// # Safety
/// - `reader` must be a valid pointer
/// - `buf` must point to a buffer of at least `buf_len` bytes
/// - `out_len` must be a valid pointer
///
/// # Returns
/// `HddsError::HddsOk` on success, writes topic name to buffer
#[no_mangle]
pub unsafe extern "C" fn hdds_reader_topic_name(
    reader: *mut HddsDataReader,
    buf: *mut c_char,
    buf_len: usize,
    out_len: *mut usize,
) -> HddsError {
    if reader.is_null() || buf.is_null() || out_len.is_null() {
        return HddsError::HddsInvalidArgument;
    }

    let reader_ref = &*reader.cast::<DataReader<BytePayload>>();
    let name = reader_ref.topic_name();

    let name_len = name.len();
    *out_len = name_len;

    if buf_len < name_len + 1 {
        return HddsError::HddsOutOfMemory;
    }

    ptr::copy_nonoverlapping(name.as_ptr(), buf.cast::<u8>(), name_len);
    *buf.add(name_len) = 0; // Null terminator

    HddsError::HddsOk
}