#include "dds/ddsrt/md5.h"
+#include "dds/ddsrt/mh3.h"
#include "dds/ddsrt/heap.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_freelist.h"
+#include "dds/ddsi/ddsi_cdrstream.h"
#include "dds/ddsi/ddsi_sertopic.h"
#include "dds/ddsi/ddsi_serdata_default.h"
-static void sertopic_default_free (struct ddsi_sertopic *tp)
+static bool sertopic_default_equal (const struct ddsi_sertopic *acmn, const struct ddsi_sertopic *bcmn)
{
- ddsi_sertopic_fini (tp);
+ const struct ddsi_sertopic_default *a = (struct ddsi_sertopic_default *) acmn;
+ const struct ddsi_sertopic_default *b = (struct ddsi_sertopic_default *) bcmn;
+ if (a->native_encoding_identifier != b->native_encoding_identifier)
+ return false;
+ if (a->type.m_size != b->type.m_size)
+ return false;
+ if (a->type.m_align != b->type.m_align)
+ return false;
+ if (a->type.m_flagset != b->type.m_flagset)
+ return false;
+ if (a->type.m_nkeys != b->type.m_nkeys)
+ return false;
+ if (memcmp (a->type.m_keys, b->type.m_keys, a->type.m_nkeys * sizeof (*a->type.m_keys)) != 0)
+ return false;
+ if (a->type.m_nops != b->type.m_nops)
+ return false;
+ if (memcmp (a->type.m_ops, b->type.m_ops, a->type.m_nops * sizeof (*a->type.m_ops)) != 0)
+ return false;
+ assert (a->opt_size == b->opt_size);
+ return true;
+}
+
+static uint32_t sertopic_default_hash (const struct ddsi_sertopic *tpcmn)
+{
+ const struct ddsi_sertopic_default *tp = (struct ddsi_sertopic_default *) tpcmn;
+ uint32_t h = 0;
+ h = ddsrt_mh3 (&tp->native_encoding_identifier, sizeof (tp->native_encoding_identifier), 0);
+ h = ddsrt_mh3 (&tp->type.m_size, sizeof (tp->type.m_size), h);
+ h = ddsrt_mh3 (&tp->type.m_align, sizeof (tp->type.m_align), h);
+ h = ddsrt_mh3 (&tp->type.m_flagset, sizeof (tp->type.m_flagset), h);
+ h = ddsrt_mh3 (tp->type.m_keys, tp->type.m_nkeys * sizeof (*tp->type.m_keys), h);
+ h = ddsrt_mh3 (tp->type.m_ops, tp->type.m_nops * sizeof (*tp->type.m_ops), h);
+ return h;
+}
+
+static void sertopic_default_free (struct ddsi_sertopic *tpcmn)
+{
+ struct ddsi_sertopic_default *tp = (struct ddsi_sertopic_default *) tpcmn;
+ ddsrt_free (tp->type.m_keys);
+ ddsrt_free (tp->type.m_ops);
+ ddsi_sertopic_fini (&tp->c);
ddsrt_free (tp);
}
static void sertopic_default_zero_samples (const struct ddsi_sertopic *sertopic_common, void *sample, size_t count)
{
const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
- memset (sample, 0, tp->type->m_size * count);
+ memset (sample, 0, tp->type.m_size * count);
}
static void sertopic_default_realloc_samples (void **ptrs, const struct ddsi_sertopic *sertopic_common, void *old, size_t oldcount, size_t count)
{
const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
- const size_t size = tp->type->m_size;
+ const size_t size = tp->type.m_size;
char *new = (oldcount == count) ? old : dds_realloc (old, size * count);
if (new && count > oldcount)
memset (new + size * oldcount, 0, size * (count - oldcount));
@@ -53,7 +95,7 @@ static void sertopic_default_free_samples (const struct ddsi_sertopic *sertopic_
if (count > 0)
{
const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
- const struct dds_topic_descriptor *type = tp->type;
+ const struct ddsi_sertopic_default_desc *type = &tp->type;
const size_t size = type->m_size;
#ifndef NDEBUG
for (size_t i = 0, off = 0; i < count; i++, off += size)
@@ -64,7 +106,7 @@ static void sertopic_default_free_samples (const struct ddsi_sertopic *sertopic_
char *ptr = ptrs[0];
for (size_t i = 0; i < count; i++)
{
- dds_sample_free (ptr, type, DDS_FREE_CONTENTS);
+ dds_stream_free_sample (ptr, type->m_ops);
ptr += size;
}
}
@@ -76,6 +118,8 @@ static void sertopic_default_free_samples (const struct ddsi_sertopic *sertopic_
}
const struct ddsi_sertopic_ops ddsi_sertopic_ops_default = {
+ .equal = sertopic_default_equal,
+ .hash = sertopic_default_hash,
.free = sertopic_default_free,
.zero_samples = sertopic_default_zero_samples,
.realloc_samples = sertopic_default_realloc_samples,
diff --git a/src/core/ddsi/src/ddsi_ssl.c b/src/core/ddsi/src/ddsi_ssl.c
index e8abd98..bbbf19b 100644
--- a/src/core/ddsi/src/ddsi_ssl.c
+++ b/src/core/ddsi/src/ddsi_ssl.c
@@ -28,7 +28,7 @@
#include "dds/ddsrt/sockets.h"
#include "dds/ddsrt/sync.h"
#include "dds/ddsrt/threads.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
static SSL_CTX *ddsi_ssl_ctx = NULL;
static bool ddsi_ssl_allow_self_signed_hack = false;
@@ -38,7 +38,7 @@ static SSL *ddsi_ssl_new (void)
return SSL_new (ddsi_ssl_ctx);
}
-static void ddsi_ssl_error (const struct q_globals *gv, SSL *ssl, const char *str, int err)
+static void ddsi_ssl_error (const struct ddsi_domaingv *gv, SSL *ssl, const char *str, int err)
{
char buff[128];
ERR_error_string ((unsigned) SSL_get_error (ssl, err), buff);
@@ -178,7 +178,7 @@ static void ddsi_ssl_dynlock_destroy (CRYPTO_dynlock_value *lock, const char *fi
static int ddsi_ssl_password (char *buf, int num, int rwflag, void *udata)
{
- struct q_globals *gv = udata;
+ struct ddsi_domaingv *gv = udata;
(void) rwflag;
if (num < 0 || (size_t) num < strlen (gv->config.ssl_key_pass) + 1)
return 0;
@@ -188,7 +188,7 @@ static int ddsi_ssl_password (char *buf, int num, int rwflag, void *udata)
return (int) strlen (gv->config.ssl_key_pass);
}
-static SSL_CTX *ddsi_ssl_ctx_init (struct q_globals *gv)
+static SSL_CTX *ddsi_ssl_ctx_init (struct ddsi_domaingv *gv)
{
SSL_CTX *ctx = SSL_CTX_new (SSLv23_method ());
unsigned disallow_TLSv1_2;
@@ -281,7 +281,7 @@ fail:
return NULL;
}
-static void dds_report_tls_version (const struct q_globals *gv, const SSL *ssl, const char *oper)
+static void dds_report_tls_version (const struct ddsi_domaingv *gv, const SSL *ssl, const char *oper)
{
if (ssl)
{
@@ -292,7 +292,7 @@ static void dds_report_tls_version (const struct q_globals *gv, const SSL *ssl,
}
}
-static SSL *ddsi_ssl_connect (const struct q_globals *gv, ddsrt_socket_t sock)
+static SSL *ddsi_ssl_connect (const struct ddsi_domaingv *gv, ddsrt_socket_t sock)
{
SSL *ssl;
int err;
@@ -326,7 +326,7 @@ static BIO *ddsi_ssl_listen (ddsrt_socket_t sock)
return bio;
}
-static SSL *ddsi_ssl_accept (const struct q_globals *gv, BIO *bio, ddsrt_socket_t *sock)
+static SSL *ddsi_ssl_accept (const struct ddsi_domaingv *gv, BIO *bio, ddsrt_socket_t *sock)
{
SSL *ssl = NULL;
BIO *nbio;
@@ -350,7 +350,7 @@ static SSL *ddsi_ssl_accept (const struct q_globals *gv, BIO *bio, ddsrt_socket_
return ssl;
}
-static bool ddsi_ssl_init (struct q_globals *gv)
+static bool ddsi_ssl_init (struct ddsi_domaingv *gv)
{
/* FIXME: allocate this stuff ... don't copy gv into a global variable ... */
ERR_load_BIO_strings ();
diff --git a/src/core/ddsi/src/ddsi_tcp.c b/src/core/ddsi/src/ddsi_tcp.c
index 47ff028..5a7ed06 100644
--- a/src/core/ddsi/src/ddsi_tcp.c
+++ b/src/core/ddsi/src/ddsi_tcp.c
@@ -25,7 +25,7 @@
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_entity.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#define INVALID_PORT (~0u)
@@ -100,11 +100,11 @@ static const ddsrt_avl_treedef_t ddsi_tcp_treedef = DDSRT_AVL_TREEDEF_INITIALIZE
static ddsi_tcp_conn_t ddsi_tcp_new_conn (struct ddsi_tran_factory_tcp *fact, ddsrt_socket_t, bool, struct sockaddr *);
-static char *sockaddr_to_string_with_port (const struct q_globals *gv, char *dst, size_t sizeof_dst, const struct sockaddr *src)
+static char *sockaddr_to_string_with_port (struct ddsi_tran_factory_tcp *fact, char *dst, size_t sizeof_dst, const struct sockaddr *src)
{
nn_locator_t loc;
- ddsi_ipaddr_to_loc(&loc, src, src->sa_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
- ddsi_locator_to_string(gv, dst, sizeof_dst, &loc);
+ ddsi_ipaddr_to_loc(&fact->fact, &loc, src, src->sa_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
+ ddsi_locator_to_string(dst, sizeof_dst, &loc);
return dst;
}
@@ -165,7 +165,7 @@ static void ddsi_tcp_sock_free (const struct ddsrt_log_cfg *logcfg, ddsrt_socket
}
}
-static void ddsi_tcp_sock_new (ddsrt_socket_t *sock, unsigned short port, const struct q_globals *gv)
+static void ddsi_tcp_sock_new (ddsrt_socket_t *sock, unsigned short port, const struct ddsi_domaingv *gv)
{
if (make_socket (sock, port, true, true, gv) != 0)
{
@@ -182,9 +182,7 @@ static void ddsi_tcp_node_free (void * ptr)
static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const ddsrt_msghdr_t * msg)
{
-#ifdef DDSI_INCLUDE_SSL
struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_base.m_factory;
-#endif
char buff[DDSI_LOCSTRLEN];
ddsrt_socket_t sock;
dds_return_t ret;
@@ -219,7 +217,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const ddsrt_msghdr_t *
}
#endif
- sockaddr_to_string_with_port(conn->m_base.m_base.gv, buff, sizeof(buff), (struct sockaddr *) msg->msg_name);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *) msg->msg_name);
DDS_CLOG (DDS_LC_TCP, &conn->m_base.m_base.gv->logconfig, "tcp connect socket %"PRIdSOCK" port %u to %s\n", sock, get_socket_port (&conn->m_base.m_base.gv->logconfig, sock), buff);
/* Also may need to receive on connection so add to waitset */
@@ -267,7 +265,7 @@ static void ddsi_tcp_cache_add (struct ddsi_tran_factory_tcp *fact, ddsi_tcp_con
}
}
- sockaddr_to_string_with_port(fact->fact.gv, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
DDS_CLOG (DDS_LC_TCP, &fact->fact.gv->logconfig, "tcp cache %s %s socket %"PRIdSOCK" to %s\n", action, conn->m_base.m_server ? "server" : "client", conn->m_sock, buff);
}
@@ -282,7 +280,7 @@ static void ddsi_tcp_cache_remove (ddsi_tcp_conn_t conn)
node = ddsrt_avl_lookup_dpath (&ddsi_tcp_treedef, &fact->ddsi_tcp_cache_g, conn, &path);
if (node)
{
- sockaddr_to_string_with_port(fact->fact.gv, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
DDS_CLOG (DDS_LC_TCP, &conn->m_base.m_base.gv->logconfig, "tcp cache removed socket %"PRIdSOCK" to %s\n", conn->m_sock, buff);
ddsrt_avl_delete_dpath (&ddsi_tcp_treedef, &fact->ddsi_tcp_cache_g, node, &path);
ddsi_tcp_node_free (node);
@@ -383,9 +381,7 @@ static bool ddsi_tcp_select (const struct ddsrt_log_cfg *logcfg, ddsrt_socket_t
static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char *buf, size_t len, bool allow_spurious, nn_locator_t *srcloc)
{
-#ifdef DDSI_INCLUDE_SSL
struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_factory;
-#endif
dds_return_t rc;
ddsi_tcp_conn_t tcp = (ddsi_tcp_conn_t) conn;
ssize_t (*rd) (ddsi_tcp_conn_t, void *, size_t, dds_return_t * err) = ddsi_tcp_conn_read_plain;
@@ -409,7 +405,7 @@ static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char *buf, si
{
if (srcloc)
{
- ddsi_ipaddr_to_loc(srcloc, (struct sockaddr *)&tcp->m_peer_addr, tcp->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
+ ddsi_ipaddr_to_loc(&fact->fact, srcloc, (struct sockaddr *)&tcp->m_peer_addr, tcp->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
}
return (ssize_t) pos;
}
@@ -703,6 +699,7 @@ static bool ddsi_tcp_supports (const struct ddsi_tran_factory *fact_cmn, int32_t
static int ddsi_tcp_locator (struct ddsi_tran_factory *fact_cmn, ddsi_tran_base_t base, nn_locator_t *loc)
{
+ loc->tran = fact_cmn;
loc->kind = fact_cmn->m_kind;
memcpy(loc->address, base->gv->extloc.address, sizeof(loc->address));
loc->port = base->m_port;
@@ -775,7 +772,7 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
if (sock == DDSRT_INVALID_SOCKET)
{
(void)ddsrt_getsockname (tl->m_sock, (struct sockaddr *) &addr, &addrlen);
- sockaddr_to_string_with_port(fact->fact.gv, buff, sizeof(buff), (struct sockaddr *)&addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_CLOG ((rc == DDS_RETCODE_OK) ? DDS_LC_ERROR : DDS_LC_FATAL, &listener->m_base.gv->logconfig, "tcp accept failed on socket %"PRIdSOCK" at %s retcode %"PRId32"\n", tl->m_sock, buff, rc);
}
else if (getpeername (sock, (struct sockaddr *) &addr, &addrlen) == -1)
@@ -785,7 +782,7 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
}
else
{
- sockaddr_to_string_with_port(fact->fact.gv, buff, sizeof(buff), (struct sockaddr *)&addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_CLOG (DDS_LC_TCP, &listener->m_base.gv->logconfig, "tcp accept new socket %"PRIdSOCK" on socket %"PRIdSOCK" from %s\n", sock, tl->m_sock, buff);
(void)ddsrt_setsocknonblocking (sock, true);
@@ -822,8 +819,8 @@ static void ddsi_tcp_conn_peer_locator (ddsi_tran_conn_t conn, nn_locator_t * lo
char buff[DDSI_LOCSTRLEN];
ddsi_tcp_conn_t tc = (ddsi_tcp_conn_t) conn;
assert (tc->m_sock != DDSRT_INVALID_SOCKET);
- ddsi_ipaddr_to_loc (loc, (struct sockaddr *)&tc->m_peer_addr, tc->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
- ddsi_locator_to_string(conn->m_base.gv, buff, sizeof(buff), loc);
+ ddsi_ipaddr_to_loc (conn->m_factory, loc, (struct sockaddr *)&tc->m_peer_addr, tc->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
+ ddsi_locator_to_string(buff, sizeof(buff), loc);
DDS_CLOG (DDS_LC_TCP, &conn->m_base.gv->logconfig, "(tcp EP:%s)", buff);
}
@@ -863,6 +860,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (ddsi_tran_factory_t fact,
struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr);
ddsi_tcp_listener_t tl = NULL;
+ struct ddsi_tran_factory_tcp * const fact_tcp = (struct ddsi_tran_factory_tcp *) fact;
(void) qos;
@@ -894,7 +892,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (ddsi_tran_factory_t fact,
return NULL;
}
- sockaddr_to_string_with_port(fact->gv, buff, sizeof(buff), (struct sockaddr *)&addr);
+ sockaddr_to_string_with_port(fact_tcp, buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_CLOG (DDS_LC_TCP, &fact->gv->logconfig, "tcp create listener socket %"PRIdSOCK" on %s\n", sock, buff);
}
@@ -903,11 +901,9 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (ddsi_tran_factory_t fact,
static void ddsi_tcp_conn_delete (ddsi_tcp_conn_t conn)
{
-#ifdef DDSI_INCLUDE_SSL
struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_base.m_factory;
-#endif
char buff[DDSI_LOCSTRLEN];
- sockaddr_to_string_with_port(conn->m_base.m_base.gv, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
DDS_CLOG (DDS_LC_TCP, &conn->m_base.m_base.gv->logconfig, "tcp free %s connnection on socket %"PRIdSOCK" to %s\n", conn->m_base.m_server ? "server" : "client", conn->m_sock, buff);
#ifdef DDSI_INCLUDE_SSL
@@ -932,10 +928,10 @@ static void ddsi_tcp_close_conn (ddsi_tran_conn_t tc)
char buff[DDSI_LOCSTRLEN];
nn_locator_t loc;
ddsi_tcp_conn_t conn = (ddsi_tcp_conn_t) tc;
- sockaddr_to_string_with_port(tc->m_base.gv, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
+ sockaddr_to_string_with_port(fact_tcp, buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
DDS_CLOG (DDS_LC_TCP, &tc->m_base.gv->logconfig, "tcp close %s connnection on socket %"PRIdSOCK" to %s\n", conn->m_base.m_server ? "server" : "client", conn->m_sock, buff);
(void) shutdown (conn->m_sock, 2);
- ddsi_ipaddr_to_loc(&loc, (struct sockaddr *)&conn->m_peer_addr, conn->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
+ ddsi_ipaddr_to_loc(&fact_tcp->fact, &loc, (struct sockaddr *)&conn->m_peer_addr, conn->m_peer_addr.ss_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6);
loc.port = conn->m_peer_port;
purge_proxy_participants (conn->m_base.m_base.gv, &loc, conn->m_base.m_server);
}
@@ -993,8 +989,9 @@ static void ddsi_tcp_unblock_listener (ddsi_tran_listener_t listener)
} while (ret == DDS_RETCODE_INTERRUPTED);
if (ret != DDS_RETCODE_OK)
{
+ struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) listener->m_factory;
char buff[DDSI_LOCSTRLEN];
- sockaddr_to_string_with_port(listener->m_base.gv, buff, sizeof(buff), (struct sockaddr *)&addr);
+ sockaddr_to_string_with_port(fact, buff, sizeof(buff), (struct sockaddr *)&addr);
DDS_CWARNING (&listener->m_base.gv->logconfig, "tcp failed to connect to own listener (%s) error %"PRId32"\n", buff, ret);
}
}
@@ -1050,9 +1047,9 @@ static int ddsi_tcp_is_ssm_mcaddr (const ddsi_tran_factory_t tran, const nn_loca
return 0;
}
-static enum ddsi_nearby_address_result ddsi_tcp_is_nearby_address (ddsi_tran_factory_t tran, const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
+static enum ddsi_nearby_address_result ddsi_tcp_is_nearby_address (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
{
- return ddsi_ipaddr_is_nearby_address(tran, loc, ownloc, ninterf, interf);
+ return ddsi_ipaddr_is_nearby_address(loc, ownloc, ninterf, interf);
}
static int ddsi_tcp_is_valid_port (ddsi_tran_factory_t fact, uint32_t port)
@@ -1061,7 +1058,7 @@ static int ddsi_tcp_is_valid_port (ddsi_tran_factory_t fact, uint32_t port)
return (port <= 65535);
}
-int ddsi_tcp_init (struct q_globals *gv)
+int ddsi_tcp_init (struct ddsi_domaingv *gv)
{
struct ddsi_tran_factory_tcp *fact = ddsrt_malloc (sizeof (*fact));
diff --git a/src/core/ddsi/src/ddsi_threadmon.c b/src/core/ddsi/src/ddsi_threadmon.c
index 53139e9..2d1a453 100644
--- a/src/core/ddsi/src/ddsi_threadmon.c
+++ b/src/core/ddsi/src/ddsi_threadmon.c
@@ -22,7 +22,7 @@
#include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_unused.h"
-#include "dds/ddsi/q_globals.h" /* for mattr, cattr */
+#include "dds/ddsi/ddsi_domaingv.h" /* for mattr, cattr */
#include "dds/ddsi/q_receive.h"
struct alive_vt {
@@ -31,7 +31,7 @@ struct alive_vt {
};
struct threadmon_domain {
- const struct q_globals *gv;
+ const struct ddsi_domaingv *gv;
unsigned n_not_alive;
size_t msgpos;
char msg[2048];
@@ -51,7 +51,7 @@ struct ddsi_threadmon {
struct ddsrt_hh *domains;
};
-static struct threadmon_domain *find_domain (struct ddsi_threadmon *sl, const struct q_globals *gv)
+static struct threadmon_domain *find_domain (struct ddsi_threadmon *sl, const struct ddsi_domaingv *gv)
{
struct threadmon_domain dummy;
dummy.gv = gv;
@@ -101,7 +101,7 @@ static uint32_t threadmon_thread (struct ddsi_threadmon *sl)
vtime_t vt = ddsrt_atomic_ld32 (&thread_states.ts[i].vtime);
ddsrt_atomic_fence_ldld ();
- struct q_globals const * const gv = ddsrt_atomic_ldvoidp (&thread_states.ts[i].gv);
+ struct ddsi_domaingv const * const gv = ddsrt_atomic_ldvoidp (&thread_states.ts[i].gv);
struct threadmon_domain *tmdom = find_domain (sl, gv);
if (tmdom == NULL)
continue;
@@ -238,7 +238,7 @@ dds_return_t ddsi_threadmon_start (struct ddsi_threadmon *sl, const char *name)
return DDS_RETCODE_ERROR;
}
-void ddsi_threadmon_register_domain (struct ddsi_threadmon *sl, const struct q_globals *gv)
+void ddsi_threadmon_register_domain (struct ddsi_threadmon *sl, const struct ddsi_domaingv *gv)
{
if (gv->config.liveliness_monitoring)
{
@@ -256,7 +256,7 @@ void ddsi_threadmon_register_domain (struct ddsi_threadmon *sl, const struct q_g
}
}
-void ddsi_threadmon_unregister_domain (struct ddsi_threadmon *sl, const struct q_globals *gv)
+void ddsi_threadmon_unregister_domain (struct ddsi_threadmon *sl, const struct ddsi_domaingv *gv)
{
if (gv->config.liveliness_monitoring)
{
diff --git a/src/core/ddsi/src/ddsi_tkmap.c b/src/core/ddsi/src/ddsi_tkmap.c
index c00d4aa..9b6324b 100644
--- a/src/core/ddsi/src/ddsi_tkmap.c
+++ b/src/core/ddsi/src/ddsi_tkmap.c
@@ -18,13 +18,13 @@
#include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_gc.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/ddsi_iid.h"
#include "dds/ddsi/ddsi_tkmap.h"
-#include "dds/ddsrt/hopscotch.h"
-#include "dds__stream.h"
+#include "dds/ddsi/ddsi_cdrstream.h"
#include "dds/ddsi/ddsi_serdata.h"
+#include "dds/ddsrt/hopscotch.h"
#define REFC_DELETE 0x80000000
#define REFC_MASK 0x0fffffff
@@ -32,7 +32,7 @@
struct ddsi_tkmap
{
struct ddsrt_chh *m_hh;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
ddsrt_mutex_t m_lock;
ddsrt_cond_t m_cond;
};
@@ -86,7 +86,7 @@ static int dds_tk_equals_void (const void *a, const void *b)
return dds_tk_equals (a, b);
}
-struct ddsi_tkmap *ddsi_tkmap_new (struct q_globals *gv)
+struct ddsi_tkmap *ddsi_tkmap_new (struct ddsi_domaingv *gv)
{
struct ddsi_tkmap *tkmap = dds_alloc (sizeof (*tkmap));
tkmap->m_hh = ddsrt_chh_new (1, dds_tk_hash_void, dds_tk_equals_void, gc_buckets, tkmap);
diff --git a/src/core/ddsi/src/ddsi_tran.c b/src/core/ddsi/src/ddsi_tran.c
index 5350d58..2bdda5d 100644
--- a/src/core/ddsi/src/ddsi_tran.c
+++ b/src/core/ddsi/src/ddsi_tran.c
@@ -17,9 +17,10 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/ifaddrs.h"
#include "dds/ddsi/ddsi_tran.h"
+#include "dds/ddsi/ddsi_ipaddr.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
extern inline uint32_t ddsi_conn_type (ddsi_tran_conn_t conn);
extern inline uint32_t ddsi_conn_port (ddsi_tran_conn_t conn);
@@ -36,13 +37,13 @@ extern inline ddsi_tran_conn_t ddsi_listener_accept (ddsi_tran_listener_t listen
extern inline ssize_t ddsi_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc);
extern inline ssize_t ddsi_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsrt_iovec_t *iov, uint32_t flags);
-void ddsi_factory_add (struct q_globals *gv, ddsi_tran_factory_t factory)
+void ddsi_factory_add (struct ddsi_domaingv *gv, ddsi_tran_factory_t factory)
{
factory->m_factory = gv->ddsi_tran_factories;
gv->ddsi_tran_factories = factory;
}
-ddsi_tran_factory_t ddsi_factory_find (const struct q_globals *gv, const char *type)
+ddsi_tran_factory_t ddsi_factory_find (const struct ddsi_domaingv *gv, const char *type)
{
/* FIXME: should speed up */
ddsi_tran_factory_t factory = gv->ddsi_tran_factories;
@@ -59,7 +60,7 @@ ddsi_tran_factory_t ddsi_factory_find (const struct q_globals *gv, const char *t
return factory;
}
-void ddsi_tran_factories_fini (struct q_globals *gv)
+void ddsi_tran_factories_fini (struct ddsi_domaingv *gv)
{
ddsi_tran_factory_t factory;
while ((factory = gv->ddsi_tran_factories) != NULL)
@@ -72,7 +73,7 @@ void ddsi_tran_factories_fini (struct q_globals *gv)
}
}
-static ddsi_tran_factory_t ddsi_factory_find_with_len (const struct q_globals *gv, const char *type, size_t len)
+static ddsi_tran_factory_t ddsi_factory_find_with_len (const struct ddsi_domaingv *gv, const char *type, size_t len)
{
/* FIXME: should speed up */
ddsi_tran_factory_t factory = gv->ddsi_tran_factories;
@@ -90,7 +91,7 @@ static ddsi_tran_factory_t ddsi_factory_find_with_len (const struct q_globals *g
}
ddsrt_attribute_no_sanitize (("thread"))
-ddsi_tran_factory_t ddsi_factory_find_supported_kind (const struct q_globals *gv, int32_t kind)
+ddsi_tran_factory_t ddsi_factory_find_supported_kind (const struct ddsi_domaingv *gv, int32_t kind)
{
/* FIXME: MUST speed up */
ddsi_tran_factory_t factory;
@@ -236,13 +237,13 @@ void ddsi_listener_free (ddsi_tran_listener_t listener)
}
}
-int ddsi_is_mcaddr (const struct q_globals *gv, const nn_locator_t *loc)
+int ddsi_is_mcaddr (const struct ddsi_domaingv *gv, const nn_locator_t *loc)
{
ddsi_tran_factory_t tran = ddsi_factory_find_supported_kind (gv, loc->kind);
return tran ? tran->m_is_mcaddr_fn (tran, loc) : 0;
}
-int ddsi_is_ssm_mcaddr (const struct q_globals *gv, const nn_locator_t *loc)
+int ddsi_is_ssm_mcaddr (const struct ddsi_domaingv *gv, const nn_locator_t *loc)
{
ddsi_tran_factory_t tran = ddsi_factory_find_supported_kind(gv, loc->kind);
if (tran && tran->m_is_ssm_mcaddr_fn != 0)
@@ -250,13 +251,15 @@ int ddsi_is_ssm_mcaddr (const struct q_globals *gv, const nn_locator_t *loc)
return 0;
}
-enum ddsi_nearby_address_result ddsi_is_nearby_address (const struct q_globals *gv, const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
+enum ddsi_nearby_address_result ddsi_is_nearby_address (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
{
- ddsi_tran_factory_t tran = ddsi_factory_find_supported_kind(gv, loc->kind);
- return tran ? tran->m_is_nearby_address_fn (tran, loc, ownloc, ninterf, interf) : DNAR_DISTANT;
+ if (loc->tran != ownloc->tran || loc->kind != ownloc->kind)
+ return DNAR_DISTANT;
+ else
+ return ownloc->tran->m_is_nearby_address_fn (loc, ownloc, ninterf, interf);
}
-enum ddsi_locator_from_string_result ddsi_locator_from_string (const struct q_globals *gv, nn_locator_t *loc, const char *str, ddsi_tran_factory_t default_factory)
+enum ddsi_locator_from_string_result ddsi_locator_from_string (const struct ddsi_domaingv *gv, nn_locator_t *loc, const char *str, ddsi_tran_factory_t default_factory)
{
const char *sep = strchr(str, '/');
ddsi_tran_factory_t tran;
@@ -277,29 +280,67 @@ enum ddsi_locator_from_string_result ddsi_locator_from_string (const struct q_gl
return tran->m_locator_from_string_fn (tran, loc, sep ? sep + 1 : str);
}
-char *ddsi_locator_to_string (const struct q_globals *gv, char *dst, size_t sizeof_dst, const nn_locator_t *loc)
+char *ddsi_locator_to_string (char *dst, size_t sizeof_dst, const nn_locator_t *loc)
{
/* FIXME: should add a "factory" for INVALID locators */
- if (loc->kind != NN_LOCATOR_KIND_INVALID) {
- ddsi_tran_factory_t tran = ddsi_factory_find_supported_kind(gv, loc->kind);
- int pos = snprintf (dst, sizeof_dst, "%s/", tran->m_typename);
- if (0 < pos && (size_t)pos < sizeof_dst)
- (void) tran->m_locator_to_string_fn (tran, dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 1);
- } else {
+ if (loc->kind == NN_LOCATOR_KIND_INVALID) {
(void) snprintf (dst, sizeof_dst, "invalid/0:0");
+ } else if (loc->tran != NULL) {
+ int pos = snprintf (dst, sizeof_dst, "%s/", loc->tran->m_typename);
+ if (0 < pos && (size_t)pos < sizeof_dst)
+ (void) loc->tran->m_locator_to_string_fn (dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 1);
+ } else {
+ /* Because IPv4 and IPv6 addresses are so common we special-case and print them in the usual form
+ even if they didn't get mapped to a transport. To indicate that this mapping never took place
+ the kind is still printed as a number, not as (udp|tcp)6? */
+ switch (loc->kind)
+ {
+ case NN_LOCATOR_KIND_TCPv4:
+ case NN_LOCATOR_KIND_TCPv6:
+ case NN_LOCATOR_KIND_UDPv4:
+ case NN_LOCATOR_KIND_UDPv6: {
+ int pos = snprintf (dst, sizeof_dst, "%"PRId32"/", loc->kind);
+ if (0 < pos && (size_t)pos < sizeof_dst)
+ (void) ddsi_ipaddr_to_string (dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 1);
+ break;
+ }
+ default: {
+ const unsigned char * const x = loc->address;
+ (void) snprintf (dst, sizeof_dst, "%"PRId32"/[%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x]:%"PRIu32,
+ loc->kind, x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12], x[13], x[14], x[15], loc->port);
+ break;
+ }
+ }
}
return dst;
}
-char *ddsi_locator_to_string_no_port (const struct q_globals *gv, char *dst, size_t sizeof_dst, const nn_locator_t *loc)
+char *ddsi_locator_to_string_no_port (char *dst, size_t sizeof_dst, const nn_locator_t *loc)
{
- if (loc->kind != NN_LOCATOR_KIND_INVALID) {
- ddsi_tran_factory_t tran = ddsi_factory_find_supported_kind(gv, loc->kind);
- int pos = snprintf (dst, sizeof_dst, "%s/", tran->m_typename);
- if (0 < pos && (size_t)pos < sizeof_dst)
- (void) tran->m_locator_to_string_fn (tran, dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 0);
- } else {
+ if (loc->kind == NN_LOCATOR_KIND_INVALID) {
(void) snprintf (dst, sizeof_dst, "invalid/0");
+ } else if (loc->tran != NULL) {
+ int pos = snprintf (dst, sizeof_dst, "%s/", loc->tran->m_typename);
+ if (0 < pos && (size_t)pos < sizeof_dst)
+ (void) loc->tran->m_locator_to_string_fn (dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 0);
+ } else {
+ switch (loc->kind)
+ {
+ case NN_LOCATOR_KIND_TCPv4:
+ case NN_LOCATOR_KIND_TCPv6:
+ case NN_LOCATOR_KIND_UDPv4:
+ case NN_LOCATOR_KIND_UDPv6: {
+ int pos = snprintf (dst, sizeof_dst, "%"PRId32"/", loc->kind);
+ if (0 < pos && (size_t)pos < sizeof_dst)
+ (void) ddsi_ipaddr_to_string (dst + (size_t)pos, sizeof_dst - (size_t)pos, loc, 0);
+ break;
+ }
+ default: {
+ const unsigned char * const x = loc->address;
+ (void) snprintf (dst, sizeof_dst, "%"PRId32"/[%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x]",
+ loc->kind, x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12], x[13], x[14], x[15]);
+ }
+ }
}
return dst;
}
diff --git a/src/core/ddsi/src/ddsi_udp.c b/src/core/ddsi/src/ddsi_udp.c
index 5addd41..8720468 100644
--- a/src/core/ddsi/src/ddsi_udp.c
+++ b/src/core/ddsi/src/ddsi_udp.c
@@ -25,7 +25,7 @@
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_pcap.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
typedef struct ddsi_udp_conn {
struct ddsi_tran_conn m_base;
@@ -68,7 +68,7 @@ static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
if (ret > 0)
{
if (srcloc)
- ddsi_ipaddr_to_loc(srcloc, (struct sockaddr *)&src, src.ss_family == AF_INET ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_UDPv6);
+ ddsi_ipaddr_to_loc(conn->m_factory, srcloc, (struct sockaddr *)&src, src.ss_family == AF_INET ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_UDPv6);
if(conn->m_base.gv->pcap_fp)
{
@@ -88,8 +88,8 @@ static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
{
char addrbuf[DDSI_LOCSTRLEN];
nn_locator_t tmp;
- ddsi_ipaddr_to_loc(&tmp, (struct sockaddr *)&src, src.ss_family == AF_INET ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_UDPv6);
- ddsi_locator_to_string(conn->m_base.gv, addrbuf, sizeof(addrbuf), &tmp);
+ ddsi_ipaddr_to_loc(conn->m_factory, &tmp, (struct sockaddr *)&src, src.ss_family == AF_INET ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_UDPv6);
+ ddsi_locator_to_string(addrbuf, sizeof(addrbuf), &tmp);
DDS_CWARNING(&conn->m_base.gv->logconfig, "%s => %d truncated to %d\n", addrbuf, (int)ret, (int)len);
}
}
@@ -432,10 +432,10 @@ static enum ddsi_locator_from_string_result ddsi_udp_address_from_string (ddsi_t
return ddsi_ipaddr_from_string (tran, loc, str, tran->m_kind);
}
-static char *ddsi_udp_locator_to_string (ddsi_tran_factory_t tran, char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
+static char *ddsi_udp_locator_to_string (char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
{
if (loc->kind != NN_LOCATOR_KIND_UDPv4MCGEN) {
- return ddsi_ipaddr_to_string(tran, dst, sizeof_dst, loc, with_port);
+ return ddsi_ipaddr_to_string(dst, sizeof_dst, loc, with_port);
} else {
struct sockaddr_in src;
nn_udpv4mcgen_address_t mcgen;
@@ -472,7 +472,7 @@ static int ddsi_udp_is_valid_port (ddsi_tran_factory_t fact, uint32_t port)
return (port <= 65535);
}
-int ddsi_udp_init (struct q_globals *gv)
+int ddsi_udp_init (struct ddsi_domaingv *gv)
{
struct ddsi_tran_factory *fact = ddsrt_malloc (sizeof (*fact));
memset (fact, 0, sizeof (*fact));
diff --git a/src/core/ddsi/src/q_addrset.c b/src/core/ddsi/src/q_addrset.c
index 0d557e7..98e5406 100644
--- a/src/core/ddsi/src/q_addrset.c
+++ b/src/core/ddsi/src/q_addrset.c
@@ -23,7 +23,7 @@
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_addrset.h"
-#include "dds/ddsi/q_globals.h" /* gv.mattr */
+#include "dds/ddsi/ddsi_domaingv.h" /* gv.mattr */
#include "dds/ddsi/ddsi_udp.h" /* nn_mc4gen_address_t */
/* So what does one do with const & mutexes? I need to take lock in a
@@ -44,7 +44,7 @@ static int compare_locators_vwrap (const void *va, const void *vb);
static const ddsrt_avl_ctreedef_t addrset_treedef =
DDSRT_AVL_CTREEDEF_INITIALIZER (offsetof (struct addrset_node, avlnode), offsetof (struct addrset_node, loc), compare_locators_vwrap, 0);
-static int add_addresses_to_addrset_1 (const struct q_globals *gv, struct addrset *as, const char *ip, int port_mode, const char *msgtag, int req_mc, int mcgen_base, int mcgen_count, int mcgen_idx)
+static int add_addresses_to_addrset_1 (const struct ddsi_domaingv *gv, struct addrset *as, const char *ip, int port_mode, const char *msgtag, int req_mc, int mcgen_base, int mcgen_count, int mcgen_idx)
{
char buf[DDSI_LOCSTRLEN];
nn_locator_t loc;
@@ -94,7 +94,7 @@ static int add_addresses_to_addrset_1 (const struct q_globals *gv, struct addrse
if (port_mode >= 0)
{
loc.port = (unsigned) port_mode;
- GVLOG (DDS_LC_CONFIG, "%s: add %s", msgtag, ddsi_locator_to_string(gv, buf, sizeof(buf), &loc));
+ GVLOG (DDS_LC_CONFIG, "%s: add %s", msgtag, ddsi_locator_to_string(buf, sizeof(buf), &loc));
add_to_addrset (gv, as, &loc);
}
else
@@ -107,7 +107,7 @@ static int add_addresses_to_addrset_1 (const struct q_globals *gv, struct addrse
{
loc.port = ddsi_get_port (&gv->config, DDSI_PORT_UNI_DISC, i);
if (i == 0)
- GVLOG (DDS_LC_CONFIG, "%s", ddsi_locator_to_string(gv, buf, sizeof(buf), &loc));
+ GVLOG (DDS_LC_CONFIG, "%s", ddsi_locator_to_string(buf, sizeof(buf), &loc));
else
GVLOG (DDS_LC_CONFIG, ", :%"PRIu32, loc.port);
add_to_addrset (gv, as, &loc);
@@ -119,7 +119,7 @@ static int add_addresses_to_addrset_1 (const struct q_globals *gv, struct addrse
loc.port = ddsi_get_port (&gv->config, DDSI_PORT_MULTI_DISC, 0);
else
loc.port = (uint32_t) port_mode;
- GVLOG (DDS_LC_CONFIG, "%s", ddsi_locator_to_string(gv, buf, sizeof(buf), &loc));
+ GVLOG (DDS_LC_CONFIG, "%s", ddsi_locator_to_string(buf, sizeof(buf), &loc));
add_to_addrset (gv, as, &loc);
}
}
@@ -128,7 +128,7 @@ static int add_addresses_to_addrset_1 (const struct q_globals *gv, struct addrse
return 0;
}
-int add_addresses_to_addrset (const struct q_globals *gv, struct addrset *as, const char *addrs, int port_mode, const char *msgtag, int req_mc)
+int add_addresses_to_addrset (const struct ddsi_domaingv *gv, struct addrset *as, const char *addrs, int port_mode, const char *msgtag, int req_mc)
{
/* port_mode: -1 => take from string, if 0 & unicast, add for a range of participant indices;
port_mode >= 0 => always set port to port_mode
@@ -231,6 +231,7 @@ void unref_addrset (struct addrset *as)
void set_unspec_locator (nn_locator_t *loc)
{
+ loc->tran = NULL;
loc->kind = NN_LOCATOR_KIND_INVALID;
loc->port = NN_LOCATOR_PORT_INVALID;
memset (loc->address, 0, sizeof (loc->address));
@@ -245,7 +246,7 @@ int is_unspec_locator (const nn_locator_t *loc)
}
#ifdef DDSI_INCLUDE_SSM
-int addrset_contains_ssm (const struct q_globals *gv, const struct addrset *as)
+int addrset_contains_ssm (const struct ddsi_domaingv *gv, const struct addrset *as)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -262,7 +263,7 @@ int addrset_contains_ssm (const struct q_globals *gv, const struct addrset *as)
return 0;
}
-int addrset_any_ssm (const struct q_globals *gv, const struct addrset *as, nn_locator_t *dst)
+int addrset_any_ssm (const struct ddsi_domaingv *gv, const struct addrset *as, nn_locator_t *dst)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -280,7 +281,7 @@ int addrset_any_ssm (const struct q_globals *gv, const struct addrset *as, nn_lo
return 0;
}
-int addrset_any_non_ssm_mc (const struct q_globals *gv, const struct addrset *as, nn_locator_t *dst)
+int addrset_any_non_ssm_mc (const struct ddsi_domaingv *gv, const struct addrset *as, nn_locator_t *dst)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -308,7 +309,7 @@ int addrset_purge (struct addrset *as)
return 0;
}
-void add_to_addrset (const struct q_globals *gv, struct addrset *as, const nn_locator_t *loc)
+void add_to_addrset (const struct ddsi_domaingv *gv, struct addrset *as, const nn_locator_t *loc)
{
if (!is_unspec_locator (loc))
{
@@ -325,7 +326,7 @@ void add_to_addrset (const struct q_globals *gv, struct addrset *as, const nn_lo
}
}
-void remove_from_addrset (const struct q_globals *gv, struct addrset *as, const nn_locator_t *loc)
+void remove_from_addrset (const struct ddsi_domaingv *gv, struct addrset *as, const nn_locator_t *loc)
{
ddsrt_avl_dpath_t path;
ddsrt_avl_ctree_t *tree = ddsi_is_mcaddr (gv, loc) ? &as->mcaddrs : &as->ucaddrs;
@@ -339,7 +340,7 @@ void remove_from_addrset (const struct q_globals *gv, struct addrset *as, const
UNLOCK (as);
}
-void copy_addrset_into_addrset_uc (const struct q_globals *gv, struct addrset *as, const struct addrset *asadd)
+void copy_addrset_into_addrset_uc (const struct ddsi_domaingv *gv, struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -349,7 +350,7 @@ void copy_addrset_into_addrset_uc (const struct q_globals *gv, struct addrset *a
UNLOCK (asadd);
}
-void copy_addrset_into_addrset_mc (const struct q_globals *gv, struct addrset *as, const struct addrset *asadd)
+void copy_addrset_into_addrset_mc (const struct ddsi_domaingv *gv, struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -359,14 +360,14 @@ void copy_addrset_into_addrset_mc (const struct q_globals *gv, struct addrset *a
UNLOCK (asadd);
}
-void copy_addrset_into_addrset (const struct q_globals *gv, struct addrset *as, const struct addrset *asadd)
+void copy_addrset_into_addrset (const struct ddsi_domaingv *gv, struct addrset *as, const struct addrset *asadd)
{
copy_addrset_into_addrset_uc (gv, as, asadd);
copy_addrset_into_addrset_mc (gv, as, asadd);
}
#ifdef DDSI_INCLUDE_SSM
-void copy_addrset_into_addrset_no_ssm_mc (const struct q_globals *gv, struct addrset *as, const struct addrset *asadd)
+void copy_addrset_into_addrset_no_ssm_mc (const struct ddsi_domaingv *gv, struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ddsrt_avl_citer_t it;
@@ -380,7 +381,7 @@ void copy_addrset_into_addrset_no_ssm_mc (const struct q_globals *gv, struct add
}
-void copy_addrset_into_addrset_no_ssm (const struct q_globals *gv, struct addrset *as, const struct addrset *asadd)
+void copy_addrset_into_addrset_no_ssm (const struct ddsi_domaingv *gv, struct addrset *as, const struct addrset *asadd)
{
copy_addrset_into_addrset_uc (gv, as, asadd);
copy_addrset_into_addrset_no_ssm_mc (gv, as, asadd);
@@ -548,19 +549,19 @@ int addrset_forone (struct addrset *as, addrset_forone_fun_t f, void *arg)
struct log_addrset_helper_arg
{
uint32_t tf;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
};
static void log_addrset_helper (const nn_locator_t *n, void *varg)
{
const struct log_addrset_helper_arg *arg = varg;
- const struct q_globals *gv = arg->gv;
+ const struct ddsi_domaingv *gv = arg->gv;
char buf[DDSI_LOCSTRLEN];
if (gv->logconfig.c.mask & arg->tf)
- GVLOG (arg->tf, " %s", ddsi_locator_to_string (gv, buf, sizeof(buf), n));
+ GVLOG (arg->tf, " %s", ddsi_locator_to_string (buf, sizeof(buf), n));
}
-void nn_log_addrset (struct q_globals *gv, uint32_t tf, const char *prefix, const struct addrset *as)
+void nn_log_addrset (struct ddsi_domaingv *gv, uint32_t tf, const char *prefix, const struct addrset *as)
{
if (gv->logconfig.c.mask & tf)
{
diff --git a/src/core/ddsi/src/q_config.c b/src/core/ddsi/src/q_config.c
index 53533b0..8203275 100644
--- a/src/core/ddsi/src/q_config.c
+++ b/src/core/ddsi/src/q_config.c
@@ -149,9 +149,7 @@ DU(ipv4);
DUPF(allow_multicast);
DUPF(boolean);
DU(boolean_default);
-#if 0
PF(boolean_default);
-#endif
DUPF(string);
DU(tracingOutputFileName);
DU(verbosity);
@@ -731,8 +729,8 @@ static const struct cfgelem unsupp_cfgelems[] = {
BLURB("This element controls whether the actual sending of packets occurs on the same thread that prepares them, or is done asynchronously by another thread.
") },
{ LEAF_W_ATTRS("RediscoveryBlacklistDuration", rediscovery_blacklist_duration_attrs), 1, "10s", ABSOFF(prune_deleted_ppant.delay), 0, uf_duration_inf, 0, pf_duration,
BLURB("This element controls for how long a remote participant that was previously deleted will remain on a blacklist to prevent rediscovery, giving the software on a node time to perform any cleanup actions it needs to do. To some extent this delay is required internally by DDSI2E, but in the default configuration with the 'enforce' attribute set to false, DDSI2E will reallow rediscovery as soon as it has cleared its internal administration. Setting it to too small a value may result in the entry being pruned from the blacklist before DDSI2E is ready, it is therefore recommended to set it to at least several seconds.
") },
- { LEAF_W_ATTRS("MultipleReceiveThreads", multiple_recv_threads_attrs), 1, "true", ABSOFF(multiple_recv_threads), 0, uf_boolean, 0, pf_boolean,
- BLURB("This element controls whether all traffic is handled by a single receive thread or whether multiple receive threads may be used to improve latency. Currently multiple receive threads are only used for connectionless transport (e.g., UDP) and ManySocketsMode not set to single (the default).
") },
+ { LEAF_W_ATTRS("MultipleReceiveThreads", multiple_recv_threads_attrs), 1, "default", ABSOFF(multiple_recv_threads), 0, uf_boolean_default, 0, pf_boolean_default,
+ BLURB("This element controls whether all traffic is handled by a single receive thread (false) or whether multiple receive threads may be used to improve latency (true). By default it is disabled on Windows because it appears that one cannot count on being able to send packets to oneself, which is necessary to stop the thread during shutdown. Currently multiple receive threads are only used for connectionless transport (e.g., UDP) and ManySocketsMode not set to single (the default).
") },
{ MGROUP("ControlTopic", control_topic_cfgelems, control_topic_cfgattrs), 1, 0, 0, 0, 0, 0, 0, 0,
BLURB("The ControlTopic element allows configured whether DDSI2E provides a special control interface via a predefined topic or not.
") },
{ GROUP("Test", unsupp_test_cfgelems),
@@ -1621,7 +1619,7 @@ GENERIC_ENUM_CTYPE (boolean, int)
static const char *en_boolean_default_vs[] = { "default", "false", "true", NULL };
static const enum boolean_default en_boolean_default_ms[] = { BOOLDEF_DEFAULT, BOOLDEF_FALSE, BOOLDEF_TRUE, 0 };
-GENERIC_ENUM_UF (boolean_default)
+GENERIC_ENUM (boolean_default)
static const char *en_besmode_vs[] = { "full", "writers", "minimal", NULL };
static const enum besmode en_besmode_ms[] = { BESMODE_FULL, BESMODE_WRITERS, BESMODE_MINIMAL, 0 };
diff --git a/src/core/ddsi/src/q_ddsi_discovery.c b/src/core/ddsi/src/q_ddsi_discovery.c
index 43b086f..05cdea6 100644
--- a/src/core/ddsi/src/q_ddsi_discovery.c
+++ b/src/core/ddsi/src/q_ddsi_discovery.c
@@ -27,7 +27,7 @@
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_xevent.h"
#include "dds/ddsi/q_addrset.h"
@@ -36,7 +36,7 @@
#include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/ddsi_entity_index.h"
#include "dds/ddsi/q_entity.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_transmit.h"
@@ -46,7 +46,7 @@
#include "dds/ddsi/ddsi_security_omg.h"
#include "dds/ddsi/ddsi_pmd.h"
-static int get_locator (const struct q_globals *gv, nn_locator_t *loc, const nn_locators_t *locs, int uc_same_subnet)
+static int get_locator (const struct ddsi_domaingv *gv, nn_locator_t *loc, const nn_locators_t *locs, int uc_same_subnet)
{
struct nn_locators_one *l;
nn_locator_t first, samenet;
@@ -118,7 +118,7 @@ static int get_locator (const struct q_globals *gv, nn_locator_t *loc, const nn_
first_set = 1;
}
- switch (ddsi_is_nearby_address(gv, &l->loc, &gv->ownloc, (size_t) gv->n_interfaces, gv->interfaces))
+ switch (ddsi_is_nearby_address(&l->loc, &gv->ownloc, (size_t) gv->n_interfaces, gv->interfaces))
{
case DNAR_DISTANT:
break;
@@ -160,7 +160,7 @@ static int get_locator (const struct q_globals *gv, nn_locator_t *loc, const nn_
***
*****************************************************************************/
-static void maybe_add_pp_as_meta_to_as_disc (struct q_globals *gv, const struct addrset *as_meta)
+static void maybe_add_pp_as_meta_to_as_disc (struct ddsi_domaingv *gv, const struct addrset *as_meta)
{
if (addrset_empty_mc (as_meta) || !(gv->config.allowMulticast & AMC_SPDP))
{
@@ -188,7 +188,7 @@ int spdp_write (struct participant *pp)
{
struct nn_xmsg *mpayload;
struct nn_locators_one def_uni_loc_one, def_multi_loc_one, meta_uni_loc_one, meta_multi_loc_one;
- nn_plist_t ps;
+ ddsi_plist_t ps;
struct writer *wr;
size_t size;
char node[64];
@@ -216,7 +216,7 @@ int spdp_write (struct participant *pp)
construct the payload. */
mpayload = nn_xmsg_new (pp->e.gv->xmsgpool, &pp->e.guid, NULL, 0, NN_XMSG_KIND_DATA);
- nn_plist_init_empty (&ps);
+ ddsi_plist_init_empty (&ps);
ps.present |= PP_PARTICIPANT_GUID | PP_BUILTIN_ENDPOINT_SET |
PP_PROTOCOL_VERSION | PP_VENDORID | PP_PARTICIPANT_LEASE_DURATION |
PP_DOMAIN_ID;
@@ -237,11 +237,6 @@ int spdp_write (struct participant *pp)
ps.aliased |= PP_DOMAIN_TAG;
ps.domain_tag = pp->e.gv->config.domainTag;
}
- if (pp->prismtech_bes)
- {
- ps.present |= PP_PRISMTECH_BUILTIN_ENDPOINT_SET;
- ps.prismtech_builtin_endpoint_set = pp->prismtech_bes;
- }
ps.default_unicast_locators.n = 1;
ps.default_unicast_locators.first =
ps.default_unicast_locators.last = &def_uni_loc_one;
@@ -327,15 +322,15 @@ int spdp_write (struct participant *pp)
}
/* Participant QoS's insofar as they are set, different from the default, and mapped to the SPDP data, rather than to the PrismTech-specific CMParticipant endpoint. Currently, that means just USER_DATA. */
- qosdiff = nn_xqos_delta (&pp->plist->qos, &pp->e.gv->default_plist_pp.qos, QP_USER_DATA);
+ qosdiff = ddsi_xqos_delta (&pp->plist->qos, &pp->e.gv->default_plist_pp.qos, QP_USER_DATA);
if (pp->e.gv->config.explicitly_publish_qos_set_to_default)
qosdiff |= ~QP_UNRECOGNIZED_INCOMPATIBLE_MASK;
assert (ps.qos.present == 0);
- nn_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, 0);
- nn_plist_addtomsg (mpayload, pp->plist, 0, qosdiff);
+ ddsi_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, 0);
+ ddsi_plist_addtomsg (mpayload, pp->plist, 0, qosdiff);
nn_xmsg_addpar_sentinel (mpayload);
- nn_plist_fini (&ps);
+ ddsi_plist_fini (&ps);
ret = write_mpayload (wr, 1, PID_PARTICIPANT_GUID, mpayload);
nn_xmsg_free (mpayload);
@@ -345,7 +340,7 @@ int spdp_write (struct participant *pp)
static int spdp_dispose_unregister_with_wr (struct participant *pp, unsigned entityid)
{
struct nn_xmsg *mpayload;
- nn_plist_t ps;
+ ddsi_plist_t ps;
struct writer *wr;
int ret;
@@ -358,12 +353,12 @@ static int spdp_dispose_unregister_with_wr (struct participant *pp, unsigned ent
}
mpayload = nn_xmsg_new (pp->e.gv->xmsgpool, &pp->e.guid, NULL, 0, NN_XMSG_KIND_DATA);
- nn_plist_init_empty (&ps);
+ ddsi_plist_init_empty (&ps);
ps.present |= PP_PARTICIPANT_GUID;
ps.participant_guid = pp->e.guid;
- nn_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
+ ddsi_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
nn_xmsg_addpar_sentinel (mpayload);
- nn_plist_fini (&ps);
+ ddsi_plist_fini (&ps);
ret = write_mpayload (wr, 0, PID_PARTICIPANT_GUID, mpayload);
nn_xmsg_free (mpayload);
@@ -414,7 +409,7 @@ static unsigned pseudo_random_delay (const ddsi_guid_t *x, const ddsi_guid_t *y,
return (unsigned) (m >> 32);
}
-static void respond_to_spdp (const struct q_globals *gv, const ddsi_guid_t *dest_proxypp_guid)
+static void respond_to_spdp (const struct ddsi_domaingv *gv, const ddsi_guid_t *dest_proxypp_guid)
{
struct entidx_enum_participant est;
struct participant *pp;
@@ -439,9 +434,9 @@ static void respond_to_spdp (const struct q_globals *gv, const ddsi_guid_t *dest
entidx_enum_participant_fini (&est);
}
-static int handle_SPDP_dead (const struct receiver_state *rst, ddsi_entityid_t pwr_entityid, nn_wctime_t timestamp, const nn_plist_t *datap, unsigned statusinfo)
+static int handle_SPDP_dead (const struct receiver_state *rst, ddsi_entityid_t pwr_entityid, nn_wctime_t timestamp, const ddsi_plist_t *datap, unsigned statusinfo)
{
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
ddsi_guid_t guid;
GVLOGDISC ("SPDP ST%x", statusinfo);
@@ -474,7 +469,7 @@ static int handle_SPDP_dead (const struct receiver_state *rst, ddsi_entityid_t p
return 1;
}
-static void allowmulticast_aware_add_to_addrset (const struct q_globals *gv, uint32_t allow_multicast, struct addrset *as, const nn_locator_t *loc)
+static void allowmulticast_aware_add_to_addrset (const struct ddsi_domaingv *gv, uint32_t allow_multicast, struct addrset *as, const nn_locator_t *loc)
{
#if DDSI_INCLUDE_SSM
if (ddsi_is_ssm_mcaddr (gv, loc))
@@ -508,7 +503,7 @@ static struct proxy_participant *find_ddsi2_proxy_participant (const struct enti
return pp;
}
-static void make_participants_dependent_on_ddsi2 (struct q_globals *gv, const ddsi_guid_t *ddsi2guid, nn_wctime_t timestamp)
+static void make_participants_dependent_on_ddsi2 (struct ddsi_domaingv *gv, const ddsi_guid_t *ddsi2guid, nn_wctime_t timestamp)
{
struct entidx_enum_proxy_participant it;
struct proxy_participant *pp, *d2pp;
@@ -544,15 +539,14 @@ static void make_participants_dependent_on_ddsi2 (struct q_globals *gv, const dd
}
}
-static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_wctime_t timestamp, const nn_plist_t *datap)
+static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_wctime_t timestamp, const ddsi_plist_t *datap)
{
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
const unsigned bes_sedp_announcer_mask =
NN_DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER |
NN_DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER;
struct addrset *as_meta, *as_default;
- unsigned builtin_endpoint_set;
- unsigned prismtech_builtin_endpoint_set;
+ uint32_t builtin_endpoint_set;
ddsi_guid_t privileged_pp_guid;
dds_duration_t lease_duration;
unsigned custom_flags = 0;
@@ -580,7 +574,6 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
so it seemed; and yet they are necessary for correct operation,
so add them. */
builtin_endpoint_set = datap->builtin_endpoint_set;
- prismtech_builtin_endpoint_set = (datap->present & PP_PRISMTECH_BUILTIN_ENDPOINT_SET) ? datap->prismtech_builtin_endpoint_set : 0;
if (vendor_is_rti (rst->vendor) &&
((builtin_endpoint_set &
(NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER |
@@ -595,21 +588,6 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER |
NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER;
}
- if ((datap->present & PP_PRISMTECH_PARTICIPANT_VERSION_INFO) &&
- (datap->present & PP_PRISMTECH_BUILTIN_ENDPOINT_SET) &&
- !(datap->prismtech_participant_version_info.flags & NN_PRISMTECH_FL_PTBES_FIXED_0))
- {
- /* FIXED_0 (bug 0) indicates that this is an updated version that advertises
- CM readers/writers correctly (without it, we could make a reasonable guess,
- but it would cause problems with cases where we would be happy with only
- (say) CM participant. Have to do a backwards-compatible fix because it has
- already been released with the flags all aliased to bits 0 and 1 ... */
- GVLOGDISC (" (ptbes_fixed_0 %x)", prismtech_builtin_endpoint_set);
- if (prismtech_builtin_endpoint_set & NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_READER)
- prismtech_builtin_endpoint_set |= NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_READER | NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_READER;
- if (prismtech_builtin_endpoint_set & NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_WRITER)
- prismtech_builtin_endpoint_set |= NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER | NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER;
- }
/* Do we know this GUID already? */
{
@@ -652,7 +630,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
GVLOGDISC ("SPDP ST0 "PGUIDFMT, PGUID (datap->participant_guid));
GVLOGDISC (proxypp->implicitly_created ? " (NEW was-implicitly-created)" : " (update)");
proxypp->implicitly_created = 0;
- update_proxy_participant_plist_locked (proxypp, seq, datap, UPD_PROXYPP_SPDP, timestamp);
+ update_proxy_participant_plist_locked (proxypp, seq, datap, timestamp);
}
ddsrt_mutex_unlock (&proxypp->e.lock);
return interesting;
@@ -666,7 +644,16 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
}
}
- GVLOGDISC ("SPDP ST0 "PGUIDFMT" bes %x ptbes %x NEW", PGUID (datap->participant_guid), builtin_endpoint_set, prismtech_builtin_endpoint_set);
+ const bool is_secure = (datap->builtin_endpoint_set & NN_DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_ANNOUNCER) != 0;
+ /* Make sure we don't create any security builtin endpoint when it's considered unsecure. */
+ if (!is_secure)
+ builtin_endpoint_set &= NN_BES_MASK_NON_SECURITY;
+ GVLOGDISC ("SPDP ST0 "PGUIDFMT" bes %x%s NEW", PGUID (datap->participant_guid), builtin_endpoint_set, is_secure ? " (secure)" : "");
+ if (is_secure && !(datap->present & PP_IDENTITY_TOKEN))
+ {
+ GVLOGDISC (" identity token missing\n");
+ return 0;
+ }
if (datap->present & PP_PARTICIPANT_LEASE_DURATION)
{
@@ -679,9 +666,6 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
}
if (datap->present & PP_PRISMTECH_PARTICIPANT_VERSION_INFO) {
- if (datap->prismtech_participant_version_info.flags & NN_PRISMTECH_FL_KERNEL_SEQUENCE_NUMBER)
- custom_flags |= CF_INC_KERNEL_SEQUENCE_NUMBERS;
-
if ((datap->prismtech_participant_version_info.flags & NN_PRISMTECH_FL_DDSI2_PARTICIPANT_FLAG) &&
(datap->prismtech_participant_version_info.flags & NN_PRISMTECH_FL_PARTICIPANT_IS_DDSI2))
custom_flags |= CF_PARTICIPANT_IS_DDSI2;
@@ -785,7 +769,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
}
GVLOGDISC (" QOS={");
- nn_log_xqos (DDS_LC_DISCOVERY, &gv->logconfig, &datap->qos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, &datap->qos);
GVLOGDISC ("}\n");
maybe_add_pp_as_meta_to_as_disc (gv, as_meta);
@@ -795,7 +779,6 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
gv,
&datap->participant_guid,
builtin_endpoint_set,
- prismtech_builtin_endpoint_set,
&privileged_pp_guid,
as_default,
as_meta,
@@ -847,7 +830,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
static void handle_SPDP (const struct receiver_state *rst, ddsi_entityid_t pwr_entityid, seqno_t seq, nn_wctime_t timestamp, unsigned statusinfo, const void *vdata, uint32_t len)
{
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
const struct CDRHeader *data = vdata; /* built-ins not deserialized (yet) */
if (data == NULL)
{
@@ -856,8 +839,8 @@ static void handle_SPDP (const struct receiver_state *rst, ddsi_entityid_t pwr_e
}
else
{
- nn_plist_t decoded_data;
- nn_plist_src_t src;
+ ddsi_plist_t decoded_data;
+ ddsi_plist_src_t src;
int interesting = 0;
dds_return_t plist_ret;
src.protocol_version = rst->protocol_version;
@@ -868,7 +851,7 @@ static void handle_SPDP (const struct receiver_state *rst, ddsi_entityid_t pwr_e
src.strict = NN_STRICT_P (gv->config);
src.factory = gv->m_factory;
src.logconfig = &gv->logconfig;
- if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
+ if ((plist_ret = ddsi_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{
if (plist_ret != DDS_RETCODE_UNSUPPORTED)
GVWARNING ("SPDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
@@ -888,14 +871,14 @@ static void handle_SPDP (const struct receiver_state *rst, ddsi_entityid_t pwr_e
break;
}
- nn_plist_fini (&decoded_data);
+ ddsi_plist_fini (&decoded_data);
GVLOG (interesting ? DDS_LC_DISCOVERY : DDS_LC_TRACE, "\n");
}
}
struct add_locator_to_ps_arg {
- struct q_globals *gv;
- nn_plist_t *ps;
+ struct ddsi_domaingv *gv;
+ ddsi_plist_t *ps;
};
static void add_locator_to_ps (const nn_locator_t *loc, void *varg)
@@ -942,14 +925,14 @@ static int sedp_write_endpoint
const struct entity_common *common, const struct endpoint_common *epcommon,
const dds_qos_t *xqos, struct addrset *as, nn_security_info_t *security)
{
- struct q_globals * const gv = wr->e.gv;
+ struct ddsi_domaingv * const gv = wr->e.gv;
const dds_qos_t *defqos = is_writer_entityid (epguid->entityid) ? &gv->default_xqos_wr : &gv->default_xqos_rd;
struct nn_xmsg *mpayload;
uint64_t qosdiff;
- nn_plist_t ps;
+ ddsi_plist_t ps;
int ret;
- nn_plist_init_empty (&ps);
+ ddsi_plist_init_empty (&ps);
ps.present |= PP_ENDPOINT_GUID;
ps.endpoint_guid = *epguid;
@@ -1009,7 +992,7 @@ static int sedp_write_endpoint
}
#endif
- qosdiff = nn_xqos_delta (xqos, defqos, ~(uint64_t)0);
+ qosdiff = ddsi_xqos_delta (xqos, defqos, ~(uint64_t)0);
if (gv->config.explicitly_publish_qos_set_to_default)
qosdiff |= ~QP_UNRECOGNIZED_INCOMPATIBLE_MASK;
@@ -1027,10 +1010,10 @@ static int sedp_write_endpoint
important, except that they need to be set to reasonable things
or it'll crash */
mpayload = nn_xmsg_new (gv->xmsgpool, &wr->e.guid, NULL, 0, NN_XMSG_KIND_DATA);
- nn_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
- if (xqos) nn_xqos_addtomsg (mpayload, xqos, qosdiff);
+ ddsi_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
+ if (xqos) ddsi_xqos_addtomsg (mpayload, xqos, qosdiff);
nn_xmsg_addpar_sentinel (mpayload);
- nn_plist_fini (&ps);
+ ddsi_plist_fini (&ps);
GVLOGDISC ("sedp: write for "PGUIDFMT" via "PGUIDFMT"\n", PGUID (*epguid), PGUID (wr->e.guid));
ret = write_mpayload (wr, alive, PID_ENDPOINT_GUID, mpayload);
@@ -1128,10 +1111,10 @@ static const char *durability_to_string (dds_durability_kind_t k)
return "undefined-durability";
}
-static struct proxy_participant *implicitly_create_proxypp (struct q_globals *gv, const ddsi_guid_t *ppguid, nn_plist_t *datap /* note: potentially modifies datap */, const ddsi_guid_prefix_t *src_guid_prefix, nn_vendorid_t vendorid, nn_wctime_t timestamp, seqno_t seq)
+static struct proxy_participant *implicitly_create_proxypp (struct ddsi_domaingv *gv, const ddsi_guid_t *ppguid, ddsi_plist_t *datap /* note: potentially modifies datap */, const ddsi_guid_prefix_t *src_guid_prefix, nn_vendorid_t vendorid, nn_wctime_t timestamp, seqno_t seq)
{
ddsi_guid_t privguid;
- nn_plist_t pp_plist;
+ ddsi_plist_t pp_plist;
if (memcmp (&ppguid->prefix, src_guid_prefix, sizeof (ppguid->prefix)) == 0)
/* if the writer is owned by the participant itself, we're not interested */
@@ -1139,7 +1122,7 @@ static struct proxy_participant *implicitly_create_proxypp (struct q_globals *gv
privguid.prefix = *src_guid_prefix;
privguid.entityid = to_entityid (NN_ENTITYID_PARTICIPANT);
- nn_plist_init_empty(&pp_plist);
+ ddsi_plist_init_empty(&pp_plist);
if (vendor_is_cloud (vendorid))
{
@@ -1165,7 +1148,7 @@ static struct proxy_participant *implicitly_create_proxypp (struct q_globals *gv
doing anything about (1). That means we fall back to the legacy mode of locally generating
GIDs but leaving the system id unchanged if the remote is OSPL. */
actual_vendorid = (datap->present & PP_VENDORID) ? datap->vendorid : vendorid;
- new_proxy_participant(gv, ppguid, 0, 0, &privguid, new_addrset(), new_addrset(), &pp_plist, T_NEVER, actual_vendorid, CF_IMPLICITLY_CREATED_PROXYPP, timestamp, seq);
+ new_proxy_participant(gv, ppguid, 0, &privguid, new_addrset(), new_addrset(), &pp_plist, T_NEVER, actual_vendorid, CF_IMPLICITLY_CREATED_PROXYPP, timestamp, seq);
}
else if (ppguid->prefix.u[0] == src_guid_prefix->u[0] && vendor_is_eclipse_or_opensplice (vendorid))
{
@@ -1184,9 +1167,9 @@ static struct proxy_participant *implicitly_create_proxypp (struct q_globals *gv
goto err;
} else {
struct addrset *as_default, *as_meta;
- nn_plist_t tmp_plist;
+ ddsi_plist_t tmp_plist;
GVTRACE (" from-ddsi2 "PGUIDFMT, PGUID (privguid));
- nn_plist_init_empty (&pp_plist);
+ ddsi_plist_init_empty (&pp_plist);
ddsrt_mutex_lock (&privpp->e.lock);
as_default = ref_addrset(privpp->as_default);
@@ -1195,23 +1178,23 @@ static struct proxy_participant *implicitly_create_proxypp (struct q_globals *gv
tmp_plist = *privpp->plist;
tmp_plist.present = PP_PARTICIPANT_GUID | PP_PRISMTECH_PARTICIPANT_VERSION_INFO;
tmp_plist.participant_guid = *ppguid;
- nn_plist_mergein_missing (&pp_plist, &tmp_plist, ~(uint64_t)0, ~(uint64_t)0);
+ ddsi_plist_mergein_missing (&pp_plist, &tmp_plist, ~(uint64_t)0, ~(uint64_t)0);
ddsrt_mutex_unlock (&privpp->e.lock);
pp_plist.prismtech_participant_version_info.flags &= ~NN_PRISMTECH_FL_PARTICIPANT_IS_DDSI2;
- new_proxy_participant (gv, ppguid, 0, 0, &privguid, as_default, as_meta, &pp_plist, T_NEVER, vendorid, CF_IMPLICITLY_CREATED_PROXYPP | CF_PROXYPP_NO_SPDP, timestamp, seq);
+ new_proxy_participant (gv, ppguid, 0, &privguid, as_default, as_meta, &pp_plist, T_NEVER, vendorid, CF_IMPLICITLY_CREATED_PROXYPP | CF_PROXYPP_NO_SPDP, timestamp, seq);
}
}
err:
- nn_plist_fini (&pp_plist);
+ ddsi_plist_fini (&pp_plist);
return entidx_lookup_proxy_participant_guid (gv->entity_index, ppguid);
}
-static void handle_SEDP_alive (const struct receiver_state *rst, seqno_t seq, nn_plist_t *datap /* note: potentially modifies datap */, const ddsi_guid_prefix_t *src_guid_prefix, nn_vendorid_t vendorid, nn_wctime_t timestamp)
+static void handle_SEDP_alive (const struct receiver_state *rst, seqno_t seq, ddsi_plist_t *datap /* note: potentially modifies datap */, const ddsi_guid_prefix_t *src_guid_prefix, nn_vendorid_t vendorid, nn_wctime_t timestamp)
{
#define E(msg, lbl) do { GVLOGDISC (msg); goto lbl; } while (0)
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
struct proxy_participant *pp;
struct proxy_writer * pwr = NULL;
struct proxy_reader * prd = NULL;
@@ -1257,11 +1240,11 @@ static void handle_SEDP_alive (const struct receiver_state *rst, seqno_t seq, nn
xqos = &datap->qos;
is_writer = is_writer_entityid (datap->endpoint_guid.entityid);
if (!is_writer)
- nn_xqos_mergein_missing (xqos, &gv->default_xqos_rd, ~(uint64_t)0);
+ ddsi_xqos_mergein_missing (xqos, &gv->default_xqos_rd, ~(uint64_t)0);
else if (vendor_is_eclipse_or_prismtech(vendorid))
- nn_xqos_mergein_missing (xqos, &gv->default_xqos_wr, ~(uint64_t)0);
+ ddsi_xqos_mergein_missing (xqos, &gv->default_xqos_wr, ~(uint64_t)0);
else
- nn_xqos_mergein_missing (xqos, &gv->default_xqos_wr_nad, ~(uint64_t)0);
+ ddsi_xqos_mergein_missing (xqos, &gv->default_xqos_wr_nad, ~(uint64_t)0);
/* After copy + merge, should have at least the ones present in the
input. Also verify reliability and durability are present,
@@ -1349,7 +1332,7 @@ static void handle_SEDP_alive (const struct receiver_state *rst, seqno_t seq, nn
GVLOGDISC (" ssm=%u", ssm);
#endif
GVLOGDISC (") QOS={");
- nn_log_xqos (DDS_LC_DISCOVERY, &gv->logconfig, xqos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, xqos);
GVLOGDISC ("}\n");
if ((datap->endpoint_guid.entityid.u & NN_ENTITYID_SOURCE_MASK) == NN_ENTITYID_SOURCE_VENDOR && !vendor_is_eclipse_or_prismtech (vendorid))
@@ -1403,9 +1386,9 @@ err:
#undef E
}
-static void handle_SEDP_dead (const struct receiver_state *rst, nn_plist_t *datap, nn_wctime_t timestamp)
+static void handle_SEDP_dead (const struct receiver_state *rst, ddsi_plist_t *datap, nn_wctime_t timestamp)
{
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
int res;
if (!(datap->present & PP_ENDPOINT_GUID))
{
@@ -1422,7 +1405,7 @@ static void handle_SEDP_dead (const struct receiver_state *rst, nn_plist_t *data
static void handle_SEDP (const struct receiver_state *rst, seqno_t seq, nn_wctime_t timestamp, unsigned statusinfo, const void *vdata, uint32_t len)
{
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
const struct CDRHeader *data = vdata; /* built-ins not deserialized (yet) */
GVLOGDISC ("SEDP ST%x", statusinfo);
if (data == NULL)
@@ -1432,8 +1415,8 @@ static void handle_SEDP (const struct receiver_state *rst, seqno_t seq, nn_wctim
}
else
{
- nn_plist_t decoded_data;
- nn_plist_src_t src;
+ ddsi_plist_t decoded_data;
+ ddsi_plist_src_t src;
dds_return_t plist_ret;
src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor;
@@ -1443,7 +1426,7 @@ static void handle_SEDP (const struct receiver_state *rst, seqno_t seq, nn_wctim
src.strict = NN_STRICT_P (gv->config);
src.factory = gv->m_factory;
src.logconfig = &gv->logconfig;
- if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
+ if ((plist_ret = ddsi_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{
if (plist_ret != DDS_RETCODE_UNSUPPORTED)
GVWARNING ("SEDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
@@ -1463,7 +1446,7 @@ static void handle_SEDP (const struct receiver_state *rst, seqno_t seq, nn_wctim
break;
}
- nn_plist_fini (&decoded_data);
+ ddsi_plist_fini (&decoded_data);
}
}
@@ -1473,7 +1456,7 @@ static void handle_SEDP (const struct receiver_state *rst, seqno_t seq, nn_wctim
***
*****************************************************************************/
-int sedp_write_topic (struct participant *pp, const struct nn_plist *datap)
+int sedp_write_topic (struct participant *pp, const struct ddsi_plist *datap)
{
struct writer *sedp_wr;
struct nn_xmsg *mpayload;
@@ -1490,10 +1473,10 @@ int sedp_write_topic (struct participant *pp, const struct nn_plist *datap)
sedp_wr = get_sedp_writer (pp, NN_ENTITYID_SEDP_BUILTIN_TOPIC_WRITER);
mpayload = nn_xmsg_new (sedp_wr->e.gv->xmsgpool, &sedp_wr->e.guid, NULL, 0, NN_XMSG_KIND_DATA);
- delta = nn_xqos_delta (&datap->qos, &sedp_wr->e.gv->default_xqos_tp, ~(uint64_t)0);
+ delta = ddsi_xqos_delta (&datap->qos, &sedp_wr->e.gv->default_xqos_tp, ~(uint64_t)0);
if (sedp_wr->e.gv->config.explicitly_publish_qos_set_to_default)
delta |= ~QP_UNRECOGNIZED_INCOMPATIBLE_MASK;
- nn_plist_addtomsg (mpayload, datap, ~(uint64_t)0, delta);
+ ddsi_plist_addtomsg (mpayload, datap, ~(uint64_t)0, delta);
nn_xmsg_addpar_sentinel (mpayload);
ETRACE (pp, "sedp: write topic %s via "PGUIDFMT"\n", datap->qos.topic_name, PGUID (sedp_wr->e.guid));
@@ -1503,104 +1486,6 @@ int sedp_write_topic (struct participant *pp, const struct nn_plist *datap)
}
-/******************************************************************************
- ***
- *** PrismTech CM data
- ***
- *****************************************************************************/
-
-int sedp_write_cm_participant (struct participant *pp, int alive)
-{
- struct writer * sedp_wr;
- struct nn_xmsg *mpayload;
- nn_plist_t ps;
- int ret;
-
- if (pp->e.onlylocal) {
- /* This topic is only locally available. */
- return 0;
- }
-
- sedp_wr = get_sedp_writer (pp, NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER);
-
- /* The message is only a temporary thing, used only for encoding
- the QoS and other settings. So the header fields aren't really
- important, except that they need to be set to reasonable things
- or it'll crash */
- mpayload = nn_xmsg_new (sedp_wr->e.gv->xmsgpool, &sedp_wr->e.guid, NULL, 0, NN_XMSG_KIND_DATA);
- nn_plist_init_empty (&ps);
- ps.present = PP_PARTICIPANT_GUID;
- ps.participant_guid = pp->e.guid;
- nn_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
- nn_plist_fini (&ps);
- if (alive)
- {
- nn_plist_addtomsg (mpayload, pp->plist,
- PP_PRISMTECH_NODE_NAME | PP_PRISMTECH_EXEC_NAME | PP_PRISMTECH_PROCESS_ID |
- PP_ENTITY_NAME,
- QP_PRISMTECH_ENTITY_FACTORY);
- }
- nn_xmsg_addpar_sentinel (mpayload);
-
- ETRACE (pp, "sedp: write CMParticipant ST%x for "PGUIDFMT" via "PGUIDFMT"\n",
- alive ? 0 : NN_STATUSINFO_DISPOSE | NN_STATUSINFO_UNREGISTER, PGUID (pp->e.guid), PGUID (sedp_wr->e.guid));
- ret = write_mpayload (sedp_wr, alive, PID_PARTICIPANT_GUID, mpayload);
- nn_xmsg_free (mpayload);
- return ret;
-}
-
-static void handle_SEDP_CM (const struct receiver_state *rst, ddsi_entityid_t wr_entity_id, nn_wctime_t timestamp, uint32_t statusinfo, const void *vdata, uint32_t len)
-{
- struct q_globals * const gv = rst->gv;
- const struct CDRHeader *data = vdata; /* built-ins not deserialized (yet) */
- GVLOGDISC ("SEDP_CM ST%x", statusinfo);
- assert (wr_entity_id.u == NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER);
- (void) wr_entity_id;
- if (data == NULL)
- {
- GVLOGDISC (" no payload?\n");
- return;
- }
- else
- {
- nn_plist_t decoded_data;
- nn_plist_src_t src;
- dds_return_t plist_ret;
- src.protocol_version = rst->protocol_version;
- src.vendorid = rst->vendor;
- src.encoding = data->identifier;
- src.buf = (unsigned char *) data + 4;
- src.bufsz = len - 4;
- src.strict = NN_STRICT_P (gv->config);
- src.factory = gv->m_factory;
- src.logconfig = &gv->logconfig;
- if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
- {
- if (plist_ret != DDS_RETCODE_UNSUPPORTED)
- GVWARNING ("SEDP_CM (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
- return;
- }
-
- /* ignore: dispose/unregister is tied to deleting the participant, which will take care of the dispose/unregister for us */;
- if ((statusinfo & (NN_STATUSINFO_DISPOSE | NN_STATUSINFO_UNREGISTER)) == 0)
- {
- struct proxy_participant *proxypp;
- if (!(decoded_data.present & PP_PARTICIPANT_GUID))
- GVWARNING ("SEDP_CM (vendor %u.%u): missing participant GUID\n", src.vendorid.id[0], src.vendorid.id[1]);
- else
- {
- if ((proxypp = entidx_lookup_proxy_participant_guid (gv->entity_index, &decoded_data.participant_guid)) == NULL)
- proxypp = implicitly_create_proxypp (gv, &decoded_data.participant_guid, &decoded_data, &rst->src_guid_prefix, rst->vendor, timestamp, 0);
- if (proxypp != NULL)
- update_proxy_participant_plist (proxypp, 0, &decoded_data, UPD_PROXYPP_CM, timestamp);
- }
- }
-
- nn_plist_fini (&decoded_data);
- }
- GVLOGDISC ("\n");
-}
-
/******************************************************************************
*****************************************************************************/
@@ -1637,7 +1522,7 @@ static int defragment (unsigned char **datap, const struct nn_rdata *fragchain,
int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const struct nn_rdata *fragchain, UNUSED_ARG (const ddsi_guid_t *rdguid), UNUSED_ARG (void *qarg))
{
- struct q_globals * const gv = sampleinfo->rst->gv;
+ struct ddsi_domaingv * const gv = sampleinfo->rst->gv;
struct proxy_writer *pwr;
struct {
struct CDRHeader cdr;
@@ -1650,7 +1535,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
ddsi_guid_t srcguid;
Data_DataFrag_common_t *msg;
unsigned char data_smhdr_flags;
- nn_plist_t qos;
+ ddsi_plist_t qos;
unsigned char *datap;
int needs_free;
uint32_t datasz = sampleinfo->size;
@@ -1694,12 +1579,12 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
need_keyhash = (datasz == 0 || (data_smhdr_flags & (DATA_FLAG_KEYFLAG | DATA_FLAG_DATAFLAG)) == 0);
if (!(sampleinfo->complex_qos || need_keyhash))
{
- nn_plist_init_empty (&qos);
+ ddsi_plist_init_empty (&qos);
statusinfo = sampleinfo->statusinfo;
}
else
{
- nn_plist_src_t src;
+ ddsi_plist_src_t src;
size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos;
dds_return_t plist_ret;
src.protocol_version = sampleinfo->rst->protocol_version;
@@ -1710,7 +1595,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
src.strict = NN_STRICT_P (gv->config);
src.factory = gv->m_factory;
src.logconfig = &gv->logconfig;
- if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH, 0, &src)) < 0)
+ if ((plist_ret = ddsi_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH, 0, &src)) < 0)
{
if (plist_ret != DDS_RETCODE_UNSUPPORTED)
GVWARNING ("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
@@ -1773,14 +1658,9 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
switch (srcguid.entityid.u)
{
case NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER:
- case NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER:
case NN_ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER:
pid = PID_PARTICIPANT_GUID;
break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER:
- case NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER:
- pid = PID_GROUP_GUID;
- break;
case NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER:
case NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER:
case NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER:
@@ -1836,9 +1716,6 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
case NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER:
handle_pmd_message (sampleinfo->rst, timestamp, statusinfo, datap, datasz);
break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER:
- handle_SEDP_CM (sampleinfo->rst, srcguid.entityid, timestamp, statusinfo, datap, datasz);
- break;
#ifdef DDSI_INCLUDE_SECURITY
case NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER:
/* TODO: Handshake */
diff --git a/src/core/ddsi/src/q_debmon.c b/src/core/ddsi/src/q_debmon.c
index 6f6bf69..fbf33a0 100644
--- a/src/core/ddsi/src/q_debmon.c
+++ b/src/core/ddsi/src/q_debmon.c
@@ -25,9 +25,9 @@
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/ddsi_entity_index.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_ddsi_discovery.h"
@@ -52,7 +52,7 @@ struct debug_monitor {
ddsi_tran_listener_t servsock;
ddsrt_mutex_t lock;
ddsrt_cond_t cond;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
struct plugin *plugins;
int stop;
};
@@ -88,7 +88,7 @@ static void print_address (const nn_locator_t *n, void *varg)
{
struct print_address_arg *arg = varg;
char buf[DDSI_LOCSTRLEN];
- arg->count += cpf (arg->conn, " %s", ddsi_locator_to_string (arg->conn->m_base.gv, buf, sizeof(buf), n));
+ arg->count += cpf (arg->conn, " %s", ddsi_locator_to_string (buf, sizeof(buf), n));
}
static int print_addrset (ddsi_tran_conn_t conn, const char *prefix, struct addrset *as, const char *suffix)
@@ -142,7 +142,7 @@ static int print_proxy_endpoint_common (ddsi_tran_conn_t conn, const char *label
}
-static int print_participants (struct thread_state1 * const ts1, struct q_globals *gv, ddsi_tran_conn_t conn)
+static int print_participants (struct thread_state1 * const ts1, struct ddsi_domaingv *gv, ddsi_tran_conn_t conn)
{
struct entidx_enum_participant e;
struct participant *p;
@@ -227,7 +227,7 @@ static int print_participants (struct thread_state1 * const ts1, struct q_global
return x;
}
-static int print_proxy_participants (struct thread_state1 * const ts1, struct q_globals *gv, ddsi_tran_conn_t conn)
+static int print_proxy_participants (struct thread_state1 * const ts1, struct ddsi_domaingv *gv, ddsi_tran_conn_t conn)
{
struct entidx_enum_proxy_participant e;
struct proxy_participant *p;
@@ -346,7 +346,7 @@ static uint32_t debmon_main (void *vdm)
return 0;
}
-struct debug_monitor *new_debug_monitor (struct q_globals *gv, int32_t port)
+struct debug_monitor *new_debug_monitor (struct ddsi_domaingv *gv, int32_t port)
{
struct debug_monitor *dm;
@@ -381,7 +381,7 @@ struct debug_monitor *new_debug_monitor (struct q_globals *gv, int32_t port)
nn_locator_t loc;
char buf[DDSI_LOCSTRLEN];
(void) ddsi_listener_locator(dm->servsock, &loc);
- GVLOG (DDS_LC_CONFIG, "debmon at %s\n", ddsi_locator_to_string (gv, buf, sizeof(buf), &loc));
+ GVLOG (DDS_LC_CONFIG, "debmon at %s\n", ddsi_locator_to_string (buf, sizeof(buf), &loc));
}
ddsrt_mutex_init (&dm->lock);
diff --git a/src/core/ddsi/src/q_entity.c b/src/core/ddsi/src/q_entity.c
index 53f215e..72df23f 100644
--- a/src/core/ddsi/src/q_entity.c
+++ b/src/core/ddsi/src/q_entity.c
@@ -26,13 +26,13 @@
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_log.h"
+#include "dds/ddsi/q_bswap.h"
#include "dds/ddsrt/avl.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_lease.h"
#include "dds/ddsi/q_qosmatch.h"
#include "dds/ddsi/ddsi_entity_index.h"
-#include "dds/ddsi/q_globals.h"
-#include "dds/ddsi/q_bswap.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_xevent.h" /* qxev_spdp, &c. */
#include "dds/ddsi/q_ddsi_discovery.h" /* spdp_write, &c. */
@@ -70,7 +70,7 @@ struct deleted_participants_admin {
int64_t delay;
};
-struct proxy_writer_alive_state {
+struct alive_state {
bool alive;
uint32_t vclock;
};
@@ -100,10 +100,6 @@ static const unsigned builtin_writers_besmask =
NN_DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER |
NN_DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER |
NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER;
-static const unsigned prismtech_builtin_writers_besmask =
- NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_WRITER |
- NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER |
- NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER;
static dds_return_t new_writer_guid (struct writer **wr_out, const struct ddsi_guid *guid, const struct ddsi_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc *whc, status_cb_t status_cb, void *status_cbarg);
@@ -113,9 +109,7 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
static struct entity_common *entity_common_from_proxy_endpoint_common (const struct proxy_endpoint_common *c);
#ifdef DDSI_INCLUDE_SECURITY
-static const unsigned BES_MASK_NON_SECURITY = 0xf000ffff;
-
-static void handshake_end_cb(struct q_globals const * const gv, struct ddsi_handshake *handshake, const struct ddsi_guid *lpguid, const struct ddsi_guid *ppguid, enum ddsi_handshake_state result);
+static void handshake_end_cb(struct ddsi_domaingv const * const gv, struct ddsi_handshake *handshake, const struct ddsi_guid *lpguid, const struct ddsi_guid *ppguid, enum ddsi_handshake_state result);
static void downgrade_to_nonsecure(struct proxy_participant *proxypp);
#endif
@@ -232,7 +226,19 @@ bool is_local_orphan_endpoint (const struct entity_common *e)
is_builtin_endpoint (e->guid.entityid, NN_VENDORID_ECLIPSE));
}
-static void entity_common_init (struct entity_common *e, struct q_globals *gv, const struct ddsi_guid *guid, const char *name, enum entity_kind kind, nn_wctime_t tcreate, nn_vendorid_t vendorid, bool onlylocal)
+static int compare_ldur (const void *va, const void *vb)
+{
+ const struct ldur_fhnode *a = va;
+ const struct ldur_fhnode *b = vb;
+ return (a->ldur == b->ldur) ? 0 : (a->ldur < b->ldur) ? -1 : 1;
+}
+
+/* used in participant for keeping writer liveliness renewal */
+const ddsrt_fibheap_def_t ldur_fhdef = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct ldur_fhnode, heapnode), compare_ldur);
+/* used in (proxy)participant for writer liveliness monitoring */
+const ddsrt_fibheap_def_t lease_fhdef_pp = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct lease, pp_heapnode), compare_lease_tdur);
+
+static void entity_common_init (struct entity_common *e, struct ddsi_domaingv *gv, const struct ddsi_guid *guid, const char *name, enum entity_kind kind, nn_wctime_t tcreate, nn_vendorid_t vendorid, bool onlylocal)
{
e->guid = *guid;
e->kind = kind;
@@ -282,10 +288,28 @@ static void local_reader_ary_fini (struct local_reader_ary *x)
static void local_reader_ary_insert (struct local_reader_ary *x, struct reader *rd)
{
ddsrt_mutex_lock (&x->rdary_lock);
+ x->rdary = ddsrt_realloc (x->rdary, (x->n_readers + 2) * sizeof (*x->rdary));
+ if (x->n_readers <= 1 || rd->topic == x->rdary[x->n_readers - 1]->topic)
+ {
+ /* if the first or second reader, or if the topic is the same as that of
+ the last one in the list simply appending the new will maintain order */
+ x->rdary[x->n_readers] = rd;
+ }
+ else
+ {
+ uint32_t i;
+ for (i = 0; i < x->n_readers; i++)
+ if (x->rdary[i]->topic == rd->topic)
+ break;
+ if (i < x->n_readers)
+ {
+ /* shift any with the same topic plus whichever follow to make room */
+ memmove (&x->rdary[i + 1], &x->rdary[i], (x->n_readers - i) * sizeof (x->rdary[i]));
+ }
+ x->rdary[i] = rd;
+ }
+ x->rdary[x->n_readers + 1] = NULL;
x->n_readers++;
- x->rdary = ddsrt_realloc (x->rdary, (x->n_readers + 1) * sizeof (*x->rdary));
- x->rdary[x->n_readers - 1] = rd;
- x->rdary[x->n_readers] = NULL;
ddsrt_mutex_unlock (&x->rdary_lock);
}
@@ -294,13 +318,20 @@ static void local_reader_ary_remove (struct local_reader_ary *x, struct reader *
uint32_t i;
ddsrt_mutex_lock (&x->rdary_lock);
for (i = 0; i < x->n_readers; i++)
- {
if (x->rdary[i] == rd)
break;
- }
assert (i < x->n_readers);
- /* if i == N-1 copy is a no-op */
- x->rdary[i] = x->rdary[x->n_readers-1];
+ if (i + 1 < x->n_readers)
+ {
+ /* dropping the final one never requires any fixups; dropping one that has
+ the same topic as the last is as simple as moving the last one in the
+ removed one's location; else shift all following readers to keep it
+ grouped by topic */
+ if (rd->topic == x->rdary[x->n_readers - 1]->topic)
+ x->rdary[i] = x->rdary[x->n_readers - 1];
+ else
+ memmove (&x->rdary[i], &x->rdary[i + 1], (x->n_readers - i - 1) * sizeof (x->rdary[i]));
+ }
x->n_readers--;
x->rdary[x->n_readers] = NULL;
x->rdary = ddsrt_realloc (x->rdary, (x->n_readers + 1) * sizeof (*x->rdary));
@@ -448,22 +479,11 @@ static void remove_deleted_participant_guid (struct deleted_participants_admin *
}
/* PARTICIPANT ------------------------------------------------------ */
-
-static int compare_ldur (const void *va, const void *vb)
-{
- const struct ldur_fhnode *a = va;
- const struct ldur_fhnode *b = vb;
- return (a->ldur == b->ldur) ? 0 : (a->ldur < b->ldur) ? -1 : 1;
-}
-
-/* used in participant for keeping writer liveliness renewal */
-const ddsrt_fibheap_def_t ldur_fhdef = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct ldur_fhnode, heapnode), compare_ldur);
-
static bool update_qos_locked (struct entity_common *e, dds_qos_t *ent_qos, const dds_qos_t *xqos, nn_wctime_t timestamp)
{
uint64_t mask;
- mask = nn_xqos_delta (ent_qos, xqos, QP_CHANGEABLE_MASK & ~(QP_RXO_MASK | QP_PARTITION)) & xqos->present;
+ mask = ddsi_xqos_delta (ent_qos, xqos, QP_CHANGEABLE_MASK & ~(QP_RXO_MASK | QP_PARTITION)) & xqos->present;
#if 0
int a = (ent_qos->present & QP_TOPIC_DATA) ? (int) ent_qos->topic_data.length : 6;
int b = (xqos->present & QP_TOPIC_DATA) ? (int) xqos->topic_data.length : 6;
@@ -476,7 +496,7 @@ static bool update_qos_locked (struct entity_common *e, dds_qos_t *ent_qos, cons
!!(mask & QP_TOPIC_DATA));
#endif
EELOGDISC (e, "update_qos_locked "PGUIDFMT" delta=%"PRIu64" QOS={", PGUID(e->guid), mask);
- nn_log_xqos (DDS_LC_DISCOVERY, &e->gv->logconfig, xqos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &e->gv->logconfig, xqos);
EELOGDISC (e, "}\n");
if (mask == 0)
@@ -484,8 +504,8 @@ static bool update_qos_locked (struct entity_common *e, dds_qos_t *ent_qos, cons
return false;
ddsrt_mutex_lock (&e->qos_lock);
- nn_xqos_fini_mask (ent_qos, mask);
- nn_xqos_mergein_missing (ent_qos, xqos, mask);
+ ddsi_xqos_fini_mask (ent_qos, mask);
+ ddsi_xqos_mergein_missing (ent_qos, xqos, mask);
ddsrt_mutex_unlock (&e->qos_lock);
builtintopic_write (e->gv->builtin_topic_interface, e, timestamp, true);
return true;
@@ -517,7 +537,7 @@ static void pp_release_entityid(struct participant *pp, ddsi_entityid_t id)
ddsrt_mutex_unlock (&pp->e.lock);
}
-static void force_as_disc_address(struct q_globals *gv, const ddsi_guid_t *subguid)
+static void force_as_disc_address(struct ddsi_domaingv *gv, const ddsi_guid_t *subguid)
{
struct writer *wr = entidx_lookup_writer_guid (gv->entity_index, subguid);
assert (wr != NULL);
@@ -530,36 +550,48 @@ static void force_as_disc_address(struct q_globals *gv, const ddsi_guid_t *subgu
}
#ifdef DDSI_INCLUDE_SECURITY
-static void add_security_builtin_endpoints(struct participant *pp, ddsi_guid_t *subguid, const ddsi_guid_t *group_guid, struct q_globals *gv, bool add_writers, bool add_readers)
+static void add_security_builtin_endpoints(struct participant *pp, ddsi_guid_t *subguid, const ddsi_guid_t *group_guid, struct ddsi_domaingv *gv, bool add_writers, bool add_readers)
{
if (add_writers)
{
+ struct whc_writer_info *wrinfo;
+
subguid->entityid = to_entityid (NN_ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), NULL, NULL);
+ wrinfo = whc_make_wrinfo (NULL, &gv->builtin_endpoint_xqos_wr);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
+ whc_free_wrinfo (wrinfo);
/* But we need the as_disc address set for SPDP, because we need to
send it to everyone regardless of the existence of readers. */
force_as_disc_address(gv, subguid);
pp->bes |= NN_DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_ANNOUNCER;
subguid->entityid = to_entityid (NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_stateless_xqos_wr, whc_new(gv, 0, 1, 1), NULL, NULL);
+ wrinfo = whc_make_wrinfo (NULL, &gv->builtin_stateless_xqos_wr);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_stateless_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
+ whc_free_wrinfo (wrinfo);
pp->bes |= NN_BUILTIN_ENDPOINT_PARTICIPANT_STATELESS_MESSAGE_ANNOUNCER;
subguid->entityid = to_entityid (NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_volatile_xqos_wr, whc_new(gv, 0, 0, 0), NULL, NULL);
+ wrinfo = whc_make_wrinfo (NULL, &gv->builtin_volatile_xqos_wr);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_volatile_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
+ whc_free_wrinfo (wrinfo);
pp->bes |= NN_BUILTIN_ENDPOINT_PARTICIPANT_VOLATILE_SECURE_ANNOUNCER;
+ wrinfo = whc_make_wrinfo (NULL, &gv->builtin_endpoint_xqos_wr);
+
subguid->entityid = to_entityid (NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), NULL, NULL);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_SECURE_ANNOUNCER;
subguid->entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), NULL, NULL);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_BUILTIN_ENDPOINT_PUBLICATION_MESSAGE_SECURE_ANNOUNCER;
subguid->entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER);
- new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), NULL, NULL);
+ new_writer_guid (NULL, subguid, group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_BUILTIN_ENDPOINT_SUBSCRIPTION_MESSAGE_SECURE_ANNOUNCER;
+
+ whc_free_wrinfo (wrinfo);
}
if (add_readers)
@@ -598,7 +630,7 @@ static void add_security_builtin_endpoints(struct participant *pp, ddsi_guid_t *
#ifdef DDSI_INCLUDE_SECURITY
-static void connect_participant_secure(struct q_globals *gv, struct participant *pp)
+static void connect_participant_secure(struct ddsi_domaingv *gv, struct participant *pp)
{
struct proxy_participant *proxypp;
struct entidx_enum_proxy_participant it;
@@ -622,7 +654,7 @@ static void disconnect_participant_secure(struct participant *pp)
{
struct proxy_participant *proxypp;
struct entidx_enum_proxy_participant it;
- struct q_globals * const gv = pp->e.gv;
+ struct ddsi_domaingv * const gv = pp->e.gv;
if (q_omg_participant_is_secure(pp))
{
@@ -636,10 +668,86 @@ static void disconnect_participant_secure(struct participant *pp)
}
#endif
-dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *gv, unsigned flags, const nn_plist_t *plist)
+static void gc_participant_lease (struct gcreq *gcreq)
+{
+ lease_free (gcreq->arg);
+ gcreq_free (gcreq);
+}
+
+static void participant_replace_minl (struct participant *pp, struct lease *lnew)
+{
+ /* By loading/storing the pointer atomically, we ensure we always
+ read a valid (or once valid) lease. By delaying freeing the lease
+ through the garbage collector, we ensure whatever lease update
+ occurs in parallel completes before the memory is released. */
+ struct gcreq *gcreq = gcreq_new (pp->e.gv->gcreq_queue, gc_participant_lease);
+ struct lease *lease_old = ddsrt_atomic_ldvoidp (&pp->minl_man);
+ assert (lease_old != NULL);
+ lease_unregister (lease_old); /* ensures lease will not expire while it is replaced */
+ gcreq->arg = lease_old;
+ gcreq_enqueue (gcreq);
+ ddsrt_atomic_stvoidp (&pp->minl_man, lnew);
+}
+
+static void participant_add_wr_lease_locked (struct participant * pp, const struct writer * wr)
+{
+ struct lease *minl_prev;
+ struct lease *minl_new;
+
+ assert (wr->lease != NULL);
+ minl_prev = ddsrt_fibheap_min (&lease_fhdef_pp, &pp->leaseheap_man);
+ ddsrt_fibheap_insert (&lease_fhdef_pp, &pp->leaseheap_man, wr->lease);
+ minl_new = ddsrt_fibheap_min (&lease_fhdef_pp, &pp->leaseheap_man);
+ /* if inserted lease is new shortest lease */
+ if (minl_prev != minl_new)
+ {
+ nn_etime_t texp = add_duration_to_etime (now_et (), minl_new->tdur);
+ struct lease *lnew = lease_new (texp, minl_new->tdur, minl_new->entity);
+ if (minl_prev == NULL)
+ {
+ assert (ddsrt_atomic_ldvoidp (&pp->minl_man) == NULL);
+ ddsrt_atomic_stvoidp (&pp->minl_man, lnew);
+ }
+ else
+ {
+ participant_replace_minl (pp, lnew);
+ }
+ lease_register (lnew);
+ }
+}
+
+static void participant_remove_wr_lease_locked (struct participant * pp, struct writer * wr)
+{
+ struct lease *minl;
+
+ assert (wr->lease != NULL);
+ assert (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT);
+ minl = ddsrt_fibheap_min (&lease_fhdef_pp, &pp->leaseheap_man);
+ ddsrt_fibheap_delete (&lease_fhdef_pp, &pp->leaseheap_man, wr->lease);
+ /* if writer with min lease is removed: update participant lease to use new minimal duration */
+ if (wr->lease == minl)
+ {
+ if ((minl = ddsrt_fibheap_min (&lease_fhdef_pp, &pp->leaseheap_man)) != NULL)
+ {
+ dds_duration_t trem = minl->tdur - wr->lease->tdur;
+ assert (trem >= 0);
+ nn_etime_t texp = add_duration_to_etime (now_et(), trem);
+ struct lease *lnew = lease_new (texp, minl->tdur, minl->entity);
+ participant_replace_minl (pp, lnew);
+ lease_register (lnew);
+ }
+ else
+ {
+ participant_replace_minl (pp, NULL);
+ }
+ }
+}
+
+dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct ddsi_domaingv *gv, unsigned flags, const ddsi_plist_t *plist)
{
struct participant *pp;
ddsi_guid_t subguid, group_guid;
+ struct whc_writer_info *wrinfo;
dds_return_t ret = DDS_RETCODE_OK;
/* no reserved bits may be set */
@@ -694,8 +802,8 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
pp->lease_duration = gv->config.lease_duration;
ddsrt_fibheap_init (&ldur_fhdef, &pp->ldur_auto_wr);
pp->plist = ddsrt_malloc (sizeof (*pp->plist));
- nn_plist_copy (pp->plist, plist);
- nn_plist_mergein_missing (pp->plist, &gv->default_local_plist_pp, ~(uint64_t)0, ~(uint64_t)0);
+ ddsi_plist_copy (pp->plist, plist);
+ ddsi_plist_mergein_missing (pp->plist, &gv->default_local_plist_pp, ~(uint64_t)0, ~(uint64_t)0);
#ifdef DDSI_INCLUDE_SECURITY
/*
@@ -706,7 +814,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
* and return if any is found */
{
bool ready_to_load_security = false;
- if (nn_xqos_has_prop(&pp->plist->qos, "dds.sec.", true, false)) {
+ if (ddsi_xqos_has_prop(&pp->plist->qos, "dds.sec.", true, false)) {
char *req[] = {DDS_SEC_PROP_AUTH_IDENTITY_CA,
DDS_SEC_PROP_AUTH_PRIV_KEY,
DDS_SEC_PROP_AUTH_IDENTITY_CERT,
@@ -729,7 +837,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
/* check if all required security properties exist in qos */
for (size_t i = 0; i < sizeof(req) / sizeof(req[0]); i++) {
- if (!nn_xqos_has_prop(&pp->plist->qos, req[i], false, true)) {
+ if (!ddsi_xqos_has_prop(&pp->plist->qos, req[i], false, true)) {
GVERROR ("new_participant("
PGUIDFMT
"): required security property %s missing in Property QoS\n", PGUID(*ppguid), req[i]);
@@ -747,7 +855,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
GVLOGDISC ("new_participant("
PGUIDFMT
"): using security settings from configuration\n", PGUID(*ppguid));
- nn_xqos_mergein_security_config(&pp->plist->qos, &gv->config.omg_security_configuration->cfg);
+ ddsi_xqos_mergein_security_config(&pp->plist->qos, &gv->config.omg_security_configuration->cfg);
ready_to_load_security = true;
}
@@ -774,7 +882,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
if (gv->logconfig.c.mask & DDS_LC_DISCOVERY)
{
GVLOGDISC ("PARTICIPANT "PGUIDFMT" QOS={", PGUID (pp->e.guid));
- nn_log_xqos (DDS_LC_DISCOVERY, &gv->logconfig, &pp->plist->qos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, &pp->plist->qos);
GVLOGDISC ("}\n");
}
@@ -788,6 +896,9 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
pp->m_conn = NULL;
}
+ ddsrt_fibheap_init (&lease_fhdef_pp, &pp->leaseheap_man);
+ ddsrt_atomic_stvoidp (&pp->minl_man, NULL);
+
/* Before we create endpoints -- and may call unref_participant if
things go wrong -- we must initialize all that unref_participant
depends on. */
@@ -796,18 +907,18 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
/* Create built-in endpoints (note: these have no GID, and no group GUID). */
pp->bes = 0;
- pp->prismtech_bes = 0;
subguid.prefix = pp->e.guid.prefix;
memset (&group_guid, 0, sizeof (group_guid));
- /* SPDP writer */
-#define LAST_WR_PARAMS NULL, NULL
+ /* SPDP writer */
/* Note: skip SEDP <=> skip SPDP because of the way ddsi_discovery.c does things
currently. */
if (!(flags & RTPS_PF_NO_BUILTIN_WRITERS))
{
subguid.entityid = to_entityid (NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->spdp_endpoint_xqos, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
+ wrinfo = whc_make_wrinfo (NULL, &gv->spdp_endpoint_xqos);
+ new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->spdp_endpoint_xqos, whc_new(gv, wrinfo), NULL, NULL);
+ whc_free_wrinfo (wrinfo);
/* But we need the as_disc address set for SPDP, because we need to
send it to everyone regardless of the existence of readers. */
force_as_disc_address(gv, &subguid);
@@ -818,34 +929,23 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
entidx_insert_participant_guid (gv->entity_index, pp);
/* SEDP writers: */
+ wrinfo = whc_make_wrinfo (NULL, &gv->builtin_endpoint_xqos_wr);
if (!(flags & RTPS_PF_NO_BUILTIN_WRITERS))
{
subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
+ new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER;
subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
+ new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_WRITER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER;
}
if (gv->config.do_topic_discovery)
{
/* TODO: make this one configurable, we don't want all participants to publish all topics (or even just those that they use themselves) */
subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_TOPIC_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
+ new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_DISC_BUILTIN_ENDPOINT_TOPIC_ANNOUNCER;
}
@@ -853,10 +953,12 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
if (!(flags & RTPS_PF_NO_BUILTIN_WRITERS))
{
subguid.entityid = to_entityid (NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER);
- new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, 1, 1, 1), LAST_WR_PARAMS);
+ new_writer_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_wr, whc_new(gv, wrinfo), NULL, NULL);
pp->bes |= NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER;
}
+ whc_free_wrinfo (wrinfo);
+
/* SPDP, SEDP, PMD readers: */
if (!(flags & RTPS_PF_NO_BUILTIN_READERS))
{
@@ -875,19 +977,6 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
subguid.entityid = to_entityid (NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER);
new_reader_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_rd, NULL, NULL, NULL);
pp->bes |= NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_READER);
- new_reader_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_rd, NULL, NULL, NULL);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_READER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_READER);
- new_reader_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_rd, NULL, NULL, NULL);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_READER;
-
- subguid.entityid = to_entityid (NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_READER);
- new_reader_guid (NULL, &subguid, &group_guid, pp, NULL, &gv->builtin_endpoint_xqos_rd, NULL, NULL, NULL);
- pp->prismtech_bes |= NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_READER;
-
}
#ifdef DDSI_INCLUDE_SECURITY
@@ -897,8 +986,6 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
}
#endif
-#undef LAST_WR_PARAMS
-
/* If the participant doesn't have the full set of builtin writers
it depends on the privileged participant, which must exist, hence
the reference count of the privileged participant is incremented.
@@ -907,8 +994,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
Except when the participant is only locally available. */
if (!(flags & RTPS_PF_ONLY_LOCAL)) {
ddsrt_mutex_lock (&gv->privileged_pp_lock);
- if ((pp->bes & builtin_writers_besmask) != builtin_writers_besmask ||
- (pp->prismtech_bes & prismtech_builtin_writers_besmask) != prismtech_builtin_writers_besmask)
+ if ((pp->bes & builtin_writers_besmask) != builtin_writers_besmask)
{
/* Simply crash when the privileged participant doesn't exist when
it is needed. Its existence is a precondition, and this is not
@@ -956,10 +1042,6 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
pp->spdp_xevent = qxev_spdp (gv->xevents, add_duration_to_mtime (now_mt (), 100 * T_MILLISECOND), &pp->e.guid, NULL);
}
- /* Also write the CM data - this one being transient local, we only
- need to write it once (or when it changes, I suppose) */
- sedp_write_cm_participant (pp, 1);
-
{
nn_mtime_t tsched;
tsched.v = (pp->lease_duration == T_NEVER) ? T_NEVER : 0;
@@ -972,13 +1054,12 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct q_globals *
connect_participant_secure (gv, pp);
}
#endif
-
return ret;
#ifdef DDSI_INCLUDE_SECURITY
not_allowed:
new_pp_err_secprop:
- nn_plist_fini (pp->plist);
+ ddsi_plist_fini (pp->plist);
ddsrt_free (pp->plist);
inverse_uint32_set_fini (&pp->avail_entityids.x);
ddsrt_mutex_destroy (&pp->refc_lock);
@@ -992,7 +1073,7 @@ new_pp_err:
return ret;
}
-dds_return_t new_participant (ddsi_guid_t *p_ppguid, struct q_globals *gv, unsigned flags, const nn_plist_t *plist)
+dds_return_t new_participant (ddsi_guid_t *p_ppguid, struct ddsi_domaingv *gv, unsigned flags, const ddsi_plist_t *plist)
{
union { uint64_t u64; uint32_t u32[2]; } u;
u.u32[0] = gv->ppguid_base.prefix.u[1];
@@ -1005,7 +1086,7 @@ dds_return_t new_participant (ddsi_guid_t *p_ppguid, struct q_globals *gv, unsig
return new_participant_guid (p_ppguid, gv, flags, plist);
}
-void update_participant_plist (struct participant *pp, const nn_plist_t *plist)
+void update_participant_plist (struct participant *pp, const ddsi_plist_t *plist)
{
ddsrt_mutex_lock (&pp->e.lock);
if (update_qos_locked (&pp->e, &pp->plist->qos, &plist->qos, now ()))
@@ -1013,7 +1094,7 @@ void update_participant_plist (struct participant *pp, const nn_plist_t *plist)
ddsrt_mutex_unlock (&pp->e.lock);
}
-static void delete_builtin_endpoint (struct q_globals *gv, const struct ddsi_guid *ppguid, unsigned entityid)
+static void delete_builtin_endpoint (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, unsigned entityid)
{
ddsi_guid_t guid;
guid.prefix = ppguid->prefix;
@@ -1070,13 +1151,6 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
NN_ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER,
NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER,
NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER,
- /* PrismTech ones: */
- NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER,
- NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_READER,
- NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER,
- NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_READER,
- NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER,
- NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_READER
};
ddsi_guid_t stguid;
@@ -1095,7 +1169,7 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
ELOGDISC (pp, "unref_participant("PGUIDFMT" @ %p <- "PGUIDFMT" @ %p) user %"PRId32" builtin %"PRId32"\n",
PGUID (pp->e.guid), (void*)pp, PGUID (stguid), (void*)guid_of_refing_entity, pp->user_refc, pp->builtin_refc);
- if (pp->user_refc == 0 && (pp->bes != 0 || pp->prismtech_bes != 0) && !pp->builtins_deleted)
+ if (pp->user_refc == 0 && pp->bes != 0 && !pp->builtins_deleted)
{
int i;
@@ -1131,9 +1205,6 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
scheduled for deletion when it runs into an empty WHC */
spdp_dispose_unregister (pp);
- /* We don't care, but other implementations might: */
- sedp_write_cm_participant (pp, 0);
-
/* If this happens to be the privileged_pp, clear it */
ddsrt_mutex_lock (&pp->e.gv->privileged_pp_lock);
if (pp == pp->e.gv->privileged_pp)
@@ -1149,8 +1220,7 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
if (!(pp->e.onlylocal))
{
- if ((pp->bes & builtin_writers_besmask) != builtin_writers_besmask ||
- (pp->prismtech_bes & prismtech_builtin_writers_besmask) != prismtech_builtin_writers_besmask)
+ if ((pp->bes & builtin_writers_besmask) != builtin_writers_besmask)
{
/* Participant doesn't have a full complement of built-in
writers, therefore, it relies on gv->privileged_pp, and
@@ -1187,7 +1257,7 @@ static void unref_participant (struct participant *pp, const struct ddsi_guid *g
while longer for it to wakeup. */
ddsi_conn_free (pp->m_conn);
}
- nn_plist_fini (pp->plist);
+ ddsi_plist_fini (pp->plist);
ddsrt_free (pp->plist);
ddsrt_mutex_destroy (&pp->refc_lock);
entity_common_fini (&pp->e);
@@ -1209,7 +1279,7 @@ static void gc_delete_participant (struct gcreq *gcreq)
unref_participant (pp, NULL);
}
-dds_return_t delete_participant (struct q_globals *gv, const struct ddsi_guid *ppguid)
+dds_return_t delete_participant (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid)
{
struct participant *pp;
GVLOGDISC ("delete_participant("PGUIDFMT")\n", PGUID (*ppguid));
@@ -1228,7 +1298,7 @@ dds_return_t delete_participant (struct q_globals *gv, const struct ddsi_guid *p
struct writer *get_builtin_writer (const struct participant *pp, unsigned entityid)
{
ddsi_guid_t bwr_guid;
- unsigned bes_mask = 0, prismtech_bes_mask = 0;
+ uint32_t bes_mask = 0;
if (pp->e.onlylocal) {
return NULL;
@@ -1257,15 +1327,6 @@ struct writer *get_builtin_writer (const struct participant *pp, unsigned entity
case NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER:
bes_mask = NN_BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER;
break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER:
- prismtech_bes_mask = NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_WRITER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER:
- prismtech_bes_mask = NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER:
- prismtech_bes_mask = NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER;
- break;
case NN_ENTITYID_SEDP_BUILTIN_TOPIC_WRITER:
bes_mask = NN_DISC_BUILTIN_ENDPOINT_TOPIC_ANNOUNCER;
break;
@@ -1286,7 +1347,7 @@ struct writer *get_builtin_writer (const struct participant *pp, unsigned entity
return NULL;
}
- if ((pp->bes & bes_mask) || (pp->prismtech_bes & prismtech_bes_mask))
+ if (pp->bes & bes_mask)
{
/* Participant has this SEDP writer => use it. */
bwr_guid.prefix = pp->e.guid.prefix;
@@ -1496,13 +1557,13 @@ static void rebuild_make_locs_nrds(int **locs_nrds, int nreaders, int nlocs, con
*locs_nrds = ln;
}
-static void rebuild_trace_covered(const struct q_globals *gv, int nreaders, int nlocs, const nn_locator_t *locs, const int *locs_nrds, const int8_t *covered)
+static void rebuild_trace_covered(const struct ddsi_domaingv *gv, int nreaders, int nlocs, const nn_locator_t *locs, const int *locs_nrds, const int8_t *covered)
{
int i, j;
for (i = 0; i < nlocs; i++)
{
char buf[DDSI_LOCATORSTRLEN];
- ddsi_locator_to_string(gv, buf, sizeof(buf), &locs[i]);
+ ddsi_locator_to_string(buf, sizeof(buf), &locs[i]);
GVLOGDISC (" loc %2d = %-30s %2d {", i, buf, locs_nrds[i]);
for (j = 0; j < nreaders; j++)
if (covered[j * nlocs + i] >= 0)
@@ -1513,7 +1574,7 @@ static void rebuild_trace_covered(const struct q_globals *gv, int nreaders, int
}
}
-static int rebuild_select(const struct q_globals *gv, int nlocs, const nn_locator_t *locs, const int *locs_nrds, bool prefer_multicast)
+static int rebuild_select(const struct ddsi_domaingv *gv, int nlocs, const nn_locator_t *locs, const int *locs_nrds, bool prefer_multicast)
{
int i, j;
if (nlocs == 0)
@@ -1536,12 +1597,12 @@ static int rebuild_select(const struct q_globals *gv, int nlocs, const nn_locato
return (locs_nrds[j] > 0) ? j : -1;
}
-static void rebuild_add(const struct q_globals *gv, struct addrset *newas, int locidx, int nreaders, int nlocs, const nn_locator_t *locs, const int8_t *covered)
+static void rebuild_add(const struct ddsi_domaingv *gv, struct addrset *newas, int locidx, int nreaders, int nlocs, const nn_locator_t *locs, const int8_t *covered)
{
char str[DDSI_LOCATORSTRLEN];
if (locs[locidx].kind != NN_LOCATOR_KIND_UDPv4MCGEN)
{
- ddsi_locator_to_string(gv, str, sizeof(str), &locs[locidx]);
+ ddsi_locator_to_string(str, sizeof(str), &locs[locidx]);
GVLOGDISC (" simple %s\n", str);
add_to_addrset(gv, newas, &locs[locidx]);
}
@@ -1560,7 +1621,7 @@ static void rebuild_add(const struct q_globals *gv, struct addrset *newas, int l
iph |= 1u << covered[i * nlocs + locidx];
ipn = htonl(iph);
memcpy(l.address + 12, &ipn, 4);
- ddsi_locator_to_string(gv, str, sizeof(str), &l);
+ ddsi_locator_to_string(str, sizeof(str), &l);
GVLOGDISC (" mcgen %s\n", str);
add_to_addrset(gv, newas, &l);
}
@@ -1639,7 +1700,7 @@ static void rebuild_writer_addrset (struct writer *wr)
ELOGDISC (wr, "\n");
}
-void rebuild_or_clear_writer_addrsets (struct q_globals *gv, int rebuild)
+void rebuild_or_clear_writer_addrsets (struct ddsi_domaingv *gv, int rebuild)
{
struct entidx_enum_writer est;
struct writer *wr;
@@ -1683,7 +1744,7 @@ static void free_wr_prd_match (struct wr_prd_match *m)
}
}
-static void free_rd_pwr_match (struct q_globals *gv, struct rd_pwr_match *m)
+static void free_rd_pwr_match (struct ddsi_domaingv *gv, struct rd_pwr_match *m)
{
if (m)
{
@@ -1728,13 +1789,26 @@ static void free_wr_rd_match (struct wr_rd_match *m)
if (m) ddsrt_free (m);
}
-static void proxy_writer_get_alive_state_locked (struct proxy_writer *pwr, struct proxy_writer_alive_state *st)
+static void writer_get_alive_state_locked (struct writer *wr, struct alive_state *st)
+{
+ st->alive = wr->alive;
+ st->vclock = wr->alive_vclock;
+}
+
+static void writer_get_alive_state (struct writer *wr, struct alive_state *st)
+{
+ ddsrt_mutex_lock (&wr->e.lock);
+ writer_get_alive_state_locked (wr, st);
+ ddsrt_mutex_unlock (&wr->e.lock);
+}
+
+static void proxy_writer_get_alive_state_locked (struct proxy_writer *pwr, struct alive_state *st)
{
st->alive = pwr->alive;
st->vclock = pwr->alive_vclock;
}
-static void proxy_writer_get_alive_state (struct proxy_writer *pwr, struct proxy_writer_alive_state *st)
+static void proxy_writer_get_alive_state (struct proxy_writer *pwr, struct alive_state *st)
{
ddsrt_mutex_lock (&pwr->e.lock);
proxy_writer_get_alive_state_locked (pwr, st);
@@ -1798,7 +1872,73 @@ static void writer_drop_local_connection (const struct ddsi_guid *wr_guid, struc
}
}
-static void reader_update_notify_pwr_alive_state (struct reader *rd, const struct proxy_writer *pwr, const struct proxy_writer_alive_state *alive_state)
+static void reader_update_notify_alive_state_invoke_cb (struct reader *rd, uint64_t iid, bool notify, int delta, const struct alive_state *alive_state)
+{
+ /* Liveliness changed events can race each other and can, potentially, be delivered
+ in a different order. */
+ if (notify && rd->status_cb)
+ {
+ status_cb_data_t data;
+ data.handle = iid;
+ data.raw_status_id = (int) DDS_LIVELINESS_CHANGED_STATUS_ID;
+ if (delta < 0) {
+ data.extra = (uint32_t) LIVELINESS_CHANGED_ALIVE_TO_NOT_ALIVE;
+ (rd->status_cb) (rd->status_cb_entity, &data);
+ } else if (delta > 0) {
+ data.extra = (uint32_t) LIVELINESS_CHANGED_NOT_ALIVE_TO_ALIVE;
+ (rd->status_cb) (rd->status_cb_entity, &data);
+ } else {
+ /* Twitch: the resulting (proxy)writer state is unchanged, but there has been
+ a transition to another state and back to the current state. So we'll call
+ the callback twice in this case. */
+ static const enum liveliness_changed_data_extra x[] = {
+ LIVELINESS_CHANGED_NOT_ALIVE_TO_ALIVE,
+ LIVELINESS_CHANGED_ALIVE_TO_NOT_ALIVE
+ };
+ data.extra = (uint32_t) x[alive_state->alive];
+ (rd->status_cb) (rd->status_cb_entity, &data);
+ data.extra = (uint32_t) x[!alive_state->alive];
+ (rd->status_cb) (rd->status_cb_entity, &data);
+ }
+ }
+}
+
+static void reader_update_notify_wr_alive_state (struct reader *rd, const struct writer *wr, const struct alive_state *alive_state)
+{
+ struct rd_wr_match *m;
+ bool notify = false;
+ int delta = 0; /* -1: alive -> not_alive; 0: unchanged; 1: not_alive -> alive */
+ ddsrt_mutex_lock (&rd->e.lock);
+ if ((m = ddsrt_avl_lookup (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid)) != NULL)
+ {
+ if ((int32_t) (alive_state->vclock - m->wr_alive_vclock) > 0)
+ {
+ delta = (int) alive_state->alive - (int) m->wr_alive;
+ notify = true;
+ m->wr_alive = alive_state->alive;
+ m->wr_alive_vclock = alive_state->vclock;
+ }
+ }
+ ddsrt_mutex_unlock (&rd->e.lock);
+
+ if (delta < 0 && rd->rhc)
+ {
+ struct ddsi_writer_info wrinfo;
+ ddsi_make_writer_info (&wrinfo, &wr->e, wr->xqos, NN_STATUSINFO_UNREGISTER);
+ ddsi_rhc_unregister_wr (rd->rhc, &wrinfo);
+ }
+
+ reader_update_notify_alive_state_invoke_cb (rd, wr->e.iid, notify, delta, alive_state);
+}
+
+static void reader_update_notify_wr_alive_state_guid (const struct ddsi_guid *rd_guid, const struct writer *wr, const struct alive_state *alive_state)
+{
+ struct reader *rd;
+ if ((rd = entidx_lookup_reader_guid (wr->e.gv->entity_index, rd_guid)) != NULL)
+ reader_update_notify_wr_alive_state (rd, wr, alive_state);
+}
+
+static void reader_update_notify_pwr_alive_state (struct reader *rd, const struct proxy_writer *pwr, const struct alive_state *alive_state)
{
struct rd_pwr_match *m;
bool notify = false;
@@ -1823,24 +1963,10 @@ static void reader_update_notify_pwr_alive_state (struct reader *rd, const struc
ddsi_rhc_unregister_wr (rd->rhc, &wrinfo);
}
- /* Liveliness changed events can race each other and can, potentially, be delivered
- in a different order. */
- if (notify && rd->status_cb)
- {
- status_cb_data_t data;
- data.handle = pwr->e.iid;
- if (delta == 0)
- data.extra = (uint32_t) LIVELINESS_CHANGED_TWITCH;
- else if (delta < 0)
- data.extra = (uint32_t) LIVELINESS_CHANGED_ALIVE_TO_NOT_ALIVE;
- else
- data.extra = (uint32_t) LIVELINESS_CHANGED_NOT_ALIVE_TO_ALIVE;
- data.raw_status_id = (int) DDS_LIVELINESS_CHANGED_STATUS_ID;
- (rd->status_cb) (rd->status_cb_entity, &data);
- }
+ reader_update_notify_alive_state_invoke_cb (rd, pwr->e.iid, notify, delta, alive_state);
}
-static void reader_update_notify_pwr_alive_state_guid (const struct ddsi_guid *rd_guid, const struct proxy_writer *pwr, const struct proxy_writer_alive_state *alive_state)
+static void reader_update_notify_pwr_alive_state_guid (const struct ddsi_guid *rd_guid, const struct proxy_writer *pwr, const struct alive_state *alive_state)
{
struct reader *rd;
if ((rd = entidx_lookup_reader_guid (pwr->e.gv->entity_index, rd_guid)) != NULL)
@@ -1907,7 +2033,7 @@ static void reader_drop_local_connection (const struct ddsi_guid *rd_guid, const
status_cb_data_t data;
data.handle = wr->e.iid;
data.add = false;
- data.extra = (uint32_t) LIVELINESS_CHANGED_REMOVE_ALIVE;
+ data.extra = (uint32_t) (m->wr_alive ? LIVELINESS_CHANGED_REMOVE_ALIVE : LIVELINESS_CHANGED_REMOVE_NOT_ALIVE);
data.raw_status_id = (int) DDS_LIVELINESS_CHANGED_STATUS_ID;
(rd->status_cb) (rd->status_cb_entity, &data);
@@ -2149,7 +2275,7 @@ static void writer_add_local_connection (struct writer *wr, struct reader *rd)
}
}
-static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr, nn_count_t *init_count, const struct proxy_writer_alive_state *alive_state)
+static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr, nn_count_t *init_count, const struct alive_state *alive_state)
{
struct rd_pwr_match *m = ddsrt_malloc (sizeof (*m));
ddsrt_avl_ipath_t path;
@@ -2223,12 +2349,14 @@ static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr,
}
}
-static void reader_add_local_connection (struct reader *rd, struct writer *wr)
+static void reader_add_local_connection (struct reader *rd, struct writer *wr, const struct alive_state *alive_state)
{
struct rd_wr_match *m = ddsrt_malloc (sizeof (*m));
ddsrt_avl_ipath_t path;
m->wr_guid = wr->e.guid;
+ m->wr_alive = alive_state->alive;
+ m->wr_alive_vclock = alive_state->vclock;
ddsrt_mutex_lock (&rd->e.lock);
@@ -2251,7 +2379,7 @@ static void reader_add_local_connection (struct reader *rd, struct writer *wr)
status_cb_data_t data;
data.handle = wr->e.iid;
data.add = true;
- data.extra = (uint32_t) LIVELINESS_CHANGED_ADD_ALIVE;
+ data.extra = (uint32_t) (alive_state->alive ? LIVELINESS_CHANGED_ADD_ALIVE : LIVELINESS_CHANGED_ADD_NOT_ALIVE);
data.raw_status_id = (int) DDS_SUBSCRIPTION_MATCHED_STATUS_ID;
(rd->status_cb) (rd->status_cb_entity, &data);
@@ -2470,24 +2598,6 @@ static ddsi_entityid_t builtin_entityid_match (ddsi_entityid_t x)
res.u = NN_ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_READER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_WRITER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_PARTICIPANT_READER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_READER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_WRITER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_PUBLISHER_READER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_READER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER;
- break;
- case NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_WRITER:
- res.u = NN_ENTITYID_SEDP_BUILTIN_CM_SUBSCRIBER_READER;
- break;
case NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER:
res.u = NN_ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER;
break;
@@ -2580,7 +2690,7 @@ void connect_writer_with_proxy_reader_secure(struct writer *wr, struct proxy_rea
void connect_reader_with_proxy_writer_secure(struct reader *rd, struct proxy_writer *pwr, nn_mtime_t tnow)
{
nn_count_t init_count;
- struct proxy_writer_alive_state alive_state;
+ struct alive_state alive_state;
/* Initialize the reader's tracking information for the writer liveliness state to something
sensible, but that may be outdated by the time the reader gets added to the writer's list
@@ -2634,7 +2744,7 @@ static void connect_proxy_writer_with_reader (struct proxy_writer *pwr, struct r
const int isb1 = (is_builtin_entityid (rd->e.guid.entityid, NN_VENDORID_ECLIPSE) != 0);
dds_qos_policy_id_t reason;
nn_count_t init_count;
- struct proxy_writer_alive_state alive_state;
+ struct alive_state alive_state;
if (isb0 != isb1)
return;
if (rd->e.onlylocal)
@@ -2699,6 +2809,7 @@ static bool ignore_local_p (const ddsi_guid_t *guid1, const ddsi_guid_t *guid2,
static void connect_writer_with_reader (struct writer *wr, struct reader *rd, nn_mtime_t tnow)
{
dds_qos_policy_id_t reason;
+ struct alive_state alive_state;
(void)tnow;
if (!is_local_orphan_endpoint (&wr->e) && (is_builtin_entityid (wr->e.guid.entityid, NN_VENDORID_ECLIPSE) || is_builtin_entityid (rd->e.guid.entityid, NN_VENDORID_ECLIPSE)))
return;
@@ -2710,8 +2821,17 @@ static void connect_writer_with_reader (struct writer *wr, struct reader *rd, nn
reader_qos_mismatch (rd, reason);
return;
}
- reader_add_local_connection (rd, wr);
+ /* Initialze the reader's tracking information for the writer liveliness state to something
+ sensible, but that may be outdated by the time the reader gets added to the writer's list
+ of matching readers. */
+ writer_get_alive_state (wr, &alive_state);
+ reader_add_local_connection (rd, wr, &alive_state);
writer_add_local_connection (wr, rd);
+
+ /* Once everything is set up: update with the latest state, any updates to the alive state
+ happening in parallel will cause this to become a no-op. */
+ writer_get_alive_state (wr, &alive_state);
+ reader_update_notify_wr_alive_state (rd, wr, &alive_state);
}
static void connect_writer_with_proxy_reader_wrapper (struct entity_common *vwr, struct entity_common *vprd, nn_mtime_t tnow)
@@ -3054,7 +3174,7 @@ static void new_reader_writer_common (const struct ddsrt_log_cfg *logcfg, const
topic ? topic->type_name : "(null)");
}
-static void endpoint_common_init (struct entity_common *e, struct endpoint_common *c, struct q_globals *gv, enum entity_kind kind, const struct ddsi_guid *guid, const struct ddsi_guid *group_guid, struct participant *pp, bool onlylocal)
+static void endpoint_common_init (struct entity_common *e, struct endpoint_common *c, struct ddsi_domaingv *gv, enum entity_kind kind, const struct ddsi_guid *guid, const struct ddsi_guid *group_guid, struct participant *pp, bool onlylocal)
{
entity_common_init (e, gv, guid, NULL, kind, now (), NN_VENDORID_ECLIPSE, pp->e.onlylocal || onlylocal);
c->pp = ref_participant (pp, &e->guid);
@@ -3267,10 +3387,8 @@ unsigned remove_acked_messages (struct writer *wr, struct whc_state *whcst, stru
assert (wr->e.guid.entityid.u != NN_ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER);
ASSERT_MUTEX_HELD (&wr->e.lock);
n = whc_remove_acked_messages (wr->whc, writer_max_drop_seq (wr), whcst, deferred_free_list);
- /* when transitioning from >= low-water to < low-water, signal
- anyone waiting in throttle_writer() */
- if (wr->throttling && whcst->unacked_bytes <= wr->whc_low)
- ddsrt_cond_broadcast (&wr->throttle_cond);
+ /* trigger anyone waiting in throttle_writer() or wait_for_acks() */
+ ddsrt_cond_broadcast (&wr->throttle_cond);
if (wr->retransmitting && whcst->unacked_bytes == 0)
writer_clear_retransmitting (wr);
if (wr->state == WRST_LINGERING && whcst->unacked_bytes == 0)
@@ -3281,6 +3399,91 @@ unsigned remove_acked_messages (struct writer *wr, struct whc_state *whcst, stru
return n;
}
+static void writer_notify_liveliness_change_may_unlock (struct writer *wr)
+{
+ struct alive_state alive_state;
+ writer_get_alive_state_locked (wr, &alive_state);
+
+ struct ddsi_guid rdguid;
+ struct pwr_rd_match *m;
+ memset (&rdguid, 0, sizeof (rdguid));
+ while (wr->alive_vclock == alive_state.vclock &&
+ (m = ddsrt_avl_lookup_succ (&wr_local_readers_treedef, &wr->local_readers, &rdguid)) != NULL)
+ {
+ rdguid = m->rd_guid;
+ ddsrt_mutex_unlock (&wr->e.lock);
+ /* unlocking pwr means alive state may have changed already; we break out of the loop once we
+ detect this but there for the reader in the current iteration, anything is possible */
+ reader_update_notify_wr_alive_state_guid (&rdguid, wr, &alive_state);
+ ddsrt_mutex_lock (&wr->e.lock);
+ }
+}
+
+void writer_set_alive_may_unlock (struct writer *wr, bool notify)
+{
+ /* Caller has wr->e.lock, so we can safely read wr->alive. Updating wr->alive requires
+ also taking wr->c.pp->e.lock because wr->alive <=> (wr->lease in pp's lease heap). */
+ assert (!wr->alive);
+
+ /* check that writer still exists (when deleting it is removed from guid hash) */
+ if (entidx_lookup_writer_guid (wr->e.gv->entity_index, &wr->e.guid) == NULL)
+ {
+ ELOGDISC (wr, "writer_set_alive_may_unlock("PGUIDFMT") - not in entity index, wr deleting\n", PGUID (wr->e.guid));
+ return;
+ }
+
+ ddsrt_mutex_lock (&wr->c.pp->e.lock);
+ wr->alive = true;
+ wr->alive_vclock++;
+ if (wr->xqos->liveliness.lease_duration != T_NEVER)
+ {
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
+ participant_add_wr_lease_locked (wr->c.pp, wr);
+ else if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC)
+ lease_set_expiry (wr->lease, add_duration_to_etime (now_et (), wr->lease->tdur));
+ }
+ ddsrt_mutex_unlock (&wr->c.pp->e.lock);
+
+ if (notify)
+ writer_notify_liveliness_change_may_unlock (wr);
+}
+
+static int writer_set_notalive_locked (struct writer *wr, bool notify)
+{
+ if (!wr->alive)
+ return DDS_RETCODE_PRECONDITION_NOT_MET;
+
+ /* To update wr->alive, both wr->e.lock and wr->c.pp->e.lock
+ should be taken */
+ ddsrt_mutex_lock (&wr->c.pp->e.lock);
+ wr->alive = false;
+ wr->alive_vclock++;
+ if (wr->xqos->liveliness.lease_duration != T_NEVER && wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
+ participant_remove_wr_lease_locked (wr->c.pp, wr);
+ ddsrt_mutex_unlock (&wr->c.pp->e.lock);
+
+ if (notify)
+ {
+ if (wr->status_cb)
+ {
+ status_cb_data_t data;
+ data.handle = wr->e.iid;
+ data.raw_status_id = (int) DDS_LIVELINESS_LOST_STATUS_ID;
+ (wr->status_cb) (wr->status_cb_entity, &data);
+ }
+ writer_notify_liveliness_change_may_unlock (wr);
+ }
+ return DDS_RETCODE_OK;
+}
+
+int writer_set_notalive (struct writer *wr, bool notify)
+{
+ ddsrt_mutex_lock (&wr->e.lock);
+ int ret = writer_set_notalive_locked(wr, notify);
+ ddsrt_mutex_unlock (&wr->e.lock);
+ return ret;
+}
+
static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc *whc, status_cb_t status_cb, void * status_entity)
{
ddsrt_cond_init (&wr->throttle_cond);
@@ -3303,6 +3506,8 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
wr->rexmit_count = 0;
wr->rexmit_lost_count = 0;
wr->force_md5_keyhash = 0;
+ wr->alive = 1;
+ wr->alive_vclock = 0;
wr->status_cb = status_cb;
wr->status_cb_entity = status_entity;
@@ -3310,13 +3515,13 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
/* Copy QoS, merging in defaults */
wr->xqos = ddsrt_malloc (sizeof (*wr->xqos));
- nn_xqos_copy (wr->xqos, xqos);
- nn_xqos_mergein_missing (wr->xqos, &wr->e.gv->default_xqos_wr, ~(uint64_t)0);
+ ddsi_xqos_copy (wr->xqos, xqos);
+ ddsi_xqos_mergein_missing (wr->xqos, &wr->e.gv->default_xqos_wr, ~(uint64_t)0);
assert (wr->xqos->aliased == 0);
set_topic_type_name (wr->xqos, topic);
ELOGDISC (wr, "WRITER "PGUIDFMT" QOS={", PGUID (wr->e.guid));
- nn_log_xqos (DDS_LC_DISCOVERY, &wr->e.gv->logconfig, wr->xqos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &wr->e.gv->logconfig, wr->xqos);
ELOGDISC (wr, "}\n");
assert (wr->xqos->present & QP_RELIABILITY);
@@ -3417,7 +3622,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
}
assert (wr->xqos->present & QP_LIVELINESS);
- if (wr->xqos->liveliness.kind == DDS_LIVELINESS_AUTOMATIC && wr->xqos->liveliness.lease_duration != T_NEVER)
+ if (wr->xqos->liveliness.lease_duration != T_NEVER)
{
wr->lease_duration = ddsrt_malloc (sizeof(*wr->lease_duration));
wr->lease_duration->ldur = wr->xqos->liveliness.lease_duration;
@@ -3497,22 +3702,38 @@ static dds_return_t new_writer_guid (struct writer **wr_out, const struct ddsi_g
if (wr->lease_duration != NULL)
{
assert (wr->lease_duration->ldur != T_NEVER);
- assert (wr->xqos->liveliness.kind == DDS_LIVELINESS_AUTOMATIC);
assert (!is_builtin_entityid (wr->e.guid.entityid, NN_VENDORID_ECLIPSE));
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_AUTOMATIC)
+ {
+ /* Store writer lease duration in participant's heap in case of automatic liveliness */
+ ddsrt_mutex_lock (&pp->e.lock);
+ ddsrt_fibheap_insert (&ldur_fhdef, &pp->ldur_auto_wr, wr->lease_duration);
+ ddsrt_mutex_unlock (&pp->e.lock);
- /* Store writer lease duration in participant's heap in case of automatic liveliness */
- ddsrt_mutex_lock (&pp->e.lock);
- ddsrt_fibheap_insert (&ldur_fhdef, &pp->ldur_auto_wr, wr->lease_duration);
- ddsrt_mutex_unlock (&pp->e.lock);
-
- /* Trigger pmd update */
- (void) resched_xevent_if_earlier (pp->pmd_update_xevent, now_mt ());
+ /* Trigger pmd update */
+ (void) resched_xevent_if_earlier (pp->pmd_update_xevent, now_mt ());
+ }
+ else
+ {
+ nn_etime_t texpire = add_duration_to_etime (now_et (), wr->lease_duration->ldur);
+ wr->lease = lease_new (texpire, wr->lease_duration->ldur, &wr->e);
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
+ {
+ ddsrt_mutex_lock (&pp->e.lock);
+ participant_add_wr_lease_locked (pp, wr);
+ ddsrt_mutex_unlock (&pp->e.lock);
+ }
+ else
+ {
+ lease_register (wr->lease);
+ }
+ }
}
return 0;
}
-dds_return_t new_writer (struct writer **wr_out, struct q_globals *gv, struct ddsi_guid *wrguid, const struct ddsi_guid *group_guid, const struct ddsi_guid *ppguid, const struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg)
+dds_return_t new_writer (struct writer **wr_out, struct ddsi_domaingv *gv, struct ddsi_guid *wrguid, const struct ddsi_guid *group_guid, const struct ddsi_guid *ppguid, const struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg)
{
struct participant *pp;
dds_return_t rc;
@@ -3534,7 +3755,7 @@ dds_return_t new_writer (struct writer **wr_out, struct q_globals *gv, struct dd
return new_writer_guid (wr_out, wrguid, group_guid, pp, topic, xqos, whc, status_cb, status_cb_arg);
}
-struct local_orphan_writer *new_local_orphan_writer (struct q_globals *gv, ddsi_entityid_t entityid, struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc *whc)
+struct local_orphan_writer *new_local_orphan_writer (struct ddsi_domaingv *gv, ddsi_entityid_t entityid, struct ddsi_sertopic *topic, const struct dds_qos *xqos, struct whc *whc)
{
ddsi_guid_t guid;
struct local_orphan_writer *lowr;
@@ -3603,23 +3824,23 @@ static void gc_delete_writer (struct gcreq *gcreq)
{
assert (wr->lease_duration->ldur == DDS_DURATION_INVALID);
ddsrt_free (wr->lease_duration);
+ if (wr->xqos->liveliness.kind != DDS_LIVELINESS_AUTOMATIC)
+ lease_free (wr->lease);
}
/* Do last gasp on SEDP and free writer. */
if (!is_builtin_entityid (wr->e.guid.entityid, NN_VENDORID_ECLIPSE))
sedp_dispose_unregister_writer (wr);
- if (wr->status_cb)
- {
- (wr->status_cb) (wr->status_cb_entity, NULL);
- }
-
whc_free (wr->whc);
+ if (wr->status_cb)
+ (wr->status_cb) (wr->status_cb_entity, NULL);
+
#ifdef DDSI_INCLUDE_SSM
if (wr->ssm_as)
unref_addrset (wr->ssm_as);
#endif
unref_addrset (wr->as); /* must remain until readers gone (rebuilding of addrset) */
- nn_xqos_fini (wr->xqos);
+ ddsi_xqos_fini (wr->xqos);
ddsrt_free (wr->xqos);
local_reader_ary_fini (&wr->rdary);
ddsrt_cond_destroy (&wr->throttle_cond);
@@ -3660,7 +3881,7 @@ static void writer_set_state (struct writer *wr, enum writer_state newstate)
wr->state = newstate;
}
-dds_return_t unblock_throttled_writer (struct q_globals *gv, const struct ddsi_guid *guid)
+dds_return_t unblock_throttled_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid)
{
struct writer *wr;
assert (is_writer_entityid (guid->entityid));
@@ -3676,6 +3897,20 @@ dds_return_t unblock_throttled_writer (struct q_globals *gv, const struct ddsi_g
return 0;
}
+dds_return_t writer_wait_for_acks (struct writer *wr, dds_time_t abstimeout)
+{
+ dds_return_t rc;
+ seqno_t ref_seq;
+ ddsrt_mutex_lock (&wr->e.lock);
+ ref_seq = wr->seq;
+ while (wr->state == WRST_OPERATIONAL && ref_seq > writer_max_drop_seq (wr))
+ if (!ddsrt_cond_waituntil (&wr->throttle_cond, &wr->e.lock, abstimeout))
+ break;
+ rc = (ref_seq <= writer_max_drop_seq (wr)) ? DDS_RETCODE_OK : DDS_RETCODE_TIMEOUT;
+ ddsrt_mutex_unlock (&wr->e.lock);
+ return rc;
+}
+
dds_return_t delete_writer_nolinger_locked (struct writer *wr)
{
ELOGDISC (wr, "delete_writer_nolinger(guid "PGUIDFMT") ...\n", PGUID (wr->e.guid));
@@ -3685,17 +3920,27 @@ dds_return_t delete_writer_nolinger_locked (struct writer *wr)
entidx_remove_writer_guid (wr->e.gv->entity_index, wr);
writer_set_state (wr, WRST_DELETING);
if (wr->lease_duration != NULL) {
- ddsrt_mutex_lock (&wr->c.pp->e.lock);
- ddsrt_fibheap_delete (&ldur_fhdef, &wr->c.pp->ldur_auto_wr, wr->lease_duration);
- ddsrt_mutex_unlock (&wr->c.pp->e.lock);
wr->lease_duration->ldur = DDS_DURATION_INVALID;
- resched_xevent_if_earlier (wr->c.pp->pmd_update_xevent, now_mt ());
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_AUTOMATIC)
+ {
+ ddsrt_mutex_lock (&wr->c.pp->e.lock);
+ ddsrt_fibheap_delete (&ldur_fhdef, &wr->c.pp->ldur_auto_wr, wr->lease_duration);
+ ddsrt_mutex_unlock (&wr->c.pp->e.lock);
+ resched_xevent_if_earlier (wr->c.pp->pmd_update_xevent, now_mt ());
+ }
+ else
+ {
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC)
+ lease_unregister (wr->lease);
+ if (writer_set_notalive_locked (wr, false) != DDS_RETCODE_OK)
+ ELOGDISC (wr, "writer_set_notalive failed for "PGUIDFMT"\n", PGUID (wr->e.guid));
+ }
}
gcreq_writer (wr);
return 0;
}
-dds_return_t delete_writer_nolinger (struct q_globals *gv, const struct ddsi_guid *guid)
+dds_return_t delete_writer_nolinger (struct ddsi_domaingv *gv, const struct ddsi_guid *guid)
{
struct writer *wr;
/* We take no care to ensure application writers are not deleted
@@ -3725,7 +3970,7 @@ void delete_local_orphan_writer (struct local_orphan_writer *lowr)
ddsrt_mutex_unlock (&lowr->wr.e.lock);
}
-dds_return_t delete_writer (struct q_globals *gv, const struct ddsi_guid *guid)
+dds_return_t delete_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid)
{
struct writer *wr;
struct whc_state whcst;
@@ -3766,7 +4011,7 @@ dds_return_t delete_writer (struct q_globals *gv, const struct ddsi_guid *guid)
/* READER ----------------------------------------------------------- */
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
-static struct addrset *get_as_from_mapping (const struct q_globals *gv, const char *partition, const char *topic)
+static struct addrset *get_as_from_mapping (const struct ddsi_domaingv *gv, const char *partition, const char *topic)
{
struct config_partitionmapping_listelem *pm;
struct addrset *as = new_addrset ();
@@ -3782,13 +4027,13 @@ static struct addrset *get_as_from_mapping (const struct q_globals *gv, const ch
struct join_leave_mcast_helper_arg {
ddsi_tran_conn_t conn;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
};
static void join_mcast_helper (const nn_locator_t *n, void *varg)
{
struct join_leave_mcast_helper_arg *arg = varg;
- struct q_globals *gv = arg->gv;
+ struct ddsi_domaingv *gv = arg->gv;
if (ddsi_is_mcaddr (gv, n))
{
if (n->kind != NN_LOCATOR_KIND_UDPv4MCGEN)
@@ -3830,7 +4075,7 @@ static void join_mcast_helper (const nn_locator_t *n, void *varg)
static void leave_mcast_helper (const nn_locator_t *n, void *varg)
{
struct join_leave_mcast_helper_arg *arg = varg;
- struct q_globals *gv = arg->gv;
+ struct ddsi_domaingv *gv = arg->gv;
if (ddsi_is_mcaddr (gv, n))
{
if (n->kind != NN_LOCATOR_KIND_UDPv4MCGEN)
@@ -3902,15 +4147,15 @@ static dds_return_t new_reader_guid
/* Copy QoS, merging in defaults */
rd->xqos = ddsrt_malloc (sizeof (*rd->xqos));
- nn_xqos_copy (rd->xqos, xqos);
- nn_xqos_mergein_missing (rd->xqos, &pp->e.gv->default_xqos_rd, ~(uint64_t)0);
+ ddsi_xqos_copy (rd->xqos, xqos);
+ ddsi_xqos_mergein_missing (rd->xqos, &pp->e.gv->default_xqos_rd, ~(uint64_t)0);
assert (rd->xqos->aliased == 0);
set_topic_type_name (rd->xqos, topic);
if (rd->e.gv->logconfig.c.mask & DDS_LC_DISCOVERY)
{
ELOGDISC (rd, "READER "PGUIDFMT" QOS={", PGUID (rd->e.guid));
- nn_log_xqos (DDS_LC_DISCOVERY, &rd->e.gv->logconfig, rd->xqos);
+ ddsi_xqos_log (DDS_LC_DISCOVERY, &rd->e.gv->logconfig, rd->xqos);
ELOGDISC (rd, "}\n");
}
assert (rd->xqos->present & QP_RELIABILITY);
@@ -4017,7 +4262,7 @@ static dds_return_t new_reader_guid
dds_return_t new_reader
(
struct reader **rd_out,
- struct q_globals *gv,
+ struct ddsi_domaingv *gv,
struct ddsi_guid *rdguid,
const struct ddsi_guid *group_guid,
const struct ddsi_guid *ppguid,
@@ -4086,7 +4331,7 @@ static void gc_delete_reader (struct gcreq *gcreq)
}
ddsi_sertopic_unref ((struct ddsi_sertopic *) rd->topic);
- nn_xqos_fini (rd->xqos);
+ ddsi_xqos_fini (rd->xqos);
ddsrt_free (rd->xqos);
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
unref_addrset (rd->as);
@@ -4096,7 +4341,7 @@ static void gc_delete_reader (struct gcreq *gcreq)
ddsrt_free (rd);
}
-dds_return_t delete_reader (struct q_globals *gv, const struct ddsi_guid *guid)
+dds_return_t delete_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *guid)
{
struct reader *rd;
assert (!is_writer_entityid (guid->entityid));
@@ -4121,21 +4366,13 @@ void update_reader_qos (struct reader *rd, const dds_qos_t *xqos)
}
/* PROXY-PARTICIPANT ------------------------------------------------ */
-const ddsrt_fibheap_def_t lease_fhdef_proxypp = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct lease, pp_heapnode), compare_lease_tdur);
-
-static void gc_proxy_participant_lease (struct gcreq *gcreq)
-{
- lease_free (gcreq->arg);
- gcreq_free (gcreq);
-}
-
static void proxy_participant_replace_minl (struct proxy_participant *proxypp, bool manbypp, struct lease *lnew)
{
/* By loading/storing the pointer atomically, we ensure we always
read a valid (or once valid) lease. By delaying freeing the lease
through the garbage collector, we ensure whatever lease update
occurs in parallel completes before the memory is released. */
- struct gcreq *gcreq = gcreq_new (proxypp->e.gv->gcreq_queue, gc_proxy_participant_lease);
+ struct gcreq *gcreq = gcreq_new (proxypp->e.gv->gcreq_queue, gc_participant_lease);
struct lease *lease_old = ddsrt_atomic_ldvoidp (manbypp ? &proxypp->minl_man : &proxypp->minl_auto);
lease_unregister (lease_old); /* ensures lease will not expire while it is replaced */
gcreq->arg = lease_old;
@@ -4148,11 +4385,11 @@ void proxy_participant_reassign_lease (struct proxy_participant *proxypp, struct
ddsrt_mutex_lock (&proxypp->e.lock);
if (proxypp->owns_lease)
{
- struct lease *minl = ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_auto);
- ddsrt_fibheap_delete (&lease_fhdef_proxypp, &proxypp->leaseheap_auto, proxypp->lease);
+ struct lease *minl = ddsrt_fibheap_min (&lease_fhdef_pp, &proxypp->leaseheap_auto);
+ ddsrt_fibheap_delete (&lease_fhdef_pp, &proxypp->leaseheap_auto, proxypp->lease);
if (minl == proxypp->lease)
{
- if ((minl = ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_auto)) != NULL)
+ if ((minl = ddsrt_fibheap_min (&lease_fhdef_pp, &proxypp->leaseheap_auto)) != NULL)
{
dds_duration_t trem = minl->tdur - proxypp->lease->tdur;
assert (trem >= 0);
@@ -4179,7 +4416,7 @@ void proxy_participant_reassign_lease (struct proxy_participant *proxypp, struct
The lease_unregister call ensures the lease will never expire
while we are messing with it. */
- struct gcreq *gcreq = gcreq_new (proxypp->e.gv->gcreq_queue, gc_proxy_participant_lease);
+ struct gcreq *gcreq = gcreq_new (proxypp->e.gv->gcreq_queue, gc_participant_lease);
lease_unregister (proxypp->lease);
gcreq->arg = proxypp->lease;
gcreq_enqueue (gcreq);
@@ -4197,7 +4434,7 @@ struct bestab {
};
static void create_proxy_builtin_endpoints(
- struct q_globals *gv,
+ struct ddsi_domaingv *gv,
const struct bestab *bestab,
int nbes,
const struct ddsi_guid *ppguid,
@@ -4206,16 +4443,16 @@ static void create_proxy_builtin_endpoints(
dds_qos_t *xqos_wr,
dds_qos_t *xqos_rd)
{
- nn_plist_t plist_rd, plist_wr;
+ ddsi_plist_t plist_rd, plist_wr;
int i;
/* Note: no entity name or group GUID supplied, but that shouldn't
* matter, as these are internal to DDSI and don't use group
* coherency
*/
- nn_plist_init_empty (&plist_wr);
- nn_plist_init_empty (&plist_rd);
- nn_xqos_copy (&plist_wr.qos, xqos_wr);
- nn_xqos_copy (&plist_rd.qos, xqos_rd);
+ ddsi_plist_init_empty (&plist_wr);
+ ddsi_plist_init_empty (&plist_rd);
+ ddsi_xqos_copy (&plist_wr.qos, xqos_wr);
+ ddsi_xqos_copy (&plist_rd.qos, xqos_rd);
for (i = 0; i < nbes; i++)
{
const struct bestab *te = &bestab[i];
@@ -4240,13 +4477,13 @@ static void create_proxy_builtin_endpoints(
}
}
}
- nn_plist_fini (&plist_wr);
- nn_plist_fini (&plist_rd);
+ ddsi_plist_fini (&plist_wr);
+ ddsi_plist_fini (&plist_rd);
}
static void add_proxy_builtin_endpoints(
- struct q_globals *gv,
+ struct ddsi_domaingv *gv,
const struct ddsi_guid *ppguid,
struct proxy_participant *proxypp,
nn_wctime_t timestamp)
@@ -4273,12 +4510,6 @@ static void add_proxy_builtin_endpoints(
LTE (PARTICIPANT_MESSAGE_DATA_READER, P2P, PARTICIPANT_MESSAGE_READER),
TE (DISC_, TOPIC_ANNOUNCER, SEDP, TOPIC_WRITER),
TE (DISC_, TOPIC_DETECTOR, SEDP, TOPIC_READER),
- PT_TE (DISC_, CM_PARTICIPANT_READER, SEDP, CM_PARTICIPANT_READER),
- PT_TE (DISC_, CM_PARTICIPANT_WRITER, SEDP, CM_PARTICIPANT_WRITER),
- PT_TE (DISC_, CM_PUBLISHER_READER, SEDP, CM_PUBLISHER_READER),
- PT_TE (DISC_, CM_PUBLISHER_WRITER, SEDP, CM_PUBLISHER_WRITER),
- PT_TE (DISC_, CM_SUBSCRIBER_READER, SEDP, CM_SUBSCRIBER_READER),
- PT_TE (DISC_, CM_SUBSCRIBER_WRITER, SEDP, CM_SUBSCRIBER_WRITER)
};
create_proxy_builtin_endpoints(gv,
bestab_default,
@@ -4339,17 +4570,6 @@ static void add_proxy_builtin_endpoints(
&gv->builtin_stateless_xqos_rd);
#endif
- /* Register lease for auto liveliness, but be careful not to accidentally re-register
- DDSI2's lease, as we may have become dependent on DDSI2 any time after
- entidx_insert_proxy_participant_guid even if privileged_pp_guid was NULL originally */
- ddsrt_mutex_lock (&proxypp->e.lock);
-
- if (proxypp->owns_lease)
- lease_register (ddsrt_atomic_ldvoidp (&proxypp->minl_auto));
-
- builtintopic_write (gv->builtin_topic_interface, &proxypp->e, timestamp, true);
- ddsrt_mutex_unlock (&proxypp->e.lock);
-
#undef PT_TE
#undef TE
#undef LTE
@@ -4365,9 +4585,9 @@ static void proxy_participant_add_pwr_lease_locked (struct proxy_participant * p
assert (pwr->lease != NULL);
manbypp = (pwr->c.xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT);
lh = manbypp ? &proxypp->leaseheap_man : &proxypp->leaseheap_auto;
- minl_prev = ddsrt_fibheap_min (&lease_fhdef_proxypp, lh);
- ddsrt_fibheap_insert (&lease_fhdef_proxypp, lh, pwr->lease);
- minl_new = ddsrt_fibheap_min (&lease_fhdef_proxypp, lh);
+ minl_prev = ddsrt_fibheap_min (&lease_fhdef_pp, lh);
+ ddsrt_fibheap_insert (&lease_fhdef_pp, lh, pwr->lease);
+ minl_new = ddsrt_fibheap_min (&lease_fhdef_pp, lh);
/* if inserted lease is new shortest lease */
if (proxypp->owns_lease && minl_prev != minl_new)
{
@@ -4396,12 +4616,12 @@ static void proxy_participant_remove_pwr_lease_locked (struct proxy_participant
assert (pwr->lease != NULL);
manbypp = (pwr->c.xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT);
lh = manbypp ? &proxypp->leaseheap_man : &proxypp->leaseheap_auto;
- minl = ddsrt_fibheap_min (&lease_fhdef_proxypp, lh);
- ddsrt_fibheap_delete (&lease_fhdef_proxypp, lh, pwr->lease);
+ minl = ddsrt_fibheap_min (&lease_fhdef_pp, lh);
+ ddsrt_fibheap_delete (&lease_fhdef_pp, lh, pwr->lease);
/* if pwr with min lease is removed: update proxypp lease to use new minimal duration */
if (proxypp->owns_lease && pwr->lease == minl)
{
- if ((minl = ddsrt_fibheap_min (&lease_fhdef_proxypp, lh)) != NULL)
+ if ((minl = ddsrt_fibheap_min (&lease_fhdef_pp, lh)) != NULL)
{
dds_duration_t trem = minl->tdur - pwr->lease->tdur;
assert (trem >= 0);
@@ -4421,7 +4641,7 @@ static void proxy_participant_remove_pwr_lease_locked (struct proxy_participant
void handshake_end_cb
(
- struct q_globals const * const gv,
+ struct ddsi_domaingv const * const gv,
struct ddsi_handshake *handshake,
const struct ddsi_guid *lpguid,
const struct ddsi_guid *ppguid,
@@ -4492,7 +4712,7 @@ void handshake_end_cb
}
}
-static int proxy_participant_check_security_info(struct q_globals *gv, struct proxy_participant *proxypp)
+static int proxy_participant_check_security_info(struct ddsi_domaingv *gv, struct proxy_participant *proxypp)
{
int r = 0;
struct participant *pp;
@@ -4510,7 +4730,7 @@ static int proxy_participant_check_security_info(struct q_globals *gv, struct pr
}
-static void proxy_participant_create_handshakes(struct q_globals *gv, struct proxy_participant *proxypp)
+static void proxy_participant_create_handshakes(struct ddsi_domaingv *gv, struct proxy_participant *proxypp)
{
struct participant *pp;
struct entidx_enum_participant est;
@@ -4527,56 +4747,43 @@ static void proxy_participant_create_handshakes(struct q_globals *gv, struct pro
#endif
-#ifdef DDSI_INCLUDE_SECURITY
-
static void free_proxy_participant(struct proxy_participant *proxypp)
{
- q_omg_security_deregister_remote_participant(proxypp);
- unref_addrset (proxypp->as_default);
- unref_addrset (proxypp->as_meta);
- nn_plist_fini (proxypp->plist);
- ddsrt_free (proxypp->plist);
if (proxypp->owns_lease)
{
struct lease * minl_auto = ddsrt_atomic_ldvoidp (&proxypp->minl_auto);
- ddsrt_fibheap_delete (&lease_fhdef_proxypp, &proxypp->leaseheap_auto, proxypp->lease);
- assert (ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_auto) == NULL);
- assert (ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_man) == NULL);
+ ddsrt_fibheap_delete (&lease_fhdef_pp, &proxypp->leaseheap_auto, proxypp->lease);
+ assert (ddsrt_fibheap_min (&lease_fhdef_pp, &proxypp->leaseheap_auto) == NULL);
+ assert (ddsrt_fibheap_min (&lease_fhdef_pp, &proxypp->leaseheap_man) == NULL);
assert (ddsrt_atomic_ldvoidp (&proxypp->minl_man) == NULL);
assert (!compare_guid (&minl_auto->entity->guid, &proxypp->e.guid));
+ /* if the lease hasn't been registered yet (which is the case when
+ new_proxy_participant calls this, it is marked as such and calling
+ lease_unregister is ok */
lease_unregister (minl_auto);
lease_free (minl_auto);
lease_free (proxypp->lease);
}
+#ifdef DDSI_INCLUDE_SECURITY
+ q_omg_security_deregister_remote_participant(proxypp);
+#endif
+ unref_addrset (proxypp->as_default);
+ unref_addrset (proxypp->as_meta);
+ ddsi_plist_fini (proxypp->plist);
+ ddsrt_free (proxypp->plist);
entity_common_fini (&proxypp->e);
ddsrt_free (proxypp);
}
-#endif
-void new_proxy_participant
-(
- struct q_globals *gv,
- const struct ddsi_guid *ppguid,
- unsigned bes,
- unsigned prismtech_bes,
- const struct ddsi_guid *privileged_pp_guid,
- struct addrset *as_default,
- struct addrset *as_meta,
- const nn_plist_t *plist,
- dds_duration_t tlease_dur,
- nn_vendorid_t vendor,
- unsigned custom_flags,
- nn_wctime_t timestamp,
- seqno_t seq
-)
+void new_proxy_participant (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, uint32_t bes, const struct ddsi_guid *privileged_pp_guid, struct addrset *as_default, struct addrset *as_meta, const ddsi_plist_t *plist, dds_duration_t tlease_dur, nn_vendorid_t vendor, unsigned custom_flags, nn_wctime_t timestamp, seqno_t seq)
{
/* No locking => iff all participants use unique guids, and sedp
runs on a single thread, it can't go wrong. FIXME, maybe? The
same holds for the other functions for creating entities. */
struct proxy_participant *proxypp;
-#ifdef DDSI_INCLUDE_SECURITY
- bool secure = false;
-#endif
+ const bool is_secure = ((bes & NN_DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_ANNOUNCER) != 0);
+ assert (!is_secure || (plist->present & PP_IDENTITY_TOKEN));
+ assert (is_secure || (bes & ~NN_BES_MASK_NON_SECURITY) == 0);
assert (ppguid->entityid.u == NN_ENTITYID_PARTICIPANT);
assert (entidx_lookup_proxy_participant_guid (gv->entity_index, ppguid) == NULL);
@@ -4592,7 +4799,6 @@ void new_proxy_participant
proxypp->deleting = 0;
proxypp->vendor = vendor;
proxypp->bes = bes;
- proxypp->prismtech_bes = prismtech_bes;
proxypp->seq = seq;
if (privileged_pp_guid) {
proxypp->privileged_pp_guid = *privileged_pp_guid;
@@ -4611,13 +4817,15 @@ void new_proxy_participant
proxypp->minimal_bes_mode = 1;
else
proxypp->minimal_bes_mode = 0;
+ proxypp->implicitly_created = ((custom_flags & CF_IMPLICITLY_CREATED_PROXYPP) != 0);
+ proxypp->proxypp_have_spdp = ((custom_flags & CF_PROXYPP_NO_SPDP) == 0);
{
struct proxy_participant *privpp;
privpp = entidx_lookup_proxy_participant_guid (gv->entity_index, &proxypp->privileged_pp_guid);
- ddsrt_fibheap_init (&lease_fhdef_proxypp, &proxypp->leaseheap_auto);
- ddsrt_fibheap_init (&lease_fhdef_proxypp, &proxypp->leaseheap_man);
+ ddsrt_fibheap_init (&lease_fhdef_pp, &proxypp->leaseheap_auto);
+ ddsrt_fibheap_init (&lease_fhdef_pp, &proxypp->leaseheap_man);
ddsrt_atomic_stvoidp (&proxypp->minl_man, NULL);
if (privpp != NULL && privpp->is_ddsi2_pp)
@@ -4643,7 +4851,7 @@ void new_proxy_participant
/* Add the proxypp lease to heap so that monitoring liveliness will include this lease
and uses the shortest duration for proxypp and all its pwr's (with automatic liveliness) */
- ddsrt_fibheap_insert (&lease_fhdef_proxypp, &proxypp->leaseheap_auto, proxypp->lease);
+ ddsrt_fibheap_insert (&lease_fhdef_pp, &proxypp->leaseheap_auto, proxypp->lease);
/* Set the shortest lease for auto liveliness: clone proxypp's lease and store the clone in
proxypp->minl_auto. As there are no pwr's at this point, the proxy pp's lease is the
@@ -4657,125 +4865,73 @@ void new_proxy_participant
proxypp->as_default = as_default;
proxypp->as_meta = as_meta;
proxypp->endpoints = NULL;
- proxypp->plist = nn_plist_dup (plist);
- nn_xqos_mergein_missing (&proxypp->plist->qos, &gv->default_plist_pp.qos, ~(uint64_t)0);
+ proxypp->plist = ddsi_plist_dup (plist);
+ ddsi_xqos_mergein_missing (&proxypp->plist->qos, &gv->default_plist_pp.qos, ~(uint64_t)0);
ddsrt_avl_init (&proxypp_groups_treedef, &proxypp->groups);
#ifdef DDSI_INCLUDE_SECURITY
proxypp->remote_identity_handle = 0;
proxypp->sec_attr = NULL;
- secure = ((bes & NN_DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_ANNOUNCER) != 0);
- if (!secure)
+ set_proxy_participant_security_info (proxypp, plist);
+ if (is_secure)
{
- /* Make sure we don't create any security builtin endpoint when it's considered unsecure. */
- proxypp->bes &= BES_MASK_NON_SECURITY;
+ q_omg_security_init_remote_participant (proxypp);
+ /* check if the proxy participant has a match with a local participant */
+ if (!proxy_participant_check_security_info (gv, proxypp))
+ {
+ GVWARNING ("Remote secure participant "PGUIDFMT" not allowed\n", PGUID (*ppguid));
+ free_proxy_participant (proxypp);
+ return;
+ }
}
- set_proxy_participant_security_info(proxypp, plist);
#endif
- if (custom_flags & CF_INC_KERNEL_SEQUENCE_NUMBERS)
- proxypp->kernel_sequence_numbers = 1;
- else
- proxypp->kernel_sequence_numbers = 0;
- if (custom_flags & CF_IMPLICITLY_CREATED_PROXYPP)
- proxypp->implicitly_created = 1;
- else
- proxypp->implicitly_created = 0;
-
- if (custom_flags & CF_PROXYPP_NO_SPDP)
- proxypp->proxypp_have_spdp = 0;
- else
- proxypp->proxypp_have_spdp = 1;
- /* Non-PrismTech doesn't implement the PT extensions and therefore won't generate
- a CMParticipant; if a PT peer does not implement a CMParticipant writer, then it
- presumably also is a handicapped implementation (perhaps simply an old one) */
- if (!vendor_is_eclipse_or_prismtech(proxypp->vendor) ||
- (proxypp->bes != 0 && !(proxypp->prismtech_bes & NN_DISC_BUILTIN_ENDPOINT_CM_PARTICIPANT_WRITER)))
- proxypp->proxypp_have_cm = 1;
- else
- proxypp->proxypp_have_cm = 0;
-
-#ifdef DDSI_INCLUDE_SECURITY
- if (secure)
- {
- /* Secure participant detected: start handshake. */
- if ((plist->present & PP_IDENTITY_TOKEN))
- {
- /* initialize the security attributes associated with the proxy participant */
- q_omg_security_init_remote_participant(proxypp);
-
- /* check if the proxy participant has a match with a local participant */
- if (proxy_participant_check_security_info(gv, proxypp))
- {
- /* Proxy participant must be in the hash tables for new_proxy_{writer,reader} to work */
- entidx_insert_proxy_participant_guid (gv->entity_index, proxypp);
- /* Create builtin endpoints, of which a few are used in the handshake. */
- add_proxy_builtin_endpoints(gv, ppguid, proxypp, timestamp);
- /* create authentication handshakes for each local secure participant */
- proxy_participant_create_handshakes(gv, proxypp);
- }
- else
- {
- DDS_CWARNING(&gv->logconfig, "Remote secure participant "PGUIDFMT" not allowed\n", PGUID (*ppguid));
- free_proxy_participant(proxypp);
- }
- }
- else
- {
- /* Do not communicate with un-secure participants. */
- DDS_CWARNING(&gv->logconfig, "Don't communicate with secure participant "PGUIDFMT" which does not provide an identity token\n", PGUID (*ppguid));
- free_proxy_participant(proxypp);
- }
- }
- else
- {
- /* Remote is un-secure. Try the discovery anyway. Maybe there's a local secure
- * participant that allowed communication with remote non-secure ones
- */
- entidx_insert_proxy_participant_guid (gv->entity_index, proxypp);
- add_proxy_builtin_endpoints(gv, ppguid, proxypp, timestamp);
- ELOGDISC (proxypp, "Un-secure participant "PGUIDFMT" tries to connect.\n", PGUID (*ppguid));
- }
-#else
/* Proxy participant must be in the hash tables for new_proxy_{writer,reader} to work */
entidx_insert_proxy_participant_guid (gv->entity_index, proxypp);
add_proxy_builtin_endpoints(gv, ppguid, proxypp, timestamp);
+
+ /* write DCPSParticipant topic before the lease can expire */
+ builtintopic_write (gv->builtin_topic_interface, &proxypp->e, timestamp, true);
+
+ /* Register lease for auto liveliness, but be careful not to accidentally re-register
+ DDSI2's lease, as we may have become dependent on DDSI2 any time after
+ entidx_insert_proxy_participant_guid even if privileged_pp_guid was NULL originally */
+ ddsrt_mutex_lock (&proxypp->e.lock);
+ if (proxypp->owns_lease)
+ lease_register (ddsrt_atomic_ldvoidp (&proxypp->minl_auto));
+ ddsrt_mutex_unlock (&proxypp->e.lock);
+
+#ifdef DDSI_INCLUDE_SECURITY
+ if (is_secure)
+ proxy_participant_create_handshakes (gv, proxypp);
#endif
}
-int update_proxy_participant_plist_locked (struct proxy_participant *proxypp, seqno_t seq, const struct nn_plist *datap, enum update_proxy_participant_source source, nn_wctime_t timestamp)
+int update_proxy_participant_plist_locked (struct proxy_participant *proxypp, seqno_t seq, const struct ddsi_plist *datap, nn_wctime_t timestamp)
{
- nn_plist_t *new_plist = ddsrt_malloc (sizeof (*new_plist));
- nn_plist_init_empty (new_plist);
- nn_plist_mergein_missing (new_plist, datap, PP_PRISMTECH_NODE_NAME | PP_PRISMTECH_EXEC_NAME | PP_PRISMTECH_PROCESS_ID | PP_ENTITY_NAME, QP_USER_DATA);
- nn_plist_mergein_missing (new_plist, &proxypp->e.gv->default_plist_pp, ~(uint64_t)0, ~(uint64_t)0);
-
if (seq > proxypp->seq)
+ {
proxypp->seq = seq;
- switch (source)
- {
- case UPD_PROXYPP_SPDP:
- (void) update_qos_locked (&proxypp->e, &proxypp->plist->qos, &new_plist->qos, timestamp);
- nn_plist_fini (new_plist);
- ddsrt_free (new_plist);
- proxypp->proxypp_have_spdp = 1;
- break;
-
- case UPD_PROXYPP_CM:
- nn_plist_fini (proxypp->plist);
- ddsrt_free (proxypp->plist);
- proxypp->plist = new_plist;
- proxypp->proxypp_have_cm = 1;
- break;
+ struct ddsi_domaingv * const gv = proxypp->e.gv;
+ const uint64_t pmask = PP_ENTITY_NAME;
+ const uint64_t qmask = QP_USER_DATA;
+ ddsi_plist_t *new_plist = ddsrt_malloc (sizeof (*new_plist));
+ ddsi_plist_init_empty (new_plist);
+ ddsi_plist_mergein_missing (new_plist, datap, pmask, qmask);
+ ddsi_plist_mergein_missing (new_plist, &gv->default_plist_pp, ~(uint64_t)0, ~(uint64_t)0);
+ (void) update_qos_locked (&proxypp->e, &proxypp->plist->qos, &new_plist->qos, timestamp);
+ ddsi_plist_fini (new_plist);
+ ddsrt_free (new_plist);
+ proxypp->proxypp_have_spdp = 1;
}
return 0;
}
-int update_proxy_participant_plist (struct proxy_participant *proxypp, seqno_t seq, const struct nn_plist *datap, enum update_proxy_participant_source source, nn_wctime_t timestamp)
+int update_proxy_participant_plist (struct proxy_participant *proxypp, seqno_t seq, const struct ddsi_plist *datap, nn_wctime_t timestamp)
{
ddsrt_mutex_lock (&proxypp->e.lock);
- update_proxy_participant_plist_locked (proxypp, seq, datap, source, timestamp);
+ update_proxy_participant_plist_locked (proxypp, seq, datap, timestamp);
ddsrt_mutex_unlock (&proxypp->e.lock);
return 0;
}
@@ -4823,32 +4979,13 @@ static void unref_proxy_participant (struct proxy_participant *proxypp, struct p
if (refc == 0)
{
+ struct ddsi_domaingv * const gv = proxypp->e.gv;
+ const ddsi_guid_t pp_guid = proxypp->e.guid;
assert (proxypp->endpoints == NULL);
- if (proxypp->owns_lease)
- {
- struct lease * minl_auto = ddsrt_atomic_ldvoidp (&proxypp->minl_auto);
- ddsrt_fibheap_delete (&lease_fhdef_proxypp, &proxypp->leaseheap_auto, proxypp->lease);
- assert (ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_auto) == NULL);
- assert (ddsrt_fibheap_min (&lease_fhdef_proxypp, &proxypp->leaseheap_man) == NULL);
- assert (ddsrt_atomic_ldvoidp (&proxypp->minl_man) == NULL);
- assert (!compare_guid (&minl_auto->entity->guid, &proxypp->e.guid));
- lease_unregister (minl_auto);
- lease_free (minl_auto);
- lease_free (proxypp->lease);
- }
ddsrt_mutex_unlock (&proxypp->e.lock);
ELOGDISC (proxypp, "unref_proxy_participant("PGUIDFMT"): refc=0, freeing\n", PGUID (proxypp->e.guid));
-
-#ifdef DDSI_INCLUDE_SECURITY
- q_omg_security_deregister_remote_participant(proxypp);
-#endif
- unref_addrset (proxypp->as_default);
- unref_addrset (proxypp->as_meta);
- nn_plist_fini (proxypp->plist);
- ddsrt_free (proxypp->plist);
- entity_common_fini (&proxypp->e);
- remove_deleted_participant_guid (proxypp->e.gv->deleted_participants, &proxypp->e.guid, DPG_LOCAL | DPG_REMOTE);
- ddsrt_free (proxypp);
+ free_proxy_participant (proxypp);
+ remove_deleted_participant_guid (gv->deleted_participants, &pp_guid, DPG_LOCAL | DPG_REMOTE);
}
else if (proxypp->endpoints == NULL && proxypp->implicitly_created)
{
@@ -5014,7 +5151,7 @@ static void downgrade_to_nonsecure(struct proxy_participant *proxypp)
/* Cleanup all kinds of related security information. */
q_omg_security_deregister_remote_participant(proxypp);
- proxypp->bes &= BES_MASK_NON_SECURITY;
+ proxypp->bes &= NN_BES_MASK_NON_SECURITY;
}
#endif
@@ -5032,7 +5169,7 @@ static void purge_helper (const nn_locator_t *n, void * varg)
delete_proxy_participant_by_guid (data->proxypp->e.gv, &data->proxypp->e.guid, data->timestamp, 1);
}
-void purge_proxy_participants (struct q_globals *gv, const nn_locator_t *loc, bool delete_from_as_disc)
+void purge_proxy_participants (struct ddsi_domaingv *gv, const nn_locator_t *loc, bool delete_from_as_disc)
{
/* FIXME: check whether addr:port can't be reused for a new connection by the time we get here. */
/* NOTE: This function exists for the sole purpose of cleaning up after closing a TCP connection in ddsi_tcp_close_conn and the state of the calling thread could be anything at this point. Because of that we do the unspeakable and toggle the thread state conditionally. We can't afford to have it in "asleep", as that causes a race with the garbage collector. */
@@ -5055,7 +5192,7 @@ void purge_proxy_participants (struct q_globals *gv, const nn_locator_t *loc, bo
thread_state_asleep (ts1);
}
-int delete_proxy_participant_by_guid (struct q_globals *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
+int delete_proxy_participant_by_guid (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
{
struct proxy_participant *ppt;
@@ -5078,7 +5215,7 @@ int delete_proxy_participant_by_guid (struct q_globals *gv, const struct ddsi_gu
return 0;
}
-uint64_t get_entity_instance_id (const struct q_globals *gv, const struct ddsi_guid *guid)
+uint64_t get_entity_instance_id (const struct ddsi_domaingv *gv, const struct ddsi_guid *guid)
{
struct thread_state1 *ts1 = lookup_thread_state ();
struct entity_common *e;
@@ -5092,7 +5229,7 @@ uint64_t get_entity_instance_id (const struct q_globals *gv, const struct ddsi_g
/* PROXY-ENDPOINT --------------------------------------------------- */
-static int proxy_endpoint_common_init (struct entity_common *e, struct proxy_endpoint_common *c, enum entity_kind kind, const struct ddsi_guid *guid, nn_wctime_t tcreate, seqno_t seq, struct proxy_participant *proxypp, struct addrset *as, const nn_plist_t *plist)
+static int proxy_endpoint_common_init (struct entity_common *e, struct proxy_endpoint_common *c, enum entity_kind kind, const struct ddsi_guid *guid, nn_wctime_t tcreate, seqno_t seq, struct proxy_participant *proxypp, struct addrset *as, const ddsi_plist_t *plist)
{
const char *name;
int ret;
@@ -5104,7 +5241,7 @@ static int proxy_endpoint_common_init (struct entity_common *e, struct proxy_end
name = (plist->present & PP_ENTITY_NAME) ? plist->entity_name : "";
entity_common_init (e, proxypp->e.gv, guid, name, kind, tcreate, proxypp->vendor, false);
- c->xqos = nn_xqos_dup (&plist->qos);
+ c->xqos = ddsi_xqos_dup (&plist->qos);
c->as = ref_addrset (as);
c->vendor = proxypp->vendor;
c->seq = seq;
@@ -5121,7 +5258,7 @@ static int proxy_endpoint_common_init (struct entity_common *e, struct proxy_end
if ((ret = ref_proxy_participant (proxypp, c)) != DDS_RETCODE_OK)
{
- nn_xqos_fini (c->xqos);
+ ddsi_xqos_fini (c->xqos);
ddsrt_free (c->xqos);
unref_addrset (c->as);
entity_common_fini (e);
@@ -5134,7 +5271,7 @@ static int proxy_endpoint_common_init (struct entity_common *e, struct proxy_end
static void proxy_endpoint_common_fini (struct entity_common *e, struct proxy_endpoint_common *c)
{
unref_proxy_participant (c->proxypp, c);
- nn_xqos_fini (c->xqos);
+ ddsi_xqos_fini (c->xqos);
ddsrt_free (c->xqos);
unref_addrset (c->as);
entity_common_fini (e);
@@ -5156,7 +5293,7 @@ get_proxy_writer_reorder_mode(const ddsi_entityid_t pwr_entityid, int isreliable
return NN_REORDER_MODE_MONOTONICALLY_INCREASING;
}
-int new_proxy_writer (struct q_globals *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const nn_plist_t *plist, struct nn_dqueue *dqueue, struct xeventq *evq, nn_wctime_t timestamp, seqno_t seq)
+int new_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const ddsi_plist_t *plist, struct nn_dqueue *dqueue, struct xeventq *evq, nn_wctime_t timestamp, seqno_t seq)
{
struct proxy_participant *proxypp;
struct proxy_writer *pwr;
@@ -5400,7 +5537,7 @@ static void gc_delete_proxy_writer (struct gcreq *gcreq)
/* First stage in deleting the proxy writer. In this function the pwr and its member pointers
will remain valid. The real cleaning-up is done async in gc_delete_proxy_writer. */
-int delete_proxy_writer (struct q_globals *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
+int delete_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
{
struct proxy_writer *pwr;
DDSRT_UNUSED_ARG (isimplicit);
@@ -5434,7 +5571,7 @@ int delete_proxy_writer (struct q_globals *gv, const struct ddsi_guid *guid, nn_
static void proxy_writer_notify_liveliness_change_may_unlock (struct proxy_writer *pwr)
{
- struct proxy_writer_alive_state alive_state;
+ struct alive_state alive_state;
proxy_writer_get_alive_state_locked (pwr, &alive_state);
struct ddsi_guid rdguid;
@@ -5469,8 +5606,13 @@ void proxy_writer_set_alive_may_unlock (struct proxy_writer *pwr, bool notify)
ddsrt_mutex_lock (&pwr->c.proxypp->e.lock);
pwr->alive = true;
pwr->alive_vclock++;
- if (pwr->c.xqos->liveliness.lease_duration != T_NEVER && pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_MANUAL_BY_TOPIC)
- proxy_participant_add_pwr_lease_locked (pwr->c.proxypp, pwr);
+ if (pwr->c.xqos->liveliness.lease_duration != T_NEVER)
+ {
+ if (pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_MANUAL_BY_TOPIC)
+ proxy_participant_add_pwr_lease_locked (pwr->c.proxypp, pwr);
+ else
+ lease_set_expiry (pwr->lease, add_duration_to_etime (now_et (), pwr->lease->tdur));
+ }
ddsrt_mutex_unlock (&pwr->c.proxypp->e.lock);
if (notify)
@@ -5501,23 +5643,9 @@ int proxy_writer_set_notalive (struct proxy_writer *pwr, bool notify)
return DDS_RETCODE_OK;
}
-void proxy_writer_set_notalive_guid (struct q_globals *gv, const struct ddsi_guid *pwrguid, bool notify)
-{
- struct proxy_writer *pwr;
- if ((pwr = entidx_lookup_proxy_writer_guid (gv->entity_index, pwrguid)) == NULL)
- GVLOGDISC (" "PGUIDFMT"?\n", PGUID (*pwrguid));
- else
- {
- GVLOGDISC ("proxy_writer_set_notalive_guid ("PGUIDFMT")", PGUID (*pwrguid));
- if (proxy_writer_set_notalive (pwr, notify) == DDS_RETCODE_PRECONDITION_NOT_MET)
- GVLOGDISC (" pwr was not alive");
- GVLOGDISC ("\n");
- }
-}
-
/* PROXY-READER ----------------------------------------------------- */
-int new_proxy_reader (struct q_globals *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const nn_plist_t *plist, nn_wctime_t timestamp, seqno_t seq
+int new_proxy_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid, const struct ddsi_guid *guid, struct addrset *as, const ddsi_plist_t *plist, nn_wctime_t timestamp, seqno_t seq
#ifdef DDSI_INCLUDE_SSM
, int favours_ssm
#endif
@@ -5639,7 +5767,7 @@ static void gc_delete_proxy_reader (struct gcreq *gcreq)
ddsrt_free (prd);
}
-int delete_proxy_reader (struct q_globals *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
+int delete_proxy_reader (struct ddsi_domaingv *gv, const struct ddsi_guid *guid, nn_wctime_t timestamp, int isimplicit)
{
struct proxy_reader *prd;
(void)isimplicit;
diff --git a/src/core/ddsi/src/q_freelist.c b/src/core/ddsi/src/q_freelist.c
index 9d1a1bc..28ed6ea 100644
--- a/src/core/ddsi/src/q_freelist.c
+++ b/src/core/ddsi/src/q_freelist.c
@@ -20,7 +20,7 @@
#if FREELIST_TYPE == FREELIST_NONE
-void nn_freelist_init (struct nn_freelist *fl, uint32_t max, off_t linkoff)
+void nn_freelist_init (struct nn_freelist *fl, uint32_t max, size_t linkoff)
{
(void) fl; (void) max; (void) linkoff;
}
@@ -50,7 +50,7 @@ void *nn_freelist_pop (struct nn_freelist *fl)
#elif FREELIST_TYPE == FREELIST_ATOMIC_LIFO
-void nn_freelist_init (struct nn_freelist *fl, uint32_t max, off_t linkoff)
+void nn_freelist_init (struct nn_freelist *fl, uint32_t max, size_t linkoff)
{
ddsrt_atomic_lifo_init (&fl->x);
ddsrt_atomic_st32(&fl->count, 0);
@@ -104,7 +104,7 @@ void *nn_freelist_pop (struct nn_freelist *fl)
static ddsrt_thread_local int freelist_inner_idx = -1;
-void nn_freelist_init (struct nn_freelist *fl, uint32_t max, off_t linkoff)
+void nn_freelist_init (struct nn_freelist *fl, uint32_t max, size_t linkoff)
{
int i;
ddsrt_mutex_init (&fl->lock);
diff --git a/src/core/ddsi/src/q_gc.c b/src/core/ddsi/src/q_gc.c
index 948510d..4444112 100644
--- a/src/core/ddsi/src/q_gc.c
+++ b/src/core/ddsi/src/q_gc.c
@@ -24,7 +24,7 @@
#include "dds/ddsi/ddsi_entity_index.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_lease.h"
-#include "dds/ddsi/q_globals.h" /* for mattr, cattr */
+#include "dds/ddsi/ddsi_domaingv.h" /* for mattr, cattr */
#include "dds/ddsi/q_receive.h" /* for trigger_receive_threads */
struct gcreq_queue {
@@ -34,11 +34,11 @@ struct gcreq_queue {
ddsrt_cond_t cond;
int terminate;
int32_t count;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
struct thread_state1 *ts;
};
-static void threads_vtime_gather_for_wait (const struct q_globals *gv, unsigned *nivs, struct idx_vtime *ivs)
+static void threads_vtime_gather_for_wait (const struct ddsi_domaingv *gv, unsigned *nivs, struct idx_vtime *ivs)
{
/* copy vtimes of threads, skipping those that are sleeping */
uint32_t i, j;
@@ -189,7 +189,7 @@ static uint32_t gcreq_queue_thread (struct gcreq_queue *q)
return 0;
}
-struct gcreq_queue *gcreq_queue_new (struct q_globals *gv)
+struct gcreq_queue *gcreq_queue_new (struct ddsi_domaingv *gv)
{
struct gcreq_queue *q = ddsrt_malloc (sizeof (*q));
diff --git a/src/core/ddsi/src/q_init.c b/src/core/ddsi/src/q_init.c
index 7765f59..a140b33 100644
--- a/src/core/ddsi/src/q_init.c
+++ b/src/core/ddsi/src/q_init.c
@@ -27,7 +27,7 @@
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_lat_estim.h"
@@ -42,7 +42,7 @@
#include "dds/ddsi/q_gc.h"
#include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_nwif.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/q_receive.h"
#include "dds/ddsi/q_pcap.h"
@@ -64,7 +64,7 @@
#include "dds/ddsi/ddsi_security_omg.h"
-static void add_peer_addresses (const struct q_globals *gv, struct addrset *as, const struct config_peer_listelem *list)
+static void add_peer_addresses (const struct ddsi_domaingv *gv, struct addrset *as, const struct config_peer_listelem *list)
{
while (list)
{
@@ -79,7 +79,7 @@ enum make_uc_sockets_ret {
MUSRET_NOSOCKET
};
-static enum make_uc_sockets_ret make_uc_sockets (struct q_globals *gv, uint32_t * pdisc, uint32_t * pdata, int ppid)
+static enum make_uc_sockets_ret make_uc_sockets (struct ddsi_domaingv *gv, uint32_t * pdisc, uint32_t * pdata, int ppid)
{
if (gv->config.many_sockets_mode == MSM_NO_UNICAST)
{
@@ -129,7 +129,7 @@ static enum make_uc_sockets_ret make_uc_sockets (struct q_globals *gv, uint32_t
static void make_builtin_endpoint_xqos (dds_qos_t *q, const dds_qos_t *template)
{
- nn_xqos_copy (q, template);
+ ddsi_xqos_copy (q, template);
q->reliability.kind = DDS_RELIABILITY_RELIABLE;
q->reliability.max_blocking_time = 100 * T_MILLISECOND;
q->durability.kind = DDS_DURABILITY_TRANSIENT_LOCAL;
@@ -138,7 +138,7 @@ static void make_builtin_endpoint_xqos (dds_qos_t *q, const dds_qos_t *template)
#ifdef DDSI_INCLUDE_SECURITY
static void make_builtin_volatile_endpoint_xqos (dds_qos_t *q, const dds_qos_t *template)
{
- nn_xqos_copy (q, template);
+ ddsi_xqos_copy (q, template);
q->reliability.kind = DDS_RELIABILITY_RELIABLE;
q->reliability.max_blocking_time = 100 * T_MILLISECOND;
q->durability.kind = DDS_DURABILITY_VOLATILE;
@@ -158,7 +158,7 @@ static void add_property_to_xqos(dds_qos_t *q, const char *name, const char *val
}
#endif
-static int set_recvips (struct q_globals *gv)
+static int set_recvips (struct ddsi_domaingv *gv)
{
gv->recvips = NULL;
@@ -263,7 +263,7 @@ static int set_recvips (struct q_globals *gv)
* return -1 : ddsi is unicast, but 'mc' indicates it expects multicast
* return 0 : ddsi is multicast, but 'mc' indicates it expects unicast
* The return 0 means that the possible changes in 'loc' can be ignored. */
-static int string_to_default_locator (const struct q_globals *gv, nn_locator_t *loc, const char *string, uint32_t port, int mc, const char *tag)
+static int string_to_default_locator (const struct ddsi_domaingv *gv, nn_locator_t *loc, const char *string, uint32_t port, int mc, const char *tag)
{
if (strspn (string, " \t") == strlen (string))
{
@@ -302,11 +302,12 @@ static int string_to_default_locator (const struct q_globals *gv, nn_locator_t *
return 1;
}
-static int set_spdp_address (struct q_globals *gv)
+static int set_spdp_address (struct ddsi_domaingv *gv)
{
const uint32_t port = ddsi_get_port (&gv->config, DDSI_PORT_MULTI_DISC, 0);
int rc = 0;
/* FIXME: FIXME: FIXME: */
+ gv->loc_spdp_mc.tran = NULL;
gv->loc_spdp_mc.kind = NN_LOCATOR_KIND_INVALID;
if (strcmp (gv->config.spdpMulticastAddressString, "239.255.0.1") != 0)
{
@@ -334,7 +335,7 @@ static int set_spdp_address (struct q_globals *gv)
return 0;
}
-static int set_default_mc_address (struct q_globals *gv)
+static int set_default_mc_address (struct ddsi_domaingv *gv)
{
const uint32_t port = ddsi_get_port (&gv->config, DDSI_PORT_MULTI_DATA, 0);
int rc;
@@ -348,7 +349,7 @@ static int set_default_mc_address (struct q_globals *gv)
return 0;
}
-static int set_ext_address_and_mask (struct q_globals *gv)
+static int set_ext_address_and_mask (struct ddsi_domaingv *gv)
{
nn_locator_t loc;
int rc;
@@ -367,6 +368,7 @@ static int set_ext_address_and_mask (struct q_globals *gv)
if (!gv->config.externalMaskString || strcmp (gv->config.externalMaskString, "0.0.0.0") == 0)
{
memset(&gv->extmask.address, 0, sizeof(gv->extmask.address));
+ gv->extmask.tran = NULL;
gv->extmask.kind = NN_LOCATOR_KIND_INVALID;
gv->extmask.port = NN_LOCATOR_PORT_INVALID;
}
@@ -384,7 +386,7 @@ static int set_ext_address_and_mask (struct q_globals *gv)
}
#ifdef DDSI_INCLUDE_NETWORK_CHANNELS
-static int known_channel_p (const struct q_globals *gv, const char *name)
+static int known_channel_p (const struct ddsi_domaingv *gv, const char *name)
{
const struct config_channel_listelem *c;
for (c = gv->config.channels; c; c = c->next)
@@ -394,7 +396,7 @@ static int known_channel_p (const struct q_globals *gv, const char *name)
}
#endif
-static int check_thread_properties (const struct q_globals *gv)
+static int check_thread_properties (const struct ddsi_domaingv *gv)
{
#ifdef DDSI_INCLUDE_NETWORK_CHANNELS
static const char *fixed[] = { "recv", "tev", "gc", "lease", "dq.builtins", "debmon", "fsm", NULL };
@@ -434,7 +436,7 @@ static int check_thread_properties (const struct q_globals *gv)
return ok;
}
-int rtps_config_open_trace (struct q_globals *gv)
+int rtps_config_open_trace (struct ddsi_domaingv *gv)
{
DDSRT_WARNING_MSVC_OFF(4996);
int status;
@@ -470,7 +472,7 @@ int rtps_config_open_trace (struct q_globals *gv)
DDSRT_WARNING_MSVC_ON(4996);
}
-int rtps_config_prep (struct q_globals *gv, struct cfgst *cfgst)
+int rtps_config_prep (struct ddsi_domaingv *gv, struct cfgst *cfgst)
{
#ifdef DDSI_INCLUDE_NETWORK_CHANNELS
unsigned num_channels = 0;
@@ -636,7 +638,7 @@ err_config_late_error:
}
struct joinleave_spdp_defmcip_helper_arg {
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
int errcount;
int dojoin;
};
@@ -662,7 +664,7 @@ static void joinleave_spdp_defmcip_helper (const nn_locator_t *loc, void *varg)
}
}
-int joinleave_spdp_defmcip (struct q_globals *gv, int dojoin)
+int joinleave_spdp_defmcip (struct ddsi_domaingv *gv, int dojoin)
{
/* Addrset provides an easy way to filter out duplicates */
struct joinleave_spdp_defmcip_helper_arg arg;
@@ -684,7 +686,7 @@ int joinleave_spdp_defmcip (struct q_globals *gv, int dojoin)
return 0;
}
-int create_multicast_sockets (struct q_globals *gv)
+int create_multicast_sockets (struct ddsi_domaingv *gv)
{
ddsi_tran_qos_t qos = ddsi_tran_create_qos ();
ddsi_tran_conn_t disc, data;
@@ -734,7 +736,7 @@ err_disc:
return 0;
}
-static void rtps_term_prep (struct q_globals *gv)
+static void rtps_term_prep (struct ddsi_domaingv *gv)
{
/* Stop all I/O */
ddsrt_mutex_lock (&gv->lock);
@@ -749,7 +751,7 @@ static void rtps_term_prep (struct q_globals *gv)
}
struct wait_for_receive_threads_helper_arg {
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
unsigned count;
};
@@ -762,7 +764,7 @@ static void wait_for_receive_threads_helper (struct xevent *xev, void *varg, nn_
(void) resched_xevent_if_earlier (xev, add_duration_to_mtime (tnow, T_SECOND));
}
-static void wait_for_receive_threads (struct q_globals *gv)
+static void wait_for_receive_threads (struct ddsi_domaingv *gv)
{
struct xevent *trigev;
struct wait_for_receive_threads_helper_arg cbarg;
@@ -790,7 +792,7 @@ static void wait_for_receive_threads (struct q_globals *gv)
}
}
-static struct ddsi_sertopic *make_special_topic (struct serdatapool *serpool, uint16_t enc_id, const struct ddsi_serdata_ops *ops)
+static struct ddsi_sertopic *make_special_topic (const char *name, struct serdatapool *serpool, uint16_t enc_id, const struct ddsi_serdata_ops *ops)
{
/* FIXME: two things (at least)
- it claims there is a key, but the underlying type description is missing
@@ -802,27 +804,63 @@ static struct ddsi_sertopic *make_special_topic (struct serdatapool *serpool, ui
(kinda natural if they stop being "default" ones) */
struct ddsi_sertopic_default *st = ddsrt_malloc (sizeof (*st));
memset (st, 0, sizeof (*st));
- ddsi_sertopic_init_anon (&st->c, &ddsi_sertopic_ops_default, ops, false);
+ ddsi_sertopic_init (&st->c, name, name, &ddsi_sertopic_ops_default, ops, false);
st->native_encoding_identifier = enc_id;
st->serpool = serpool;
- st->nkeys = 1;
return (struct ddsi_sertopic *) st;
}
-static void make_special_topics (struct q_globals *gv)
-{
- gv->plist_topic = make_special_topic (gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? PL_CDR_LE : PL_CDR_BE, &ddsi_serdata_ops_plist);
- gv->rawcdr_topic = make_special_topic (gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE, &ddsi_serdata_ops_rawcdr);
-}
-
-static void free_special_topics (struct q_globals *gv)
+static void free_special_topics (struct ddsi_domaingv *gv)
{
ddsi_sertopic_unref (gv->plist_topic);
ddsi_sertopic_unref (gv->rawcdr_topic);
}
-static int setup_and_start_recv_threads (struct q_globals *gv)
+static void make_special_topics (struct ddsi_domaingv *gv)
{
+ gv->plist_topic = make_special_topic ("plist", gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? PL_CDR_LE : PL_CDR_BE, &ddsi_serdata_ops_plist);
+ gv->rawcdr_topic = make_special_topic ("rawcdr", gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE, &ddsi_serdata_ops_rawcdr);
+
+ ddsrt_mutex_lock (&gv->sertopics_lock);
+ ddsi_sertopic_register_locked (gv, gv->plist_topic);
+ ddsi_sertopic_register_locked (gv, gv->rawcdr_topic);
+ ddsrt_mutex_unlock (&gv->sertopics_lock);
+
+ /* register increments refcount (which is reasonable), but at some point
+ one needs to get rid of that reference */
+ free_special_topics (gv);
+}
+
+static bool use_multiple_receive_threads (const struct config *cfg)
+{
+ /* Under some unknown circumstances Windows (at least Windows 10) exhibits
+ the interesting behaviour of losing its ability to let us send packets
+ to our own sockets. When that happens, dedicated receive threads can no
+ longer be stopped and Cyclone hangs in shutdown. So until someone
+ figures out why this happens, it is probably best have a different
+ default on Windows. */
+#if _WIN32
+ const bool def = false;
+#else
+ const bool def = true;
+#endif
+ switch (cfg->multiple_recv_threads)
+ {
+ case BOOLDEF_FALSE:
+ return false;
+ case BOOLDEF_TRUE:
+ return true;
+ case BOOLDEF_DEFAULT:
+ return def;
+ }
+ assert (0);
+ return false;
+}
+
+static int setup_and_start_recv_threads (struct ddsi_domaingv *gv)
+{
+ const bool multi_recv_thr = use_multiple_receive_threads (&gv->config);
+
for (uint32_t i = 0; i < MAX_RECV_THREADS; i++)
{
gv->recv_threads[i].ts = NULL;
@@ -837,7 +875,7 @@ static int setup_and_start_recv_threads (struct q_globals *gv)
gv->n_recv_threads = 1;
gv->recv_threads[0].name = "recv";
gv->recv_threads[0].arg.mode = RTM_MANY;
- if (gv->m_factory->m_connless && gv->config.many_sockets_mode != MSM_NO_UNICAST && gv->config.multiple_recv_threads)
+ if (gv->m_factory->m_connless && gv->config.many_sockets_mode != MSM_NO_UNICAST && multi_recv_thr)
{
if (ddsi_is_mcaddr (gv, &gv->loc_default_mc) && !ddsi_is_ssm_mcaddr (gv, &gv->loc_default_mc) && (gv->config.allowMulticast & AMC_ASM))
{
@@ -903,7 +941,17 @@ fail:
return -1;
}
-int rtps_init (struct q_globals *gv)
+static int ddsi_sertopic_equal_wrap (const void *a, const void *b)
+{
+ return ddsi_sertopic_equal (a, b);
+}
+
+static uint32_t ddsi_sertopic_hash_wrap (const void *tp)
+{
+ return ddsi_sertopic_hash (tp);
+}
+
+int rtps_init (struct ddsi_domaingv *gv)
{
uint32_t port_disc_uc = 0;
uint32_t port_data_uc = 0;
@@ -911,7 +959,7 @@ int rtps_init (struct q_globals *gv)
gv->tstart = now (); /* wall clock time, used in logs */
- nn_plist_init_tables ();
+ ddsi_plist_init_tables ();
gv->disc_conn_uc = NULL;
gv->data_conn_uc = NULL;
@@ -982,7 +1030,7 @@ int rtps_init (struct q_globals *gv)
{
if (!gv->interfaces[gv->selected_interface].mc_capable)
{
- GVWARNING ("selected interface is not multicast-capable: disabling multicast\n");
+ GVWARNING ("selected interface \"%s\" is not multicast-capable: disabling multicast\n", gv->interfaces[gv->selected_interface].name);
gv->config.allowMulticast = AMC_FALSE;
/* ensure discovery can work: firstly, that the process will be reachable on a "well-known" port
number, and secondly, that the local interface's IP address gets added to the discovery
@@ -1021,12 +1069,11 @@ int rtps_init (struct q_globals *gv)
{
char buf[DDSI_LOCSTRLEN];
/* the "ownip", "extip" labels in the trace have been there for so long, that it seems worthwhile to retain them even though they need not be IP any longer */
- GVLOG (DDS_LC_CONFIG, "ownip: %s\n", ddsi_locator_to_string_no_port (gv, buf, sizeof(buf), &gv->ownloc));
- GVLOG (DDS_LC_CONFIG, "extip: %s\n", ddsi_locator_to_string_no_port (gv, buf, sizeof(buf), &gv->extloc));
- GVLOG (DDS_LC_CONFIG, "extmask: %s%s\n", ddsi_locator_to_string_no_port (gv, buf, sizeof(buf), &gv->extmask), gv->m_factory->m_kind != NN_LOCATOR_KIND_UDPv4 ? " (not applicable)" : "");
- GVLOG (DDS_LC_CONFIG, "networkid: 0x%lx\n", (unsigned long) gv->myNetworkId);
- GVLOG (DDS_LC_CONFIG, "SPDP MC: %s\n", ddsi_locator_to_string_no_port (gv, buf, sizeof(buf), &gv->loc_spdp_mc));
- GVLOG (DDS_LC_CONFIG, "default MC: %s\n", ddsi_locator_to_string_no_port (gv, buf, sizeof(buf), &gv->loc_default_mc));
+ GVLOG (DDS_LC_CONFIG, "ownip: %s\n", ddsi_locator_to_string_no_port (buf, sizeof(buf), &gv->ownloc));
+ GVLOG (DDS_LC_CONFIG, "extip: %s\n", ddsi_locator_to_string_no_port (buf, sizeof(buf), &gv->extloc));
+ GVLOG (DDS_LC_CONFIG, "extmask: %s%s\n", ddsi_locator_to_string_no_port (buf, sizeof(buf), &gv->extmask), gv->m_factory->m_kind != NN_LOCATOR_KIND_UDPv4 ? " (not applicable)" : "");
+ GVLOG (DDS_LC_CONFIG, "SPDP MC: %s\n", ddsi_locator_to_string_no_port (buf, sizeof(buf), &gv->loc_spdp_mc));
+ GVLOG (DDS_LC_CONFIG, "default MC: %s\n", ddsi_locator_to_string_no_port (buf, sizeof(buf), &gv->loc_default_mc));
#ifdef DDSI_INCLUDE_SSM
GVLOG (DDS_LC_CONFIG, "SSM support included\n");
#endif
@@ -1059,23 +1106,23 @@ int rtps_init (struct q_globals *gv)
gv->xmsgpool = nn_xmsgpool_new ();
gv->serpool = ddsi_serdatapool_new ();
- nn_plist_init_default_participant (&gv->default_plist_pp);
- nn_plist_init_default_participant (&gv->default_local_plist_pp);
- nn_xqos_init_default_reader (&gv->default_xqos_rd);
- nn_xqos_init_default_writer (&gv->default_xqos_wr);
- nn_xqos_init_default_writer_noautodispose (&gv->default_xqos_wr_nad);
- nn_xqos_init_default_topic (&gv->default_xqos_tp);
- nn_xqos_init_default_subscriber (&gv->default_xqos_sub);
- nn_xqos_init_default_publisher (&gv->default_xqos_pub);
- nn_xqos_copy (&gv->spdp_endpoint_xqos, &gv->default_xqos_rd);
+ ddsi_plist_init_default_participant (&gv->default_plist_pp);
+ ddsi_plist_init_default_participant (&gv->default_local_plist_pp);
+ ddsi_xqos_init_default_reader (&gv->default_xqos_rd);
+ ddsi_xqos_init_default_writer (&gv->default_xqos_wr);
+ ddsi_xqos_init_default_writer_noautodispose (&gv->default_xqos_wr_nad);
+ ddsi_xqos_init_default_topic (&gv->default_xqos_tp);
+ ddsi_xqos_init_default_subscriber (&gv->default_xqos_sub);
+ ddsi_xqos_init_default_publisher (&gv->default_xqos_pub);
+ ddsi_xqos_copy (&gv->spdp_endpoint_xqos, &gv->default_xqos_rd);
gv->spdp_endpoint_xqos.durability.kind = DDS_DURABILITY_TRANSIENT_LOCAL;
make_builtin_endpoint_xqos (&gv->builtin_endpoint_xqos_rd, &gv->default_xqos_rd);
make_builtin_endpoint_xqos (&gv->builtin_endpoint_xqos_wr, &gv->default_xqos_wr);
#ifdef DDSI_INCLUDE_SECURITY
make_builtin_volatile_endpoint_xqos(&gv->builtin_volatile_xqos_rd, &gv->default_xqos_rd);
make_builtin_volatile_endpoint_xqos(&gv->builtin_volatile_xqos_wr, &gv->default_xqos_wr);
- nn_xqos_copy (&gv->builtin_stateless_xqos_rd, &gv->default_xqos_rd);
- nn_xqos_copy (&gv->builtin_stateless_xqos_wr, &gv->default_xqos_wr);
+ ddsi_xqos_copy (&gv->builtin_stateless_xqos_rd, &gv->default_xqos_rd);
+ ddsi_xqos_copy (&gv->builtin_stateless_xqos_wr, &gv->default_xqos_wr);
gv->builtin_stateless_xqos_wr.reliability.kind = DDS_RELIABILITY_BEST_EFFORT;
gv->builtin_stateless_xqos_wr.durability.kind = DDS_DURABILITY_VOLATILE;
@@ -1083,10 +1130,12 @@ int rtps_init (struct q_globals *gv)
* the entities (see DDS Security spec chapter 8.8.8.1). */
add_property_to_xqos(&gv->builtin_volatile_xqos_rd, "dds.sec.builtin_endpoint_name", "BuiltinParticipantVolatileMessageSecureReader");
add_property_to_xqos(&gv->builtin_volatile_xqos_wr, "dds.sec.builtin_endpoint_name", "BuiltinParticipantVolatileMessageSecureWriter");
-
+
q_omg_security_init( &gv->security_context, &gv->logconfig );
#endif
+ ddsrt_mutex_init (&gv->sertopics_lock);
+ gv->sertopics = ddsrt_hh_new (1, ddsi_sertopic_hash_wrap, ddsi_sertopic_equal_wrap);
make_special_topics (gv);
ddsrt_mutex_init (&gv->participant_set_lock);
@@ -1354,7 +1403,7 @@ int rtps_init (struct q_globals *gv)
{
struct config_peer_listelem peer_local;
char local_addr[DDSI_LOCSTRLEN];
- ddsi_locator_to_string_no_port (gv, local_addr, sizeof (local_addr), &gv->interfaces[gv->selected_interface].loc);
+ ddsi_locator_to_string_no_port (local_addr, sizeof (local_addr), &gv->interfaces[gv->selected_interface].loc);
peer_local.next = NULL;
peer_local.peer = local_addr;
add_peer_addresses (gv, gv->as_disc, &peer_local);
@@ -1419,25 +1468,34 @@ err_unicast_sockets:
ddsrt_cond_destroy (&gv->participant_set_cond);
ddsrt_mutex_destroy (&gv->participant_set_lock);
free_special_topics (gv);
+#ifndef NDEBUG
+ {
+ struct ddsrt_hh_iter it;
+ assert (ddsrt_hh_iter_first (gv->sertopics, &it) == NULL);
+ }
+#endif
+ ddsrt_hh_free (gv->sertopics);
+ ddsrt_mutex_destroy (&gv->sertopics_lock);
#ifdef DDSI_INCLUDE_SECURITY
- nn_xqos_fini (&gv->builtin_stateless_xqos_wr);
- nn_xqos_fini (&gv->builtin_stateless_xqos_rd);
- nn_xqos_fini (&gv->builtin_volatile_xqos_wr);
- nn_xqos_fini (&gv->builtin_volatile_xqos_rd);
-
+ ddsi_xqos_fini (&gv->builtin_stateless_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_stateless_xqos_rd);
+ ddsi_xqos_fini (&gv->builtin_volatile_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_volatile_xqos_rd);
+
q_omg_security_deinit( &gv->security_context );
#endif
- nn_xqos_fini (&gv->builtin_endpoint_xqos_wr);
- nn_xqos_fini (&gv->builtin_endpoint_xqos_rd);
- nn_xqos_fini (&gv->spdp_endpoint_xqos);
- nn_xqos_fini (&gv->default_xqos_pub);
- nn_xqos_fini (&gv->default_xqos_sub);
- nn_xqos_fini (&gv->default_xqos_tp);
- nn_xqos_fini (&gv->default_xqos_wr_nad);
- nn_xqos_fini (&gv->default_xqos_wr);
- nn_xqos_fini (&gv->default_xqos_rd);
- nn_plist_fini (&gv->default_local_plist_pp);
- nn_plist_fini (&gv->default_plist_pp);
+ ddsi_xqos_fini (&gv->builtin_endpoint_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_endpoint_xqos_rd);
+ ddsi_xqos_fini (&gv->spdp_endpoint_xqos);
+ ddsi_xqos_fini (&gv->default_xqos_pub);
+ ddsi_xqos_fini (&gv->default_xqos_sub);
+ ddsi_xqos_fini (&gv->default_xqos_tp);
+ ddsi_xqos_fini (&gv->default_xqos_wr_nad);
+ ddsi_xqos_fini (&gv->default_xqos_wr);
+ ddsi_xqos_fini (&gv->default_xqos_rd);
+ ddsi_plist_fini (&gv->default_local_plist_pp);
+ ddsi_plist_fini (&gv->default_plist_pp);
+
ddsi_serdatapool_free (gv->serpool);
nn_xmsgpool_free (gv->xmsgpool);
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
@@ -1472,7 +1530,7 @@ static void stop_all_xeventq_upto (struct config_channel_listelem *chptr)
}
#endif
-int rtps_start (struct q_globals *gv)
+int rtps_start (struct ddsi_domaingv *gv)
{
if (xeventq_start (gv->xevents, NULL) < 0)
return -1;
@@ -1538,7 +1596,7 @@ static void builtins_dqueue_ready_cb (void *varg)
ddsrt_mutex_unlock (&arg->lock);
}
-void rtps_stop (struct q_globals *gv)
+void rtps_stop (struct ddsi_domaingv *gv)
{
struct thread_state1 * const ts1 = lookup_thread_state ();
@@ -1669,7 +1727,7 @@ void rtps_stop (struct q_globals *gv)
ddsrt_mutex_destroy (&gv->privileged_pp_lock);
}
-void rtps_fini (struct q_globals *gv)
+void rtps_fini (struct ddsi_domaingv *gv)
{
/* Shut down the GC system -- no new requests will be added */
gcreq_queue_free (gv->gcreq_queue);
@@ -1765,25 +1823,34 @@ void rtps_fini (struct q_globals *gv)
ddsrt_cond_destroy (&gv->participant_set_cond);
free_special_topics (gv);
+#ifndef NDEBUG
+ {
+ struct ddsrt_hh_iter it;
+ assert (ddsrt_hh_iter_first (gv->sertopics, &it) == NULL);
+ }
+#endif
+ ddsrt_hh_free (gv->sertopics);
+ ddsrt_mutex_destroy (&gv->sertopics_lock);
+
#ifdef DDSI_INCLUDE_SECURITY
- nn_xqos_fini (&gv->builtin_stateless_xqos_wr);
- nn_xqos_fini (&gv->builtin_stateless_xqos_rd);
- nn_xqos_fini (&gv->builtin_volatile_xqos_wr);
- nn_xqos_fini (&gv->builtin_volatile_xqos_rd);
-
+ ddsi_xqos_fini (&gv->builtin_stateless_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_stateless_xqos_rd);
+ ddsi_xqos_fini (&gv->builtin_volatile_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_volatile_xqos_rd);
+
q_omg_security_deinit( &gv->security_context);
#endif
- nn_xqos_fini (&gv->builtin_endpoint_xqos_wr);
- nn_xqos_fini (&gv->builtin_endpoint_xqos_rd);
- nn_xqos_fini (&gv->spdp_endpoint_xqos);
- nn_xqos_fini (&gv->default_xqos_pub);
- nn_xqos_fini (&gv->default_xqos_sub);
- nn_xqos_fini (&gv->default_xqos_tp);
- nn_xqos_fini (&gv->default_xqos_wr_nad);
- nn_xqos_fini (&gv->default_xqos_wr);
- nn_xqos_fini (&gv->default_xqos_rd);
- nn_plist_fini (&gv->default_local_plist_pp);
- nn_plist_fini (&gv->default_plist_pp);
+ ddsi_xqos_fini (&gv->builtin_endpoint_xqos_wr);
+ ddsi_xqos_fini (&gv->builtin_endpoint_xqos_rd);
+ ddsi_xqos_fini (&gv->spdp_endpoint_xqos);
+ ddsi_xqos_fini (&gv->default_xqos_pub);
+ ddsi_xqos_fini (&gv->default_xqos_sub);
+ ddsi_xqos_fini (&gv->default_xqos_tp);
+ ddsi_xqos_fini (&gv->default_xqos_wr_nad);
+ ddsi_xqos_fini (&gv->default_xqos_wr);
+ ddsi_xqos_fini (&gv->default_xqos_rd);
+ ddsi_plist_fini (&gv->default_local_plist_pp);
+ ddsi_plist_fini (&gv->default_plist_pp);
ddsrt_mutex_destroy (&gv->lock);
diff --git a/src/core/ddsi/src/q_lease.c b/src/core/ddsi/src/q_lease.c
index a903ab2..7e8f9f3 100644
--- a/src/core/ddsi/src/q_lease.c
+++ b/src/core/ddsi/src/q_lease.c
@@ -24,7 +24,7 @@
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_xevent.h"
#include "dds/ddsi/q_addrset.h"
@@ -32,7 +32,7 @@
#include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/ddsi_entity_index.h"
#include "dds/ddsi/q_entity.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_transmit.h"
@@ -64,13 +64,13 @@ int compare_lease_tdur (const void *va, const void *vb)
return (a->tdur == b->tdur) ? 0 : (a->tdur < b->tdur) ? -1 : 1;
}
-void lease_management_init (struct q_globals *gv)
+void lease_management_init (struct ddsi_domaingv *gv)
{
ddsrt_mutex_init (&gv->leaseheap_lock);
ddsrt_fibheap_init (&lease_fhdef, &gv->leaseheap);
}
-void lease_management_term (struct q_globals *gv)
+void lease_management_term (struct ddsi_domaingv *gv)
{
assert (ddsrt_fibheap_min (&lease_fhdef, &gv->leaseheap) == NULL);
ddsrt_mutex_destroy (&gv->leaseheap_lock);
@@ -105,7 +105,7 @@ struct lease *lease_clone (const struct lease *l)
void lease_register (struct lease *l) /* FIXME: make lease admin struct */
{
- struct q_globals * const gv = l->entity->gv;
+ struct ddsi_domaingv * const gv = l->entity->gv;
GVTRACE ("lease_register(l %p guid "PGUIDFMT")\n", (void *) l, PGUID (l->entity->guid));
ddsrt_mutex_lock (&gv->leaseheap_lock);
assert (l->tsched.v == TSCHED_NOT_ON_HEAP);
@@ -123,7 +123,7 @@ void lease_register (struct lease *l) /* FIXME: make lease admin struct */
void lease_unregister (struct lease *l)
{
- struct q_globals * const gv = l->entity->gv;
+ struct ddsi_domaingv * const gv = l->entity->gv;
GVTRACE ("lease_unregister(l %p guid "PGUIDFMT")\n", (void *) l, PGUID (l->entity->guid));
ddsrt_mutex_lock (&gv->leaseheap_lock);
if (l->tsched.v != TSCHED_NOT_ON_HEAP)
@@ -139,11 +139,27 @@ void lease_unregister (struct lease *l)
void lease_free (struct lease *l)
{
- struct q_globals * const gv = l->entity->gv;
+ struct ddsi_domaingv * const gv = l->entity->gv;
GVTRACE ("lease_free(l %p guid "PGUIDFMT")\n", (void *) l, PGUID (l->entity->guid));
ddsrt_free (l);
}
+static void trace_lease_renew (const struct lease *l, const char *tag, nn_etime_t tend_new)
+{
+ struct ddsi_domaingv const * gv = l->entity->gv;
+ if (gv->logconfig.c.mask & DDS_LC_TRACE)
+ {
+ int32_t tsec, tusec;
+ GVTRACE (" L(%s", tag);
+ if (l->entity->guid.entityid.u == NN_ENTITYID_PARTICIPANT)
+ GVTRACE (":%"PRIx32, l->entity->guid.entityid.u);
+ else
+ GVTRACE (""PGUIDFMT"", PGUID (l->entity->guid));
+ etime_to_sec_usec (&tsec, &tusec, tend_new);
+ GVTRACE (" %"PRId32".%06"PRId32")", tsec, tusec);
+ }
+}
+
void lease_renew (struct lease *l, nn_etime_t tnowE)
{
nn_etime_t tend_new = add_duration_to_etime (tnowE, l->tdur);
@@ -160,23 +176,12 @@ void lease_renew (struct lease *l, nn_etime_t tnowE)
* lease (i.e. the entity still exists). In cases where dereferencing l->entity->gv
* is not safe (e.g. the deletion of entities), the early out in the loop above
* will be the case because tend is set to T_NEVER. */
- struct q_globals const * gv = l->entity->gv;
- if (gv->logconfig.c.mask & DDS_LC_TRACE)
- {
- int32_t tsec, tusec;
- GVTRACE (" L(");
- if (l->entity->guid.entityid.u == NN_ENTITYID_PARTICIPANT)
- GVTRACE (":%"PRIx32, l->entity->guid.entityid.u);
- else
- GVTRACE (""PGUIDFMT"", PGUID (l->entity->guid));
- etime_to_sec_usec (&tsec, &tusec, tend_new);
- GVTRACE (" %"PRId32".%06"PRId32")", tsec, tusec);
- }
+ trace_lease_renew (l, "", tend_new);
}
void lease_set_expiry (struct lease *l, nn_etime_t when)
{
- struct q_globals * const gv = l->entity->gv;
+ struct ddsi_domaingv * const gv = l->entity->gv;
bool trigger = false;
assert (when.v >= 0);
ddsrt_mutex_lock (&gv->leaseheap_lock);
@@ -189,6 +194,7 @@ void lease_set_expiry (struct lease *l, nn_etime_t when)
TSCHED_NOT_ON_HEAP == INT64_MIN) */
l->tsched = when;
ddsrt_fibheap_decrease_key (&lease_fhdef, &gv->leaseheap, l);
+ trace_lease_renew (l, "earlier ", when);
trigger = true;
}
else if (l->tsched.v == TSCHED_NOT_ON_HEAP && when.v < T_NEVER)
@@ -196,6 +202,7 @@ void lease_set_expiry (struct lease *l, nn_etime_t when)
/* not currently scheduled, with a finite new expiry time */
l->tsched = when;
ddsrt_fibheap_insert (&lease_fhdef, &gv->leaseheap, l);
+ trace_lease_renew (l, "insert ", when);
trigger = true;
}
ddsrt_mutex_unlock (&gv->leaseheap_lock);
@@ -205,7 +212,7 @@ void lease_set_expiry (struct lease *l, nn_etime_t when)
force_lease_check (gv->gcreq_queue);
}
-int64_t check_and_handle_lease_expiration (struct q_globals *gv, nn_etime_t tnowE)
+int64_t check_and_handle_lease_expiration (struct ddsi_domaingv *gv, nn_etime_t tnowE)
{
struct lease *l;
int64_t delay;
@@ -281,11 +288,13 @@ int64_t check_and_handle_lease_expiration (struct q_globals *gv, nn_etime_t tnow
delete_proxy_participant_by_guid (gv, &g, now(), 1);
break;
case EK_PROXY_WRITER:
- proxy_writer_set_notalive_guid (gv, &g, true);
+ proxy_writer_set_notalive ((struct proxy_writer *) l->entity, true);
+ break;
+ case EK_WRITER:
+ writer_set_notalive ((struct writer *) l->entity, true);
break;
case EK_PARTICIPANT:
case EK_READER:
- case EK_WRITER:
case EK_PROXY_READER:
assert (false);
break;
diff --git a/src/core/ddsi/src/q_nwif.c b/src/core/ddsi/src/q_nwif.c
index c5c4c85..7b96a2f 100644
--- a/src/core/ddsi/src/q_nwif.c
+++ b/src/core/ddsi/src/q_nwif.c
@@ -24,7 +24,7 @@
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_nwif.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_misc.h"
@@ -214,7 +214,7 @@ static int set_reuse_options (const struct ddsrt_log_cfg *logcfg, ddsrt_socket_t
return 0;
}
-static int bind_socket (ddsrt_socket_t socket, unsigned short port, const struct q_globals *gv)
+static int bind_socket (ddsrt_socket_t socket, unsigned short port, const struct ddsi_domaingv *gv)
{
dds_return_t rc = DDS_RETCODE_ERROR;
@@ -249,7 +249,7 @@ static int bind_socket (ddsrt_socket_t socket, unsigned short port, const struct
}
#if DDSRT_HAVE_IPV6
-static int set_mc_options_transmit_ipv6 (ddsrt_socket_t socket, const struct q_globals *gv)
+static int set_mc_options_transmit_ipv6 (ddsrt_socket_t socket, const struct ddsi_domaingv *gv)
{
unsigned interfaceNo = gv->interfaceNo;
unsigned ttl = (unsigned) gv->config.multicast_ttl;
@@ -274,7 +274,7 @@ static int set_mc_options_transmit_ipv6 (ddsrt_socket_t socket, const struct q_g
}
#endif
-static int set_mc_options_transmit_ipv4 (ddsrt_socket_t socket, const struct q_globals *gv)
+static int set_mc_options_transmit_ipv4 (ddsrt_socket_t socket, const struct ddsi_domaingv *gv)
{
unsigned char ttl = (unsigned char) gv->config.multicast_ttl;
unsigned char loop;
@@ -319,7 +319,7 @@ static int set_mc_options_transmit_ipv4 (ddsrt_socket_t socket, const struct q_g
return 0;
}
-static int set_mc_options_transmit (ddsrt_socket_t socket, const struct q_globals *gv)
+static int set_mc_options_transmit (ddsrt_socket_t socket, const struct ddsi_domaingv *gv)
{
#if DDSRT_HAVE_IPV6
if (gv->config.transport_selector == TRANS_TCP6 || gv->config.transport_selector == TRANS_UDP6)
@@ -338,7 +338,7 @@ static int set_mc_options_transmit (ddsrt_socket_t socket, const struct q_global
}
}
-int make_socket (ddsrt_socket_t *sock, uint16_t port, bool stream, bool reuse, const struct q_globals *gv)
+int make_socket (ddsrt_socket_t *sock, uint16_t port, bool stream, bool reuse, const struct ddsi_domaingv *gv)
{
/* FIXME: this stuff has to move to the transports */
int rc = -2;
@@ -433,7 +433,7 @@ static int multicast_override(const char *ifname, const struct config *config)
#include
#endif
-int find_own_ip (struct q_globals *gv, const char *requested_address)
+int find_own_ip (struct ddsi_domaingv *gv, const char *requested_address)
{
const char *sep = " ";
char last_if_name[80] = "";
@@ -504,9 +504,9 @@ int find_own_ip (struct q_globals *gv, const char *requested_address)
else
#endif
{
- ddsi_ipaddr_to_loc(&gv->interfaces[gv->n_interfaces].loc, ifa->addr, gv->m_factory->m_kind);
+ ddsi_ipaddr_to_loc(gv->m_factory, &gv->interfaces[gv->n_interfaces].loc, ifa->addr, gv->m_factory->m_kind);
}
- ddsi_locator_to_string_no_port(gv, addrbuf, sizeof(addrbuf), &gv->interfaces[gv->n_interfaces].loc);
+ ddsi_locator_to_string_no_port(addrbuf, sizeof(addrbuf), &gv->interfaces[gv->n_interfaces].loc);
GVLOG (DDS_LC_CONFIG, " %s(", addrbuf);
if (!(ifa->flags & IFF_MULTICAST) && multicast_override (if_name, &gv->config))
@@ -568,7 +568,7 @@ int find_own_ip (struct q_globals *gv, const char *requested_address)
if (ifa->addr->sa_family == AF_INET && ifa->netmask)
{
- ddsi_ipaddr_to_loc(&gv->interfaces[gv->n_interfaces].netmask, ifa->netmask, gv->m_factory->m_kind);
+ ddsi_ipaddr_to_loc(gv->m_factory, &gv->interfaces[gv->n_interfaces].netmask, ifa->netmask, gv->m_factory->m_kind);
}
else
{
@@ -593,7 +593,7 @@ int find_own_ip (struct q_globals *gv, const char *requested_address)
const int idx = maxq_list[0];
char *names;
int p;
- ddsi_locator_to_string_no_port (gv, addrbuf, sizeof(addrbuf), &gv->interfaces[idx].loc);
+ ddsi_locator_to_string_no_port (addrbuf, sizeof(addrbuf), &gv->interfaces[idx].loc);
names = ddsrt_malloc (maxq_strlen + 1);
p = 0;
for (i = 0; i < maxq_count && (size_t) p < maxq_strlen; i++)
diff --git a/src/core/ddsi/src/q_pcap.c b/src/core/ddsi/src/q_pcap.c
index 1ac6117..42b2824 100644
--- a/src/core/ddsi/src/q_pcap.c
+++ b/src/core/ddsi/src/q_pcap.c
@@ -16,7 +16,7 @@
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_config.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_pcap.h"
@@ -127,7 +127,7 @@ static uint16_t calc_ipv4_checksum (const uint16_t *x)
return (uint16_t) ~s;
}
-void write_pcap_received (struct q_globals *gv, nn_wctime_t tstamp, const struct sockaddr_storage *src, const struct sockaddr_storage *dst, unsigned char *buf, size_t sz)
+void write_pcap_received (struct ddsi_domaingv *gv, nn_wctime_t tstamp, const struct sockaddr_storage *src, const struct sockaddr_storage *dst, unsigned char *buf, size_t sz)
{
if (gv->config.transport_selector == TRANS_UDP)
{
@@ -160,7 +160,7 @@ void write_pcap_received (struct q_globals *gv, nn_wctime_t tstamp, const struct
}
}
-void write_pcap_sent (struct q_globals *gv, nn_wctime_t tstamp, const struct sockaddr_storage *src, const ddsrt_msghdr_t *hdr, size_t sz)
+void write_pcap_sent (struct ddsi_domaingv *gv, nn_wctime_t tstamp, const struct sockaddr_storage *src, const ddsrt_msghdr_t *hdr, size_t sz)
{
if (gv->config.transport_selector == TRANS_UDP)
{
diff --git a/src/core/ddsi/src/q_qosmatch.c b/src/core/ddsi/src/q_qosmatch.c
index 721a010..7c951e1 100644
--- a/src/core/ddsi/src/q_qosmatch.c
+++ b/src/core/ddsi/src/q_qosmatch.c
@@ -13,7 +13,7 @@
#include
#include "dds/ddsi/q_time.h"
-#include "dds/ddsi/q_xqos.h"
+#include "dds/ddsi/ddsi_xqos.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_qosmatch.h"
diff --git a/src/core/ddsi/src/q_radmin.c b/src/core/ddsi/src/q_radmin.c
index 6265a0f..184838b 100644
--- a/src/core/ddsi/src/q_radmin.c
+++ b/src/core/ddsi/src/q_radmin.c
@@ -36,12 +36,12 @@
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_bitset.h"
#include "dds/ddsi/q_thread.h"
-#include "dds/ddsi/q_globals.h" /* for mattr, cattr */
+#include "dds/ddsi/ddsi_domaingv.h" /* for mattr, cattr */
/* OVERVIEW ------------------------------------------------------------
@@ -2453,7 +2453,7 @@ static enum dqueue_elem_kind dqueue_elem_kind (const struct nn_rsample_chain_ele
static uint32_t dqueue_thread (struct nn_dqueue *q)
{
struct thread_state1 * const ts1 = lookup_thread_state ();
- struct q_globals const * const gv = ddsrt_atomic_ldvoidp (&ts1->gv);
+ struct ddsi_domaingv const * const gv = ddsrt_atomic_ldvoidp (&ts1->gv);
nn_mtime_t next_thread_cputime = { 0 };
int keepgoing = 1;
ddsi_guid_t rdguid, *prdguid = NULL;
@@ -2540,7 +2540,7 @@ static uint32_t dqueue_thread (struct nn_dqueue *q)
return 0;
}
-struct nn_dqueue *nn_dqueue_new (const char *name, const struct q_globals *gv, uint32_t max_samples, nn_dqueue_handler_t handler, void *arg)
+struct nn_dqueue *nn_dqueue_new (const char *name, const struct ddsi_domaingv *gv, uint32_t max_samples, nn_dqueue_handler_t handler, void *arg)
{
struct nn_dqueue *q;
char *thrname;
diff --git a/src/core/ddsi/src/q_receive.c b/src/core/ddsi/src/q_receive.c
index 42f874d..7cc6f7b 100644
--- a/src/core/ddsi/src/q_receive.c
+++ b/src/core/ddsi/src/q_receive.c
@@ -22,13 +22,13 @@
#include "dds/ddsrt/static_assert.h"
#include "dds/ddsrt/avl.h"
-#include "dds__stream.h"
+#include "dds/ddsi/ddsi_cdrstream.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_plist.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_lat_estim.h"
@@ -45,9 +45,10 @@
#include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/q_receive.h"
#include "dds/ddsi/ddsi_rhc.h"
+#include "dds/ddsi/ddsi_deliver_locally.h"
#include "dds/ddsi/q_transmit.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_init.h"
#include "dds/ddsi/ddsi_tkmap.h"
#include "dds/ddsi/ddsi_mcgroup.h"
@@ -366,7 +367,7 @@ static int valid_Data (const struct receiver_state *rst, struct nn_rmsg *rmsg, D
ptr = (unsigned char *) msg + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->x.octetsToInlineQos) + msg->x.octetsToInlineQos;
if (msg->x.smhdr.flags & DATA_FLAG_INLINE_QOS)
{
- nn_plist_src_t src;
+ ddsi_plist_src_t src;
src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor;
src.encoding = (msg->x.smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE;
@@ -375,7 +376,7 @@ static int valid_Data (const struct receiver_state *rst, struct nn_rmsg *rmsg, D
src.factory = NULL;
src.logconfig = &rst->gv->logconfig;
/* just a quick scan, gathering only what we _really_ need */
- if ((ptr = nn_plist_quickscan (sampleinfo, rmsg, &src)) == NULL)
+ if ((ptr = ddsi_plist_quickscan (sampleinfo, rmsg, &src)) == NULL)
return 0;
}
else
@@ -470,7 +471,7 @@ static int valid_DataFrag (const struct receiver_state *rst, struct nn_rmsg *rms
ptr = (unsigned char *) msg + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->x.octetsToInlineQos) + msg->x.octetsToInlineQos;
if (msg->x.smhdr.flags & DATAFRAG_FLAG_INLINE_QOS)
{
- nn_plist_src_t src;
+ ddsi_plist_src_t src;
src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor;
src.encoding = (msg->x.smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE;
@@ -479,7 +480,7 @@ static int valid_DataFrag (const struct receiver_state *rst, struct nn_rmsg *rms
src.factory = NULL;
src.logconfig = &rst->gv->logconfig;
/* just a quick scan, gathering only what we _really_ need */
- if ((ptr = nn_plist_quickscan (sampleinfo, rmsg, &src)) == NULL)
+ if ((ptr = ddsi_plist_quickscan (sampleinfo, rmsg, &src)) == NULL)
return 0;
}
else
@@ -618,7 +619,7 @@ void nn_gap_info_init(struct nn_gap_info *gi)
memset(gi->gapbits, 0, sizeof(gi->gapbits));
}
-void nn_gap_info_update(struct q_globals *gv, struct nn_gap_info *gi, int64_t seqnr)
+void nn_gap_info_update(struct ddsi_domaingv *gv, struct nn_gap_info *gi, int64_t seqnr)
{
if (gi->gapstart == -1)
{
@@ -1184,7 +1185,8 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
dst.prefix = rst->dst_guid_prefix;
dst.entityid = msg->readerId;
- RSTTRACE ("HEARTBEAT(%s#%"PRId32":%"PRId64"..%"PRId64" ", msg->smhdr.flags & HEARTBEAT_FLAG_FINAL ? "F" : "", msg->count, firstseq, lastseq);
+ RSTTRACE ("HEARTBEAT(%s%s#%"PRId32":%"PRId64"..%"PRId64" ", msg->smhdr.flags & HEARTBEAT_FLAG_FINAL ? "F" : "",
+ msg->smhdr.flags & HEARTBEAT_FLAG_LIVELINESS ? "L" : "", msg->count, firstseq, lastseq);
if (!rst->forme)
{
@@ -1210,7 +1212,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
RSTTRACE (PGUIDFMT" -> "PGUIDFMT":", PGUID (src), PGUID (dst));
ddsrt_mutex_lock (&pwr->e.lock);
if (msg->smhdr.flags & HEARTBEAT_FLAG_LIVELINESS &&
- pwr->c.xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC &&
+ pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_AUTOMATIC &&
pwr->c.xqos->liveliness.lease_duration != T_NEVER)
{
if ((lease = ddsrt_atomic_ldvoidp (&pwr->c.proxypp->minl_man)) != NULL)
@@ -1862,12 +1864,30 @@ static struct ddsi_serdata *get_serdata (struct ddsi_sertopic const * const topi
return sd;
}
-static struct ddsi_serdata *new_sample_from_data (struct ddsi_tkmap_instance **tk1, struct q_globals *gv, const struct nn_rsample_info *sampleinfo, unsigned char data_smhdr_flags, const nn_plist_t *qos, const struct nn_rdata *fragchain, unsigned statusinfo, nn_wctime_t tstamp, struct ddsi_sertopic const * const topic)
+struct remote_sourceinfo {
+ const struct nn_rsample_info *sampleinfo;
+ unsigned char data_smhdr_flags;
+ const ddsi_plist_t *qos;
+ const struct nn_rdata *fragchain;
+ unsigned statusinfo;
+ nn_wctime_t tstamp;
+};
+
+static struct ddsi_serdata *remote_make_sample (struct ddsi_tkmap_instance **tk, struct ddsi_domaingv *gv, struct ddsi_sertopic const * const topic, void *vsourceinfo)
{
+ /* hopefully the compiler figures out that these are just aliases and doesn't reload them
+ unnecessarily from memory */
+ const struct remote_sourceinfo * __restrict si = vsourceinfo;
+ const struct nn_rsample_info * __restrict sampleinfo = si->sampleinfo;
+ const struct nn_rdata * __restrict fragchain = si->fragchain;
+ const uint32_t statusinfo = si->statusinfo;
+ const unsigned char data_smhdr_flags = si->data_smhdr_flags;
+ const nn_wctime_t tstamp = si->tstamp;
+ const ddsi_plist_t * __restrict qos = si->qos;
const char *failmsg = NULL;
struct ddsi_serdata *sample = NULL;
- if (statusinfo == 0)
+ if (si->statusinfo == 0)
{
/* normal write */
if (!(data_smhdr_flags & DATA_FLAG_DATAFLAG) || sampleinfo->size == 0)
@@ -1881,7 +1901,7 @@ static struct ddsi_serdata *new_sample_from_data (struct ddsi_tkmap_instance **t
"data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": write without proper payload (data_smhdr_flags 0x%x size %"PRIu32")\n",
sampleinfo->rst->vendor.id[0], sampleinfo->rst->vendor.id[1],
PGUID (guid), sampleinfo->seq,
- data_smhdr_flags, sampleinfo->size);
+ si->data_smhdr_flags, sampleinfo->size);
return NULL;
}
sample = get_serdata (topic, fragchain, sampleinfo->size, 0, statusinfo, tstamp);
@@ -1936,7 +1956,7 @@ static struct ddsi_serdata *new_sample_from_data (struct ddsi_tkmap_instance **t
}
else
{
- if ((*tk1 = ddsi_tkmap_lookup_instance_ref (gv->m_tkmap, sample)) == NULL)
+ if ((*tk = ddsi_tkmap_lookup_instance_ref (gv->m_tkmap, sample)) == NULL)
{
ddsi_serdata_unref (sample);
sample = NULL;
@@ -1960,12 +1980,6 @@ static struct ddsi_serdata *new_sample_from_data (struct ddsi_tkmap_instance **t
return sample;
}
-static void free_sample_after_store (struct q_globals *gv, struct ddsi_serdata *sample, struct ddsi_tkmap_instance *tk)
-{
- ddsi_tkmap_instance_unref (gv->m_tkmap, tk);
- ddsi_serdata_unref (sample);
-}
-
unsigned char normalize_data_datafrag_flags (const SubmessageHeader_t *smhdr)
{
switch ((SubmessageKind_t) smhdr->submessageId)
@@ -1987,35 +2001,58 @@ unsigned char normalize_data_datafrag_flags (const SubmessageHeader_t *smhdr)
}
}
-static struct reader *proxy_writer_first_in_sync_reader (struct proxy_writer *pwr, ddsrt_avl_iter_t *it)
+static struct reader *proxy_writer_first_in_sync_reader (struct entity_index *entity_index, struct entity_common *pwrcmn, ddsrt_avl_iter_t *it)
{
+ assert (pwrcmn->kind == EK_PROXY_WRITER);
+ struct proxy_writer *pwr = (struct proxy_writer *) pwrcmn;
struct pwr_rd_match *m;
struct reader *rd;
for (m = ddsrt_avl_iter_first (&pwr_readers_treedef, &pwr->readers, it); m != NULL; m = ddsrt_avl_iter_next (it))
- if (m->in_sync == PRMSS_SYNC && (rd = entidx_lookup_reader_guid (pwr->e.gv->entity_index, &m->rd_guid)) != NULL)
+ if (m->in_sync == PRMSS_SYNC && (rd = entidx_lookup_reader_guid (entity_index, &m->rd_guid)) != NULL)
return rd;
return NULL;
}
-static struct reader *proxy_writer_next_in_sync_reader (struct proxy_writer *pwr, ddsrt_avl_iter_t *it)
+static struct reader *proxy_writer_next_in_sync_reader (struct entity_index *entity_index, ddsrt_avl_iter_t *it)
{
struct pwr_rd_match *m;
struct reader *rd;
for (m = ddsrt_avl_iter_next (it); m != NULL; m = ddsrt_avl_iter_next (it))
- if (m->in_sync == PRMSS_SYNC && (rd = entidx_lookup_reader_guid (pwr->e.gv->entity_index, &m->rd_guid)) != NULL)
+ if (m->in_sync == PRMSS_SYNC && (rd = entidx_lookup_reader_guid (entity_index, &m->rd_guid)) != NULL)
return rd;
return NULL;
}
+static dds_return_t remote_on_delivery_failure_fastpath (struct entity_common *source_entity, bool source_entity_locked, struct local_reader_ary *fastpath_rdary, void *vsourceinfo)
+{
+ (void) vsourceinfo;
+ ddsrt_mutex_unlock (&fastpath_rdary->rdary_lock);
+ if (source_entity_locked)
+ ddsrt_mutex_unlock (&source_entity->lock);
+
+ dds_sleepfor (DDS_MSECS (10));
+
+ if (source_entity_locked)
+ ddsrt_mutex_lock (&source_entity->lock);
+ ddsrt_mutex_lock (&fastpath_rdary->rdary_lock);
+ return DDS_RETCODE_TRY_AGAIN;
+}
+
static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const struct nn_rdata *fragchain, const ddsi_guid_t *rdguid, int pwr_locked)
{
+ static const struct deliver_locally_ops deliver_locally_ops = {
+ .makesample = remote_make_sample,
+ .first_reader = proxy_writer_first_in_sync_reader,
+ .next_reader = proxy_writer_next_in_sync_reader,
+ .on_failure_fastpath = remote_on_delivery_failure_fastpath
+ };
struct receiver_state const * const rst = sampleinfo->rst;
- struct q_globals * const gv = rst->gv;
+ struct ddsi_domaingv * const gv = rst->gv;
struct proxy_writer * const pwr = sampleinfo->pwr;
unsigned statusinfo;
Data_DataFrag_common_t *msg;
unsigned char data_smhdr_flags;
- nn_plist_t qos;
+ ddsi_plist_t qos;
int need_keyhash;
if (pwr->ddsi2direct_cb)
@@ -2051,12 +2088,12 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
need_keyhash = (sampleinfo->size == 0 || (data_smhdr_flags & (DATA_FLAG_KEYFLAG | DATA_FLAG_DATAFLAG)) == 0);
if (!(sampleinfo->complex_qos || need_keyhash) || !(data_smhdr_flags & DATA_FLAG_INLINE_QOS))
{
- nn_plist_init_empty (&qos);
+ ddsi_plist_init_empty (&qos);
statusinfo = sampleinfo->statusinfo;
}
else
{
- nn_plist_src_t src;
+ ddsi_plist_src_t src;
size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos;
dds_return_t plist_ret;
src.protocol_version = rst->protocol_version;
@@ -2067,7 +2104,7 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
src.strict = NN_STRICT_P (gv->config);
src.factory = gv->m_factory;
src.logconfig = &gv->logconfig;
- if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH | PP_COHERENT_SET, 0, &src)) < 0)
+ if ((plist_ret = ddsi_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH | PP_COHERENT_SET, 0, &src)) < 0)
{
if (plist_ret != DDS_RETCODE_UNSUPPORTED)
GVWARNING ("data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
@@ -2082,109 +2119,23 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
struct ddsi_writer_info wrinfo;
ddsi_make_writer_info (&wrinfo, &pwr->e, pwr->c.xqos, statusinfo);
- if (rdguid == NULL)
- {
- /* FIXME: Retry loop, for re-delivery of rejected reliable samples. Is a
- temporary hack till throttling back of writer is implemented (with late
- acknowledgement of sample and nack). */
- retry:
- ddsrt_mutex_lock (&pwr->rdary.rdary_lock);
- if (pwr->rdary.fastpath_ok)
- {
- struct reader ** const rdary = pwr->rdary.rdary;
- if (rdary[0])
- {
- struct ddsi_serdata *payload;
- struct ddsi_tkmap_instance *tk;
- if ((payload = new_sample_from_data (&tk, gv, sampleinfo, data_smhdr_flags, &qos, fragchain, statusinfo, tstamp, rdary[0]->topic)) != NULL)
- {
- ETRACE (pwr, " => EVERYONE\n");
- uint32_t i = 0;
- do {
- if (!ddsi_rhc_store (rdary[i]->rhc, &wrinfo, payload, tk))
- {
- if (pwr_locked) ddsrt_mutex_unlock (&pwr->e.lock);
- ddsrt_mutex_unlock (&pwr->rdary.rdary_lock);
- /* It is painful to drop the sample, but there is no guarantee that the readers
- will still be there after unlocking; indeed, it is even possible that the
- topic definition got replaced in the meantime. Fortunately, this is in
- the midst of a FIXME for many other reasons. */
- free_sample_after_store (gv, payload, tk);
- dds_sleepfor (DDS_MSECS (10));
- if (pwr_locked) ddsrt_mutex_lock (&pwr->e.lock);
- goto retry;
- }
- } while (rdary[++i]);
- free_sample_after_store (gv, payload, tk);
- }
- }
- ddsrt_mutex_unlock (&pwr->rdary.rdary_lock);
- }
- else
- {
- /* When deleting, pwr is no longer accessible via the hash
- tables, and consequently, a reader may be deleted without
- it being possible to remove it from rdary. The primary
- reason rdary exists is to avoid locking the proxy writer
- but this is less of an issue when we are deleting it, so
- we fall back to using the GUIDs so that we can deliver all
- samples we received from it. As writer being deleted any
- reliable samples that are rejected are simply discarded. */
- ddsrt_avl_iter_t it;
- struct reader *rd;
- ddsrt_mutex_unlock (&pwr->rdary.rdary_lock);
- if (!pwr_locked) ddsrt_mutex_lock (&pwr->e.lock);
- if ((rd = proxy_writer_first_in_sync_reader (pwr, &it)) != NULL)
- {
- struct ddsi_serdata *payload;
- struct ddsi_tkmap_instance *tk;
- if ((payload = new_sample_from_data (&tk, gv, sampleinfo, data_smhdr_flags, &qos, fragchain, statusinfo, tstamp, rd->topic)) != NULL)
- {
- ETRACE (pwr, " =>");
- do {
- ETRACE (pwr, " "PGUIDFMT, PGUID (rd->e.guid));
- (void) ddsi_rhc_store (rd->rhc, &wrinfo, payload, tk);
- rd = proxy_writer_next_in_sync_reader (pwr, &it);
- } while (rd != NULL);
- free_sample_after_store (gv, payload, tk);
- ETRACE (pwr, "\n");
- }
- }
- if (!pwr_locked) ddsrt_mutex_unlock (&pwr->e.lock);
- }
-
- ddsrt_atomic_st32 (&pwr->next_deliv_seq_lowword, (uint32_t) (sampleinfo->seq + 1));
- }
+ struct remote_sourceinfo sourceinfo = {
+ .sampleinfo = sampleinfo,
+ .data_smhdr_flags = data_smhdr_flags,
+ .qos = &qos,
+ .fragchain = fragchain,
+ .statusinfo = statusinfo,
+ .tstamp = tstamp
+ };
+ if (rdguid)
+ (void) deliver_locally_one (gv, &pwr->e, pwr_locked != 0, rdguid, &wrinfo, &deliver_locally_ops, &sourceinfo);
else
{
- struct reader *rd = entidx_lookup_reader_guid (gv->entity_index, rdguid);
- if (rd != NULL)
- {
- struct ddsi_serdata *payload;
- struct ddsi_tkmap_instance *tk;
- if ((payload = new_sample_from_data (&tk, gv, sampleinfo, data_smhdr_flags, &qos, fragchain, statusinfo, tstamp, rd->topic)) != NULL)
- {
- ETRACE (pwr, " =>"PGUIDFMT"\n", PGUID (*rdguid));
- /* FIXME: why look up rd,pwr again? Their states remains valid while the thread stays
- "awake" (although a delete can be initiated), and blocking like this is a stopgap
- anyway -- quite possibly to abort once either is deleted */
- while (!ddsi_rhc_store (rd->rhc, &wrinfo, payload, tk))
- {
- if (pwr_locked) ddsrt_mutex_unlock (&pwr->e.lock);
- dds_sleepfor (DDS_MSECS (1));
- if (pwr_locked) ddsrt_mutex_lock (&pwr->e.lock);
- if (entidx_lookup_reader_guid (gv->entity_index, rdguid) == NULL ||
- entidx_lookup_proxy_writer_guid (gv->entity_index, &pwr->e.guid) == NULL)
- {
- /* give up when reader or proxy writer no longer accessible */
- break;
- }
- }
- free_sample_after_store (gv, payload, tk);
- }
- }
+ (void) deliver_locally_allinsync (gv, &pwr->e, pwr_locked != 0, &pwr->rdary, &wrinfo, &deliver_locally_ops, &sourceinfo);
+ ddsrt_atomic_st32 (&pwr->next_deliv_seq_lowword, (uint32_t) (sampleinfo->seq + 1));
}
- nn_plist_fini (&qos);
+
+ ddsi_plist_fini (&qos);
return 0;
}
@@ -2466,7 +2417,7 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
static int handle_SPDP (const struct nn_rsample_info *sampleinfo, struct nn_rdata *rdata)
{
- struct q_globals * const gv = sampleinfo->rst->gv;
+ struct ddsi_domaingv * const gv = sampleinfo->rst->gv;
struct nn_rsample *rsample;
struct nn_rsample_chain sc;
struct nn_rdata *fragchain;
@@ -2688,7 +2639,7 @@ static int handle_DataFrag (struct receiver_state *rst, nn_etime_t tnow, struct
return 1;
}
-static void malformed_packet_received_nosubmsg (const struct q_globals *gv, const unsigned char * msg, ssize_t len, const char *state, nn_vendorid_t vendorid
+static void malformed_packet_received_nosubmsg (const struct ddsi_domaingv *gv, const unsigned char * msg, ssize_t len, const char *state, nn_vendorid_t vendorid
)
{
char tmp[1024];
@@ -2705,7 +2656,7 @@ static void malformed_packet_received_nosubmsg (const struct q_globals *gv, cons
GVWARNING ("%s\n", tmp);
}
-static void malformed_packet_received (const struct q_globals *gv, const unsigned char *msg, const unsigned char *submsg, size_t len, const char *state, SubmessageKind_t smkind, nn_vendorid_t vendorid)
+static void malformed_packet_received (const struct ddsi_domaingv *gv, const unsigned char *msg, const unsigned char *submsg, size_t len, const char *state, SubmessageKind_t smkind, nn_vendorid_t vendorid)
{
char tmp[1024];
size_t i, pos, smsize;
@@ -2820,7 +2771,7 @@ static struct receiver_state *rst_cow_if_needed (int *rst_live, struct nn_rmsg *
static int handle_submsg_sequence
(
struct thread_state1 * const ts1,
- struct q_globals *gv,
+ struct ddsi_domaingv *gv,
ddsi_tran_conn_t conn,
const nn_locator_t *srcloc,
nn_wctime_t tnowWC,
@@ -3154,7 +3105,7 @@ malformed_asleep:
return -1;
}
-static bool do_packet (struct thread_state1 * const ts1, struct q_globals *gv, ddsi_tran_conn_t conn, const ddsi_guid_prefix_t *guidprefix, struct nn_rbufpool *rbpool)
+static bool do_packet (struct thread_state1 * const ts1, struct ddsi_domaingv *gv, ddsi_tran_conn_t conn, const ddsi_guid_prefix_t *guidprefix, struct nn_rbufpool *rbpool)
{
/* UDP max packet size is 64kB */
@@ -3261,7 +3212,7 @@ static bool do_packet (struct thread_state1 * const ts1, struct q_globals *gv, d
if (gv->logconfig.c.mask & DDS_LC_TRACE)
{
char addrstr[DDSI_LOCSTRLEN];
- ddsi_locator_to_string(gv, addrstr, sizeof(addrstr), &srcloc);
+ ddsi_locator_to_string(addrstr, sizeof(addrstr), &srcloc);
GVTRACE ("HDR(%"PRIx32":%"PRIx32":%"PRIx32" vendor %d.%d) len %lu from %s\n",
PGUIDPREFIX (hdr->guid_prefix), hdr->vendorid.id[0], hdr->vendorid.id[1], (unsigned long) sz, addrstr);
}
@@ -3359,7 +3310,7 @@ static void local_participant_set_fini (struct local_participant_set *lps)
ddsrt_free (lps->ps);
}
-static void rebuild_local_participant_set (struct thread_state1 * const ts1, struct q_globals *gv, struct local_participant_set *lps)
+static void rebuild_local_participant_set (struct thread_state1 * const ts1, struct ddsi_domaingv *gv, struct local_participant_set *lps)
{
struct entidx_enum_participant est;
struct participant *pp;
@@ -3427,7 +3378,7 @@ static void rebuild_local_participant_set (struct thread_state1 * const ts1, str
uint32_t listen_thread (struct ddsi_tran_listener *listener)
{
- struct q_globals *gv = listener->m_base.gv;
+ struct ddsi_domaingv *gv = listener->m_base.gv;
ddsi_tran_conn_t conn;
while (ddsrt_atomic_ld32 (&gv->rtps_keepgoing))
@@ -3450,7 +3401,7 @@ static int recv_thread_waitset_add_conn (os_sockWaitset ws, ddsi_tran_conn_t con
return 0;
else
{
- struct q_globals *gv = conn->m_base.gv;
+ struct ddsi_domaingv *gv = conn->m_base.gv;
for (uint32_t i = 0; i < gv->n_recv_threads; i++)
if (gv->recv_threads[i].arg.mode == RTM_SINGLE && gv->recv_threads[i].arg.u.single.conn == conn)
return 0;
@@ -3469,7 +3420,7 @@ struct local_deaf_state {
nn_mtime_t tnext;
};
-static int check_and_handle_deafness_recover (struct q_globals *gv, struct local_deaf_state *st, unsigned num_fixed_uc)
+static int check_and_handle_deafness_recover (struct ddsi_domaingv *gv, struct local_deaf_state *st, unsigned num_fixed_uc)
{
int rebuildws = 0;
if (now_mt().v < st->tnext.v)
@@ -3524,7 +3475,7 @@ error:
return rebuildws;
}
-static int check_and_handle_deafness (struct q_globals *gv, struct local_deaf_state *st, unsigned num_fixed_uc)
+static int check_and_handle_deafness (struct ddsi_domaingv *gv, struct local_deaf_state *st, unsigned num_fixed_uc)
{
const int gv_deaf = gv->deaf;
assert (gv_deaf == 0 || gv_deaf == 1);
@@ -3549,7 +3500,7 @@ static int check_and_handle_deafness (struct q_globals *gv, struct local_deaf_st
}
}
-void trigger_recv_threads (const struct q_globals *gv)
+void trigger_recv_threads (const struct ddsi_domaingv *gv)
{
for (uint32_t i = 0; i < gv->n_recv_threads; i++)
{
@@ -3564,7 +3515,7 @@ void trigger_recv_threads (const struct q_globals *gv)
ddsrt_iovec_t iov;
iov.iov_base = &dummy;
iov.iov_len = 1;
- GVTRACE ("trigger_recv_threads: %d single %s\n", i, ddsi_locator_to_string (gv, buf, sizeof (buf), dst));
+ GVTRACE ("trigger_recv_threads: %d single %s\n", i, ddsi_locator_to_string (buf, sizeof (buf), dst));
ddsi_conn_write (gv->data_conn_uc, dst, 1, &iov, 0);
break;
}
@@ -3581,7 +3532,7 @@ uint32_t recv_thread (void *vrecv_thread_arg)
{
struct thread_state1 * const ts1 = lookup_thread_state ();
struct recv_thread_arg *recv_thread_arg = vrecv_thread_arg;
- struct q_globals * const gv = recv_thread_arg->gv;
+ struct ddsi_domaingv * const gv = recv_thread_arg->gv;
struct nn_rbufpool *rbpool = recv_thread_arg->rbpool;
os_sockWaitset waitset = recv_thread_arg->mode == RTM_MANY ? recv_thread_arg->u.many.ws : NULL;
nn_mtime_t next_thread_cputime = { 0 };
diff --git a/src/core/ddsi/src/q_thread.c b/src/core/ddsi/src/q_thread.c
index 1c0c144..a8190fa 100644
--- a/src/core/ddsi/src/q_thread.c
+++ b/src/core/ddsi/src/q_thread.c
@@ -25,7 +25,7 @@
#include "dds/ddsi/ddsi_threadmon.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_config.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/sysdeps.h"
struct thread_states thread_states;
@@ -39,12 +39,12 @@ extern inline struct thread_state1 *lookup_thread_state (void);
extern inline bool thread_is_asleep (void);
extern inline bool thread_is_awake (void);
extern inline void thread_state_asleep (struct thread_state1 *ts1);
-extern inline void thread_state_awake (struct thread_state1 *ts1, const struct q_globals *gv);
+extern inline void thread_state_awake (struct thread_state1 *ts1, const struct ddsi_domaingv *gv);
extern inline void thread_state_awake_domain_ok (struct thread_state1 *ts1);
extern inline void thread_state_awake_fixed_domain (struct thread_state1 *ts1);
extern inline void thread_state_awake_to_awake_no_nest (struct thread_state1 *ts1);
-static struct thread_state1 *init_thread_state (const char *tname, const struct q_globals *gv, enum thread_state state);
+static struct thread_state1 *init_thread_state (const char *tname, const struct ddsi_domaingv *gv, enum thread_state state);
static void reap_thread_state (struct thread_state1 *ts1);
static void *ddsrt_malloc_aligned_cacheline (size_t size)
@@ -213,7 +213,7 @@ static uint32_t create_thread_wrapper (void *ptr)
{
uint32_t ret;
struct thread_context *ctx = ptr;
- struct q_globals const * const gv = ddsrt_atomic_ldvoidp (&ctx->self->gv);
+ struct ddsi_domaingv const * const gv = ddsrt_atomic_ldvoidp (&ctx->self->gv);
if (gv)
GVTRACE ("started new thread %"PRIdTID": %s\n", ddsrt_gettid (), ctx->self->name);
ctx->self->tid = ddsrt_thread_self ();
@@ -240,7 +240,7 @@ const struct config_thread_properties_listelem *lookup_thread_properties (const
return e;
}
-static struct thread_state1 *init_thread_state (const char *tname, const struct q_globals *gv, enum thread_state state)
+static struct thread_state1 *init_thread_state (const char *tname, const struct ddsi_domaingv *gv, enum thread_state state)
{
int cand;
struct thread_state1 *ts;
@@ -249,7 +249,7 @@ static struct thread_state1 *init_thread_state (const char *tname, const struct
return NULL;
ts = &thread_states.ts[cand];
- ddsrt_atomic_stvoidp (&ts->gv, (struct q_globals *) gv);
+ ddsrt_atomic_stvoidp (&ts->gv, (struct ddsi_domaingv *) gv);
assert (vtime_asleep_p (ddsrt_atomic_ld32 (&ts->vtime)));
(void) ddsrt_strlcpy (ts->name, tname, sizeof (ts->name));
ts->state = state;
@@ -257,7 +257,7 @@ static struct thread_state1 *init_thread_state (const char *tname, const struct
return ts;
}
-static dds_return_t create_thread_int (struct thread_state1 **ts1, const struct q_globals *gv, struct config_thread_properties_listelem const * const tprops, const char *name, uint32_t (*f) (void *arg), void *arg)
+static dds_return_t create_thread_int (struct thread_state1 **ts1, const struct ddsi_domaingv *gv, struct config_thread_properties_listelem const * const tprops, const char *name, uint32_t (*f) (void *arg), void *arg)
{
ddsrt_threadattr_t tattr;
ddsrt_thread_t tid;
@@ -308,7 +308,7 @@ dds_return_t create_thread_with_properties (struct thread_state1 **ts1, struct c
return create_thread_int (ts1, NULL, tprops, name, f, arg);
}
-dds_return_t create_thread (struct thread_state1 **ts1, const struct q_globals *gv, const char *name, uint32_t (*f) (void *arg), void *arg)
+dds_return_t create_thread (struct thread_state1 **ts1, const struct ddsi_domaingv *gv, const char *name, uint32_t (*f) (void *arg), void *arg)
{
struct config_thread_properties_listelem const * const tprops = lookup_thread_properties (&gv->config, name);
return create_thread_int (ts1, gv, tprops, name, f, arg);
@@ -337,7 +337,7 @@ void reset_thread_state (struct thread_state1 *ts1)
reap_thread_state (ts1);
}
-void log_stack_traces (const struct ddsrt_log_cfg *logcfg, const struct q_globals *gv)
+void log_stack_traces (const struct ddsrt_log_cfg *logcfg, const struct ddsi_domaingv *gv)
{
for (uint32_t i = 0; i < thread_states.nthreads; i++)
{
diff --git a/src/core/ddsi/src/q_transmit.c b/src/core/ddsi/src/q_transmit.c
index b229713..063d2a1 100644
--- a/src/core/ddsi/src/q_transmit.c
+++ b/src/core/ddsi/src/q_transmit.c
@@ -28,12 +28,13 @@
#include "dds/ddsi/q_xevent.h"
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_config.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_hbcontrol.h"
#include "dds/ddsi/q_receive.h"
+#include "dds/ddsi/q_lease.h"
#include "dds/ddsi/ddsi_tkmap.h"
#include "dds/ddsi/ddsi_serdata.h"
#include "dds/ddsi/ddsi_sertopic.h"
@@ -81,7 +82,7 @@ static void writer_hbcontrol_note_hb (struct writer *wr, nn_mtime_t tnow, int an
int64_t writer_hbcontrol_intv (const struct writer *wr, const struct whc_state *whcst, UNUSED_ARG (nn_mtime_t tnow))
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct hbcontrol const * const hbc = &wr->hbcontrol;
int64_t ret = gv->config.const_hb_intv_sched;
size_t n_unacked;
@@ -107,8 +108,8 @@ int64_t writer_hbcontrol_intv (const struct writer *wr, const struct whc_state *
void writer_hbcontrol_note_asyncwrite (struct writer *wr, nn_mtime_t tnow)
{
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct hbcontrol * const hbc = &wr->hbcontrol;
- struct q_globals const * const gv = wr->e.gv;
nn_mtime_t tnext;
/* Reset number of heartbeats since last write: that means the
@@ -136,7 +137,7 @@ int writer_hbcontrol_must_send (const struct writer *wr, const struct whc_state
struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const struct whc_state *whcst, nn_mtime_t tnow, int hbansreq, int issync)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg *msg;
const ddsi_guid_t *prd_guid;
@@ -235,7 +236,7 @@ struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const stru
static int writer_hbcontrol_ack_required_generic (const struct writer *wr, const struct whc_state *whcst, nn_mtime_t tlast, nn_mtime_t tnow, int piggyback)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct hbcontrol const * const hbc = &wr->hbcontrol;
const int64_t hb_intv_ack = gv->config.const_hb_intv_sched;
assert(wr->heartbeat_xevent != NULL && whcst != NULL);
@@ -327,7 +328,7 @@ struct nn_xmsg *writer_hbcontrol_piggyback (struct writer *wr, const struct whc_
#ifdef DDSI_INCLUDE_SECURITY
struct nn_xmsg *writer_hbcontrol_p2p(struct writer *wr, const struct whc_state *whcst, int hbansreq, struct proxy_reader *prd)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg *msg;
ASSERT_MUTEX_HELD (&wr->e.lock);
@@ -367,7 +368,7 @@ struct nn_xmsg *writer_hbcontrol_p2p(struct writer *wr, const struct whc_state *
void add_Heartbeat (struct nn_xmsg *msg, struct writer *wr, const struct whc_state *whcst, int hbansreq, int hbliveliness, ddsi_entityid_t dst, int issync)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg_marker sm_marker;
Heartbeat_t * hb;
seqno_t max = 0, min = 1;
@@ -443,7 +444,7 @@ static dds_return_t create_fragment_message_simple (struct writer *wr, seqno_t s
/* actual expected_inline_qos_size is typically 0, but always claiming 32 bytes won't make
a difference, so no point in being precise */
const size_t expected_inline_qos_size = /* statusinfo */ 8 + /* keyhash */ 20 + /* sentinel */ 4;
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg_marker sm_marker;
unsigned char contentflag = 0;
Data_t *data;
@@ -512,7 +513,7 @@ static dds_return_t create_fragment_message_simple (struct writer *wr, seqno_t s
return 0;
}
-dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd, struct nn_xmsg **pmsg, int isnew)
+dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const struct ddsi_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd, struct nn_xmsg **pmsg, int isnew)
{
/* We always fragment into FRAGMENT_SIZEd fragments, which are near
the smallest allowed fragment size & can't be bothered (yet) to
@@ -528,7 +529,7 @@ dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const stru
actual expected_inline_qos_size is typically 0, but always claiming 32 bytes won't make
a difference, so no point in being precise */
const size_t expected_inline_qos_size = /* statusinfo */ 8 + /* keyhash */ 20 + /* sentinel */ 4;
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg_marker sm_marker;
void *sm;
Data_DataFrag_common_t *ddcmn;
@@ -696,7 +697,7 @@ dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const stru
static void create_HeartbeatFrag (struct writer *wr, seqno_t seq, unsigned fragnum, struct proxy_reader *prd, struct nn_xmsg **pmsg)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg_marker sm_marker;
HeartbeatFrag_t *hbf;
ASSERT_MUTEX_HELD (&wr->e.lock);
@@ -740,11 +741,13 @@ static void create_HeartbeatFrag (struct writer *wr, seqno_t seq, unsigned fragn
}
}
-dds_return_t write_hb_liveliness (struct q_globals * const gv, struct ddsi_guid *wr_guid, struct nn_xpack *xp)
+dds_return_t write_hb_liveliness (struct ddsi_domaingv * const gv, struct ddsi_guid *wr_guid, struct nn_xpack *xp)
{
struct nn_xmsg *msg = NULL;
struct whc_state whcst;
struct thread_state1 * const ts1 = lookup_thread_state ();
+ struct lease *lease;
+
thread_state_awake (ts1, gv);
struct writer *wr = entidx_lookup_writer_guid (gv->entity_index, wr_guid);
if (wr == NULL)
@@ -752,6 +755,12 @@ dds_return_t write_hb_liveliness (struct q_globals * const gv, struct ddsi_guid
GVTRACE ("write_hb_liveliness("PGUIDFMT") - writer not found\n", PGUID (*wr_guid));
return DDS_RETCODE_PRECONDITION_NOT_MET;
}
+
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT && ((lease = ddsrt_atomic_ldvoidp (&wr->c.pp->minl_man)) != NULL))
+ lease_renew (lease, now_et());
+ else if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC && wr->lease != NULL)
+ lease_renew (wr->lease, now_et());
+
if ((msg = nn_xmsg_new (gv->xmsgpool, &wr->e.guid, wr->c.pp, sizeof (InfoTS_t) + sizeof (Heartbeat_t), NN_XMSG_KIND_CONTROL)) == NULL)
return DDS_RETCODE_OUT_OF_RESOURCES;
ddsrt_mutex_lock (&wr->e.lock);
@@ -791,7 +800,7 @@ static int must_skip_frag (const char *frags_to_skip, unsigned frag)
}
#endif
-static void transmit_sample_lgmsg_unlocked (struct nn_xpack *xp, struct writer *wr, const struct whc_state *whcst, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew, uint32_t nfrags)
+static void transmit_sample_lgmsg_unlocked (struct nn_xpack *xp, struct writer *wr, const struct whc_state *whcst, seqno_t seq, const struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew, uint32_t nfrags)
{
#if 0
const char *frags_to_skip = getenv ("SKIPFRAGS");
@@ -848,10 +857,10 @@ static void transmit_sample_lgmsg_unlocked (struct nn_xpack *xp, struct writer *
}
}
-static void transmit_sample_unlocks_wr (struct nn_xpack *xp, struct writer *wr, const struct whc_state *whcst, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew)
+static void transmit_sample_unlocks_wr (struct nn_xpack *xp, struct writer *wr, const struct whc_state *whcst, seqno_t seq, const struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew)
{
/* on entry: &wr->e.lock held; on exit: lock no longer held */
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
struct nn_xmsg *fmsg;
uint32_t sz;
assert(xp);
@@ -891,9 +900,9 @@ static void transmit_sample_unlocks_wr (struct nn_xpack *xp, struct writer *wr,
}
}
-int enqueue_sample_wrlock_held (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew)
+int enqueue_sample_wrlock_held (struct writer *wr, seqno_t seq, const struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
uint32_t i, sz, nfrags;
int enqueued = 1;
@@ -946,10 +955,11 @@ int enqueue_sample_wrlock_held (struct writer *wr, seqno_t seq, const struct nn_
return enqueued ? 0 : -1;
}
-static int insert_sample_in_whc (struct writer *wr, seqno_t seq, struct nn_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk)
+static int insert_sample_in_whc (struct writer *wr, seqno_t seq, struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk)
{
/* returns: < 0 on error, 0 if no need to insert in whc, > 0 if inserted */
- int do_insert, insres, res;
+ int insres, res = 0;
+ bool wr_deadline = false;
ASSERT_MUTEX_HELD (&wr->e.lock);
@@ -970,17 +980,15 @@ static int insert_sample_in_whc (struct writer *wr, seqno_t seq, struct nn_plist
}
assert (wr->reliable || have_reliable_subs (wr) == 0);
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+ /* If deadline missed duration is not infinite, the sample is inserted in
+ the whc so that the instance is created (or renewed) in the whc and the deadline
+ missed event is registered. The sample is removed immediately after inserting it
+ as we don't want to store it. */
+ wr_deadline = wr->xqos->deadline.deadline != DDS_INFINITY;
+#endif
- if (wr->reliable && have_reliable_subs (wr))
- do_insert = 1;
- else if (wr->handle_as_transient_local)
- do_insert = 1;
- else
- do_insert = 0;
-
- if (!do_insert)
- res = 0;
- else
+ if ((wr->reliable && have_reliable_subs (wr)) || wr_deadline || wr->handle_as_transient_local)
{
nn_mtime_t exp = NN_MTIME_NEVER;
#ifdef DDSI_INCLUDE_LIFESPAN
@@ -991,6 +999,20 @@ static int insert_sample_in_whc (struct writer *wr, seqno_t seq, struct nn_plist
exp = add_duration_to_mtime(serdata->twrite, wr->xqos->lifespan.duration);
#endif
res = ((insres = whc_insert (wr->whc, writer_max_drop_seq (wr), seq, exp, plist, serdata, tk)) < 0) ? insres : 1;
+
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+ if (!(wr->reliable && have_reliable_subs (wr)) && !wr->handle_as_transient_local)
+ {
+ /* Sample was inserted only because writer has deadline, so we'll remove the sample from whc */
+ struct whc_node *deferred_free_list = NULL;
+ struct whc_state whcst;
+ uint32_t n = whc_remove_acked_messages (wr->whc, seq, &whcst, &deferred_free_list);
+ (void)n;
+ assert (n <= 1);
+ assert (whcst.min_seq == -1 && whcst.max_seq == -1);
+ whc_free_deferred_free_list (wr->whc, deferred_free_list);
+ }
+#endif
}
#ifndef NDEBUG
@@ -1047,7 +1069,7 @@ static dds_return_t throttle_writer (struct thread_state1 * const ts1, struct nn
resent to them, until a ACKNACK is received from that
reader. This implicitly clears the whc and unblocks the
writer. */
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
dds_return_t result = DDS_RETCODE_OK;
nn_mtime_t tnow = now_mt ();
const nn_mtime_t abstimeout = add_duration_to_mtime (tnow, wr->xqos->reliability.max_blocking_time);
@@ -1118,7 +1140,7 @@ static dds_return_t throttle_writer (struct thread_state1 * const ts1, struct nn
static int maybe_grow_whc (struct writer *wr)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
if (!wr->retransmitting && gv->config.whc_adaptive && wr->whc_high < gv->config.whc_highwater_mark)
{
nn_etime_t tnow = now_et();
@@ -1134,9 +1156,9 @@ static int maybe_grow_whc (struct writer *wr)
return 0;
}
-int write_sample_p2p_wrlock_held(struct writer *wr, seqno_t seq, struct nn_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk, struct proxy_reader *prd)
+int write_sample_p2p_wrlock_held(struct writer *wr, seqno_t seq, struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk, struct proxy_reader *prd)
{
- struct q_globals * const gv = wr->e.gv;
+ struct ddsi_domaingv * const gv = wr->e.gv;
int r;
nn_mtime_t tnow;
int rexmit = 1;
@@ -1193,12 +1215,13 @@ int write_sample_p2p_wrlock_held(struct writer *wr, seqno_t seq, struct nn_plist
return r;
}
-static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr, struct nn_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk, int end_of_txn, int gc_allowed)
+static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr, struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk, int end_of_txn, int gc_allowed)
{
- struct q_globals const * const gv = wr->e.gv;
+ struct ddsi_domaingv const * const gv = wr->e.gv;
int r;
seqno_t seq;
nn_mtime_t tnow;
+ struct lease *lease;
/* If GC not allowed, we must be sure to never block when writing. That is only the case for (true, aggressive) KEEP_LAST writers, and also only if there is no limit to how much unacknowledged data the WHC may contain. */
assert (gc_allowed || (wr->xqos->history.kind == DDS_HISTORY_KEEP_LAST && wr->whc_low == INT32_MAX));
@@ -1220,8 +1243,16 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
goto drop;
}
+ if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT && ((lease = ddsrt_atomic_ldvoidp (&wr->c.pp->minl_man)) != NULL))
+ lease_renew (lease, now_et());
+ else if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC && wr->lease != NULL)
+ lease_renew (wr->lease, now_et());
+
ddsrt_mutex_lock (&wr->e.lock);
+ if (!wr->alive)
+ writer_set_alive_may_unlock (wr, true);
+
if (end_of_txn)
{
wr->cs_seq = 0;
@@ -1271,7 +1302,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
if (plist == NULL)
{
plist = ddsrt_malloc (sizeof (*plist));
- nn_plist_init_empty (plist);
+ ddsi_plist_init_empty (plist);
}
assert (!(plist->present & PP_COHERENT_SET));
plist->present |= PP_COHERENT_SET;
@@ -1284,7 +1315,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
ddsrt_mutex_unlock (&wr->e.lock);
if (plist != NULL)
{
- nn_plist_fini (plist);
+ ddsi_plist_fini (plist);
ddsrt_free (plist);
}
}
@@ -1300,7 +1331,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
ddsrt_mutex_unlock (&wr->e.lock);
if (plist != NULL)
{
- nn_plist_fini (plist);
+ ddsi_plist_fini (plist);
ddsrt_free (plist);
}
}
@@ -1315,14 +1346,14 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
* creating the message, the WHC will free the plist (if any). Currently,
* plist's are only used for coherent sets, which is assumed to be rare,
* which in turn means that an extra copy doesn't hurt too badly ... */
- nn_plist_t plist_stk, *plist_copy;
+ ddsi_plist_t plist_stk, *plist_copy;
struct whc_state whcst, *whcstptr;
if (plist == NULL)
plist_copy = NULL;
else
{
plist_copy = &plist_stk;
- nn_plist_copy (plist_copy, plist);
+ ddsi_plist_copy (plist_copy, plist);
}
if (wr->heartbeat_xevent == NULL)
whcstptr = NULL;
@@ -1333,7 +1364,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
}
transmit_sample_unlocks_wr (xp, wr, whcstptr, seq, plist_copy, serdata, NULL, 1);
if (plist_copy)
- nn_plist_fini (plist_copy);
+ ddsi_plist_fini (plist_copy);
}
else
{
@@ -1346,7 +1377,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
/* If not actually inserted, WHC didn't take ownership of plist */
if (r == 0 && plist != NULL)
{
- nn_plist_fini (plist);
+ ddsi_plist_fini (plist);
ddsrt_free (plist);
}
}
diff --git a/src/core/ddsi/src/q_whc.c b/src/core/ddsi/src/q_whc.c
index 0a7d1c8..457045d 100644
--- a/src/core/ddsi/src/q_whc.c
+++ b/src/core/ddsi/src/q_whc.c
@@ -21,7 +21,7 @@ extern inline void whc_return_sample (struct whc *whc, struct whc_borrowed_sampl
extern inline void whc_sample_iter_init (const struct whc *whc, struct whc_sample_iter *it);
extern inline bool whc_sample_iter_borrow_next (struct whc_sample_iter *it, struct whc_borrowed_sample *sample);
extern inline void whc_free (struct whc *whc);
-extern int whc_insert (struct whc *whc, seqno_t max_drop_seq, seqno_t seq, nn_mtime_t exp, struct nn_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk);
+extern int whc_insert (struct whc *whc, seqno_t max_drop_seq, seqno_t seq, nn_mtime_t exp, struct ddsi_plist *plist, struct ddsi_serdata *serdata, struct ddsi_tkmap_instance *tk);
extern unsigned whc_downgrade_to_volatile (struct whc *whc, struct whc_state *st);
extern unsigned whc_remove_acked_messages (struct whc *whc, seqno_t max_drop_seq, struct whc_state *whcst, struct whc_node **deferred_free_list);
extern void whc_free_deferred_free_list (struct whc *whc, struct whc_node *deferred_free_list);
diff --git a/src/core/ddsi/src/q_xevent.c b/src/core/ddsi/src/q_xevent.c
index 3c852d5..41b91a7 100644
--- a/src/core/ddsi/src/q_xevent.c
+++ b/src/core/ddsi/src/q_xevent.c
@@ -27,7 +27,7 @@
#include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_unused.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/ddsi_entity_index.h"
#include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_bswap.h"
@@ -145,7 +145,7 @@ struct xeventq {
size_t max_queued_rexmit_msgs;
int terminate;
struct thread_state1 *ts;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
ddsrt_mutex_t lock;
ddsrt_cond_t cond;
ddsi_tran_conn_t tev_conn;
@@ -343,14 +343,20 @@ void delete_xevent_callback (struct xevent *ev)
struct xeventq *evq = ev->evq;
assert (ev->kind == XEVK_CALLBACK);
ddsrt_mutex_lock (&evq->lock);
- if (ev->tsched.v != T_NEVER)
+ /* wait until neither scheduled nor executing; loop in case the callback reschedules the event */
+ while (ev->tsched.v != T_NEVER || ev->u.callback.executing)
{
- assert (ev->tsched.v != TSCHED_DELETE);
- ddsrt_fibheap_delete (&evq_xevents_fhdef, &evq->xevents, ev);
- ev->tsched.v = TSCHED_DELETE;
+ if (ev->tsched.v != T_NEVER)
+ {
+ assert (ev->tsched.v != TSCHED_DELETE);
+ ddsrt_fibheap_delete (&evq_xevents_fhdef, &evq->xevents, ev);
+ ev->tsched.v = T_NEVER;
+ }
+ if (ev->u.callback.executing)
+ {
+ ddsrt_cond_wait (&evq->cond, &evq->lock);
+ }
}
- while (ev->u.callback.executing)
- ddsrt_cond_wait (&evq->cond, &evq->lock);
ddsrt_mutex_unlock (&evq->lock);
free_xevent (evq, ev);
}
@@ -656,7 +662,7 @@ static void send_heartbeat_to_all_readers(struct nn_xpack *xp, struct xevent *ev
static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mtime_t tnow /* monotonic */)
{
- struct q_globals const * const gv = ev->evq->gv;
+ struct ddsi_domaingv const * const gv = ev->evq->gv;
struct nn_xmsg *msg;
struct writer *wr;
nn_mtime_t t_next;
@@ -946,7 +952,7 @@ static void handle_xevk_acknack (struct nn_xpack *xp, struct xevent *ev, nn_mtim
A little snag is that the defragmenter can throw out partial samples in
favour of others, so MUST ensure that the defragmenter won't start
threshing and fail to make progress! */
- struct q_globals *gv = ev->evq->gv;
+ struct ddsi_domaingv *gv = ev->evq->gv;
struct proxy_writer *pwr;
struct nn_xmsg *msg;
struct pwr_rd_match *rwn;
@@ -1049,16 +1055,16 @@ static bool resend_spdp_sample_by_guid_key (struct writer *wr, const ddsi_guid_t
/* Look up data in (transient-local) WHC by key value -- FIXME: clearly
a slightly more efficient and elegant way of looking up the key value
is to be preferred */
- struct q_globals *gv = wr->e.gv;
+ struct ddsi_domaingv *gv = wr->e.gv;
bool sample_found;
- nn_plist_t ps;
- nn_plist_init_empty (&ps);
+ ddsi_plist_t ps;
+ ddsi_plist_init_empty (&ps);
ps.present |= PP_PARTICIPANT_GUID;
ps.participant_guid = *guid;
struct nn_xmsg *mpayload = nn_xmsg_new (gv->xmsgpool, guid, wr->c.pp, 0, NN_XMSG_KIND_DATA);
- nn_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
+ ddsi_plist_addtomsg (mpayload, &ps, ~(uint64_t)0, ~(uint64_t)0);
nn_xmsg_addpar_sentinel (mpayload);
- nn_plist_fini (&ps);
+ ddsi_plist_fini (&ps);
struct ddsi_plist_sample plist_sample;
nn_xmsg_payload_to_plistsample (&plist_sample, PID_PARTICIPANT_GUID, mpayload);
struct ddsi_serdata *sd = ddsi_serdata_from_sample (gv->plist_topic, SDK_KEY, &plist_sample);
@@ -1085,7 +1091,7 @@ static bool resend_spdp_sample_by_guid_key (struct writer *wr, const ddsi_guid_t
static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *ev, nn_mtime_t tnow)
{
/* Like the writer pointer in the heartbeat event, the participant pointer in the spdp event is assumed valid. */
- struct q_globals *gv = ev->evq->gv;
+ struct ddsi_domaingv *gv = ev->evq->gv;
struct participant *pp;
struct proxy_reader *prd;
struct writer *spdp_wr;
@@ -1199,7 +1205,7 @@ static void handle_xevk_spdp (UNUSED_ARG (struct nn_xpack *xp), struct xevent *e
static void handle_xevk_pmd_update (struct thread_state1 * const ts1, struct nn_xpack *xp, struct xevent *ev, nn_mtime_t tnow)
{
- struct q_globals * const gv = ev->evq->gv;
+ struct ddsi_domaingv * const gv = ev->evq->gv;
struct participant *pp;
dds_duration_t intv;
nn_mtime_t tnext;
@@ -1234,7 +1240,7 @@ static void handle_xevk_pmd_update (struct thread_state1 * const ts1, struct nn_
static void handle_xevk_delete_writer (UNUSED_ARG (struct nn_xpack *xp), struct xevent *ev, UNUSED_ARG (nn_mtime_t tnow))
{
/* don't worry if the writer is already gone by the time we get here. */
- struct q_globals * const gv = ev->evq->gv;
+ struct ddsi_domaingv * const gv = ev->evq->gv;
GVTRACE ("handle_xevk_delete_writer: "PGUIDFMT"\n", PGUID (ev->u.delete_writer.guid));
delete_writer_nolinger (gv, &ev->u.delete_writer.guid);
delete_xevent (ev);
@@ -1455,7 +1461,7 @@ void qxev_msg (struct xeventq *evq, struct nn_xmsg *msg)
void qxev_prd_entityid (struct proxy_reader *prd, const ddsi_guid_t *guid)
{
- struct q_globals * const gv = prd->e.gv;
+ struct ddsi_domaingv * const gv = prd->e.gv;
struct nn_xmsg *msg;
struct xevent_nt *ev;
@@ -1483,7 +1489,7 @@ void qxev_prd_entityid (struct proxy_reader *prd, const ddsi_guid_t *guid)
void qxev_pwr_entityid (struct proxy_writer *pwr, const ddsi_guid_t *guid)
{
- struct q_globals * const gv = pwr->e.gv;
+ struct ddsi_domaingv * const gv = pwr->e.gv;
struct nn_xmsg *msg;
struct xevent_nt *ev;
@@ -1511,7 +1517,7 @@ void qxev_pwr_entityid (struct proxy_writer *pwr, const ddsi_guid_t *guid)
int qxev_msg_rexmit_wrlock_held (struct xeventq *evq, struct nn_xmsg *msg, int force)
{
- struct q_globals * const gv = evq->gv;
+ struct ddsi_domaingv * const gv = evq->gv;
size_t msg_size = nn_xmsg_size (msg);
struct xevent_nt *ev;
diff --git a/src/core/ddsi/src/q_xmsg.c b/src/core/ddsi/src/q_xmsg.c
index 0e964e5..695c47d 100644
--- a/src/core/ddsi/src/q_xmsg.c
+++ b/src/core/ddsi/src/q_xmsg.c
@@ -27,7 +27,7 @@
#include "dds/ddsrt/thread_pool.h"
#include "dds/ddsi/q_protocol.h"
-#include "dds/ddsi/q_xqos.h"
+#include "dds/ddsi/ddsi_xqos.h"
#include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_addrset.h"
@@ -37,7 +37,7 @@
#include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_entity.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/ddsi_entity_index.h"
#include "dds/ddsi/q_freelist.h"
#include "dds/ddsi/ddsi_serdata_default.h"
@@ -208,7 +208,7 @@ struct nn_xpack
size_t niov;
ddsrt_iovec_t *iov;
enum nn_xmsg_dstmode dstmode;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
union
{
@@ -709,7 +709,7 @@ void nn_xmsg_serdata (struct nn_xmsg *m, struct ddsi_serdata *serdata, size_t of
}
}
-void nn_xmsg_setdst1 (struct q_globals *gv, struct nn_xmsg *m, const ddsi_guid_prefix_t *gp, const nn_locator_t *loc)
+void nn_xmsg_setdst1 (struct ddsi_domaingv *gv, struct nn_xmsg *m, const ddsi_guid_prefix_t *gp, const nn_locator_t *loc)
{
assert (m->dstmode == NN_XMSG_DST_UNSET);
m->dstmode = NN_XMSG_DST_ONE;
@@ -809,7 +809,7 @@ static int readerId_compatible (const struct nn_xmsg *m, const struct nn_xmsg *m
return e.u == NN_ENTITYID_UNKNOWN || e.u == eadd.u;
}
-int nn_xmsg_merge_rexmit_destinations_wrlock_held (struct q_globals *gv, struct nn_xmsg *m, const struct nn_xmsg *madd)
+int nn_xmsg_merge_rexmit_destinations_wrlock_held (struct ddsi_domaingv *gv, struct nn_xmsg *m, const struct nn_xmsg *madd)
{
assert (m->kindspecific.data.wrseq >= 1);
assert (m->kindspecific.data.wrguid.prefix.u[0] != 0);
@@ -993,7 +993,7 @@ int nn_xmsg_addpar_sentinel_ifparam (struct nn_xmsg * m)
pointer we compute the address of the xmsg from the address of the
chain element, &c. */
-static void nn_xmsg_chain_release (struct q_globals *gv, struct nn_xmsg_chain *chain)
+static void nn_xmsg_chain_release (struct ddsi_domaingv *gv, struct nn_xmsg_chain *chain)
{
ddsi_guid_t wrguid;
memset (&wrguid, 0, sizeof (wrguid));
@@ -1051,7 +1051,7 @@ static void nn_xmsg_chain_add (struct nn_xmsg_chain *chain, struct nn_xmsg *m)
#define NN_BW_LIMIT_MAX_BUFFER (-30 * T_MILLISECOND)
#define NN_BW_LIMIT_MIN_SLEEP (2 * T_MILLISECOND)
-static void nn_bw_limit_sleep_if_needed (struct q_globals const * const gv, struct nn_bw_limiter *this, ssize_t size)
+static void nn_bw_limit_sleep_if_needed (struct ddsi_domaingv const * const gv, struct nn_bw_limiter *this, ssize_t size)
{
if ( this->bandwidth > 0 ) {
nn_mtime_t tnow = now_mt();
@@ -1210,13 +1210,13 @@ static ssize_t nn_xpack_send_rtps(struct nn_xpack * xp, const nn_locator_t *loc)
static ssize_t nn_xpack_send1 (const nn_locator_t *loc, void * varg)
{
struct nn_xpack *xp = varg;
- struct q_globals const * const gv = xp->gv;
+ struct ddsi_domaingv const * const gv = xp->gv;
ssize_t nbytes = 0;
if (gv->logconfig.c.mask & DDS_LC_TRACE)
{
char buf[DDSI_LOCSTRLEN];
- GVTRACE (" %s", ddsi_locator_to_string (gv, buf, sizeof(buf), loc));
+ GVTRACE (" %s", ddsi_locator_to_string (buf, sizeof(buf), loc));
}
if (gv->config.xmit_lossiness > 0)
@@ -1299,7 +1299,7 @@ static void nn_xpack_send1_threaded (const nn_locator_t *loc, void * varg)
static void nn_xpack_send_real (struct nn_xpack *xp)
{
- struct q_globals const * const gv = xp->gv;
+ struct ddsi_domaingv const * const gv = xp->gv;
size_t calls;
assert (xp->niov <= NN_XMSG_MAX_MESSAGE_IOVECS);
@@ -1379,7 +1379,7 @@ static void nn_xpack_send_real (struct nn_xpack *xp)
static uint32_t nn_xpack_sendq_thread (void *vgv)
{
- struct q_globals *gv = vgv;
+ struct ddsi_domaingv *gv = vgv;
ddsrt_mutex_lock (&gv->sendq_lock);
while (!(gv->sendq_stop && gv->sendq_head == NULL))
{
@@ -1403,7 +1403,7 @@ static uint32_t nn_xpack_sendq_thread (void *vgv)
return 0;
}
-void nn_xpack_sendq_init (struct q_globals *gv)
+void nn_xpack_sendq_init (struct ddsi_domaingv *gv)
{
gv->sendq_stop = 0;
gv->sendq_head = NULL;
@@ -1413,13 +1413,13 @@ void nn_xpack_sendq_init (struct q_globals *gv)
ddsrt_cond_init (&gv->sendq_cond);
}
-void nn_xpack_sendq_start (struct q_globals *gv)
+void nn_xpack_sendq_start (struct ddsi_domaingv *gv)
{
if (create_thread (&gv->sendq_ts, gv, "sendq", nn_xpack_sendq_thread, NULL) != DDS_RETCODE_OK)
GVERROR ("nn_xpack_sendq_start: can't create nn_xpack_sendq_thread\n");
}
-void nn_xpack_sendq_stop (struct q_globals *gv)
+void nn_xpack_sendq_stop (struct ddsi_domaingv *gv)
{
ddsrt_mutex_lock (&gv->sendq_lock);
gv->sendq_stop = 1;
@@ -1427,7 +1427,7 @@ void nn_xpack_sendq_stop (struct q_globals *gv)
ddsrt_mutex_unlock (&gv->sendq_lock);
}
-void nn_xpack_sendq_fini (struct q_globals *gv)
+void nn_xpack_sendq_fini (struct ddsi_domaingv *gv)
{
assert (gv->sendq_head == NULL);
join_thread (gv->sendq_ts);
@@ -1443,7 +1443,7 @@ void nn_xpack_send (struct nn_xpack *xp, bool immediately)
}
else
{
- struct q_globals * const gv = xp->gv;
+ struct ddsi_domaingv * const gv = xp->gv;
struct nn_xpack *xp1 = ddsrt_malloc (sizeof (*xp));
memcpy (xp1, xp, sizeof (*xp1));
nn_xpack_reinit (xp);
@@ -1549,7 +1549,7 @@ static int nn_xpack_mayaddmsg (const struct nn_xpack *xp, const struct nn_xmsg *
int nn_xpack_addmsg (struct nn_xpack *xp, struct nn_xmsg *m, const uint32_t flags)
{
/* Returns > 0 if pack got sent out before adding m */
- struct q_globals const * const gv = xp->gv;
+ struct ddsi_domaingv const * const gv = xp->gv;
static InfoDST_t static_zero_dst = {
{ SMID_INFO_DST, (DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? SMFLAG_ENDIANNESS : 0), sizeof (ddsi_guid_prefix_t) },
{ { 0,0,0,0, 0,0,0,0, 0,0,0,0 } }
diff --git a/src/core/ddsi/src/sysdeps.c b/src/core/ddsi/src/sysdeps.c
index e7b2915..b1ce8c3 100644
--- a/src/core/ddsi/src/sysdeps.c
+++ b/src/core/ddsi/src/sysdeps.c
@@ -18,7 +18,7 @@
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/sysdeps.h"
-#if DDSRT_WITH_FREERTOS || !(defined __APPLE__ || defined __linux) || (__GNUC__ > 0 && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40100)
+#if DDSRT_WITH_FREERTOS || !(defined __APPLE__ || (defined __linux && (defined __GLIBC__ || defined __UCLIBC__))) || (__GNUC__ > 0 && (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40100)
void log_stacktrace (const struct ddsrt_log_cfg *logcfg, const char *name, ddsrt_thread_t tid)
{
DDSRT_UNUSED_ARG (name);
diff --git a/src/core/ddsi/tests/plist.c b/src/core/ddsi/tests/plist.c
index a9b96a0..8227831 100644
--- a/src/core/ddsi/tests/plist.c
+++ b/src/core/ddsi/tests/plist.c
@@ -14,18 +14,17 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/string.h"
#include "dds/ddsrt/endian.h"
-#include "dds/ddsi/q_xqos.h"
-#include "dds/ddsi/q_plist.h"
+#include "dds/ddsi/ddsi_xqos.h"
+#include "dds/ddsi/ddsi_plist.h"
CU_Test (ddsi_plist, unalias_copy_merge)
{
- /* one int, one string, one string sequence and one struct sequence covers most cases */
- nn_plist_t p0, p0memcpy;
+ /* one int, one string and one string sequence covers most cases */
+ ddsi_plist_t p0, p0memcpy;
char *p0strs[7];
- nn_plist_init_empty (&p0);
- p0.present = PP_PRISMTECH_PROCESS_ID | PP_ENTITY_NAME;
+ ddsi_plist_init_empty (&p0);
+ p0.present = PP_ENTITY_NAME;
p0.aliased = PP_ENTITY_NAME;
- p0.process_id = 0x12345678;
p0.entity_name = "nemo";
p0.qos.present = QP_PARTITION;
p0.qos.aliased = QP_PARTITION;
@@ -52,14 +51,14 @@ CU_Test (ddsi_plist, unalias_copy_merge)
memcpy (&p0memcpy, &p0, sizeof (p0));
/* manually alias one, so we can free it*/
- nn_plist_t p0alias;
+ ddsi_plist_t p0alias;
memcpy (&p0alias, &p0, sizeof (p0));
p0alias.qos.partition.strs = ddsrt_memdup (p0alias.qos.partition.strs, p0.qos.partition.n * sizeof (*p0.qos.partition.strs));
#ifdef DDSI_INCLUDE_SECURITY
p0alias.identity_token.properties.props = ddsrt_memdup (p0alias.identity_token.properties.props,
p0.identity_token.properties.n * sizeof (*p0.identity_token.properties.props));
#endif
- nn_plist_fini (&p0alias);
+ ddsi_plist_fini (&p0alias);
CU_ASSERT (memcmp (&p0, &p0memcpy, sizeof (p0)) == 0);
CU_ASSERT_STRING_EQUAL (p0.entity_name, "nemo");
CU_ASSERT_STRING_EQUAL (p0.qos.partition.strs[0], p0strs[0]);
@@ -73,15 +72,14 @@ CU_Test (ddsi_plist, unalias_copy_merge)
#endif
/* copy an aliased one; the original must be unchanged, the copy unaliased */
- nn_plist_t p1;
- nn_plist_init_empty (&p1);
- nn_plist_copy (&p1, &p0);
+ ddsi_plist_t p1;
+ ddsi_plist_init_empty (&p1);
+ ddsi_plist_copy (&p1, &p0);
CU_ASSERT (memcmp (&p0, &p0memcpy, sizeof (p0)) == 0);
CU_ASSERT (p1.present == p0.present);
CU_ASSERT (p1.aliased == 0);
CU_ASSERT (p1.qos.present == p0.qos.present);
CU_ASSERT (p1.qos.aliased == 0);
- CU_ASSERT (p1.process_id == p0.process_id);
CU_ASSERT (p1.entity_name != p0.entity_name);
CU_ASSERT_STRING_EQUAL (p1.entity_name, p0.entity_name);
CU_ASSERT (p1.qos.partition.n == p0.qos.partition.n);
@@ -114,19 +112,18 @@ CU_Test (ddsi_plist, unalias_copy_merge)
/* merge-in missing ones from an aliased copy: original must remain unchanged;
existing ones should stay without touching "aliased" only new ones are
added as unaliased ones */
- nn_plist_t p2, p2memcpy;
- nn_plist_init_empty (&p2);
+ ddsi_plist_t p2, p2memcpy;
+ ddsi_plist_init_empty (&p2);
p2.present = PP_ENTITY_NAME;
p2.aliased = PP_ENTITY_NAME;
p2.entity_name = "omen";
memcpy (&p2memcpy, &p2, sizeof (p2));
- nn_plist_mergein_missing (&p2, &p0, p0.present, p0.qos.present);
+ ddsi_plist_mergein_missing (&p2, &p0, p0.present, p0.qos.present);
CU_ASSERT (memcmp (&p0, &p0memcpy, sizeof (p0)) == 0);
CU_ASSERT (p2.present == p0.present);
CU_ASSERT (p2.aliased == p2memcpy.aliased);
CU_ASSERT (p2.qos.present == p0.qos.present);
CU_ASSERT (p2.qos.aliased == p2memcpy.qos.aliased);
- CU_ASSERT (p2.process_id == p0.process_id);
CU_ASSERT (p2.entity_name == p2memcpy.entity_name);
CU_ASSERT_STRING_EQUAL (p2.entity_name, "omen");
CU_ASSERT (p2.qos.partition.n == p0.qos.partition.n);
@@ -157,12 +154,11 @@ CU_Test (ddsi_plist, unalias_copy_merge)
#endif
/* unalias of p0, partition.strs mustn't change, because it, unlike its elements, wasn't aliased */
- nn_plist_unalias (&p0);
+ ddsi_plist_unalias (&p0);
CU_ASSERT (p0.present == p0memcpy.present);
CU_ASSERT (p0.aliased == 0);
CU_ASSERT (p0.qos.present == p0memcpy.qos.present);
CU_ASSERT (p0.qos.aliased == 0);
- CU_ASSERT (p0.process_id == p0memcpy.process_id);
CU_ASSERT (p0.entity_name != p0memcpy.entity_name);
CU_ASSERT_STRING_EQUAL (p0.entity_name, p0memcpy.entity_name);
CU_ASSERT (p0.qos.partition.n == p0memcpy.qos.partition.n);
@@ -187,15 +183,14 @@ CU_Test (ddsi_plist, unalias_copy_merge)
memcpy (&p0memcpy, &p0, sizeof (p0));
/* copy an aliased one; the original must be unchanged, the copy unaliased */
- nn_plist_t p3;
- nn_plist_init_empty (&p3);
- nn_plist_copy (&p3, &p0);
+ ddsi_plist_t p3;
+ ddsi_plist_init_empty (&p3);
+ ddsi_plist_copy (&p3, &p0);
CU_ASSERT (memcmp (&p0, &p0memcpy, sizeof (p0)) == 0);
CU_ASSERT (p3.present == p0.present);
CU_ASSERT (p3.aliased == 0);
CU_ASSERT (p3.qos.present == p0.qos.present);
CU_ASSERT (p3.qos.aliased == 0);
- CU_ASSERT (p3.process_id == p0.process_id);
CU_ASSERT (p3.entity_name != p0.entity_name);
CU_ASSERT_STRING_EQUAL (p3.entity_name, p0.entity_name);
CU_ASSERT (p3.qos.partition.n == p0.qos.partition.n);
@@ -228,19 +223,18 @@ CU_Test (ddsi_plist, unalias_copy_merge)
/* merge-in missing ones from an aliased copy: original must remain unchanged;
existing ones should stay without touching "aliased" only new ones are
added as unaliased ones */
- nn_plist_t p4, p4memcpy;
- nn_plist_init_empty (&p4);
+ ddsi_plist_t p4, p4memcpy;
+ ddsi_plist_init_empty (&p4);
p4.present = PP_ENTITY_NAME;
p4.aliased = PP_ENTITY_NAME;
p4.entity_name = "omen";
memcpy (&p4memcpy, &p4, sizeof (p4));
- nn_plist_mergein_missing (&p4, &p0, p0.present, p0.qos.present);
+ ddsi_plist_mergein_missing (&p4, &p0, p0.present, p0.qos.present);
CU_ASSERT (memcmp (&p0, &p0memcpy, sizeof (p0)) == 0);
CU_ASSERT (p4.present == p0.present);
CU_ASSERT (p4.aliased == p4memcpy.aliased);
CU_ASSERT (p4.qos.present == p0.qos.present);
CU_ASSERT (p4.qos.aliased == p4memcpy.qos.aliased);
- CU_ASSERT (p4.process_id == p0.process_id);
CU_ASSERT (p4.entity_name == p4memcpy.entity_name);
CU_ASSERT_STRING_EQUAL (p4.entity_name, "omen");
CU_ASSERT (p4.qos.partition.n == p0.qos.partition.n);
@@ -270,9 +264,9 @@ CU_Test (ddsi_plist, unalias_copy_merge)
CU_ASSERT (p4.identity_token.binary_properties.props == NULL);
#endif
- nn_plist_fini (&p0);
- nn_plist_fini (&p1);
- nn_plist_fini (&p2);
- nn_plist_fini (&p3);
- nn_plist_fini (&p4);
+ ddsi_plist_fini (&p0);
+ ddsi_plist_fini (&p1);
+ ddsi_plist_fini (&p2);
+ ddsi_plist_fini (&p3);
+ ddsi_plist_fini (&p4);
}
diff --git a/src/core/ddsi/tests/plist_generic.c b/src/core/ddsi/tests/plist_generic.c
index 54f7647..689f2f9 100644
--- a/src/core/ddsi/tests/plist_generic.c
+++ b/src/core/ddsi/tests/plist_generic.c
@@ -13,7 +13,7 @@
#include "CUnit/Theory.h"
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/endian.h"
-#include "dds/ddsi/q_xqos.h"
+#include "dds/ddsi/ddsi_xqos.h"
#include "dds/ddsi/ddsi_plist_generic.h"
#include "mem_ser.h"
diff --git a/src/core/xtests/cdrtest/CMakeLists.txt b/src/core/xtests/cdrtest/CMakeLists.txt
index 1535a9c..2021e0b 100644
--- a/src/core/xtests/cdrtest/CMakeLists.txt
+++ b/src/core/xtests/cdrtest/CMakeLists.txt
@@ -11,6 +11,8 @@
#
cmake_minimum_required(VERSION 3.5)
+find_package(CycloneDDS COMPONENTS idlc)
+
add_compile_options("-I${PROJECT_SOURCE_DIR}/src/ddsrt/include")
add_compile_options("-I${PROJECT_SOURCE_DIR}/src/core/ddsc/include")
add_compile_options("-I${PROJECT_SOURCE_DIR}/src/core/ddsc/src")
diff --git a/src/core/xtests/cdrtest/cdrtest.pl b/src/core/xtests/cdrtest/cdrtest.pl
index e850927..f42a7c2 100644
--- a/src/core/xtests/cdrtest/cdrtest.pl
+++ b/src/core/xtests/cdrtest/cdrtest.pl
@@ -54,7 +54,7 @@ print CYC <[1]_desc;
+ ddd.type = (struct ddsi_sertopic_default_desc) {
+ .m_size = $t->[1]_desc.m_size,
+ .m_align = $t->[1]_desc.m_align,
+ .m_flagset = $t->[1]_desc.m_flagset,
+ .m_nkeys = 0,
+ .m_keys = NULL,
+ .m_nops = dds_stream_countops ($t->[1]_desc.m_ops),
+ .m_ops = (uint32_t *) $t->[1]_desc.m_ops
+ };
for (uint32_t i = 0; i < 1000; i++) {
for (size_t j = 0; j < sizeof (garbage); j++)
garbage[j] = (unsigned char) ddsrt_random ();
diff --git a/src/core/xtests/rhc_torture/rhc_torture.c b/src/core/xtests/rhc_torture/rhc_torture.c
index 080f993..b662b7a 100644
--- a/src/core/xtests/rhc_torture/rhc_torture.c
+++ b/src/core/xtests/rhc_torture/rhc_torture.c
@@ -24,7 +24,7 @@
#include "dds__entity.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_bswap.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_gc.h"
@@ -107,7 +107,7 @@ static struct ddsi_serdata *mkkeysample (int32_t keyval, unsigned statusinfo)
return sd;
}
-#ifdef DDSI_INCLUDE_LIFESPAN
+#if defined(DDSI_INCLUDE_LIFESPAN) || defined (DDSI_INCLUDE_DEADLINE_MISSED)
static nn_mtime_t rand_texp ()
{
nn_mtime_t ret = now_mt();
@@ -116,6 +116,13 @@ static nn_mtime_t rand_texp ()
}
#endif
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+static dds_duration_t rand_deadline ()
+{
+ return (dds_duration_t) (ddsrt_prng_random (&prng) % DDS_MSECS(500));
+}
+#endif
+
static uint64_t store (struct ddsi_tkmap *tkmap, struct dds_rhc *rhc, struct proxy_writer *wr, struct ddsi_serdata *sd, bool print, bool lifespan_expiry)
{
#ifndef DDSI_INCLUDE_LIFESPAN
@@ -160,7 +167,7 @@ static uint64_t store (struct ddsi_tkmap *tkmap, struct dds_rhc *rhc, struct pro
return iid;
}
-static struct proxy_writer *mkwr (const struct q_globals *gv, bool auto_dispose)
+static struct proxy_writer *mkwr (const struct ddsi_domaingv *gv, bool auto_dispose)
{
struct proxy_writer *pwr;
struct dds_qos *xqos;
@@ -169,8 +176,8 @@ static struct proxy_writer *mkwr (const struct q_globals *gv, bool auto_dispose)
xqos = ddsrt_malloc (sizeof (*xqos));
wr_iid = ddsi_iid_gen ();
memset (pwr, 0, sizeof (*pwr));
- nn_xqos_init_empty (xqos);
- nn_xqos_mergein_missing (xqos, &gv->default_xqos_wr, ~(uint64_t)0);
+ ddsi_xqos_init_empty (xqos);
+ ddsi_xqos_mergein_missing (xqos, &gv->default_xqos_wr, ~(uint64_t)0);
xqos->ownership_strength.value = 0;
xqos->writer_data_lifecycle.autodispose_unregistered_instances = auto_dispose;
pwr->e.iid = wr_iid;
@@ -184,16 +191,16 @@ static void fwr (struct proxy_writer *wr)
free (wr);
}
-static struct dds_rhc *mkrhc (struct q_globals *gv, dds_reader *rd, dds_history_kind_t hk, int32_t hdepth, dds_destination_order_kind_t dok)
+static struct dds_rhc *mkrhc (struct ddsi_domaingv *gv, dds_reader *rd, dds_history_kind_t hk, int32_t hdepth, dds_destination_order_kind_t dok)
{
struct dds_rhc *rhc;
dds_qos_t rqos;
- nn_xqos_init_empty (&rqos);
+ ddsi_xqos_init_empty (&rqos);
rqos.present |= QP_HISTORY | QP_DESTINATION_ORDER;
rqos.history.kind = hk;
rqos.history.depth = hdepth;
rqos.destination_order.kind = dok;
- nn_xqos_mergein_missing (&rqos, &gv->default_xqos_rd, ~(uint64_t)0);
+ ddsi_xqos_mergein_missing (&rqos, &gv->default_xqos_rd, ~(uint64_t)0);
thread_state_awake_domain_ok (lookup_thread_state ());
rhc = dds_rhc_default_new_xchecks (rd, gv, mdtopic, true);
dds_rhc_set_qos(rhc, &rqos);
@@ -553,9 +560,9 @@ static dds_entity_t readcond_wrapper (dds_entity_t reader, uint32_t mask, dds_qu
return dds_create_readcondition (reader, mask);
}
-static struct q_globals *get_gv (dds_entity_t e)
+static struct ddsi_domaingv *get_gv (dds_entity_t e)
{
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
dds_entity *x;
if (dds_entity_pin (e, &x) < 0)
abort ();
@@ -569,6 +576,9 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
dds_qos_t *qos = dds_create_qos ();
dds_qset_history (qos, DDS_HISTORY_KEEP_LAST, MAX_HIST_DEPTH);
dds_qset_destination_order (qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP);
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+ dds_qset_deadline (qos, rand_deadline());
+#endif
/* two identical readers because we need 63 conditions while we can currently only attach 32 a single reader */
dds_entity_t rd[] = { dds_create_reader (pp, tp, qos, NULL), dds_create_reader (pp, tp, qos, NULL) };
const size_t nrd = sizeof (rd) / sizeof (rd[0]);
@@ -584,7 +594,7 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
dds_entity_unlock (x);
}
- const struct q_globals *gv = get_gv (pp);
+ const struct ddsi_domaingv *gv = get_gv (pp);
struct ddsi_tkmap *tkmap = gv->m_tkmap;
struct proxy_writer *wr[] = { mkwr (gv, 0), mkwr (gv, 1), mkwr (gv, 1) };
@@ -673,7 +683,8 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
[9] = "tkc",
[10] = "tkc1",
[11] = "delwr",
- [12] = "drpxp"
+ [12] = "drpxp",
+ [13] = "dlmis"
};
static const uint32_t opfreqs[] = {
[0] = 500, /* write */
@@ -689,9 +700,14 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
[10] = 100, /* take cond, max 1 */
[11] = 1, /* unreg writer */
#ifdef DDSI_INCLUDE_LIFESPAN
- [12] = 100 /* drop expired sample */
+ [12] = 100, /* drop expired sample */
#else
- [12] = 0 /* drop expired sample */
+ [12] = 0, /* drop expired sample */
+#endif
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+ [13] = 100 /* deadline missed */
+#else
+ [13] = 0 /* drop expired sample */
#endif
};
uint32_t opthres[sizeof (opfreqs) / sizeof (opfreqs[0])];
@@ -829,6 +845,16 @@ static void test_conditions (dds_entity_t pp, dds_entity_t tp, const int count,
for (size_t k = 0; k < nrd; k++)
(void) dds_rhc_default_sample_expired_cb (rhc[k], rand_texp());
thread_state_asleep (lookup_thread_state ());
+#endif
+ break;
+ }
+ case 13: {
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
+ thread_state_awake_domain_ok (lookup_thread_state ());
+ /* We can assume that rhc[k] is a dds_rhc_default at this point */
+ for (size_t k = 0; k < nrd; k++)
+ (void) dds_rhc_default_deadline_missed_cb (rhc[k], rand_texp());
+ thread_state_asleep (lookup_thread_state ());
#endif
break;
}
@@ -895,15 +921,15 @@ int main (int argc, char **argv)
mainthread = lookup_thread_state ();
assert (ddsrt_atomic_ldvoidp (&mainthread->gv) != NULL);
{
- struct dds_entity *x;
- if (dds_entity_lock(tp, DDS_KIND_TOPIC, &x) < 0) abort();
- mdtopic = dds_topic_lookup(x->m_domain, "RhcTypes_T");
- dds_entity_unlock(x);
+ struct dds_topic *x;
+ if (dds_topic_pin (tp, &x) < 0) abort();
+ mdtopic = ddsi_sertopic_ref (x->m_stopic);
+ dds_topic_unpin (x);
}
if (0 >= first)
{
- struct q_globals *gv = get_gv (pp);
+ struct ddsi_domaingv *gv = get_gv (pp);
struct ddsi_tkmap *tkmap = gv->m_tkmap;
if (print)
printf ("************* 0 *************\n");
@@ -954,7 +980,7 @@ int main (int argc, char **argv)
if (1 >= first)
{
- struct q_globals *gv = get_gv (pp);
+ struct ddsi_domaingv *gv = get_gv (pp);
struct ddsi_tkmap *tkmap = gv->m_tkmap;
if (print)
printf ("************* 1 *************\n");
diff --git a/src/ddsrt/CMakeLists.txt b/src/ddsrt/CMakeLists.txt
index 00d51e5..6efefdd 100644
--- a/src/ddsrt/CMakeLists.txt
+++ b/src/ddsrt/CMakeLists.txt
@@ -101,12 +101,17 @@ set(include_path "${CMAKE_CURRENT_SOURCE_DIR}/include")
set(source_path "${CMAKE_CURRENT_SOURCE_DIR}/src")
list(APPEND headers
+ "${include_path}/dds/ddsrt/avl.h"
+ "${include_path}/dds/ddsrt/fibheap.h"
+ "${include_path}/dds/ddsrt/hopscotch.h"
+ "${include_path}/dds/ddsrt/thread_pool.h"
"${include_path}/dds/ddsrt/log.h"
"${include_path}/dds/ddsrt/retcode.h"
"${include_path}/dds/ddsrt/attributes.h"
"${include_path}/dds/ddsrt/endian.h"
"${include_path}/dds/ddsrt/arch.h"
"${include_path}/dds/ddsrt/misc.h"
+ "${include_path}/dds/ddsrt/mh3.h"
"${include_path}/dds/ddsrt/io.h"
"${include_path}/dds/ddsrt/process.h"
"${include_path}/dds/ddsrt/dynlib.h"
@@ -114,7 +119,8 @@ list(APPEND headers
"${include_path}/dds/ddsrt/strtol.h"
"${include_path}/dds/ddsrt/types.h"
"${include_path}/dds/ddsrt/countargs.h"
- "${include_path}/dds/ddsrt/static_assert.h")
+ "${include_path}/dds/ddsrt/static_assert.h"
+ "${include_path}/dds/ddsrt/circlist.h")
list(APPEND sources
"${source_path}/bswap.c"
@@ -122,21 +128,15 @@ list(APPEND sources
"${source_path}/log.c"
"${source_path}/retcode.c"
"${source_path}/strtod.c"
- "${source_path}/strtol.c")
-
-list(APPEND headers
- "${include_path}/dds/ddsrt/avl.h"
- "${include_path}/dds/ddsrt/fibheap.h"
- "${include_path}/dds/ddsrt/hopscotch.h"
- "${include_path}/dds/ddsrt/thread_pool.h")
-
-list(APPEND sources
+ "${source_path}/strtol.c"
+ "${source_path}/mh3.c"
"${source_path}/avl.c"
"${source_path}/expand_envvars.c"
"${source_path}/fibheap.c"
"${source_path}/hopscotch.c"
"${source_path}/thread_pool.c"
- "${source_path}/xmlparser.c")
+ "${source_path}/xmlparser.c"
+ "${source_path}/circlist.c")
# Not every target offers the same set of features. For embedded targets the
# set of features may even be different between builds. e.g. a FreeRTOS build
diff --git a/src/ddsrt/include/dds/ddsrt/circlist.h b/src/ddsrt/include/dds/ddsrt/circlist.h
new file mode 100644
index 0000000..767b582
--- /dev/null
+++ b/src/ddsrt/include/dds/ddsrt/circlist.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright(c) 2006 to 2019 ADLINK Technology Limited 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 DDSRT_CIRCLIST_H
+#define DDSRT_CIRCLIST_H
+
+/* Circular doubly linked list implementation */
+
+#include
+#include
+#include "dds/export.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#define DDSRT_FROM_CIRCLIST(typ_, member_, cle_) ((typ_ *) ((char *) (cle_) - offsetof (typ_, member_)))
+
+struct ddsrt_circlist {
+ struct ddsrt_circlist_elem *latest; /* pointer to latest inserted element */
+};
+
+struct ddsrt_circlist_elem {
+ struct ddsrt_circlist_elem *next;
+ struct ddsrt_circlist_elem *prev;
+};
+
+DDS_EXPORT void ddsrt_circlist_init (struct ddsrt_circlist *list);
+DDS_EXPORT bool ddsrt_circlist_isempty (const struct ddsrt_circlist *list);
+DDS_EXPORT void ddsrt_circlist_append (struct ddsrt_circlist *list, struct ddsrt_circlist_elem *elem);
+DDS_EXPORT void ddsrt_circlist_remove (struct ddsrt_circlist *list, struct ddsrt_circlist_elem *elem);
+DDS_EXPORT struct ddsrt_circlist_elem *ddsrt_circlist_oldest (const struct ddsrt_circlist *list);
+DDS_EXPORT struct ddsrt_circlist_elem *ddsrt_circlist_latest (const struct ddsrt_circlist *list);
+
+#endif /* DDSRT_CIRCLIST_H */
diff --git a/src/ddsrt/include/dds/ddsrt/mh3.h b/src/ddsrt/include/dds/ddsrt/mh3.h
new file mode 100644
index 0000000..d22e387
--- /dev/null
+++ b/src/ddsrt/include/dds/ddsrt/mh3.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright(c) 2006 to 2018 ADLINK Technology Limited 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 DDSRT_MH3_H
+#define DDSRT_MH3_H
+
+#include
+#include
+
+#include "dds/export.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+DDS_EXPORT uint32_t
+ddsrt_mh3(
+ const void *key,
+ size_t len,
+ uint32_t seed);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* DDSRT_MH3_H */
diff --git a/src/ddsrt/include/dds/ddsrt/time.h b/src/ddsrt/include/dds/ddsrt/time.h
index b5ebd12..43a458b 100644
--- a/src/ddsrt/include/dds/ddsrt/time.h
+++ b/src/ddsrt/include/dds/ddsrt/time.h
@@ -43,7 +43,7 @@ extern "C" {
/** Absolute Time definition */
typedef int64_t dds_time_t;
-/** Relative Time definition */
+/** Relative Time definition in nanoseconds */
typedef int64_t dds_duration_t;
/** @name Macro definition for time units in nanoseconds.
diff --git a/src/ddsrt/include/dds/ddsrt/types/windows.h b/src/ddsrt/include/dds/ddsrt/types/windows.h
index 7e81bf8..1171cc7 100644
--- a/src/ddsrt/include/dds/ddsrt/types/windows.h
+++ b/src/ddsrt/include/dds/ddsrt/types/windows.h
@@ -16,6 +16,10 @@
#define WIN32_LEAN_AND_MEAN
#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
#include
#include
#include
diff --git a/src/ddsrt/src/atomics.c b/src/ddsrt/src/atomics.c
index 829be41..f586e1a 100644
--- a/src/ddsrt/src/atomics.c
+++ b/src/ddsrt/src/atomics.c
@@ -119,7 +119,7 @@ extern inline int ddsrt_atomic_cas64 (volatile ddsrt_atomic_uint64_t *x, uint64_
#endif
extern inline int ddsrt_atomic_casptr (volatile ddsrt_atomic_uintptr_t *x, uintptr_t exp, uintptr_t des);
extern inline int ddsrt_atomic_casvoidp (volatile ddsrt_atomic_voidp_t *x, void *exp, void *des);
-#if DDSRT_ATOMIC_LIFO_SUPPORT
+#if DDSRT_HAVE_ATOMIC_LIFO
extern inline int ddsrt_atomic_casvoidp2 (volatile ddsrt_atomic_uintptr2_t *x, uintptr_t a0, uintptr_t b0, uintptr_t a1, uintptr_t b1);
#endif
/* FENCES */
@@ -129,7 +129,7 @@ extern inline void ddsrt_atomic_fence_stst (void);
extern inline void ddsrt_atomic_fence_acq (void);
extern inline void ddsrt_atomic_fence_rel (void);
-#if DDSRT_ATOMIC_LIFO_SUPPORT
+#if DDSRT_HAVE_ATOMIC_LIFO
void ddsrt_atomic_lifo_init (ddsrt_atomic_lifo_t *head)
{
head->aba_head.s.a = head->aba_head.s.b = 0;
@@ -243,6 +243,7 @@ int ddsrt_atomic_cas64 (volatile ddsrt_atomic_uint64_t *x, uint64_t exp, uint64_
}
#define DDSRT_FAKE_ATOMIC64(name, oper, ret) \
+ uint64_t ddsrt_atomic_##name##64_##ret (volatile ddsrt_atomic_uint64_t *x, uint64_t v); \
uint64_t ddsrt_atomic_##name##64_##ret (volatile ddsrt_atomic_uint64_t *x, uint64_t v) \
{ \
const uint64_t idx = atomic64_lock_index (x); \
diff --git a/src/ddsrt/src/circlist.c b/src/ddsrt/src/circlist.c
new file mode 100644
index 0000000..51159bd
--- /dev/null
+++ b/src/ddsrt/src/circlist.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright(c) 2006 to 2019 ADLINK Technology Limited 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
+ */
+#include
+#include
+#include
+#include
+#include "dds/ddsrt/circlist.h"
+
+void ddsrt_circlist_init (struct ddsrt_circlist *list)
+{
+ list->latest = NULL;
+}
+
+bool ddsrt_circlist_isempty (const struct ddsrt_circlist *list)
+{
+ return list->latest == NULL;
+}
+
+void ddsrt_circlist_append (struct ddsrt_circlist *list, struct ddsrt_circlist_elem *elem)
+{
+ if (list->latest == NULL)
+ elem->next = elem->prev = elem;
+ else
+ {
+ struct ddsrt_circlist_elem * const hd = list->latest;
+#ifndef NDEBUG
+ {
+ const struct ddsrt_circlist_elem *x = hd;
+ do { assert (x != elem); x = x->next; } while (x != hd);
+ }
+#endif
+ elem->next = hd->next;
+ elem->prev = hd;
+ hd->next = elem;
+ elem->next->prev = elem;
+ }
+ list->latest = elem;
+}
+
+void ddsrt_circlist_remove (struct ddsrt_circlist *list, struct ddsrt_circlist_elem *elem)
+{
+#ifndef NDEBUG
+ {
+ const struct ddsrt_circlist_elem *x = list->latest;
+ assert (x);
+ do { if (x == elem) break; x = x->next; } while (x != list->latest);
+ assert (x == elem);
+ }
+#endif
+ if (elem->next == elem)
+ list->latest = NULL;
+ else
+ {
+ struct ddsrt_circlist_elem * const elem_prev = elem->prev;
+ struct ddsrt_circlist_elem * const elem_next = elem->next;
+ elem_prev->next = elem_next;
+ elem_next->prev = elem_prev;
+ if (list->latest == elem)
+ list->latest = elem_prev;
+ }
+}
+
+struct ddsrt_circlist_elem *ddsrt_circlist_oldest (const struct ddsrt_circlist *list)
+{
+ assert (!ddsrt_circlist_isempty (list));
+ return list->latest->next;
+}
+
+struct ddsrt_circlist_elem *ddsrt_circlist_latest (const struct ddsrt_circlist *list)
+{
+ assert (!ddsrt_circlist_isempty (list));
+ return list->latest;
+}
+
+
diff --git a/src/ddsrt/src/ifaddrs/windows/ifaddrs.c b/src/ddsrt/src/ifaddrs/windows/ifaddrs.c
index 7c5045c..f63f87c 100644
--- a/src/ddsrt/src/ifaddrs/windows/ifaddrs.c
+++ b/src/ddsrt/src/ifaddrs/windows/ifaddrs.c
@@ -167,14 +167,37 @@ guess_iftype (const PIP_ADAPTER_ADDRESSES iface)
}
}
-static int
+static dds_return_t
+copyname(const wchar_t *wstr, char **strp)
+{
+ int cnt, len;
+ char buf[1], *str;
+
+ len = WideCharToMultiByte(
+ CP_UTF8, WC_ERR_INVALID_CHARS, wstr, -1, buf, 0, NULL, NULL);
+ if (len == 0) {
+ return DDS_RETCODE_BAD_PARAMETER;
+ } else if ((str = ddsrt_malloc_s(len)) == NULL) {
+ return DDS_RETCODE_OUT_OF_RESOURCES;
+ }
+
+ cnt = WideCharToMultiByte(
+ CP_UTF8, WC_ERR_INVALID_CHARS, wstr, -1, str, len, NULL, NULL);
+ assert(cnt == len);
+ assert(str[len - 1] == '\0');
+
+ *strp = str;
+ return DDS_RETCODE_OK;
+}
+
+static dds_return_t
copyaddr(
ddsrt_ifaddrs_t **ifap,
const PIP_ADAPTER_ADDRESSES iface,
const PMIB_IPADDRTABLE addrtable,
const PIP_ADAPTER_UNICAST_ADDRESS addr)
{
- dds_return_t err = DDS_RETCODE_OK;
+ dds_return_t rc = DDS_RETCODE_OK;
ddsrt_ifaddrs_t *ifa;
struct sockaddr *sa;
size_t sz;
@@ -187,15 +210,17 @@ copyaddr(
sz = (size_t)addr->Address.iSockaddrLength;
if ((ifa = ddsrt_calloc_s(1, sizeof(*ifa))) == NULL) {
- err = DDS_RETCODE_OUT_OF_RESOURCES;
+ rc = DDS_RETCODE_OUT_OF_RESOURCES;
} else {
ifa->flags = getflags(iface);
ifa->type = guess_iftype(iface);
- ifa->addr = ddsrt_memdup(sa, sz);
- (void)ddsrt_asprintf(&ifa->name, "%wS", iface->FriendlyName);
- if (ifa->addr == NULL || ifa->name == NULL) {
- err = DDS_RETCODE_OUT_OF_RESOURCES;
- } else if (ifa->addr->sa_family == AF_INET6) {
+ if ((ifa->addr = ddsrt_memdup(sa, sz)) == NULL) {
+ rc = DDS_RETCODE_OUT_OF_RESOURCES;
+ } else {
+ rc = copyname(iface->FriendlyName, &ifa->name);
+ }
+
+ if (ifa->addr->sa_family == AF_INET6) {
ifa->index = iface->Ipv6IfIndex;
/* Address is not in addrtable if the interface is not connected. */
@@ -222,18 +247,18 @@ copyaddr(
if ((ifa->netmask = ddsrt_memdup(&nm, sz)) == NULL ||
(ifa->broadaddr = ddsrt_memdup(&bc, sz)) == NULL)
{
- err = DDS_RETCODE_OUT_OF_RESOURCES;
+ rc = DDS_RETCODE_OUT_OF_RESOURCES;
}
}
}
- if (err == 0) {
+ if (rc == DDS_RETCODE_OK) {
*ifap = ifa;
} else {
ddsrt_freeifaddrs(ifa);
}
- return err;
+ return rc;
}
dds_return_t
@@ -241,7 +266,7 @@ ddsrt_getifaddrs(
ddsrt_ifaddrs_t **ifap,
const int *afs)
{
- int err = 0;
+ dds_return_t rc = DDS_RETCODE_OK;
int use;
PIP_ADAPTER_ADDRESSES ifaces = NULL, iface;
PIP_ADAPTER_UNICAST_ADDRESS addr = NULL;
@@ -257,12 +282,15 @@ ddsrt_getifaddrs(
ifa = ifa_root = ifa_next = NULL;
- if ((err = getifaces(&ifaces)) == DDS_RETCODE_OK &&
- (err = getaddrtable(&addrtable)) == DDS_RETCODE_OK)
+ if ((rc = getifaces(&ifaces)) == DDS_RETCODE_OK &&
+ (rc = getaddrtable(&addrtable)) == DDS_RETCODE_OK)
{
- for (iface = ifaces; !err && iface != NULL; iface = iface->Next) {
+ for (iface = ifaces;
+ iface != NULL && rc == DDS_RETCODE_OK;
+ iface = iface->Next)
+ {
for (addr = iface->FirstUnicastAddress;
- addr != NULL;
+ addr != NULL && rc == DDS_RETCODE_OK;
addr = addr->Next)
{
sa = (struct sockaddr *)addr->Address.lpSockaddr;
@@ -272,8 +300,8 @@ ddsrt_getifaddrs(
}
if (use) {
- err = copyaddr(&ifa_next, iface, addrtable, addr);
- if (err == DDS_RETCODE_OK) {
+ rc = copyaddr(&ifa_next, iface, addrtable, addr);
+ if (rc == DDS_RETCODE_OK) {
if (ifa == NULL) {
ifa = ifa_root = ifa_next;
} else {
@@ -289,11 +317,11 @@ ddsrt_getifaddrs(
ddsrt_free(ifaces);
ddsrt_free(addrtable);
- if (err == DDS_RETCODE_OK) {
+ if (rc == DDS_RETCODE_OK) {
*ifap = ifa_root;
} else {
ddsrt_freeifaddrs(ifa_root);
}
- return err;
+ return rc;
}
diff --git a/src/ddsrt/src/mh3.c b/src/ddsrt/src/mh3.c
new file mode 100644
index 0000000..f186e95
--- /dev/null
+++ b/src/ddsrt/src/mh3.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright(c) 2006 to 2018 ADLINK Technology Limited 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
+ */
+#include "dds/ddsrt/mh3.h"
+
+#define DDSRT_MH3_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
+
+/* Really
+ http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp,
+ MurmurHash3_x86_32
+*/
+uint32_t ddsrt_mh3 (const void *key, size_t len, uint32_t seed)
+{
+ const uint8_t *data = (const uint8_t *) key;
+ const intptr_t nblocks = (intptr_t) (len / 4);
+ const uint32_t c1 = 0xcc9e2d51;
+ const uint32_t c2 = 0x1b873593;
+
+ uint32_t h1 = seed;
+ const uint32_t *blocks = (const uint32_t *) (data + nblocks * 4);
+ for (intptr_t i = -nblocks; i; i++)
+ {
+ uint32_t k1 = blocks[i];
+
+ k1 *= c1;
+ k1 = DDSRT_MH3_ROTL32 (k1, 15);
+ k1 *= c2;
+
+ h1 ^= k1;
+ h1 = DDSRT_MH3_ROTL32 (h1, 13);
+ h1 = h1 * 5 + 0xe6546b64;
+ }
+
+ const uint8_t *tail = data + nblocks * 4;
+ uint32_t k1 = 0;
+ switch (len & 3)
+ {
+ case 3:
+ k1 ^= (uint32_t) tail[2] << 16;
+ /* FALLS THROUGH */
+ case 2:
+ k1 ^= (uint32_t) tail[1] << 8;
+ /* FALLS THROUGH */
+ case 1:
+ k1 ^= (uint32_t) tail[0];
+ k1 *= c1;
+ k1 = DDSRT_MH3_ROTL32 (k1, 15);
+ k1 *= c2;
+ h1 ^= k1;
+ /* FALLS THROUGH */
+ };
+
+ /* finalization */
+ h1 ^= (uint32_t) len;
+ h1 ^= h1 >> 16;
+ h1 *= 0x85ebca6b;
+ h1 ^= h1 >> 13;
+ h1 *= 0xc2b2ae35;
+ h1 ^= h1 >> 16;
+ return h1;
+}
diff --git a/src/ddsrt/src/threads/posix/threads.c b/src/ddsrt/src/threads/posix/threads.c
index 2affcdb..3244202 100644
--- a/src/ddsrt/src/threads/posix/threads.c
+++ b/src/ddsrt/src/threads/posix/threads.c
@@ -39,6 +39,7 @@ typedef struct {
} thread_context_t;
#if defined(__linux)
+#include
#include
#include
#define MAXTHREADNAMESIZE (15) /* 16 bytes including null-terminating byte. */
@@ -72,9 +73,10 @@ ddsrt_thread_getname(char *str, size_t size)
assert(size > 0);
#if defined(__linux)
- /* Thread names are limited to 16 bytes on Linux. ERANGE is returned if the
- buffer is smaller than 16 bytes. Use an intermediate buffer. */
- (void)pthread_getname_np(pthread_self(), buf, sizeof(buf));
+ /* Thread names are limited to 16 bytes on Linux, which the buffer should
+ allow space for. prctl is favored over pthread_getname_np for
+ portability. e.g. musl libc. */
+ (void)prctl(PR_GET_NAME, (unsigned long)buf, 0UL, 0UL, 0UL);
cnt = ddsrt_strlcpy(str, buf, size);
#elif defined(__APPLE__)
/* pthread_getname_np on APPLE uses strlcpy to copy the thread name, but
diff --git a/src/mpt/tests/qos/procs/rw.c b/src/mpt/tests/qos/procs/rw.c
index 10cceee..14889cf 100644
--- a/src/mpt/tests/qos/procs/rw.c
+++ b/src/mpt/tests/qos/procs/rw.c
@@ -23,7 +23,7 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/log.h"
-#include "dds/ddsi/q_xqos.h"
+#include "dds/ddsi/ddsi_xqos.h"
#include "rwdata.h"
#include "rw.h"
@@ -98,7 +98,11 @@ static void setqos (dds_qos_t *q, size_t i, bool isrd, bool create)
#else
dds_qset_lifespan (q, DDS_INFINITY);
#endif
+#ifdef DDSI_INCLUDE_DEADLINE_MISSED
dds_qset_deadline (q, INT64_C (67890123456789012) + (int32_t) i);
+#else
+ dds_qset_deadline (q, DDS_INFINITY);
+#endif
dds_qset_latency_budget (q, INT64_C (45678901234567890) + (int32_t) i);
dds_qset_ownership (q, (dds_ownership_kind_t) ((i + 1) % 2));
dds_qset_ownership_strength (q, 0x12345670 + (int32_t) i);
@@ -136,14 +140,14 @@ static bool pubsub_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
dds_get_qos (ent, b);
/* internal interface is more luxurious that a simple compare for equality, and
using that here saves us a ton of code */
- uint64_t delta = nn_xqos_delta (a, b, QP_GROUP_DATA | QP_PRESENTATION | QP_PARTITION);
+ uint64_t delta = ddsi_xqos_delta (a, b, QP_GROUP_DATA | QP_PRESENTATION | QP_PARTITION);
if (delta)
{
struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "pub/sub: delta = %"PRIx64"\n", delta);
- nn_log_xqos (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
- nn_log_xqos (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@@ -151,7 +155,7 @@ static bool pubsub_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
static uint64_t reader_qos_delta (const dds_qos_t *a, const dds_qos_t *b)
{
- return nn_xqos_delta (a, b, QP_USER_DATA | QP_TOPIC_DATA | QP_GROUP_DATA | QP_DURABILITY | QP_HISTORY | QP_RESOURCE_LIMITS | QP_PRESENTATION | QP_DEADLINE | QP_LATENCY_BUDGET | QP_OWNERSHIP | QP_LIVELINESS | QP_TIME_BASED_FILTER | QP_PARTITION | QP_RELIABILITY | QP_DESTINATION_ORDER | QP_PRISMTECH_READER_DATA_LIFECYCLE);
+ return ddsi_xqos_delta (a, b, QP_USER_DATA | QP_TOPIC_DATA | QP_GROUP_DATA | QP_DURABILITY | QP_HISTORY | QP_RESOURCE_LIMITS | QP_PRESENTATION | QP_DEADLINE | QP_LATENCY_BUDGET | QP_OWNERSHIP | QP_LIVELINESS | QP_TIME_BASED_FILTER | QP_PARTITION | QP_RELIABILITY | QP_DESTINATION_ORDER | QP_PRISMTECH_READER_DATA_LIFECYCLE);
}
static bool reader_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
@@ -164,8 +168,8 @@ static bool reader_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "reader: delta = %"PRIx64"\n", delta);
- nn_log_xqos (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
- nn_log_xqos (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@@ -173,7 +177,7 @@ static bool reader_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
static uint64_t writer_qos_delta (const dds_qos_t *a, const dds_qos_t *b)
{
- return nn_xqos_delta (a, b, QP_USER_DATA | QP_TOPIC_DATA | QP_GROUP_DATA | QP_DURABILITY | QP_HISTORY | QP_RESOURCE_LIMITS | QP_PRESENTATION | QP_LIFESPAN | QP_DEADLINE | QP_LATENCY_BUDGET | QP_OWNERSHIP | QP_OWNERSHIP_STRENGTH | QP_LIVELINESS | QP_PARTITION | QP_RELIABILITY | QP_DESTINATION_ORDER | QP_PRISMTECH_WRITER_DATA_LIFECYCLE);
+ return ddsi_xqos_delta (a, b, QP_USER_DATA | QP_TOPIC_DATA | QP_GROUP_DATA | QP_DURABILITY | QP_HISTORY | QP_RESOURCE_LIMITS | QP_PRESENTATION | QP_LIFESPAN | QP_DEADLINE | QP_LATENCY_BUDGET | QP_OWNERSHIP | QP_OWNERSHIP_STRENGTH | QP_LIVELINESS | QP_PARTITION | QP_RELIABILITY | QP_DESTINATION_ORDER | QP_PRISMTECH_WRITER_DATA_LIFECYCLE);
}
static bool writer_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
@@ -186,8 +190,8 @@ static bool writer_qos_eq_h (const dds_qos_t *a, dds_entity_t ent)
struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "writer: delta = %"PRIx64"\n", delta);
- nn_log_xqos (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
- nn_log_xqos (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@@ -271,8 +275,8 @@ MPT_ProcessEntry (rw_publisher,
struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "matched reader: delta = %"PRIx64"\n", delta);
- nn_log_xqos (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
- nn_log_xqos (DDS_LC_ERROR, &logcfg, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
MPT_ASSERT (delta == 0, "writer %zu %zu matched reader QoS mismatch\n", i, j);
dds_delete_qos (ep->qos);
@@ -423,8 +427,8 @@ MPT_ProcessEntry (rw_subscriber,
struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "matched writer: delta = %"PRIx64"\n", delta);
- nn_log_xqos (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
- nn_log_xqos (DDS_LC_ERROR, &logcfg, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
+ ddsi_xqos_log (DDS_LC_ERROR, &logcfg, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
MPT_ASSERT (delta == 0, "reader %zu %zu matched writer QoS mismatch\n", i, j);
dds_delete_qos (ep->qos);
diff --git a/src/security/core/include/dds/security/core/dds_security_fsm.h b/src/security/core/include/dds/security/core/dds_security_fsm.h
index 198c1c4..503c5f6 100644
--- a/src/security/core/include/dds/security/core/dds_security_fsm.h
+++ b/src/security/core/include/dds/security/core/dds_security_fsm.h
@@ -14,7 +14,7 @@
#define DDS_SECURITY_FSM_H
#include "dds/ddsrt/time.h"
-#include "dds/ddsi/q_globals.h"
+#include "dds/ddsi/ddsi_domaingv.h"
#if defined (__cplusplus)
extern "C" {
@@ -176,7 +176,7 @@ dds_security_fsm_free(struct dds_security_fsm *fsm);
* @return Returns the new fsm control on success. Null on failure.
*/
DDS_EXPORT struct dds_security_fsm_control *
-dds_security_fsm_control_create (struct q_globals *gv);
+dds_security_fsm_control_create (struct ddsi_domaingv *gv);
/**
* Frees the fsm control and the allocated fsm's.
diff --git a/src/security/core/src/dds_security_fsm.c b/src/security/core/src/dds_security_fsm.c
index 4fa9d8e..ce1a2bb 100644
--- a/src/security/core/src/dds_security_fsm.c
+++ b/src/security/core/src/dds_security_fsm.c
@@ -66,7 +66,7 @@ struct dds_security_fsm_control
ddsrt_mutex_t lock;
ddsrt_cond_t cond;
struct thread_state1 *ts;
- struct q_globals *gv;
+ struct ddsi_domaingv *gv;
struct dds_security_fsm *first_fsm;
struct dds_security_fsm *last_fsm;
struct fsm_event *event_queue;
@@ -179,7 +179,7 @@ static void fsm_check_auto_state_change (struct dds_security_fsm *fsm)
}
}
-static void fsm_state_change (struct dds_security_fsm_control *control, struct fsm_event *event)
+static void fsm_state_change (struct thread_state1 *ts1, struct dds_security_fsm_control *control, struct fsm_event *event)
{
struct dds_security_fsm *fsm = event->fsm;
int event_id = event->event_id;
@@ -199,10 +199,14 @@ static void fsm_state_change (struct dds_security_fsm_control *control, struct f
set_state_timer (fsm);
ddsrt_mutex_unlock (&control->lock);
+
+ thread_state_asleep (ts1);
if (fsm->transitions[i].func)
fsm->transitions[i].func (fsm, fsm->arg);
if (fsm->current && fsm->current->func)
fsm->current->func (fsm, fsm->arg);
+
+ thread_state_awake (ts1, control->gv);
ddsrt_mutex_lock (&control->lock);
fsm_check_auto_state_change (fsm);
break;
@@ -241,9 +245,8 @@ static void fsm_handle_timeout (struct dds_security_fsm_control *control, struct
static uint32_t handle_events (struct dds_security_fsm_control *control)
{
struct thread_state1 * const ts1 = lookup_thread_state ();
-
- ddsrt_mutex_lock (&control->lock);
thread_state_awake (ts1, control->gv);
+ ddsrt_mutex_lock (&control->lock);
while (control->running)
{
if (control->event_queue)
@@ -253,7 +256,7 @@ static uint32_t handle_events (struct dds_security_fsm_control *control)
control->event_queue = event->next;
if (control->event_queue)
control->event_queue->prev = NULL;
- fsm_state_change (control, event);
+ fsm_state_change (ts1, control, event);
ddsrt_free (event);
}
else
@@ -263,7 +266,7 @@ static uint32_t handle_events (struct dds_security_fsm_control *control)
if (timeout > dds_time ())
{
thread_state_asleep (ts1);
- (void)ddsrt_cond_waituntil( &control->cond, &control->lock, timeout);
+ (void)ddsrt_cond_waituntil (&control->cond, &control->lock, timeout);
thread_state_awake (ts1, control->gv);
}
else
@@ -273,9 +276,8 @@ static uint32_t handle_events (struct dds_security_fsm_control *control)
}
}
}
- thread_state_asleep (ts1);
ddsrt_mutex_unlock (&control->lock);
-
+ thread_state_asleep (ts1);
return 0;
}
@@ -456,7 +458,7 @@ static void fsm_delete (struct dds_security_fsm_control *control, struct dds_sec
ddsrt_free(fsm);
}
-struct dds_security_fsm_control * dds_security_fsm_control_create (struct q_globals *gv)
+struct dds_security_fsm_control * dds_security_fsm_control_create (struct ddsi_domaingv *gv)
{
struct dds_security_fsm_control *control;
diff --git a/src/security/core/tests/plugin_loading/security_config.c b/src/security/core/tests/plugin_loading/security_config.c
index 5e95683..3c91f60 100644
--- a/src/security/core/tests/plugin_loading/security_config.c
+++ b/src/security/core/tests/plugin_loading/security_config.c
@@ -20,7 +20,7 @@
#include "dds/ddsrt/environ.h"
#include "dds/ddsrt/heap.h"
#include "dds/ddsi/q_misc.h"
-#include "dds/ddsi/q_xqos.h"
+#include "dds/ddsi/ddsi_xqos.h"
#include "dds/security/dds_security_api_defs.h"
@@ -39,6 +39,32 @@
" initFunction=\"init_access_control\"" \
" finalizeFunction=\"finalize_access_control\" />"
+#define PROPLIST(auth, crypto, ac, pre_str, post_str, binprops) \
+ "property_list={" pre_str \
+ "0:\"dds.sec.auth.library.path\":\""auth"\"," \
+ "0:\"dds.sec.auth.library.init\":\"init_authentication\"," \
+ "0:\"dds.sec.auth.library.finalize\":\"finalize_authentication\"," \
+ "0:\"dds.sec.crypto.library.path\":\""crypto"\"," \
+ "0:\"dds.sec.crypto.library.init\":\"init_crypto\"," \
+ "0:\"dds.sec.crypto.library.finalize\":\"finalize_crypto\"," \
+ "0:\"dds.sec.access.library.path\":\""ac"\"," \
+ "0:\"dds.sec.access.library.init\":\"init_access_control\"," \
+ "0:\"dds.sec.access.library.finalize\":\"finalize_access_control\"," \
+ "0:\"dds.sec.auth.identity_ca\":\"testtext_IdentityCA_testtext\"," \
+ "0:\"dds.sec.auth.private_key\":\"testtext_PrivateKey_testtext\"," \
+ "0:\"dds.sec.auth.identity_certificate\":\"testtext_IdentityCertificate_testtext\"," \
+ "0:\"dds.sec.access.permissions_ca\":\"file:Permissions_CA.pem\"," \
+ "0:\"dds.sec.access.governance\":\"file:Governance.p7s\"," \
+ "0:\"dds.sec.access.permissions\":\"file:Permissions.p7s\"" \
+ post_str "}:{" binprops "}"
+#define PARTICIPANT_QOS(auth, crypto, ac, pre_str, post_str, binprops) \
+ "PARTICIPANT * QOS={*" PROPLIST (auth, crypto, ac, pre_str, post_str, binprops) "*"
+#define PARTICIPANT_QOS_ALL_OK(pre_str, post_str, binprops) \
+ PARTICIPANT_QOS (MOCKLIB_PATH ("dds_security_authentication_all_ok"), \
+ MOCKLIB_PATH ("dds_security_cryptography_all_ok"), \
+ MOCKLIB_PATH ("dds_security_access_control_all_ok"), \
+ pre_str, post_str, binprops)
+
#define URI_VARIABLE DDS_PROJECT_NAME_NOSPACE_CAPS"_URI"
/*
@@ -52,6 +78,7 @@ static uint32_t found;
static void logger(void *ptr, const dds_log_data_t *data)
{
char **expected = (char**)ptr;
+ fputs (data->message, stdout);
for (uint32_t i = 0; expected[i] != NULL; i++) {
if (ddsi2_patmatch(expected[i], data->message)) {
found |= (uint32_t)(1 << i);
@@ -196,23 +223,7 @@ CU_Test(ddsc_security_config, all, .init = ddsrt_init, .fini = ddsrt_fini)
"config: Domain/DDSSecurity/Cryptographic/Library[@initFunction]: init_crypto*",
"config: Domain/DDSSecurity/Cryptographic/Library[@finalizeFunction]: finalize_crypto*",
/* The config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0},"
- "{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,testtext_Password_testtext,0},"
- "{dds.sec.auth.trusted_ca_dir,testtext_Dir_testtext,0}}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", ",0:\"dds.sec.auth.password\":\"testtext_Password_testtext\",0:\"dds.sec.auth.trusted_ca_dir\":\"testtext_Dir_testtext\"", ""),
NULL
};
const char *sec_config =
@@ -287,23 +298,7 @@ CU_Test(ddsc_security_config, security, .init = ddsrt_init, .fini = ddsrt_fini)
"config: Domain/DDSSecurity/Cryptographic/Library[@initFunction]: init_crypto*",
"config: Domain/DDSSecurity/Cryptographic/Library[@finalizeFunction]: finalize_crypto*",
/* The config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0},"
- "{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,,0},"
- "{dds.sec.auth.trusted_ca_dir,,0}}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", ",0:\"dds.sec.auth.password\":\"\",0:\"dds.sec.auth.trusted_ca_dir\":\"\"", ""),
NULL
};
@@ -373,22 +368,7 @@ CU_Test(ddsc_security_config, deprecated, .init = ddsrt_init, .fini = ddsrt_fini
"config: Domain/DDSSecurity/Cryptographic/Library[@initFunction]: init_crypto*",
"config: Domain/DDSSecurity/Cryptographic/Library[@finalizeFunction]: finalize_crypto*",
/* The config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={"
- "{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},{dds.sec.access.library.finalize,finalize_access_control,0},{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,testtext_Password_testtext,0},"
- "{dds.sec.auth.trusted_ca_dir,testtext_Dir_testtext,0}}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", ",0:\"dds.sec.auth.password\":\"testtext_Password_testtext\",0:\"dds.sec.auth.trusted_ca_dir\":\"testtext_Dir_testtext\"", ""),
NULL
};
@@ -444,24 +424,7 @@ CU_Test(ddsc_security_config, qos, .init = ddsrt_init, .fini = ddsrt_fini)
/* Expected traces when creating participant with the security elements. */
const char *log_expected[] = {
/* The config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={"
- "{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,testtext_Password_testtext,0},"
- "{dds.sec.auth.trusted_ca_dir,file:/test/dir,0},"
- "{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0}}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", ",0:\"dds.sec.auth.password\":\"testtext_Password_testtext\",0:\"dds.sec.auth.trusted_ca_dir\":\"file:/test/dir\"", ""),
NULL
};
@@ -473,16 +436,9 @@ CU_Test(ddsc_security_config, qos, .init = ddsrt_init, .fini = ddsrt_fini)
dds_set_log_sink(&logger, (void*)log_expected);
dds_set_trace_sink(&logger, (void*)log_expected);
- /* Create the qos */
+ /* Create the qos -- the properties are dumped in the order in which they are set, so for
+ PARTICIPANT_QOS_ALL_OK to work, the order must match that one */
CU_ASSERT_FATAL((qos = dds_create_qos()) != NULL);
- dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_IdentityCA_testtext");
- dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_PrivateKey_testtext");
- dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_IdentityCertificate_testtext");
- dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:Permissions_CA.pem");
- dds_qset_prop(qos, "dds.sec.access.governance", "file:Governance.p7s");
- dds_qset_prop(qos, "dds.sec.access.permissions", "file:Permissions.p7s");
- dds_qset_prop(qos, "dds.sec.auth.password", "testtext_Password_testtext");
- dds_qset_prop(qos, "dds.sec.auth.trusted_ca_dir", "file:/test/dir");
dds_qset_prop(qos, "dds.sec.auth.library.path", ""MOCKLIB_PATH("dds_security_authentication_all_ok")"");
dds_qset_prop(qos, "dds.sec.auth.library.init", "init_authentication");
dds_qset_prop(qos, "dds.sec.auth.library.finalize", "finalize_authentication");
@@ -492,6 +448,14 @@ CU_Test(ddsc_security_config, qos, .init = ddsrt_init, .fini = ddsrt_fini)
dds_qset_prop(qos, "dds.sec.access.library.path", ""MOCKLIB_PATH("dds_security_access_control_all_ok")"");
dds_qset_prop(qos, "dds.sec.access.library.init", "init_access_control");
dds_qset_prop(qos, "dds.sec.access.library.finalize", "finalize_access_control");
+ dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_IdentityCA_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_PrivateKey_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_IdentityCertificate_testtext");
+ dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:Permissions_CA.pem");
+ dds_qset_prop(qos, "dds.sec.access.governance", "file:Governance.p7s");
+ dds_qset_prop(qos, "dds.sec.access.permissions", "file:Permissions.p7s");
+ dds_qset_prop(qos, "dds.sec.auth.password", "testtext_Password_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.trusted_ca_dir", "file:/test/dir");
/* Create participant with security config in qos. */
found = 0;
@@ -513,27 +477,8 @@ CU_Test(ddsc_security_config, qos_props, .init = ddsrt_init, .fini = ddsrt_fini)
/* Expected traces when creating participant with the security elements. */
const char *log_expected[] = {
/* The config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={"
- "{test.prop1,testtext_value1_testtext,0},"
- "{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,testtext_Password_testtext,0},"
- "{dds.sec.auth.trusted_ca_dir,file:/test/dir,0},"
- "{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0},"
- "{test.prop2,testtext_value2_testtext,0}}"
- "binary_value={{test.bprop1,(3,*),0}}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", ",0:\"dds.sec.auth.password\":\"testtext_Password_testtext\",0:\"dds.sec.auth.trusted_ca_dir\":\"file:/test/dir\",0:\"test.prop1\":\"testtext_value1_testtext\",0:\"test.prop2\":\"testtext_value2_testtext\"",
+ "0:\"test.bprop1\":3<1,2,3>"),
NULL
};
@@ -545,19 +490,10 @@ CU_Test(ddsc_security_config, qos_props, .init = ddsrt_init, .fini = ddsrt_fini)
dds_set_log_sink(&logger, (void*)log_expected);
dds_set_trace_sink(&logger, (void*)log_expected);
- /* Create the qos */
+ /* Create the qos -- the properties are dumped in the order in which they are set, so for
+ PARTICIPANT_QOS_ALL_OK to work, the order must match that one */
unsigned char bvalue[3] = { 0x01, 0x02, 0x03 };
CU_ASSERT_FATAL((qos = dds_create_qos()) != NULL);
- dds_qset_prop(qos, "test.prop1", "testtext_value1_testtext");
- dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_IdentityCA_testtext");
- dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_PrivateKey_testtext");
- dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_IdentityCertificate_testtext");
- dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:Permissions_CA.pem");
- dds_qset_prop(qos, "dds.sec.access.governance", "file:Governance.p7s");
- dds_qset_prop(qos, "dds.sec.access.permissions", "file:Permissions.p7s");
- dds_qset_prop(qos, "dds.sec.auth.password", "testtext_Password_testtext");
- dds_qset_prop(qos, "dds.sec.auth.trusted_ca_dir", "file:/test/dir");
-
dds_qset_prop(qos, "dds.sec.auth.library.path", ""MOCKLIB_PATH("dds_security_authentication_all_ok")"");
dds_qset_prop(qos, "dds.sec.auth.library.init", "init_authentication");
dds_qset_prop(qos, "dds.sec.auth.library.finalize", "finalize_authentication");
@@ -567,10 +503,17 @@ CU_Test(ddsc_security_config, qos_props, .init = ddsrt_init, .fini = ddsrt_fini)
dds_qset_prop(qos, "dds.sec.access.library.path", ""MOCKLIB_PATH("dds_security_access_control_all_ok")"");
dds_qset_prop(qos, "dds.sec.access.library.init", "init_access_control");
dds_qset_prop(qos, "dds.sec.access.library.finalize", "finalize_access_control");
-
- dds_qset_prop(qos, "test.prop2", "testtext_value2_testtext");
-
dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_IdentityCA_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_PrivateKey_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_IdentityCertificate_testtext");
+ dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:Permissions_CA.pem");
+ dds_qset_prop(qos, "dds.sec.access.governance", "file:Governance.p7s");
+ dds_qset_prop(qos, "dds.sec.access.permissions", "file:Permissions.p7s");
+ dds_qset_prop(qos, "dds.sec.auth.password", "testtext_Password_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.trusted_ca_dir", "file:/test/dir");
+
+ dds_qset_prop(qos, "test.prop1", "testtext_value1_testtext");
+ dds_qset_prop(qos, "test.prop2", "testtext_value2_testtext");
dds_qset_bprop(qos, "test.bprop1", bvalue, 3);
@@ -595,23 +538,7 @@ CU_Test(ddsc_security_config, config_qos, .init = ddsrt_init, .fini = ddsrt_fini
const char *log_expected[] = {
/* The security settings from qos properties should have been parsed into the participant QoS. */
"new_participant(*): using security settings from QoS*",
- "PARTICIPANT * QOS={*property_list={value={"
- "{dds.sec.auth.identity_ca,testtext_QOS_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_QOS_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_QOS_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:QOS_Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:QOS_Governance.p7s,0},"
- "{dds.sec.access.permissions,file:QOS_Permissions.p7s,0},"
- "{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0}"
- "}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("", "", ""),
NULL
};
@@ -633,23 +560,24 @@ CU_Test(ddsc_security_config, config_qos, .init = ddsrt_init, .fini = ddsrt_fini
dds_entity_t participant;
dds_qos_t * qos;
+ /* Create the qos -- the properties are dumped in the order in which they are set, so for
+ PARTICIPANT_QOS_ALL_OK to work, the order must match that one */
CU_ASSERT_FATAL((qos = dds_create_qos()) != NULL);
- dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_QOS_IdentityCA_testtext");
- dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_QOS_PrivateKey_testtext");
- dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_QOS_IdentityCertificate_testtext");
- dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:QOS_Permissions_CA.pem");
- dds_qset_prop(qos, "dds.sec.access.governance", "file:QOS_Governance.p7s");
- dds_qset_prop(qos, "dds.sec.access.permissions", "file:QOS_Permissions.p7s");
-
- dds_qset_prop(qos, DDS_SEC_PROP_AUTH_LIBRARY_PATH, ""MOCKLIB_PATH("dds_security_authentication_all_ok")"");
- dds_qset_prop(qos, DDS_SEC_PROP_AUTH_LIBRARY_INIT, "init_authentication");
- dds_qset_prop(qos, DDS_SEC_PROP_AUTH_LIBRARY_FINALIZE, "finalize_authentication");
- dds_qset_prop(qos, DDS_SEC_PROP_CRYPTO_LIBRARY_PATH, ""MOCKLIB_PATH("dds_security_cryptography_all_ok")"");
- dds_qset_prop(qos, DDS_SEC_PROP_CRYPTO_LIBRARY_INIT, "init_crypto");
- dds_qset_prop(qos, DDS_SEC_PROP_CRYPTO_LIBRARY_FINALIZE, "finalize_crypto");
- dds_qset_prop(qos, DDS_SEC_PROP_ACCESS_LIBRARY_PATH, ""MOCKLIB_PATH("dds_security_access_control_all_ok")"");
- dds_qset_prop(qos, DDS_SEC_PROP_ACCESS_LIBRARY_INIT, "init_access_control");
- dds_qset_prop(qos, DDS_SEC_PROP_ACCESS_LIBRARY_FINALIZE, "finalize_access_control");
+ dds_qset_prop(qos, "dds.sec.auth.library.path", ""MOCKLIB_PATH("dds_security_authentication_all_ok")"");
+ dds_qset_prop(qos, "dds.sec.auth.library.init", "init_authentication");
+ dds_qset_prop(qos, "dds.sec.auth.library.finalize", "finalize_authentication");
+ dds_qset_prop(qos, "dds.sec.crypto.library.path", ""MOCKLIB_PATH("dds_security_cryptography_all_ok")"");
+ dds_qset_prop(qos, "dds.sec.crypto.library.init", "init_crypto");
+ dds_qset_prop(qos, "dds.sec.crypto.library.finalize", "finalize_crypto");
+ dds_qset_prop(qos, "dds.sec.access.library.path", ""MOCKLIB_PATH("dds_security_access_control_all_ok")"");
+ dds_qset_prop(qos, "dds.sec.access.library.init", "init_access_control");
+ dds_qset_prop(qos, "dds.sec.access.library.finalize", "finalize_access_control");
+ dds_qset_prop(qos, "dds.sec.auth.identity_ca", "testtext_IdentityCA_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.private_key", "testtext_PrivateKey_testtext");
+ dds_qset_prop(qos, "dds.sec.auth.identity_certificate", "testtext_IdentityCertificate_testtext");
+ dds_qset_prop(qos, "dds.sec.access.permissions_ca", "file:Permissions_CA.pem");
+ dds_qset_prop(qos, "dds.sec.access.governance", "file:Governance.p7s");
+ dds_qset_prop(qos, "dds.sec.access.permissions", "file:Permissions.p7s");
/* Set up the trace sinks to detect the config parsing. */
dds_set_log_mask(DDS_LC_FATAL | DDS_LC_ERROR | DDS_LC_WARNING | DDS_LC_CONFIG);
@@ -677,24 +605,7 @@ CU_Test(ddsc_security_config, other_prop, .init = ddsrt_init, .fini = ddsrt_fini
* qos containing only non-security properties. */
const char *log_expected[] = {
/* The security settings from config should have been parsed into the participant QoS. */
- "PARTICIPANT * QOS={*property_list={value={{test.dds.sec.prop1,testtext_value1_testtext,0},"
- "{dds.sec.auth.library.path,"MOCKLIB_PATH("dds_security_authentication_all_ok")",0},"
- "{dds.sec.auth.library.init,init_authentication,0},"
- "{dds.sec.auth.library.finalize,finalize_authentication,0},"
- "{dds.sec.crypto.library.path,"MOCKLIB_PATH("dds_security_cryptography_all_ok")",0},"
- "{dds.sec.crypto.library.init,init_crypto,0},"
- "{dds.sec.crypto.library.finalize,finalize_crypto,0},"
- "{dds.sec.access.library.path,"MOCKLIB_PATH("dds_security_access_control_all_ok")",0},"
- "{dds.sec.access.library.init,init_access_control,0},"
- "{dds.sec.access.library.finalize,finalize_access_control,0},"
- "{dds.sec.auth.identity_ca,testtext_IdentityCA_testtext,0},"
- "{dds.sec.auth.private_key,testtext_PrivateKey_testtext,0},"
- "{dds.sec.auth.identity_certificate,testtext_IdentityCertificate_testtext,0},"
- "{dds.sec.access.permissions_ca,file:Permissions_CA.pem,0},"
- "{dds.sec.access.governance,file:Governance.p7s,0},"
- "{dds.sec.access.permissions,file:Permissions.p7s,0},"
- "{dds.sec.auth.password,testtext_Password_testtext,0},"
- "{dds.sec.auth.trusted_ca_dir,testtext_Dir_testtext,0}}binary_value={}}*}*",
+ PARTICIPANT_QOS_ALL_OK ("0:\"test.dds.sec.prop1\":\"testtext_value1_testtext\",", ",0:\"dds.sec.auth.password\":\"testtext_Password_testtext\",0:\"dds.sec.auth.trusted_ca_dir\":\"testtext_Dir_testtext\"", ""),
NULL
};
diff --git a/src/tools/ddsperf/cputime.c b/src/tools/ddsperf/cputime.c
index b94a473..6788e4a 100644
--- a/src/tools/ddsperf/cputime.c
+++ b/src/tools/ddsperf/cputime.c
@@ -184,6 +184,11 @@ bool record_cputime (struct record_cputime_state *state, const char *prefix, dds
return print_cputime (&state->s, prefix, false, true);
}
+double record_cputime_read_rss (const struct record_cputime_state *state)
+{
+ return state->s.maxrss;
+}
+
struct record_cputime_state *record_cputime_new (dds_entity_t wr)
{
ddsrt_thread_list_id_t tids[100];
@@ -251,6 +256,12 @@ bool record_cputime (struct record_cputime_state *state, const char *prefix, dds
(void) tnow;
}
+double record_cputime_read_rss (const struct record_cputime_state *state)
+{
+ (void) state;
+ return 0.0;
+}
+
struct record_cputime_state *record_cputime_new (dds_entity_t wr)
{
(void) wr;
diff --git a/src/tools/ddsperf/cputime.h b/src/tools/ddsperf/cputime.h
index 3216692..7574356 100644
--- a/src/tools/ddsperf/cputime.h
+++ b/src/tools/ddsperf/cputime.h
@@ -19,6 +19,7 @@ struct record_cputime_state;
struct record_cputime_state *record_cputime_new (dds_entity_t wr);
void record_cputime_free (struct record_cputime_state *state);
bool record_cputime (struct record_cputime_state *state, const char *prefix, dds_time_t tnow);
+double record_cputime_read_rss (const struct record_cputime_state *state);
bool print_cputime (const struct CPUStats *s, const char *prefix, bool print_host, bool is_fresh);
#endif
diff --git a/src/tools/ddsperf/ddsperf.c b/src/tools/ddsperf/ddsperf.c
index 8fe6eae..18eaad7 100644
--- a/src/tools/ddsperf/ddsperf.c
+++ b/src/tools/ddsperf/ddsperf.c
@@ -151,6 +151,18 @@ static dds_duration_t ping_intv;
pongs had been received */
static uint32_t ping_timeouts = 0;
+/* Maximum allowed increase in RSS between 2nd RSS sample and
+ final RSS sample: final one must be <=
+ init * (1 + rss_factor/100) + rss_term */
+static bool rss_check = false;
+static double rss_factor = 0;
+static double rss_term = 0;
+
+/* Minimum number of samples, minimum number of roundtrips to
+ declare the run a success */
+static uint64_t min_received = 0;
+static uint64_t min_roundtrips = 0;
+
static ddsrt_mutex_t disc_lock;
/* Publisher statistics and lock protecting it */
@@ -207,6 +219,7 @@ struct subthread_arg_pongstat {
uint64_t min, max;
uint64_t sum;
uint32_t cnt;
+ uint64_t totcnt;
uint64_t *raw;
};
@@ -733,6 +746,7 @@ static bool update_roundtrip (dds_instance_handle_t pubhandle, uint64_t tdelta,
if (x->cnt < PINGPONG_RAWSIZE)
x->raw[x->cnt] = tdelta;
x->cnt++;
+ x->totcnt++;
ddsrt_mutex_unlock (&pongstat_lock);
return allseen;
}
@@ -742,6 +756,7 @@ static bool update_roundtrip (dds_instance_handle_t pubhandle, uint64_t tdelta,
x->pphandle = get_pphandle_for_pubhandle (pubhandle);
x->min = x->max = x->sum = tdelta;
x->cnt = 1;
+ x->totcnt = 1;
x->raw = malloc (PINGPONG_RAWSIZE * sizeof (*x->raw));
x->raw[0] = tdelta;
npongstat++;
@@ -969,18 +984,24 @@ static void maybe_send_new_ping (dds_time_t tnow, dds_time_t *tnextping)
}
}
-static uint32_t subthread_waitset (void *varg)
+static dds_entity_t make_reader_waitset (dds_entity_t rd)
{
- struct subthread_arg * const arg = varg;
dds_entity_t ws;
int32_t rc;
ws = dds_create_waitset (dp);
if ((rc = dds_waitset_attach (ws, termcond, 0)) < 0)
error2 ("dds_waitset_attach (termcond, 0): %d\n", (int) rc);
- if ((rc = dds_set_status_mask (rd_data, DDS_DATA_AVAILABLE_STATUS)) < 0)
- error2 ("dds_set_status_mask (rd_data, DDS_DATA_AVAILABLE_STATUS): %d\n", (int) rc);
- if ((rc = dds_waitset_attach (ws, rd_data, 1)) < 0)
- error2 ("dds_waitset_attach (ws, rd_data, 1): %d\n", (int) rc);
+ if ((rc = dds_set_status_mask (rd, DDS_DATA_AVAILABLE_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS)) < 0)
+ error2 ("dds_set_status_mask (rd, DDS_DATA_AVAILABLE_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS): %d\n", (int) rc);
+ if ((rc = dds_waitset_attach (ws, rd, 1)) < 0)
+ error2 ("dds_waitset_attach (ws, rd, 1): %d\n", (int) rc);
+ return ws;
+}
+
+static uint32_t subthread_waitset (void *varg)
+{
+ struct subthread_arg * const arg = varg;
+ dds_entity_t ws = make_reader_waitset (rd_data);
while (!ddsrt_atomic_ld32 (&termflag))
{
if (!process_data (rd_data, arg))
@@ -998,15 +1019,7 @@ static uint32_t subthread_waitset (void *varg)
static uint32_t subpingthread_waitset (void *varg)
{
struct subthread_arg * const arg = varg;
- dds_entity_t ws;
- int32_t rc;
- ws = dds_create_waitset (dp);
- if ((rc = dds_waitset_attach (ws, termcond, 0)) < 0)
- error2 ("dds_waitset_attach (termcond, 0): %d\n", (int) rc);
- if ((rc = dds_set_status_mask (rd_ping, DDS_DATA_AVAILABLE_STATUS)) < 0)
- error2 ("dds_set_status_mask (rd_ping, DDS_DATA_AVAILABLE_STATUS): %d\n", (int) rc);
- if ((rc = dds_waitset_attach (ws, rd_ping, 1)) < 0)
- error2 ("dds_waitset_attach (ws, rd_ping, 1): %d\n", (int) rc);
+ dds_entity_t ws = make_reader_waitset (rd_ping);
while (!ddsrt_atomic_ld32 (&termflag))
{
int32_t nxs;
@@ -1020,15 +1033,7 @@ static uint32_t subpingthread_waitset (void *varg)
static uint32_t subpongthread_waitset (void *varg)
{
struct subthread_arg * const arg = varg;
- dds_entity_t ws;
- int32_t rc;
- ws = dds_create_waitset (dp);
- if ((rc = dds_waitset_attach (ws, termcond, 0)) < 0)
- error2 ("dds_waitset_attach (termcond, 0): %d\n", (int) rc);
- if ((rc = dds_set_status_mask (rd_pong, DDS_DATA_AVAILABLE_STATUS)) < 0)
- error2 ("dds_set_status_mask (rd_pong, DDS_DATA_AVAILABLE_STATUS): %d\n", (int) rc);
- if ((rc = dds_waitset_attach (ws, rd_pong, 1)) < 0)
- error2 ("dds_waitset_attach (ws, rd_pong, 1): %d\n", (int) rc);
+ dds_entity_t ws = make_reader_waitset (rd_pong);
while (!ddsrt_atomic_ld32 (&termflag))
{
int32_t nxs;
@@ -1101,7 +1106,7 @@ static dds_entity_t create_pong_writer (dds_instance_handle_t pphandle, const st
return wr_pong;
}
-static void delete_pong_writer (dds_instance_handle_t pphandle)
+static dds_entity_t delete_pong_writer (dds_instance_handle_t pphandle)
{
uint32_t i = 0;
dds_entity_t wr_pong = 0;
@@ -1118,8 +1123,7 @@ static void delete_pong_writer (dds_instance_handle_t pphandle)
}
}
ddsrt_mutex_unlock (&pongwr_lock);
- if (wr_pong)
- dds_delete (wr_pong);
+ return wr_pong;
}
static void free_ppant (void *vpp)
@@ -1143,6 +1147,7 @@ static void participant_data_listener (dds_entity_t rd, void *arg)
if (info.instance_state != DDS_ALIVE_INSTANCE_STATE)
{
ddsrt_avl_dpath_t dpath;
+ dds_entity_t pong_wr_to_del = 0;
ddsrt_mutex_lock (&disc_lock);
if ((pp = ddsrt_avl_lookup_dpath (&ppants_td, &ppants, &info.instance_handle, &dpath)) != NULL)
{
@@ -1151,7 +1156,7 @@ static void participant_data_listener (dds_entity_t rd, void *arg)
if (pp->handle != dp_handle || ignorelocal == DDS_IGNORELOCAL_NONE)
{
- delete_pong_writer (pp->handle);
+ pong_wr_to_del = delete_pong_writer (pp->handle);
n_pong_expected_delta--;
}
@@ -1161,6 +1166,7 @@ static void participant_data_listener (dds_entity_t rd, void *arg)
free_ppant (pp);
}
ddsrt_mutex_unlock (&disc_lock);
+ dds_delete (pong_wr_to_del);
}
else
{
@@ -1171,6 +1177,7 @@ static void participant_data_listener (dds_entity_t rd, void *arg)
/* only add unknown participants with the magic user_data value: DDSPerf:X:HOSTNAME, where X is decimal */
if (dds_qget_userdata (sample->qos, &vudata, &usz) && usz > 0)
{
+ bool make_pongwr = false;
const char *udata = vudata;
int has_reader, pos;
long pid;
@@ -1199,15 +1206,17 @@ static void participant_data_listener (dds_entity_t rd, void *arg)
ddsrt_fibheap_insert (&ppants_to_match_fhd, &ppants_to_match, pp);
ddsrt_avl_insert_ipath (&ppants_td, &ppants, pp, &ipath);
- if (pp->handle != dp_handle || ignorelocal == DDS_IGNORELOCAL_NONE)
- {
- struct guidstr guidstr;
- make_guidstr (&guidstr, &sample->key);
- create_pong_writer (pp->handle, &guidstr);
- n_pong_expected_delta++;
- }
+ make_pongwr = (pp->handle != dp_handle || ignorelocal == DDS_IGNORELOCAL_NONE);
}
ddsrt_mutex_unlock (&disc_lock);
+
+ if (make_pongwr)
+ {
+ struct guidstr guidstr;
+ make_guidstr (&guidstr, &sample->key);
+ create_pong_writer (pp->handle, &guidstr);
+ n_pong_expected_delta++;
+ }
}
dds_free (vudata);
}
@@ -1312,8 +1321,8 @@ static void subscription_matched_listener (dds_entity_t rd, const dds_subscripti
static void publication_matched_listener (dds_entity_t wr, const dds_publication_matched_status_t status, void *arg)
{
/* this only works because the listener is called for every match; but I don't think that is something the
- spec guarantees, and I don't think Cyclone should guarantee that either -- and if it isn't guaranteed
- _really_ needs the get_matched_... interfaces to not have to implement the matching logic ... */
+ spec guarantees, and I don't think Cyclone should guarantee that either -- and if it isn't guaranteed
+ _really_ needs the get_matched_... interfaces to not have to implement the matching logic ... */
(void) wr;
if (status.current_count_change > 0)
{
@@ -1326,8 +1335,8 @@ static void publication_matched_listener (dds_entity_t wr, const dds_publication
static void set_data_available_listener (dds_entity_t rd, const char *rd_name, dds_on_data_available_fn fn, void *arg)
{
/* This convoluted code is so that we leave all listeners unchanged, except the
- data_available one. There is no real need for these complications, but it is
- a nice exercise. */
+ data_available one. There is no real need for these complications, but it is
+ a nice exercise. */
dds_listener_t *listener = dds_create_listener (arg);
dds_return_t rc;
dds_lset_data_available (listener, fn);
@@ -1349,7 +1358,7 @@ static int cmp_uint64 (const void *va, const void *vb)
return (*a == *b) ? 0 : (*a < *b) ? -1 : 1;
}
-static void print_stats (dds_time_t tref, dds_time_t tnow, dds_time_t tprev, struct record_cputime_state *cputime_state, struct record_netload_state *netload_state)
+static bool print_stats (dds_time_t tref, dds_time_t tnow, dds_time_t tprev, struct record_cputime_state *cputime_state, struct record_netload_state *netload_state)
{
char prefix[128];
const double ts = (double) (tnow - tref) / 1e9;
@@ -1475,6 +1484,7 @@ static void print_stats (dds_time_t tref, dds_time_t tnow, dds_time_t tprev, str
if (output)
record_netload (netload_state, prefix, tnow);
fflush (stdout);
+ return output;
}
static void subthread_arg_init (struct subthread_arg *arg, dds_entity_t rd, uint32_t max_samples)
@@ -1561,8 +1571,14 @@ OPTIONS:\n\
-d DEV:BW report network load for device DEV with nominal\n\
bandwidth BW in bits/s (e.g., eth0:1e9)\n\
-D DUR run for at most DUR seconds\n\
- -N COUNT require at least COUNT matching participants\n\
- -M DUR require those participants to match within DUR seconds\n\
+ -Q KEY:VAL set success criteria\n\
+ rss:X%% max allowed increase in RSS, in %%\n\
+ rss:X max allowed increase in RSS, in MB\n\
+ samples:N min received messages by \"sub\"\n\
+ roundtrips:N min roundtrips for \"pong\"\n\
+ minmatch:N require >= N matching participants\n\
+ maxwait:DUR require those participants to match\n\
+ within DUR seconds\n\
-R TREF timestamps in the output relative to TREF instead of\n\
process start\n\
-i ID use domain ID instead of the default domain\n\
@@ -1873,7 +1889,7 @@ int main (int argc, char *argv[])
argv0 = argv[0];
- while ((opt = getopt (argc, argv, "cd:D:i:n:k:uLK:T:M:N:R:h")) != EOF)
+ while ((opt = getopt (argc, argv, "cd:D:i:n:k:uLK:T:Q:R:h")) != EOF)
{
switch (opt)
{
@@ -1903,11 +1919,28 @@ int main (int argc, char *argv[])
else if (strcmp (optarg, "UK1024") == 0) topicsel = UK1024;
else error3 ("%s: unknown topic\n", optarg);
break;
- case 'M': maxwait = atof (optarg); if (maxwait <= 0) maxwait = HUGE_VAL; break;
- case 'N': minmatch = (unsigned) atoi (optarg); break;
+ case 'Q': {
+ int pos;
+ double d;
+ unsigned long n;
+ if (sscanf (optarg, "rss:%lf%n", &d, &pos) == 1 && (optarg[pos] == 0 || optarg[pos] == '%')) {
+ if (optarg[pos] == 0) rss_term = d * 1048576.0; else rss_factor = 1.0 + d / 100.0;
+ rss_check = true;
+ } else if (sscanf (optarg, "samples:%lu%n", &n, &pos) == 1 && optarg[pos] == 0) {
+ min_received = (uint64_t) n;
+ } else if (sscanf (optarg, "roundtrips:%lu%n", &n, &pos) == 1 && optarg[pos] == 0) {
+ min_roundtrips = (uint64_t) n;
+ } else if (sscanf (optarg, "maxwait:%lf%n", &maxwait, &pos) == 1 && optarg[pos] == 0) {
+ maxwait = (maxwait <= 0) ? HUGE_VAL : maxwait;
+ } else if (sscanf (optarg, "minmatch:%lu%n", &n, &pos) == 1 && optarg[pos] == 0) {
+ minmatch = (uint32_t) n;
+ } else {
+ error3 ("-Q%s: invalid success criterium\n", optarg);
+ }
+ break;
+ }
case 'R': tref = 0; sscanf (optarg, "%"SCNd64, &tref); break;
- case 'h': usage (); break;
- default: error3 ("-%c: unknown option\n", opt); break;
+ case 'h': default: usage (); break;
}
}
@@ -2012,11 +2045,17 @@ int main (int argc, char *argv[])
/* participants reader must exist before the "publication matched" or "subscription matched"
listener is invoked, or it won't be able to get the details (FIXME: even the DDS spec
has convenience functions for that ...) */
+ if ((rd_participants = dds_create_reader (dp, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL)) < 0)
+ error2 ("dds_create_reader(participants) failed: %d\n", (int) rd_participants);
+ /* set listener later: DATA_AVAILABLE still has the nasty habit of potentially triggering
+ before the reader is accessible to the application via its handle */
listener = dds_create_listener (NULL);
dds_lset_data_available (listener, participant_data_listener);
- if ((rd_participants = dds_create_reader (dp, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, listener)) < 0)
- error2 ("dds_create_reader(participants) failed: %d\n", (int) rd_participants);
+ dds_set_listener (rd_participants, listener);
dds_delete_listener (listener);
+ /* then there is the matter of data arriving prior to setting the listener ... this state
+ of affairs is undoubtedly a bug */
+ participant_data_listener (rd_participants, NULL);
if ((rd_subscriptions = dds_create_reader (dp, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL)) < 0)
error2 ("dds_create_reader(subscriptions) failed: %d\n", (int) rd_subscriptions);
if ((rd_publications = dds_create_reader (dp, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL)) < 0)
@@ -2161,7 +2200,7 @@ int main (int argc, char *argv[])
const bool pingpong_waitset = (ping_intv != DDS_NEVER && ignorelocal == DDS_IGNORELOCAL_NONE) || pingpongmode == SM_WAITSET;
if (pingpong_waitset)
{
- ddsrt_thread_create (&subpingtid, "ping", &attr, subpingthread_waitset, &subarg_pong);
+ ddsrt_thread_create (&subpingtid, "ping", &attr, subpingthread_waitset, &subarg_ping);
ddsrt_thread_create (&subpongtid, "pong", &attr, subpongthread_waitset, &subarg_pong);
}
else
@@ -2185,6 +2224,7 @@ int main (int argc, char *argv[])
dds_time_t tnext = tstart + DDS_SECS (1);
dds_time_t tlast = tstart;
dds_time_t tnextping = (ping_intv == DDS_INFINITY) ? DDS_NEVER : (ping_intv == 0) ? tstart + DDS_SECS (1) : tstart + ping_intv;
+ double rss_init = 0.0, rss_final = 0.0;
while (!ddsrt_atomic_ld32 (&termflag) && tnow < tstop)
{
dds_time_t twakeup = DDS_NEVER;
@@ -2250,12 +2290,17 @@ int main (int argc, char *argv[])
tnow = dds_time ();
if (tnext <= tnow)
{
- print_stats (tref, tnow, tlast, cputime_state, netload_state);
+ bool output;
+ output = print_stats (tref, tnow, tlast, cputime_state, netload_state);
tlast = tnow;
if (tnow > tnext + DDS_MSECS (500))
tnext = tnow + DDS_SECS (1);
else
tnext += DDS_SECS (1);
+
+ if (rss_init == 0.0 && matchcount >= minmatch && output)
+ rss_init = record_cputime_read_rss (cputime_state);
+ rss_final = record_cputime_read_rss (cputime_state);
}
/* If a "real" ping doesn't result in the expected number of pongs within a reasonable
@@ -2323,8 +2368,13 @@ int main (int argc, char *argv[])
dds_delete (rd_data);
uint64_t nlost = 0;
+ bool received_ok = true;
for (uint32_t i = 0; i < eseq_admin.nph; i++)
+ {
nlost += eseq_admin.stats[i].nlost;
+ if (eseq_admin.stats[i].nrecv < (uint64_t) min_received)
+ received_ok = false;
+ }
fini_eseq_admin (&eseq_admin);
subthread_arg_fini (&subarg_data);
subthread_arg_fini (&subarg_ping);
@@ -2336,8 +2386,13 @@ int main (int argc, char *argv[])
ddsrt_mutex_destroy (&pubstat_lock);
hist_free (pubstat_hist);
free (pongwr);
+ bool roundtrips_ok = true;
for (uint32_t i = 0; i < npongstat; i++)
+ {
+ if (pongstat[i].totcnt < min_roundtrips)
+ roundtrips_ok = false;
free (pongstat[i].raw);
+ }
free (pongstat);
bool ok = true;
@@ -2366,5 +2421,20 @@ int main (int argc, char *argv[])
printf ("[%"PRIdPID"] error: %"PRIu64" samples lost\n", ddsrt_getpid (), nlost);
ok = false;
}
+ if (!roundtrips_ok)
+ {
+ printf ("[%"PRIdPID"] error: too few roundtrips for some peers\n", ddsrt_getpid ());
+ ok = false;
+ }
+ if (!received_ok)
+ {
+ printf ("[%"PRIdPID"] error: too few samples received from some peers\n", ddsrt_getpid ());
+ ok = false;
+ }
+ if (rss_check && rss_final >= rss_init * rss_factor + rss_term)
+ {
+ printf ("[%"PRIdPID"] error: RSS grew too much (%f -> %f)\n", ddsrt_getpid (), rss_init, rss_final);
+ ok = false;
+ }
return ok ? 0 : 1;
}
diff --git a/src/tools/ddsperf/sanity.bash b/src/tools/ddsperf/sanity.bash
new file mode 100755
index 0000000..45f425e
--- /dev/null
+++ b/src/tools/ddsperf/sanity.bash
@@ -0,0 +1,23 @@
+exitcode=0
+# RSS/samples/roundtrip numbers are based on experimentation on Travis
+bin/ddsperf -L -D10 -n10 -Qminmatch:2 -Qrss:10% -Qrss:0.5 -Qsamples:300000 -Qroundtrips:3000 sub ping & ddsperf_pids=$!
+bin/ddsperf -L -D10 -n10 -Qminmatch:2 -Qrss:10% -Qrss:0.5 pub & ddsperf_pids="$ddsperf_pids $!"
+sleep 11
+for pid in $ddsperf_pids ; do
+ if kill -0 $pid 2>/dev/null ; then
+ echo "killing process $pid"
+ kill -9 $pid
+ exitcode=2
+ fi
+ wait $pid
+ x=$?
+ if [[ $x -gt $exitcode ]] ; then
+ exitcode=$x
+ fi
+done
+if [[ $exitcode -gt 0 ]] ; then
+ echo "** FAILED **"
+else
+ echo "** OK **"
+fi
+exit $exitcode
diff --git a/src/tools/decode-trace b/src/tools/decode-trace
index eedeee5..e534669 100755
--- a/src/tools/decode-trace
+++ b/src/tools/decode-trace
@@ -36,6 +36,7 @@ for (@showopts) {
my $topfmt = "%${topcolwidth}.${topcolwidth}s";
my $guidre = "[0-9a-f]+(?::[0-9a-f]+){3}";
my $gidre = "[0-9a-f]+(?::[0-9a-f]+){2}";
+my $leasere = "(?:L\\((?:[a-z]+ )?[0-9a-f:]+\\s+[0-9.]+\\)\\s*)+";
my %opstr = ("00" => "R ", "01" => "W ", # index by $stinfo.$dflag
"10" => " D ", "11" => "WD ",
"20" => " U", "21" => "W U",
@@ -258,7 +259,7 @@ while(<>) {
# decent proxy for that.
#
# FIXME: find a way of dealing with decimal representation ...
- if (/: ACKNACK\(F?#\d+:(\d+)\/(\d+):[01]* (?:L\([0-9a-f:]+\s+[0-9.]+\)\s*)?([0-9a-f]+(?::[0-9a-f]+){2}:[234]c7) -\> ([0-9a-f]+(?::[0-9a-f]+){2}:[234]c2) .*?(happy-now)?/) {
+ if (/: ACKNACK\(F?#\d+:(\d+)\/(\d+):[01]* (?:$leasere)?([0-9a-f]+(?::[0-9a-f]+){2}:[234]c7) -\> ([0-9a-f]+(?::[0-9a-f]+){2}:[234]c2) .*?(happy-now)?/) {
if (defined $5 || ($1 > 1 && $2 == 0 && version_at_least(6,6,4))) {
# happy-now should be enough, but historically DDSI2 advertised only data present in the WHC,
# which caused happy-now to not show up if the historical data ended on an unregister, because
@@ -266,7 +267,7 @@ while(<>) {
# last one written (that is, unregistered) (fixed in 6.6.4)
check_disccomplete("A", $3);
}
- } elsif (/: HEARTBEAT\(F?#\d+:(\d+)\.\.(\d+)\s+(?:L\([0-9a-f:]+\s+[0-9.]+\)\s*)?([0-9a-f]+(?::[0-9a-f]+){2}:[234]c2)/) {
+ } elsif (/: HEARTBEAT\(F?L?#\d+:(\d+)\.\.(\d+)\s+(?:$leasere)?([0-9a-f]+(?::[0-9a-f]+){2}:[234]c2)/) {
check_disccomplete("H", $3);
# if there is no data and final is set there might be no ACK
check_disccomplete("B", $3) if $2 < $1;
@@ -351,8 +352,10 @@ while(<>) {
$rwguid{$tid} = $guid; # if $is_cyclone;
die "$guid $rwguid{$tid}" unless $guid eq $rwguid{$tid};
my $topic; my $type; my $groupcoh; my $partitions; my $keepall;
- if ($3 =~ /topic=([^,]+?),type=([^,]+?).*?,presentation=(\d:\d):\d,partition=\{([^}]*?)\}.*?,history=([01]):/) {
- $topic = $1; $type = $2; $groupcoh = ($3 eq "2:1"); $partitions = $4; $keepall = $5;
+ if ($qos =~ /topic(?:_name)?=([^,]+?),type(?:_name)=([^,]+?).*?,partition=\{([^}]*?)\}/) {
+ $topic = $1; $type = $2; $partitions = $3;
+ die unless $qos =~ /,history=([01]):/; $keepall = $1;
+ die unless $qos =~ /,presentation=(\d:\d):\d/; $groupcoh = ($1 eq "2:1");
unless (defined $rwguid{$tid} && ($ftrflag{$tid} || (defined $psgid{$tid} && defined $psguid{$tid} && defined $rwgid{$tid})) || 1) { # $is_cyclone
die;
}
@@ -622,15 +625,14 @@ while(<>) {
my $h = ($kind eq "READER") ? \%prd : \%pwr;
my $hk = ($kind eq "READER") ? "prd" : "pwr";
my $qos = $3;
- unless ($3 =~ /topic=([^,]+?),type=([^,]+?),presentation=(\d+):\d+:\d+,partition=\{([^}]*?)\}.*?,durability=(\d+)/) {
+ unless ($3 =~ /topic(?:_name)?=([^,]+?),type(?:_name)?=([^,]+?),(?:.+?,)?partition=\{([^}]*?)\}/) {
die unless $prwguid =~ /[4c][27]$/;
}
- my $topic = $1; my $type = $2; my $access_scope = $3; my $partitions = $4; my $durkind = $5;
+ my $topic = $1; my $type = $2; my $partitions = $3;
(my $ppguid = $prwguid) =~ s/:[0-9a-f]+$/:1c1/;
die unless exists $proxypp{$ppguid} && !defined $proxypp{$ppguid}->{tdel};
my @ps = split ',', $partitions;
my $stopic = make_stopic($partitions, $topic);
- #print "$kind $topic\n" if $durkind >= 2 && ($kind eq "READER" || $access_scope >= 2);
my $prw = { guid => $prwguid, ppguid => $ppguid,
topic => $topic, stopic => $stopic, type => $type, partition => \@ps,
matches => {}, checklost => 0, suppressbegin => 0, tcreate => $ts, tstamps => {} };
@@ -745,7 +747,7 @@ while(<>) {
if $nlost > 0 && $shows{rematch};
delete $prd->{matches}->{$wrguid}->{seqp1del};
}
- } elsif (/ACKNACK\(F?#\d+:(\d+)\/\d+:([01]*) (?:L\(:1c1 [0-9.]+\) )?($guidre) -> ($guidre)(\??)/o) {
+ } elsif (/ACKNACK\(F?#\d+:(\d+)\/\d+:([01]*) (?:$leasere)?($guidre) -> ($guidre)(\??)/o) {
my $seqp1 = $1; my $nackset = $2; my $prdguid = hexify($3); my $wrguid = hexify($4); my $wrknown = ($5 eq "");
my $wr = $wr{$wrguid};
my $cnt = ($nackset =~ y/1//);
@@ -904,7 +906,7 @@ while(<>) {
}
}
}
- } elsif (/HEARTBEAT\(F?#\d+:(\d+)\.\.(\d+) ($guidre)/o) {
+ } elsif (/HEARTBEAT\(F?L?#\d+:(\d+)\.\.(\d+) ($guidre)/o) {
my $prdguid = hexify($3);
(my $ppguid = $prdguid) =~ s/:[0-9a-f]+$/:1c1/;
$proxypp{$ppguid}->{non_spdp_seen} = 1 if exists $proxypp{$ppguid} && !defined $proxypp{$ppguid}->{tdel};
@@ -1475,7 +1477,7 @@ not necessarily the 4th field in, say, AWK):
EOT
;
exit 1;
- return;
+ return;
}
sub fmtblurb {