Upload third-party source (skip LFS pointer assets) (part 6)

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_alloc.h

@@ -0,0 +1,156 @@
+/*
+ * Copyright(c) 2006 to 2019 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+/* TODO: do we really need to expose this as an API? */
+
+/** @file
+ *
+ * @brief DDS C Allocation API
+ *
+ * This header file defines the public API of allocation convenience functions
+ * in the Eclipse Cyclone DDS C language binding.
+ */
+#ifndef DDS_ALLOC_H
+#define DDS_ALLOC_H
+
+#include <stddef.h>
+
+#include "dds/export.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct dds_topic_descriptor;
+struct dds_sequence;
+
+/**
+ * @anchor DDS_FREE_KEY_BIT
+ * @ingroup alloc
+ * @brief Instruction to free all keyfields in sample
+ */
+#define DDS_FREE_KEY_BIT 0x01
+
+/**
+ * @anchor DDS_FREE_CONTENTS_BIT
+ * @ingroup alloc
+ * @brief Instruction to free all non-keyfields in sample
+ */
+#define DDS_FREE_CONTENTS_BIT 0x02
+
+/**
+ * @anchor DDS_FREE_ALL_BIT
+ * @ingroup alloc
+ * @brief Instruction to free outer sample
+ */
+#define DDS_FREE_ALL_BIT 0x04
+
+/**
+ * @brief Freeing operation type
+ * @ingroup alloc
+ * What part of a sample to free
+ */
+typedef enum
+{
+  DDS_FREE_ALL = DDS_FREE_KEY_BIT | DDS_FREE_CONTENTS_BIT | DDS_FREE_ALL_BIT, /**< free full sample */
+  DDS_FREE_CONTENTS = DDS_FREE_KEY_BIT | DDS_FREE_CONTENTS_BIT, /**< free all sample contents, but leave sample pointer intact */
+  DDS_FREE_KEY = DDS_FREE_KEY_BIT /**< free only the keyfields in a sample */
+}
+dds_free_op_t;
+
+/**
+ * @brief DDS Allocator
+ * @ingroup alloc
+ * C-Style allocator API
+ */
+typedef struct dds_allocator
+{
+  void * (*malloc) (size_t size); /**< behave like C malloc */
+  void * (*realloc) (void *ptr, size_t size); /**< behave like C realloc, may be null */
+  void (*free) (void *ptr); /**< behave like C free */
+}
+dds_allocator_t;
+
+/**
+ * @brief Perform an alloc() with the default allocator.
+ *
+ * @param[in] size number of bytes
+ * @returns new pointer or NULL if out of memory
+ */
+DDS_EXPORT void * dds_alloc (size_t size);
+
+/**
+ * @brief Perform a realloc() with the default allocator.
+ *
+ * @param[in] ptr previously alloc()'ed pointer
+ * @param[in] size new size
+ * @return new pointer or NULL if out of memory
+ */
+DDS_EXPORT void * dds_realloc (void * ptr, size_t size);
+
+/**
+ * @brief Perform a realloc() with the default allocator. Zero out memory.
+ *
+ * @param[in] ptr previously alloc()'ed pointer
+ * @param[in] size new size
+ * @return new pointer or NULL if out of memory
+ */
+DDS_EXPORT void * dds_realloc_zero (void * ptr, size_t size);
+
+/**
+ * @brief Perform a free() on a memory fragment allocated with the default allocator.
+ *
+ * @param[in] ptr previously alloc()'ed pointer
+ */
+DDS_EXPORT void dds_free (void * ptr);
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef void * (*dds_alloc_fn_t) (size_t);
+typedef void * (*dds_realloc_fn_t) (void *, size_t);
+typedef void (*dds_free_fn_t) (void *);
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+/**
+ * @brief Allocated a string with size, accounting for the null terminator.
+ *
+ * @param[in] size number of characters
+ * @returns newly allocated string or NULL if out of memory
+ */
+DDS_EXPORT char * dds_string_alloc (size_t size);
+
+/**
+ * @brief Duplicate a null-terminated string
+ *
+ * @param[in] str string to duplicate
+ * @returns newly allocated duplicate string, or NULL if out of memory
+ */
+DDS_EXPORT char * dds_string_dup (const char * str);
+
+/**
+ * @brief Free a string, equivalent to dds_free
+ *
+ * @param[in] str string to free
+ */
+DDS_EXPORT void dds_string_free (char * str);
+
+/**
+ * @brief Free (parts of) a sample according to the \ref dds_free_op_t
+ *
+ * @param[in] sample sample to free
+ * @param[in] desc topic descriptor of the type this sample was created from.
+ * @param[in] op Which parts of the sample to free.
+ */
+DDS_EXPORT void dds_sample_free (void * sample, const struct dds_topic_descriptor * desc, dds_free_op_t op);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_error.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright(c) 2006 to 2019 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+/** @file
+ *
+ * @brief DDS C Error API
+ *
+ * This header file defines the public API of error values and convenience
+ * functions in the CycloneDDS C language binding.
+ */
+#ifndef DDS_ERROR_H
+#define DDS_ERROR_H
+
+#include "dds/export.h"
+#include "dds/ddsrt/log.h"
+#include "dds/ddsrt/retcode.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* ** DEPRECATED ** */
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+/* Error masks for returned status values */
+
+#define DDS_ERR_NR_MASK       0x000000ff
+#define DDS_ERR_LINE_MASK     0x003fff00
+#define DDS_ERR_FILE_ID_MASK  0x7fc00000
+
+/* Error code handling functions */
+
+/** Macro to extract error number */
+#define dds_err_nr(e) (e)
+
+/** Macro to extract line number */
+#define dds_err_line(e) (0)
+
+/** Macro to extract file identifier */
+#define dds_err_file_id(e) (0)
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_impl.h

@@ -0,0 +1,350 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+/* TODO: do we really need to expose all of this as an API? maybe some, but all? */
+
+/** @file
+ *
+ * @brief DDS C Implementation API
+ *
+ * This header file defines the public API for all kinds of things in the
+ * Eclipse Cyclone DDS C language binding.
+ */
+#ifndef DDS_IMPL_H
+#define DDS_IMPL_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "dds/export.h"
+#include "dds/features.h"
+#include "dds/ddsrt/align.h"
+#include "dds/ddsc/dds_public_alloc.h"
+#include "dds/ddsc/dds_opcodes.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * @defgroup implementation (Public Implementation Details)
+ * @ingroup dds
+ * Miscellaneous types and functions that are required to be public, since they are
+ * in the output of the IDL compiler, but are not intended for direct use.
+ */
+
+/**
+ * @ingroup implementation
+ * @brief Datastructure of a Sequence type
+ * Container for a sequence of bytes. The general model of this type is also used in IDL output,
+ * where the uint8_t * _buffer is replaced by the appropriate subtype of what is contained.
+ */
+typedef struct dds_sequence
+{
+  uint32_t _maximum; /**< Allocated space in _buffer */
+  uint32_t _length; /**< Used space in _buffer */
+  uint8_t * _buffer; /**< Sequence of bytes */
+  bool _release; /**< Whether a CycloneDDS _free method should free the contained buffer.
+                      if you put in your own allocated _buffer set this to false to avoid
+                      CycloneDDS calling free() on it. */
+}
+dds_sequence_t;
+
+/**
+ * @ingroup implementation
+ * @brief Key Descriptor
+ * Used to describe a named key field in a type with the offset from the start of a struct.
+ */
+typedef struct dds_key_descriptor
+{
+  const char * m_name; /**< name of keyfield */
+  uint32_t m_offset; /**< offset from pointer */
+  uint32_t m_idx; /**< m_idx'th key of type */
+}
+dds_key_descriptor_t;
+
+/**
+ * @defgroup topic_definition (Topic Definition)
+ * @ingroup implementation
+ * Topic definitions are output by the IDL compiler and have an
+ * implementation-private definition. The only thing exposed on the
+ * API is a pointer to the "dds_topic_descriptor_t" struct type.
+ */
+
+/**
+ * @ingroup topic_definition
+ * @brief Simple sized byte container to hold serialized type info
+ * Holds XTypes information (TypeInformation, TypeMapping) for a
+ * type
+ */
+struct dds_type_meta_ser
+{
+  unsigned char * data;  /**< data pointer */
+  uint32_t sz;  /**< data size */
+};
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_XCDR1
+ * @ingroup topic_definition
+ * @brief Data representation XCDR1
+ * Type can be represented using XCDR1
+ */
+#define DDS_DATA_REPRESENTATION_XCDR1    0
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_XML
+ * @ingroup topic_definition
+ * @brief Data representation XML
+ * Type can be represented using XML
+ */
+#define DDS_DATA_REPRESENTATION_XML      1
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_XCDR2
+ * @ingroup topic_definition
+ * @brief Data representation XCDR2
+ * Type can be represented using XCDR2
+ */
+#define DDS_DATA_REPRESENTATION_XCDR2    2
+
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_FLAG_XCDR1
+ * @ingroup topic_definition
+ * @brief Data representation XCDR1 flag
+ * Type can be represented using XCDR1, preshifted
+ */
+#define DDS_DATA_REPRESENTATION_FLAG_XCDR1  (1u << DDS_DATA_REPRESENTATION_XCDR1)
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_FLAG_XML
+ * @ingroup topic_definition
+ * @brief Data representation XML flag
+ * Type can be represented using XML, preshifted
+ */
+#define DDS_DATA_REPRESENTATION_FLAG_XML    (1u << DDS_DATA_REPRESENTATION_XML)
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_FLAG_XCDR2
+ * @ingroup topic_definition
+ * @brief Data representation XCDR2 flag
+ * Type can be represented using XCDR2, preshifted
+ */
+#define DDS_DATA_REPRESENTATION_FLAG_XCDR2  (1u << DDS_DATA_REPRESENTATION_XCDR2)
+
+/**
+ * @anchor DDS_DATA_REPRESENTATION_RESTRICT_DEFAULT
+ * @ingroup topic_definition
+ * @brief Default datarepresentation flag, XCDR1 and XCDR2 flags
+ */
+#define DDS_DATA_REPRESENTATION_RESTRICT_DEFAULT  (DDS_DATA_REPRESENTATION_FLAG_XCDR1 | DDS_DATA_REPRESENTATION_FLAG_XCDR2)
+
+/**
+ * @brief Topic Descriptor
+ * @ingroup topic_definition
+ * @warning Unstable/Private API
+ * Contains all meta information about a type, usually produced by the IDL compiler
+ * Since this type is not intended for public consumption it can change without warning.
+ */
+typedef struct dds_topic_descriptor
+{
+  const uint32_t m_size;               /**< Size of topic type */
+  const uint32_t m_align;              /**< Alignment of topic type */
+  const uint32_t m_flagset;            /**< Flags */
+  const uint32_t m_nkeys;              /**< Number of keys (can be 0) */
+  const char * m_typename;             /**< Type name */
+  const dds_key_descriptor_t * m_keys; /**< Key descriptors (NULL iff m_nkeys 0) */
+  const uint32_t m_nops;               /**< Number of ops in m_ops */
+  const uint32_t * m_ops;              /**< Marshalling meta data */
+  const char * m_meta;                 /**< XML topic description meta data */
+  struct dds_type_meta_ser type_information;  /**< XCDR2 serialized TypeInformation, only present if flag DDS_TOPIC_XTYPES_METADATA is set */
+  struct dds_type_meta_ser type_mapping;      /**< XCDR2 serialized TypeMapping: maps type-id to type object and minimal to complete type id,
+                                                   only present if flag DDS_TOPIC_XTYPES_METADATA is set */
+  const uint32_t restrict_data_representation; /**< restrictions on the data representations allowed for the top-level type for this topic,
+                                           only present if flag DDS_TOPIC_RESTRICT_DATA_REPRESENTATION */
+}
+dds_topic_descriptor_t;
+
+/**
+ * @defgroup reading_masks (Reading Masks)
+ * @ingroup conditions
+ * Masks for read condition, read, take: there is only one mask here,
+ * which combines the sample, view and instance states.
+*/
+
+/**
+ * @anchor DDS_READ_SAMPLE_STATE
+ * @ingroup reading_masks
+ * @brief Samples that were already returned once by a read/take operation
+ */
+#define DDS_READ_SAMPLE_STATE 1u
+
+/**
+ * @anchor DDS_NOT_READ_SAMPLE_STATE
+ * @ingroup reading_masks
+ * @brief Samples that have not been returned by a read/take operation yet
+ */
+#define DDS_NOT_READ_SAMPLE_STATE 2u
+
+/**
+ * @anchor DDS_ANY_SAMPLE_STATE
+ * @ingroup reading_masks
+ * @brief Samples \ref DDS_READ_SAMPLE_STATE or \ref DDS_NOT_READ_SAMPLE_STATE
+ */
+#define DDS_ANY_SAMPLE_STATE (1u | 2u)
+
+
+/**
+ * @anchor DDS_NEW_VIEW_STATE
+ * @ingroup reading_masks
+ * @brief Samples that belong to a new instance (unique key value)
+ */
+#define DDS_NEW_VIEW_STATE 4u
+
+/**
+ * @anchor DDS_NOT_NEW_VIEW_STATE
+ * @ingroup reading_masks
+ * @brief Samples that belong to an existing instance (previously received key value)
+ */
+#define DDS_NOT_NEW_VIEW_STATE 8u
+
+/**
+ * @anchor DDS_ANY_VIEW_STATE
+ * @ingroup reading_masks
+ * @brief Samples \ref DDS_NEW_VIEW_STATE or \ref DDS_NOT_NEW_VIEW_STATE
+ */
+#define DDS_ANY_VIEW_STATE (4u | 8u)
+
+
+/**
+ * @anchor DDS_ALIVE_INSTANCE_STATE
+ * @ingroup reading_masks
+ * @brief Samples that belong to a write
+ */
+#define DDS_ALIVE_INSTANCE_STATE 16u
+
+/**
+ * @anchor DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE
+ * @ingroup reading_masks
+ * @brief Samples that belong to a (write)dispose
+ */
+#define DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE 32u
+
+/**
+ * @anchor DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE
+ * @ingroup reading_masks
+ * @brief Samples that belong a writer that is gone
+ */
+#define DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE 64u
+
+/**
+ * @anchor DDS_ANY_INSTANCE_STATE
+ * @ingroup reading_masks
+ * @brief Samples \ref DDS_ALIVE_INSTANCE_STATE, \ref DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE or \ref DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE
+ */
+#define DDS_ANY_INSTANCE_STATE (16u | 32u | 64u)
+
+/**
+ * @anchor DDS_ANY_STATE
+ * @ingroup reading_masks
+ * @brief Any and all samples
+ * Equivalen to \ref DDS_ANY_SAMPLE_STATE | \ref DDS_ANY_VIEW_STATE | \ref DDS_ANY_INSTANCE_STATE
+ */
+#define DDS_ANY_STATE (DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE)
+
+/**
+ * @anchor DDS_DOMAIN_DEFAULT
+ * @ingroup domain
+ * @brief Select the default domain
+ */
+#define DDS_DOMAIN_DEFAULT ((uint32_t) 0xffffffffu)
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+#define DDS_HANDLE_NIL 0
+#define DDS_ENTITY_NIL 0
+#endif
+
+/**
+ * @brief DDS Entity Kind constants
+ * @ingroup internal
+ * @warning Unstable/Private API
+ * Used throughout the library to indicate what entity is what.
+ */
+typedef enum dds_entity_kind
+{
+  DDS_KIND_DONTCARE, /**< Retrieving any entity */
+  DDS_KIND_TOPIC, /**< Topic entity */
+  DDS_KIND_PARTICIPANT, /**< Domain Participant entity */
+  DDS_KIND_READER, /**< Reader entity */
+  DDS_KIND_WRITER, /**< Writer entity */
+  DDS_KIND_SUBSCRIBER, /**< Subscriber entity */
+  DDS_KIND_PUBLISHER, /**< Publisher entity */
+  DDS_KIND_COND_READ, /**< ReadCondition entity */
+  DDS_KIND_COND_QUERY, /**< QueryCondition entity */
+  DDS_KIND_COND_GUARD, /**< GuardCondition entity */
+  DDS_KIND_WAITSET, /**< WaitSet entity */
+  DDS_KIND_DOMAIN, /**< Domain entity */
+  DDS_KIND_CYCLONEDDS /**< CycloneDDS library entity */
+} dds_entity_kind_t;
+/**
+ * @anchor DDS_KIND_MAX
+ * @ingroup internal
+ * @brief Max entity kind, used for loops.
+ */
+#define DDS_KIND_MAX DDS_KIND_CYCLONEDDS
+
+/**
+ * @ingroup internal
+ * @warning Private API
+ * @brief Instance handles are uint64_t behind the scenes
+ */
+typedef uint64_t dds_instance_handle_t;
+
+/**
+ * @ingroup domain
+ * @brief Domain IDs are 32 bit unsigned integers.
+ */
+typedef uint32_t dds_domainid_t;
+
+/**
+ * @ingroup topic
+ * @brief Scope for dds_find_topic()
+ */
+typedef enum dds_find_scope
+{
+  DDS_FIND_SCOPE_GLOBAL, /**< locate the topic anywhere CycloneDDS knows about */
+  DDS_FIND_SCOPE_LOCAL_DOMAIN, /**< locate the topic locally within domain boundaries */
+  DDS_FIND_SCOPE_PARTICIPANT /**< locate the topic within the current participant */
+}
+dds_find_scope_t;
+
+/**
+ * @ingroup builtintopic
+ * @brief Type identifier kind for getting endpoint type identifier
+ */
+typedef enum dds_typeid_kind
+{
+  DDS_TYPEID_MINIMAL, /**< XTypes Minimal Type ID */
+  DDS_TYPEID_COMPLETE /**< XTypes Complete Type ID */
+}
+dds_typeid_kind_t;
+
+/**
+ * @brief Enable or disable write batching.
+ * Overrides default configuration setting for write batching (Internal/WriteBatch).
+ *
+ * @param[in] enable Enables or disables write batching for all writers.
+ */
+DDS_EXPORT void dds_write_set_batch (bool enable);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_listener.h

@@ -0,0 +1,813 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+/**
+ * @defgroup listener (Listener API)
+ * @ingroup dds
+ *
+ * This defines the public API of listeners in the
+ * Eclipse Cyclone DDS C language binding.
+ */
+#ifndef _DDS_PUBLIC_LISTENER_H_
+#define _DDS_PUBLIC_LISTENER_H_
+
+#include "dds/export.h"
+#include "dds/ddsc/dds_public_impl.h"
+#include "dds/ddsc/dds_public_status.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* Listener callbacks */
+typedef void (*dds_on_inconsistent_topic_fn) (dds_entity_t topic, const dds_inconsistent_topic_status_t status, void* arg);
+typedef void (*dds_on_liveliness_lost_fn) (dds_entity_t writer, const dds_liveliness_lost_status_t status, void* arg);
+typedef void (*dds_on_offered_deadline_missed_fn) (dds_entity_t writer, const dds_offered_deadline_missed_status_t status, void* arg);
+typedef void (*dds_on_offered_incompatible_qos_fn) (dds_entity_t writer, const dds_offered_incompatible_qos_status_t status, void* arg);
+typedef void (*dds_on_data_on_readers_fn) (dds_entity_t subscriber, void* arg);
+typedef void (*dds_on_sample_lost_fn) (dds_entity_t reader, const dds_sample_lost_status_t status, void* arg);
+typedef void (*dds_on_data_available_fn) (dds_entity_t reader, void* arg);
+typedef void (*dds_on_sample_rejected_fn) (dds_entity_t reader, const dds_sample_rejected_status_t status, void* arg);
+typedef void (*dds_on_liveliness_changed_fn) (dds_entity_t reader, const dds_liveliness_changed_status_t status, void* arg);
+typedef void (*dds_on_requested_deadline_missed_fn) (dds_entity_t reader, const dds_requested_deadline_missed_status_t status, void* arg);
+typedef void (*dds_on_requested_incompatible_qos_fn) (dds_entity_t reader, const dds_requested_incompatible_qos_status_t status, void* arg);
+typedef void (*dds_on_publication_matched_fn) (dds_entity_t writer, const dds_publication_matched_status_t  status, void* arg);
+typedef void (*dds_on_subscription_matched_fn) (dds_entity_t reader, const dds_subscription_matched_status_t  status, void* arg);
+
+/**
+ * @anchor DDS_LUNSET
+ * @ingroup internal
+ * @brief Default initial value (nullptr) for listener functions.
+ */
+#define DDS_LUNSET 0
+
+/**
+ * @brief DDS Listener struct (opaque)
+ * @ingroup listener
+ */
+struct dds_listener;
+
+/**
+ * @brief DDS Listener type (opaque)
+ * @ingroup listener
+ */
+typedef struct dds_listener dds_listener_t;
+
+/**
+ * @ingroup listener
+ * @brief Allocate memory and initializes to default values (@ref DDS_LUNSET) of a listener
+ *
+ * @param[in] arg optional pointer that will be passed on to the listener callbacks
+ *
+ * @returns Returns a pointer to the allocated memory for dds_listener_t structure.
+ */
+DDS_EXPORT dds_listener_t* dds_create_listener(void* arg);
+
+/**
+ * @ingroup deprecated
+ * @deprecated use \ref dds_create_listener instead.
+ * Allocate memory and initializes to default values (@ref DDS_LUNSET) of a listener
+ *
+ * @param[in] arg optional pointer that will be passed on to the listener callbacks
+ *
+ * @return Returns a pointer to the allocated memory for dds_listener_t structure.
+ */
+DDS_DEPRECATED_EXPORT dds_listener_t* dds_listener_create (void* arg);
+
+/**
+ * @ingroup listener
+ * @brief Delete the memory allocated to listener structure
+ *
+ * @param[in] listener pointer to the listener struct to delete
+ */
+DDS_EXPORT void dds_delete_listener (dds_listener_t * __restrict listener);
+DDS_DEPRECATED_EXPORT void dds_listener_delete (dds_listener_t * __restrict listener);
+
+/**
+ * @ingroup listener
+ * @brief Reset the listener structure contents to @ref DDS_LUNSET
+ *
+ * @param[in,out] listener pointer to the listener struct to reset
+ */
+DDS_EXPORT void dds_reset_listener (dds_listener_t * __restrict listener);
+DDS_DEPRECATED_EXPORT void dds_listener_reset (dds_listener_t * __restrict listener);
+
+/**
+ * @ingroup listener
+ * @brief Copy the listener callbacks from source to destination
+ *
+ * @param[in,out] dst The pointer to the destination listener structure, where the content is to copied
+ * @param[in] src The pointer to the source listener structure to be copied
+ */
+DDS_EXPORT void dds_copy_listener (dds_listener_t * __restrict dst, const dds_listener_t * __restrict src);
+DDS_DEPRECATED_EXPORT void dds_listener_copy (dds_listener_t * __restrict dst, const dds_listener_t * __restrict src);
+
+/**
+ * @ingroup listener
+ * @brief Copy the listener callbacks from source to destination, unless already set
+ *
+ * Any listener callbacks already set in @p dst (including NULL) are skipped, only
+ * those set to DDS_LUNSET are copied from @p src.
+ *
+ * @param[in,out] dst The pointer to the destination listener structure, where the content is merged
+ * @param[in] src The pointer to the source listener structure to be copied
+ */
+DDS_EXPORT void dds_merge_listener (dds_listener_t * __restrict dst, const dds_listener_t * __restrict src);
+DDS_DEPRECATED_EXPORT void dds_listener_merge (dds_listener_t * __restrict dst, const dds_listener_t * __restrict src);
+
+/************************************************************************************************
+ *  Setters
+ ************************************************************************************************/
+
+/**
+ * @defgroup listener_setters (Setters)
+ * @ingroup listener
+ */
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the data_available callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_data_available_arg (dds_listener_t * __restrict listener, dds_on_data_available_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the data_on_readers callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_data_on_readers_arg (dds_listener_t * __restrict listener, dds_on_data_on_readers_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the inconsistent_topic callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_inconsistent_topic_arg (dds_listener_t * __restrict listener, dds_on_inconsistent_topic_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the liveliness_changed callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_liveliness_changed_arg (dds_listener_t * __restrict listener, dds_on_liveliness_changed_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the liveliness_lost callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_liveliness_lost_arg (dds_listener_t * __restrict listener, dds_on_liveliness_lost_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the offered_deadline_missed callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_offered_deadline_missed_arg (dds_listener_t * __restrict listener, dds_on_offered_deadline_missed_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the offered_incompatible_qos callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_offered_incompatible_qos_arg (dds_listener_t * __restrict listener, dds_on_offered_incompatible_qos_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the publication_matched callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_publication_matched_arg (dds_listener_t * __restrict listener, dds_on_publication_matched_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the requested_deadline_missed callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_requested_deadline_missed_arg (dds_listener_t * __restrict listener, dds_on_requested_deadline_missed_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the requested_incompatible_qos callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_requested_incompatible_qos_arg (dds_listener_t * __restrict listener, dds_on_requested_incompatible_qos_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the sample_lost callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_sample_lost_arg (dds_listener_t * __restrict listener, dds_on_sample_lost_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the sample_rejected callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_sample_rejected_arg (dds_listener_t * __restrict listener, dds_on_sample_rejected_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the subscription_matched callback and argument in the listener structure.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ * @param[in] arg callback argument that is passed uninterpreted to the callback function
+ * @param[in] reset_on_invoke whether or not the status should be cleared when the listener callback is invoked
+ *
+ * @retval DDS_RETCODE_OK success
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lset_subscription_matched_arg (dds_listener_t * __restrict listener, dds_on_subscription_matched_fn callback, void *arg, bool reset_on_invoke);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the inconsistent_topic callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_inconsistent_topic_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_inconsistent_topic (dds_listener_t * __restrict listener, dds_on_inconsistent_topic_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the liveliness_lost callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_liveliness_lost_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_liveliness_lost (dds_listener_t * __restrict listener, dds_on_liveliness_lost_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the offered_deadline_missed callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_offered_deadline_missed_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_offered_deadline_missed (dds_listener_t * __restrict listener, dds_on_offered_deadline_missed_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the offered_incompatible_qos callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_offered_incompatible_qos_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_offered_incompatible_qos (dds_listener_t * __restrict listener, dds_on_offered_incompatible_qos_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the data_on_readers callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_data_on_readers_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_data_on_readers (dds_listener_t * __restrict listener, dds_on_data_on_readers_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the sample_lost callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_sample_lost_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_sample_lost (dds_listener_t * __restrict listener, dds_on_sample_lost_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the data_available callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_data_available_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_data_available (dds_listener_t * __restrict listener, dds_on_data_available_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the sample_rejected callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_sample_rejected_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_sample_rejected (dds_listener_t * __restrict listener, dds_on_sample_rejected_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the liveliness_changed callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_liveliness_changed_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_liveliness_changed (dds_listener_t * __restrict listener, dds_on_liveliness_changed_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the requested_deadline_missed callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_requested_deadline_missed_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_requested_deadline_missed (dds_listener_t * __restrict listener, dds_on_requested_deadline_missed_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the requested_incompatible_qos callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_requested_incompatible_qos_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_requested_incompatible_qos (dds_listener_t * __restrict listener, dds_on_requested_incompatible_qos_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the publication_matched callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_publication_matched_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_publication_matched (dds_listener_t * __restrict listener, dds_on_publication_matched_fn callback);
+
+/**
+ * @ingroup listener_setters
+ * @brief Set the subscription_matched callback in the listener structure.
+ *
+ * Equivalent to calling @ref dds_lset_subscription_matched_arg with arg set to the argument passed in
+ * dds_create_listener() and reset_on_invoke to true, and throwing away the result.
+ *
+ * @param[in,out] listener listener structure to update
+ * @param[in] callback the callback to set or a null pointer
+ */
+DDS_EXPORT void dds_lset_subscription_matched (dds_listener_t * __restrict listener, dds_on_subscription_matched_fn callback);
+
+
+/************************************************************************************************
+ *  Getters
+ ************************************************************************************************/
+
+/**
+ * @defgroup listener_getters (Getters)
+ * @ingroup listener
+ */
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the data_available callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_data_available_arg (const dds_listener_t * __restrict listener, dds_on_data_available_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the data_on_readers callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_data_on_readers_arg (const dds_listener_t * __restrict listener, dds_on_data_on_readers_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the inconsistent_topic callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_inconsistent_topic_arg (const dds_listener_t * __restrict listener, dds_on_inconsistent_topic_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the liveliness_changed callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_liveliness_changed_arg (const dds_listener_t * __restrict listener, dds_on_liveliness_changed_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the liveliness_lost callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_liveliness_lost_arg (const dds_listener_t * __restrict listener, dds_on_liveliness_lost_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the offered_deadline_missed callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_offered_deadline_missed_arg (const dds_listener_t * __restrict listener, dds_on_offered_deadline_missed_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the offered_incompatible_qos callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_offered_incompatible_qos_arg (const dds_listener_t * __restrict listener, dds_on_offered_incompatible_qos_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the publication_matched callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_publication_matched_arg (const dds_listener_t * __restrict listener, dds_on_publication_matched_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the subscription_matched callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_requested_deadline_missed_arg (const dds_listener_t * __restrict listener, dds_on_requested_deadline_missed_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the requested_incompatible_qos callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_requested_incompatible_qos_arg (const dds_listener_t * __restrict listener, dds_on_requested_incompatible_qos_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the sample_lost callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_sample_lost_arg (const dds_listener_t * __restrict listener, dds_on_sample_lost_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the sample_rejected callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_sample_rejected_arg (const dds_listener_t * __restrict listener, dds_on_sample_rejected_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the subscription_matched callback from the listener structure.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ * @param[out] arg Callback argument pointer; may be a null pointer
+ * @param[out] reset_on_invoke Whether the status is reset by listener invocation; may be a null pointer
+ *
+ * @retval DDS_RETCODE_OK if successful
+ * @retval DDS_RETCODE_BAD_PARAMETER listener is a null pointer
+ */
+DDS_EXPORT dds_return_t dds_lget_subscription_matched_arg (const dds_listener_t * __restrict listener, dds_on_subscription_matched_fn *callback, void **arg, bool *reset_on_invoke);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the inconsistent_topic callback from the listener structure
+ *
+ * Equivalent to calling @ref dds_lget_inconsistent_topic_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_inconsistent_topic (const dds_listener_t * __restrict listener, dds_on_inconsistent_topic_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the liveliness_lost callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_liveliness_lost_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_liveliness_lost (const dds_listener_t * __restrict listener, dds_on_liveliness_lost_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the offered_deadline_missed callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_offered_deadline_missed_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_offered_deadline_missed (const dds_listener_t * __restrict listener, dds_on_offered_deadline_missed_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the offered_incompatible_qos callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_offered_incompatible_qos_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_offered_incompatible_qos (const dds_listener_t * __restrict listener, dds_on_offered_incompatible_qos_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the data_on_readers callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_data_on_readers_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_data_on_readers (const dds_listener_t * __restrict listener, dds_on_data_on_readers_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the sample_lost callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_sample_lost_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_sample_lost (const dds_listener_t *__restrict listener, dds_on_sample_lost_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the data_available callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_data_available_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_data_available (const dds_listener_t *__restrict listener, dds_on_data_available_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the sample_rejected callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_sample_rejected_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_sample_rejected (const dds_listener_t  *__restrict listener, dds_on_sample_rejected_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the liveliness_changed callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_liveliness_changed_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_liveliness_changed (const dds_listener_t * __restrict listener, dds_on_liveliness_changed_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the requested_deadline_missed callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_requested_deadline_missed_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_requested_deadline_missed (const dds_listener_t * __restrict listener, dds_on_requested_deadline_missed_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the requested_incompatible_qos callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_requested_incompatible_qos_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_requested_incompatible_qos (const dds_listener_t * __restrict listener, dds_on_requested_incompatible_qos_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the publication_matched callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_publication_matched_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_publication_matched (const dds_listener_t * __restrict listener, dds_on_publication_matched_fn *callback);
+
+/**
+ * @ingroup listener_getters
+ * @brief Get the subscription_matched callback from the listener structure.
+ *
+ * Equivalent to calling @ref dds_lget_subscription_matched_arg with arg and reset_on_invoke set to a null pointer and throwing away the result.
+ *
+ * @param[in] listener The pointer to the listener structure, where the callback will be retrieved from
+ * @param[out] callback Callback function; may be a null pointer
+ */
+DDS_EXPORT void dds_lget_subscription_matched (const dds_listener_t * __restrict listener, dds_on_subscription_matched_fn *callback);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /*_DDS_PUBLIC_LISTENER_H_*/

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_qos.h

@@ -0,0 +1,1021 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+/**
+ * @defgroup qos (DDS C QoS API)
+ * @ingroup dds
+ *
+ * This defines the public API of QoS and Policies in the
+ * Eclipse Cyclone DDS C language binding.
+ */
+#ifndef DDS_QOS_H
+#define DDS_QOS_H
+
+#include "dds/export.h"
+#include "dds/ddsc/dds_public_qosdefs.h"
+
+/**
+ * @anchor DDS_HAS_PROPERTY_LIST_QOS
+ * @ingroup qos
+ * @brief Whether or not the "property list" QoS setting is supported in this version.  If it is,
+ * the "dds.sec." properties are treated specially, preventing the accidental creation of
+ * an non-secure participant by an implementation built without support for DDS Security.
+ */
+#define DDS_HAS_PROPERTY_LIST_QOS 1
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * @ingroup qos
+ * @brief Allocate memory and initialize default QoS-policies
+ *
+ * @returns - Pointer to the initialized dds_qos_t structure, NULL if unsuccessful.
+ */
+DDS_EXPORT
+dds_qos_t * dds_create_qos (void);
+
+/**
+ * @ingroup deprecated
+ * @deprecated use \ref dds_create_qos instead.
+ * Allocate memory and initialize default QoS-policies
+ *
+ * @returns - Pointer to the initialized dds_qos_t structure, NULL if unsuccessful.
+ */
+DDS_DEPRECATED_EXPORT
+dds_qos_t * dds_qos_create (void);
+
+/**
+ * @ingroup qos
+ * @brief Delete memory allocated to QoS-policies structure
+ *
+ * @param[in] qos - Pointer to dds_qos_t structure
+ */
+DDS_EXPORT void
+dds_delete_qos (dds_qos_t * __restrict qos);
+
+DDS_DEPRECATED_EXPORT void
+dds_qos_delete (dds_qos_t * __restrict qos);
+
+/**
+ * @ingroup qos
+ * @brief Reset a QoS-policies structure to default values
+ *
+ * @param[in,out] qos - Pointer to the dds_qos_t structure
+ */
+DDS_EXPORT void
+dds_reset_qos(dds_qos_t * __restrict qos);
+
+DDS_DEPRECATED_EXPORT
+void dds_qos_reset (dds_qos_t * __restrict qos
+);
+
+/**
+ * @ingroup qos
+ * @brief Copy all QoS-policies from one structure to another
+ *
+ * @param[in,out] dst - Pointer to the destination dds_qos_t structure
+ * @param[in] src - Pointer to the source dds_qos_t structure
+ *
+ * @returns - Return-code indicating success or failure
+ */
+DDS_EXPORT dds_return_t
+dds_copy_qos (dds_qos_t * __restrict dst, const dds_qos_t * __restrict src);
+
+DDS_DEPRECATED_EXPORT dds_return_t
+dds_qos_copy (dds_qos_t * __restrict dst, const dds_qos_t * __restrict src);
+
+/**
+ * @ingroup qos
+ * @brief Copy all QoS-policies from one structure to another, unless already set
+ *
+ * Policies are copied from src to dst, unless src already has the policy set to a non-default value.
+ *
+ * @param[in,out] dst - Pointer to the destination qos structure
+ * @param[in] src - Pointer to the source qos structure
+ */
+DDS_EXPORT void
+dds_merge_qos (dds_qos_t * __restrict dst, const dds_qos_t * __restrict src);
+
+DDS_DEPRECATED_EXPORT void
+dds_qos_merge (dds_qos_t * __restrict dst, const dds_qos_t * __restrict src);
+
+/**
+ * @ingroup qos
+ * @brief Copy all QoS-policies from one structure to another, unless already set
+ *
+ * Policies are copied from src to dst, unless src already has the policy set to a non-default value.
+ *
+ * @param[in,out] a - Pointer to the destination qos structure
+ * @param[in] b - Pointer to the source qos structure
+ *
+ * @returns whether the copy was successful.
+ */
+DDS_EXPORT bool
+dds_qos_equal (const dds_qos_t * __restrict a, const dds_qos_t * __restrict b);
+
+/**
+ * @defgroup qos_setters (Qos Setters)
+ * @ingroup qos
+ */
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the userdata of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the userdata
+ * @param[in] value - Pointer to the userdata
+ * @param[in] sz - Size of userdata stored in value
+ */
+DDS_EXPORT void
+dds_qset_userdata (
+  dds_qos_t * __restrict qos,
+  const void * __restrict value,
+  size_t sz);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the topicdata of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the topicdata
+ * @param[in] value - Pointer to the topicdata
+ * @param[in] sz - Size of the topicdata stored in value
+ */
+DDS_EXPORT void
+dds_qset_topicdata (
+  dds_qos_t * __restrict qos,
+  const void * __restrict value,
+  size_t sz);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the groupdata of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the groupdata
+ * @param[in] value - Pointer to the group data
+ * @param[in] sz - Size of groupdata stored in value
+ */
+DDS_EXPORT void
+dds_qset_groupdata (
+  dds_qos_t * __restrict qos,
+  const void * __restrict value,
+  size_t sz);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the durability policy of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Durability kind value
+ */
+DDS_EXPORT void
+dds_qset_durability (dds_qos_t * __restrict qos, dds_durability_kind_t kind);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the history policy of a qos structure.
+ *
+ * Note that depth is only relevant for keep last. If you want limited history for keep all, use dds_qset_resource_limits().
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - History kind value
+ * @param[in] depth - History depth value
+ */
+DDS_EXPORT void
+dds_qset_history (
+  dds_qos_t * __restrict qos,
+  dds_history_kind_t kind,
+  int32_t depth);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the resource limits policy of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] max_samples - Number of samples resource-limit value
+ * @param[in] max_instances - Number of instances resource-limit value
+ * @param[in] max_samples_per_instance - Number of samples per instance resource-limit value
+ */
+DDS_EXPORT void
+dds_qset_resource_limits (
+  dds_qos_t * __restrict qos,
+  int32_t max_samples,
+  int32_t max_instances,
+  int32_t max_samples_per_instance);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the presentation policy of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] access_scope - Access-scope kind
+ * @param[in] coherent_access - Coherent access enable value
+ * @param[in] ordered_access - Ordered access enable value
+ */
+DDS_EXPORT void
+dds_qset_presentation (
+  dds_qos_t * __restrict qos,
+  dds_presentation_access_scope_kind_t access_scope,
+  bool coherent_access,
+  bool ordered_access);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the lifespan policy of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] lifespan - Lifespan duration (expiration time relative to source timestamp of a sample)
+ */
+DDS_EXPORT void
+dds_qset_lifespan (
+  dds_qos_t * __restrict qos,
+  dds_duration_t lifespan);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the deadline policy of a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] deadline - Deadline duration
+ */
+DDS_EXPORT void
+dds_qset_deadline (
+  dds_qos_t * __restrict qos,
+  dds_duration_t deadline);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the latency-budget policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] duration - Latency budget duration
+ */
+DDS_EXPORT void
+dds_qset_latency_budget (
+  dds_qos_t * __restrict qos,
+  dds_duration_t duration);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the ownership policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Ownership kind
+ */
+DDS_EXPORT void
+dds_qset_ownership (
+  dds_qos_t * __restrict qos,
+  dds_ownership_kind_t kind);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the ownership strength policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] value - Ownership strength value
+ */
+DDS_EXPORT void
+dds_qset_ownership_strength (dds_qos_t * __restrict qos, int32_t value);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the liveliness policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Liveliness kind
+ * @param[in] lease_duration - Lease duration
+ */
+DDS_EXPORT void
+dds_qset_liveliness (
+  dds_qos_t * __restrict qos,
+  dds_liveliness_kind_t kind,
+  dds_duration_t lease_duration);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the time-based filter policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] minimum_separation - Minimum duration between sample delivery for an instance
+ */
+DDS_EXPORT void
+dds_qset_time_based_filter (
+  dds_qos_t * __restrict qos,
+  dds_duration_t minimum_separation);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the partition policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] n - Number of partitions stored in ps
+ * @param[in] ps - Pointer to string(s) storing partition name(s)
+ */
+DDS_EXPORT void
+dds_qset_partition (
+  dds_qos_t * __restrict qos,
+  uint32_t n,
+  const char ** __restrict ps);
+
+/**
+ * @ingroup qos_setters
+ * @brief Convenience function to set the partition policy of a qos structure to a
+ * single name.  Name may be a null pointer.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] name - Pointer to the name
+ */
+DDS_EXPORT void
+dds_qset_partition1 (
+  dds_qos_t * __restrict qos,
+  const char * __restrict name);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the reliability policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Reliability kind
+ * @param[in] max_blocking_time - Max blocking duration applied when kind is reliable. This is how long the writer will block when its history is full.
+ */
+DDS_EXPORT void
+dds_qset_reliability (
+  dds_qos_t * __restrict qos,
+  dds_reliability_kind_t kind,
+  dds_duration_t max_blocking_time);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the transport-priority policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] value - Priority value
+ */
+DDS_EXPORT void
+dds_qset_transport_priority (dds_qos_t * __restrict qos, int32_t value);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the destination-order policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Destination-order kind
+ */
+DDS_EXPORT void
+dds_qset_destination_order (
+  dds_qos_t * __restrict qos,
+  dds_destination_order_kind_t kind);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the writer data-lifecycle policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] autodispose - Automatic disposal of unregistered instances
+ */
+DDS_EXPORT void
+dds_qset_writer_data_lifecycle (dds_qos_t * __restrict qos, bool autodispose);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the reader data-lifecycle policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] autopurge_nowriter_samples_delay - Delay for purging of samples from instances in a no-writers state
+ * @param[in] autopurge_disposed_samples_delay - Delay for purging of samples from disposed instances
+ */
+DDS_EXPORT void
+dds_qset_reader_data_lifecycle (
+  dds_qos_t * __restrict qos,
+  dds_duration_t autopurge_nowriter_samples_delay,
+  dds_duration_t autopurge_disposed_samples_delay);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the durability-service policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] service_cleanup_delay - Delay for purging of abandoned instances from the durability service
+ * @param[in] history_kind - History policy kind applied by the durability service
+ * @param[in] history_depth - History policy depth applied by the durability service
+ * @param[in] max_samples - Number of samples resource-limit policy applied by the durability service
+ * @param[in] max_instances - Number of instances resource-limit policy applied by the durability service
+ * @param[in] max_samples_per_instance - Number of samples per instance resource-limit policy applied by the durability service
+ */
+DDS_EXPORT void
+dds_qset_durability_service (
+  dds_qos_t * __restrict qos,
+  dds_duration_t service_cleanup_delay,
+  dds_history_kind_t history_kind,
+  int32_t history_depth,
+  int32_t max_samples,
+  int32_t max_instances,
+  int32_t max_samples_per_instance);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the ignore-local policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] ignore - True if readers and writers owned by the same participant should be ignored
+ */
+DDS_EXPORT void
+dds_qset_ignorelocal (
+  dds_qos_t * __restrict qos,
+  dds_ignorelocal_kind_t ignore);
+
+/**
+ * @ingroup qos_setters
+ * @brief Stores a property with the provided name and string value in a qos structure.
+ *
+ * In the case a property with the provided name already exists in the qos structure,
+ * the value for this entry is overwritten with the provided string value. If more than
+ * one property with the provided name exists, only the value of the first of these
+ * properties is updated.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the property
+ * @param[in] name - Pointer to name of the property
+ * @param[in] value - Pointer to a (null-terminated) string that will be stored
+ */
+DDS_EXPORT void
+dds_qset_prop (
+  dds_qos_t * __restrict qos,
+  const char * name,
+  const char * value);
+
+/**
+ * @ingroup qos_setters
+ * @brief Removes the property with the provided name from a qos structure.
+ *
+ * In case more than one property exists with this name, only the first property
+ * is removed.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains the property
+ * @param[in] name - Pointer to name of the property
+ */
+DDS_EXPORT void
+dds_qunset_prop (
+  dds_qos_t * __restrict qos,
+  const char * name);
+
+/**
+ * @ingroup qos_setters
+ * @brief Stores the provided binary data as a property in a qos structure
+ *
+ * In the case a property with the provided name already exists in the qos structure,
+ * the value for this entry is overwritten with the provided data. If more than one
+ * property with the provided name exists, only the value of the first of these
+ * properties is updated.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the property
+ * @param[in] name - Pointer to name of the property
+ * @param[in] value - Pointer to data to be stored in the property
+ * @param[in] sz - Size of the data
+ */
+DDS_EXPORT void
+dds_qset_bprop (
+  dds_qos_t * __restrict qos,
+  const char * name,
+  const void * value,
+  const size_t sz);
+
+/**
+ * @ingroup qos_setters
+ * @brief Removes the binary property with the provided name from a qos structure.
+ *
+ * In case more than one binary property exists with this name, only the first binary
+ * property is removed.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains the binary property
+ * @param[in] name - Pointer to name of the property
+ */
+DDS_EXPORT void
+dds_qunset_bprop (
+  dds_qos_t * __restrict qos,
+  const char * name);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the type consistency enforcement policy of a qos structure
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in] kind - Type consistency policy kind
+ * @param[in] ignore_sequence_bounds - Ignore sequence bounds in type assignability checking
+ * @param[in] ignore_string_bounds - Ignore string bounds in type assignability checking
+ * @param[in] ignore_member_names - Ignore member names in type assignability checking
+ * @param[in] prevent_type_widening - Prevent type widening in type assignability checking
+ * @param[in] force_type_validation - Force type validation in assignability checking
+ */
+DDS_EXPORT void
+dds_qset_type_consistency (
+  dds_qos_t * __restrict qos,
+  dds_type_consistency_kind_t kind,
+  bool ignore_sequence_bounds,
+  bool ignore_string_bounds,
+  bool ignore_member_names,
+  bool prevent_type_widening,
+  bool force_type_validation);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the data representation of a qos structure
+ *
+ * @param[in,out] qos    - Pointer to a dds_qos_t structure that will store the policy
+ * @param[in]     n      - Number of data representation values
+ * @param[in]     values - Data representation values
+ */
+DDS_EXPORT void
+dds_qset_data_representation (
+  dds_qos_t * __restrict qos,
+  uint32_t n,
+  const dds_data_representation_id_t *values);
+
+/**
+ * @ingroup qos_setters
+ * @brief Set the entity name.
+ *
+ * When using this QoS to initialize a participant, publisher, subscriber, reader or writer
+ * it will take the name set here. This name is visible over discovery and can be used
+ * to make sense of network in tooling.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that will store the entity name.
+ * @param[in] name - Pointer to the entity name to set.
+ */
+DDS_EXPORT void
+dds_qset_entity_name (
+  dds_qos_t * __restrict qos,
+  const char * name);
+
+
+/**
+ * @defgroup qos_getters (QoS Getters)
+ * @ingroup qos
+ */
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the userdata from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] value - Pointer that will store the userdata.  If sz = 0, then a null pointer, else it is a pointer to an allocated buffer of sz+1 bytes where the last byte is always 0
+ * @param[in,out] sz - Pointer that will store the size of userdata
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool dds_qget_userdata (const dds_qos_t * __restrict qos, void **value, size_t *sz);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the topicdata from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] value - Pointer that will store the topicdata.  If sz = 0, then a null pointer, else it is a pointer to an allocated buffer of sz+1 bytes where the last byte is always 0
+ * @param[in,out] sz - Pointer that will store the size of topicdata
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+*/
+DDS_EXPORT bool dds_qget_topicdata (const dds_qos_t * __restrict qos, void **value, size_t *sz);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the groupdata from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] value - Pointer that will store the groupdata.  If sz = 0, then a null pointer, else it is a pointer to an allocated buffer of sz+1 bytes where the last byte is always 0
+ * @param[in,out] sz - Pointer that will store the size of groupdata
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool dds_qget_groupdata (const dds_qos_t * __restrict qos, void **value, size_t *sz);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the durability policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the durability kind
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool dds_qget_durability (const dds_qos_t * __restrict qos, dds_durability_kind_t *kind);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the history policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the history kind (optional)
+ * @param[in,out] depth - Pointer that will store the history depth (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool dds_qget_history (const dds_qos_t * __restrict qos, dds_history_kind_t *kind, int32_t *depth);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the resource-limits policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] max_samples - Pointer that will store the number of samples resource-limit (optional)
+ * @param[in,out] max_instances - Pointer that will store the number of instances resource-limit (optional)
+ * @param[in,out] max_samples_per_instance - Pointer that will store the number of samples per instance resource-limit (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_resource_limits (
+  const dds_qos_t * __restrict qos,
+  int32_t *max_samples,
+  int32_t *max_instances,
+  int32_t *max_samples_per_instance);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the presentation policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] access_scope - Pointer that will store access scope kind (optional)
+ * @param[in,out] coherent_access - Pointer that will store coherent access enable value (optional)
+ * @param[in,out] ordered_access - Pointer that will store orderede access enable value (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_presentation (
+  const dds_qos_t * __restrict qos,
+  dds_presentation_access_scope_kind_t *access_scope,
+  bool *coherent_access,
+  bool *ordered_access);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the lifespan policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] lifespan - Pointer that will store lifespan duration
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_lifespan (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *lifespan);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the deadline policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] deadline - Pointer that will store deadline duration
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_deadline (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *deadline);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the latency-budget policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] duration - Pointer that will store latency-budget duration
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_latency_budget (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *duration);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the ownership policy from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the ownership kind
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_ownership (
+  const dds_qos_t * __restrict qos,
+  dds_ownership_kind_t *kind);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the ownership strength qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] value - Pointer that will store the ownership strength value
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_ownership_strength (
+  const dds_qos_t * __restrict qos,
+  int32_t *value);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the liveliness qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the liveliness kind (optional)
+ * @param[in,out] lease_duration - Pointer that will store the liveliness lease duration (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_liveliness (
+  const dds_qos_t * __restrict qos,
+  dds_liveliness_kind_t *kind,
+  dds_duration_t *lease_duration);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the time-based filter qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] minimum_separation - Pointer that will store the minimum separation duration (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_time_based_filter (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *minimum_separation);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the partition qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] n - Pointer that will store the number of partitions (optional)
+ * @param[in,out] ps - Pointer that will store the string(s) containing partition name(s) (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_partition (
+  const dds_qos_t * __restrict qos,
+  uint32_t *n,
+  char ***ps);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the reliability qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the reliability kind (optional)
+ * @param[in,out] max_blocking_time - Pointer that will store the max blocking time for reliable reliability (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_reliability (
+  const dds_qos_t * __restrict qos,
+  dds_reliability_kind_t *kind,
+  dds_duration_t *max_blocking_time);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the transport priority qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] value - Pointer that will store the transport priority value
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_transport_priority (
+  const dds_qos_t * __restrict qos,
+  int32_t *value);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the destination-order qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the destination-order kind
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_destination_order (
+  const dds_qos_t * __restrict qos,
+  dds_destination_order_kind_t *kind);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the writer data-lifecycle qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] autodispose - Pointer that will store the autodispose unregistered instances enable value
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_writer_data_lifecycle (
+  const dds_qos_t * __restrict qos,
+  bool *autodispose);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the reader data-lifecycle qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] autopurge_nowriter_samples_delay - Pointer that will store the delay for auto-purging samples from instances in a no-writer state (optional)
+ * @param[in,out] autopurge_disposed_samples_delay - Pointer that will store the delay for auto-purging of disposed instances (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_reader_data_lifecycle (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *autopurge_nowriter_samples_delay,
+  dds_duration_t *autopurge_disposed_samples_delay);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the durability-service qos policy values.
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out]  service_cleanup_delay - Pointer that will store the delay for purging of abandoned instances from the durability service (optional)
+ * @param[in,out] history_kind - Pointer that will store history policy kind applied by the durability service (optional)
+ * @param[in,out] history_depth - Pointer that will store history policy depth applied by the durability service (optional)
+ * @param[in,out] max_samples - Pointer that will store number of samples resource-limit policy applied by the durability service (optional)
+ * @param[in,out] max_instances - Pointer that will store number of instances resource-limit policy applied by the durability service (optional)
+ * @param[in,out] max_samples_per_instance - Pointer that will store number of samples per instance resource-limit policy applied by the durability service (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_durability_service (
+  const dds_qos_t * __restrict qos,
+  dds_duration_t *service_cleanup_delay,
+  dds_history_kind_t *history_kind,
+  int32_t *history_depth,
+  int32_t *max_samples,
+  int32_t *max_instances,
+  int32_t *max_samples_per_instance);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the ignore-local qos policy
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] ignore - Pointer that will store whether to ignore readers/writers owned by the same participant (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_ignorelocal (
+  const dds_qos_t * __restrict qos,
+  dds_ignorelocal_kind_t *ignore);
+
+/**
+ * @ingroup qos_getters
+ * @brief Gets the names of the properties from a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains properties
+ * @param[in,out] n - Pointer to number of property names that are returned (optional)
+ * @param[in,out] names - Pointer that will store the string(s) containing property name(s) (optional). This function will allocate the memory for the list of names and for the strings containing the names; the caller gets ownership of the allocated memory
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_propnames (
+  const dds_qos_t * __restrict qos,
+  uint32_t * n,
+  char *** names);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the value of the property with the provided name from a qos structure.
+ *
+ * In case more than one property exists with this name, the value for the first
+ * property with this name will be returned.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains the property
+ * @param[in] name - Pointer to name of the property
+ * @param[in,out] value - Pointer to a string that will store the value of the property. The memory for storing the string value will be allocated by this function and the caller gets ownership of the allocated memory
+ *
+ * @returns - false iff any of the arguments is invalid, the qos is not present in the qos object or there was no property found with the provided name
+ */
+DDS_EXPORT bool
+dds_qget_prop (
+  const dds_qos_t * __restrict qos,
+  const char * name,
+  char ** value);
+
+/**
+ * @ingroup qos_getters
+ * @brief Gets the names of the binary properties from a qos structure.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains binary properties
+ * @param[in,out] n - Pointer to number of binary property names that are returned (optional)
+ * @param[in,out] names - Pointer that will store the string(s) containing binary property name(s) (optional). This function will allocate the memory for the list of names and for the strings containing the names; the caller gets ownership of the allocated memory
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_bpropnames (
+  const dds_qos_t * __restrict qos,
+  uint32_t * n,
+  char *** names);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the value of the binary property with the provided name from a qos structure.
+ *
+ * In case more than one binary property exists with this name, the value for the first
+ * binary property with this name will be returned.
+ *
+ * @param[in,out] qos - Pointer to a dds_qos_t structure that contains the property
+ * @param[in] name - Pointer to name of the binary property
+ * @param[in,out] value - Pointer to a buffer that will store the value of the property. If sz = 0 then a NULL pointer. The memory for storing the value will be allocated by this function and the caller gets ownership of the allocated memory
+ * @param[in,out] sz - Pointer that will store the size of the returned buffer.
+ *
+ * @returns - false iff any of the arguments is invalid, the qos is not present in the qos object or there was no binary property found with the provided name
+ */
+DDS_EXPORT bool
+dds_qget_bprop (
+  const dds_qos_t * __restrict qos,
+  const char * name,
+  void ** value,
+  size_t * sz);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the type consistency enforcement qos policy values.
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] kind - Pointer that will store the type consistency enforcement kind (optional)
+ * @param[in,out] ignore_sequence_bounds - Pointer that will store the boolean value for ignoring sequence bounds in type assignability checking (optional)
+ * @param[in,out] ignore_string_bounds - Pointer that will store the boolean value for ignoring string bounds in type assignability checking (optional)
+ * @param[in,out] ignore_member_names - Pointer that will store the boolean value for ignoring member names in type assignability checking (optional)
+ * @param[in,out] prevent_type_widening - Pointer that will store the boolean value to prevent type widening in type assignability checking (optional)
+ * @param[in,out] force_type_validation - Pointer that will store the boolean value to force type validation in assignability checking (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_type_consistency (
+  const dds_qos_t * __restrict qos,
+  dds_type_consistency_kind_t *kind,
+  bool *ignore_sequence_bounds,
+  bool *ignore_string_bounds,
+  bool *ignore_member_names,
+  bool *prevent_type_widening,
+  bool *force_type_validation);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the data representation qos policy value.
+ *
+ * Returns the data representation values that are set in the provided QoS object
+ * and stores the number of values in out parameter 'n'. In case the 'values' parameter
+ * is provided, this function will allocate a buffer that contains the data representation
+ * values, and set 'values' to point to this buffer. It is the responsibility of the caller
+ * to free the memory of this buffer.
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the policy
+ * @param[in,out] n - Pointer that will store the number of data representation values
+ * @param[in,out] values - Pointer that will store the data representation values (optional)
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ */
+DDS_EXPORT bool
+dds_qget_data_representation (
+  const dds_qos_t * __restrict qos,
+  uint32_t *n,
+  dds_data_representation_id_t **values);
+
+/**
+ * @ingroup qos_getters
+ * @brief Get the entity name from a qos structure
+ *
+ * @param[in] qos - Pointer to a dds_qos_t structure storing the entity name
+ * @param[in,out] name - Pointer to a string that will store the returned entity name
+ *
+ * @returns - false iff any of the arguments is invalid or the qos is not present in the qos object
+ *            or if a buffer to store the name could not be allocated.
+ */
+DDS_EXPORT bool dds_qget_entity_name (const dds_qos_t * __restrict qos, char **name);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_qosdefs.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+#ifndef DDS_QOSDEFS_H
+#define DDS_QOSDEFS_H
+
+#include <stdint.h>
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * @anchor DDS_LENGTH_UNLIMITED
+ * @ingroup qos
+ * @brief Used for indicating unlimited length in dds_qset_resource_limits()
+ */
+#define DDS_LENGTH_UNLIMITED -1
+
+/**
+ * @brief Qos Policy IDs
+ * @ingroup internal
+ * Used internally to mark the QoS policy type
+ */
+typedef enum dds_qos_policy_id {
+  DDS_INVALID_QOS_POLICY_ID, /**< Invalid Policy */
+  DDS_USERDATA_QOS_POLICY_ID, /**< Userdata policy dds_qset_userdata() */
+  DDS_DURABILITY_QOS_POLICY_ID, /**< Durability policy dds_qset_durability() */
+  DDS_PRESENTATION_QOS_POLICY_ID, /**< Presentation policy dds_qset_presentation() */
+  DDS_DEADLINE_QOS_POLICY_ID, /**< Deadline policy dds_qset_deadline() */
+  DDS_LATENCYBUDGET_QOS_POLICY_ID, /**< LatencyBudget policy dds_qset_latency_budget() */
+  DDS_OWNERSHIP_QOS_POLICY_ID, /**< Ownership policy dds_qset_ownership() */
+  DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID, /**< OwnershipStrength policy dds_qset_ownership_strength() */
+  DDS_LIVELINESS_QOS_POLICY_ID, /**< Liveliness policy dds_qset_liveliness() */
+  DDS_TIMEBASEDFILTER_QOS_POLICY_ID, /**< TimeBasedFilter policy dds_qset_time_based_filter() */
+  DDS_PARTITION_QOS_POLICY_ID, /**< Partition policy dds_qset_partition() */
+  DDS_RELIABILITY_QOS_POLICY_ID, /**< Reliability policy dds_qset_reliability() */
+  DDS_DESTINATIONORDER_QOS_POLICY_ID, /**< DestinationOrder policy dds_qset_destination_order() */
+  DDS_HISTORY_QOS_POLICY_ID, /**< History policy dds_qset_history() */
+  DDS_RESOURCELIMITS_QOS_POLICY_ID, /**< ResourceLimits policy dds_qset_resource_limits() */
+  DDS_ENTITYFACTORY_QOS_POLICY_ID, /**< EntityFactory policy */
+  DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID, /**< WriterDataLifecycle policy dds_qset_writer_data_lifecycle() */
+  DDS_READERDATALIFECYCLE_QOS_POLICY_ID, /**< ReaderDataLifecycle policy dds_qset_reader_data_lifecycle() */
+  DDS_TOPICDATA_QOS_POLICY_ID, /**< Topicdata policy dds_qset_topicdata() */
+  DDS_GROUPDATA_QOS_POLICY_ID, /**< Groupdata policy dds_qset_groupdata() */
+  DDS_TRANSPORTPRIORITY_QOS_POLICY_ID, /**< TransportPriority policy dds_qset_transport_priority() */
+  DDS_LIFESPAN_QOS_POLICY_ID, /**< Livespan policy dds_qset_lifespan() */
+  DDS_DURABILITYSERVICE_QOS_POLICY_ID, /**< DurabilityService policy dds_qset_durability_service() */
+  DDS_PROPERTY_QOS_POLICY_ID, /**< Property policy dds_qset_property() */
+  DDS_TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID, /**< TypeConsistencyEnforcement policy dds_qset_type_consistency_enforcements() */
+  DDS_DATA_REPRESENTATION_QOS_POLICY_ID /**< DataRepresentation policy dds_qset_data_representation() */
+} dds_qos_policy_id_t;
+
+
+/**
+ * @brief QoS datatype
+ * @ingroup qos
+ * QoS structure is opaque
+ */
+typedef struct dds_qos dds_qos_t;
+
+/**
+ * @brief Durability QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_durability_kind
+{
+    DDS_DURABILITY_VOLATILE, /**< Volatile durability */
+    DDS_DURABILITY_TRANSIENT_LOCAL, /**< Transient Local durability */
+    DDS_DURABILITY_TRANSIENT, /**< Transient durability */
+    DDS_DURABILITY_PERSISTENT /**< Persistent durability */
+}
+dds_durability_kind_t;
+
+/**
+ * @brief History QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_history_kind
+{
+    DDS_HISTORY_KEEP_LAST, /**< Keep Last history */
+    DDS_HISTORY_KEEP_ALL /**< Keep All history */
+}
+dds_history_kind_t;
+
+/**
+ * @brief Ownership QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_ownership_kind
+{
+    DDS_OWNERSHIP_SHARED, /**< Shared Ownership */
+    DDS_OWNERSHIP_EXCLUSIVE /**< Exclusive Ownership */
+}
+dds_ownership_kind_t;
+
+/**
+ * @brief Liveliness QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_liveliness_kind
+{
+    DDS_LIVELINESS_AUTOMATIC, /**< Automatic liveliness */
+    DDS_LIVELINESS_MANUAL_BY_PARTICIPANT, /**< Manual by Participant liveliness */
+    DDS_LIVELINESS_MANUAL_BY_TOPIC /**< Manual by Topic liveliness */
+}
+dds_liveliness_kind_t;
+
+/**
+ * @brief Reliability QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_reliability_kind
+{
+    DDS_RELIABILITY_BEST_EFFORT, /**< Best Effort reliability */
+    DDS_RELIABILITY_RELIABLE /**< Reliable reliability */
+}
+dds_reliability_kind_t;
+
+/**
+ * @brief DestinationOrder QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_destination_order_kind
+{
+    DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP, /**< order by reception timestamp */
+    DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP /**< order by source timestamp */
+}
+dds_destination_order_kind_t;
+
+/**
+ * @brief Presentation QoS: Applies to Publisher, Subscriber
+ * @ingroup qos
+ */
+typedef enum dds_presentation_access_scope_kind
+{
+    DDS_PRESENTATION_INSTANCE, /**< presentation scope per instance */
+    DDS_PRESENTATION_TOPIC, /**< presentation scope per topic */
+    DDS_PRESENTATION_GROUP /**< presentation scope per group */
+}
+dds_presentation_access_scope_kind_t;
+
+/**
+ * @brief Ignore-local QoS: Applies to DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_ignorelocal_kind
+{
+    DDS_IGNORELOCAL_NONE, /**< Don't ignore local data */
+    DDS_IGNORELOCAL_PARTICIPANT, /**< Ignore local data from same participant */
+    DDS_IGNORELOCAL_PROCESS /**< Ignore local data from same process */
+}
+dds_ignorelocal_kind_t;
+
+/**
+ * @brief Type-consistency QoS: Applies to DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef enum dds_type_consistency_kind
+{
+    DDS_TYPE_CONSISTENCY_DISALLOW_TYPE_COERCION, /**< Do not allow type coercion */
+    DDS_TYPE_CONSISTENCY_ALLOW_TYPE_COERCION /**< Allow type coercion */
+}
+dds_type_consistency_kind_t;
+
+/**
+ * @brief Data Representation QoS: Applies to Topic, DataReader, DataWriter
+ * @ingroup qos
+ */
+typedef int16_t dds_data_representation_id_t;
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_public_status.h

@@ -0,0 +1,512 @@
+/*
+ * Copyright(c) 2006 to 2019 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+/**
+ * @defgroup dcps_status (DDS C Communication Status API)
+ * @ingroup dds
+ * This defines the public API of the Communication Status in the
+ * Eclipse Cyclone DDS C language binding. Listeners are implemented
+ * as structs containing callback functions that take listener status types
+ * as arguments.
+ */
+#ifndef DDS_STATUS_H
+#define DDS_STATUS_H
+
+#include "dds/export.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_OfferedDeadlineMissed
+ * DOC_TODO
+ */
+typedef struct dds_offered_deadline_missed_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  dds_instance_handle_t last_instance_handle;  /**< DOC_TODO */
+}
+dds_offered_deadline_missed_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_OfferedIncompatibleQoS
+ * DOC_TODO
+ */
+typedef struct dds_offered_incompatible_qos_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  uint32_t last_policy_id;  /**< DOC_TODO */
+}
+dds_offered_incompatible_qos_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_PublicationMatched
+ * DOC_TODO
+ */
+typedef struct dds_publication_matched_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  uint32_t current_count;  /**< DOC_TODO */
+  int32_t current_count_change;  /**< DOC_TODO */
+  dds_instance_handle_t last_subscription_handle;  /**< DOC_TODO */
+}
+dds_publication_matched_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_LivelinessLost
+ * DOC_TODO
+ */
+typedef struct dds_liveliness_lost_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+}
+dds_liveliness_lost_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_SubscriptionMatched
+ * DOC_TODO
+ */
+typedef struct dds_subscription_matched_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  uint32_t current_count;  /**< DOC_TODO */
+  int32_t current_count_change;  /**< DOC_TODO */
+  dds_instance_handle_t last_publication_handle;  /**< DOC_TODO */
+}
+dds_subscription_matched_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief Rejected Status
+ * DOC_TODO
+ */
+typedef enum
+{
+  DDS_NOT_REJECTED,  /**< DOC_TODO */
+  DDS_REJECTED_BY_INSTANCES_LIMIT,  /**< DOC_TODO */
+  DDS_REJECTED_BY_SAMPLES_LIMIT,  /**< DOC_TODO */
+  DDS_REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT  /**< DOC_TODO */
+}
+dds_sample_rejected_status_kind;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_SampleRejected
+ * DOC_TODO
+ */
+typedef struct dds_sample_rejected_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  dds_sample_rejected_status_kind last_reason;  /**< DOC_TODO */
+  dds_instance_handle_t last_instance_handle;  /**< DOC_TODO */
+}
+dds_sample_rejected_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_LivelinessChanged
+ * DOC_TODO
+ */
+typedef struct dds_liveliness_changed_status
+{
+  uint32_t alive_count;  /**< DOC_TODO */
+  uint32_t not_alive_count;  /**< DOC_TODO */
+  int32_t alive_count_change;  /**< DOC_TODO */
+  int32_t not_alive_count_change;  /**< DOC_TODO */
+  dds_instance_handle_t last_publication_handle;  /**< DOC_TODO */
+}
+dds_liveliness_changed_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_RequestedDeadlineMissed
+ * DOC_TODO
+ */
+typedef struct dds_requested_deadline_missed_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  dds_instance_handle_t last_instance_handle;  /**< DOC_TODO */
+}
+dds_requested_deadline_missed_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_RequestedIncompatibleQoS
+ * DOC_TODO
+ */
+typedef struct dds_requested_incompatible_qos_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+  uint32_t last_policy_id;  /**< DOC_TODO */
+}
+dds_requested_incompatible_qos_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_SampleLost
+ * DOC_TODO
+ */
+typedef struct dds_sample_lost_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+}
+dds_sample_lost_status_t;
+
+/**
+ * @ingroup dcps_status
+ * @brief DCPS_Status_InconsistentTopic
+ * DOC_TODO
+ */
+typedef struct dds_inconsistent_topic_status
+{
+  uint32_t total_count;  /**< DOC_TODO */
+  int32_t total_count_change;  /**< DOC_TODO */
+}
+dds_inconsistent_topic_status_t;
+
+
+/**
+ * @defgroup dcps_status_getters (DCPS Status Getters)
+ * @ingroup dcps_status
+ * get_<status> APIs return the status of an entity and resets the status
+*/
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get INCONSISTENT_TOPIC status
+ *
+ * This operation gets the status value corresponding to INCONSISTENT_TOPIC
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  topic  The entity to get the status
+ * @param[out] status The pointer to @ref dds_inconsistent_topic_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_inconsistent_topic_status (
+  dds_entity_t topic,
+  dds_inconsistent_topic_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get PUBLICATION_MATCHED status
+ *
+ * This operation gets the status value corresponding to PUBLICATION_MATCHED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  writer  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_publication_matched_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_publication_matched_status (
+  dds_entity_t writer,
+  dds_publication_matched_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get LIVELINESS_LOST status
+ *
+ * This operation gets the status value corresponding to LIVELINESS_LOST
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  writer  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_liveliness_lost_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_liveliness_lost_status (
+  dds_entity_t writer,
+  dds_liveliness_lost_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get OFFERED_DEADLINE_MISSED status
+ *
+ * This operation gets the status value corresponding to OFFERED_DEADLINE_MISSED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  writer  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_offered_deadline_missed_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_offered_deadline_missed_status(
+  dds_entity_t writer,
+  dds_offered_deadline_missed_status_t *status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get OFFERED_INCOMPATIBLE_QOS status
+ *
+ * This operation gets the status value corresponding to OFFERED_INCOMPATIBLE_QOS
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  writer  The writer entity to get the status
+ * @param[out] status  The pointer to @ref dds_offered_incompatible_qos_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_offered_incompatible_qos_status (
+  dds_entity_t writer,
+  dds_offered_incompatible_qos_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get SUBSCRIPTION_MATCHED status
+ *
+ * This operation gets the status value corresponding to SUBSCRIPTION_MATCHED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The reader entity to get the status
+ * @param[out] status  The pointer to @ref dds_subscription_matched_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_subscription_matched_status (
+  dds_entity_t reader,
+  dds_subscription_matched_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get LIVELINESS_CHANGED status
+ *
+ * This operation gets the status value corresponding to LIVELINESS_CHANGED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_liveliness_changed_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_liveliness_changed_status (
+  dds_entity_t reader,
+  dds_liveliness_changed_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get SAMPLE_REJECTED status
+ *
+ * This operation gets the status value corresponding to SAMPLE_REJECTED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_sample_rejected_status_t to get the status
+ *
+ * @returns  0 - Success
+ * @returns <0 - Failure
+ *
+ * @retval DDS_RETCODE_ERROR
+ *                  An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *                  One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *                  The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *                  The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_sample_rejected_status (
+  dds_entity_t reader,
+  dds_sample_rejected_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get SAMPLE_LOST status
+ *
+ * This operation gets the status value corresponding to SAMPLE_LOST
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_sample_lost_status_t to get the status
+ *
+ * @returns A dds_return_t indicating success or failure
+ *
+ * @retval DDS_RETCODE_OK
+ *            Success
+ * @retval DDS_RETCODE_ERROR
+ *            An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *            One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *            The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *            The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_sample_lost_status (
+  dds_entity_t reader,
+  dds_sample_lost_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get REQUESTED_DEADLINE_MISSED status
+ *
+ * This operation gets the status value corresponding to REQUESTED_DEADLINE_MISSED
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_requested_deadline_missed_status_t to get the status
+ *
+ * @returns A dds_return_t indicating success or failure
+ *
+ * @retval DDS_RETCODE_OK
+ *            Success
+ * @retval DDS_RETCODE_ERROR
+ *            An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *            One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *            The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *            The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_requested_deadline_missed_status (
+  dds_entity_t reader,
+  dds_requested_deadline_missed_status_t * status);
+
+/**
+ * @ingroup dcps_status_getters
+ * @brief Get REQUESTED_INCOMPATIBLE_QOS status
+ *
+ * This operation gets the status value corresponding to REQUESTED_INCOMPATIBLE_QOS
+ * and reset the status. The value can be obtained, only if the status is enabled for an entity.
+ * NULL value for status is allowed and it will reset the trigger value when status is enabled.
+ *
+ * @param[in]  reader  The entity to get the status
+ * @param[out] status  The pointer to @ref dds_requested_incompatible_qos_status_t to get the status
+ *
+ * @returns A dds_return_t indicating success or failure
+ *
+ * @retval DDS_RETCODE_OK
+ *            Success
+ * @retval DDS_RETCODE_ERROR
+ *            An internal error has occurred.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *            One of the given arguments is not valid.
+ * @retval DDS_RETCODE_ILLEGAL_OPERATION
+ *            The operation is invoked on an inappropriate object.
+ * @retval DDS_RETCODE_ALREADY_DELETED
+ *            The entity has already been deleted.
+ */
+DDS_EXPORT dds_return_t
+dds_get_requested_incompatible_qos_status (
+  dds_entity_t reader,
+  dds_requested_incompatible_qos_status_t * status);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_rhc.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef _DDS_RHC_H_
+#define _DDS_RHC_H_
+
+#include "dds/ddsrt/static_assert.h"
+#include "dds/ddsi/ddsi_rhc.h"
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS /** DOC_TODO we should document the rhc */
+
+#define NO_STATE_MASK_SET   (DDS_ANY_STATE + 1)
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct dds_rhc;
+struct dds_readcond;
+struct dds_reader;
+struct ddsi_tkmap;
+
+typedef dds_return_t (*dds_rhc_associate_t) (struct dds_rhc *rhc, struct dds_reader *reader, const struct ddsi_sertype *type, struct ddsi_tkmap *tkmap);
+typedef int32_t (*dds_rhc_read_take_t) (struct dds_rhc *rhc, bool lock, void **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t mask, dds_instance_handle_t handle, struct dds_readcond *cond);
+typedef int32_t (*dds_rhc_read_take_cdr_t) (struct dds_rhc *rhc, bool lock, struct ddsi_serdata **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t sample_states, uint32_t view_states, uint32_t instance_states, dds_instance_handle_t handle);
+
+typedef bool (*dds_rhc_add_readcondition_t) (struct dds_rhc *rhc, struct dds_readcond *cond);
+typedef void (*dds_rhc_remove_readcondition_t) (struct dds_rhc *rhc, struct dds_readcond *cond);
+
+typedef uint32_t (*dds_rhc_lock_samples_t) (struct dds_rhc *rhc);
+
+struct dds_rhc_ops {
+  /* A copy of DDSI rhc ops comes first so we can use either interface without
+     additional indirections */
+  struct ddsi_rhc_ops rhc_ops;
+  dds_rhc_read_take_t read;
+  dds_rhc_read_take_t take;
+  dds_rhc_read_take_cdr_t readcdr;
+  dds_rhc_read_take_cdr_t takecdr;
+  dds_rhc_add_readcondition_t add_readcondition;
+  dds_rhc_remove_readcondition_t remove_readcondition;
+  dds_rhc_lock_samples_t lock_samples;
+  dds_rhc_associate_t associate;
+};
+
+struct dds_rhc {
+  union {
+    const struct dds_rhc_ops *ops;
+    struct ddsi_rhc rhc;
+  } common;
+};
+
+DDSRT_STATIC_ASSERT (offsetof (struct dds_rhc, common.ops) == offsetof (struct ddsi_rhc, ops));
+
+DDS_INLINE_EXPORT inline dds_return_t dds_rhc_associate (struct dds_rhc *rhc, struct dds_reader *reader, const struct ddsi_sertype *type, struct ddsi_tkmap *tkmap) {
+  return rhc->common.ops->associate (rhc, reader, type, tkmap);
+}
+DDS_INLINE_EXPORT inline bool dds_rhc_store (struct dds_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo, struct ddsi_serdata * __restrict sample, struct ddsi_tkmap_instance * __restrict tk) {
+  return rhc->common.ops->rhc_ops.store (&rhc->common.rhc, wrinfo, sample, tk);
+}
+DDS_INLINE_EXPORT inline void dds_rhc_unregister_wr (struct dds_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo) {
+  rhc->common.ops->rhc_ops.unregister_wr (&rhc->common.rhc, wrinfo);
+}
+DDS_INLINE_EXPORT inline void dds_rhc_relinquish_ownership (struct dds_rhc * __restrict rhc, const uint64_t wr_iid) {
+  rhc->common.ops->rhc_ops.relinquish_ownership (&rhc->common.rhc, wr_iid);
+}
+DDS_INLINE_EXPORT inline void dds_rhc_set_qos (struct dds_rhc *rhc, const struct dds_qos *qos) {
+  rhc->common.ops->rhc_ops.set_qos (&rhc->common.rhc, qos);
+}
+DDS_INLINE_EXPORT inline void dds_rhc_free (struct dds_rhc *rhc) {
+  rhc->common.ops->rhc_ops.free (&rhc->common.rhc);
+}
+DDS_INLINE_EXPORT inline int32_t dds_rhc_read (struct dds_rhc *rhc, bool lock, void **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t mask, dds_instance_handle_t handle, struct dds_readcond *cond) {
+  return (rhc->common.ops->read) (rhc, lock, values, info_seq, max_samples, mask, handle, cond);
+}
+DDS_INLINE_EXPORT inline int32_t dds_rhc_take (struct dds_rhc *rhc, bool lock, void **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t mask, dds_instance_handle_t handle, struct dds_readcond *cond) {
+  return rhc->common.ops->take (rhc, lock, values, info_seq, max_samples, mask, handle, cond);
+}
+DDS_INLINE_EXPORT inline int32_t dds_rhc_readcdr (struct dds_rhc *rhc, bool lock, struct ddsi_serdata **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t sample_states, uint32_t view_states, uint32_t instance_states, dds_instance_handle_t handle) {
+  return rhc->common.ops->readcdr (rhc, lock, values, info_seq, max_samples, sample_states, view_states, instance_states, handle);
+}
+DDS_INLINE_EXPORT inline int32_t dds_rhc_takecdr (struct dds_rhc *rhc, bool lock, struct ddsi_serdata **values, dds_sample_info_t *info_seq, uint32_t max_samples, uint32_t sample_states, uint32_t view_states, uint32_t instance_states, dds_instance_handle_t handle) {
+  return rhc->common.ops->takecdr (rhc, lock, values, info_seq, max_samples, sample_states, view_states, instance_states, handle);
+}
+DDS_INLINE_EXPORT inline bool dds_rhc_add_readcondition (struct dds_rhc *rhc, struct dds_readcond *cond) {
+  return rhc->common.ops->add_readcondition (rhc, cond);
+}
+DDS_INLINE_EXPORT inline void dds_rhc_remove_readcondition (struct dds_rhc *rhc, struct dds_readcond *cond) {
+  rhc->common.ops->remove_readcondition (rhc, cond);
+}
+DDS_INLINE_EXPORT inline uint32_t dds_rhc_lock_samples (struct dds_rhc *rhc) {
+  return rhc->common.ops->lock_samples (rhc);
+}
+
+DDS_EXPORT void dds_reader_data_available_cb (struct dds_reader *rd);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsc/dds_statistics.h

@@ -0,0 +1,133 @@
+/*
+ * Copyright(c) 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+
+#ifndef DDS_STATISTICS_H
+#define DDS_STATISTICS_H
+
+/**
+ * @defgroup statistics (DDS Statistics)
+ * @ingroup dds
+ * @warning Unstable API
+ *
+ * A quick-and-dirty provisional interface
+ */
+
+#include "dds/dds.h"
+#include "dds/ddsrt/attributes.h"
+#include "dds/export.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * @brief Kind of statistical value
+ * @ingroup statistics
+ */
+enum dds_stat_kind {
+  DDS_STAT_KIND_UINT32,          /**< value is a 32-bit unsigned integer */
+  DDS_STAT_KIND_UINT64,          /**< value is a 64-bit unsigned integer */
+  DDS_STAT_KIND_LENGTHTIME       /**< value is integral(length(t) dt) */
+};
+
+/**
+ * @brief KeyValue statistics entry
+ * @ingroup statistics
+ */
+struct dds_stat_keyvalue {
+  const char *name;              /**< name, memory owned by library */
+  enum dds_stat_kind kind;       /**< value type */
+  union {
+    uint32_t u32; /**< used if kind == DDS_STAT_KIND_UINT32 */
+    uint64_t u64; /**< used if kind == DDS_STAT_KIND_UINT64 */
+    uint64_t lengthtime; /**< used if kind == DDS_STAT_KIND_LENGTHTIME */
+  } u; /**< value */
+};
+
+/**
+ * @brief Statistics container
+ * @ingroup statistics
+ */
+struct dds_statistics {
+  dds_entity_t entity;           /**< handle of entity to which this set of values applies */
+  uint64_t opaque;               /**< internal data */
+  dds_time_t time;               /**< time stamp of latest call to dds_refresh_statistics() */
+  size_t count;                  /**< number of key-value pairs */
+  struct dds_stat_keyvalue kv[]; /**< data */
+};
+
+/**
+ * @brief Allocate a new statistics object for entity
+ * @ingroup statistics
+ *
+ * This allocates and populates a newly allocated `struct dds_statistics` for the
+ * specified entity.
+ *
+ * @param[in] entity       the handle of the entity
+ *
+ * @returns a newly allocated and populated statistics structure or NULL if entity is
+ * invalid or doesn't support any statistics.
+ */
+DDS_EXPORT struct dds_statistics *dds_create_statistics (dds_entity_t entity);
+
+/**
+ * @brief Update a previously created statistics structure with current values
+ * @ingroup statistics
+ *
+ * Only the time stamp and the values (and "opaque") may change.  The set of keys and the
+ * types of the values do not change.
+ *
+ * @param[in,out] stat     statistics structure to update the values of
+ *
+ * @returns success or an error indication
+ *
+ * @retval DDS_RETCODE_OK
+ *    the data was successfully updated
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *    stats is a null pointer or the referenced entity no longer exists
+ * @retval DDS_RETCODE_PRECONDITION_NOT_MET
+ *    library was deinitialized
+ */
+DDS_EXPORT dds_return_t dds_refresh_statistics (struct dds_statistics *stat);
+
+/**
+ * @brief Free a previously created statistics object
+ * @ingroup statistics
+ *
+ * This frees the statistics object.  Passing a null pointer is a no-op.  The operation
+ * succeeds also if the referenced entity no longer exists.
+ *
+ * @param[in] stat         statistics object to free
+ */
+DDS_EXPORT void dds_delete_statistics (struct dds_statistics *stat);
+
+/**
+ * @brief Lookup a specific value by name
+ * @ingroup statistics
+ *
+ * This looks up the specified name in the list of keys in `stat` and returns the address
+ * of the key-value pair if present, a null pointer if not.  If `stat` is a null pointer,
+ * it returns a null pointer.
+ *
+ * @param[in] stat         statistics object to lookup a name in (or NULL)
+ * @param[in] name         name to look for
+ *
+ * @returns The address of the key-value pair inside `stat`, or NULL if `stat` is NULL or
+ * `name` does not match a key in `stat.
+ */
+DDS_EXPORT const struct dds_stat_keyvalue *dds_lookup_statistic (const struct dds_statistics *stat, const char *name)
+  ddsrt_nonnull ((2));
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_acknack.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright(c) 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_ACKNACK_H
+#define DDSI_ACKNACK_H
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "dds/ddsrt/time.h"
+#include "dds/ddsi/q_xevent.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/q_protocol.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+enum add_AckNack_result {
+  AANR_SUPPRESSED_ACK,  //!< sending nothing: too short a time since the last ACK
+  AANR_ACK,             //!< sending an ACK and there's nothing to NACK
+  AANR_SUPPRESSED_NACK, //!< sending an ACK even though there are things to NACK
+  AANR_NACK,            //!< sending a NACK, possibly also a NACKFRAG
+  AANR_NACKFRAG_ONLY    //!< sending only a NACKFRAG
+};
+
+void sched_acknack_if_needed (struct xevent *ev, struct ddsi_proxy_writer *pwr, struct ddsi_pwr_rd_match *rwn, ddsrt_mtime_t tnow, bool avoid_suppressed_nack);
+
+struct nn_xmsg *make_and_resched_acknack (struct xevent *ev, struct ddsi_proxy_writer *pwr, struct ddsi_pwr_rd_match *rwn, ddsrt_mtime_t tnow, bool avoid_suppressed_nack);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_ACKNACK_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_builtin_topic_if.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright(c) 2019 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef _DDSI_BUILTIN_TOPIC_IF_H_
+#define _DDSI_BUILTIN_TOPIC_IF_H_
+
+#include "dds/ddsi/ddsi_vendor.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_entity_common;
+struct ddsi_tkmap_instance;
+struct ddsi_sertype;
+struct ddsi_guid;
+struct ddsi_topic_definition;
+
+struct ddsi_builtin_topic_interface {
+  void *arg;
+
+  bool (*builtintopic_is_builtintopic) (const struct ddsi_sertype *type, void *arg);
+  bool (*builtintopic_is_visible) (const struct ddsi_guid *guid, nn_vendorid_t vendorid, void *arg);
+  struct ddsi_tkmap_instance * (*builtintopic_get_tkmap_entry) (const struct ddsi_guid *guid, void *arg);
+  void (*builtintopic_write_endpoint) (const struct ddsi_entity_common *e, ddsrt_wctime_t timestamp, bool alive, void *arg);
+  void (*builtintopic_write_topic) (const struct ddsi_topic_definition *tpd, ddsrt_wctime_t timestamp, bool alive, void *arg);
+};
+
+DDS_INLINE_EXPORT inline bool builtintopic_is_visible (const struct ddsi_builtin_topic_interface *btif, const struct ddsi_guid *guid, nn_vendorid_t vendorid) {
+  return btif ? btif->builtintopic_is_visible (guid, vendorid, btif->arg) : false;
+}
+DDS_INLINE_EXPORT inline bool builtintopic_is_builtintopic (const struct ddsi_builtin_topic_interface *btif, const struct ddsi_sertype *type) {
+  return btif ? btif->builtintopic_is_builtintopic (type, btif->arg) : false;
+}
+DDS_INLINE_EXPORT inline struct ddsi_tkmap_instance *builtintopic_get_tkmap_entry (const struct ddsi_builtin_topic_interface *btif, const struct ddsi_guid *guid) {
+  return btif ? btif->builtintopic_get_tkmap_entry (guid, btif->arg) : NULL;
+}
+DDS_INLINE_EXPORT inline void builtintopic_write_endpoint (const struct ddsi_builtin_topic_interface *btif, const struct ddsi_entity_common *e, ddsrt_wctime_t timestamp, bool alive) {
+  if (btif) btif->builtintopic_write_endpoint (e, timestamp, alive, btif->arg);
+}
+DDS_INLINE_EXPORT inline void builtintopic_write_topic (const struct ddsi_builtin_topic_interface *btif, const struct ddsi_topic_definition *tpd, ddsrt_wctime_t timestamp, bool alive) {
+  if (btif) btif->builtintopic_write_topic (tpd, timestamp, alive, btif->arg);
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_cdrstream.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_CDRSTREAM_H
+#define DDSI_CDRSTREAM_H
+
+#include "dds/ddsrt/static_assert.h"
+#include "dds/ddsi/ddsi_serdata.h"
+#include "dds/ddsi/ddsi_serdata_default.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define DDSI_CDRSTREAM_MAX_NESTING_DEPTH 32  /* maximum level of nesting for key extraction */
+
+typedef struct dds_istream {
+  const unsigned char *m_buffer;
+  uint32_t m_size;          /* Buffer size */
+  uint32_t m_index;         /* Read/write offset from start of buffer */
+  uint32_t m_xcdr_version;  /* XCDR version of the data */
+} dds_istream_t;
+
+typedef struct dds_ostream {
+  unsigned char *m_buffer;
+  uint32_t m_size;          /* Buffer size */
+  uint32_t m_index;         /* Read/write offset from start of buffer */
+  uint32_t m_xcdr_version;  /* XCDR version to use for serializing data */
+} dds_ostream_t;
+
+typedef struct dds_ostreamBE {
+  dds_ostream_t x;
+} dds_ostreamBE_t;
+
+typedef struct dds_ostreamLE {
+  dds_ostream_t x;
+} dds_ostreamLE_t;
+
+DDSRT_STATIC_ASSERT (offsetof (dds_ostreamLE_t, x) == 0);
+DDSRT_STATIC_ASSERT (offsetof (dds_ostreamBE_t, x) == 0);
+
+DDS_EXPORT void dds_istream_init (dds_istream_t * __restrict st, uint32_t size, const void * __restrict input, uint32_t xcdr_version);
+DDS_EXPORT void dds_istream_fini (dds_istream_t * __restrict st);
+DDS_EXPORT void dds_ostream_init (dds_ostream_t * __restrict st, uint32_t size, uint32_t xcdr_version);
+DDS_EXPORT void dds_ostream_fini (dds_ostream_t * __restrict st);
+DDS_EXPORT void dds_ostreamLE_init (dds_ostreamLE_t * __restrict st, uint32_t size, uint32_t xcdr_version);
+DDS_EXPORT void dds_ostreamLE_fini (dds_ostreamLE_t * __restrict st);
+DDS_EXPORT void dds_ostreamBE_init (dds_ostreamBE_t * __restrict st, uint32_t size, uint32_t xcdr_version);
+DDS_EXPORT void dds_ostreamBE_fini (dds_ostreamBE_t * __restrict st);
+
+// *actual_size is set to the actual size of the data (*actual_size <= size) on successful return
+DDS_EXPORT bool dds_stream_normalize (void * __restrict data, uint32_t size, bool bswap, uint32_t xcdr_version, const struct ddsi_sertype_default * __restrict type, bool just_key, uint32_t * __restrict actual_size) ddsrt_attribute_warn_unused_result ddsrt_nonnull_all;
+DDS_EXPORT const uint32_t *dds_stream_normalize_data (char * __restrict data, uint32_t * __restrict off, uint32_t size, bool bswap, uint32_t xcdr_version, const uint32_t * __restrict ops) ddsrt_attribute_warn_unused_result ddsrt_nonnull_all;
+
+DDS_EXPORT const uint32_t *dds_stream_write (dds_ostream_t * __restrict os, const char * __restrict data, const uint32_t * __restrict ops);
+DDS_EXPORT const uint32_t *dds_stream_writeLE (dds_ostreamLE_t * __restrict os, const char * __restrict data, const uint32_t * __restrict ops);
+DDS_EXPORT const uint32_t *dds_stream_writeBE (dds_ostreamBE_t * __restrict os, const char * __restrict data, const uint32_t * __restrict ops);
+DDS_EXPORT const uint32_t * dds_stream_write_with_byte_order (dds_ostream_t * __restrict os, const char * __restrict data, const uint32_t * __restrict ops, enum ddsrt_byte_order_selector bo);
+DDS_EXPORT bool dds_stream_write_sample (dds_ostream_t * __restrict os, const void * __restrict data, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT bool dds_stream_write_sampleLE (dds_ostreamLE_t * __restrict os, const void * __restrict data, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT bool dds_stream_write_sampleBE (dds_ostreamBE_t * __restrict os, const void * __restrict data, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT void dds_stream_read_sample (dds_istream_t * __restrict is, void * __restrict data, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT void dds_stream_free_sample (void * __restrict data, const uint32_t * __restrict ops);
+
+DDS_EXPORT uint32_t dds_stream_countops (const uint32_t * __restrict ops, uint32_t nkeys, const dds_key_descriptor_t * __restrict keys);
+DDS_EXPORT size_t dds_stream_check_optimize (const struct ddsi_sertype_default_desc * __restrict desc, uint32_t xcdr_version);
+DDS_EXPORT void dds_istream_from_serdata_default (dds_istream_t * __restrict s, const struct ddsi_serdata_default * __restrict d);
+DDS_EXPORT void dds_ostream_from_serdata_default (dds_ostream_t * __restrict s, const struct ddsi_serdata_default * __restrict d);
+DDS_EXPORT void dds_ostream_add_to_serdata_default (dds_ostream_t * __restrict s, struct ddsi_serdata_default ** __restrict d);
+
+DDS_EXPORT void dds_stream_write_key (dds_ostream_t * __restrict os, const char * __restrict sample, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT void dds_stream_write_keyBE (dds_ostreamBE_t * __restrict os, const char * __restrict sample, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT bool dds_stream_extract_key_from_data (dds_istream_t * __restrict is, dds_ostream_t * __restrict os, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT void dds_stream_extract_key_from_key (dds_istream_t * __restrict is, dds_ostream_t * __restrict os, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT bool dds_stream_extract_keyBE_from_data (dds_istream_t * __restrict is, dds_ostreamBE_t * __restrict os, const struct ddsi_sertype_default * __restrict type);
+DDS_EXPORT void dds_stream_extract_keyBE_from_key (dds_istream_t * __restrict is, dds_ostreamBE_t * __restrict os, const struct ddsi_sertype_default * __restrict type);
+
+DDS_EXPORT const uint32_t *dds_stream_read (dds_istream_t * __restrict is, char * __restrict data, const uint32_t * __restrict ops);
+DDS_EXPORT void dds_stream_read_key (dds_istream_t * __restrict is, char * __restrict sample, const struct ddsi_sertype_default * __restrict type);
+
+DDS_EXPORT size_t dds_stream_print_key (dds_istream_t * __restrict is, const struct ddsi_sertype_default * __restrict type, char * __restrict buf, size_t size);
+
+DDS_EXPORT size_t dds_stream_print_sample (dds_istream_t * __restrict is, const struct ddsi_sertype_default * __restrict type, char * __restrict buf, size_t size);
+
+DDS_EXPORT uint16_t dds_stream_minimum_xcdr_version (const uint32_t * __restrict ops);
+DDS_EXPORT uint32_t dds_stream_type_nesting_depth (const uint32_t * __restrict ops);
+DDS_EXPORT bool dds_stream_extensibility (const uint32_t * __restrict ops, enum ddsi_sertype_extensibility *ext);
+
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_cfgunits.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright(c) 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_CFGUNITS_H
+#define DDSI_CFGUNITS_H
+
+static const struct cfgunit cfgunits[] = {
+  UNIT("bandwidth",
+    DESCRIPTION(
+      "<p>The unit must be specified explicitly. Recognised units: "
+      "<i>X</i>b/s, <i>X</i>bps for bits/s or <i>X</i>B/s, <i>X</i>Bps for "
+      "bytes/s; where <i>X</i> is an optional prefix: k for 10<sup>3</sup>, "
+      "Ki for 2<sup>10</sup>, M for 10<sup>6</sup>, Mi for 2<sup>20</sup>, "
+      "G for 10<sup>9</sup>, Gi for 2<sup>30</sup>.</p>"),
+    PATTERN(
+      "0|(\\d+(\\.\\d*)?([Ee][\\-+]?\\d+)?|\\.\\d+([Ee][\\-+]?\\d+)?) *([kMG]i?)?[Bb][p/]s")),
+  UNIT("duration",
+    DESCRIPTION(
+      "<p>The unit must be specified explicitly. Recognised units: ns, us, ms, "
+      "s, min, hr, day.</p>"),
+    PATTERN(
+      "0|(\\d+(\\.\\d*)?([Ee][\\-+]?\\d+)?|\\.\\d+([Ee][\\-+]?\\d+)?) *([num]?s|min|hr|day)")),
+  UNIT("duration_inf",
+    DESCRIPTION(
+      "<p>Valid values are finite durations with an explicit unit or the "
+      "keyword 'inf' for infinity. Recognised units: ns, us, ms, s, min, hr, "
+      "day.</p>"),
+    PATTERN(
+      "inf|0|(\\d+(\\.\\d*)?([Ee][\\-+]?\\d+)?|\\.\\d+([Ee][\\-+]?\\d+)?) *([num]?s|min|hr|day)")),
+  UNIT("memsize",
+    DESCRIPTION(
+      "<p>The unit must be specified explicitly. Recognised units: B (bytes), "
+      "kB & KiB (2<sup>10</sup> bytes), MB & MiB (2<sup>20</sup> bytes), GB & "
+      "GiB (2<sup>30</sup> bytes).</p>"),
+    PATTERN(
+      "0|(\\d+(\\.\\d*)?([Ee][\\-+]?\\d+)?|\\.\\d+([Ee][\\-+]?\\d+)?) *([kMG]i?)?B")),
+  END_MARKER
+};
+
+#endif /* DDSI_CFGUNITS_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_config.h

@@ -0,0 +1,455 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_CONFIG_H
+#define DDSI_CONFIG_H
+
+#include <stdio.h>
+
+#include "dds/export.h"
+#include "dds/features.h"
+#include "dds/ddsrt/sched.h"
+#include "dds/ddsrt/random.h"
+#include "dds/ddsi/ddsi_portmapping.h"
+#include "dds/ddsi/ddsi_locator.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_config;
+
+/**
+ * @brief Default-initialize a configuration (unstable)
+ *
+ * @param[out]  cfg The configuration struct to be initialized.
+ */
+DDS_EXPORT void ddsi_config_init_default (struct ddsi_config *cfg);
+
+enum ddsi_standards_conformance {
+  DDSI_SC_PEDANTIC,
+  DDSI_SC_STRICT,
+  DDSI_SC_LAX
+};
+
+#define DDSI_SC_PEDANTIC_P(config) ((config).standards_conformance <= DDSI_SC_PEDANTIC)
+#define DDSI_SC_STRICT_P(config) ((config).standards_conformance <= DDSI_SC_STRICT)
+
+enum ddsi_besmode {
+  DDSI_BESMODE_FULL,
+  DDSI_BESMODE_WRITERS,
+  DDSI_BESMODE_MINIMAL
+};
+
+enum ddsi_retransmit_merging {
+  DDSI_REXMIT_MERGE_NEVER,
+  DDSI_REXMIT_MERGE_ADAPTIVE,
+  DDSI_REXMIT_MERGE_ALWAYS
+};
+
+enum ddsi_boolean_default {
+  DDSI_BOOLDEF_DEFAULT,
+  DDSI_BOOLDEF_FALSE,
+  DDSI_BOOLDEF_TRUE
+};
+
+#ifdef DDS_HAS_SHM
+enum ddsi_shm_loglevel {
+  DDSI_SHM_OFF = 0,
+  DDSI_SHM_FATAL,
+  DDSI_SHM_ERROR,
+  DDSI_SHM_WARN,
+  DDSI_SHM_INFO,
+  DDSI_SHM_DEBUG,
+  DDSI_SHM_VERBOSE
+};
+#endif
+
+#define DDSI_PARTICIPANT_INDEX_AUTO -1
+#define DDSI_PARTICIPANT_INDEX_NONE -2
+
+/* ddsi_config_listelem must be an overlay for all used listelem types */
+struct ddsi_config_listelem {
+  struct ddsi_config_listelem *next;
+};
+
+#ifdef DDS_HAS_NETWORK_PARTITIONS
+struct networkpartition_address {
+  struct networkpartition_address *next;
+  ddsi_locator_t loc;
+};
+
+struct ddsi_config_networkpartition_listelem {
+  struct ddsi_config_networkpartition_listelem *next;
+  char *name;
+  char *address_string;
+  struct networkpartition_address *uc_addresses;
+  struct networkpartition_address *asm_addresses;
+#ifdef DDS_HAS_SSM
+  struct networkpartition_address *ssm_addresses;
+#endif
+};
+
+struct ddsi_config_ignoredpartition_listelem {
+  struct ddsi_config_ignoredpartition_listelem *next;
+  char *DCPSPartitionTopic;
+};
+
+struct ddsi_config_partitionmapping_listelem {
+  struct ddsi_config_partitionmapping_listelem *next;
+  char *networkPartition;
+  char *DCPSPartitionTopic;
+  struct ddsi_config_networkpartition_listelem *partition;
+};
+#endif /* DDS_HAS_NETWORK_PARTITIONS */
+
+#ifdef DDS_HAS_NETWORK_CHANNELS
+struct ddsi_config_channel_listelem {
+  struct ddsi_config_channel_listelem *next;
+  char   *name;
+  int    priority;
+  int64_t resolution;
+#ifdef DDS_HAS_BANDWIDTH_LIMITING
+  uint32_t data_bandwidth_limit;
+  uint32_t auxiliary_bandwidth_limit;
+#endif
+  int    diffserv_field;
+  struct thread_state *channel_reader_thrst;  /* keeping an handle to the running thread for this channel */
+  struct nn_dqueue *dqueue; /* The handle of teh delivery queue servicing incoming data for this channel*/
+  struct xeventq *evq; /* The handle of the event queue servicing this channel*/
+  uint32_t queueId; /* the index of the networkqueue serviced by this channel*/
+  struct ddsi_tran_conn * transmit_conn; /* the connection used for sending data out via this channel */
+};
+#endif /* DDS_HAS_NETWORK_CHANNELS */
+
+struct ddsi_config_maybe_int32 {
+  int isdefault;
+  int32_t value;
+};
+
+struct ddsi_config_maybe_uint32 {
+  int isdefault;
+  uint32_t value;
+};
+
+struct ddsi_config_thread_properties_listelem {
+  struct ddsi_config_thread_properties_listelem *next;
+  char *name;
+  ddsrt_sched_t sched_class;
+  struct ddsi_config_maybe_int32 schedule_priority;
+  struct ddsi_config_maybe_uint32 stack_size;
+};
+
+struct ddsi_config_peer_listelem
+{
+  struct ddsi_config_peer_listelem *next;
+  char *peer;
+};
+
+struct ddsi_config_prune_deleted_ppant {
+  int64_t delay;
+  int enforce_delay;
+};
+
+/* allow multicast bits (default depends on network type): */
+#define DDSI_AMC_FALSE 0u
+#define DDSI_AMC_SPDP 1u
+#define DDSI_AMC_ASM 2u
+#ifdef DDS_HAS_SSM
+#define DDSI_AMC_SSM 4u
+#define DDSI_AMC_TRUE (DDSI_AMC_SPDP | DDSI_AMC_ASM | DDSI_AMC_SSM)
+#else
+#define DDSI_AMC_TRUE (DDSI_AMC_SPDP | DDSI_AMC_ASM)
+#endif
+#define DDSI_AMC_DEFAULT 0x80000000u
+
+/* FIXME: this should be fully dynamic ... but this is easier for a quick hack */
+enum ddsi_transport_selector {
+  DDSI_TRANS_DEFAULT, /* actually UDP, but this is so we can tell what has been set */
+  DDSI_TRANS_UDP,
+  DDSI_TRANS_UDP6,
+  DDSI_TRANS_TCP,
+  DDSI_TRANS_TCP6,
+  DDSI_TRANS_RAWETH,
+  DDSI_TRANS_NONE /* FIXME: see FIXME above ... :( */
+};
+
+enum ddsi_many_sockets_mode {
+  DDSI_MSM_NO_UNICAST,
+  DDSI_MSM_SINGLE_UNICAST,
+  DDSI_MSM_MANY_UNICAST
+};
+
+#ifdef DDS_HAS_SECURITY
+struct ddsi_plugin_library_properties {
+  char *library_path;
+  char *library_init;
+  char *library_finalize;
+};
+
+struct ddsi_authentication_properties {
+  char *identity_certificate;
+  char *identity_ca;
+  char *private_key;
+  char *password;
+  char *trusted_ca_dir;
+  char *crl;
+  int include_optional_fields;
+};
+
+struct ddsi_access_control_properties {
+  char *permissions;
+  char *permissions_ca;
+  char *governance;
+};
+
+struct ddsi_config_omg_security {
+  struct ddsi_authentication_properties authentication_properties;
+  struct ddsi_access_control_properties access_control_properties;
+  struct ddsi_plugin_library_properties authentication_plugin;
+  struct ddsi_plugin_library_properties access_control_plugin;
+  struct ddsi_plugin_library_properties cryptography_plugin;
+};
+
+struct ddsi_config_omg_security_listelem {
+  struct ddsi_config_omg_security_listelem *next;
+  struct ddsi_config_omg_security cfg;
+};
+#endif /* DDS_HAS_SECURITY */
+
+#ifdef DDS_HAS_SSL
+struct ddsi_config_ssl_min_version {
+  int major;
+  int minor;
+};
+#endif
+
+struct ddsi_config_socket_buf_size {
+  struct ddsi_config_maybe_uint32 min, max;
+};
+
+struct ddsi_config_network_interface {
+  int automatic;
+  char *name;
+  char *address;
+  int prefer_multicast;
+  int presence_required;
+  enum ddsi_boolean_default multicast;
+  struct ddsi_config_maybe_int32 priority;
+};
+
+struct ddsi_config_network_interface_listelem {
+  struct ddsi_config_network_interface_listelem *next;
+  struct ddsi_config_network_interface cfg;
+};
+
+enum ddsi_config_entity_naming_mode {
+  DDSI_ENTITY_NAMING_DEFAULT_EMPTY,
+  DDSI_ENTITY_NAMING_DEFAULT_FANCY
+};
+
+/* Expensive checks (compiled in when NDEBUG not defined, enabled only if flag set in xchecks) */
+#define DDSI_XCHECK_WHC 1u
+#define DDSI_XCHECK_RHC 2u
+#define DDSI_XCHECK_XEV 4u
+
+struct ddsi_config
+{
+  int valid;
+  uint32_t tracemask;
+  uint32_t enabled_xchecks;
+  char *pcap_file;
+
+  /* interfaces */
+  struct ddsi_config_network_interface_listelem *network_interfaces;
+
+  /* deprecated interface support */
+  char *depr_networkAddressString;
+  int depr_prefer_multicast;
+  char *depr_assumeMulticastCapable;
+
+  char **networkRecvAddressStrings;
+  uint32_t allowMulticast;
+  char *externalAddressString;
+  char *externalMaskString;
+  FILE *tracefp;
+  char *tracefile;
+  int tracingAppendToFile;
+  enum ddsi_transport_selector transport_selector;
+  enum ddsi_boolean_default compat_use_ipv6;
+  enum ddsi_boolean_default compat_tcp_enable;
+  int dontRoute;
+  int enableMulticastLoopback;
+  uint32_t domainId;
+  struct ddsi_config_maybe_uint32 extDomainId; // domain id advertised in discovery
+  char *domainTag;
+  int participantIndex;
+  int maxAutoParticipantIndex;
+  char *spdpMulticastAddressString;
+  char *defaultMulticastAddressString;
+  int64_t spdp_interval;
+  int64_t spdp_response_delay_max;
+  int64_t lease_duration;
+  int64_t const_hb_intv_sched;
+  int64_t const_hb_intv_sched_min;
+  int64_t const_hb_intv_sched_max;
+  int64_t const_hb_intv_min;
+  enum ddsi_retransmit_merging retransmit_merging;
+  int64_t retransmit_merging_period;
+  int squash_participants;
+  int liveliness_monitoring;
+  int noprogress_log_stacktraces;
+  int64_t liveliness_monitoring_interval;
+  int prioritize_retransmit;
+  enum ddsi_boolean_default multiple_recv_threads;
+  unsigned recv_thread_stop_maxretries;
+
+  unsigned primary_reorder_maxsamples;
+  unsigned secondary_reorder_maxsamples;
+
+  unsigned delivery_queue_maxsamples;
+
+  uint16_t fragment_size;
+  uint32_t max_msg_size;
+  uint32_t max_rexmit_msg_size;
+  uint32_t init_transmit_extra_pct;
+  uint32_t max_rexmit_burst_size;
+
+  int publish_uc_locators; /* Publish discovery unicast locators */
+  int enable_uc_locators; /* If false, don't even try to create a unicast socket */
+
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+  int enable_topic_discovery_endpoints;
+#endif
+
+  /* TCP transport configuration */
+  int tcp_nodelay;
+  int tcp_port;
+  int64_t tcp_read_timeout;
+  int64_t tcp_write_timeout;
+  int tcp_use_peeraddr_for_unicast;
+
+#ifdef DDS_HAS_SSL
+  /* SSL support for TCP */
+  int ssl_enable;
+  int ssl_verify;
+  int ssl_verify_client;
+  int ssl_self_signed;
+  char * ssl_keystore;
+  char * ssl_rand_file;
+  char * ssl_key_pass;
+  char * ssl_ciphers;
+  struct ddsi_config_ssl_min_version ssl_min_version;
+#endif
+
+#ifdef DDS_HAS_NETWORK_CHANNELS
+  struct ddsi_config_channel_listelem *channels;
+  struct ddsi_config_channel_listelem *max_channel; /* channel with highest prio; always computed */
+#endif /* DDS_HAS_NETWORK_CHANNELS */
+#ifdef DDS_HAS_NETWORK_PARTITIONS
+  struct ddsi_config_networkpartition_listelem *networkPartitions;
+  unsigned nof_networkPartitions;
+  struct ddsi_config_ignoredpartition_listelem *ignoredPartitions;
+  struct ddsi_config_partitionmapping_listelem *partitionMappings;
+#endif /* DDS_HAS_NETWORK_PARTITIONS */
+  struct ddsi_config_peer_listelem *peers;
+  struct ddsi_config_thread_properties_listelem *thread_properties;
+
+  /* debug/test/undoc features: */
+  int xmit_lossiness;           /**<< fraction of packets to drop on xmit, in units of 1e-3 */
+  uint32_t rmsg_chunk_size;          /**<< size of a chunk in the receive buffer */
+  uint32_t rbuf_size;                /* << size of a single receiver buffer */
+  enum ddsi_besmode besmode;
+  int meas_hb_to_ack_latency;
+  int unicast_response_to_spdp_messages;
+  int synchronous_delivery_priority_threshold;
+  int64_t synchronous_delivery_latency_bound;
+
+  /* Write cache */
+
+  int whc_batch;
+  uint32_t whc_lowwater_mark;
+  uint32_t whc_highwater_mark;
+  struct ddsi_config_maybe_uint32 whc_init_highwater_mark;
+  int whc_adaptive;
+
+  unsigned defrag_unreliable_maxsamples;
+  unsigned defrag_reliable_maxsamples;
+  unsigned accelerate_rexmit_block_size;
+  int64_t responsiveness_timeout;
+  uint32_t max_participants;
+  int64_t writer_linger_duration;
+  int multicast_ttl;
+  struct ddsi_config_socket_buf_size socket_rcvbuf_size;
+  struct ddsi_config_socket_buf_size socket_sndbuf_size;
+  int64_t ack_delay;
+  int64_t nack_delay;
+  int64_t preemptive_ack_delay;
+  int64_t schedule_time_rounding;
+  int64_t auto_resched_nack_delay;
+  int64_t ds_grace_period;
+#ifdef DDS_HAS_BANDWIDTH_LIMITING
+  uint32_t auxiliary_bandwidth_limit; /* bytes/second */
+#endif
+  uint32_t max_queued_rexmit_bytes;
+  unsigned max_queued_rexmit_msgs;
+  unsigned ddsi2direct_max_threads;
+  int late_ack_mode;
+  int retry_on_reject_besteffort;
+  int generate_keyhash;
+  uint32_t max_sample_size;
+
+  /* compability options */
+  enum ddsi_standards_conformance standards_conformance;
+  int explicitly_publish_qos_set_to_default;
+  enum ddsi_many_sockets_mode many_sockets_mode;
+  int assume_rti_has_pmd_endpoints;
+
+  struct ddsi_portmapping ports;
+
+  int monitor_port;
+
+  int enable_control_topic;
+  int initial_deaf;
+  int initial_mute;
+  int64_t initial_deaf_mute_reset;
+
+  int use_multicast_if_mreqn;
+  struct ddsi_config_prune_deleted_ppant prune_deleted_ppant;
+  int redundant_networking;
+
+#ifdef DDS_HAS_SECURITY
+  struct ddsi_config_omg_security_listelem *omg_security_configuration;
+#endif
+
+#ifdef DDS_HAS_SHM
+  int enable_shm;
+  char *shm_locator;
+  char *iceoryx_service;
+  enum ddsi_shm_loglevel shm_log_lvl;
+#endif
+
+  enum ddsi_config_entity_naming_mode entity_naming_mode;
+  ddsrt_prng_seed_t entity_naming_seed;
+
+#if defined (__cplusplus)
+public:
+  ddsi_config() {
+    ddsi_config_init_default (this);
+  }
+#endif
+};
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_CONFIG_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_config_impl.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef NN_CONFIG_H
+#define NN_CONFIG_H
+
+#include <stdio.h>
+
+#include "dds/ddsrt/attributes.h"
+#include "dds/ddsi/ddsi_config.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct cfgst;
+struct ddsrt_log_cfg;
+
+struct cfgst *ddsi_config_init (const char *config, struct ddsi_config *cfg, uint32_t domid) ddsrt_nonnull((1,2));
+void ddsi_config_print_cfgst (struct cfgst *cfgst, const struct ddsrt_log_cfg *logcfg);
+void ddsi_config_print_rawconfig (const struct ddsi_config *cfg, const struct ddsrt_log_cfg *logcfg);
+void ddsi_config_free_source_info (struct cfgst *cfgst);
+void ddsi_config_fini (struct cfgst *cfgst);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* NN_CONFIG_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_deadline.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_DEADLINE_H
+#define DDSI_DEADLINE_H
+
+#include "dds/ddsrt/circlist.h"
+#include "dds/ddsrt/time.h"
+#include "dds/ddsi/ddsi_domaingv.h"
+#include "dds/ddsi/q_xevent.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef ddsrt_mtime_t (*deadline_missed_cb_t)(void *hc, ddsrt_mtime_t tnow);
+
+struct deadline_adm {
+  struct ddsrt_circlist list;               /* linked list for deadline missed */
+  struct xevent *evt;                       /* xevent that triggers when deadline expires for an instance */
+  deadline_missed_cb_t deadline_missed_cb;  /* callback for deadline missed; this cb can use deadline_next_missed_locked to get next instance that has a missed deadline */
+  size_t list_offset;                       /* offset of deadline_adm element in whc or rhc */
+  size_t elem_offset;                       /* offset of deadline_elem element in whc or rhc instance */
+  dds_duration_t dur;                       /* deadline duration */
+};
+
+struct deadline_elem {
+  struct ddsrt_circlist_elem e;
+  ddsrt_mtime_t t_deadline;
+};
+
+DDS_EXPORT void deadline_init (const struct ddsi_domaingv *gv, struct deadline_adm *deadline_adm, size_t list_offset, size_t elem_offset, deadline_missed_cb_t deadline_missed_cb);
+DDS_EXPORT void deadline_stop (const struct deadline_adm *deadline_adm);
+DDS_EXPORT void deadline_clear (struct deadline_adm *deadline_adm);
+DDS_EXPORT void deadline_fini (const struct deadline_adm *deadline_adm);
+DDS_EXPORT ddsrt_mtime_t deadline_next_missed_locked (struct deadline_adm *deadline_adm, ddsrt_mtime_t tnow, void **instance);
+DDS_EXPORT void deadline_register_instance_real (struct deadline_adm *deadline_adm, struct deadline_elem *elem, ddsrt_mtime_t tprev, ddsrt_mtime_t tnow);
+DDS_EXPORT void deadline_unregister_instance_real (struct deadline_adm *deadline_adm, struct deadline_elem *elem);
+DDS_EXPORT void deadline_renew_instance_real (struct deadline_adm *deadline_adm, struct deadline_elem *elem);
+
+DDS_INLINE_EXPORT inline void deadline_register_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem, ddsrt_mtime_t tnow)
+{
+  if (deadline_adm->dur != DDS_INFINITY)
+    deadline_register_instance_real (deadline_adm, elem, tnow, tnow);
+}
+
+DDS_INLINE_EXPORT inline void deadline_reregister_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem, ddsrt_mtime_t tnow)
+{
+  if (deadline_adm->dur != DDS_INFINITY)
+    deadline_register_instance_real (deadline_adm, elem, elem->t_deadline, tnow);
+}
+
+DDS_INLINE_EXPORT inline void deadline_unregister_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem)
+{
+  if (deadline_adm->dur != DDS_INFINITY)
+  {
+    assert (elem->t_deadline.v != DDS_NEVER);
+    deadline_unregister_instance_real (deadline_adm, elem);
+  }
+}
+
+DDS_INLINE_EXPORT inline void deadline_renew_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem)
+{
+  if (deadline_adm->dur != DDS_INFINITY)
+  {
+    assert (elem->t_deadline.v != DDS_NEVER);
+    deadline_renew_instance_real (deadline_adm, elem);
+  }
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_DEADLINE_H */
+

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_deliver_locally.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright(c) 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_DELIVER_LOCALLY_H
+#define DDSI_DELIVER_LOCALLY_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "dds/export.h"
+#include "dds/ddsrt/retcode.h"
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsi/ddsi_guid.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_domaingv;
+struct ddsi_tkmap_instance;
+struct ddsi_sertype;
+struct ddsi_serdata;
+struct entity_index;
+struct ddsi_reader;
+struct ddsi_entity_common;
+struct ddsi_writer_info;
+struct ddsi_local_reader_ary;
+
+typedef struct ddsi_serdata * (*deliver_locally_makesample_t) (struct ddsi_tkmap_instance **tk, struct ddsi_domaingv *gv, struct ddsi_sertype const * const type, void *vsourceinfo);
+typedef struct ddsi_reader * (*deliver_locally_first_reader_t) (struct entity_index *entity_index, struct ddsi_entity_common *source_entity, ddsrt_avl_iter_t *it);
+typedef struct ddsi_reader * (*deliver_locally_next_reader_t) (struct entity_index *entity_index, ddsrt_avl_iter_t *it);
+
+/** return:
+    - DDS_RETCODE_OK to try again immediately
+    - DDS_RETCODE_TRY_AGAIN to complete restart the operation later
+    - anything else: error to be returned from deliver_locally_xxx */
+typedef dds_return_t (*deliver_locally_on_failure_fastpath_t) (struct ddsi_entity_common *source_entity, bool source_entity_locked, struct ddsi_local_reader_ary *fastpath_rdary, void *vsourceinfo);
+
+struct deliver_locally_ops {
+  deliver_locally_makesample_t makesample;
+  deliver_locally_first_reader_t first_reader;
+  deliver_locally_next_reader_t next_reader;
+  deliver_locally_on_failure_fastpath_t on_failure_fastpath;
+};
+
+dds_return_t deliver_locally_one (struct ddsi_domaingv *gv, struct ddsi_entity_common *source_entity, bool source_entity_locked, const ddsi_guid_t *rdguid, const struct ddsi_writer_info *wrinfo, const struct deliver_locally_ops * __restrict ops, void *vsourceinfo);
+
+dds_return_t deliver_locally_allinsync (struct ddsi_domaingv *gv, struct ddsi_entity_common *source_entity, bool source_entity_locked, struct ddsi_local_reader_ary *fastpath_rdary, const struct ddsi_writer_info *wrinfo, const struct deliver_locally_ops * __restrict ops, void *vsourceinfo);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_DELIVER_LOCALLY_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_domaingv.h

@@ -0,0 +1,357 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_DOMAINGV_H
+#define DDSI_DOMAINGV_H
+
+#include <stdio.h>
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/atomics.h"
+#include "dds/ddsrt/sockets.h"
+#include "dds/ddsrt/sync.h"
+#include "dds/ddsrt/fibheap.h"
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsrt/random.h"
+
+#include "dds/ddsi/ddsi_plist.h"
+#include "dds/ddsi/ddsi_ownip.h"
+#include "dds/ddsi/q_protocol.h"
+#include "dds/ddsi/q_sockwaitset.h"
+#include "dds/ddsi/ddsi_config_impl.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct nn_xmsgpool;
+struct serdatapool;
+struct nn_dqueue;
+struct nn_reorder;
+struct nn_defrag;
+struct addrset;
+struct xeventq;
+struct gcreq_queue;
+struct entity_index;
+struct lease;
+struct ddsi_tran_conn;
+struct ddsi_tran_listener;
+struct ddsi_tran_factory;
+struct debug_monitor;
+struct ddsi_tkmap;
+struct dds_security_context;
+struct dds_security_match_index;
+struct ddsi_hsadmin;
+
+typedef struct config_in_addr_node {
+   ddsi_locator_t loc;
+   struct config_in_addr_node *next;
+} config_in_addr_node;
+
+enum recvips_mode {
+  RECVIPS_MODE_ALL,             /* all MC capable interfaces */
+  RECVIPS_MODE_ANY,             /* kernel-default interface */
+  RECVIPS_MODE_PREFERRED,       /* selected interface only */
+  RECVIPS_MODE_NONE,            /* no interfaces at all */
+  RECVIPS_MODE_SOME             /* explicit list of interfaces; only one requiring recvips */
+};
+
+enum recv_thread_mode {
+  RTM_SINGLE,
+  RTM_MANY
+};
+
+struct recv_thread_arg {
+  enum recv_thread_mode mode;
+  struct nn_rbufpool *rbpool;
+  struct ddsi_domaingv *gv;
+  union {
+    struct {
+      const ddsi_locator_t *loc;
+      struct ddsi_tran_conn *conn;
+    } single;
+    struct {
+      os_sockWaitset ws;
+    } many;
+  } u;
+};
+
+struct deleted_participants_admin;
+
+struct ddsi_domaingv {
+  volatile int terminate;
+  volatile int deaf;
+  volatile int mute;
+
+  struct ddsrt_log_cfg logconfig;
+  struct ddsi_config config;
+
+  struct ddsi_tkmap * m_tkmap;
+
+  /* Hash tables for participants, readers, writers, proxy
+     participants, proxy readers and proxy writers by GUID. */
+  struct entity_index *entity_index;
+
+  /* Timed events admin */
+  struct xeventq *xevents;
+
+  /* Queue for garbage collection requests */
+  struct gcreq_queue *gcreq_queue;
+
+  /* Lease junk */
+  ddsrt_mutex_t leaseheap_lock;
+  ddsrt_fibheap_t leaseheap;
+
+  /* Transport factories & selected factory */
+  struct ddsi_tran_factory *ddsi_tran_factories;
+  struct ddsi_tran_factory *m_factory;
+
+  /* Connections for multicast discovery & data, and those that correspond
+     to the one DDSI participant index that the DDSI2 service uses. The
+     DCPS participant of DDSI2 itself will be mirrored in a DDSI
+     participant, and in multi-socket mode that one gets its own
+     socket. */
+  struct ddsi_tran_conn * disc_conn_mc;
+  struct ddsi_tran_conn * data_conn_mc;
+  struct ddsi_tran_conn * disc_conn_uc;
+  struct ddsi_tran_conn * data_conn_uc;
+
+  /* Connection used for all output (for connectionless transports), this
+     used to simply be data_conn_uc, but:
+
+     - Windows has a quirk that makes multicast delivery within a machine
+       utterly unreliable if the transmitting socket is bound to 0.0.0.0
+       (despite all sockets having multicast interfaces set correctly),
+       but apparently only in the presence of sockets transmitting to the
+       same multicast group that have been bound to non-0.0.0.0 ...
+     - At least Fast-RTPS and Connext fail to honour the set of advertised
+       addresses and substitute 127.0.0.1 for the advertised IP address and
+       expect it to work.
+     - Fast-RTPS (at least) binds the socket it uses for transmitting
+       multicasts to non-0.0.0.0
+
+     So binding to 0.0.0.0 means the unicasts from Fast-RTPS & Connext will
+     arrive but the multicasts from Cyclone get dropped often on Windows
+     when trying to interoperate; and binding to the IP address means
+     unicast messages from the others fail to arrive (because they fail to
+     arrive).
+
+     The only work around is to use a separate socket for sending.  It is
+     rather sad that Cyclone needs to work around the bugs of the others,
+     but it seems the only way to get the users what they expect. */
+#define MAX_XMIT_CONNS 4
+  struct ddsi_tran_conn * xmit_conns[MAX_XMIT_CONNS];
+  ddsi_xlocator_t intf_xlocators[MAX_XMIT_CONNS];
+
+  /* TCP listener */
+  struct ddsi_tran_listener * listener;
+
+  /* In many sockets mode, the receive threads maintain a local array
+     with participant GUIDs and sockets, participant_set_generation is
+     used to notify them. */
+  ddsrt_atomic_uint32_t participant_set_generation;
+
+  /* nparticipants is used primarily for limiting the number of active
+     participants, but also during shutdown to determine when it is
+     safe to stop the GC thread. */
+  ddsrt_mutex_t participant_set_lock;
+  ddsrt_cond_t participant_set_cond;
+  uint32_t nparticipants;
+
+  /* For participants without (some) built-in writers, we fall back to
+     this participant, which is the first one created with all
+     built-in writers present.  It MUST be created before any in need
+     of it pops up! */
+  struct ddsi_participant *privileged_pp;
+  ddsrt_mutex_t privileged_pp_lock;
+
+  /* For tracking (recently) deleted participants */
+  struct deleted_participants_admin *deleted_participants;
+
+  /* GUID to be used in next call to new_participant; also protected
+     by privileged_pp_lock */
+  struct ddsi_guid ppguid_base;
+
+  /* number of selected interfaces. */
+  int n_interfaces;
+  struct nn_interface interfaces[MAX_XMIT_CONNS];
+  /* whether we're using a link-local address (and therefore
+     only listening to multicasts on that interface) */
+  int using_link_local_intf;
+
+  /* Addressing: actual own (preferred) IP address, IP address
+     advertised in discovery messages (so that an external IP address on
+     a NAT may be advertised), and the DDSI multi-cast address. */
+  enum recvips_mode recvips_mode;
+  struct config_in_addr_node *recvips;
+  ddsi_locator_t extmask;
+
+  /* Locators */
+
+  ddsi_locator_t loc_spdp_mc;
+  ddsi_locator_t loc_meta_mc;
+  ddsi_locator_t loc_meta_uc;
+  ddsi_locator_t loc_default_mc;
+  ddsi_locator_t loc_default_uc;
+#ifdef DDS_HAS_SHM
+  ddsi_locator_t loc_iceoryx_addr;
+#endif
+
+  /*
+    Initial discovery address set, and the current discovery address
+    set. These are the addresses that SPDP pings get sent to.
+  */
+  struct addrset *as_disc;
+
+  ddsrt_mutex_t lock;
+
+  /* Receive thread. (We can only has one for now, cos of the signal
+     trigger socket.) Receive buffer pool is per receive thread,
+     it is only a global variable because it needs to be freed way later
+     than the receive thread itself terminates */
+#define MAX_RECV_THREADS 3
+  uint32_t n_recv_threads;
+  struct recv_thread {
+    const char *name;
+    struct thread_state *thrst;
+    struct recv_thread_arg arg;
+  } recv_threads[MAX_RECV_THREADS];
+
+  /* Listener thread for connection based transports */
+  struct thread_state *listen_ts;
+
+  /* Flag cleared when stopping (receive threads). FIXME. */
+  ddsrt_atomic_uint32_t rtps_keepgoing;
+
+  /* Start time of the DDSI2 service, for logging relative time stamps,
+     should I ever so desire. */
+  ddsrt_wctime_t tstart;
+
+  /* Default QoSs for participant, readers and writers (needed for
+     eliminating default values in outgoing discovery packets, and for
+     supplying values for missing QoS settings in incoming discovery
+     packets); plus the actual QoSs needed for the builtin
+     endpoints. */
+  ddsi_plist_t default_local_plist_pp;
+  dds_qos_t spdp_endpoint_xqos;
+  dds_qos_t builtin_endpoint_xqos_rd;
+  dds_qos_t builtin_endpoint_xqos_wr;
+#ifdef DDS_HAS_TYPE_DISCOVERY
+  dds_qos_t builtin_volatile_xqos_rd;
+  dds_qos_t builtin_volatile_xqos_wr;
+#endif
+#ifdef DDS_HAS_SECURITY
+  dds_qos_t builtin_secure_volatile_xqos_rd;
+  dds_qos_t builtin_secure_volatile_xqos_wr;
+  dds_qos_t builtin_stateless_xqos_rd;
+  dds_qos_t builtin_stateless_xqos_wr;
+#endif
+
+  /* SPDP packets get very special treatment (they're the only packets
+     we accept from writers we don't know) and have their very own
+     do-nothing defragmentation and reordering thingummies, as well as a
+     global mutex to in lieu of the proxy writer lock. */
+  ddsrt_mutex_t spdp_lock;
+  struct nn_defrag *spdp_defrag;
+  struct nn_reorder *spdp_reorder;
+
+  /* Built-in stuff other than SPDP gets funneled through the builtins
+     delivery queue; currently just SEDP and PMD */
+  struct nn_dqueue *builtins_dqueue;
+
+  struct debug_monitor *debmon;
+
+#ifndef DDS_HAS_NETWORK_CHANNELS
+  uint32_t networkQueueId;
+  struct thread_state *channel_reader_thrst;
+
+  /* Application data gets its own delivery queue */
+  struct nn_dqueue *user_dqueue;
+#endif
+
+  /* Transmit side: pools for the serializer & transmit messages and a
+     transmit queue*/
+  struct serdatapool *serpool;
+  struct nn_xmsgpool *xmsgpool;
+  struct ddsi_sertype *spdp_type; /* key = participant GUID */
+  struct ddsi_sertype *sedp_reader_type; /* key = endpoint GUID */
+  struct ddsi_sertype *sedp_writer_type; /* key = endpoint GUID */
+  struct ddsi_sertype *sedp_topic_type; /* key = topic GUID */
+  struct ddsi_sertype *pmd_type; /* participant message data */
+#ifdef DDS_HAS_TYPE_DISCOVERY
+  struct ddsi_sertype *tl_svc_request_type; /* TypeLookup service request, no key */
+  struct ddsi_sertype *tl_svc_reply_type; /* TypeLookup service reply, no key */
+#endif
+#ifdef DDS_HAS_SECURITY
+  struct ddsi_sertype *spdp_secure_type; /* key = participant GUID */
+  struct ddsi_sertype *sedp_reader_secure_type; /* key = endpoint GUID */
+  struct ddsi_sertype *sedp_writer_secure_type; /* key = endpoint GUID */
+  struct ddsi_sertype *pmd_secure_type; /* participant message data */
+  struct ddsi_sertype *pgm_stateless_type; /* participant generic message */
+  struct ddsi_sertype *pgm_volatile_type; /* participant generic message */
+#endif
+
+  ddsrt_mutex_t sendq_lock;
+  ddsrt_cond_t sendq_cond;
+  unsigned sendq_length;
+  struct nn_xpack *sendq_head;
+  struct nn_xpack *sendq_tail;
+  int sendq_stop;
+  struct thread_state *sendq_ts;
+  bool sendq_running;
+  ddsrt_mutex_t sendq_running_lock;
+
+  /* File for dumping captured packets, NULL if disabled */
+  FILE *pcap_fp;
+  ddsrt_mutex_t pcap_lock;
+
+  struct ddsi_builtin_topic_interface *builtin_topic_interface;
+
+  struct nn_group_membership *mship;
+
+  ddsrt_mutex_t sertypes_lock;
+  struct ddsrt_hh *sertypes;
+
+#ifdef DDS_HAS_TYPE_DISCOVERY
+  ddsrt_mutex_t typelib_lock;
+  ddsrt_avl_tree_t typelib;
+  ddsrt_avl_tree_t typedeps;
+  ddsrt_avl_tree_t typedeps_reverse;
+  ddsrt_cond_t typelib_resolved_cond;
+#endif
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+  ddsrt_mutex_t topic_defs_lock;
+  struct ddsrt_hh *topic_defs;
+#endif
+
+  ddsrt_mutex_t new_topic_lock;
+  ddsrt_cond_t new_topic_cond;
+  uint32_t new_topic_version;
+
+  /* security globals */
+#ifdef DDS_HAS_SECURITY
+  struct dds_security_context *security_context;
+  struct ddsi_hsadmin *hsadmin;
+  bool handshake_include_optional;
+#endif
+
+  /* naming */
+  ddsrt_mutex_t naming_lock;
+  ddsrt_prng_t naming_rng;
+};
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_DOMAINGV_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_endpoint.h

@@ -0,0 +1,237 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_ENDPOINT_H
+#define DDSI_ENDPOINT_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/fibheap.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_participant;
+struct ddsi_type_pair;
+struct ddsi_entity_common;
+struct ddsi_endpoint_common;
+struct dds_qos;
+
+/* Liveliness changed is more complicated than just add/remove. Encode the event
+   in ddsi_status_cb_data_t::extra and ignore ddsi_status_cb_data_t::add */
+enum ddsi_liveliness_changed_data_extra {
+  DDSI_LIVELINESS_CHANGED_ADD_ALIVE,
+  DDSI_LIVELINESS_CHANGED_ADD_NOT_ALIVE,
+  DDSI_LIVELINESS_CHANGED_REMOVE_NOT_ALIVE,
+  DDSI_LIVELINESS_CHANGED_REMOVE_ALIVE,
+  DDSI_LIVELINESS_CHANGED_ALIVE_TO_NOT_ALIVE,
+  DDSI_LIVELINESS_CHANGED_NOT_ALIVE_TO_ALIVE
+};
+
+struct ddsi_endpoint_common {
+  struct ddsi_participant *pp;
+  ddsi_guid_t group_guid;
+#ifdef DDS_HAS_TYPE_DISCOVERY
+  struct ddsi_type_pair *type_pair;
+#endif
+};
+
+enum ddsi_writer_state {
+  WRST_OPERATIONAL, /* normal situation */
+  WRST_INTERRUPT, /* will be deleted, unblock throttle_writer but do not do anything further */
+  WRST_LINGERING, /* writer deletion has been requested but still has unack'd data */
+  WRST_DELETING /* writer is actually being deleted (removed from hash table) */
+};
+
+typedef ddsrt_atomic_uint64_t seq_xmit_t;
+
+struct ldur_fhnode {
+  ddsrt_fibheap_node_t heapnode;
+  dds_duration_t ldur;
+};
+
+struct ddsi_writer
+{
+  struct ddsi_entity_common e;
+  struct ddsi_endpoint_common c;
+  ddsi_status_cb_t status_cb;
+  void * status_cb_entity;
+  ddsrt_cond_t throttle_cond; /* used to trigger a transmit thread blocked in throttle_writer() or wait_for_acks() */
+  seqno_t seq; /* last sequence number (transmitted seqs are 1 ... seq, 0 when nothing published yet) */
+  seqno_t cs_seq; /* 1st seq in coherent set (or 0) */
+  seq_xmit_t seq_xmit; /* last sequence number actually transmitted */
+  seqno_t min_local_readers_reject_seq; /* mimum of local_readers->last_deliv_seq */
+  nn_count_t hbcount; /* last hb seq number */
+  nn_count_t hbfragcount; /* last hb frag seq number */
+  int throttling; /* non-zero when some thread is waiting for the WHC to shrink */
+  struct hbcontrol hbcontrol; /* controls heartbeat timing, piggybacking */
+  struct dds_qos *xqos;
+  enum ddsi_writer_state state;
+  unsigned reliable: 1; /* iff 1, writer is reliable <=> heartbeat_xevent != NULL */
+  unsigned handle_as_transient_local: 1; /* controls whether data is retained in WHC */
+  unsigned force_md5_keyhash: 1; /* iff 1, when keyhash has to be hashed, no matter the size */
+  unsigned retransmitting: 1; /* iff 1, this writer is currently retransmitting */
+  unsigned alive: 1; /* iff 1, the writer is alive (lease for this writer is not expired); field may be modified only when holding both wr->e.lock and wr->c.pp->e.lock */
+  unsigned test_ignore_acknack : 1; /* iff 1, the writer ignores all arriving ACKNACK messages */
+  unsigned test_suppress_retransmit : 1; /* iff 1, the writer does not respond to retransmit requests */
+  unsigned test_suppress_heartbeat : 1; /* iff 1, the writer suppresses all periodic heartbeats */
+  unsigned test_drop_outgoing_data : 1; /* iff 1, the writer drops outgoing data, forcing the readers to request a retransmit */
+#ifdef DDS_HAS_SHM
+  unsigned has_iceoryx : 1;
+#endif
+#ifdef DDS_HAS_SSM
+  unsigned supports_ssm: 1;
+  struct addrset *ssm_as;
+#endif
+  uint32_t alive_vclock; /* virtual clock counting transitions between alive/not-alive */
+  const struct ddsi_sertype * type; /* type of the data written by this writer */
+  struct addrset *as; /* set of addresses to publish to */
+  struct xevent *heartbeat_xevent; /* timed event for "periodically" publishing heartbeats when unack'd data present, NULL <=> unreliable */
+  struct ldur_fhnode *lease_duration; /* fibheap node to keep lease duration for this writer, NULL in case of automatic liveliness with inifite duration  */
+  struct whc *whc; /* WHC tracking history, T-L durability service history + samples by sequence number for retransmit */
+  uint32_t whc_low, whc_high; /* watermarks for WHC in bytes (counting only unack'd data) */
+  ddsrt_etime_t t_rexmit_start;
+  ddsrt_etime_t t_rexmit_end; /* time of last 1->0 transition of "retransmitting" */
+  ddsrt_etime_t t_whc_high_upd; /* time "whc_high" was last updated for controlled ramp-up of throughput */
+  uint32_t init_burst_size_limit; /* derived from reader's receive_buffer_size */
+  uint32_t rexmit_burst_size_limit; /* derived from reader's receive_buffer_size */
+  uint32_t num_readers; /* total number of matching PROXY readers */
+  uint32_t num_reliable_readers; /* number of matching reliable PROXY readers */
+  uint32_t num_readers_requesting_keyhash; /* also +1 for protected keys and config override for generating keyhash */
+  ddsrt_avl_tree_t readers; /* all matching PROXY readers, see struct ddsi_wr_prd_match */
+  ddsrt_avl_tree_t local_readers; /* all matching LOCAL readers, see struct ddsi_wr_rd_match */
+#ifdef DDS_HAS_NETWORK_PARTITIONS
+  const struct ddsi_config_networkpartition_listelem *network_partition;
+#endif
+  uint32_t num_acks_received; /* cum received ACKNACKs with no request for retransmission */
+  uint32_t num_nacks_received; /* cum received ACKNACKs that did request retransmission */
+  uint32_t throttle_count; /* cum times transmitting was throttled (whc hitting high-level mark) */
+  uint32_t throttle_tracing;
+  uint32_t rexmit_count; /* cum samples retransmitted (counting events; 1 sample can be counted many times) */
+  uint32_t rexmit_lost_count; /* cum samples lost but retransmit requested (also counting events) */
+  uint64_t rexmit_bytes; /* cum bytes queued for retransmit */
+  uint64_t time_throttled; /* cum time in throttled state */
+  uint64_t time_retransmit; /* cum time in retransmitting state */
+  struct xeventq *evq; /* timed event queue to be used by this writer */
+  struct ddsi_local_reader_ary rdary; /* LOCAL readers for fast-pathing; if not fast-pathed, fall back to scanning local_readers */
+  struct lease *lease; /* for liveliness administration (writer can only become inactive when using manual liveliness) */
+#ifdef DDS_HAS_SECURITY
+  struct ddsi_writer_sec_attributes *sec_attr;
+#endif
+};
+
+struct ddsi_local_orphan_writer {
+  struct ddsi_writer wr;
+};
+
+struct ddsi_reader
+{
+  struct ddsi_entity_common e;
+  struct ddsi_endpoint_common c;
+  ddsi_status_cb_t status_cb;
+  void * status_cb_entity;
+  struct ddsi_rhc * rhc; /* reader history, tracks registrations and data */
+  struct dds_qos *xqos;
+  unsigned reliable: 1; /* 1 iff reader is reliable */
+  unsigned handle_as_transient_local: 1; /* 1 iff reader wants historical data from proxy writers */
+  unsigned request_keyhash: 1; /* really controlled by the sertype */
+#ifdef DDS_HAS_SSM
+  unsigned favours_ssm: 1; /* iff 1, this reader favours SSM */
+#endif
+#ifdef DDS_HAS_SHM
+  unsigned has_iceoryx : 1;
+#endif
+  nn_count_t init_acknack_count; /* initial value for "count" (i.e. ACK seq num) for newly matched proxy writers */
+#ifdef DDS_HAS_NETWORK_PARTITIONS
+  struct networkpartition_address *uc_as;
+  struct networkpartition_address *mc_as;
+#endif
+  const struct ddsi_sertype * type; /* type of the data read by this reader */
+  uint32_t num_writers; /* total number of matching PROXY writers */
+  ddsrt_avl_tree_t writers; /* all matching PROXY writers, see struct ddsi_rd_pwr_match */
+  ddsrt_avl_tree_t local_writers; /* all matching LOCAL writers, see struct ddsi_rd_wr_match */
+  ddsi2direct_directread_cb_t ddsi2direct_cb;
+  void *ddsi2direct_cbarg;
+#ifdef DDS_HAS_SECURITY
+  struct ddsi_reader_sec_attributes *sec_attr;
+#endif
+};
+
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_wr_readers_treedef;
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_wr_local_readers_treedef;
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_rd_writers_treedef;
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_rd_local_writers_treedef;
+
+DDS_INLINE_EXPORT inline seqno_t ddsi_writer_read_seq_xmit (const struct ddsi_writer *wr)
+{
+  return ddsrt_atomic_ld64 (&wr->seq_xmit);
+}
+
+DDS_INLINE_EXPORT inline void ddsi_writer_update_seq_xmit (struct ddsi_writer *wr, seqno_t nv)
+{
+  uint64_t ov;
+  do {
+    ov = ddsrt_atomic_ld64 (&wr->seq_xmit);
+    if (nv <= ov) break;
+  } while (!ddsrt_atomic_cas64 (&wr->seq_xmit, ov, nv));
+}
+
+// generic
+bool ddsi_is_local_orphan_endpoint (const struct ddsi_entity_common *e);
+int ddsi_is_keyed_endpoint_entityid (ddsi_entityid_t id);
+int ddsi_is_builtin_volatile_endpoint (ddsi_entityid_t id);
+
+DDS_EXPORT int ddsi_is_builtin_endpoint (ddsi_entityid_t id, nn_vendorid_t vendorid);
+
+// writer
+dds_return_t ddsi_new_writer_guid (struct ddsi_writer **wr_out, const struct ddsi_guid *guid, const struct ddsi_guid *group_guid, struct ddsi_participant *pp, const char *topic_name, const struct ddsi_sertype *type, const struct dds_qos *xqos, struct whc *whc, ddsi_status_cb_t status_cb, void *status_entity);
+int ddsi_is_writer_entityid (ddsi_entityid_t id);
+void ddsi_deliver_historical_data (const struct ddsi_writer *wr, const struct ddsi_reader *rd);
+unsigned ddsi_remove_acked_messages (struct ddsi_writer *wr, struct whc_state *whcst, struct whc_node **deferred_free_list);
+seqno_t ddsi_writer_max_drop_seq (const struct ddsi_writer *wr);
+int ddsi_writer_must_have_hb_scheduled (const struct ddsi_writer *wr, const struct whc_state *whcst);
+void ddsi_writer_set_retransmitting (struct ddsi_writer *wr);
+void ddsi_writer_clear_retransmitting (struct ddsi_writer *wr);
+dds_return_t ddsi_delete_writer_nolinger (struct ddsi_domaingv *gv, const struct ddsi_guid *guid);
+void ddsi_writer_get_alive_state (struct ddsi_writer *wr, struct ddsi_alive_state *st);
+void ddsi_rebuild_writer_addrset (struct ddsi_writer *wr);
+void ddsi_writer_set_alive_may_unlock (struct ddsi_writer *wr, bool notify);
+int ddsi_writer_set_notalive (struct ddsi_writer *wr, bool notify);
+
+DDS_EXPORT struct ddsi_local_orphan_writer *ddsi_new_local_orphan_writer (struct ddsi_domaingv *gv, ddsi_entityid_t entityid, const char *topic_name, struct ddsi_sertype *type, const struct dds_qos *xqos, struct whc *whc);
+DDS_EXPORT void ddsi_delete_local_orphan_writer (struct ddsi_local_orphan_writer *wr);
+DDS_EXPORT dds_return_t ddsi_new_writer (struct ddsi_writer **wr_out, struct ddsi_guid *wrguid, const struct ddsi_guid *group_guid, struct ddsi_participant *pp, const char *topic_name, const struct ddsi_sertype *type, const struct dds_qos *xqos, struct whc * whc, ddsi_status_cb_t status_cb, void *status_cb_arg);
+DDS_EXPORT void ddsi_update_writer_qos (struct ddsi_writer *wr, const struct dds_qos *xqos);
+DDS_EXPORT void ddsi_make_writer_info(struct ddsi_writer_info *wrinfo, const struct ddsi_entity_common *e, const struct dds_qos *xqos, uint32_t statusinfo);
+DDS_EXPORT dds_return_t ddsi_writer_wait_for_acks (struct ddsi_writer *wr, const ddsi_guid_t *rdguid, dds_time_t abstimeout);
+DDS_EXPORT dds_return_t ddsi_unblock_throttled_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid);
+DDS_EXPORT dds_return_t ddsi_delete_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid);
+
+// reader
+dds_return_t ddsi_new_reader_guid (struct ddsi_reader **rd_out, const struct ddsi_guid *guid, const struct ddsi_guid *group_guid, struct ddsi_participant *pp, const char *topic_name, const struct ddsi_sertype *type, const struct dds_qos *xqos, struct ddsi_rhc *rhc, ddsi_status_cb_t status_cb, void * status_entity);
+int ddsi_is_reader_entityid (ddsi_entityid_t id);
+void ddsi_reader_update_notify_wr_alive_state (struct ddsi_reader *rd, const struct ddsi_writer *wr, const struct ddsi_alive_state *alive_state);
+void ddsi_reader_update_notify_pwr_alive_state (struct ddsi_reader *rd, const struct ddsi_proxy_writer *pwr, const struct ddsi_alive_state *alive_state);
+void ddsi_reader_update_notify_pwr_alive_state_guid (const struct ddsi_guid *rd_guid, const struct ddsi_proxy_writer *pwr, const struct ddsi_alive_state *alive_state);
+void ddsi_update_reader_init_acknack_count (const ddsrt_log_cfg_t *logcfg, const struct entity_index *entidx, const struct ddsi_guid *rd_guid, nn_count_t count);
+
+DDS_EXPORT dds_return_t ddsi_new_reader (struct ddsi_reader **rd_out, struct ddsi_guid *rdguid, const struct ddsi_guid *group_guid, struct ddsi_participant *pp, const char *topic_name, const struct ddsi_sertype *type, const struct dds_qos *xqos, struct ddsi_rhc * rhc, ddsi_status_cb_t status_cb, void *status_cb_arg);
+DDS_EXPORT void ddsi_update_reader_qos (struct ddsi_reader *rd, const struct dds_qos *xqos);
+DDS_EXPORT dds_return_t ddsi_delete_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *guid);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_ENDPOINT_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_entity.h

@@ -0,0 +1,134 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_ENTITY_H
+#define DDSI_ENTITY_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/atomics.h"
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsrt/fibheap.h"
+#include "dds/ddsrt/sync.h"
+#include "dds/ddsi/q_rtps.h"
+#include "dds/ddsi/ddsi_plist.h"
+#include "dds/ddsi/q_protocol.h"
+#include "dds/ddsi/q_lat_estim.h"
+#include "dds/ddsi/q_hbcontrol.h"
+#include "dds/ddsi/q_feature_check.h"
+#include "dds/ddsi/q_inverse_uint32_set.h"
+#include "dds/ddsi/ddsi_typelib.h"
+#include "dds/ddsi/ddsi_serdata_default.h"
+#include "dds/ddsi/ddsi_handshake.h"
+#include "dds/ddsi/ddsi_typelookup.h"
+#include "dds/ddsi/ddsi_tran.h"
+#include "dds/ddsi/ddsi_list_genptr.h"
+#include "dds/ddsi/q_gc.h"
+#include "dds/ddsi/q_lease.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct whc_node;
+struct ddsi_plist;
+struct nn_rsample_info;
+struct nn_rdata;
+struct ddsi_tkmap_instance;
+struct ddsi_writer_info;
+struct entity_index;
+
+typedef void (*ddsi2direct_directread_cb_t) (const struct nn_rsample_info *sampleinfo, const struct nn_rdata *fragchain, void *arg);
+
+enum ddsi_entity_kind {
+  DDSI_EK_PARTICIPANT,
+  DDSI_EK_PROXY_PARTICIPANT,
+  DDSI_EK_TOPIC,
+  DDSI_EK_WRITER,
+  DDSI_EK_PROXY_WRITER,
+  DDSI_EK_READER,
+  DDSI_EK_PROXY_READER
+};
+
+typedef struct ddsi_status_cb_data
+{
+  int raw_status_id;
+  uint32_t extra;
+  uint64_t handle;
+  bool add;
+} ddsi_status_cb_data_t;
+
+typedef void (*ddsi_status_cb_t) (void *entity, const ddsi_status_cb_data_t *data);
+
+typedef struct ddsi_type_pair
+#ifdef DDS_HAS_TYPE_DISCOVERY
+{
+  struct ddsi_type *minimal;
+  struct ddsi_type *complete;
+}
+#endif
+ddsi_type_pair_t;
+
+struct ddsi_entity_common {
+  enum ddsi_entity_kind kind;
+  ddsi_guid_t guid;
+  ddsrt_wctime_t tupdate; /* timestamp of last update */
+  uint64_t iid;
+  struct ddsi_tkmap_instance *tk;
+  ddsrt_mutex_t lock;
+  bool onlylocal;
+  struct ddsi_domaingv *gv;
+  ddsrt_avl_node_t all_entities_avlnode;
+
+  /* QoS changes always lock the entity itself, and additionally
+     (and within the scope of the entity lock) acquire qos_lock
+     while manipulating the QoS.  So any thread that needs to read
+     the QoS without acquiring the entity's lock can still do so
+     (e.g., the materialisation of samples for built-in topics
+     when connecting a reader to a writer for a built-in topic).
+
+     qos_lock lock order across entities in is in increasing
+     order of entity addresses cast to uintptr_t. */
+  ddsrt_mutex_t qos_lock;
+};
+
+struct ddsi_local_reader_ary {
+  ddsrt_mutex_t rdary_lock;
+  unsigned valid: 1; /* always true until (proxy-)writer is being deleted; !valid => !fastpath_ok */
+  unsigned fastpath_ok: 1; /* if not ok, fall back to using GUIDs (gives access to the reader-writer match data for handling readers that bumped into resource limits, hence can flip-flop, unlike "valid") */
+  uint32_t n_readers;
+  struct ddsi_reader **rdary; /* for efficient delivery, null-pointer terminated, grouped by topic */
+};
+
+struct ddsi_alive_state {
+  bool alive;
+  uint32_t vclock;
+};
+
+bool ddsi_is_null_guid (const ddsi_guid_t *guid);
+int ddsi_is_builtin_entityid (ddsi_entityid_t id, nn_vendorid_t vendorid);
+bool ddsi_update_qos_locked (struct ddsi_entity_common *e, dds_qos_t *ent_qos, const dds_qos_t *xqos, ddsrt_wctime_t timestamp);
+int ddsi_set_topic_type_name (dds_qos_t *xqos, const char * topic_name, const char * type_name);
+int ddsi_compare_entityid (const void *a, const void *b);
+
+DDS_EXPORT int ddsi_compare_guid (const void *va, const void *vb);
+DDS_EXPORT ddsi_entityid_t ddsi_to_entityid (unsigned u);
+DDS_EXPORT nn_vendorid_t ddsi_get_entity_vendorid (const struct ddsi_entity_common *e);
+DDS_EXPORT uint64_t ddsi_get_entity_instanceid (const struct ddsi_domaingv *gv, const struct ddsi_guid *guid);
+DDS_EXPORT void ddsi_entity_common_init (struct ddsi_entity_common *e, struct ddsi_domaingv *gv, const struct ddsi_guid *guid, enum ddsi_entity_kind kind, ddsrt_wctime_t tcreate, nn_vendorid_t vendorid, bool onlylocal);
+DDS_EXPORT void ddsi_entity_common_fini (struct ddsi_entity_common *e);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_ENTITY_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_entity_index.h

@@ -0,0 +1,163 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_ENTITY_INDEX_H
+#define DDSI_ENTITY_INDEX_H
+
+#include "dds/ddsrt/hopscotch.h"
+#include "dds/ddsi/q_thread.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/ddsi_topic.h"
+#include "dds/ddsi/ddsi_endpoint.h"
+#include "dds/ddsi/ddsi_proxy_endpoint.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct entity_index;
+struct ddsi_guid;
+struct ddsi_domaingv;
+
+struct match_entities_range_key {
+  union {
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+    struct ddsi_topic tp;
+#endif
+    struct ddsi_writer wr;
+    struct ddsi_reader rd;
+    struct ddsi_entity_common e;
+    struct ddsi_generic_proxy_endpoint gpe;
+  } entity;
+  struct dds_qos xqos;
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+  struct ddsi_topic_definition tpdef;
+#endif
+};
+
+struct entidx_enum
+{
+  struct entity_index *entidx;
+  enum ddsi_entity_kind kind;
+  struct ddsi_entity_common *cur;
+#ifndef NDEBUG
+  vtime_t vtime;
+#endif
+};
+
+/* Readers & writers are both in a GUID- and in a GID-keyed table. If
+   they are in the GID-based one, they are also in the GUID-based one,
+   but not the way around, for two reasons:
+
+   - firstly, there are readers & writers that do not have a GID
+     (built-in endpoints, fictitious transient data readers),
+
+   - secondly, they are inserted first in the GUID-keyed one, and then
+     in the GID-keyed one.
+
+   The GID is used solely for the interface with the OpenSplice
+   kernel, all internal state and protocol handling is done using the
+   GUID. So all this means is that, e.g., a writer being deleted
+   becomes invisible to the network reader slightly before it
+   disappears in the protocol handling, or that a writer might exist
+   at the protocol level slightly before the network reader can use it
+   to transmit data. */
+
+struct entity_index *entity_index_new (struct ddsi_domaingv *gv) ddsrt_nonnull_all;
+void entity_index_free (struct entity_index *ei) ddsrt_nonnull_all;
+
+void entidx_insert_participant_guid (struct entity_index *ei, struct ddsi_participant *pp) ddsrt_nonnull_all;
+void entidx_insert_proxy_participant_guid (struct entity_index *ei, struct ddsi_proxy_participant *proxypp) ddsrt_nonnull_all;
+void entidx_insert_writer_guid (struct entity_index *ei, struct ddsi_writer *wr) ddsrt_nonnull_all;
+void entidx_insert_reader_guid (struct entity_index *ei, struct ddsi_reader *rd) ddsrt_nonnull_all;
+void entidx_insert_proxy_writer_guid (struct entity_index *ei, struct ddsi_proxy_writer *pwr) ddsrt_nonnull_all;
+void entidx_insert_proxy_reader_guid (struct entity_index *ei, struct ddsi_proxy_reader *prd) ddsrt_nonnull_all;
+
+void entidx_remove_participant_guid (struct entity_index *ei, struct ddsi_participant *pp) ddsrt_nonnull_all;
+void entidx_remove_proxy_participant_guid (struct entity_index *ei, struct ddsi_proxy_participant *proxypp) ddsrt_nonnull_all;
+void entidx_remove_writer_guid (struct entity_index *ei, struct ddsi_writer *wr) ddsrt_nonnull_all;
+void entidx_remove_reader_guid (struct entity_index *ei, struct ddsi_reader *rd) ddsrt_nonnull_all;
+void entidx_remove_proxy_writer_guid (struct entity_index *ei, struct ddsi_proxy_writer *pwr) ddsrt_nonnull_all;
+void entidx_remove_proxy_reader_guid (struct entity_index *ei, struct ddsi_proxy_reader *prd) ddsrt_nonnull_all;
+
+DDS_EXPORT void *entidx_lookup_guid_untyped (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT void *entidx_lookup_guid (const struct entity_index *ei, const struct ddsi_guid *guid, enum ddsi_entity_kind kind) ddsrt_nonnull_all;
+
+DDS_EXPORT struct ddsi_participant *entidx_lookup_participant_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_proxy_participant *entidx_lookup_proxy_participant_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_writer *entidx_lookup_writer_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_reader *entidx_lookup_reader_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_proxy_writer *entidx_lookup_proxy_writer_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_proxy_reader *entidx_lookup_proxy_reader_guid (const struct entity_index *ei, const struct ddsi_guid *guid) ddsrt_nonnull_all;
+
+/* Enumeration of entries in the hash table:
+
+   - "next" visits at least all entries that were in the hash table at
+     the time of calling init and that have not subsequently been
+     removed;
+
+   - "next" may visit an entry more than once, but will do so only
+     because of rare events (i.e., resize or so);
+
+   - the order in which entries are visited is arbitrary;
+
+   - the caller must call init() before it may call next(); it must
+     call fini() before it may call init() again. */
+struct entidx_enum_participant { struct entidx_enum st; };
+struct entidx_enum_writer { struct entidx_enum st; };
+struct entidx_enum_reader { struct entidx_enum st; };
+struct entidx_enum_proxy_participant { struct entidx_enum st; };
+struct entidx_enum_proxy_writer { struct entidx_enum st; };
+struct entidx_enum_proxy_reader { struct entidx_enum st; };
+
+void entidx_enum_init (struct entidx_enum *st, const struct entity_index *ei, enum ddsi_entity_kind kind) ddsrt_nonnull_all;
+void entidx_enum_init_topic (struct entidx_enum *st, const struct entity_index *gh, enum ddsi_entity_kind kind, const char *topic, struct match_entities_range_key *max) ddsrt_nonnull_all;
+void entidx_enum_init_topic_w_prefix (struct entidx_enum *st, const struct entity_index *ei, enum ddsi_entity_kind kind, const char *topic, const ddsi_guid_prefix_t *prefix, struct match_entities_range_key *max) ddsrt_nonnull_all;
+void *entidx_enum_next_max (struct entidx_enum *st, const struct match_entities_range_key *max) ddsrt_nonnull_all;
+void *entidx_enum_next (struct entidx_enum *st) ddsrt_nonnull_all;
+void entidx_enum_fini (struct entidx_enum *st) ddsrt_nonnull_all;
+
+void entidx_enum_writer_init (struct entidx_enum_writer *st, const struct entity_index *ei) ddsrt_nonnull_all;
+void entidx_enum_reader_init (struct entidx_enum_reader *st, const struct entity_index *ei) ddsrt_nonnull_all;
+void entidx_enum_proxy_writer_init (struct entidx_enum_proxy_writer *st, const struct entity_index *ei) ddsrt_nonnull_all;
+void entidx_enum_proxy_reader_init (struct entidx_enum_proxy_reader *st, const struct entity_index *ei) ddsrt_nonnull_all;
+void entidx_enum_participant_init (struct entidx_enum_participant *st, const struct entity_index *ei) ddsrt_nonnull_all;
+void entidx_enum_proxy_participant_init (struct entidx_enum_proxy_participant *st, const struct entity_index *ei) ddsrt_nonnull_all;
+
+struct ddsi_writer *entidx_enum_writer_next (struct entidx_enum_writer *st) ddsrt_nonnull_all;
+struct ddsi_reader *entidx_enum_reader_next (struct entidx_enum_reader *st) ddsrt_nonnull_all;
+struct ddsi_proxy_writer *entidx_enum_proxy_writer_next (struct entidx_enum_proxy_writer *st) ddsrt_nonnull_all;
+struct ddsi_proxy_reader *entidx_enum_proxy_reader_next (struct entidx_enum_proxy_reader *st) ddsrt_nonnull_all;
+struct ddsi_participant *entidx_enum_participant_next (struct entidx_enum_participant *st) ddsrt_nonnull_all;
+struct ddsi_proxy_participant *entidx_enum_proxy_participant_next (struct entidx_enum_proxy_participant *st) ddsrt_nonnull_all;
+
+void entidx_enum_writer_fini (struct entidx_enum_writer *st) ddsrt_nonnull_all;
+void entidx_enum_reader_fini (struct entidx_enum_reader *st) ddsrt_nonnull_all;
+void entidx_enum_proxy_writer_fini (struct entidx_enum_proxy_writer *st) ddsrt_nonnull_all;
+void entidx_enum_proxy_reader_fini (struct entidx_enum_proxy_reader *st) ddsrt_nonnull_all;
+void entidx_enum_participant_fini (struct entidx_enum_participant *st) ddsrt_nonnull_all;
+void entidx_enum_proxy_participant_fini (struct entidx_enum_proxy_participant *st) ddsrt_nonnull_all;
+
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+void entidx_insert_topic_guid (struct entity_index *ei, struct ddsi_topic *tp) ddsrt_nonnull_all;
+void entidx_remove_topic_guid (struct entity_index *ei, struct ddsi_topic *tp) ddsrt_nonnull_all;
+DDS_EXPORT struct ddsi_topic *entidx_lookup_topic_guid (const struct entity_index *ei, const struct ddsi_guid *guid);
+struct entidx_enum_topic { struct entidx_enum st; };
+void entidx_enum_topic_init (struct entidx_enum_topic *st, const struct entity_index *ei) ddsrt_nonnull_all;
+struct ddsi_topic *entidx_enum_topic_next (struct entidx_enum_topic *st) ddsrt_nonnull_all;
+void entidx_enum_topic_fini (struct entidx_enum_topic *st) ddsrt_nonnull_all;
+#endif
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_ENTITY_INDEX_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_entity_match.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_ENTITY_MATCH_H
+#define DDSI_ENTITY_MATCH_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/q_addrset.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_participant;
+struct ddsi_proxy_participant;
+struct ddsi_writer;
+struct ddsi_reader;
+struct ddsi_proxy_writer;
+struct ddsi_proxy_reader;
+struct ddsi_alive_state;
+struct ddsi_generic_proxy_endpoint;
+
+struct bestab {
+  unsigned besflag;
+  unsigned entityid;
+  const char *topic_name;
+};
+
+#ifdef DDS_HAS_SECURITY
+struct setab {
+  enum ddsi_entity_kind kind;
+  uint32_t id;
+};
+#endif
+
+struct ddsi_prd_wr_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t wr_guid;
+#ifdef DDS_HAS_SECURITY
+  int64_t crypto_handle;
+#endif
+};
+
+struct ddsi_rd_pwr_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t pwr_guid;
+  unsigned pwr_alive: 1; /* tracks pwr's alive state */
+  uint32_t pwr_alive_vclock; /* used to ensure progress */
+#ifdef DDS_HAS_SSM
+  ddsi_xlocator_t ssm_mc_loc;
+  ddsi_xlocator_t ssm_src_loc;
+#endif
+#ifdef DDS_HAS_SECURITY
+  int64_t crypto_handle;
+#endif
+};
+
+struct ddsi_wr_rd_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t rd_guid;
+};
+
+struct ddsi_rd_wr_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t wr_guid;
+  unsigned wr_alive: 1; /* tracks wr's alive state */
+  uint32_t wr_alive_vclock; /* used to ensure progress */
+};
+
+struct ddsi_wr_prd_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t prd_guid; /* guid of the proxy reader */
+  unsigned assumed_in_sync: 1; /* set to 1 upon receipt of ack not nack'ing msgs */
+  unsigned has_replied_to_hb: 1; /* we must keep sending HBs until all readers have this set */
+  unsigned all_have_replied_to_hb: 1; /* true iff 'has_replied_to_hb' for all readers in subtree */
+  unsigned is_reliable: 1; /* true iff reliable proxy reader */
+  seqno_t min_seq; /* smallest ack'd seq nr in subtree */
+  seqno_t max_seq; /* sort-of highest ack'd seq nr in subtree (see augment function) */
+  seqno_t seq; /* highest acknowledged seq nr */
+  seqno_t last_seq; /* highest seq send to this reader used when filter is applied */
+  uint32_t num_reliable_readers_where_seq_equals_max;
+  ddsi_guid_t arbitrary_unacked_reader;
+  nn_count_t prev_acknack; /* latest accepted acknack sequence number */
+  nn_count_t prev_nackfrag; /* latest accepted nackfrag sequence number */
+  ddsrt_etime_t t_acknack_accepted; /* (local) time an acknack was last accepted */
+  ddsrt_etime_t t_nackfrag_accepted; /* (local) time a nackfrag was last accepted */
+  struct nn_lat_estim hb_to_ack_latency;
+  ddsrt_wctime_t hb_to_ack_latency_tlastlog;
+  uint32_t non_responsive_count;
+  uint32_t rexmit_requests;
+#ifdef DDS_HAS_SECURITY
+  int64_t crypto_handle;
+#endif
+};
+
+enum pwr_rd_match_syncstate {
+  PRMSS_SYNC, /* in sync with proxy writer, has caught up with historical data */
+  PRMSS_TLCATCHUP, /* in sync with proxy writer, pwr + readers still catching up on historical data */
+  PRMSS_OUT_OF_SYNC /* not in sync with proxy writer */
+};
+
+struct last_nack_summary {
+  seqno_t seq_end_p1; /* last seq for which we requested a retransmit */
+  seqno_t seq_base;
+  uint32_t frag_end_p1; /* last fragnum of seq_last_nack for which requested a retransmit */
+  uint32_t frag_base;
+};
+
+struct ddsi_pwr_rd_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t rd_guid;
+  ddsrt_mtime_t tcreate;
+  nn_count_t count; /* most recent acknack sequence number */
+  nn_count_t prev_heartbeat; /* latest accepted heartbeat (see also add_proxy_writer_to_reader) */
+  ddsrt_wctime_t hb_timestamp; /* time of most recent heartbeat that rescheduled the ack event */
+  ddsrt_etime_t t_heartbeat_accepted; /* (local) time a heartbeat was last accepted */
+  ddsrt_mtime_t t_last_nack; /* (local) time we last sent a NACK */
+  ddsrt_mtime_t t_last_ack; /* (local) time we last sent any ACKNACK */
+  seqno_t last_seq; /* last known sequence number from this writer */
+  struct last_nack_summary last_nack;
+  struct xevent *acknack_xevent; /* entry in xevent queue for sending acknacks */
+  enum pwr_rd_match_syncstate in_sync; /* whether in sync with the proxy writer */
+  unsigned ack_requested : 1; /* set on receipt of HEARTBEAT with FINAL clear, cleared on sending an ACKNACK */
+  unsigned heartbeat_since_ack : 1; /* set when a HEARTBEAT has been received since the last ACKNACK */
+  unsigned heartbeatfrag_since_ack : 1; /* set when a HEARTBEATFRAG has been received since the last ACKNACK */
+  unsigned directed_heartbeat : 1; /* set on receipt of a directed heartbeat, cleared on sending an ACKNACK */
+  unsigned nack_sent_on_nackdelay : 1; /* set when the most recent NACK sent was because of the NackDelay  */
+  unsigned filtered : 1;
+  union {
+    struct {
+      seqno_t end_of_tl_seq; /* when seq >= end_of_tl_seq, it's in sync, =0 when not tl */
+      struct nn_reorder *reorder; /* can be done (mostly) per proxy writer, but that is harder; only when state=OUT_OF_SYNC */
+    } not_in_sync;
+  } u;
+#ifdef DDS_HAS_SECURITY
+  int64_t crypto_handle;
+#endif
+};
+
+void connect_writer_with_proxy_reader_secure (struct ddsi_writer *wr, struct ddsi_proxy_reader *prd, ddsrt_mtime_t tnow, int64_t crypto_handle);
+void connect_reader_with_proxy_writer_secure (struct ddsi_reader *rd, struct ddsi_proxy_writer *pwr, ddsrt_mtime_t tnow, int64_t crypto_handle);
+void match_writer_with_proxy_readers (struct ddsi_writer *wr, ddsrt_mtime_t tnow);
+void match_writer_with_local_readers (struct ddsi_writer *wr, ddsrt_mtime_t tnow);
+void match_reader_with_proxy_writers (struct ddsi_reader *rd, ddsrt_mtime_t tnow);
+void match_reader_with_local_writers (struct ddsi_reader *rd, ddsrt_mtime_t tnow);
+void match_proxy_writer_with_readers (struct ddsi_proxy_writer *pwr, ddsrt_mtime_t tnow);
+void match_proxy_reader_with_writers (struct ddsi_proxy_reader *prd, ddsrt_mtime_t tnow);
+void free_wr_prd_match (const struct ddsi_domaingv *gv, const ddsi_guid_t *wr_guid, struct ddsi_wr_prd_match *m);
+void free_rd_pwr_match (struct ddsi_domaingv *gv, const ddsi_guid_t *rd_guid, struct ddsi_rd_pwr_match *m);
+void free_pwr_rd_match (struct ddsi_pwr_rd_match *m);
+void free_prd_wr_match (struct ddsi_prd_wr_match *m);
+void free_rd_wr_match (struct ddsi_rd_wr_match *m);
+void free_wr_rd_match (struct ddsi_wr_rd_match *m);
+
+void writer_add_connection (struct ddsi_writer *wr, struct ddsi_proxy_reader *prd, int64_t crypto_handle);
+void writer_add_local_connection (struct ddsi_writer *wr, struct ddsi_reader *rd);
+void reader_add_connection (struct ddsi_reader *rd, struct ddsi_proxy_writer *pwr, nn_count_t *init_count, const struct ddsi_alive_state *alive_state, int64_t crypto_handle);
+void reader_add_local_connection (struct ddsi_reader *rd, struct ddsi_writer *wr, const struct ddsi_alive_state *alive_state);
+void proxy_writer_add_connection (struct ddsi_proxy_writer *pwr, struct ddsi_reader *rd, ddsrt_mtime_t tnow, nn_count_t init_count, int64_t crypto_handle);
+void proxy_reader_add_connection (struct ddsi_proxy_reader *prd, struct ddsi_writer *wr, int64_t crypto_handle);
+
+void writer_drop_connection (const struct ddsi_guid *wr_guid, const struct ddsi_proxy_reader *prd);
+void writer_drop_local_connection (const struct ddsi_guid *wr_guid, struct ddsi_reader *rd);
+void reader_drop_connection (const struct ddsi_guid *rd_guid, const struct ddsi_proxy_writer *pwr);
+void reader_drop_local_connection (const struct ddsi_guid *rd_guid, const struct ddsi_writer *wr);
+void proxy_writer_drop_connection (const struct ddsi_guid *pwr_guid, struct ddsi_reader *rd);
+void proxy_reader_drop_connection (const struct ddsi_guid *prd_guid, struct ddsi_writer *wr);
+
+void local_reader_ary_init (struct ddsi_local_reader_ary *x);
+void local_reader_ary_fini (struct ddsi_local_reader_ary *x);
+void local_reader_ary_setinvalid (struct ddsi_local_reader_ary *x);
+void local_reader_ary_insert (struct ddsi_local_reader_ary *x, struct ddsi_reader *rd);
+void local_reader_ary_remove (struct ddsi_local_reader_ary *x, struct ddsi_reader *rd);
+void local_reader_ary_setfastpath_ok (struct ddsi_local_reader_ary *x, bool fastpath_ok);
+
+#ifdef DDS_HAS_SECURITY
+void handshake_end_cb (struct ddsi_handshake *handshake, struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp, enum ddsi_handshake_state result);
+bool proxy_participant_has_pp_match (struct ddsi_domaingv *gv, struct ddsi_proxy_participant *proxypp);
+void proxy_participant_create_handshakes (struct ddsi_domaingv *gv, struct ddsi_proxy_participant *proxypp);
+void disconnect_proxy_participant_secure (struct ddsi_proxy_participant *proxypp);
+void match_volatile_secure_endpoints (struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+void update_proxy_participant_endpoint_matching (struct ddsi_proxy_participant *proxypp, struct ddsi_participant *pp);
+#endif
+
+DDS_EXPORT void ddsi_update_proxy_endpoint_matching (const struct ddsi_domaingv *gv, struct ddsi_generic_proxy_endpoint *proxy_ep);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_ENTITY_MATCH_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_guid.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright(c) 2019 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_GUID_H
+#define DDSI_GUID_H
+
+#include <stdint.h>
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef union ddsi_guid_prefix {
+  unsigned char s[12];
+  uint32_t u[3];
+} ddsi_guid_prefix_t;
+typedef union ddsi_entityid {
+  uint32_t u;
+} ddsi_entityid_t;
+typedef struct ddsi_guid {
+  ddsi_guid_prefix_t prefix;
+  ddsi_entityid_t entityid;
+} ddsi_guid_t;
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_handshake.h

@@ -0,0 +1,226 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_HANDSHAKE_H
+#define DDSI_HANDSHAKE_H
+
+#include "dds/ddsi/ddsi_entity.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_participant;
+struct ddsi_proxy_participant;
+struct ddsi_handshake;
+struct dssi_hsadmin;
+
+enum ddsi_handshake_state {
+    STATE_HANDSHAKE_IN_PROGRESS,
+    STATE_HANDSHAKE_TIMED_OUT,
+    STATE_HANDSHAKE_FAILED,
+    STATE_HANDSHAKE_PROCESSED,
+    STATE_HANDSHAKE_SEND_TOKENS,
+    STATE_HANDSHAKE_OK
+};
+
+/* The handshake will not use the related handshake object after this callback
+ * was executed. This means that it can be deleted in this callback. */
+typedef void (*ddsi_handshake_end_cb_t)(
+    struct ddsi_handshake *handshake,
+    struct ddsi_participant *pp,
+    struct ddsi_proxy_participant *proxypp,
+    enum ddsi_handshake_state result);
+
+#ifdef DDS_HAS_SECURITY
+
+#include "dds/ddsi/ddsi_security_msg.h"
+
+/**
+ * @brief Release the handshake.
+ *
+ * This function will decrement the refcount associated with the handshake
+ * and delete the handshake when the refcount becomes 0.
+ *
+ * @param[in] handshake    The handshake.
+ */
+void ddsi_handshake_release(struct ddsi_handshake *handshake);
+
+/**
+ * @brief Handle an authentication handshake message received from the remote participant.
+ *
+ * During the authentication phase handshake messages are being exchanged between the local and
+ * the remote participant. THis function will handle a handshake message received from a remote
+ * participant.
+ *
+ * @param[in] handshake  The handshake.
+ * @param[in] pp         The local participant.
+ * @param[in] proxypp    The remote participant.
+ * @param[in] msg        The handshake message received.
+ */
+void ddsi_handshake_handle_message(struct ddsi_handshake *handshake, const struct ddsi_participant *pp, const struct ddsi_proxy_participant *proxypp, const struct nn_participant_generic_message *msg);
+
+/**
+ * @brief Notify the handshake that crypto tokens have been received.
+ *
+ * The handshake could be finished at one end while the other side has not yet processed the
+ * final handshake messages. The arrival of crypto tokens signals that the other side has also finished
+ * processing the handshake. This function is used to signal the handshake that crypto tokens have been
+ * received.
+ *
+ * @param[in] handshake     The handshake.
+ */
+void ddsi_handshake_crypto_tokens_received(struct ddsi_handshake *handshake);
+
+/**
+ * @brief Get the shared secret handle.
+ *
+ * During the handshake a shared secret is established which is used to encrypt
+ * and decrypt the crypto token exchange messages. This function will return a
+ * handle to the shared secret which will be passed to the crypto plugin to
+ * determine the session keys used for the echange of the the crypto tokens.
+ *
+ * @param[in] handshake  The handshake.
+ *
+ * @returns handle to the shared sercet.
+ */
+int64_t ddsi_handshake_get_shared_secret(const struct ddsi_handshake *handshake);
+
+/**
+ * @brief Get the handshake handle
+ *
+ * This function returns the handshake handle that was returned by the authentication plugin
+ * when starting the handshake.
+ *
+ * @param[in]  handshake  The handshake.
+ *
+ * @returns The handshake handle.
+ */
+int64_t ddsi_handshake_get_handle(const struct ddsi_handshake *handshake);
+
+/**
+ * @brief Create and start the handshake for the participants
+ *
+ * This function will create a handshake for the specified local
+ * and remote participants when it does not yet exists. It will start the
+ * handshake procedure by calling the corresponding functions of the authentication plugin.
+ * The callback function is called by the handshake when to report events,
+ * for example to indicate that the handshake has finished or has failed.
+ *
+ * @param[in] pp         The local participant.
+ * @param[in] proxypp    The remote participant.
+ * @param[in] callback   The callback function.
+ *
+ */
+void ddsi_handshake_register(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp, ddsi_handshake_end_cb_t callback);
+
+/**
+ * @brief Remove the handshake associated with the specified participants.
+ *
+ * This function will remove the handshake from the handshake administation and release
+ * the handshake. When the handshake argument is not specified the handshake is searched
+ * in the handshake administation.
+ *
+ * @param[in] pp         The local participant.
+ * @param[in] proxypp    The remote participant.
+ *
+ */
+void ddsi_handshake_remove(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Searches for the handshake associated with the specified participants
+ *
+ * This function will search through the handshake administration to find the handshake
+ * corresponding the to specified local and remote participant.
+ *
+ * @param[in] pp         The local participant.
+ * @param[in] proxypp    The remote participant.
+ *
+ * @returns The handshake
+ */
+struct ddsi_handshake * ddsi_handshake_find(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Searches for the handshake associated with the specified participants
+ *
+ * This function will search through the handshake administration to find the handshake
+ * corresponding the to specified local and remote participant.
+ *
+ * @param[in] pp         The local participant.
+ * @param[in] proxypp    The remote participant.
+ *
+ * @returns The handshake
+ */
+struct ddsi_handshake * ddsi_handshake_find(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Initialize the handshake administration
+ *
+ * @param[in] gv         The global parameters
+ */
+void ddsi_handshake_admin_init(struct ddsi_domaingv *gv);
+
+/**
+* @brief Stop handshake background processing.
+*
+* @param[in] gv         The global parameters
+*/
+void ddsi_handshake_admin_stop(struct ddsi_domaingv *gv);
+
+/**
+ * @brief Deinitialze the handshake administration.
+ *
+ * @param[in] gv         The global parameters
+ */
+void ddsi_handshake_admin_deinit(struct ddsi_domaingv *gv);
+
+#else /* DDS_HAS_SECURITY */
+
+#include "dds/ddsi/q_unused.h"
+
+DDS_INLINE_EXPORT inline void ddsi_handshake_register(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp), UNUSED_ARG(ddsi_handshake_end_cb_t callback))
+{
+}
+
+DDS_INLINE_EXPORT inline void ddsi_handshake_release(UNUSED_ARG(struct ddsi_handshake *handshake))
+{
+}
+
+DDS_INLINE_EXPORT inline void ddsi_handshake_crypto_tokens_received(UNUSED_ARG(struct ddsi_handshake *handshake))
+{
+}
+
+DDS_INLINE_EXPORT inline int64_t ddsi_handshake_get_shared_secret(UNUSED_ARG(const struct ddsi_handshake *handshake))
+{
+  return 0;
+}
+
+DDS_INLINE_EXPORT inline int64_t ddsi_handshake_get_handle(UNUSED_ARG(const struct ddsi_handshake *handshake))
+{
+  return 0;
+}
+
+DDS_INLINE_EXPORT inline void ddsi_handshake_remove(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp), UNUSED_ARG(struct ddsi_handshake *handshake))
+{
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_handshake * ddsi_handshake_find(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+  return NULL;
+}
+
+#endif /* DDS_HAS_SECURITY */
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_HANDSHAKE_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_iid.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright(c) 2006 to 2019 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef _DDS_IID_H_
+#define _DDS_IID_H_
+
+#include "dds/export.h"
+#include "dds/ddsrt/atomics.h"
+#include "dds/ddsrt/sync.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_iid {
+  ddsrt_atomic_uint64_t counter;
+  uint32_t key[4];
+};
+
+DDS_EXPORT void ddsi_iid_init (void);
+DDS_EXPORT void ddsi_iid_fini (void);
+DDS_EXPORT uint64_t ddsi_iid_gen (void);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_ipaddr.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_IPADDR_H
+#define DDSI_IPADDR_H
+
+#include "dds/ddsi/ddsi_tran.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+enum ddsi_nearby_address_result ddsi_ipaddr_is_nearby_address (const ddsi_locator_t *loc, size_t ninterf, const struct nn_interface *interf, size_t *interf_idx);
+enum ddsi_locator_from_string_result ddsi_ipaddr_from_string (ddsi_locator_t *loc, const char *str, int32_t kind);
+int ddsi_ipaddr_compare (const struct sockaddr *const sa1, const struct sockaddr *const sa2);
+char *ddsi_ipaddr_to_string (char *dst, size_t sizeof_dst, const ddsi_locator_t *loc, int with_port, const struct nn_interface *interf);
+void ddsi_ipaddr_to_loc (ddsi_locator_t *dst, const struct sockaddr *src, int32_t kind);
+void ddsi_ipaddr_to_xloc (const struct ddsi_tran_factory *tran, ddsi_xlocator_t *dst, const struct sockaddr *src, int32_t kind);
+void ddsi_ipaddr_from_loc (struct sockaddr_storage *dst, const ddsi_locator_t *src);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_keyhash.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright(c) 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_KEYHASH_H
+#define DDSI_KEYHASH_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef struct ddsi_keyhash {
+  unsigned char value[16];
+} ddsi_keyhash_t;
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_lifespan.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_LIFESPAN_H
+#define DDSI_LIFESPAN_H
+
+#include "dds/ddsrt/fibheap.h"
+#include "dds/ddsrt/time.h"
+#include "dds/ddsi/ddsi_domaingv.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef ddsrt_mtime_t (*sample_expired_cb_t)(void *hc, ddsrt_mtime_t tnow);
+
+struct lifespan_adm {
+  ddsrt_fibheap_t ls_exp_heap;              /* heap for sample expiration (lifespan) */
+  struct xevent *evt;                       /* xevent that triggers for sample with earliest expiration */
+  sample_expired_cb_t sample_expired_cb;    /* callback for expired sample; this cb can use lifespan_next_expired_locked to get next expired sample */
+  size_t fh_offset;                         /* offset of lifespan_adm element in whc or rhc */
+  size_t fhn_offset;                        /* offset of lifespan_fhnode element in whc or rhc node (sample) */
+};
+
+struct lifespan_fhnode {
+  ddsrt_fibheap_node_t heapnode;
+  ddsrt_mtime_t t_expire;
+};
+
+DDS_EXPORT void lifespan_init (const struct ddsi_domaingv *gv, struct lifespan_adm *lifespan_adm, size_t fh_offset, size_t fh_node_offset, sample_expired_cb_t sample_expired_cb);
+DDS_EXPORT void lifespan_fini (const struct lifespan_adm *lifespan_adm);
+DDS_EXPORT ddsrt_mtime_t lifespan_next_expired_locked (const struct lifespan_adm *lifespan_adm, ddsrt_mtime_t tnow, void **sample);
+DDS_EXPORT void lifespan_register_sample_real (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node);
+DDS_EXPORT void lifespan_unregister_sample_real (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node);
+
+DDS_INLINE_EXPORT inline void lifespan_register_sample_locked (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node)
+{
+  if (node->t_expire.v != DDS_NEVER)
+    lifespan_register_sample_real (lifespan_adm, node);
+}
+
+DDS_INLINE_EXPORT inline void lifespan_unregister_sample_locked (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node)
+{
+  if (node->t_expire.v != DDS_NEVER)
+    lifespan_unregister_sample_real (lifespan_adm, node);
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_LIFESPAN_H */
+

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_list_genptr.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_LIST_GENPTR_H
+#define DDSI_LIST_GENPTR_H
+
+#include <assert.h>
+#include "dds/export.h"
+#include "dds/ddsrt/types.h"
+#include "dds/ddsi/ddsi_list_tmpl.h"
+
+#define NOARG
+DDSI_LIST_TYPES_TMPL(generic_ptr_list, void *, NOARG, 32)
+DDSI_LIST_DECLS_TMPL(extern, generic_ptr_list, void *, ddsrt_attribute_unused)
+#undef NOARG
+
+#define DDSI_LIST_GENERIC_PTR_TYPES(prefix_) \
+typedef struct generic_ptr_list_node prefix_##_node_t; \
+typedef struct generic_ptr_list prefix_##_t; \
+typedef struct generic_ptr_list_iter prefix_##_iter_t; \
+typedef struct generic_ptr_list_iter_d prefix_##_iter_d_t;
+
+#define DDSI_LIST_GENERIC_PTR_DECL(linkage_, prefix_, elemT_, attrs_)                          \
+linkage_ void prefix_##_init (prefix_##_t *list) attrs_;                                       \
+linkage_ void prefix_##_free (prefix_##_t *list) attrs_;                                       \
+linkage_ elemT_ prefix_##_insert (prefix_##_t *list, elemT_ o) attrs_;                         \
+linkage_ elemT_ prefix_##_append (prefix_##_t *list, elemT_ o) attrs_;                         \
+linkage_ elemT_ prefix_##_iter_first (const prefix_##_t *list, prefix_##_iter_t *iter) attrs_; \
+linkage_ elemT_ prefix_##_iter_next (prefix_##_iter_t *iter) attrs_;                           \
+linkage_ elemT_ *prefix_##_iter_elem_addr (prefix_##_iter_t *iter) attrs_;                     \
+linkage_ elemT_ prefix_##_iter_d_first (prefix_##_t *list, prefix_##_iter_d_t *iter) attrs_;   \
+linkage_ elemT_ prefix_##_iter_d_next (prefix_##_iter_d_t *iter) attrs_;                       \
+linkage_ void prefix_##_iter_d_remove (prefix_##_iter_d_t *iter) attrs_;                       \
+linkage_ elemT_ prefix_##_remove (prefix_##_t *list, elemT_ o) attrs_;                         \
+linkage_ elemT_ prefix_##_take_first (prefix_##_t *list) attrs_;                               \
+linkage_ elemT_ prefix_##_take_last (prefix_##_t *list) attrs_;                                \
+linkage_ uint32_t prefix_##_count (const prefix_##_t *list) attrs_;                            \
+linkage_ void prefix_##_append_list (prefix_##_t *list, prefix_##_t *b) attrs_;                \
+linkage_ elemT_ *prefix_##_index_addr (prefix_##_t *list, uint32_t index) attrs_;              \
+linkage_ elemT_ prefix_##_index (prefix_##_t *list, uint32_t index) attrs_;
+
+#define DDSI_LIST_GENERIC_PTR_CODE(linkage_, prefix_, elemT_, equals_)                   \
+linkage_ void prefix_##_init (prefix_##_t *list) {                                       \
+  generic_ptr_list_init ((struct generic_ptr_list *) list);                          \
+}                                                                                        \
+linkage_ void prefix_##_free (prefix_##_t *list) {                                       \
+  generic_ptr_list_free ((struct generic_ptr_list *) list);                          \
+}                                                                                        \
+linkage_ elemT_ prefix_##_insert (prefix_##_t *list, elemT_ o) {                         \
+  return (elemT_) generic_ptr_list_insert ((struct generic_ptr_list *) list, (void *) o); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_append (prefix_##_t *list, elemT_ o) {                         \
+  return (elemT_) generic_ptr_list_append ((struct generic_ptr_list *) list, (void *) o); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_iter_first (const prefix_##_t *list, prefix_##_iter_t *iter) { \
+  return (elemT_) generic_ptr_list_iter_first ((struct generic_ptr_list *) list, (struct generic_ptr_list_iter *) iter); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_iter_next (prefix_##_iter_t *iter) {                           \
+  return (elemT_) generic_ptr_list_iter_next ((struct generic_ptr_list_iter *) iter);    \
+}                                                                                        \
+linkage_ elemT_ *prefix_##_iter_elem_addr (prefix_##_iter_t *iter) {                     \
+  return (elemT_ *) generic_ptr_list_iter_elem_addr ((struct generic_ptr_list_iter *) iter); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_iter_d_first (prefix_##_t *list, prefix_##_iter_d_t *iter) {   \
+  return (elemT_) generic_ptr_list_iter_d_first ((struct generic_ptr_list *) list, (struct generic_ptr_list_iter_d *) iter); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_iter_d_next (prefix_##_iter_d_t *iter) {                       \
+  return (elemT_) generic_ptr_list_iter_d_next ((struct generic_ptr_list_iter_d *) iter);\
+}                                                                                        \
+linkage_ void prefix_##_iter_d_remove (prefix_##_iter_d_t *iter) {                       \
+  generic_ptr_list_iter_d_remove ((struct generic_ptr_list_iter_d *) iter);              \
+}                                                                                        \
+linkage_ elemT_ prefix_##_remove (prefix_##_t *list, elemT_ o) {                         \
+  return (elemT_) generic_ptr_list_remove ((struct generic_ptr_list *) list, (void *) o, (generic_ptr_list_eq_fn) equals_); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_take_first (prefix_##_t *list) {                               \
+  return (elemT_) generic_ptr_list_take_first ((struct generic_ptr_list *) list);    \
+}                                                                                        \
+linkage_ elemT_ prefix_##_take_last (prefix_##_t *list) {                                \
+  return (elemT_) generic_ptr_list_take_last ((struct generic_ptr_list *) list);     \
+}                                                                                        \
+linkage_ uint32_t prefix_##_count (const prefix_##_t *list) {                            \
+  return generic_ptr_list_count ((struct generic_ptr_list *) list);                  \
+}                                                                                        \
+linkage_ void prefix_##_append_list (prefix_##_t *list, prefix_##_t *b) {                \
+  generic_ptr_list_append_list ((struct generic_ptr_list *) list, (struct generic_ptr_list *) b); \
+}                                                                                        \
+linkage_ elemT_ *prefix_##_index_addr (prefix_##_t *list, uint32_t index) {              \
+  return (elemT_ *) generic_ptr_list_index_addr ((struct generic_ptr_list *) list, index); \
+}                                                                                        \
+linkage_ elemT_ prefix_##_index (prefix_##_t *list, uint32_t index) {                    \
+  return (elemT_) generic_ptr_list_index ((struct generic_ptr_list *) list, index);  \
+}
+
+#endif /* DDSI_LIST_GENPTR_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_list_tmpl.h

@@ -0,0 +1,318 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_LIST_TMPL_H
+#define DDSI_LIST_TMPL_H
+
+#define DDSI_LIST_TYPES_TMPL(prefix_, elemT_, extension_, batch_) \
+struct prefix_##_node {                                           \
+  struct prefix_##_node *next;                                    \
+  uint32_t first, lastp1;                                         \
+  elemT_ ary[(batch_)];                                           \
+};                                                                \
+                                                                  \
+struct prefix_ {                                                  \
+  struct prefix_##_node *head;                                    \
+  struct prefix_##_node *tail;                                    \
+  uint32_t count;                                                 \
+  extension_                                                      \
+};                                                                \
+                                                                  \
+struct prefix_##_iter {                                           \
+  struct prefix_##_node *node;                                    \
+  uint32_t idx;                                                   \
+};                                                                \
+                                                                  \
+struct prefix_##_iter_d {                                         \
+  struct prefix_ *list;                                           \
+  struct prefix_##_node *node;                                    \
+  struct prefix_##_node *prev;                                    \
+  uint32_t idx;                                                   \
+};                                                                \
+                                                                  \
+typedef int (*prefix_##_eq_fn)(const elemT_, const elemT_);
+
+#ifndef NDEBUG
+#define DDSI_LIST_TMPL_POISON(x) do { x = (void *)1; } while (0)
+#else
+#define DDSI_LIST_TMPL_POISON(x) do {} while (0)
+#endif
+
+#define DDSI_LIST_DECLS_TMPL(linkage_, prefix_, elemT_, attrs_) \
+linkage_ void prefix_##_init (struct prefix_ *list) attrs_; \
+linkage_ void prefix_##_free (struct prefix_ *list) attrs_; \
+linkage_ elemT_ prefix_##_insert (struct prefix_ *list, elemT_ o) attrs_; \
+linkage_ elemT_ prefix_##_append (struct prefix_ *list, elemT_ o) attrs_; \
+linkage_ elemT_ prefix_##_iter_first (const struct prefix_ *list, struct prefix_##_iter *iter) attrs_; \
+linkage_ elemT_ prefix_##_iter_next (struct prefix_##_iter *iter) attrs_; \
+linkage_ elemT_ *prefix_##_iter_elem_addr (struct prefix_##_iter *iter) attrs_; \
+linkage_ elemT_ prefix_##_iter_d_first (struct prefix_ *list, struct prefix_##_iter_d *iter) attrs_; \
+linkage_ elemT_ prefix_##_iter_d_next (struct prefix_##_iter_d *iter) attrs_; \
+linkage_ void prefix_##_iter_d_remove (struct prefix_##_iter_d *iter) attrs_; \
+linkage_ elemT_ prefix_##_remove (struct prefix_ *list, elemT_ o, prefix_##_eq_fn) attrs_; \
+linkage_ elemT_ prefix_##_take_first (struct prefix_ *list) attrs_; \
+linkage_ elemT_ prefix_##_take_last (struct prefix_ *list) attrs_; \
+linkage_ uint32_t prefix_##_count (const struct prefix_ *list) attrs_; \
+linkage_ void prefix_##_append_list (struct prefix_ *list, struct prefix_ *b) attrs_; \
+linkage_ elemT_ *prefix_##_index_addr (struct prefix_ *list, uint32_t index) attrs_; \
+linkage_ elemT_ prefix_##_index (struct prefix_ *list, uint32_t index) attrs_;
+
+#define DDSI_LIST_CODE_TMPL(linkage_, prefix_, elemT_, null_, malloc_, free_) \
+linkage_ void prefix_##_init (struct prefix_ *list)                   \
+{                                                                     \
+  list->head = NULL;                                                  \
+  list->tail = NULL;                                                  \
+  list->count = 0;                                                    \
+}                                                                     \
+                                                                      \
+linkage_ void prefix_##_free (struct prefix_ *list)                   \
+{                                                                     \
+  /* Note: just free, not re-init */                                  \
+  struct prefix_##_node *n;                                           \
+  while ((n = list->head) != NULL)                                    \
+  {                                                                   \
+    list->head = n->next;                                             \
+    free_ (n);                                                        \
+  }                                                                   \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_insert (struct prefix_ *list, elemT_ o)     \
+{                                                                     \
+  struct prefix_##_node *n;                                           \
+  const uint32_t bs = (uint32_t) (sizeof (n->ary) / sizeof (n->ary[0])); \
+  if (list->head != NULL && list->head->first > 0)                    \
+    n = list->head;                                                   \
+  else                                                                \
+  {                                                                   \
+    if ((n = (malloc_ (sizeof (struct prefix_##_node)))) == NULL)     \
+      return null_;                                                   \
+    n->next = list->head;                                             \
+    n->first = n->lastp1 = bs;                                        \
+    if (list->head == NULL)                                           \
+      list->tail = n;                                                 \
+    list->head = n;                                                   \
+  }                                                                   \
+  n->ary[--n->first] = o;                                             \
+  list->count++;                                                      \
+  return o;                                                           \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_append (struct prefix_ *list, elemT_ o)     \
+{                                                                     \
+  struct prefix_##_node *n;                                           \
+  const uint32_t bs = (uint32_t) (sizeof (n->ary) / sizeof (n->ary[0])); \
+  if (list->head != NULL && list->tail->lastp1 < bs)                  \
+    n = list->tail;                                                   \
+  else                                                                \
+  {                                                                   \
+    if ((n = (malloc_ (sizeof (struct prefix_##_node)))) == NULL)     \
+      return null_;                                                   \
+    n->next = NULL;                                                   \
+    n->first = n->lastp1 = 0;                                         \
+    if (list->head == NULL)                                           \
+      list->head = n;                                                 \
+    else                                                              \
+      list->tail->next = n;                                           \
+    list->tail = n;                                                   \
+  }                                                                   \
+  n->ary[n->lastp1++] = o;                                            \
+  list->count++;                                                      \
+  return o;                                                           \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_iter_first (const struct prefix_ *list, struct prefix_##_iter *iter) \
+{                                                                     \
+  iter->node = list->head;                                            \
+  if (iter->node == NULL)                                             \
+  {                                                                   \
+    iter->idx = 0;                                                    \
+    return null_;                                                     \
+  }                                                                   \
+  iter->idx = iter->node->first;                                      \
+  if (iter->node->first < iter->node->lastp1)                         \
+    return iter->node->ary[iter->idx];                                \
+  return null_;                                                       \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_iter_next (struct prefix_##_iter *iter)     \
+{                                                                     \
+  /* You MAY NOT call _list_iter_next after having received a null    \
+    * pointer from _iter_first or _iter_next */                       \
+  assert (iter->node != NULL);                                        \
+  if (iter->idx+1 < iter->node->lastp1)                               \
+    return iter->node->ary[++iter->idx];                              \
+  if (iter->node->next == NULL)                                       \
+    return null_;                                                     \
+  iter->node = iter->node->next;                                      \
+  iter->idx = iter->node->first;                                      \
+  return iter->node->ary[iter->idx];                                  \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ *prefix_##_iter_elem_addr (struct prefix_##_iter *iter) \
+{                                                                     \
+  assert (iter->node != NULL);                                        \
+  return &iter->node->ary[iter->idx];                                 \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_iter_d_first (struct prefix_ *list, struct prefix_##_iter_d *iter) \
+{                                                                     \
+  iter->list = list;                                                  \
+  iter->node = list->head;                                            \
+  iter->prev = NULL;                                                  \
+  if (iter->node == NULL)                                             \
+  {                                                                   \
+    iter->idx = 0;                                                    \
+    return null_;                                                     \
+  }                                                                   \
+  iter->idx = iter->node->first;                                      \
+  if (iter->node->first < iter->node->lastp1)                         \
+    return iter->node->ary[iter->idx];                                \
+  return null_;                                                       \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_iter_d_next (struct prefix_##_iter_d *iter) \
+{                                                                     \
+  /* You MAY NOT call _list_iter_d_next after having received a null  \
+    * pointer from _iter_d_first or _iter_d_next */                   \
+  if (iter->node == NULL)                                             \
+    return prefix_##_iter_d_first (iter->list, iter);                 \
+  if (iter->idx+1 < iter->node->lastp1)                               \
+    return iter->node->ary[++iter->idx];                              \
+  if (iter->node->next == NULL)                                       \
+    return null_;                                                     \
+  iter->prev = iter->node;                                            \
+  iter->node = iter->node->next;                                      \
+  iter->idx = iter->node->first;                                      \
+  return iter->node->ary[iter->idx];                                  \
+}                                                                     \
+                                                                      \
+linkage_ void prefix_##_iter_d_remove (struct prefix_##_iter_d *iter) \
+{                                                                     \
+  struct prefix_ * const list = iter->list;                           \
+  struct prefix_##_node * const n = iter->node;                       \
+  uint32_t j;                                                         \
+  assert(iter->node);                                                 \
+  list->count--;                                                      \
+  for (j = iter->idx; j > n->first; j--)                              \
+    n->ary[j] = n->ary[j-1];                                          \
+  n->first++;                                                         \
+  if (n->first == n->lastp1)                                          \
+  {                                                                   \
+    if (n == list->tail)                                              \
+      list->tail = iter->prev;                                        \
+    if (iter->prev)                                                   \
+    {                                                                 \
+      iter->prev->next = n->next;                                     \
+      iter->node = iter->prev;                                        \
+      iter->idx = iter->prev->lastp1;                                 \
+      DDSI_LIST_TMPL_POISON(iter->prev);                              \
+    }                                                                 \
+    else                                                              \
+    {                                                                 \
+      list->head = n->next;                                           \
+      iter->node = NULL; /* removed first entry, restart */           \
+    }                                                                 \
+    free_ (n);                                                        \
+  }                                                                   \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_remove (struct prefix_ *list, elemT_ o, prefix_##_eq_fn equals) \
+{                                                                     \
+  struct prefix_##_iter_d iter;                                       \
+  elemT_ obj;                                                         \
+  for (obj = prefix_##_iter_d_first (list, &iter); !(equals (obj, null_)); obj = prefix_##_iter_d_next (&iter)) \
+  {                                                                   \
+    if (equals (obj, o))                                              \
+    {                                                                 \
+      prefix_##_iter_d_remove (&iter);                                \
+      return obj;                                                     \
+    }                                                                 \
+  }                                                                   \
+  return null_;                                                       \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_take_first (struct prefix_ *list)           \
+{                                                                     \
+  if (list->count == 0)                                               \
+    return null_;                                                     \
+  struct prefix_##_iter_d iter;                                       \
+  elemT_ obj = prefix_##_iter_d_first (list, &iter);                  \
+  prefix_##_iter_d_remove (&iter);                                    \
+  return obj;                                                         \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_take_last (struct prefix_ *list)            \
+{                                                                     \
+  if (list->count == 0)                                               \
+    return null_;                                                     \
+  struct prefix_##_iter_d iter;                                       \
+  uint32_t i;                                                         \
+  elemT_ obj;                                                         \
+  obj = prefix_##_iter_d_first (list, &iter);                         \
+  for (i = 0; i < list->count - 1; i++)                               \
+    obj = prefix_##_iter_d_next (&iter);                              \
+  prefix_##_iter_d_remove (&iter);                                    \
+  return obj;                                                         \
+}                                                                     \
+                                                                      \
+linkage_ uint32_t prefix_##_count (const struct prefix_ *list)        \
+{                                                                     \
+  return list->count;                                                 \
+}                                                                     \
+                                                                      \
+linkage_ void prefix_##_append_list (struct prefix_ *list, struct prefix_ *b) \
+{                                                                     \
+  if (list->head == NULL)                                             \
+    *list = *b;                                                       \
+  else if (b->head != NULL)                                           \
+  {                                                                   \
+    list->tail->next = b->head;                                       \
+    list->tail = b->tail;                                             \
+    list->count += b->count;                                          \
+  }                                                                   \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ *prefix_##_index_addr (struct prefix_ *list, uint32_t index) \
+{                                                                     \
+  struct prefix_##_node *n;                                           \
+  uint32_t pos = 0;                                                   \
+  if (index >= list->count)                                           \
+    return NULL;                                                      \
+  if (index == list->count - 1)                                       \
+  {                                                                   \
+    n = list->tail;                                                   \
+    pos = list->count - (n->lastp1 - n->first);                       \
+  }                                                                   \
+  else                                                                \
+  {                                                                   \
+    for (n = list->head; n; n = n->next)                              \
+    {                                                                 \
+      const uint32_t c = n->lastp1 - n->first;                        \
+      if (pos + c > index)                                            \
+        break;                                                        \
+      pos += c;                                                       \
+    }                                                                 \
+  }                                                                   \
+  if (n == NULL)                                                      \
+    return NULL;                                                      \
+  assert (pos <= index && index < pos + n->lastp1 - n->first);        \
+  return &n->ary[n->first + (index - pos)];                           \
+}                                                                     \
+                                                                      \
+linkage_ elemT_ prefix_##_index (struct prefix_ *list, uint32_t index) \
+{                                                                     \
+  elemT_ *p = prefix_##_index_addr (list, index);                     \
+  if (p == NULL)                                                      \
+    return null_;                                                     \
+  return *p;                                                          \
+}
+
+#endif /* DDSI_LIST_TMPL_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_locator.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_LOCATOR_H
+#define DDSI_LOCATOR_H
+
+#include <stdint.h>
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_tran_factory;
+struct ddsi_tran_conn;
+
+/* address field in locator maintained in network byte order, the rest in host */
+typedef struct {
+  int32_t kind;
+  uint32_t port;
+  unsigned char address[16];
+} ddsi_locator_t;
+typedef struct {
+  ddsi_locator_t c;
+  struct ddsi_tran_conn *conn;
+} ddsi_xlocator_t;
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_LOCATOR_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_mcgroup.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_MCGROUP_H
+#define DDSI_MCGROUP_H
+
+#include "dds/ddsi/ddsi_tran.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct nn_group_membership;
+
+struct nn_group_membership *new_group_membership (void);
+void free_group_membership (struct nn_group_membership *mship);
+int ddsi_join_mc (const struct ddsi_domaingv *gv, struct nn_group_membership *mship, ddsi_tran_conn_t conn, const ddsi_locator_t *srcip, const ddsi_locator_t *mcip);
+int ddsi_leave_mc (const struct ddsi_domaingv *gv, struct nn_group_membership *mship, ddsi_tran_conn_t conn, const ddsi_locator_t *srcip, const ddsi_locator_t *mcip);
+void ddsi_transfer_group_membership (struct nn_group_membership *mship, ddsi_tran_conn_t conn, ddsi_tran_conn_t newconn);
+int ddsi_rejoin_transferred_mcgroups (const struct ddsi_domaingv *gv, struct nn_group_membership *mship, ddsi_tran_conn_t conn);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_ownip.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_OWNIP_H
+#define DDSI_OWNIP_H
+
+#include <stdbool.h>
+
+#include "dds/ddsrt/ifaddrs.h"
+#include "dds/ddsrt/sockets.h"
+#include "dds/ddsi/ddsi_locator.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_domaingv;
+
+struct nn_interface {
+  ddsi_locator_t loc; // actual interface address
+  ddsi_locator_t extloc; // interface address to advertise in discovery
+  ddsi_locator_t netmask;
+  uint32_t if_index;
+  unsigned mc_capable: 1;
+  unsigned mc_flaky: 1;
+  unsigned point_to_point: 1;
+  unsigned loopback: 1;
+  unsigned link_local: 1;
+  unsigned prefer_multicast: 1;
+  int32_t priority;
+  char *name;
+};
+
+int find_own_ip (struct ddsi_domaingv *gv);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_OWNIP_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_participant.h

@@ -0,0 +1,241 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PARTICIPANT_H
+#define DDSI_PARTICIPANT_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsrt/fibheap.h"
+#include "dds/ddsrt/sync.h"
+#include "dds/ddsi/ddsi_entity.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define DPG_LOCAL 1
+#define DPG_REMOTE 2
+
+extern const ddsrt_fibheap_def_t ldur_fhdef;
+extern const ddsrt_fibheap_def_t lease_fhdef_pp;
+
+struct deleted_participant {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t guid;
+  unsigned for_what;
+  ddsrt_mtime_t t_prune;
+};
+
+struct deleted_participants_admin {
+  ddsrt_mutex_t deleted_participants_lock;
+  ddsrt_avl_tree_t deleted_participants;
+  const ddsrt_log_cfg_t *logcfg;
+  int64_t delay;
+};
+
+struct avail_entityid_set {
+  struct inverse_uint32_set x;
+};
+
+enum ddsi_participant_state {
+  DDSI_PARTICIPANT_STATE_INITIALIZING,
+  DDSI_PARTICIPANT_STATE_OPERATIONAL,
+  DDSI_PARTICIPANT_STATE_DELETE_STARTED,
+  DDSI_PARTICIPANT_STATE_DELETING_BUILTINS
+};
+
+struct ddsi_participant
+{
+  struct ddsi_entity_common e;
+  dds_duration_t lease_duration; /* constant */
+  uint32_t bes; /* built-in endpoint set */
+  unsigned is_ddsi2_pp: 1; /* true for the "federation leader", the ddsi2 participant itself in OSPL; FIXME: probably should use this for broker mode as well ... */
+  struct ddsi_plist *plist; /* settings/QoS for this participant */
+  struct xevent *spdp_xevent; /* timed event for periodically publishing SPDP */
+  struct xevent *pmd_update_xevent; /* timed event for periodically publishing ParticipantMessageData */
+  ddsi_locator_t m_locator; /* this is always a unicast address, it is set if it is in the many unicast mode */
+  ddsi_tran_conn_t m_conn; /* this is connection to m_locator, if it is set, this is used */
+  struct avail_entityid_set avail_entityids; /* available entity ids [e.lock] */
+  ddsrt_mutex_t refc_lock;
+  int32_t user_refc; /* number of non-built-in endpoints in this participant [refc_lock] */
+  int32_t builtin_refc; /* number of built-in endpoints in this participant [refc_lock] */
+  enum ddsi_participant_state state; /* current state of this participant [refc_lock] */
+  ddsrt_fibheap_t ldur_auto_wr; /* Heap that contains lease duration for writers with automatic liveliness in this participant */
+  ddsrt_atomic_voidp_t minl_man; /* clone of min(leaseheap_man) */
+  ddsrt_fibheap_t leaseheap_man; /* keeps leases for this participant's writers (with liveliness manual-by-participant) */
+#ifdef DDS_HAS_SECURITY
+  struct participant_sec_attributes *sec_attr;
+  nn_security_info_t security_info;
+#endif
+};
+
+/* Interface for glue code between the OpenSplice kernel and the DDSI
+   entities. These all return 0 iff successful. All GIDs supplied
+   __MUST_BE_UNIQUE__. All hell may break loose if they aren't.
+
+   All delete operations synchronously remove the entity being deleted
+   from the various global hash tables on GUIDs. This ensures no new
+   operations can be invoked by the glue code, discovery, protocol
+   messages, &c.  The entity is then scheduled for garbage collection.
+
+     There is one exception: a participant without built-in
+     endpoints: that one synchronously reaches reference count zero
+     and is then freed immediately.
+
+     If ddsi_new_writer () and/or ddsi_new_reader () may be called in parallel to
+     ddsi_delete_participant (), trouble ensues. The current glue code
+     performs all local discovery single-threaded, and can't ever get
+     into that issue.
+
+   A garbage collector thread is used to perform the actual freeing of
+   an entity, but it never does so before all threads have made
+   sufficient progress to guarantee they are not using that entity any
+   longer, with the exception of use via internal pointers in the
+   entity data structures.
+
+   An example of the latter is that (proxy) endpoints have a pointer
+   to the owning (proxy) participant, but the (proxy) participant is
+   reference counted to make this safe.
+
+   The case of a proxy writer is particularly complicated is it has to
+   pass through a multiple-stage delay in the garbage collector before
+   it may be freed: first there is the possibility of a parallel
+   delete or protocol message, then there is still the possibility of
+   data in a delivery queue.  This is dealt by requeueing garbage
+   collection and sending bubbles through the delivery queue. */
+
+/* Set this flag in new_participant to prevent the creation SPDP, SEDP
+   and PMD readers for that participant.  It doesn't really need it,
+   they all share the information anyway.  But you do need it once. */
+#define RTPS_PF_NO_BUILTIN_READERS 1u
+/* Set this flag to prevent the creation of SPDP, SEDP and PMD
+   writers.  It will then rely on the "privileged participant", which
+   must exist at the time of creation.  It creates a reference to that
+   "privileged participant" to ensure it won't disappear too early. */
+#define RTPS_PF_NO_BUILTIN_WRITERS 2u
+/* Set this flag to mark the participant as the "privileged
+   participant", there can only be one of these.  The privileged
+   participant MUST have all builtin readers and writers. */
+#define RTPS_PF_PRIVILEGED_PP 4u
+  /* Set this flag to mark the participant as is_ddsi2_pp. */
+#define RTPS_PF_IS_DDSI2_PP 8u
+  /* Set this flag to mark the participant as an local entity only. */
+#define RTPS_PF_ONLY_LOCAL 16u
+
+
+void ddsi_participant_add_wr_lease_locked (struct ddsi_participant * pp, const struct ddsi_writer * wr);
+void ddsi_participant_remove_wr_lease_locked (struct ddsi_participant * pp, struct ddsi_writer * wr);
+dds_return_t ddsi_participant_allocate_entityid (ddsi_entityid_t *id, uint32_t kind, struct ddsi_participant *pp);
+void ddsi_participant_release_entityid (struct ddsi_participant *pp, ddsi_entityid_t id);
+void ddsi_gc_participant_lease (struct gcreq *gcreq);
+void ddsi_prune_deleted_participant_guids (struct deleted_participants_admin *admin, ddsrt_mtime_t tnow);
+void ddsi_remove_deleted_participant_guid (struct deleted_participants_admin *admin, const struct ddsi_guid *guid, unsigned for_what);
+void ddsi_remember_deleted_participant_guid (struct deleted_participants_admin *admin, const struct ddsi_guid *guid);
+struct ddsi_participant *ddsi_ref_participant (struct ddsi_participant *pp, const struct ddsi_guid *guid_of_refing_entity);
+void ddsi_unref_participant (struct ddsi_participant *pp, const struct ddsi_guid *guid_of_refing_entity);
+struct deleted_participants_admin *ddsi_deleted_participants_admin_new (const ddsrt_log_cfg_t *logcfg, int64_t delay);
+void ddsi_deleted_participants_admin_free (struct deleted_participants_admin *admin);
+int ddsi_is_deleted_participant_guid (struct deleted_participants_admin *admin, const struct ddsi_guid *guid, unsigned for_what);
+
+
+
+/**
+ * @brief Create a new participant in the domain
+ *
+ * @param[out] ppguid
+ *               On successful return: the GUID of the new participant;
+ *               Undefined on error.
+ * @param[in]  flags
+ *               Zero or more of:
+ *               - RTPS_PF_NO_BUILTIN_READERS   do not create discovery readers in new ppant
+ *               - RTPS_PF_NO_BUILTIN_WRITERS   do not create discvoery writers in new ppant
+ *               - RTPS_PF_PRIVILEGED_PP        FIXME: figure out how to describe this ...
+ *               - RTPS_PF_IS_DDSI2_PP          FIXME: OSPL holdover - there is no DDSI2E here
+ *               - RTPS_PF_ONLY_LOCAL           FIXME: not used, it seems
+ * @param[in]  plist
+ *               Parameters/QoS for this participant
+ *
+ * @returns A dds_return_t indicating success or failure.
+ *
+ * @retval DDS_RETCODE_OK
+ *               Success, there is now a local participant with the GUID stored in
+ *               *ppguid
+ * @retval DDS_RETCODE_OUT_OF_RESOURCES
+ *               Failed to allocate a new GUID (note: currently this will always
+ *               happen after 2**24-1 successful calls to new_participant ...).
+ * @retval DDS_RETCODE_OUT_OF_RESOURCES
+ *               The configured maximum number of participants has been reached.
+*/
+DDS_EXPORT dds_return_t ddsi_new_participant (struct ddsi_guid *ppguid, struct ddsi_domaingv *gv, unsigned flags, const struct ddsi_plist *plist);
+
+/**
+ * @brief Initiate the deletion of the participant:
+ * - dispose/unregister built-in topic
+ * - list it as one of the recently deleted participants
+ * - remote it from the GUID hash tables
+ * - schedule the scare stuff to really delete it via the GC
+ *
+ * It is ok to call delete_participant without deleting all DDSI-level
+ * readers/writers: those will simply be deleted.  (New ones can't be
+ * created anymore because the participant can no longer be located via
+ * the hash tables).
+ *
+ * @param[in]  ppguid
+ *               GUID of the participant to be deleted.
+ *
+ * @returns A dds_return_t indicating success or failure.
+ *
+ * @retval DDS_RETCODE_OK
+ *               Success, it is no longer visible and GC events have
+ *               been scheduled for eventual deleting of all remaining
+ *               readers and writers and freeing of memory
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *               ppguid lookup failed.
+*/
+DDS_EXPORT dds_return_t ddsi_delete_participant (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid);
+
+/**
+ * @brief Updates the parameters list for this participant and trigger sending
+ * an updated SPDP message.
+ *
+ * @param[in] pp The participant
+ * @param[in] plist The new parameters
+ */
+DDS_EXPORT void ddsi_update_participant_plist (struct ddsi_participant *pp, const struct ddsi_plist *plist);
+
+/**
+ * @brief Gets the interval for PMD messages, which is the minimal lease duration for writers
+ * with auto liveliness in this participant, or the participants lease duration if shorter
+ *
+ * @param[in] pp The participant
+ * @returns The PMD interval of the participant
+ */
+DDS_EXPORT dds_duration_t ddsi_participant_get_pmd_interval (struct ddsi_participant *pp);
+
+/**
+ * @brief To obtain the builtin writer to be used for publishing SPDP, SEDP, PMD stuff for
+ * PP and its endpoints, given the entityid. If PP has its own writer, use it; else use the
+ * privileged participant.
+ *
+ * @param[in] pp The participant
+ * @param[in] entityid The entity ID of the writer
+ * @returns The built-in writer
+ */
+DDS_EXPORT struct ddsi_writer *ddsi_get_builtin_writer (const struct ddsi_participant *pp, unsigned entityid);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_PARTICIPANT_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_plist.h

@@ -0,0 +1,526 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PLIST_H
+#define DDSI_PLIST_H
+
+#include "dds/ddsrt/bswap.h"
+#include "dds/ddsi/q_feature_check.h"
+#include "dds/ddsi/ddsi_xqos.h"
+#include "dds/ddsi/ddsi_keyhash.h"
+#include "dds/ddsi/ddsi_tran.h" /* FIXME: eliminate */
+#include "dds/ddsi/ddsi_typelookup.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define PP_PROTOCOL_VERSION                     ((uint64_t)1 <<  0)
+#define PP_VENDORID                             ((uint64_t)1 <<  1)
+#define PP_UNICAST_LOCATOR                      ((uint64_t)1 <<  2)
+#define PP_MULTICAST_LOCATOR                    ((uint64_t)1 <<  3)
+#define PP_DEFAULT_UNICAST_LOCATOR              ((uint64_t)1 <<  4)
+#define PP_DEFAULT_MULTICAST_LOCATOR            ((uint64_t)1 <<  5)
+#define PP_METATRAFFIC_UNICAST_LOCATOR          ((uint64_t)1 <<  6)
+#define PP_METATRAFFIC_MULTICAST_LOCATOR        ((uint64_t)1 <<  7)
+#define PP_EXPECTS_INLINE_QOS                   ((uint64_t)1 <<  8)
+#define PP_PARTICIPANT_MANUAL_LIVELINESS_COUNT  ((uint64_t)1 <<  9)
+#define PP_PARTICIPANT_BUILTIN_ENDPOINTS        ((uint64_t)1 << 10)
+#define PP_PARTICIPANT_LEASE_DURATION           ((uint64_t)1 << 11)
+#define PP_CONTENT_FILTER_PROPERTY              ((uint64_t)1 << 12)
+#define PP_PARTICIPANT_GUID                     ((uint64_t)1 << 13)
+#define PP_PARTICIPANT_ENTITYID                 ((uint64_t)1 << 14)
+#define PP_GROUP_GUID                           ((uint64_t)1 << 15)
+#define PP_GROUP_ENTITYID                       ((uint64_t)1 << 16)
+#define PP_BUILTIN_ENDPOINT_SET                 ((uint64_t)1 << 17)
+#define PP_PROPERTIES                           ((uint64_t)1 << 18)
+#define PP_TYPE_MAX_SIZE_SERIALIZED             ((uint64_t)1 << 19)
+#define PP_CYCLONE_REDUNDANT_NETWORKING         ((uint64_t)1 << 20)
+#define PP_KEYHASH                              ((uint64_t)1 << 21)
+#define PP_STATUSINFO                           ((uint64_t)1 << 22)
+#define PP_ORIGINAL_WRITER_INFO                 ((uint64_t)1 << 23)
+#define PP_ENDPOINT_GUID                        ((uint64_t)1 << 24)
+#define PP_ADLINK_PARTICIPANT_VERSION_INFO      ((uint64_t)1 << 26)
+#define PP_ADLINK_TYPE_DESCRIPTION              ((uint64_t)1 << 27)
+#define PP_COHERENT_SET                         ((uint64_t)1 << 28)
+#ifdef DDS_HAS_SSM
+#define PP_READER_FAVOURS_SSM                   ((uint64_t)1 << 29)
+#endif
+#define PP_DOMAIN_ID                            ((uint64_t)1 << 30)
+#define PP_DOMAIN_TAG                           ((uint64_t)1 << 31)
+/* Security extensions. */
+#define PP_IDENTITY_TOKEN                       ((uint64_t)1 << 32)
+#define PP_PERMISSIONS_TOKEN                    ((uint64_t)1 << 33)
+#define PP_ENDPOINT_SECURITY_INFO               ((uint64_t)1 << 34)
+#define PP_PARTICIPANT_SECURITY_INFO            ((uint64_t)1 << 35)
+#define PP_IDENTITY_STATUS_TOKEN                ((uint64_t)1 << 36)
+#define PP_DATA_TAGS                            ((uint64_t)1 << 37)
+/* Other stuff */
+#define PP_CYCLONE_RECEIVE_BUFFER_SIZE          ((uint64_t)1 << 38)
+#define PP_CYCLONE_TOPIC_GUID                   ((uint64_t)1 << 39)
+#define PP_CYCLONE_REQUESTS_KEYHASH             ((uint64_t)1 << 40)
+
+/* Set for unrecognized parameters that are in the reserved space or
+   in our own vendor-specific space that have the
+   PID_UNRECOGNIZED_INCOMPATIBLE_FLAG set (see DDSI 2.1 9.6.2.2.1) */
+#define PP_INCOMPATIBLE                         ((uint64_t)1 << 63)
+
+#define NN_ADLINK_PARTICIPANT_VERSION_INFO_FIXED_CDRSIZE (24)
+
+#define NN_ADLINK_FL_KERNEL_SEQUENCE_NUMBER     (1u << 0)
+#define NN_ADLINK_FL_DISCOVERY_INCLUDES_GID     (1u << 1)
+#define NN_ADLINK_FL_PTBES_FIXED_0              (1u << 2)
+#define NN_ADLINK_FL_DDSI2_PARTICIPANT_FLAG     (1u << 3)
+#define NN_ADLINK_FL_PARTICIPANT_IS_DDSI2       (1u << 4)
+#define NN_ADLINK_FL_MINIMAL_BES_MODE           (1u << 5)
+#define NN_ADLINK_FL_SUPPORTS_STATUSINFOX       (1u << 5)
+/* SUPPORTS_STATUSINFOX: when set, also means any combination of
+   write/unregister/dispose supported */
+
+/* For locators one could patch the received message data to create
+   singly-linked lists (parameter header -> offset of next entry in
+   list relative to current), allowing aliasing of the data. But that
+   requires modifying the data. For string sequences the length does
+   the same thing. */
+struct nn_locators_one {
+  struct nn_locators_one *next;
+  ddsi_locator_t loc;
+};
+
+typedef struct nn_locators {
+  uint32_t n;
+  struct nn_locators_one *first;
+  struct nn_locators_one *last;
+} nn_locators_t;
+
+typedef uint32_t nn_ipv4address_t;
+
+typedef uint32_t nn_port_t;
+
+#ifdef DDS_HAS_SECURITY
+typedef struct nn_tag {
+  char *name;
+  char *value;
+} nn_tag_t;
+
+typedef struct nn_tagseq {
+  uint32_t n;
+  nn_tag_t *tags;
+} nn_tagseq_t;
+
+typedef struct nn_datatags {
+  nn_tagseq_t tags;
+} nn_datatags_t;
+#endif
+
+#ifdef DDS_HAS_SSM
+typedef struct nn_reader_favours_ssm {
+  uint32_t state; /* default is false */
+} nn_reader_favours_ssm_t;
+#endif
+
+#ifdef DDS_HAS_SECURITY
+typedef struct nn_dataholder
+{
+  char *class_id;
+  dds_propertyseq_t properties;
+  dds_binarypropertyseq_t binary_properties;
+} nn_dataholder_t;
+
+typedef struct nn_dataholderseq {
+  uint32_t n;
+  nn_dataholder_t *tags;
+} nn_dataholderseq_t;
+
+typedef nn_dataholder_t nn_token_t;
+
+/* Used for both nn_participant_security_info and nn_endpoint_security_info. */
+typedef struct nn_security_info
+{
+  uint32_t security_attributes;
+  uint32_t plugin_security_attributes;
+} nn_security_info_t;
+
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_READ_PROTECTED                         (1u <<  0)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_WRITE_PROTECTED                        (1u <<  1)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_DISCOVERY_PROTECTED                    (1u <<  2)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_SUBMESSAGE_PROTECTED                   (1u <<  3)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_PAYLOAD_PROTECTED                      (1u <<  4)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_KEY_PROTECTED                          (1u <<  5)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_LIVELINESS_PROTECTED                   (1u <<  6)
+#define NN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_VALID                                  (1u << 31)
+
+#define NN_PLUGIN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_SUBMESSAGE_ENCRYPTED            (1u <<  0)
+#define NN_PLUGIN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_PAYLOAD_ENCRYPTED               (1u <<  1)
+#define NN_PLUGIN_ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_SUBMESSAGE_ORIGIN_AUTHENTICATED (1u <<  2)
+
+#define NN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_RTPS_PROTECTED                      (1u <<  0)
+#define NN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_DISCOVERY_PROTECTED                 (1u <<  1)
+#define NN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_LIVELINESS_PROTECTED                (1u <<  2)
+#define NN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_VALID                               (1u << 31)
+
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_RTPS_ENCRYPTED               (1u <<  0)
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_DISCOVERY_ENCRYPTED          (1u <<  1)
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_LIVELINESS_ENCRYPTED         (1u <<  2)
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_RTPS_AUTHENTICATED           (1u <<  3)
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_DISCOVERY_AUTHENTICATED      (1u <<  4)
+#define NN_PLUGIN_PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_LIVELINESS_AUTHENTICATED     (1u <<  5)
+#else
+struct nn_security_info;
+typedef struct nn_security_info nn_security_info_t;
+#endif
+
+typedef struct nn_adlink_participant_version_info
+{
+  uint32_t version;
+  uint32_t flags;
+  uint32_t unused[3];
+  char *internals;
+} nn_adlink_participant_version_info_t;
+
+typedef struct ddsi_plist {
+  uint64_t present;
+  uint64_t aliased;
+
+  dds_qos_t qos;
+
+  nn_protocol_version_t protocol_version;
+  nn_vendorid_t vendorid;
+  nn_locators_t unicast_locators;
+  nn_locators_t multicast_locators;
+  nn_locators_t default_unicast_locators;
+  nn_locators_t default_multicast_locators;
+  nn_locators_t metatraffic_unicast_locators;
+  nn_locators_t metatraffic_multicast_locators;
+
+  unsigned char expects_inline_qos;
+  nn_count_t participant_manual_liveliness_count;
+  uint32_t participant_builtin_endpoints;
+  dds_duration_t participant_lease_duration;
+  /* nn_content_filter_property_t content_filter_property; */
+  ddsi_guid_t participant_guid;
+  ddsi_guid_t endpoint_guid;
+  ddsi_guid_t group_guid;
+  ddsi_guid_t topic_guid;
+#if 0 /* reserved, rather than NIY */
+  nn_entityid_t participant_entityid;
+  nn_entityid_t group_entityid;
+#endif
+  uint32_t builtin_endpoint_set;
+  /* int type_max_size_serialized; */
+  ddsi_keyhash_t keyhash;
+  uint32_t statusinfo;
+  nn_adlink_participant_version_info_t adlink_participant_version_info;
+  char *type_description;
+  nn_sequence_number_t coherent_set_seqno;
+#ifdef DDS_HAS_SECURITY
+  nn_token_t identity_token;
+  nn_token_t permissions_token;
+  nn_security_info_t endpoint_security_info;
+  nn_security_info_t participant_security_info;
+  nn_token_t identity_status_token;
+  nn_datatags_t data_tags;
+#endif
+#ifdef DDS_HAS_SSM
+  nn_reader_favours_ssm_t reader_favours_ssm;
+#endif
+  uint32_t domain_id;
+  char *domain_tag;
+  uint32_t cyclone_receive_buffer_size;
+  unsigned char cyclone_requests_keyhash;
+  unsigned char cyclone_redundant_networking;
+} ddsi_plist_t;
+
+
+/***/
+
+typedef struct ddsi_plist_src {
+  nn_protocol_version_t protocol_version; /**< input protocol version */
+  nn_vendorid_t vendorid;                 /**< vendor code for input */
+  int encoding;                           /**< PL_CDR_LE or PL_CDR_BE */
+  const unsigned char *buf;               /**< input buffer */
+  size_t bufsz;                           /**< size of input buffer */
+  bool strict;                            /**< whether to be strict in checking */
+} ddsi_plist_src_t;
+
+DDS_EXPORT extern const ddsi_plist_t ddsi_default_plist_participant;
+
+/**
+ * @brief Initialize global parameter-list parsing indices.
+ *
+ * These indices are derived from compile-time constant tables.  This only does the work
+ * once; ideally it would be done at compile time instead.
+ */
+void ddsi_plist_init_tables (void);
+
+/**
+ * @brief Initialize a ddsi_plist_t as an empty object
+ *
+ * In principle, this only clears the "present" and "aliased" bitmasks.  A debug build
+ * additionally initializes all other bytes to 0x55.
+ *
+ * @param[out] dest  plist_t to be initialized.
+ */
+DDS_EXPORT void ddsi_plist_init_empty (ddsi_plist_t *dest);
+
+/**
+ * @brief Extend "a" with selected entries present in "b"
+ *
+ * This copies into "a" any entries present in "b" that are included in "pmask" and
+ * "qmask" and missing in "a".  It doesn't touch any entries already present in "a".
+ * Calling this on an empty "a" with all bits set in "pmask" and "qmask" all is equivalent
+ * to copying "b" into "a"; calling this with "pmask" and "qmask" both 0 copies nothing.
+ *
+ * @param[in,out] a       ddsi_plist_t to be extended
+ * @param[in]     b       ddsi_plist_t from which to copy entries
+ * @param[in]     pmask   subset of non-QoS part of b (if PP_X is set, include X)
+ * @param[in]     qmask   subset of QoS part of b (if QP_X is set, include X)
+ */
+DDS_EXPORT void ddsi_plist_mergein_missing (ddsi_plist_t *a, const ddsi_plist_t *b, uint64_t pmask, uint64_t qmask);
+
+/**
+ * @brief Copy "src" to "dst"
+ *
+ * @param[out]    dst     destination, any contents are overwritten
+ * @param[in]     src     source ddsi_plist_t
+ */
+DDS_EXPORT void ddsi_plist_copy (ddsi_plist_t *dst, const ddsi_plist_t *src);
+
+/**
+ * @brief Duplicate "src"
+ *
+ * @param[in]     src     ddsi_plist_t to be duplicated
+ *
+ * @returns a new (allocated using ddsrt_malloc) ddsi_plist_t containing a copy of "src".
+ */
+DDS_EXPORT ddsi_plist_t *ddsi_plist_dup (const ddsi_plist_t *src);
+
+/**
+ * @brief Initialize an ddsi_plist_t from a PL_CDR_{LE,BE} paylaod.
+ *
+ * @param[in]  pwanted
+ *               PP_... flags indicating which non-QoS parameters are of interest, treated as
+ *               a hint.  Parameters in the input that are outside the mask may or may not be
+ *               ignored.
+ * @param[in]  qwanted
+ *               QP_... flags indicating which QoS settings are of interest, and is treated as
+ *               a hint.  Parameters in the input that are outside the mask may or may not be
+ *               ignored.
+ * @param[in]  src
+ *               Serialized payload to be parsed, validated and copied into dest
+ *               - protocol_version is the version protocol version according to which the list
+ *                 should be parsed
+ *               - vendorid is the vendor id code for the source of the parameter list (for
+ *                 handling vendor-specific parameters and compatibility workarounds)
+ *               - encoding is PL_CDR_LE or PL_CDR_BE
+ *               - buf is a pointer to the first parameter header
+ *               - bufsz is the size in bytes of the input buffer
+ * @param[in]  gv
+ *               Global context, used for locator kind lookups and tracing
+ * @param[out] dest
+ *               Filled with the recognized parameters in the input if successful, otherwise
+ *               initialized to an empty parameter list.  Where possible, pointers alias the
+ *               input (indicated by the "aliased" bits in the plist/xqos structures), but
+ *               some things cannot be aliased (e.g., the array of pointers to strings for a
+ *               sequence of strings).
+ *               Generally, ddsi_plist_fini should be called when done with the parameter list,
+ *               even when ddsi_plist_unlias or ddsi_xqos_unlias hasn't been called.
+ * @param[out] nextafterplist
+ *               If non-NULL, *nextafterplist is set to the first byte following the parameter
+ *               list sentinel on successful parse, or to NULL on failure
+ *
+ * @returns A dds_return_t indicating success or failure.
+ *
+ * @retval DDS_RETCODE_OK
+ *               All parameters valid (or ignored), dest and *nextafterplist have been set
+ *               accordingly.
+ * @retval DDS_INCONSISTENT_POLICY
+ *               All individual settings are valid, but there are inconsistencies between
+ *               dependent settings.
+ * @retval DDS_RETCODE_BAD_PARAMETER
+ *               Input contained invalid data; dest is cleared, *nextafterplist is NULL.
+ * @retval DDS_RETCODE_UNSUPPORTED
+ *               Input contained an unrecognized parameter with the "incompatible-if-unknown"
+ *               flag set; dest is cleared, *nextafterplist is NULL.
+ */
+DDS_EXPORT dds_return_t ddsi_plist_init_frommsg (ddsi_plist_t *dest, char **nextafterplist, uint64_t pwanted, uint64_t qwanted, const ddsi_plist_src_t *src, struct ddsi_domaingv const * const gv);
+
+/**
+ * @brief Free memory owned by "ps"
+ *
+ * A ddsi_plist_t may own other allocated blocks of memory, depending on which fields are
+ * set, their types and whether they are marked as "aliased".  This function releases any
+ * such memory owned by "ps", but not "ps" itself.  Afterward, the contents of "ps" is
+ * undefined and must not be used again without initialising it (either via
+ * `ddsi_plist_init_empty`, `ddsi_plist_init_frommsg` or `ddsi_plist_copy`.
+ *
+ * @param[in] ps   ddsi_plist_t for which to free memory
+ */
+DDS_EXPORT void ddsi_plist_fini (ddsi_plist_t *ps);
+
+/**
+ * @brief Free memory owned by "plist" for a subset of the entries
+ *
+ * A ddsi_plist_t may own other allocated blocks of memory, depending on which fields are
+ * set, their types and whether they are marked as "aliased".  This function releases any
+ * such memory owned by "plist" for entries included in "pmask" and "qmask".  The
+ * "present" and "aliased" bits are cleared accordingly.
+ *
+ * @param[in,out] plist  ddsi_plist_t for which to free memory
+ * @param[in]     pmask  subset of non-QoS part of b (if PP_X is set, free X if present)
+ * @param[in]     qmask  subset of QoS part of b (if QP_X is set, free X if present)
+ */
+DDS_EXPORT void ddsi_plist_fini_mask (ddsi_plist_t *plist, uint64_t pmask, uint64_t qmask);
+
+/**
+ * @brief Replace any memory "plist" aliases by copies it owns
+ *
+ * A ddsi_plist_t may can reference other memory without owning it.  This functions allows
+ * one to replace any such aliased memory by copies, allowing one to free the original
+ * copy.
+ *
+ * @param[in,out] plist  ddsi_plist_t for which to replace all aliased memory by owned
+ *                       copies
+ */
+DDS_EXPORT void ddsi_plist_unalias (ddsi_plist_t *plist);
+
+/**
+ * @brief Add selected entries in "ps" to a message in native endianness.
+ *
+ * This functions appends to "m" a serialized copy of the the entries selected by
+ * "pwanted"/"qwanted" and present in "ps".  Each copy is preceded by a 4-byte header with
+ * a parameter id and length (conform the PL_CDR representation).  It does *not* add a
+ * sentinel to allow adding additional data to the parameter list.  A sentinel can be
+ * added using `nn_xmsg_addpar_sentinel`.
+ *
+ * @param[in,out] m        message to append the parameters to
+ * @param[in]     ps       source
+ * @param[in]     pwanted  subset of non-QoS part of ps (if PP_X is set, add X if present)
+ * @param[in]     qwanted  subset of QoS part of ps (if QP_X is set, add X if present)
+ */
+DDS_EXPORT void ddsi_plist_addtomsg (struct nn_xmsg *m, const ddsi_plist_t *ps, uint64_t pwanted, uint64_t qwanted);
+
+/**
+ * @brief Add selected entries in "ps" to a message with selected endianness.
+ *
+ * This functions appends to "m" a serialized copy of the the entries selected by
+ * "pwanted"/"qwanted" and present in "ps".  Each copy is preceded by a 4-byte header with
+ * a parameter id and length (conform the PL_CDR representation).  It does *not* add a
+ * sentinel to allow adding additional data to the parameter list.  A sentinel can be
+ * added using `nn_xmsg_addpar_sentinel`.
+ *
+ * @param[in,out] m        message to append the parameters to
+ * @param[in]     ps       source
+ * @param[in]     pwanted  subset of non-QoS part of ps (if PP_X is set, add X if present)
+ * @param[in]     qwanted  subset of QoS part of ps (if QP_X is set, add X if present)
+ * @param[in]     bo       byte order
+ */
+DDS_EXPORT void ddsi_plist_addtomsg_bo (struct nn_xmsg *m, const ddsi_plist_t *ps, uint64_t pwanted, uint64_t qwanted, enum ddsrt_byte_order_selector bo);
+
+/**
+ * @brief Determine the set of entries in which "x" differs from "y"
+ *
+ * This computes the entries set in "x" but not set in "y", not set in "x" but set in "y",
+ * or set in both "x" and "y" but to a different value.  It returns this set reduced to
+ * only those included in "pmask"/"qmask", that is, if bit X is clear in "pmask", bit X
+ * will be clear in "pdelta", etc.
+ *
+ * @param[out] pdelta    non-QoS entries that are different and not masked out
+ * @param[out] qdelta    QoS entries that are different and not masked out
+ * @param[in]  x         one of the two plists to compare
+ * @param[in]  y         other plist to compare
+ * @param[in]  pmask     subset of non-QoS part to be compared
+ * @param[in]  qmask     subset of QoS part to be compared
+ */
+DDS_EXPORT void ddsi_plist_delta (uint64_t *pdelta, uint64_t *qdelta, const ddsi_plist_t *x, const ddsi_plist_t *y, uint64_t pmask, uint64_t qmask);
+
+/**
+ * @brief Formats plist using `ddsi_plist_print` and writes it to the trace.
+ *
+ * @param[in] cat        log category to use
+ * @param[in] logcfg     logging configuration
+ * @param[in] plist      parameter list to be logged
+ */
+DDS_EXPORT void ddsi_plist_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const ddsi_plist_t *plist);
+
+/**
+ * @brief Formats plist into a buffer
+ *
+ * The representation is somewhat cryptic as all enumerated types are dumped as numbers
+ * and timestamps are durations as nanoseconds with "infinite" represented as
+ * 9223372036854775807 (INT64_MAX).
+ *
+ * @param[out] buf       buffer to store the formatted representation in
+ * @param[in]  bufsize   size of buffer, if > 0, there will be a terminating 0 in buf on
+ *                       return
+ * @param[in]  plist     parameter list to be formatted as a string
+ *
+ * @returns number of bytes written to buf, excluding a terminating 0.
+ */
+DDS_EXPORT size_t ddsi_plist_print (char * __restrict buf, size_t bufsize, const ddsi_plist_t *plist);
+
+struct nn_rsample_info;
+
+/**
+ * @brief Scan a PL_CDR-serialized parameter list, checking structure and copying some information to "dest".
+ *
+ * This checks that the serialized data is structured correctly (proper aligned headers,
+ * declared lengths within bounds, a sentinel at the end).  It sets the `statusinfo` of
+ * `dest` to the least significant two bits (UNREGISTER and DISPOSE) of a status info
+ * parameter if present, else to 0.  A statusinfo parameter that is too short (less than 4
+ * bytes) is treated as an invalid input.
+ *
+ * It sets the `complex_qos` flag if it encounters any parameter other than a statusinfo
+ * limited to those two bits, keyhash or padding, and clears it otherwise.
+ *
+ * It clears the `bswap` flag in `dest` if the input is in native endianness, and sets it
+ * otherwise.
+ *
+ * @param[out] dest     internal sample info of which some fields will be set
+ * @param[in]  src      input description (see `ddsi_plist_init_frommsg`)
+ * @param[out] keyhashp set to point to keyhash in inline QoS if present, else to NULL
+ * @param[in]  gv       global context (for logging)
+ *
+ * @return pointer to the first byte following the sentinel if the input is well-formed, a
+ * null pointer if it is not.
+*/
+DDS_EXPORT unsigned char *ddsi_plist_quickscan (struct nn_rsample_info *dest, const ddsi_keyhash_t **keyhashp, const ddsi_plist_src_t *src, struct ddsi_domaingv const * const gv);
+
+/**
+ * @brief Locate a specific parameter in a PL_CDR-serialized parameter list
+ *
+ * This scans the serialized data until it encounters the sentinel, recording whether the
+ * specified parameter occurs and returning the size and address of it in `buf`.
+ *
+ * If `needle` is PID_SENTINEL, it will simply check well-formedness of the input and
+ * `needlep` and `needlesz` must both be null pointers.  If `needle` is not PID_SENTINEL,
+ * `needlep` and `needlesz` may not be null pointers.
+ *
+ * @param[in]  buf       serialized parameter list to scan
+ * @param[in]  bufsz     length of serialized form
+ * @param[in]  encoding  encoding of `buf`, either PL_CDR_LE or PL_CDR_BE
+ * @param[in]  needle    parameter id to look for
+ * @param[out] needlep   where to store the address of the `needle` value
+ * @param[out] needlesz  where to store the size of the `needle` value
+ *
+ * @return Whether input was valid and if so, whether it contains the needle.
+ *
+ * @retval DDS_RETCODE_BAD_PARAMETER  invalid input
+ * @retval DDS_RETCODE_NOT_FOUND      valid input, `needle` not present
+ * @retval DDS_RETCODE_OK             valid input, `needle` is present
+*/
+DDS_EXPORT dds_return_t ddsi_plist_findparam_checking (const void *buf, size_t bufsz, uint16_t encoding, nn_parameterid_t needle, void **needlep, size_t *needlesz);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_PLIST_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_plist_generic.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright(c) 2019 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PLIST_GENERIC_H
+#define DDSI_PLIST_GENERIC_H
+
+#include <stddef.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "dds/export.h"
+#include "dds/ddsrt/bswap.h"
+#include "dds/ddsrt/attributes.h"
+#include "dds/ddsrt/retcode.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* Instructions for the generic serializer (&c) that handles most parameters.
+   The "packed" attribute means single-byte instructions on GCC and Clang. */
+enum pserop {
+  XSTOP,
+  XO, /* octet sequence */
+  XS, /* string */
+  XE1, XE2, XE3, /* enum 0..1, 0..2, 0..3 */
+  Xs, /* int16_t */
+  Xi, Xix2, Xix3, Xix4, /* int32_t, 1 .. 4 in a row */
+  Xu, Xux2, Xux3, Xux4, Xux5, /* uint32_t, 1 .. 5 in a row */
+  XD, XDx2, /* duration, 1 .. 2 in a row */
+  Xl,       /* int64_t */
+  Xo, Xox2, /* octet, 1 .. 2 in a row */
+  Xb, Xbx2, Xbx3, Xbx4, Xbx5, /* boolean, 1 .. 5 in a row */
+  XbCOND, /* boolean: compare to ignore remainder if false (for use_... flags) */
+  XbPROP, /* boolean: omit in serialized form; skip serialization if false; always true on deserialize */
+  XG, /* GUID */
+  XK, /* keyhash */
+  XQ, /* arbitary non-nested sequence */
+  Xopt, /* remainder is optional on deser, 0-init if not present */
+} ddsrt_attribute_packed;
+
+DDS_EXPORT void plist_fini_generic (void * __restrict dst, const enum pserop *desc, bool aliased);
+DDS_EXPORT void plist_ser_generic_size_embeddable (size_t *dstoff, const void *src, size_t srcoff, const enum pserop * __restrict desc);
+DDS_EXPORT dds_return_t plist_deser_generic (void * __restrict dst, const void * __restrict src, size_t srcsize, bool bswap, const enum pserop * __restrict desc);
+DDS_EXPORT dds_return_t plist_deser_generic_srcoff (void * __restrict dst, const void * __restrict src, size_t srcsize, size_t *srcoff, bool bswap, const enum pserop * __restrict desc);
+DDS_EXPORT dds_return_t plist_ser_generic_embeddable (char * const data, size_t *dstoff, const void *src, size_t srcoff, const enum pserop * __restrict desc, enum ddsrt_byte_order_selector bo);
+DDS_EXPORT dds_return_t plist_ser_generic (void **dst, size_t *dstsize, const void *src, const enum pserop * __restrict desc);
+DDS_EXPORT dds_return_t plist_ser_generic_be (void **dst, size_t *dstsize, const void *src, const enum pserop * __restrict desc);
+DDS_EXPORT dds_return_t plist_unalias_generic (void * __restrict dst, const enum pserop * __restrict desc);
+DDS_EXPORT bool plist_equal_generic (const void *srcx, const void *srcy, const enum pserop * __restrict desc);
+DDS_EXPORT size_t plist_memsize_generic (const enum pserop * __restrict desc);
+DDS_EXPORT size_t plist_print_generic (char * __restrict buf, size_t bufsize, const void * __restrict src, const enum pserop * __restrict desc);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_pmd.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PMD_H
+#define DDSI_PMD_H
+
+#include <stdint.h>
+#include "dds/ddsrt/time.h"
+#include "dds/ddsi/ddsi_serdata.h"
+#include "dds/ddsi/ddsi_plist_generic.h"
+#include "dds/ddsi/ddsi_guid.h"
+#include "dds/ddsi/ddsi_xqos.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_domaingv;
+struct thread_state;
+struct ddsi_guid;
+struct nn_xpack;
+struct ddsi_participant;
+struct receiver_state;
+
+typedef struct ParticipantMessageData {
+  ddsi_guid_prefix_t participantGuidPrefix;
+  uint32_t kind; /* really 4 octets */
+  ddsi_octetseq_t value;
+} ParticipantMessageData_t;
+
+extern const enum pserop participant_message_data_ops[];
+extern size_t participant_message_data_nops;
+extern const enum pserop participant_message_data_ops_key[];
+extern size_t participant_message_data_nops_key;
+
+void write_pmd_message_guid (struct ddsi_domaingv * const gv, struct ddsi_guid *pp_guid, unsigned pmd_kind);
+void write_pmd_message (struct thread_state * const ts1, struct nn_xpack *xp, struct ddsi_participant *pp, unsigned pmd_kind);
+void handle_pmd_message (const struct receiver_state *rst, struct ddsi_serdata *sample_common);
+
+#if defined (__cplusplus)
+}
+#endif
+#endif /* DDSI_PMD_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_portmapping.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright(c) 2019 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PORTMAPPING_H
+#define DDSI_PORTMAPPING_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+enum ddsi_port {
+  DDSI_PORT_MULTI_DISC,
+  DDSI_PORT_MULTI_DATA,
+  DDSI_PORT_UNI_DISC,
+  DDSI_PORT_UNI_DATA
+};
+
+struct ddsi_portmapping {
+  uint32_t base;
+  uint32_t dg;
+  uint32_t pg;
+  uint32_t d0;
+  uint32_t d1;
+  uint32_t d2;
+  uint32_t d3;
+};
+
+struct ddsi_config;
+
+bool ddsi_valid_portmapping (const struct ddsi_config *config, int32_t participant_index, char *msg, size_t msgsize);
+uint32_t ddsi_get_port (const struct ddsi_config *config, enum ddsi_port which, int32_t participant_index);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_PORTMAPPING_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_proxy_endpoint.h

@@ -0,0 +1,143 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PROXY_ENDPOINT_H
+#define DDSI_PROXY_ENDPOINT_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsrt/atomics.h"
+#include "dds/ddsi/ddsi_guid.h"
+#include "dds/ddsi/ddsi_domaingv.h"
+#include "dds/ddsi/ddsi_entity.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_proxy_participant;
+struct dds_qos;
+struct addrset;
+
+struct ddsi_proxy_endpoint_common
+{
+  struct ddsi_proxy_participant *proxypp; /* counted backref to proxy participant */
+  struct ddsi_proxy_endpoint_common *next_ep; /* next \ endpoint belonging to this proxy participant */
+  struct ddsi_proxy_endpoint_common *prev_ep; /* prev / -- this is in arbitrary ordering */
+  struct dds_qos *xqos; /* proxy endpoint QoS lives here; FIXME: local ones should have it moved to common as well */
+  struct addrset *as; /* address set to use for communicating with this endpoint */
+  ddsi_guid_t group_guid; /* 0:0:0:0 if not available */
+  nn_vendorid_t vendor; /* cached from proxypp->vendor */
+  seqno_t seq; /* sequence number of most recent SEDP message */
+#ifdef DDS_HAS_TYPE_DISCOVERY
+  struct ddsi_type_pair *type_pair;
+#endif
+#ifdef DDS_HAS_SECURITY
+  nn_security_info_t security_info;
+#endif
+};
+
+struct ddsi_generic_proxy_endpoint {
+  struct ddsi_entity_common e;
+  struct ddsi_proxy_endpoint_common c;
+};
+
+struct ddsi_proxy_writer {
+  struct ddsi_entity_common e;
+  struct ddsi_proxy_endpoint_common c;
+  ddsrt_avl_tree_t readers; /* matching LOCAL readers, see pwr_rd_match */
+  int32_t n_reliable_readers; /* number of those that are reliable */
+  int32_t n_readers_out_of_sync; /* number of those that require special handling (accepting historical data, waiting for historical data set to become complete) */
+  seqno_t last_seq; /* highest known seq published by the writer, not last delivered */
+  uint32_t last_fragnum; /* last known frag for last_seq, or UINT32_MAX if last_seq not partial */
+  nn_count_t nackfragcount; /* last nackfrag seq number */
+  ddsrt_atomic_uint32_t next_deliv_seq_lowword; /* lower 32-bits for next sequence number that will be delivered; for generating acks; 32-bit so atomic reads on all supported platforms */
+  unsigned deliver_synchronously: 1; /* iff 1, delivery happens straight from receive thread for non-historical data; else through delivery queue "dqueue" */
+  unsigned have_seen_heartbeat: 1; /* iff 1, we have received at least on heartbeat from this proxy writer */
+  unsigned local_matching_inprogress: 1; /* iff 1, we are still busy matching local readers; this is so we don't deliver incoming data to some but not all readers initially */
+  unsigned alive: 1; /* iff 1, the proxy writer is alive (lease for this proxy writer is not expired); field may be modified only when holding both pwr->e.lock and pwr->c.proxypp->e.lock */
+  unsigned filtered: 1; /* iff 1, builtin proxy writer uses content filter, which affects heartbeats and gaps. */
+  unsigned redundant_networking: 1; /* 1 iff requests receiving data on all advertised interfaces */
+#ifdef DDS_HAS_SSM
+  unsigned supports_ssm: 1; /* iff 1, this proxy writer supports SSM */
+#endif
+#ifdef DDS_HAS_SHM
+  unsigned is_iceoryx : 1;
+#endif
+  uint32_t alive_vclock; /* virtual clock counting transitions between alive/not-alive */
+  struct nn_defrag *defrag; /* defragmenter for this proxy writer; FIXME: perhaps shouldn't be for historical data */
+  struct nn_reorder *reorder; /* message reordering for this proxy writer, out-of-sync readers can have their own, see pwr_rd_match */
+  struct nn_dqueue *dqueue; /* delivery queue for asynchronous delivery (historical data is always delivered asynchronously) */
+  struct xeventq *evq; /* timed event queue to be used for ACK generation */
+  struct ddsi_local_reader_ary rdary; /* LOCAL readers for fast-pathing; if not fast-pathed, fall back to scanning local_readers */
+  ddsi2direct_directread_cb_t ddsi2direct_cb;
+  void *ddsi2direct_cbarg;
+  struct lease *lease;
+};
+
+
+typedef int (*ddsi_filter_fn_t)(struct ddsi_writer *wr, struct ddsi_proxy_reader *prd, struct ddsi_serdata *serdata);
+
+struct ddsi_proxy_reader {
+  struct ddsi_entity_common e;
+  struct ddsi_proxy_endpoint_common c;
+  unsigned deleting: 1; /* set when being deleted */
+  unsigned is_fict_trans_reader: 1; /* only true when it is certain that is a fictitious transient data reader (affects built-in topic generation) */
+  unsigned requests_keyhash: 1; /* 1 iff this reader would like to receive keyhashes */
+  unsigned redundant_networking: 1; /* 1 iff requests receiving data on all advertised interfaces */
+#ifdef DDS_HAS_SSM
+  unsigned favours_ssm: 1; /* iff 1, this proxy reader favours SSM when available */
+#endif
+#ifdef DDS_HAS_SHM
+  unsigned is_iceoryx: 1;
+#endif
+  ddsrt_avl_tree_t writers; /* matching LOCAL writers */
+  uint32_t receive_buffer_size; /* assumed receive buffer size inherited from proxypp */
+  ddsi_filter_fn_t filter;
+};
+
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_pwr_readers_treedef;
+DDS_EXPORT extern const ddsrt_avl_treedef_t ddsi_prd_writers_treedef;
+
+void ddsi_proxy_writer_set_alive_may_unlock (struct ddsi_proxy_writer *pwr, bool notify);
+int ddsi_proxy_writer_set_notalive (struct ddsi_proxy_writer *pwr, bool notify);
+void ddsi_proxy_writer_get_alive_state (struct ddsi_proxy_writer *pwr, struct ddsi_alive_state *st);
+struct ddsi_entity_common *ddsi_entity_common_from_proxy_endpoint_common (const struct ddsi_proxy_endpoint_common *c);
+bool ddsi_is_proxy_endpoint (const struct ddsi_entity_common *e);
+
+
+/* To create a new proxy writer or reader; the proxy participant is
+   determined from the GUID and must exist. */
+DDS_EXPORT int ddsi_new_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const struct ddsi_plist *plist, struct nn_dqueue *dqueue, struct xeventq *evq, ddsrt_wctime_t timestamp, seqno_t seq);
+DDS_EXPORT int ddsi_new_proxy_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const struct ddsi_plist *plist, ddsrt_wctime_t timestamp, seqno_t seq
+#ifdef DDS_HAS_SSM
+, int favours_ssm
+#endif
+);
+
+/* To delete a proxy writer or reader; these synchronously hide it
+   from the outside world, preventing it from being matched to a
+   reader or writer. Actual deletion is scheduled in the future, when
+   no outstanding references may still exist (determined by checking
+   thread progress, &c.). */
+DDS_EXPORT int ddsi_delete_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, ddsrt_wctime_t timestamp, int isimplicit);
+DDS_EXPORT int ddsi_delete_proxy_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, ddsrt_wctime_t timestamp, int isimplicit);
+
+DDS_EXPORT void ddsi_update_proxy_reader (struct ddsi_proxy_reader *prd, seqno_t seq, struct addrset *as, const struct dds_qos *xqos, ddsrt_wctime_t timestamp);
+DDS_EXPORT void ddsi_update_proxy_writer (struct ddsi_proxy_writer *pwr, seqno_t seq, struct addrset *as, const struct dds_qos *xqos, ddsrt_wctime_t timestamp);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_PROXY_ENDPOINT_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_proxy_participant.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_PROXY_PARTICIPANT_H
+#define DDSI_PROXY_PARTICIPANT_H
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+#include "dds/ddsrt/atomics.h"
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsrt/fibheap.h"
+#include "dds/ddsi/ddsi_domaingv.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/ddsi_topic.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct lease;
+struct ddsi_plist;
+struct addrset;
+struct ddsi_proxy_endpoint_common;
+
+struct ddsi_proxy_participant
+{
+  struct ddsi_entity_common e;
+  uint32_t refc; /* number of proxy endpoints (both user & built-in; not groups, they don't have a life of their own) */
+  nn_vendorid_t vendor; /* vendor code from discovery */
+  unsigned bes; /* built-in endpoint set */
+  ddsi_guid_t privileged_pp_guid; /* if this PP depends on another PP for its SEDP writing */
+  struct ddsi_plist *plist; /* settings/QoS for this participant */
+  ddsrt_atomic_voidp_t minl_auto; /* clone of min(leaseheap_auto) */
+  ddsrt_fibheap_t leaseheap_auto; /* keeps leases for this proxypp and leases for pwrs (with liveliness automatic) */
+  ddsrt_atomic_voidp_t minl_man; /* clone of min(leaseheap_man) */
+  ddsrt_fibheap_t leaseheap_man; /* keeps leases for this proxypp and leases for pwrs (with liveliness manual-by-participant) */
+  struct lease *lease; /* lease for this proxypp */
+  struct addrset *as_default; /* default address set to use for user data traffic */
+  struct addrset *as_meta; /* default address set to use for discovery traffic */
+  struct ddsi_proxy_endpoint_common *endpoints; /* all proxy endpoints can be reached from here */
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+  ddsrt_avl_tree_t topics;
+#endif
+  seqno_t seq; /* sequence number of most recent SPDP message */
+  uint32_t receive_buffer_size; /* assumed size of receive buffer, used to limit bursts involving this proxypp */
+  unsigned implicitly_created : 1; /* participants are implicitly created for Cloud/Fog discovered endpoints */
+  unsigned is_ddsi2_pp: 1; /* if this is the federation-leader on the remote node */
+  unsigned minimal_bes_mode: 1;
+  unsigned lease_expired: 1;
+  unsigned deleting: 1;
+  unsigned proxypp_have_spdp: 1;
+  unsigned owns_lease: 1;
+  unsigned redundant_networking: 1; /* 1 iff requests receiving data on all advertised interfaces */
+#ifdef DDS_HAS_SECURITY
+  nn_security_info_t security_info;
+  struct ddsi_proxy_participant_sec_attributes *sec_attr;
+#endif
+};
+
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+extern const ddsrt_avl_treedef_t ddsi_proxypp_proxytp_treedef;
+#endif
+
+/* Set when this proxy participant is created implicitly and has to be deleted upon disappearance
+   of its last endpoint.  FIXME: Currently there is a potential race with adding a new endpoint
+   in parallel to deleting the last remaining one. The endpoint will then be created, added to the
+   proxy participant and then both are deleted. With the current single-threaded discovery
+   this can only happen when it is all triggered by lease expiry. */
+#define CF_IMPLICITLY_CREATED_PROXYPP          (1 << 0)
+/* Set when this proxy participant is a DDSI2 participant, to help Cloud figure out whom to send
+   discovery data when used in conjunction with the networking bridge */
+#define CF_PARTICIPANT_IS_DDSI2                (1 << 1)
+/* Set when this proxy participant is not to be announced on the built-in topics yet */
+#define CF_PROXYPP_NO_SPDP                     (1 << 2)
+
+int ddsi_update_proxy_participant_plist_locked (struct ddsi_proxy_participant *proxypp, seqno_t seq, const struct ddsi_plist *datap, ddsrt_wctime_t timestamp);
+void ddsi_proxy_participant_reassign_lease (struct ddsi_proxy_participant *proxypp, struct lease *newlease);
+void ddsi_purge_proxy_participants (struct ddsi_domaingv *gv, const ddsi_xlocator_t *loc, bool delete_from_as_disc);
+int ddsi_ref_proxy_participant (struct ddsi_proxy_participant *proxypp, struct ddsi_proxy_endpoint_common *c);
+void ddsi_unref_proxy_participant (struct ddsi_proxy_participant *proxypp, struct ddsi_proxy_endpoint_common *c);
+void ddsi_proxy_participant_add_pwr_lease_locked (struct ddsi_proxy_participant * proxypp, const struct ddsi_proxy_writer * pwr);
+void ddsi_proxy_participant_remove_pwr_lease_locked (struct ddsi_proxy_participant * proxypp, struct ddsi_proxy_writer * pwr);
+
+/* To create or delete a new proxy participant: "guid" MUST have the
+   pre-defined participant entity id. Unlike ddsi_delete_participant (),
+   deleting a proxy participant will automatically delete all its
+   readers & writers. Delete removes the participant from a hash table
+   and schedules the actual deletion.
+
+   TODO: what about proxy participants without built-in endpoints?
+*/
+
+DDS_EXPORT bool ddsi_new_proxy_participant (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, uint32_t bes, const struct ddsi_guid *privileged_pp_guid, struct addrset *as_default, struct addrset *as_meta, const struct ddsi_plist *plist, dds_duration_t tlease_dur, nn_vendorid_t vendor, unsigned custom_flags, ddsrt_wctime_t timestamp, seqno_t seq);
+DDS_EXPORT int ddsi_delete_proxy_participant_by_guid (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, ddsrt_wctime_t timestamp, int isimplicit);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_PROXY_PARTICIPANT_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_raweth.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_RAWETH_H
+#define DDSI_RAWETH_H
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+int ddsi_raweth_init (struct ddsi_domaingv *gv);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_rhc.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_RHC_H
+#define DDSI_RHC_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "dds/export.h"
+#include "dds/features.h"
+
+/* DDS_EXPORT inline i.c.w. __attributes__((visibility...)) and some compilers: */
+#include "dds/ddsrt/attributes.h"
+#include "dds/ddsrt/time.h"
+#include "dds/ddsi/ddsi_guid.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct dds_qos;
+struct ddsi_rhc;
+struct ddsi_tkmap_instance;
+struct ddsi_serdata;
+
+struct ddsi_writer_info
+{
+  ddsi_guid_t guid;
+  bool auto_dispose;
+  int32_t ownership_strength;
+  uint64_t iid;
+#ifdef DDS_HAS_LIFESPAN
+  ddsrt_mtime_t lifespan_exp;
+#endif
+};
+
+typedef void (*ddsi_rhc_free_t) (struct ddsi_rhc *rhc);
+typedef bool (*ddsi_rhc_store_t) (struct ddsi_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo, struct ddsi_serdata * __restrict sample, struct ddsi_tkmap_instance * __restrict tk);
+typedef void (*ddsi_rhc_unregister_wr_t) (struct ddsi_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo);
+typedef void (*ddsi_rhc_relinquish_ownership_t) (struct ddsi_rhc * __restrict rhc, const uint64_t wr_iid);
+typedef void (*ddsi_rhc_set_qos_t) (struct ddsi_rhc *rhc, const struct dds_qos *qos);
+
+struct ddsi_rhc_ops {
+  ddsi_rhc_store_t store;
+  ddsi_rhc_unregister_wr_t unregister_wr;
+  ddsi_rhc_relinquish_ownership_t relinquish_ownership;
+  ddsi_rhc_set_qos_t set_qos;
+  ddsi_rhc_free_t free;
+};
+
+struct ddsi_rhc {
+  const struct ddsi_rhc_ops *ops;
+};
+
+DDS_INLINE_EXPORT inline bool ddsi_rhc_store (struct ddsi_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo, struct ddsi_serdata * __restrict sample, struct ddsi_tkmap_instance * __restrict tk) {
+  return rhc->ops->store (rhc, wrinfo, sample, tk);
+}
+DDS_INLINE_EXPORT inline void ddsi_rhc_unregister_wr (struct ddsi_rhc * __restrict rhc, const struct ddsi_writer_info * __restrict wrinfo) {
+  rhc->ops->unregister_wr (rhc, wrinfo);
+}
+DDS_INLINE_EXPORT inline void ddsi_rhc_relinquish_ownership (struct ddsi_rhc * __restrict rhc, const uint64_t wr_iid) {
+  rhc->ops->relinquish_ownership (rhc, wr_iid);
+}
+DDS_INLINE_EXPORT inline void ddsi_rhc_set_qos (struct ddsi_rhc *rhc, const struct dds_qos *qos) {
+  rhc->ops->set_qos (rhc, qos);
+}
+DDS_INLINE_EXPORT inline void ddsi_rhc_free (struct ddsi_rhc *rhc) {
+  rhc->ops->free (rhc);
+}
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_RHC_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_security_exchange.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SECURITY_EXCHANGE_H
+#define DDSI_SECURITY_EXCHANGE_H
+
+#include "dds/features.h"
+
+#ifdef DDS_HAS_SECURITY
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "dds/ddsi/q_rtps.h"
+#include "dds/ddsi/q_radmin.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/ddsi_security_msg.h"
+
+
+#define GMCLASSID_SECURITY_PARTICIPANT_CRYPTO_TOKENS    "dds.sec.participant_crypto_tokens"
+#define GMCLASSID_SECURITY_DATAWRITER_CRYPTO_TOKENS     "dds.sec.datawriter_crypto_tokens"
+#define GMCLASSID_SECURITY_DATAREADER_CRYPTO_TOKENS     "dds.sec.datareader_crypto_tokens"
+
+bool write_auth_handshake_message(const struct ddsi_participant *pp, const struct ddsi_proxy_participant *proxypp, nn_dataholderseq_t *mdata, bool request, const nn_message_identity_t *related_message_id);
+void handle_auth_handshake_message(const struct receiver_state *rst, ddsi_entityid_t wr_entity_id, struct ddsi_serdata *sample);
+void handle_crypto_exchange_message(const struct receiver_state *rst, struct ddsi_serdata *sample);
+void auth_get_serialized_participant_data(struct ddsi_participant *pp, ddsi_octetseq_t *seq);
+bool write_crypto_participant_tokens(const struct ddsi_participant *pp, const struct ddsi_proxy_participant *proxypp, const nn_dataholderseq_t *tokens);
+bool write_crypto_writer_tokens(const struct ddsi_writer *wr, const struct ddsi_proxy_reader *prd, const nn_dataholderseq_t *tokens);
+bool write_crypto_reader_tokens(const struct ddsi_reader *rd, const struct ddsi_proxy_writer *pwr, const nn_dataholderseq_t *tokens);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#else /* DDS_HAS_SECURITY */
+
+#define volatile_secure_data_filter NULL
+
+#endif /* DDS_HAS_SECURITY */
+
+#endif /* DDSI_SECURITY_EXCHANGE_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_security_msg.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SECURITY_MSG_H
+#define DDSI_SECURITY_MSG_H
+
+#include "dds/features.h"
+
+#ifdef DDS_HAS_SECURITY
+
+#include "dds/ddsi/ddsi_plist.h"
+#include "dds/ddsi/ddsi_guid.h"
+#include "dds/ddsrt/retcode.h"
+#include "dds/ddsrt/misc.h"
+#include "dds/ddsi/ddsi_plist_generic.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct ddsi_participant;
+struct ddsi_writer;
+struct ddsi_proxy_reader;
+struct ddsi_serdata;
+
+#define DDS_SECURITY_AUTH_REQUEST                     "dds.sec.auth_request"
+#define DDS_SECURITY_AUTH_HANDSHAKE                   "dds.sec.auth"
+
+#define DDS_SECURITY_AUTH_VERSION_MAJOR 1
+#define DDS_SECURITY_AUTH_VERSION_MINOR 0
+
+#define DDS_SECURITY_AUTH_TOKEN_CLASS_ID_BASE         "DDS:Auth:PKI-DH:"
+#define DDS_SECURITY_AUTH_TOKEN_CLASS_ID              DDS_SECURITY_AUTH_TOKEN_CLASS_ID_BASE DDSRT_STRINGIFY(DDS_SECURITY_AUTH_VERSION_MAJOR) "." DDSRT_STRINGIFY(DDS_SECURITY_AUTH_VERSION_MINOR)
+
+#define DDS_SECURITY_AUTH_REQUEST_TOKEN_CLASS_ID      DDS_SECURITY_AUTH_TOKEN_CLASS_ID "+AuthReq"
+#define DDS_SECURITY_AUTH_HANDSHAKE_REQUEST_TOKEN_ID  DDS_SECURITY_AUTH_TOKEN_CLASS_ID "+Req"
+#define DDS_SECURITY_AUTH_HANDSHAKE_REPLY_TOKEN_ID    DDS_SECURITY_AUTH_TOKEN_CLASS_ID "+Reply"
+#define DDS_SECURITY_AUTH_HANDSHAKE_FINAL_TOKEN_ID    DDS_SECURITY_AUTH_TOKEN_CLASS_ID "+Final"
+
+
+typedef struct nn_message_identity {
+  ddsi_guid_t source_guid;
+  seqno_t sequence_number;
+} nn_message_identity_t;
+
+typedef struct nn_participant_generic_message {
+  nn_message_identity_t message_identity;
+  nn_message_identity_t related_message_identity;
+  ddsi_guid_t destination_participant_guid;
+  ddsi_guid_t destination_endpoint_guid;
+  ddsi_guid_t source_endpoint_guid;
+  const char *message_class_id;
+  nn_dataholderseq_t message_data;
+} nn_participant_generic_message_t;
+
+
+/*
+ * The arguments are aliased in the resulting message structure.
+ * This means that the lifecycle of the arguments should be longer
+ * then that of the message.
+ */
+DDS_EXPORT void
+nn_participant_generic_message_init(
+   nn_participant_generic_message_t *msg,
+   const ddsi_guid_t *wrguid,
+   seqno_t wrseq,
+   const ddsi_guid_t *dstpguid,
+   const ddsi_guid_t *dsteguid,
+   const ddsi_guid_t *srceguid,
+   const char *classid,
+   const nn_dataholderseq_t *mdata,
+   const nn_message_identity_t *rmid);
+
+/*
+ * Aliased struct variables will not be freed.
+ */
+DDS_EXPORT void
+nn_participant_generic_message_deinit(
+   nn_participant_generic_message_t *msg);
+
+/*
+ * Some struct variables are aliased to the given buffer.
+ * This means that the lifecycle of the data buffer should be
+ * longer then that of the message.
+ */
+DDS_EXPORT dds_return_t
+nn_participant_generic_message_deseralize(
+   nn_participant_generic_message_t *msg,
+   const unsigned char *data,
+   size_t len,
+   bool bswap);
+
+DDS_EXPORT dds_return_t
+nn_participant_generic_message_serialize(
+   const nn_participant_generic_message_t *msg,
+   unsigned char **data,
+   size_t *len);
+
+DDS_EXPORT extern const enum pserop pserop_participant_generic_message[];
+DDS_EXPORT extern const size_t pserop_participant_generic_message_nops;
+
+DDS_EXPORT int
+volatile_secure_data_filter(
+   struct ddsi_writer *wr,
+   struct ddsi_proxy_reader *prd,
+   struct ddsi_serdata *serdata);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif
+
+#endif /* DDSI_SECURITY_MSG_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_security_omg.h

@@ -0,0 +1,1455 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_OMG_SECURITY_H
+#define DDSI_OMG_SECURITY_H
+
+#include "dds/features.h"
+
+#include "dds/ddsrt/sync.h"
+#include "dds/ddsrt/avl.h"
+
+#include "dds/ddsi/ddsi_plist.h"
+#include "dds/ddsi/ddsi_entity.h"
+#include "dds/ddsi/ddsi_entity_match.h"
+#include "dds/ddsi/ddsi_domaingv.h"
+#include "dds/ddsi/q_radmin.h"
+#include "dds/ddsi/q_xmsg.h"
+#include "dds/ddsrt/retcode.h"
+#include "dds/ddsrt/types.h"
+#include "dds/ddsrt/sync.h"
+#include "dds/ddsi/ddsi_xqos.h"
+
+#ifdef DDS_HAS_SECURITY
+#include "dds/security/dds_security_api.h"
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+typedef enum {
+  NN_RTPS_MSG_STATE_ERROR,
+  NN_RTPS_MSG_STATE_PLAIN,
+  NN_RTPS_MSG_STATE_ENCODED
+} nn_rtps_msg_state_t;
+
+struct ddsi_hsadmin;
+struct participant_sec_attributes;
+struct ddsi_proxy_participant_sec_attributes;
+struct ddsi_writer_sec_attributes;
+struct ddsi_reader_sec_attributes;
+struct dds_security_context;
+struct ddsi_topic;
+struct ddsi_proxy_endpoint_common;
+
+#ifdef DDS_HAS_SECURITY
+
+typedef struct nn_msg_sec_info {
+  unsigned encoded:1;
+  unsigned use_rtps_encoding:1;
+  int64_t src_pp_handle;
+  int64_t dst_pp_handle;
+} nn_msg_sec_info_t;
+
+struct pp_proxypp_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t proxypp_guid;
+  DDS_Security_ParticipantCryptoHandle proxypp_crypto_handle;
+};
+
+struct proxypp_pp_match {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t pp_guid;
+  DDS_Security_ParticipantCryptoHandle pp_crypto_handle;
+  DDS_Security_PermissionsHandle permissions_handle;
+  DDS_Security_SharedSecretHandle shared_secret;
+  bool authenticated;
+};
+
+struct participant_sec_attributes {
+  ddsrt_avl_node_t avlnode;
+  ddsi_guid_t pp_guid;
+  DDS_Security_ParticipantSecurityAttributes attr;
+  DDS_Security_IdentityHandle local_identity_handle;
+  DDS_Security_PermissionsHandle permissions_handle;
+  DDS_Security_ParticipantCryptoHandle crypto_handle;
+  bool plugin_attr;
+  ddsrt_mutex_t lock;
+  ddsrt_avl_ctree_t proxy_participants;
+  bool initialized;
+};
+
+struct ddsi_proxy_participant_sec_attributes {
+  struct dds_security_context *sc;
+  DDS_Security_IdentityHandle remote_identity_handle;
+  DDS_Security_ParticipantCryptoHandle crypto_handle;
+  ddsrt_mutex_t lock;
+  ddsrt_avl_tree_t participants;
+  bool initialized;
+};
+
+struct ddsi_writer_sec_attributes {
+  DDS_Security_EndpointSecurityAttributes attr;
+  DDS_Security_DatawriterCryptoHandle crypto_handle;
+  bool plugin_attr;
+};
+
+struct ddsi_reader_sec_attributes {
+  DDS_Security_EndpointSecurityAttributes attr;
+  DDS_Security_DatareaderCryptoHandle crypto_handle;
+  bool plugin_attr;
+};
+
+DDS_EXPORT struct dds_security_access_control *q_omg_participant_get_access_control(const struct ddsi_participant *pp);
+DDS_EXPORT struct dds_security_authentication *q_omg_participant_get_authentication(const struct ddsi_participant *pp);
+DDS_EXPORT struct dds_security_cryptography *q_omg_participant_get_cryptography(const struct ddsi_participant *pp);
+
+void q_omg_vlog_exception(const struct ddsrt_log_cfg *lc, uint32_t cat, DDS_Security_SecurityException *exception, const char *file, uint32_t line, const char *func, const char *fmt, va_list ap);
+void q_omg_log_exception(const struct ddsrt_log_cfg *lc, uint32_t cat, DDS_Security_SecurityException *exception, const char *file, uint32_t line, const char *func, const char *fmt, ...);
+
+/**
+ * @brief Check if access control is enabled for the participant.
+ *
+ * @param[in] pp  Participant to check.
+ *
+ * @returns bool  True if access control is enabled for participant
+ */
+bool q_omg_participant_is_access_protected(const struct ddsi_participant *pp);
+
+/**
+ * @brief Check if protection at RTPS level is enabled for the participant.
+ *
+ * @param[in] pp  Participant to check.
+ *
+ * @returns bool  True if RTPS protection enabled for participant
+ */
+bool q_omg_participant_is_rtps_protected(const struct ddsi_participant *pp);
+
+/**
+ * @brief Check if liveliness is protected for the participant.
+ *
+ * @param[in] pp  Participant to check.
+ *
+ * @returns bool  True  if liveliness data for participant is protected
+ */
+bool q_omg_participant_is_liveliness_protected(const struct ddsi_participant *pp);
+
+/**
+ * @brief Check if discovery is protected for the participant.
+ *
+ * @param[in] pp  Participant to check.
+ *
+ * @returns bool  True  if discovery data for participant is protected
+ */
+bool q_omg_participant_is_discovery_protected(const struct ddsi_participant *pp);
+
+/**
+ * @brief Check if security is enabled for the participant.
+ *
+ * @param[in] pp  Participant to check if it is secure.
+ *
+ * @returns bool  True if participant is secure
+ */
+bool q_omg_participant_is_secure(const struct ddsi_participant *pp);
+
+/**
+ * @brief Check if security is enabled for the proxy participant.
+ *
+ * @param[in] proxypp  Proxy participant to check if it is secure.
+ *
+ * @returns bool  True if proxy participant is secure
+ */
+bool q_omg_proxy_participant_is_secure(const struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Check security if it is allowed to create the participant.
+ *
+ * When security is enabled for this participant it is checked if the
+ * participant is authenticated by checking the provided security
+ * certificates. When that is ok the participant is registered with
+ * access control and with cryptography. When that is all successful
+ * this function return true;
+ *
+ * @param[in] pp         The participant to check if alloweed by security.
+ * #param[in] domain_id  The domain_id
+ *
+ * @returns dds_return_t
+ * @retval DDS_RETCODE_OK   Participant is allowed
+ * @retval DDS_RETCODE_NOT_ALLOWED_BY_SECURITY
+ *                          Participant is not allowed
+ */
+dds_return_t q_omg_security_check_create_participant(struct ddsi_participant *pp, uint32_t domain_id);
+
+void q_omg_security_participant_set_initialized(struct ddsi_participant *pp);
+
+bool q_omg_security_participant_is_initialized(struct ddsi_participant *pp);
+
+/**
+ * @brief Remove the participant from the security plugins.
+ *
+ * When the participant was registered with the security
+ * plugins then this function will release the allocated
+ * security resources.
+ *
+ * @param[in] pp  Participant to remove.
+ */
+void q_omg_security_deregister_participant(struct ddsi_participant *pp);
+
+/**
+ * @brief Get the identity handle associate with this participant.
+ *
+ * This function returns the identity handle that was created
+ * when the participant was authenticated. This handle corresponds
+ * with the handle returned by calling validate_local_identity on
+ * the authentication plugin.
+ *
+ * @param[in] pp  Participant to check if it is secure.
+ *
+ * @returns int64_t
+ * @retval !0 Identity handle associated with the participant.
+ * @retval 0  Invalid handle the participant was not registered
+ */
+int64_t q_omg_security_get_local_participant_handle(const struct ddsi_participant *pp);
+
+/**
+ * @brief Get security info flags of the given participant.
+ *
+ * @param[in]  pp    Participant to get the security info from.
+ * @param[out] info  The security info.
+ *
+ * @returns bool
+ * @retval true   Security info set.
+ * @retval false  Security info not set.
+ */
+bool q_omg_get_participant_security_info(const struct ddsi_participant *pp, nn_security_info_t *info);
+
+/**
+ * @brief Get the is_rtps_protected flag of the given remote participant.
+ *
+ * @param[in] pp        The participant.
+ * @param[in] entityid  ID of the entity to check.
+ *
+ * @returns bool
+ * @retval true   RTPS protected is set.
+ * @retval false  RTPS protected is not set.
+ */
+bool q_omg_security_is_local_rtps_protected(const struct ddsi_participant *pp, ddsi_entityid_t entityid);
+
+/**
+ * @brief Check if the participant and the proxy participant
+ *        have compatible security info settings.
+ *
+ * Associated with a secure participant is the ParticipantSecurityInfo parameter.
+ * This parameter contains the setting of the security attributes and the associated
+ * plugin security attributes of the secure participant.
+ * This function will check if the received ParticipantSecurityInfo parameter is
+ * compatible with the local ParticipantSecurityInfo parameter.
+ *
+ * @param[in] pp      The participant.
+ * @param[in] proxypp The proxy participant.
+ *
+ * @returns bool
+ * @retval true   The participant and the proxy participant have compatible
+ *                security info settings.
+ * @retval false  Otherwise.
+ */
+bool q_omg_is_similar_participant_security_info(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Check if the parameter list key hash is protected
+ *
+ * @param[in] plist        The parameter list
+ *
+ * @returns bool  True if the parameter list key hash is protected
+ */
+bool q_omg_plist_keyhash_is_protected(const ddsi_plist_t *plist);
+
+/**
+ * @brief Check if the endpoint is protected
+ *
+ * Checks whether the provided parameter list has the flag
+ * ENDPOINT_SECURITY_ATTRIBUTES_FLAG_IS_VALID set. When this flag
+ * is set, this implies that the remote endpoint has protection
+ * enabled.
+ *
+ * @param[in] plist        The parameter list
+ *
+ * @returns bool  True if the endpoint is protected
+ */
+bool q_omg_is_endpoint_protected(const ddsi_plist_t *plist);
+
+/**
+ * @brief Writes the security attributes and security plugin attributes to log (category discovery)
+ *
+ * @param[in] gv        Global variable
+ * @param[in] plist     The parameter list
+ */
+void q_omg_log_endpoint_protection(struct ddsi_domaingv * const gv, const ddsi_plist_t *plist);
+
+/**
+ * @brief Check if security allows to create the topic.
+ *
+ * This function checks with access control if is allowed to create
+ * this topic for the specified domain.
+ *
+ * @param[in] gv          The domain global information.
+ * @param[in] pp_guid     The participant guid.
+ * @param[in] topic_name  The name of the  topic.
+ * @param[in] qos         The topic QoS used.
+ *
+ * @returns bool
+ * @retval true   Creation of the topic is allowed
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_check_create_topic(const struct ddsi_domaingv *gv, const ddsi_guid_t *pp_guid, const char *topic_name, const struct dds_qos *qos);
+
+/**
+ * @brief Get security info flags of the given writer.
+ *
+ * @param[in]  wr    Writer to get the security info from.
+ * @param[out] info  The security info.
+ *
+ * @returns bool
+ * @retval true   Security info set.
+ * @retval false  Security info not set (probably unsecure writer).
+ */
+bool q_omg_get_writer_security_info(const struct ddsi_writer *wr, nn_security_info_t *info);
+
+/**
+ * @brief Return the builtin writer id for this writers' discovery.
+ *
+ * Return builtin entity id of the writer to use for the publication
+ * discovery information.
+ * Depending on whether the discovery is protected or not (for the
+ * given writer), either the default writer or protected writer needs
+ * to be used.
+ *
+ * @param[in] wr Writer to determine the publication writer from.
+ *
+ * @returns unsigned
+ * @retval NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER
+ * @retval NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER
+ */
+unsigned determine_publication_writer(const struct ddsi_writer *wr);
+
+/**
+ * @brief Check if security allows to create the writer.
+ *
+ * This function checks with access control if is allowed to create
+ * this writer for the specified domain.
+ *
+ * @param[in] pp          Participant on which the topic is being created.
+ * @param[in] domain_id   The corresponding domain_id.
+ * @param[in] topic_name  The name of the topic.
+ * @param[in] writer_qos  The writer QoS used.
+ *
+ * @returns bool
+ * @retval true   Creation of the writer is allowed
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_check_create_writer(struct ddsi_participant *pp, uint32_t domain_id, const char *topic_name, const struct dds_qos *writer_qos);
+
+/**
+ * @brief Register the writer with security.
+ *
+ * This function registers the writer with security
+ * when the associated participant has security enabled.
+ * The security settings associated with this writer are determined
+ * and the writer is registered with cryptography when needed by
+ * the security settings which indicate if payload protection and or
+ * submessage protection is enabled for this writer.
+ *
+ * @param[in] wr  The writer to register.
+ */
+void q_omg_security_register_writer(struct ddsi_writer *wr);
+
+/**
+ * @brief Remove the writer from security.
+ *
+ * When the writer was registered with security then this function
+ * will remove the writer from security which will free the allocated
+ * security resource created for this writer.
+ *
+ * @param[in] wr  The writer to remove.
+ */
+void q_omg_security_deregister_writer(struct ddsi_writer *wr);
+
+/**
+ * @brief Get security info flags of the given reader.
+ *
+ * @param[in]  rd    Reader to get the security info from.
+ * @param[out] info  The security info.
+ *
+ * @returns bool
+ * @retval true   Security info set.
+ * @retval false  Security info not set (probably unsecure reader).
+ */
+bool q_omg_get_reader_security_info(const struct ddsi_reader *rd, nn_security_info_t *info);
+
+/**
+ * @brief Return the builtin writer id for this readers' discovery.
+ *
+ * Return builtin entity id of the writer to use for the subscription
+ * discovery information.
+ * Depending on whether the discovery is protected or not (for the
+ * given reader), either the default writer or protected writer needs
+ * to be used.
+ *
+ * @param[in] rd Reader to determine the subscription writer from.
+ *
+ * @returns unsigned
+ * @retval NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER
+ * @retval NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER
+ */
+unsigned determine_subscription_writer(const struct ddsi_reader *rd);
+
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+/**
+ * @brief Return the builtin writer id for topic discovery.
+ *
+ * Return builtin entity id of the writer to use for the topic
+ * discovery information.
+ *
+ * @param[in] tp Topic to determine the writer from.
+ *
+ * @returns unsigned
+ * @retval NN_ENTITYID_SEDP_BUILTIN_TOPIC_WRITER
+ */
+unsigned determine_topic_writer(const struct ddsi_topic *tp);
+#endif /* DDS_HAS_TOPIC_DISCOVERY */
+
+/**
+ * @brief Check if security allows to create the reader.
+ *
+ * This function checks with access control if is allowed to create
+ * this reader for the specified domain.
+ *
+ * @param[in] pp          Participant on which the topic is being created.
+ * @param[in] domain_id   The corresponding domain_id.
+ * @param[in] topic_name  The name of the topic.
+ * @param[in] reader_qos  The reader QoS used.
+ *
+ * @returns bool
+ * @retval true   Creation of the writer is allowed
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_check_create_reader(struct ddsi_participant *pp, uint32_t domain_id, const char *topic_name, const struct dds_qos *reader_qos);
+
+/**
+ * @brief Register the reader with security.
+ *
+ * This function registers the reader with security
+ * when the associated participant has security enabled.
+ * The security settings associated with this reader are determined
+ * and the reader is registered with cryptography when needed by
+ * the security settings which indicate if submessage protection is
+ *  enabled for this reader.
+ *
+ * @param[in] rd  The reader to register.
+ */
+void q_omg_security_register_reader(struct ddsi_reader *rd);
+
+/**
+ * @brief Remove the reader from security.
+ *
+ * When the reader was registered with security then this function
+ * will remove the reader from security which will free the allocated
+ * security resource created for this reader.
+ *
+ * @param[in] rd  The reader to remove.
+ */
+void q_omg_security_deregister_reader(struct ddsi_reader *rd);
+
+/**
+ * @brief Determine if the proxy participant is allowed to be deleted
+ *        by the given writer.
+ *
+ * If an proxy participant is authenticated, it is only allowed to
+ * to deleted when a dispose is received from the proper protected
+ * discovery writer.
+ *
+ * @param[in] gv           Used for tracing.
+ * @param[in] guid         Guid of the proxy participant to be deleted.
+ * @param[in] pwr_entityid Writer that send the dispose.
+ *
+ * @returns bool
+ * @retval true   The proxy participant may be deleted.
+ * @retval false  The proxy participant may not be deleted by this writer.
+ */
+bool is_proxy_participant_deletion_allowed(struct ddsi_domaingv * const gv, const struct ddsi_guid *guid, const ddsi_entityid_t pwr_entityid);
+
+/**
+ * @brief Determine if the messages, related to the given remote
+ * entity, are RTPS protected or not.
+ *
+ * @param[in] proxy_pp  Related proxy participant.
+ * @param[in] entityid  ID of the entity to check.
+ *
+ * @returns bool
+ * @retval true   The entity messages are RTPS protected.
+ * @retval false  The entity messages are not RTPS protected.
+ */
+bool q_omg_security_is_remote_rtps_protected(const struct ddsi_proxy_participant *proxy_pp, ddsi_entityid_t entityid);
+
+/**
+ * @brief Set security information, depending on plist, into the given
+ * proxy participant.
+ *
+ * @param[in] proxypp  Proxy participant to set security info on.
+ * @param[in] plist    Paramater list, possibly contains security info.
+ */
+void set_proxy_participant_security_info(struct ddsi_proxy_participant *proxypp, const ddsi_plist_t *plist);
+
+/**
+ * @brief Determine if the messages, related to the given remote
+ * entity, are RTPS protected or not.
+ *
+ * @param[in] pp       The participant.
+ * @param[in] entityid ID of the entity to check.
+ *
+ * @returns bool
+ * @retval true   The entity messages are RTPS protected.
+ * @retval false  The entity messages are not RTPS protected.
+ */
+bool q_omg_security_is_local_rtps_protected(const struct ddsi_participant *pp, ddsi_entityid_t entityid);
+
+/**
+ * @brief Check if the participant allows communication with unauthenticated
+ *        participants
+ *
+ * @param[in] pp  The participant.
+ *
+ * @returns bool
+ * @retval true   The participant allows unauthenticated communication
+ * @retval false  Otherwise.
+ */
+bool q_omg_participant_allow_unauthenticated(struct ddsi_participant *pp);
+
+/**
+ * @brief Initialize the proxy participant security attributes
+ *
+ * @param[in] proxypp  The proxy participant.
+ *
+ */
+void q_omg_security_init_remote_participant(struct ddsi_proxy_participant *proxypp);
+
+void q_omg_security_remote_participant_set_initialized(struct ddsi_proxy_participant *proxypp);
+
+bool q_omg_security_remote_participant_is_initialized(struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Registers the matched proxy participant with the crypto plugin
+ *
+ * When the proxy participant is authenticated and allowed by access control then the match between the local and
+ * the remote participant must be registered with the cypto factory provided by the crypto plugin. The
+ * shared secret handle obtained from the authentication phase and the permission handle returned when validating
+ * the proxy participant with access control plugin have to be provided.
+ *
+ *
+ * @param[in] pp                 The participant.
+ * @param[in] proxypp            The proxy participant.
+ * @param[in] shared_secret      The shared_secret handle.
+ *
+ * @returns bool
+ * @retval true    The proxy participant is allowed.
+ * @retval false   The proxy participant is not allowed.
+ */
+bool q_omg_security_register_remote_participant(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp, int64_t shared_secret);
+
+/**
+ * @brief Sets the matching participant and proxy participant as authorized.
+ *
+ * When the authentication handshake has finished successfully and the
+ * volatile secure readers and writers are matched then with this function
+ * the matching local and remote participant are set to authenticated which
+ * allows the crypto tokens to be exchanged and the corresponding entities
+ * be matched.
+ *
+ * @param[in] pp                 The participant.
+ * @param[in] proxypp            The proxy participant.
+ */
+void q_omg_security_set_remote_participant_authenticated(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Removes a registered proxy participant from administation of the authentication,
+ *        access control and crypto plugins.
+ *
+ * @param[in] proxypp            The proxy participant.
+ */
+void q_omg_security_deregister_remote_participant(struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Generate and send the crypto tokens needed for encoding RTPS messages.
+ *
+ * When the security settings indicate that RTPS message encoding or signing is
+ * configured for the participant then this function will ask the cypto echange for
+ * the corresponding cypto tokens and send these to the proxy participant.
+ *
+ * @param[in] pp                 The participant.
+ * @param[in] proxypp            The proxy participant.
+ */
+void q_omg_security_participant_send_tokens(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Get the cypto handle associated with the proxy participant.
+ *
+ * This function returns the handle which is the association between
+ * the proxy participant and the crypto plugin. This handle is created
+ * when the proxy participant is registered with the crypto plugin.
+ *
+ * @param[in] proxypp            The proxy participant.
+ *
+ * @returns handle
+ * @retval !0  Valid crypto handle associated with the proxy participant.
+ * @retval 0   Otherwise.
+ */
+int64_t q_omg_security_get_remote_participant_handle(struct ddsi_proxy_participant *proxypp);
+
+/**
+ * @brief Set the crypto tokens used for the encryption and decryption of RTPS messages.
+ *
+ * The remote participant  will send the crypto tokens when the security settings determine that the
+ * communication between the participants must be secure. These tokens are used for the necryption and
+ * decryption of complete RTPS messages. When these tokens are received this function will register these tokens
+ * with the crypto plugin. The crypto plugin will return a crypto handle that will be used to associate the
+ * stored tokens with the remote participant.
+ *
+ * @param[in] pp        The local participant.
+ * @param[in] proxypp   The remote participant.
+ * @param[in] tokens    The crypto token received from the remote participant for the local participant.
+ */
+void q_omg_security_set_participant_crypto_tokens(struct ddsi_participant *pp, struct ddsi_proxy_participant *proxypp, const nn_dataholderseq_t *tokens);
+
+/**
+ * @brief Check if the writer has the is_discovery_protected flag set
+ *
+ * @param[in] wr        The local writer.
+ *
+ * @returns bool  True if the writer has the is_discovery_protected flag set
+ */
+bool q_omg_writer_is_discovery_protected(const struct ddsi_writer *wr);
+
+/**
+ * @brief Check if the writer has the is_submessage_protected flag set
+ *
+ * @param[in] wr        The local writer.
+ *
+ * @returns bool  True if the writer has the is_submessage_protected flag set
+ */
+bool q_omg_writer_is_submessage_protected(const struct ddsi_writer *wr);
+
+/**
+ * @brief Check if the writer has the is_payload_protected flag set
+ *
+ * @param[in] wr        The local writer.
+ *
+ * @returns bool  True if the writer has the is_payload_protected flag set
+ */
+bool q_omg_writer_is_payload_protected(const struct ddsi_writer *wr);
+
+/**
+ * @brief Check if the remote writer is allowed to communicate with endpoints of the
+ *        local participant.
+ *
+ * This function will check with the access control plugin if the remote writer
+ * is allowed to communicate with this participant.
+ *
+ * @param[in] pwr       The remote writer.
+ * @param[in] domain_id The domain id.
+ * @param[in] pp        The local participant.
+ *
+ * @returns bool
+ * @retval true   The remote writer is allowed to communicate.
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_check_remote_writer_permissions(const struct ddsi_proxy_writer *pwr, uint32_t domain_id, struct ddsi_participant *pp);
+
+/**
+ * @brief Check it the remote writer is allowed to communicate with the local reader.
+ *
+ * When a remote writer is allowed by access control it has to be checked if the remote
+ * writer is allowed to communicate with a particular local reader. This function will
+ * check if the provided security end-point attributes are compatible, When the security
+ * attributes are compatible then the function will register the reader and remote writer
+ * match with the crypto factory and will also ask the crypto exchange to generate the
+ * crypto tokens associate with the local reader which will be sent to the remote entity.
+ * Note that the reader crypto tokens are used to encrypt the reader specific submessages
+ * when submessage encoding or signing is configured.
+ *
+ * @param[in] rd   The local reader.
+ * @param[in] pwr  The remote writer.
+ * @param[out] crypto_handle  The crypto handle associated with the match.
+ *
+ * @returns bool
+ * @retval true   The local reader and remote writer are allowed to communicate.
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_match_remote_writer_enabled(struct ddsi_reader *rd, struct ddsi_proxy_writer *pwr, int64_t *crypto_handle);
+
+/**
+ * @brief Release the security information associated with the match between a reader and
+ * a remote writer.
+ *
+ * This function releases the security resources that were allocated for this reader and remote
+ * writer match. For example it will release the security tokens that where associated with this
+ * reader and the remote writer.
+ *
+ * @param[in] gv       The global parameters.
+ * @param[in] rd_guid  The guid of the reader.
+ * @param[in] match    The reader-proxy_writer match.
+ */
+void q_omg_security_deregister_remote_writer_match(const struct ddsi_domaingv *gv, const ddsi_guid_t *rd_guid, struct ddsi_rd_pwr_match *match);
+
+/**
+ * @brief Set the crypto tokens used for the secure communication from the remote writer to the reader.
+ *
+ * The remote writer instance will send the crypto tokens when the security settings determine that the
+ * communication between the remote writer and the reader must be secure. When these tokens are received
+ * this function will register these tokens with the crypto plugin and set the corresponding crypto handle returned
+ * by the crypto plugin which is then used for decrypting messages received from that remote writer to the reader.
+ *
+ * @param[in] rd        The local reader.
+ * @param[in] pwr_guid  The guid of the remote writer.
+ * @param[in] tokens    The crypto token received from the remote writer for the reader.
+ */
+void q_omg_security_set_remote_writer_crypto_tokens(struct ddsi_reader *rd, const ddsi_guid_t *pwr_guid, const nn_dataholderseq_t *tokens);
+
+/**
+ * @brief Release all the security resources associated with the remote writer.
+ *
+ * Cleanup security resource associated with the remote writer.
+ *
+ * @param[in] pwr       The remote writer.
+ */
+void q_omg_security_deregister_remote_writer(const struct ddsi_proxy_writer *pwr);
+
+/**
+ * @brief Set security information, depending on plist and proxy participant,
+ * into the given proxy reader.
+ *
+ * @param[in] prd      Proxy reader to set security info on.
+ * @param[in] plist    Paramater list, possibly contains security info.
+ */
+void set_proxy_reader_security_info(struct ddsi_proxy_reader *prd, const ddsi_plist_t *plist);
+
+/**
+ * @brief Determine the security settings associated with the remote reader.
+ *
+ * From the security information contained in the parameter list from the remote reader
+ * the corresponding security settings are determined and returned in the info parameter.
+ *
+ * @param[in] prd       The remote reader.
+ * @param[in] plist     The parameter list from the remote reader.
+ * @param[out] info     The security settings associated with the remote reader.
+ */
+void q_omg_get_proxy_reader_security_info(struct ddsi_proxy_reader *prd, const ddsi_plist_t *plist, nn_security_info_t *info);
+
+/**
+ * @brief Check if the reader has the is_discovery_protected flag set
+ *
+ * @param[in] rd        The local reader.
+ *
+ * @returns bool  True if the reader has the is_discovery_protected flag set
+ */
+bool q_omg_reader_is_discovery_protected(const struct ddsi_reader *rd);
+
+/**
+ * @brief Check if the reader has the is_submessage_protected flag set
+ *
+ * @param[in] rd        The local reader.
+ *
+ * @returns bool  True if the reader has the is_submessage_protected flag set
+ */
+bool q_omg_reader_is_submessage_protected(const struct ddsi_reader *rd);
+
+/**
+ * @brief Check if the remote reader is allowed to communicate with endpoints of the
+ *        local participant.
+ *
+ * This function will check with the access control plugin if the remote reader
+ * is allowed to communicate with this participant.
+ *
+ * @param[in] prd         The remote reader.
+ * @param[in] domain_id   The domain id.
+ * @param[in] pp          The local participant.
+ * @param[out] relay_only The "relay_only" value returned by the access control
+ *                        operation check_remote_datareader()
+ *
+ * @returns bool
+ * @retval true   The remote reader is allowed to communicate.
+ * @retval false  Otherwise; relay_only is unspecified.
+ */
+bool q_omg_security_check_remote_reader_permissions(const struct ddsi_proxy_reader *prd, uint32_t domain_id, struct ddsi_participant *pp, bool *relay_only);
+
+
+/**
+ * @brief Set security information, depending on plist and proxy participant,
+ * into the given proxy endpoint.
+ *
+ * @param[in] entity            The endpoint common attributes.
+ * @param[in] proxypp_sec_info  The security info of the proxy participant
+ * @param[in] plist             Paramater list which may contain security info.
+ * @param[in] info              The proxy endpoint security info to be set.
+ */
+void q_omg_get_proxy_endpoint_security_info(const struct ddsi_entity_common *entity, nn_security_info_t *proxypp_sec_info, const ddsi_plist_t *plist, nn_security_info_t *info);
+
+/**
+ * @brief Check it the local writer is allowed to communicate with the remote reader.
+ *
+ * When a remote reader is allowed by accessstruct dds_security_garbage control it has to be checked if the local
+ * writer is allowed to communicate with a particular local writer. This function will
+ * check if the provided security end-point attributes are compatible, When the security
+ * attributes are compatible then the function will register the writer and remote reader
+ * match with the crypto factory and will also ask the crypto exchange to generate the
+ * crypto tokens associate with the local writer which will be sent to the remote entity.
+ * Note that the writer crypto tokens are used to encrypt the writer specific submessages
+ * when submessage encoding or signing is configured and also the crypto tokens used
+ * for encoding the payload of data or datafrag messages.
+ *
+ * @param[in] wr              The local writer.
+ * @param[in] prd             The remote reader.
+ * @param[in] relay_only      The "relay_only" returned by access control
+ *                            operation check_remote_datareader()
+ * @param[out] crypto_handle  The crypto handle associated with the match.
+ *
+ * @returns bool
+ * @retval true   The local writer and remote reader are allowed to communicate.
+ * @retval false  Otherwise.
+ */
+bool q_omg_security_match_remote_reader_enabled(struct ddsi_writer *wr, struct ddsi_proxy_reader *prd, bool relay_only, int64_t *crypto_handle);
+
+/**
+ * @brief Release the security information associated with the match between a writer and
+ * a remote reader.
+ *
+ * This function releases the security resources that were allocated for this writer and remote
+ * reader match. For example it will release the security tokens that where associated with this
+ * writer and the remote reader.
+ *
+ * @param[in] gv       The global parameters.
+ * @param[in] wr_guid  The guid of the writer.
+ * @param[in] match    The writer-proxy_reader match.
+ */
+void q_omg_security_deregister_remote_reader_match(const struct ddsi_domaingv *gv, const ddsi_guid_t *wr_guid, struct ddsi_wr_prd_match *match);
+
+/**
+ * @brief Set the crypto tokens used for the secure communication from the remote reader to the writer.
+ *
+ * The remote reader instance will send the crypto tokens when the security settings determine that the
+ * communication between the remote reader and the writer must be secure. When these tokens are received
+ * this function will register these tokens with the crypto plugin and set the corresponding crypto handle returned
+ * by the crypto plugin which is then used for decrypting messages received from that remote reader to the writer.
+ *
+ * @param[in] wr        The local writer.
+ * @param[in] prd_guid  The guid of the remote reader.
+ * @param[in] tokens    The crypto token received from the remote reader for the writer.
+ */
+void q_omg_security_set_remote_reader_crypto_tokens(struct ddsi_writer *wr, const ddsi_guid_t *prd_guid, const nn_dataholderseq_t *tokens);
+
+/**
+ * @brief Release all the security resources associated with the remote reader.
+ *
+ * Cleanup security resource associated with the remote reader.
+ *
+ * @param[in] prd       The remote reader.
+ */
+void q_omg_security_deregister_remote_reader(const struct ddsi_proxy_reader *prd);
+
+/**
+ * @brief Encode RTPS message.
+ *
+ * @param[in]     src_handle  Security handle of data source.
+ * @param[in]     src_guid    GUID of the entity data source.
+ * @param[in]     src_buf     Original RTPS message.
+ * @param[in]     src_len     Original RTPS message size.
+ * @param[out]    dst_buf     Encoded RTPS message.
+ * @param[out]    dst_len     Encoded RTPS message size.
+ * @param[in]     dst_handle  Security handle of data destination.
+ *
+ * @returns bool
+ * @retval true   Encoding succeeded.
+ * @retval false  Encoding failed.
+ */
+bool
+q_omg_security_encode_rtps_message(
+  const struct ddsi_domaingv *gv,
+  int64_t                 src_handle,
+  const ddsi_guid_t      *src_guid,
+  const unsigned char    *src_buf,
+  size_t                  src_len,
+  unsigned char         **dst_buf,
+  size_t                 *dst_len,
+  int64_t                 dst_handle);
+
+/**
+ * @brief Encode payload when necessary.
+ *
+ * When encoding is necessary, *buf will be allocated and the vec contents
+ * will change to point to that buffer.
+ * It is expected that the vec contents is always aliased.
+ *
+ * If no encoding is necessary, nothing changes.
+ *
+ * encoding(    not needed) -> return( true), vec(untouched), buf(NULL)
+ * encoding(needed&success) -> return( true), vec( buf(new))
+ * encoding(needed&failure) -> return(false), vec(untouched), buf(NULL)
+ *
+ * @param[in]     wr   Writer that writes the payload.
+ * @param[in,out] vec  An iovec that contains the payload.
+ * @param[out]    buf  Buffer to contain the encoded payload.
+ *
+ * @returns bool
+ * @retval true   Encoding succeeded or not necessary. Either way, vec
+ *                contains the payload that should be send.
+ * @retval false  Encoding was necessary, but failed.
+ */
+bool encode_payload(struct ddsi_writer *wr, ddsrt_iovec_t *vec, unsigned char **buf);
+
+/**
+ * @brief Decode the payload of a Data submessage.
+ *
+ * When decoding is necessary, the payloadp memory will be replaced
+ * by the decoded payload. This means that the original submessage
+ * now contains payload that can be deserialized.
+ *
+ * If no decoding is necessary, nothing changes.
+ *
+ * @param[in]     gv          Global information.
+ * @param[in]     sampleinfo  Sample information.
+ * @param[in,out] payloadp    Pointer to payload memory.
+ * @param[in]     payloadsz   Size of payload.
+ * @param[in,out] submsg_len  Size of submessage.
+ *
+ * @returns bool
+ * @retval true   Decoding succeeded or not necessary. Either way, payloadp
+ *                contains the data that should be deserialized.
+ * @retval false  Decoding was necessary, but failed.
+ */
+bool decode_Data(const struct ddsi_domaingv *gv, struct nn_rsample_info *sampleinfo, unsigned char *payloadp, uint32_t payloadsz, size_t *submsg_len);
+
+/**
+ * @brief Decode the payload of a DataFrag submessage.
+ *
+ * When decoding is necessary, the payloadp memory will be replaced
+ * by the decoded payload. This means that the original submessage
+ * now contains payload that can be deserialized.
+ *
+ * If no decoding is necessary, nothing changes.
+ *
+ * @param[in]     gv          Global information.
+ * @param[in]     sampleinfo  Sample information.
+ * @param[in,out] payloadp    Pointer to payload memory.
+ * @param[in]     payloadsz   Size of payload.
+ * @param[in,out] submsg_len  Size of submessage.
+ *
+ * @returns bool
+ * @retval true   Decoding succeeded or not necessary. Either way, payloadp
+ *                contains the data that should be deserialized.
+ * @retval false  Decoding was necessary, but failed.
+ */
+bool decode_DataFrag(const struct ddsi_domaingv *gv, struct nn_rsample_info *sampleinfo, unsigned char *payloadp, uint32_t payloadsz, size_t *submsg_len);
+
+/**
+ * @brief Encode datareader submessage when necessary.
+ *
+ * When encoding is necessary, the original submessage will be replaced
+ * by a new encoded submessage.
+ * If the encoding fails, the original submessage will be removed.
+ *
+ * If no encoding is necessary, nothing changes.
+ *
+ * @param[in,out] msg       Complete message.
+ * @param[in,out] sm_marker Submessage location within message.
+ * @param[in]     pwr       Writer for which the message is intended.
+ * @param[in]     rd_guid   Origin reader guid.
+ */
+void encode_datareader_submsg(struct nn_xmsg *msg, struct nn_xmsg_marker sm_marker, const struct ddsi_proxy_writer *pwr, const struct ddsi_guid *rd_guid);
+
+/**
+ * @brief Encode datawriter submessage when necessary.
+ *
+ * When encoding is necessary, the original submessage will be replaced
+ * by a new encoded submessage.
+ * If the encoding fails, the original submessage will be removed.
+ *
+ * If no encoding is necessary, nothing changes.
+ *
+ * @param[in,out] msg       Complete message.
+ * @param[in,out] sm_marker Submessage location within message.
+ * @param[in]     wr        Origin writer guid.
+ */
+void encode_datawriter_submsg(struct nn_xmsg *msg, struct nn_xmsg_marker sm_marker, struct ddsi_writer *wr);
+
+/**
+ * @brief Check if given submessage is properly decoded.
+ *
+ * When decoding is necessary, it should be checked if a plain submessage was
+ * actually decoded. Otherwise data can be injected just by inserting a plain
+ * submessage directly.
+ *
+ * @param[in] e         Entity information.
+ * @param[in] c         Proxy endpoint information.
+ * @param[in] proxypp   Related proxy participant.
+ * @param[in] rst       Receiver information.
+ * @param[in] prev_smid Previously handled submessage ID.
+ *
+ * @returns bool
+ * @retval true   Decoding succeeded or was not necessary.
+ * @retval false  Decoding was necessary, but not detected.
+ */
+bool
+validate_msg_decoding(
+  const struct ddsi_entity_common *e,
+  const struct ddsi_proxy_endpoint_common *c,
+  const struct ddsi_proxy_participant *proxypp,
+  const struct receiver_state *rst,
+  SubmessageKind_t prev_smid);
+
+/**
+ * @brief Decode not only SecPrefix, but also the SecBody and SecPostfix
+ * sub-messages.
+ *
+ * When encrypted, the original SecBody will be replaced by the decrypted
+ * submessage. Then the normal sequence can continue as if there was no
+ * encrypted data.
+ *
+ * @param[in]     rst         Receiver information.
+ * @param[in,out] submsg      Pointer to SecPrefix/(SecBody|Submsg)/SecPostfix.
+ * @param[in]     submsg_size Size of SecPrefix submessage.
+ * @param[in]     msg_end     End of the complete message.
+ * @param[in]     src_prefix  Prefix of the source entity.
+ * @param[in]     dst_prefix  Prefix of the destination entity.
+ * @param[in]     byteswap    Do the bytes need swapping?
+ *
+ * @returns bool
+ * @retval true   Decoding succeeded.
+ * @retval false  Decoding failed.
+ */
+bool
+decode_SecPrefix(
+  const struct receiver_state *rst,
+  unsigned char *submsg,
+  size_t submsg_size,
+  unsigned char * const msg_end,
+  const ddsi_guid_prefix_t * const src_prefix,
+  const ddsi_guid_prefix_t * const dst_prefix,
+  int byteswap);
+
+/**
+ * @brief Decode the RTPS message.
+ *
+ * When encrypted, the original buffers and information will be replaced
+ * by the decrypted RTPS message. Then the normal sequence can continue
+ * as if there was no encrypted data.
+ *
+ * @param[in]     thrst         Thread information.
+ * @param[in]     gv          Global information.
+ * @param[in,out] rmsg        Message information.
+ * @param[in,out] hdr         Message header.
+ * @param[in,out] buff        Message buffer.
+ * @param[in,out] sz          Message size.
+ * @param[in]     rbpool      Buffers pool.
+ * @param[in]     isstream    Is message a stream variant?
+ *
+ * @returns nn_rtps_msg_state_t
+ * @retval NN_RTPS_MSG_STATE_PLAIN    No decoding was necessary.
+ * @retval NN_RTPS_MSG_STATE_ENCODED  Decoding succeeded.
+ * @retval NN_RTPS_MSG_STATE_ERROR    Decoding failed.
+ */
+nn_rtps_msg_state_t decode_rtps_message(struct thread_state * const thrst, struct ddsi_domaingv *gv, struct nn_rmsg **rmsg, Header_t **hdr, unsigned char **buff, size_t *sz, struct nn_rbufpool *rbpool, bool isstream);
+
+/**
+ * @brief Send the RTPS message securely.
+ *
+ * @param[in]     conn          Connection to use.
+ * @param[in]     dst           Possible destination information.
+ * @param[in]     niov          Number of io vectors.
+ * @param[in]     iov           Array of io vectors.
+ * @param[in]     flags         Connection write flags.
+ * @param[in,out] msg_len       Submessage containing length.
+ * @param[in]     dst_one       Is there only one specific destination?
+ * @param[in]     sec_info      Security information for handles.
+ * @param[in]     conn_write_cb Function to call to do the actual writing.
+ *
+ * @returns ssize_t
+ * @retval negative/zero    Something went wrong.
+ * @retval positive         Secure writing succeeded.
+ */
+ssize_t
+secure_conn_write(
+    const struct ddsi_domaingv *gv,
+    ddsi_tran_conn_t conn,
+    const ddsi_locator_t *dst,
+    size_t niov,
+    const ddsrt_iovec_t *iov,
+    uint32_t flags,
+    MsgLen_t *msg_len,
+    bool dst_one,
+    nn_msg_sec_info_t *sec_info,
+    ddsi_tran_write_fn_t conn_write_cb);
+
+
+/**
+ * @brief Loads the security plugins with the given configuration.
+ *        This function tries to load the plugins only once. Returns the same
+ *        result on subsequent calls.
+ *        It logs the reason and returns error if can not load a plugin.
+ *
+ * @param[in] qos   Participant qos which owns the Property list
+ *                             that contains security configurations and
+ *                             plugin properties that are required for loading libraries
+ * @returns dds_return_t
+ * @retval DDS_RETCODE_OK   All plugins are successfully loaded
+ * @retval DDS_RETCODE_ERROR  One or more security plugins are not loaded.
+ */
+dds_return_t q_omg_security_load( struct dds_security_context *security_context, const dds_qos_t *qos, struct ddsi_domaingv *gv );
+
+
+void q_omg_security_init( struct ddsi_domaingv *gv );
+
+void q_omg_security_stop (struct ddsi_domaingv *gv);
+
+void q_omg_security_deinit (struct dds_security_context *sc );
+
+void q_omg_security_free (struct ddsi_domaingv *gv);
+
+bool q_omg_is_security_loaded(  struct dds_security_context *sc );
+
+#else /* DDS_HAS_SECURITY */
+
+#include "dds/ddsi/q_unused.h"
+
+DDS_INLINE_EXPORT inline bool q_omg_security_enabled(void)
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_is_access_protected(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_is_rtps_protected(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_is_liveliness_protected(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_is_discovery_protected(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_is_secure(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_proxy_participant_is_secure(UNUSED_ARG(const struct ddsi_proxy_participant *proxypp))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline unsigned determine_subscription_writer(UNUSED_ARG(const struct ddsi_reader *rd))
+{
+  return NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
+}
+
+DDS_INLINE_EXPORT inline unsigned determine_publication_writer(UNUSED_ARG(const struct ddsi_writer *wr))
+{
+  return NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
+}
+
+#ifdef DDS_HAS_TOPIC_DISCOVERY
+DDS_INLINE_EXPORT inline unsigned determine_topic_writer(UNUSED_ARG(const struct ddsi_topic *tp))
+{
+  return NN_ENTITYID_SEDP_BUILTIN_TOPIC_WRITER;
+}
+#endif
+
+DDS_INLINE_EXPORT inline bool is_proxy_participant_deletion_allowed(UNUSED_ARG(struct ddsi_domaingv * const gv), UNUSED_ARG(const struct ddsi_guid *guid), UNUSED_ARG(const ddsi_entityid_t pwr_entityid))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_is_similar_participant_security_info(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_participant_allow_unauthenticated(UNUSED_ARG(struct ddsi_participant *pp))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_create_participant(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(uint32_t domain_id))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_participant(UNUSED_ARG(struct ddsi_participant *pp))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_create_topic(UNUSED_ARG(const struct ddsi_domaingv *gv), UNUSED_ARG(const ddsi_guid_t *pp_guid), UNUSED_ARG(const char *topic_name), UNUSED_ARG(const struct dds_qos *qos))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline int64_t q_omg_security_get_local_participant_handle(UNUSED_ARG(const struct ddsi_participant *pp))
+{
+  return 0;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_create_writer(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(uint32_t domain_id), UNUSED_ARG(const char *topic_name), UNUSED_ARG(const struct dds_qos *writer_qos))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_register_writer(UNUSED_ARG(struct ddsi_writer *wr))
+{
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_writer(UNUSED_ARG(struct ddsi_writer *wr))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_create_reader(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(uint32_t domain_id), UNUSED_ARG(const char *topic_name), UNUSED_ARG(const struct dds_qos *reader_qos))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_register_reader(UNUSED_ARG(struct ddsi_reader *rd))
+{
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_reader(UNUSED_ARG(struct ddsi_reader *rd))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_is_remote_rtps_protected(UNUSED_ARG(const struct ddsi_proxy_participant *proxypp), UNUSED_ARG(ddsi_entityid_t entityid))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_init_remote_participant(UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+}
+
+DDS_INLINE_EXPORT inline int64_t q_omg_security_check_remote_participant_permissions(UNUSED_ARG(uint32_t domain_id), UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+  return 0LL;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_register_remote_participant(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp), UNUSED_ARG(int64_t identity_handle), UNUSED_ARG(int64_t shared_secret))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_remote_participant(UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_participant_send_tokens(UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+}
+
+DDS_INLINE_EXPORT inline int64_t q_omg_security_get_remote_participant_handle(UNUSED_ARG(struct ddsi_proxy_participant *proxypp))
+{
+  return 0;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_match_remote_writer_enabled(UNUSED_ARG(struct ddsi_reader *rd), UNUSED_ARG(struct ddsi_proxy_writer *pwr), UNUSED_ARG(int64_t *crypto_handle))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_match_remote_reader_enabled(UNUSED_ARG(struct ddsi_writer *wr), UNUSED_ARG(struct ddsi_proxy_reader *prd), UNUSED_ARG(bool relay_only), UNUSED_ARG(int64_t *crypto_handle))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_get_proxy_writer_security_info(UNUSED_ARG(struct ddsi_proxy_writer *pwr), UNUSED_ARG(const ddsi_plist_t *plist), UNUSED_ARG(nn_security_info_t *info))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_writer_is_discovery_protected(UNUSED_ARG(const struct ddsi_writer *wr))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_writer_is_submessage_protected(UNUSED_ARG(const struct ddsi_writer *wr))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_writer_is_payload_protected(UNUSED_ARG(const struct ddsi_writer *wr))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_remote_writer_permissions(UNUSED_ARG(const struct ddsi_proxy_writer *pwr), UNUSED_ARG(uint32_t domain_id), UNUSED_ARG(struct ddsi_participant *pp))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_remote_writer_match(UNUSED_ARG(const struct ddsi_proxy_writer *pwr), UNUSED_ARG(const struct ddsi_reader *rd), UNUSED_ARG(struct ddsi_rd_pwr_match *match))
+{
+}
+
+DDS_INLINE_EXPORT inline void q_omg_get_proxy_reader_security_info(UNUSED_ARG(struct ddsi_proxy_reader *prd), UNUSED_ARG(const ddsi_plist_t *plist), UNUSED_ARG(nn_security_info_t *info))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_reader_is_discovery_protected(UNUSED_ARG(const struct ddsi_reader *rd))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_reader_is_submessage_protected(UNUSED_ARG(const struct ddsi_reader *rd))
+{
+  return false;
+}
+
+
+DDS_INLINE_EXPORT inline bool q_omg_security_check_remote_reader_permissions(UNUSED_ARG(const struct ddsi_proxy_reader *prd), UNUSED_ARG(uint32_t domain_id), UNUSED_ARG(struct ddsi_participant *pp), UNUSED_ARG(bool *relay_only))
+{
+  *relay_only = false;
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void set_proxy_participant_security_info(UNUSED_ARG(struct ddsi_proxy_participant *prd), UNUSED_ARG(const ddsi_plist_t *plist))
+{
+}
+
+DDS_INLINE_EXPORT inline void set_proxy_reader_security_info(UNUSED_ARG(struct ddsi_proxy_reader *prd), UNUSED_ARG(const ddsi_plist_t *plist))
+{
+}
+
+DDS_INLINE_EXPORT inline void set_proxy_writer_security_info(UNUSED_ARG(struct ddsi_proxy_writer *pwr), UNUSED_ARG(const ddsi_plist_t *plist))
+{
+}
+
+DDS_INLINE_EXPORT inline bool
+decode_Data(
+  UNUSED_ARG(const struct ddsi_domaingv *gv),
+  UNUSED_ARG(struct nn_rsample_info *sampleinfo),
+  UNUSED_ARG(unsigned char *payloadp),
+  UNUSED_ARG(uint32_t payloadsz),
+  UNUSED_ARG(size_t *submsg_len))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline bool
+decode_DataFrag(
+  UNUSED_ARG(const struct ddsi_domaingv *gv),
+  UNUSED_ARG(struct nn_rsample_info *sampleinfo),
+  UNUSED_ARG(unsigned char *payloadp),
+  UNUSED_ARG(uint32_t payloadsz),
+  UNUSED_ARG(size_t *submsg_len))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline void
+encode_datareader_submsg(
+  UNUSED_ARG(struct nn_xmsg *msg),
+  UNUSED_ARG(struct nn_xmsg_marker sm_marker),
+  UNUSED_ARG(const struct ddsi_proxy_writer *pwr),
+  UNUSED_ARG(const struct ddsi_guid *rd_guid))
+{
+}
+
+DDS_INLINE_EXPORT inline void
+encode_datawriter_submsg(
+  UNUSED_ARG(struct nn_xmsg *msg),
+  UNUSED_ARG(struct nn_xmsg_marker sm_marker),
+  UNUSED_ARG(struct ddsi_writer *wr))
+{
+}
+
+DDS_INLINE_EXPORT inline bool
+validate_msg_decoding(
+  UNUSED_ARG(const struct ddsi_entity_common *e),
+  UNUSED_ARG(const struct ddsi_proxy_endpoint_common *c),
+  UNUSED_ARG(struct ddsi_proxy_participant *proxypp),
+  UNUSED_ARG(struct receiver_state *rst),
+  UNUSED_ARG(SubmessageKind_t prev_smid))
+{
+  return true;
+}
+
+DDS_INLINE_EXPORT inline int
+decode_SecPrefix(
+  UNUSED_ARG(struct receiver_state *rst),
+  UNUSED_ARG(unsigned char *submsg),
+  UNUSED_ARG(size_t submsg_size),
+  UNUSED_ARG(unsigned char * const msg_end),
+  UNUSED_ARG(const ddsi_guid_prefix_t * const src_prefix),
+  UNUSED_ARG(const ddsi_guid_prefix_t * const dst_prefix),
+  UNUSED_ARG(int byteswap))
+{
+  /* Just let the parsing ignore the security sub-messages. */
+  return true;
+}
+
+DDS_INLINE_EXPORT inline nn_rtps_msg_state_t
+decode_rtps_message(
+  UNUSED_ARG(struct thread_state * const thrst),
+  UNUSED_ARG(struct ddsi_domaingv *gv),
+  UNUSED_ARG(struct nn_rmsg **rmsg),
+  UNUSED_ARG(Header_t **hdr),
+  UNUSED_ARG(unsigned char **buff),
+  UNUSED_ARG(size_t *sz),
+  UNUSED_ARG(struct nn_rbufpool *rbpool),
+  UNUSED_ARG(bool isstream))
+{
+  return NN_RTPS_MSG_STATE_PLAIN;
+}
+
+DDS_INLINE_EXPORT inline dds_return_t q_omg_security_load( UNUSED_ARG( struct dds_security_context *security_context ), UNUSED_ARG( const dds_qos_t *property_seq), UNUSED_ARG ( struct ddsi_domaingv *gv ) )
+{
+  return DDS_RETCODE_ERROR;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_is_security_loaded(  UNUSED_ARG( struct dds_security_context *sc )) { return false; }
+
+DDS_INLINE_EXPORT inline void q_omg_security_deregister_remote_reader_match(UNUSED_ARG(const struct ddsi_proxy_reader *prd), UNUSED_ARG(const struct ddsi_writer *wr), UNUSED_ARG(struct ddsi_wr_prd_match *match))
+{
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_plist_keyhash_is_protected(UNUSED_ARG(const ddsi_plist_t *plist))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline bool q_omg_is_endpoint_protected(UNUSED_ARG(const ddsi_plist_t *plist))
+{
+  return false;
+}
+
+DDS_INLINE_EXPORT inline void q_omg_log_endpoint_protection(UNUSED_ARG(struct ddsi_domaingv * const gv), UNUSED_ARG(const ddsi_plist_t *plist))
+{
+}
+
+#endif /* DDS_HAS_SECURITY */
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* DDSI_OMG_SECURITY_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_security_util.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright(c) 2006 to 2020 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SECURITY_UTIL_H
+#define DDSI_SECURITY_UTIL_H
+
+#include "dds/features.h"
+
+#ifdef DDS_HAS_SECURITY
+
+#include "dds/ddsi/ddsi_plist.h"
+#include "dds/security/core/dds_security_utils.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+void g_omg_shallow_copy_StringSeq(DDS_Security_StringSeq *dst, const ddsi_stringseq_t *src);
+void g_omg_shallow_free_StringSeq(DDS_Security_StringSeq *obj);
+void q_omg_copy_PropertySeq(DDS_Security_PropertySeq *dst, const dds_propertyseq_t *src);
+void q_omg_shallow_copyin_PropertySeq(DDS_Security_PropertySeq *dst, const dds_propertyseq_t *src);
+void q_omg_shallow_copyout_PropertySeq(dds_propertyseq_t *dst, const DDS_Security_PropertySeq *src);
+void q_omg_shallow_free_PropertySeq(DDS_Security_PropertySeq *obj);
+void q_omg_shallow_copyin_BinaryPropertySeq(DDS_Security_BinaryPropertySeq *dst, const dds_binarypropertyseq_t *src);
+void q_omg_shallow_copyout_BinaryPropertySeq(dds_binarypropertyseq_t *dst, const DDS_Security_BinaryPropertySeq *src);
+void q_omg_shallow_free_BinaryPropertySeq(DDS_Security_BinaryPropertySeq *obj);
+void q_omg_shallow_copy_PropertyQosPolicy(DDS_Security_PropertyQosPolicy *dst, const dds_property_qospolicy_t *src);
+void q_omg_shallow_copy_security_qos(DDS_Security_Qos *dst, const struct dds_qos *src);
+void q_omg_shallow_free_PropertyQosPolicy(DDS_Security_PropertyQosPolicy *obj);
+void q_omg_shallow_free_security_qos(DDS_Security_Qos *obj);
+void q_omg_security_dataholder_copyin(nn_dataholder_t *dh, const DDS_Security_DataHolder *holder);
+void q_omg_security_dataholder_copyout(DDS_Security_DataHolder *holder, const nn_dataholder_t *dh);
+void q_omg_shallow_copyin_DataHolder(DDS_Security_DataHolder *dst, const nn_dataholder_t *src);
+void q_omg_shallow_copyout_DataHolder(nn_dataholder_t *dst, const DDS_Security_DataHolder *src);
+void q_omg_shallow_free_DataHolder(DDS_Security_DataHolder *obj);
+void q_omg_shallow_free_nn_dataholder(nn_dataholder_t *holder);
+void q_omg_shallow_copyin_DataHolderSeq(DDS_Security_DataHolderSeq *dst, const nn_dataholderseq_t *src);
+void q_omg_copyin_DataHolderSeq(DDS_Security_DataHolderSeq *dst, const nn_dataholderseq_t *src);
+void q_omg_shallow_copyout_DataHolderSeq(nn_dataholderseq_t *dst, const DDS_Security_DataHolderSeq *src);
+void q_omg_shallow_free_DataHolderSeq(DDS_Security_DataHolderSeq *obj);
+void q_omg_shallow_free_nn_dataholderseq(nn_dataholderseq_t *obj);
+void q_omg_shallow_copy_ParticipantBuiltinTopicDataSecure(DDS_Security_ParticipantBuiltinTopicDataSecure *dst, const ddsi_guid_t *guid, const ddsi_plist_t *plist);
+void q_omg_shallow_free_ParticipantBuiltinTopicDataSecure(DDS_Security_ParticipantBuiltinTopicDataSecure *obj);
+void q_omg_shallow_copy_SubscriptionBuiltinTopicDataSecure(DDS_Security_SubscriptionBuiltinTopicDataSecure *dst, const ddsi_guid_t *guid, const struct dds_qos *qos, const nn_security_info_t *secinfo);
+void q_omg_shallow_free_SubscriptionBuiltinTopicDataSecure(DDS_Security_SubscriptionBuiltinTopicDataSecure *obj);
+void q_omg_shallow_copy_PublicationBuiltinTopicDataSecure(DDS_Security_PublicationBuiltinTopicDataSecure *dst, const ddsi_guid_t *guid, const struct dds_qos *qos, const nn_security_info_t *secinfo);
+void q_omg_shallow_free_PublicationBuiltinTopicDataSecure(DDS_Security_PublicationBuiltinTopicDataSecure *obj);
+void q_omg_shallow_copy_TopicBuiltinTopicData(DDS_Security_TopicBuiltinTopicData *dst, const char *topic_name, const char *type_name);
+void q_omg_shallow_free_TopicBuiltinTopicData(DDS_Security_TopicBuiltinTopicData *obj);
+
+#if defined (__cplusplus)
+}
+#endif
+
+
+#endif /* DDS_HAS_SECURITY */
+
+#endif /* DDSI_SECURITY_UTIL_H */

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_serdata.h

@@ -0,0 +1,348 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SERDATA_H
+#define DDSI_SERDATA_H
+
+#include "dds/features.h"
+#include "dds/ddsrt/misc.h"
+#include "dds/ddsrt/time.h"
+#include "dds/ddsrt/iovec.h"
+#include "dds/ddsi/ddsi_sertype.h"
+#include "dds/ddsi/ddsi_keyhash.h"
+#include "dds/ddsi/ddsi_typelib.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct nn_rdata;
+
+enum ddsi_serdata_kind {
+  SDK_EMPTY,
+  SDK_KEY,
+  SDK_DATA
+};
+
+struct ddsi_serdata {
+  // Backwards compatibility support for ddsi_sertopic (which is intended to exist
+  // only for a little while, have to see how that works out ...) relies on reading
+  // and writing the first few fields of ddsi_serdata regardless of whether it is a
+  // new or an old one.
+  //
+  // At a minimum, it needs to look at "ops" for this.  Currently, because the old
+  // serdata is a prefix of the new serdata anyway, it also looks directly at "type"
+  // in dds_writecdr_impl, and elsewhere it simply timestamp and statusinfo.
+  //
+  // So don't change anything of the layout up to and including "twrite" unless
+  // checking the compatibility code in ddsi_sertopic.c, dds_writecdr_impl and
+  // dds_readcdr_impl.
+
+  const struct ddsi_serdata_ops *ops; /* cached from type->serdata_ops */
+  uint32_t hash;
+  ddsrt_atomic_uint32_t refc;
+  enum ddsi_serdata_kind kind;
+  const struct ddsi_sertype *type;
+
+  /* these get set by generic code after creating the serdata */
+  ddsrt_wctime_t timestamp;
+  uint32_t statusinfo;
+
+  /* FIXME: can I get rid of this one? */
+  ddsrt_mtime_t twrite; /* write time, not source timestamp, set post-throttling */
+
+#ifdef DDS_HAS_SHM
+  void* iox_chunk;
+  void* iox_subscriber; // actually: iox_sub_t *
+#endif
+};
+
+struct ddsi_serdata_wrapper {
+  struct ddsi_serdata c;
+  void *compat_wrap;
+};
+
+/* Serialised size of sample inclusive of DDSI encoding header
+   - uint32_t because the protocol can't handle samples larger than 4GB anyway
+   - FIXME: get the encoding header out of the serialised data */
+typedef uint32_t (*ddsi_serdata_size_t) (const struct ddsi_serdata *d);
+
+/* Free a serdata (called by unref when refcount goes to 0) */
+typedef void (*ddsi_serdata_free_t) (struct ddsi_serdata *d);
+
+/* Construct a serdata from a fragchain received over the network
+   - "kind" is KEY or DATA depending on the type of payload
+   - "size" is the serialised size of the sample, inclusive of DDSI encoding header
+   - the first fragchain always contains the encoding header in its entirety
+   - fragchains may overlap, though I have never seen any DDS implementation
+     actually send such nasty fragments
+   - FIXME: get the encoding header out of the serialised data */
+typedef struct ddsi_serdata * (*ddsi_serdata_from_ser_t) (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const struct nn_rdata *fragchain, size_t size);
+
+/* Exactly like ddsi_serdata_from_ser_t, but with the data in an iovec and guaranteed absence of overlap */
+typedef struct ddsi_serdata * (*ddsi_serdata_from_ser_iov_t) (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, ddsrt_msg_iovlen_t niov, const ddsrt_iovec_t *iov, size_t size);
+
+/* Construct a serdata from a keyhash (an SDK_KEY by definition) */
+typedef struct ddsi_serdata * (*ddsi_serdata_from_keyhash_t) (const struct ddsi_sertype *type, const struct ddsi_keyhash *keyhash);
+
+/* Construct a serdata from an application sample
+   - "kind" is KEY or DATA depending on the operation invoked by the application;
+     e.g., write results in kind = DATA, dispose in kind = KEY.  The important bit
+     is to not assume anything of the contents of non-key fields if kind = KEY
+     unless additional application knowledge is available */
+typedef struct ddsi_serdata * (*ddsi_serdata_from_sample_t) (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const void *sample);
+
+/* Construct a untyped serdata with just a keyvalue given a normal serdata (either key or data)
+   - used for mapping key values to instance ids in tkmap
+   - two reasons: size (keys are typically smaller than samples), and data in tkmap
+     is shared across topics
+   - whether a serdata is untyped or not is known from the context, and the topic
+     field may have any value for a untyped serdata (so in some cases, one can
+     simply do "return ddsi_serdata_ref(d);"
+ */
+typedef struct ddsi_serdata * (*ddsi_serdata_to_untyped_t) (const struct ddsi_serdata *d);
+
+/* Fill buffer with 'size' bytes of serialised data, starting from 'off'
+   - 0 <= off < off+sz <= alignup4(size(d))
+   - bytes at offsets 0 .. 3 are DDSI encoding header, size(d) includes that header
+   - what to copy for bytes in [size(d), alignup4(size(d))) depends on the serdata
+     implementation, the protocol treats them as undefined
+   - FIXME: get the encoding header out of the serialised data */
+typedef void (*ddsi_serdata_to_ser_t) (const struct ddsi_serdata *d, size_t off, size_t sz, void *buf);
+
+/* Provide a pointer to 'size' bytes of serialised data, starting from 'off'
+   - see ddsi_serdata_to_ser_t above
+   - instead of copying, this gives a reference that must remain valid until the
+     corresponding call to to_ser_unref
+   - multiple calls to to_ser_ref() may be issued in parallel
+   - lazily creating the serialised representation is allowed (though I'm not sure
+     how that would work with knowing the serialised size beforehand ...) */
+typedef struct ddsi_serdata * (*ddsi_serdata_to_ser_ref_t) (const struct ddsi_serdata *d, size_t off, size_t sz, ddsrt_iovec_t *ref);
+
+/* Release a lock on serialised data
+   - ref was previousy filled by ddsi_serdata_to_ser_ref_t */
+typedef void (*ddsi_serdata_to_ser_unref_t) (struct ddsi_serdata *d, const ddsrt_iovec_t *ref);
+
+/* Turn serdata into an application sample (or just the key values if only key values are
+   available); return false on error (typically out-of-memory, but if from_ser doesn't do any
+   validation it might be a deserialisation error, too).
+
+   If (bufptr != 0), then *bufptr .. buflim is space to be used from *bufptr up (with minimal
+   padding) for any data in the sample that needs to be allocated (e.g., strings, sequences);
+   otherwise malloc() is to be used for those.  (This allows read/take to be given a block of memory
+   by the caller.) */
+typedef bool (*ddsi_serdata_to_sample_t) (const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
+
+/* Create a sample from a untyped serdata, as returned by serdata_to_untyped.  This sample
+   obviously has just the key fields filled in and is used for generating invalid samples. */
+typedef bool (*ddsi_serdata_untyped_to_sample_t) (const struct ddsi_sertype *type, const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim);
+
+/* Test key values of two serdatas for equality.  The two will have the same ddsi_serdata_ops,
+   but are not necessarily of the same topic (one can decide to never consider them equal if they
+   are of different topics, of course; but the nice thing about _not_ doing that is that all
+   instances with a certain key value with have the same instance id, and that in turn makes
+   computing equijoins across topics much simpler). */
+typedef bool (*ddsi_serdata_eqkey_t) (const struct ddsi_serdata *a, const struct ddsi_serdata *b);
+
+/* Print a serdata into the provided buffer (truncating as necessary)
+   - topic is present for supporting printing of "untyped" samples
+   - buf != NULL, bufsize > 0 on input
+   - buf must always be terminated with a nul character on return
+   - returns the number of characters (excluding the terminating 0) needed to print it
+     in full (or, as an optimization, it may pretend that it has printed it in full,
+     returning bufsize-1) if it had to truncate) */
+typedef size_t (*ddsi_serdata_print_t) (const struct ddsi_sertype *type, const struct ddsi_serdata *d, char *buf, size_t size);
+
+/* Add keyhash (from serdata) to buffer (forcing md5 when necessary).
+   - key needs to be set within serdata (can already be md5)
+   - buf needs to be at least 16 bytes large */
+typedef void (*ddsi_serdata_get_keyhash_t) (const struct ddsi_serdata *d, struct ddsi_keyhash *buf, bool force_md5);
+
+#ifdef DDS_HAS_SHM
+typedef uint32_t(*ddsi_serdata_iox_size_t) (const struct ddsi_serdata* d);
+
+// Used for receiving a sample from a Iceoryx and for constructing a serdata for writing a "loaned sample",
+// that is, for constructing a sample where the data is already in shared memory.  The latter allows one
+// to avoid serializing the data for zero-copy data transfer if all subscribers are reachable via Iceoryx.
+//
+// The first case is when "sub" is not NULL, in which case it is a pointer to the Iceoryx subscriber
+typedef struct ddsi_serdata* (*ddsi_serdata_from_iox_t) (const struct ddsi_sertype* type, enum ddsi_serdata_kind kind, void* sub, void* buffer);
+#endif
+
+struct ddsi_serdata_ops {
+  ddsi_serdata_eqkey_t eqkey;
+  ddsi_serdata_size_t get_size;
+  ddsi_serdata_from_ser_t from_ser;
+  ddsi_serdata_from_ser_iov_t from_ser_iov;
+  ddsi_serdata_from_keyhash_t from_keyhash;
+  ddsi_serdata_from_sample_t from_sample;
+  ddsi_serdata_to_ser_t to_ser;
+  ddsi_serdata_to_ser_ref_t to_ser_ref;
+  ddsi_serdata_to_ser_unref_t to_ser_unref;
+  ddsi_serdata_to_sample_t to_sample;
+  ddsi_serdata_to_untyped_t to_untyped;
+  ddsi_serdata_untyped_to_sample_t untyped_to_sample;
+  ddsi_serdata_free_t free;
+  ddsi_serdata_print_t print;
+  ddsi_serdata_get_keyhash_t get_keyhash;
+#ifdef DDS_HAS_SHM
+  ddsi_serdata_iox_size_t get_sample_size;
+  ddsi_serdata_from_iox_t from_iox_buffer;
+#endif
+};
+
+#define DDSI_SERDATA_HAS_PRINT 1
+#define DDSI_SERDATA_HAS_FROM_SER_IOV 1
+#define DDSI_SERDATA_HAS_GET_KEYHASH 1
+
+DDS_EXPORT void ddsi_serdata_init (struct ddsi_serdata *d, const struct ddsi_sertype *type, enum ddsi_serdata_kind kind);
+
+/**
+ * @brief Return a pointer to the keyhash in the message fragchain if it was present, or else NULL.
+ *
+ * @param[in] fragchain the fragchain argument passed to @ref ddsi_serdata_from_ser (the first one, not any subsequent ones)
+ * @returns A pointer to the keyhash in the message if it was present, NULL if not. The lifetime is at least that of the fragchain itself.
+ */
+DDS_EXPORT const ddsi_keyhash_t *ddsi_serdata_keyhash_from_fragchain (const struct nn_rdata *fragchain);
+
+/* backwards compatibility: wrap a sertopic-derived serdata so that it may be used as a sertype-derived one; increments refcount */
+DDS_EXPORT struct ddsi_serdata *ddsi_sertopic_wrap_serdata (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, void *old);
+
+/**
+ * @brief Return a reference to a serdata with possible type conversion
+ *
+ * If `serdata` is of type `type`, this increments the reference count and returns
+ * `serdata`.  Otherwise, it constructs a new one from the serialised representation of
+ * `serdata`.  This can fail, in which case it returns NULL.
+ *
+ * @param[in] type    sertype the returned serdata must have
+ * @param[in] serdata  source sample (untouched except for the reference count and/or
+ *   extracting the serialised representation)
+ * @returns A reference to a serdata that is equivalent to the input with the correct
+ *   topic, or a null pointer on failure.  The reference must be released with @ref
+ *   ddsi_serdata_unref.
+ */
+DDS_EXPORT struct ddsi_serdata *ddsi_serdata_ref_as_type (const struct ddsi_sertype *type, struct ddsi_serdata *serdata);
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_ref (const struct ddsi_serdata *serdata_const) {
+#if defined (__cplusplus)
+  DDSRT_WARNING_GNUC_OFF(old-style-cast)
+  DDSRT_WARNING_CLANG_OFF(old-style-cast)
+#endif
+  struct ddsi_serdata *serdata = (struct ddsi_serdata *)serdata_const;
+#if defined (__cplusplus)
+  DDSRT_WARNING_CLANG_ON(old-style-cast)
+  DDSRT_WARNING_GNUC_ON(old-style-cast)
+#endif
+  ddsrt_atomic_inc32 (&serdata->refc);
+  return serdata;
+}
+
+DDS_INLINE_EXPORT inline void ddsi_serdata_unref (struct ddsi_serdata *serdata) {
+  if (ddsrt_atomic_dec32_ov (&serdata->refc) == 1)
+    serdata->ops->free (serdata);
+}
+
+DDS_INLINE_EXPORT inline uint32_t ddsi_serdata_size (const struct ddsi_serdata *d) {
+  return d->ops->get_size (d);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_from_ser (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const struct nn_rdata *fragchain, size_t size) {
+  return type->serdata_ops->from_ser (type, kind, fragchain, size);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_from_ser_iov (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, ddsrt_msg_iovlen_t niov, const ddsrt_iovec_t *iov, size_t size) {
+  return type->serdata_ops->from_ser_iov (type, kind, niov, iov, size);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_from_keyhash (const struct ddsi_sertype *type, const struct ddsi_keyhash *keyhash) {
+  return type->serdata_ops->from_keyhash (type, keyhash);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_from_sample (const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const void *sample) {
+  return type->serdata_ops->from_sample (type, kind, sample);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_to_untyped (const struct ddsi_serdata *d) {
+  return d->ops->to_untyped (d);
+}
+
+DDS_INLINE_EXPORT inline void ddsi_serdata_to_ser (const struct ddsi_serdata *d, size_t off, size_t sz, void *buf) {
+  d->ops->to_ser (d, off, sz, buf);
+}
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_to_ser_ref (const struct ddsi_serdata *d, size_t off, size_t sz, ddsrt_iovec_t *ref) {
+  return d->ops->to_ser_ref (d, off, sz, ref);
+}
+
+DDS_INLINE_EXPORT inline void ddsi_serdata_to_ser_unref (struct ddsi_serdata *d, const ddsrt_iovec_t *ref) {
+  d->ops->to_ser_unref (d, ref);
+}
+
+DDS_INLINE_EXPORT inline bool ddsi_serdata_to_sample (const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim) {
+  return d->ops->to_sample (d, sample, bufptr, buflim);
+}
+
+DDS_INLINE_EXPORT inline bool ddsi_serdata_untyped_to_sample (const struct ddsi_sertype *type, const struct ddsi_serdata *d, void *sample, void **bufptr, void *buflim) {
+  return d->ops->untyped_to_sample (type, d, sample, bufptr, buflim);
+}
+
+DDS_INLINE_EXPORT inline bool ddsi_serdata_eqkey (const struct ddsi_serdata *a, const struct ddsi_serdata *b) {
+  return a->ops->eqkey (a, b);
+}
+
+DDS_INLINE_EXPORT inline bool ddsi_serdata_print (const struct ddsi_serdata *d, char *buf, size_t size) {
+  return d->ops->print (d->type, d, buf, size);
+}
+
+DDS_INLINE_EXPORT inline bool ddsi_serdata_print_untyped (const struct ddsi_sertype *type, const struct ddsi_serdata *d, char *buf, size_t size) {
+  if (d->ops->print)
+    return d->ops->print (type, d, buf, size);
+  else
+  {
+    buf[0] = 0;
+    return 0;
+  }
+}
+
+DDS_INLINE_EXPORT inline void ddsi_serdata_get_keyhash (const struct ddsi_serdata *d, struct ddsi_keyhash *buf, bool force_md5) {
+  d->ops->get_keyhash (d, buf, force_md5);
+}
+
+#ifdef DDS_HAS_SHM
+DDS_INLINE_EXPORT inline uint32_t ddsi_serdata_iox_size(const struct ddsi_serdata* d)
+{
+  return d->type->iox_size;
+}
+
+inline struct ddsi_serdata* ddsi_serdata_from_iox(const struct ddsi_sertype* type, enum ddsi_serdata_kind kind, void* sub, void* iox_buffer) ddsrt_nonnull_all;
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata* ddsi_serdata_from_iox(const struct ddsi_sertype* type, enum ddsi_serdata_kind kind, void* sub, void* iox_buffer)
+{
+  return type->serdata_ops->from_iox_buffer(type, kind, sub, iox_buffer);
+}
+
+inline struct ddsi_serdata *ddsi_serdata_from_loaned_sample(const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const char *sample) ddsrt_nonnull_all;
+
+DDS_INLINE_EXPORT inline struct ddsi_serdata *ddsi_serdata_from_loaned_sample(const struct ddsi_sertype *type, enum ddsi_serdata_kind kind, const char *sample)
+{
+  if (type->serdata_ops->from_iox_buffer)
+    return type->serdata_ops->from_iox_buffer (type, kind, NULL, (void *) sample);
+  else
+    return type->serdata_ops->from_sample (type, kind, sample);
+}
+#endif
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_serdata_default.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright(c) 2006 to 2022 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SERDATA_DEFAULT_H
+#define DDSI_SERDATA_DEFAULT_H
+
+#include "dds/ddsrt/endian.h"
+#include "dds/ddsi/q_protocol.h" /* for nn_parameterid_t */
+#include "dds/ddsi/q_freelist.h"
+#include "dds/ddsrt/avl.h"
+#include "dds/ddsi/ddsi_serdata.h"
+#include "dds/ddsi/ddsi_plist_generic.h"
+#include "dds/ddsi/ddsi_typelib.h"
+#include "dds/ddsi/ddsi_typelookup.h"
+
+#include "dds/dds.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+struct CDRHeader {
+  unsigned short identifier;
+  unsigned short options;
+};
+
+struct serdatapool {
+  struct nn_freelist freelist;
+};
+
+#define KEYBUFTYPE_UNSET    0u
+#define KEYBUFTYPE_STATIC   1u // uses u.stbuf
+#define KEYBUFTYPE_DYNALIAS 2u // points into payload
+#define KEYBUFTYPE_DYNALLOC 3u // dynamically allocated
+
+#define SERDATA_DEFAULT_KEYSIZE_MASK        0x3FFFFFFFu
+
+struct ddsi_serdata_default_key {
+  unsigned buftype : 2;
+  unsigned keysize : 30;
+  union {
+    unsigned char stbuf[DDS_FIXED_KEY_MAX_SIZE];
+    unsigned char *dynbuf;
+  } u;
+};
+
+/* Debug builds may want to keep some additional state */
+#ifndef NDEBUG
+#define DDSI_SERDATA_DEFAULT_DEBUG_FIELDS \
+  bool fixed;
+#else
+#define DDSI_SERDATA_DEFAULT_DEBUG_FIELDS
+#endif
+
+/* There is an alignment requirement on the raw data (it must be at
+   offset mod 8 for the conversion to/from a dds_stream to work).
+   So we define two types: one without any additional padding, and
+   one where the appropriate amount of padding is inserted */
+#define DDSI_SERDATA_DEFAULT_PREPAD   \
+  struct ddsi_serdata c;              \
+  uint32_t pos;                       \
+  uint32_t size;                      \
+  DDSI_SERDATA_DEFAULT_DEBUG_FIELDS   \
+  struct ddsi_serdata_default_key key;\
+  struct serdatapool *serpool;        \
+  struct ddsi_serdata_default *next /* in pool->freelist */
+/* We suppress the zero-array warning (MSVC C4200) here ONLY for MSVC
+   and ONLY if it is being compiled as C++ code, as it only causes
+   issues there */
+#if defined _MSC_VER && defined __cplusplus
+#define DDSI_SERDATA_DEFAULT_POSTPAD  \
+  struct CDRHeader hdr;               \
+  DDSRT_WARNING_MSVC_OFF(4200)        \
+  char data[];                        \
+  DDSRT_WARNING_MSVC_ON(4200)
+#else
+#define DDSI_SERDATA_DEFAULT_POSTPAD  \
+  struct CDRHeader hdr;               \
+  char data[]
+#endif
+
+struct ddsi_serdata_default_unpadded {
+  DDSI_SERDATA_DEFAULT_PREPAD;
+  DDSI_SERDATA_DEFAULT_POSTPAD;
+};
+
+#ifdef __GNUC__
+#define DDSI_SERDATA_DEFAULT_PAD(n) ((n) % 8)
+#else
+#define DDSI_SERDATA_DEFAULT_PAD(n) (n)
+#endif
+
+struct ddsi_serdata_default {
+  DDSI_SERDATA_DEFAULT_PREPAD;
+  char pad[DDSI_SERDATA_DEFAULT_PAD (8 - (offsetof (struct ddsi_serdata_default_unpadded, data) % 8))];
+  DDSI_SERDATA_DEFAULT_POSTPAD;
+};
+
+#undef DDSI_SERDATA_DEFAULT_PAD
+#undef DDSI_SERDATA_DEFAULT_POSTPAD
+#undef DDSI_SERDATA_DEFAULT_PREPAD
+#undef DDSI_SERDATA_DEFAULT_FIXED_FIELD
+
+#ifndef DDS_TOPIC_INTERN_FILTER_FN_DEFINED
+#define DDS_TOPIC_INTERN_FILTER_FN_DEFINED
+typedef bool (*dds_topic_intern_filter_fn) (const void * sample, void *ctx);
+#endif
+
+typedef struct ddsi_sertype_default_desc_key {
+  uint32_t ops_offs;   /* Offset for key ops */
+  uint32_t idx;        /* Key index (used for key order) */
+} ddsi_sertype_default_desc_key_t;
+
+typedef struct ddsi_sertype_default_desc_key_seq {
+  uint32_t nkeys;
+  ddsi_sertype_default_desc_key_t *keys;
+} ddsi_sertype_default_desc_key_seq_t;
+
+typedef struct ddsi_sertype_default_desc_op_seq {
+  uint32_t nops;    /* Number of words in ops (which >= number of ops stored in preproc output) */
+  uint32_t *ops;    /* Marshalling meta data */
+} ddsi_sertype_default_desc_op_seq_t;
+
+/* Reduced version of dds_topic_descriptor_t */
+struct ddsi_sertype_default_desc {
+  uint32_t size;    /* Size of topic type */
+  uint32_t align;   /* Alignment of topic type */
+  uint32_t flagset; /* Flags */
+  ddsi_sertype_default_desc_key_seq_t keys;
+  ddsi_sertype_default_desc_op_seq_t ops;
+  ddsi_sertype_cdr_data_t typeinfo_ser;
+  ddsi_sertype_cdr_data_t typemap_ser;
+};
+
+struct ddsi_sertype_default {
+  struct ddsi_sertype c;
+  uint16_t encoding_format; /* CDR_ENC_FORMAT_(PLAIN|DELIMITED|PL) - CDR encoding format for the top-level type in this sertype */
+  uint16_t write_encoding_version; /* CDR_ENC_VERSION_(1|2) - CDR encoding version used for writing data using this sertype */
+  struct serdatapool *serpool;
+  struct ddsi_sertype_default_desc type;
+  size_t opt_size_xcdr1;
+  size_t opt_size_xcdr2;
+};
+
+struct ddsi_plist_sample {
+  void *blob;
+  size_t size;
+  nn_parameterid_t keyparam;
+};
+
+struct ddsi_rawcdr_sample {
+  void *blob;
+  size_t size;
+  void *key;
+  size_t keysize;
+};
+
+extern DDS_EXPORT const struct ddsi_sertype_ops ddsi_sertype_ops_default;
+
+extern DDS_EXPORT const struct ddsi_serdata_ops ddsi_serdata_ops_cdr;
+extern DDS_EXPORT const struct ddsi_serdata_ops ddsi_serdata_ops_cdr_nokey;
+
+extern DDS_EXPORT const struct ddsi_serdata_ops ddsi_serdata_ops_xcdr2;
+extern DDS_EXPORT const struct ddsi_serdata_ops ddsi_serdata_ops_xcdr2_nokey;
+
+struct serdatapool * ddsi_serdatapool_new (void);
+void ddsi_serdatapool_free (struct serdatapool * pool);
+dds_return_t ddsi_sertype_default_init (const struct ddsi_domaingv *gv, struct ddsi_sertype_default *st, const dds_topic_descriptor_t *desc, uint16_t min_xcdrv, dds_data_representation_id_t data_representation);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif

third-party/GR00T-WholeBodyControl/gear_sonic_deploy/thirdparty/unitree_sdk2/thirdparty/include/dds/ddsi/ddsi_serdata_plist.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright(c) 2006 to 2021 ZettaScale Technology and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
+ * v. 1.0 which is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
+ */
+#ifndef DDSI_SERDATA_PLIST_H
+#define DDSI_SERDATA_PLIST_H
+
+#include "dds/ddsi/q_protocol.h" /* for nn_parameterid_t */
+#include "dds/ddsi/ddsi_keyhash.h"
+#include "dds/ddsi/ddsi_serdata.h"
+#include "dds/ddsi/ddsi_sertype.h"
+
+#include "dds/dds.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* There is an alignment requirement on the raw data (it must be at
+   offset mod 8 for the conversion to/from a dds_stream to work).
+   So we define two types: one without any additional padding, and
+   one where the appropriate amount of padding is inserted */
+#define DDSI_SERDATA_PLIST_PREPAD     \
+  struct ddsi_serdata c;              \
+  uint32_t pos;                       \
+  uint32_t size;                      \
+  nn_vendorid_t vendorid;             \
+  nn_protocol_version_t protoversion; \
+  ddsi_keyhash_t keyhash
+#define DDSI_SERDATA_PLIST_POSTPAD    \
+  uint16_t identifier;                \
+  uint16_t options;                   \
+  char data[]
+
+struct ddsi_serdata_plist_unpadded {
+  DDSI_SERDATA_PLIST_PREPAD;
+  DDSI_SERDATA_PLIST_POSTPAD;
+};
+
+#ifdef __GNUC__
+#define DDSI_SERDATA_PLIST_PAD(n) ((n) % 8)
+#else
+#define DDSI_SERDATA_PLIST_PAD(n) (n)
+#endif
+
+struct ddsi_serdata_plist {
+  DDSI_SERDATA_PLIST_PREPAD;
+  char pad[DDSI_SERDATA_PLIST_PAD (8 - (offsetof (struct ddsi_serdata_plist_unpadded, data) % 8))];
+  DDSI_SERDATA_PLIST_POSTPAD;
+};
+
+#undef DDSI_SERDATA_PLIST_PAD
+#undef DDSI_SERDATA_PLIST_POSTPAD
+#undef DDSI_SERDATA_PLIST_PREPAD
+
+struct ddsi_sertype_plist {
+  struct ddsi_sertype c;
+  uint16_t encoding_format; /* CDR_ENC_FORMAT_(PLAIN|DELIMITED|PL) */
+  nn_parameterid_t keyparam;
+};
+
+extern DDS_EXPORT const struct ddsi_sertype_ops ddsi_sertype_ops_plist;
+extern DDS_EXPORT const struct ddsi_serdata_ops ddsi_serdata_ops_plist;
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif