niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rework plist/qos printing, diffing and logging

Browse source 
* Use the parameter tables to pretty-print QoS and plist, rather than a
  hard-coded function supporting only the QoS.

* Support diffing two plists: a single table-driven function can handle
  both nn_plist_t and ddsi_qos_t, and it removes the discrepancy between
  the two types.

* Log content of discovery samples in trace rather than merely printing
  "(plist)"

Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
Erik Boasson 2020-01-08 12:26:21 +01:00 • committed by eboasson
parent 6bd28fb4b1
commit 08c9db0934
25 changed files with 575 additions and 320 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/core/ddsc/src/dds_topic.c
View file

@ -482,6 +482,7 @@ dds_entity_t dds_create_topic (dds_entity_t participant, const dds_topic_descrip
st = dds_alloc (sizeof (*st));
ddsi_sertopic_init (&st->c, name, desc->m_typename, &ddsi_sertopic_ops_default, desc->m_nkeys ? &ddsi_serdata_ops_cdr : &ddsi_serdata_ops_cdr_nokey, (desc->m_nkeys == 0));
st->gv = &ppent->m_domain->gv;
st->native_encoding_identifier = (DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE);
st->serpool = ppent->m_domain->gv.serpool;
st->type = (void*) desc;

6
src/core/ddsi/include/dds/ddsi/ddsi_ipaddr.h
View file

@ -18,11 +18,11 @@
extern "C" {
#endif
enum ddsi_nearby_address_result ddsi_ipaddr_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);
enum ddsi_nearby_address_result ddsi_ipaddr_is_nearby_address (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface *interf);
enum ddsi_locator_from_string_result ddsi_ipaddr_from_string (ddsi_tran_factory_t tran, nn_locator_t *loc, const char *str, int32_t kind);
int ddsi_ipaddr_compare (const struct sockaddr *const sa1, const struct sockaddr *const sa2);
char *ddsi_ipaddr_to_string (ddsi_tran_factory_t tran, char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port);
void ddsi_ipaddr_to_loc (nn_locator_t *dst, const struct sockaddr *src, int32_t kind);
char *ddsi_ipaddr_to_string (char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port);
void ddsi_ipaddr_to_loc (const struct ddsi_tran_factory *tran, nn_locator_t *dst, const struct sockaddr *src, int32_t kind);
void ddsi_ipaddr_from_loc (struct sockaddr_storage *dst, const nn_locator_t *src);
#if defined (__cplusplus)

1
src/core/ddsi/include/dds/ddsi/ddsi_serdata_default.h
View file

@ -107,6 +107,7 @@ struct ddsi_sertopic_default {
struct ddsi_sertopic c;
uint16_t native_encoding_identifier; /* (PL_)?CDR_(LE|BE) */
struct serdatapool *serpool;
struct q_globals *gv;
struct dds_topic_descriptor * type;
unsigned nkeys;

10
src/core/ddsi/include/dds/ddsi/ddsi_tran.h
View file

@ -78,7 +78,7 @@ enum ddsi_nearby_address_result {
DNAR_SAME
};
typedef enum ddsi_nearby_address_result (*ddsi_is_nearby_address_fn_t) (ddsi_tran_factory_t tran, const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface *interf);
typedef enum ddsi_nearby_address_result (*ddsi_is_nearby_address_fn_t) (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface *interf);
enum ddsi_locator_from_string_result {
AFSR_OK, /* conversion succeeded */
@ -89,7 +89,7 @@ enum ddsi_locator_from_string_result {
typedef enum ddsi_locator_from_string_result (*ddsi_locator_from_string_fn_t) (ddsi_tran_factory_t tran, nn_locator_t *loc, const char *str);
typedef char * (*ddsi_locator_to_string_fn_t) (ddsi_tran_factory_t tran, char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port);
typedef char * (*ddsi_locator_to_string_fn_t) (char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port);
typedef int (*ddsi_enumerate_interfaces_fn_t) (ddsi_tran_factory_t tran, enum transport_selector transport_selector, ddsrt_ifaddrs_t **interfs);
@ -255,7 +255,7 @@ void ddsi_conn_transfer_group_membership (ddsi_tran_conn_t conn, ddsi_tran_conn_
int ddsi_conn_rejoin_transferred_mcgroups (ddsi_tran_conn_t conn);
int ddsi_is_mcaddr (const struct q_globals *gv, const nn_locator_t *loc);
int ddsi_is_ssm_mcaddr (const struct q_globals *gv, const nn_locator_t *loc);
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);
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);
@ -270,8 +270,8 @@ enum ddsi_locator_from_string_result ddsi_locator_from_string (const struct q_gl
*/
#define DDSI_LOCSTRLEN 70
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_no_port (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);
char *ddsi_locator_to_string_no_port (char *dst, size_t sizeof_dst, const nn_locator_t *loc);
int ddsi_enumerate_interfaces (ddsi_tran_factory_t factory, enum transport_selector transport_selector, ddsrt_ifaddrs_t **interfs);

2
src/core/ddsi/include/dds/ddsi/q_plist.h
View file

@ -233,6 +233,8 @@ DDS_EXPORT void nn_plist_unalias (nn_plist_t *plist);
DDS_EXPORT void nn_plist_addtomsg (struct nn_xmsg *m, const nn_plist_t *ps, uint64_t pwanted, uint64_t qwanted);
DDS_EXPORT void nn_plist_init_default_participant (nn_plist_t *plist);
DDS_EXPORT void nn_plist_delta (uint64_t *pdelta, uint64_t *qdelta, const nn_plist_t *x, const nn_plist_t *y, uint64_t pmask, uint64_t qmask);
DDS_EXPORT void nn_plist_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const nn_plist_t *plist);
DDS_EXPORT size_t nn_plist_print (char * __restrict buf, size_t bufsize, const nn_plist_t *plist);
struct nn_rmsg;
struct nn_rsample_info;

4
src/core/ddsi/include/dds/ddsi/q_protocol.h
View file

@ -58,9 +58,9 @@ typedef struct nn_fragment_number_set_header {
typedef int32_t nn_count_t;
#define DDSI_COUNT_MIN (-2147483647 - 1)
#define DDSI_COUNT_MAX (2147483647)
/* address field in locator maintained in network byte order, the rest
in host (yes: that's a FIXME) */
/* address field in locator maintained in network byte order, the rest in host */
typedef struct {
const struct ddsi_tran_factory *tran;
int32_t kind;
uint32_t port;
unsigned char address[16];

3
src/core/ddsi/include/dds/ddsi/q_xqos.h
View file

@ -319,7 +319,8 @@ DDS_EXPORT dds_return_t nn_xqos_valid (const struct ddsrt_log_cfg *logcfg, const
DDS_EXPORT void nn_xqos_mergein_missing (dds_qos_t *a, const dds_qos_t *b, uint64_t mask);
DDS_EXPORT uint64_t nn_xqos_delta (const dds_qos_t *a, const dds_qos_t *b, uint64_t mask);
DDS_EXPORT void nn_xqos_addtomsg (struct nn_xmsg *m, const dds_qos_t *xqos, uint64_t wanted);
DDS_EXPORT void nn_log_xqos (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos);
DDS_EXPORT void nn_xqos_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos);
DDS_EXPORT size_t nn_xqos_print (char * __restrict buf, size_t bufsize, const dds_qos_t *xqos);
DDS_EXPORT dds_qos_t *nn_xqos_dup (const dds_qos_t *src);
#if defined (__cplusplus)

13
src/core/ddsi/src/ddsi_ipaddr.c
View file

@ -54,11 +54,10 @@ int ddsi_ipaddr_compare (const struct sockaddr *const sa1, const struct sockaddr
return eq;
}
enum ddsi_nearby_address_result ddsi_ipaddr_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[])
enum ddsi_nearby_address_result ddsi_ipaddr_is_nearby_address (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
{
struct sockaddr_storage tmp, iftmp, nmtmp, ownip;
size_t i;
(void)tran;
ddsi_ipaddr_from_loc(&tmp, loc);
for (i = 0; i < ninterf; i++)
{
@ -111,16 +110,15 @@ enum ddsi_locator_from_string_result ddsi_ipaddr_from_string (ddsi_tran_factory_
if (tmpaddr.ss_family != af) {
return AFSR_MISMATCH;
}
ddsi_ipaddr_to_loc (loc, (struct sockaddr *)&tmpaddr, kind);
ddsi_ipaddr_to_loc (tran, loc, (struct sockaddr *)&tmpaddr, kind);
/* This is just an address, so there is no valid value for port, other than INVALID.
Without a guarantee that tmpaddr has port 0, best is to set it explicitly here */
loc->port = NN_LOCATOR_PORT_INVALID;
return AFSR_OK;
}
char *ddsi_ipaddr_to_string (ddsi_tran_factory_t tran, char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
char *ddsi_ipaddr_to_string (char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
{
(void)tran;
assert (sizeof_dst > 1);
if (loc->kind == NN_LOCATOR_KIND_INVALID)
(void) snprintf (dst, sizeof_dst, "(invalid)");
@ -161,8 +159,9 @@ char *ddsi_ipaddr_to_string (ddsi_tran_factory_t tran, char *dst, size_t sizeof_
return dst;
}
void ddsi_ipaddr_to_loc (nn_locator_t *dst, const struct sockaddr *src, int32_t kind)
void ddsi_ipaddr_to_loc (const struct ddsi_tran_factory *tran, nn_locator_t *dst, const struct sockaddr *src, int32_t kind)
{
dst->tran = (struct ddsi_tran_factory *) tran;
dst->kind = kind;
switch (src->sa_family)
{
@ -172,6 +171,7 @@ void ddsi_ipaddr_to_loc (nn_locator_t *dst, const struct sockaddr *src, int32_t
assert (kind == NN_LOCATOR_KIND_UDPv4 || kind == NN_LOCATOR_KIND_TCPv4);
if (x->sin_addr.s_addr == htonl (INADDR_ANY))
{
dst->tran = NULL;
dst->kind = NN_LOCATOR_KIND_INVALID;
dst->port = NN_LOCATOR_PORT_INVALID;
memset (dst->address, 0, sizeof (dst->address));
@ -191,6 +191,7 @@ void ddsi_ipaddr_to_loc (nn_locator_t *dst, const struct sockaddr *src, int32_t
assert (kind == NN_LOCATOR_KIND_UDPv6 || kind == NN_LOCATOR_KIND_TCPv6);
if (IN6_IS_ADDR_UNSPECIFIED (&x->sin6_addr))
{
dst->tran = NULL;
dst->kind = NN_LOCATOR_KIND_INVALID;
dst->port = NN_LOCATOR_PORT_INVALID;
memset (dst->address, 0, sizeof (dst->address));

6
src/core/ddsi/src/ddsi_mcgroup.c
View file

@ -136,14 +136,14 @@ static char *make_joinleave_msg (char *buf, size_t bufsz, ddsi_tran_conn_t conn,
int n;
#ifdef DDSI_INCLUDE_SSM
if (srcloc) {
ddsi_locator_to_string_no_port(conn->m_base.gv, srcstr, sizeof(srcstr), srcloc);
ddsi_locator_to_string_no_port(srcstr, sizeof(srcstr), srcloc);
}
#else
DDSRT_UNUSED_ARG (srcloc);
#endif
ddsi_locator_to_string_no_port (conn->m_base.gv, mcstr, sizeof(mcstr), mcloc);
ddsi_locator_to_string_no_port (mcstr, sizeof(mcstr), mcloc);
if (interf)
ddsi_locator_to_string_no_port(conn->m_base.gv, interfstr, sizeof(interfstr), &interf->loc);
ddsi_locator_to_string_no_port(interfstr, sizeof(interfstr), &interf->loc);
else
(void) snprintf (interfstr, sizeof (interfstr), "(default)");
n = err ? snprintf (buf, bufsz, "error %d in ", err) : 0;

8
src/core/ddsi/src/ddsi_raweth.c
View file

@ -38,9 +38,8 @@ typedef struct ddsi_raweth_conn {
int m_ifindex;
} *ddsi_raweth_conn_t;
static char *ddsi_raweth_to_string (ddsi_tran_factory_t tran, char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
static char *ddsi_raweth_to_string (char *dst, size_t sizeof_dst, const nn_locator_t *loc, int with_port)
{
(void)tran;
if (with_port)
(void) snprintf(dst, sizeof_dst, "[%02x:%02x:%02x:%02x:%02x:%02x]:%u",
loc->address[10], loc->address[11], loc->address[12],
@ -80,6 +79,7 @@ static ssize_t ddsi_raweth_conn_read (ddsi_tran_conn_t conn, unsigned char * buf
{
if (srcloc)
{
srcloc->tran = conn->m_factory;
srcloc->kind = NN_LOCATOR_KIND_RAWETH;
srcloc->port = ntohs (src.sll_protocol);
memset(srcloc->address, 0, 10);
@ -305,9 +305,8 @@ static int ddsi_raweth_is_ssm_mcaddr (const ddsi_tran_factory_t tran, const nn_l
return 0;
}
static enum ddsi_nearby_address_result ddsi_raweth_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_raweth_is_nearby_address (const nn_locator_t *loc, const nn_locator_t *ownloc, size_t ninterf, const struct nn_interface interf[])
{
(void) tran;
(void) loc;
(void) ownloc;
(void) ninterf;
@ -319,6 +318,7 @@ static enum ddsi_locator_from_string_result ddsi_raweth_address_from_string (dds
{
int i = 0;
(void)tran;
loc->tran = tran;
loc->kind = NN_LOCATOR_KIND_RAWETH;
loc->port = NN_LOCATOR_PORT_INVALID;
memset (loc->address, 0, sizeof (loc->address));

25
src/core/ddsi/src/ddsi_serdata_default.c
View file

@ -644,10 +644,27 @@ static size_t serdata_default_print_cdr (const struct ddsi_sertopic *sertopic_co
static size_t serdata_default_print_plist (const struct ddsi_sertopic *sertopic_common, const struct ddsi_serdata *serdata_common, char *buf, size_t size)
{
/* FIXME: should change q_plist.c to print to a string instead of a log, and then drop the
logging of QoS in the rest of code, instead relying on this */
(void)sertopic_common; (void)serdata_common;
return (size_t) snprintf (buf, size, "(plist)");
const struct ddsi_serdata_default *d = (const struct ddsi_serdata_default *)serdata_common;
const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
nn_plist_src_t src;
nn_plist_t tmp;
src.buf = (const unsigned char *) d->data;
src.bufsz = d->pos;
src.encoding = d->hdr.identifier;
src.factory = tp->gv->m_factory;
src.logconfig = &tp->gv->logconfig;
src.protocol_version.major = RTPS_MAJOR;
src.protocol_version.minor = RTPS_MINOR;
src.strict = false;
src.vendorid = NN_VENDORID_ECLIPSE;
if (nn_plist_init_frommsg (&tmp, NULL, ~(uint64_t)0, ~(uint64_t)0, &src) < 0)
return (size_t) snprintf (buf, size, "(unparseable-plist)");
else
{
size_t ret = nn_plist_print (buf, size, &tmp);
nn_plist_fini (&tmp);
return ret;
}
}
static size_t serdata_default_print_raw (const struct ddsi_sertopic *sertopic_common, const struct ddsi_serdata *serdata_common, char *buf, size_t size)

44
src/core/ddsi/src/ddsi_tcp.c
View file

@ -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;
}
@ -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;
}
@ -775,7 +771,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 +781,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 +818,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 +859,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 +891,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 +900,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 +927,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 +988,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 +1046,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)

75
src/core/ddsi/src/ddsi_tran.c
View file

@ -17,6 +17,7 @@
#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"
@ -250,10 +251,12 @@ 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)
@ -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;
}

10
src/core/ddsi/src/ddsi_udp.c
View file

@ -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;

9
src/core/ddsi/src/q_addrset.c
View file

@ -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);
}
}
@ -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));
@ -557,7 +558,7 @@ static void log_addrset_helper (const nn_locator_t *n, void *varg)
const struct q_globals *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)

6
src/core/ddsi/src/q_ddsi_discovery.c
View file

@ -117,7 +117,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;
@ -738,7 +738,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);
nn_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, &datap->qos);
GVLOGDISC ("}\n");
maybe_add_pp_as_meta_to_as_disc (gv, as_meta);
@ -1270,7 +1270,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);
nn_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))

4
src/core/ddsi/src/q_debmon.c
View file

@ -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)
@ -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);

14
src/core/ddsi/src/q_entity.c
View file

@ -442,7 +442,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);
nn_xqos_log (DDS_LC_DISCOVERY, &e->gv->logconfig, xqos);
EELOGDISC (e, "}\n");
if (mask == 0)
@ -621,7 +621,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);
nn_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, &pp->plist->qos);
GVLOGDISC ("}\n");
}
@ -1247,7 +1247,7 @@ static void rebuild_trace_covered(const struct q_globals *gv, int nreaders, int
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)
@ -1286,7 +1286,7 @@ static void rebuild_add(const struct q_globals *gv, struct addrset *newas, int l
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]);
}
@ -1305,7 +1305,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);
}
@ -2979,7 +2979,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
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);
nn_xqos_log (DDS_LC_DISCOVERY, &wr->e.gv->logconfig, wr->xqos);
ELOGDISC (wr, "}\n");
assert (wr->xqos->present & QP_RELIABILITY);
@ -3609,7 +3609,7 @@ static dds_return_t new_reader_guid
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);
nn_xqos_log (DDS_LC_DISCOVERY, &rd->e.gv->logconfig, rd->xqos);
ELOGDISC (rd, "}\n");
}
assert (rd->xqos->present & QP_RELIABILITY);

21
src/core/ddsi/src/q_init.c
View file

@ -282,6 +282,7 @@ static int set_spdp_address (struct q_globals *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)
{
@ -342,6 +343,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;
}
@ -765,7 +767,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 (struct q_globals *gv, 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
@ -778,6 +780,7 @@ static struct ddsi_sertopic *make_special_topic (struct serdatapool *serpool, ui
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);
st->gv = gv;
st->native_encoding_identifier = enc_id;
st->serpool = serpool;
st->nkeys = 1;
@ -786,8 +789,8 @@ static struct ddsi_sertopic *make_special_topic (struct serdatapool *serpool, ui
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);
gv->plist_topic = make_special_topic (gv, gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? PL_CDR_LE : PL_CDR_BE, &ddsi_serdata_ops_plist);
gv->rawcdr_topic = make_special_topic (gv, gv->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE, &ddsi_serdata_ops_rawcdr);
}
static void free_special_topics (struct q_globals *gv)
@ -1024,12 +1027,12 @@ 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, "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, "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, "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
@ -1342,7 +1345,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);

8
src/core/ddsi/src/q_nwif.c
View file

@ -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++)

578
src/core/ddsi/src/q_plist.c
View file

@ -109,6 +109,7 @@ struct piddesc {
dds_return_t (*fini) (void * __restrict dst, size_t * __restrict dstoff, struct flagset *flagset, uint64_t flag);
dds_return_t (*valid) (const void *src, size_t srcoff);
bool (*equal) (const void *srcx, const void *srcy, size_t srcoff);
bool (*print) (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff);
} f;
} op;
dds_return_t (*deser_validate_xform) (void * __restrict dst, const struct dd * __restrict dd);
@ -116,7 +117,6 @@ struct piddesc {
extern inline bool pserop_seralign_is_1 (enum pserop op);
static void log_octetseq (uint32_t cat, const struct ddsrt_log_cfg *logcfg, uint32_t n, const unsigned char *xs);
static dds_return_t validate_history_qospolicy (const dds_history_qospolicy_t *q);
static dds_return_t validate_resource_limits_qospolicy (const dds_resource_limits_qospolicy_t *q);
static dds_return_t validate_history_and_resource_limits (const dds_history_qospolicy_t *qh, const dds_resource_limits_qospolicy_t *qr);
@ -124,7 +124,7 @@ static dds_return_t validate_external_duration (const ddsi_duration_t *d);
static dds_return_t validate_durability_service_qospolicy_acceptzero (const dds_durability_service_qospolicy_t *q, bool acceptzero);
static dds_return_t do_locator (nn_locators_t *ls, uint64_t *present, uint64_t wanted, uint64_t fl, const struct dd *dd, const struct ddsi_tran_factory *factory);
static dds_return_t final_validation_qos (const dds_qos_t *dest, nn_protocol_version_t protocol_version, nn_vendorid_t vendorid, bool *dursvc_accepted_allzero, bool strict);
static int partitions_equal (const dds_partition_qospolicy_t *a, const dds_partition_qospolicy_t *b);
static int partitions_equal (const void *srca, const void *srcb, size_t off);
static dds_return_t nn_xqos_valid_strictness (const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos, bool strict);
static size_t align4size (size_t x)
@ -169,6 +169,34 @@ static dds_return_t deser_uint32 (uint32_t *dst, const struct dd * __restrict dd
return 0;
}
/* Returns true if buffer not yet exhausted, false otherwise */
static bool prtf (char * __restrict *buf, size_t * __restrict bufsize, const char *fmt, ...)
{
va_list ap;
if (*bufsize == 0)
return false;
va_start (ap, fmt);
int n = vsnprintf (*buf, *bufsize, fmt, ap);
va_end (ap);
if (n < 0)
{
**buf = 0;
return false;
}
else if ((size_t) n <= *bufsize)
{
*buf += (size_t) n;
*bufsize -= (size_t) n;
return (*bufsize > 0);
}
else
{
*buf += *bufsize;
*bufsize = 0;
return false;
}
}
#define alignof(type_) offsetof (struct { char c; type_ d; }, d)
static dds_return_t deser_reliability (void * __restrict dst, size_t * __restrict dstoff, struct flagset *flagset, uint64_t flag, const struct dd * __restrict dd, size_t * __restrict srcoff)
@ -222,6 +250,12 @@ static bool equal_reliability (const void *srcx, const void *srcy, size_t srcoff
return x->kind == y->kind && x->max_blocking_time == y->max_blocking_time;
}
static bool print_reliability (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff)
{
dds_reliability_qospolicy_t const * const x = deser_generic_src (src, &srcoff, alignof (dds_reliability_qospolicy_t));
return prtf (buf, bufsize, "%d:%"PRId64, (int) x->kind, x->max_blocking_time);
}
static dds_return_t deser_statusinfo (void * __restrict dst, size_t * __restrict dstoff, struct flagset *flagset, uint64_t flag, const struct dd * __restrict dd, size_t * __restrict srcoff)
{
uint32_t * const x = deser_generic_dst (dst, dstoff, alignof (dds_reliability_qospolicy_t));
@ -246,6 +280,12 @@ static dds_return_t ser_statusinfo (struct nn_xmsg *xmsg, nn_parameterid_t pid,
return 0;
}
static bool print_statusinfo (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff)
{
uint32_t const * const x = deser_generic_src (src, &srcoff, alignof (uint32_t));
return prtf (buf, bufsize, "%"PRIx32, *x);
}
static dds_return_t deser_locator (void * __restrict dst, size_t * __restrict dstoff, struct flagset *flagset, uint64_t flag, const struct dd * __restrict dd, size_t * __restrict srcoff)
{
nn_locators_t * const x = deser_generic_dst (dst, dstoff, alignof (nn_locators_t));
@ -271,8 +311,10 @@ static dds_return_t ser_locator (struct nn_xmsg *xmsg, nn_parameterid_t pid, con
nn_locators_t const * const x = deser_generic_src (src, &srcoff, alignof (nn_locators_t));
for (const struct nn_locators_one *l = x->first; l != NULL; l = l->next)
{
char * const p = nn_xmsg_addpar (xmsg, pid, sizeof (nn_locator_t));
memcpy (p, &l->loc, sizeof (nn_locator_t));
char * const p = nn_xmsg_addpar (xmsg, pid, 24);
memcpy (p, &l->loc.kind, 4);
memcpy (p + 4, &l->loc.port, 4);
memcpy (p + 8, l->loc.address, 16);
}
return 0;
}
@ -310,6 +352,21 @@ static dds_return_t fini_locator (void * __restrict dst, size_t * __restrict dst
return 0;
}
static bool print_locator (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff)
{
nn_locators_t const * const x = deser_generic_src (src, &srcoff, alignof (nn_locators_t));
const char *sep = "";
prtf (buf, bufsize, "{");
for (const struct nn_locators_one *l = x->first; l != NULL; l = l->next)
{
char tmp[DDSI_LOCATORSTRLEN];
ddsi_locator_to_string (tmp, sizeof (tmp), &l->loc);
prtf (buf, bufsize, "%s%s", sep, tmp);
sep = ",";
}
return prtf (buf, bufsize, "}");
}
static size_t ser_generic_srcsize (const enum pserop * __restrict desc)
{
size_t srcoff = 0, srcalign = 0;
@ -1040,6 +1097,186 @@ bool plist_equal_generic (const void *srcx, const void *srcy, const enum pserop
return equal_generic (srcx, srcy, 0, desc);
}
static uint32_t isprint_runlen (uint32_t n, const unsigned char *xs)
{
uint32_t m;
for (m = 0; m < n && xs[m] != '"' && isprint (xs[m]) && xs[m] < 127; m++)
;
return m;
}
static bool prtf_octetseq (char * __restrict *buf, size_t * __restrict bufsize, uint32_t n, const unsigned char *xs)
{
uint32_t i = 0;
while (i < n)
{
uint32_t m = isprint_runlen (n - i, xs);
if (m >= 4 || (i == 0 && m == n))
{
if (!prtf (buf, bufsize, "%s\"%*.*s\"", i == 0 ? "" : ",", m, m, xs))
return false;
xs += m;
i += m;
}
else
{
if (m == 0)
m = 1;
while (m--)
{
if (!prtf (buf, bufsize, "%s%u", i == 0 ? "" : ",", *xs++))
return false;
i++;
}
}
}
return true;
}
static bool print_generic1 (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff, const enum pserop * __restrict desc, const char *sep)
{
while (true)
{
switch (*desc)
{
case XSTOP:
return true;
case XO: { /* octet sequence */
ddsi_octetseq_t const * const x = deser_generic_src (src, &srcoff, alignof (ddsi_octetseq_t));
prtf (buf, bufsize, "%s%"PRIu32"<", sep, x->length);
(void) prtf_octetseq (buf, bufsize, x->length, x->value);
if (!prtf (buf, bufsize, ">"))
return false;
srcoff += sizeof (*x);
break;
}
case XS: { /* string */
char const * const * const x = deser_generic_src (src, &srcoff, alignof (char *));
if (!prtf (buf, bufsize, "%s\"%s\"", sep, *x))
return false;
srcoff += sizeof (*x);
break;
}
case XE1: case XE2: case XE3: { /* enum */
unsigned const * const x = deser_generic_src (src, &srcoff, alignof (unsigned));
if (!prtf (buf, bufsize, "%s%u", sep, *x))
return false;
srcoff += sizeof (*x);
break;
}
case Xi: case Xix2: case Xix3: case Xix4: { /* int32_t(s) */
int32_t const * const x = deser_generic_src (src, &srcoff, alignof (int32_t));
const uint32_t cnt = 1 + (uint32_t) (*desc - Xi);
for (uint32_t i = 0; i < cnt; i++)
{
if (!prtf (buf, bufsize, "%s%"PRId32, sep, x[i]))
return false;
sep = ":";
}
srcoff += cnt * sizeof (*x);
break;
}
case Xu: case Xux2: case Xux3: case Xux4: case Xux5: { /* uint32_t(s) */
uint32_t const * const x = deser_generic_src (src, &srcoff, alignof (uint32_t));
const uint32_t cnt = 1 + (uint32_t) (*desc - Xu);
for (uint32_t i = 0; i < cnt; i++)
{
if (!prtf (buf, bufsize, "%s%"PRIu32, sep, x[i]))
return false;
sep = ":";
}
srcoff += cnt * sizeof (*x);
break;
}
case XD: case XDx2: { /* duration(s): int64_t <=> int32_t.uint32_t (seconds.fraction) */
dds_duration_t const * const x = deser_generic_src (src, &srcoff, alignof (dds_duration_t));
const uint32_t cnt = 1 + (uint32_t) (*desc - XD);
for (uint32_t i = 0; i < cnt; i++)
{
if (!prtf (buf, bufsize, "%s%"PRId64, sep, x[i]))
return false;
sep = ":";
}
srcoff += cnt * sizeof (*x);
break;
}
case Xo: case Xox2: { /* octet(s) */
unsigned char const * const x = deser_generic_src (src, &srcoff, alignof (unsigned char));
const uint32_t cnt = 1 + (uint32_t) (*desc - Xo);
for (uint32_t i = 0; i < cnt; i++)
{
if (!prtf (buf, bufsize, "%s%d", sep, x[i]))
return false;
sep = ":";
}
srcoff += cnt * sizeof (*x);
break;
}
case Xb: case Xbx2: case XbCOND: { /* boolean(s) */
unsigned char const * const x = deser_generic_src (src, &srcoff, alignof (unsigned char));
const uint32_t cnt = (*desc == Xbx2) ? 2 : 1; /* <<<< beware! */
for (uint32_t i = 0; i < cnt; i++)
{
if (!prtf (buf, bufsize, "%s%d", sep, x[i]))
return false;
sep = ":";
}
srcoff += cnt * sizeof (*x);
break;
}
case XbPROP: { /* "propagate" boolean: don't serialize, skip it and everything that follows if false */
unsigned char const * const x = deser_generic_src (src, &srcoff, alignof (unsigned char));
if (!prtf (buf, bufsize, "%s%d", sep, *x))
return false;
srcoff++;
break;
}
case XG: { /* GUID */
ddsi_guid_t const * const x = deser_generic_src (src, &srcoff, alignof (ddsi_guid_t));
if (!prtf (buf, bufsize, "%s"PGUIDFMT, sep, PGUID (*x)))
return false;
srcoff += sizeof (*x);
break;
}
case XK: { /* keyhash */
nn_keyhash_t const * const x = deser_generic_src (src, &srcoff, alignof (nn_keyhash_t));
if (!prtf (buf, bufsize, "%s{%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x}", sep,
x->value[0], x->value[1], x->value[2], x->value[3], x->value[4], x->value[5], x->value[6], x->value[7],
x->value[8], x->value[9], x->value[10], x->value[11], x->value[12], x->value[13], x->value[14], x->value[15]))
return false;
srcoff += sizeof (*x);
break;
}
case XQ: {
ddsi_octetseq_t const * const x = deser_generic_src (src, &srcoff, alignof (ddsi_octetseq_t));
if (!prtf (buf, bufsize, "%s{", sep))
return false;
if (x->length > 0)
{
const size_t elem_size = ser_generic_srcsize (desc + 1);
for (uint32_t i = 0; i < x->length; i++)
if (!print_generic1 (buf, bufsize, x->value, i * elem_size, desc + 1, (i == 0) ? "" : ","))
return false;
}
if (!prtf (buf, bufsize, "}"))
return false;
srcoff += sizeof (*x);
while (*++desc != XSTOP) { }
break;
}
case Xopt:
break;
}
sep = ":";
desc++;
}
}
static bool print_generic (char * __restrict *buf, size_t * __restrict bufsize, const void *src, size_t srcoff, const enum pserop * __restrict desc)
{
return print_generic1 (buf, bufsize, src, srcoff, desc, "");
}
#define membersize(type, member) sizeof (((type *) 0)->member)
#define ENTRY(PFX_, NAME_, member_, flag_, validate_, ...) \
{ PID_##NAME_, flag_, PFX_##_##NAME_, #NAME_, offsetof (struct nn_plist, member_), \
@ -1124,7 +1361,6 @@ static dds_return_t dvx_reader_favours_ssm (void * __restrict dst, const struct
}
#endif
/* Standardized parameters -- QoS _MUST_ come first (nn_plist_init_tables verifies this) because
it allows early-out when processing a dds_qos_t instead of an nn_plist_t */
static const struct piddesc piddesc_omg[] = {
@ -1146,7 +1382,7 @@ static const struct piddesc piddesc_omg[] = {
/* Reliability encoding does not follow the rules (best-effort/reliable map to 1/2 instead of 0/1 */
{ PID_RELIABILITY, PDF_QOS | PDF_FUNCTION, QP_RELIABILITY, "RELIABILITY",
offsetof (struct nn_plist, qos.reliability), membersize (struct nn_plist, qos.reliability),
{ .f = { .deser = deser_reliability, .ser = ser_reliability, .valid = valid_reliability, .equal = equal_reliability } }, 0 },
{ .f = { .deser = deser_reliability, .ser = ser_reliability, .valid = valid_reliability, .equal = equal_reliability, .print = print_reliability } }, 0 },
QP (LIFESPAN, lifespan, XD),
QP (DESTINATION_ORDER, destination_order, XE1),
/* History depth is ignored when kind = KEEP_ALL, and must be >= 1 when KEEP_LAST, so can't use "l" */
@ -1177,34 +1413,34 @@ static const struct piddesc piddesc_omg[] = {
PP (DOMAIN_TAG, domain_tag, XS),
{ PID_STATUSINFO, PDF_FUNCTION, PP_STATUSINFO, "STATUSINFO",
offsetof (struct nn_plist, statusinfo), membersize (struct nn_plist, statusinfo),
{ .f = { .deser = deser_statusinfo, .ser = ser_statusinfo } }, 0 },
{ .f = { .deser = deser_statusinfo, .ser = ser_statusinfo, .print = print_statusinfo } }, 0 },
/* Locators are difficult to deal with because they can occur multi times to represent a set;
that is manageable for deser, unalias and fini, but it breaks ser because that one only
generates a single parameter header */
{ PID_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_UNICAST_LOCATOR, "UNICAST_LOCATOR",
offsetof (struct nn_plist, unicast_locators), membersize (struct nn_plist, unicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
{ PID_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_MULTICAST_LOCATOR, "MULTICAST_LOCATOR",
offsetof (struct nn_plist, multicast_locators), membersize (struct nn_plist, multicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
{ PID_DEFAULT_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_DEFAULT_UNICAST_LOCATOR, "DEFAULT_UNICAST_LOCATOR",
offsetof (struct nn_plist, default_unicast_locators), membersize (struct nn_plist, default_unicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
{ PID_DEFAULT_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_DEFAULT_MULTICAST_LOCATOR, "DEFAULT_MULTICAST_LOCATOR",
offsetof (struct nn_plist, default_multicast_locators), membersize (struct nn_plist, default_multicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
{ PID_METATRAFFIC_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_METATRAFFIC_UNICAST_LOCATOR, "METATRAFFIC_UNICAST_LOCATOR",
offsetof (struct nn_plist, metatraffic_unicast_locators), membersize (struct nn_plist, metatraffic_unicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
{ PID_METATRAFFIC_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_METATRAFFIC_MULTICAST_LOCATOR, "METATRAFFIC_MULTICAST_LOCATOR",
offsetof (struct nn_plist, metatraffic_multicast_locators), membersize (struct nn_plist, metatraffic_multicast_locators),
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator } }, 0 },
{ .f = { .deser = deser_locator, .ser = ser_locator, .unalias = unalias_locator, .fini = fini_locator, .print = print_locator } }, 0 },
/* PID_..._{IPADDRESS,PORT} is impossible to deal with and are never generated, only accepted.
The problem is that there one needs additional state (and even then there is no clear
interpretation) ... So they'll have to be special-cased */
@ -1675,76 +1911,55 @@ dds_return_t nn_xqos_valid (const struct ddsrt_log_cfg *logcfg, const dds_qos_t
return nn_xqos_valid_strictness (logcfg, xqos, true);
}
uint64_t nn_xqos_delta (const dds_qos_t *x, const dds_qos_t *y, uint64_t mask)
static void plist_or_xqos_delta (uint64_t *pdelta, uint64_t *qdelta, const void *srcx, const void *srcy, size_t shift, uint64_t pmask, uint64_t qmask)
{
if (piddesc_unalias[0] == NULL)
nn_plist_init_tables ();
/* Returns QP_... set for settings where x differs from y; if
present in x but not in y (or in y but not in x) it counts as a
difference. */
uint64_t delta = (x->present ^ y->present) & mask;
const uint64_t check = (x->present & y->present) & mask;
for (size_t k = 0; k < sizeof (piddesc_tables_all) / sizeof (piddesc_tables_all[0]); k++)
{
struct piddesc const * const table = piddesc_tables_all[k];
for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++)
{
struct piddesc const * const entry = &table[i];
if (!(entry->flags & PDF_QOS))
break;
if (check & entry->present_flag)
{
const size_t srcoff = entry->plist_offset - offsetof (nn_plist_t, qos);
bool equal;
/* Partition is special-cased because it is a set (with a special rules
for empty sets and empty strings to boot), and normal string sequence
comparison requires the ordering to be the same */
if (entry->pid == PID_PARTITION)
equal = partitions_equal (&x->partition, &y->partition);
else if (!(entry->flags & PDF_FUNCTION))
equal = equal_generic (x, y, srcoff, entry->op.desc);
else
equal = entry->op.f.equal (x, y, srcoff);
if (!equal)
delta |= entry->present_flag;
}
}
}
return delta;
}
uint64_t pcheck, qcheck;
void nn_plist_delta (uint64_t *pdelta, uint64_t *qdelta, const nn_plist_t *x, const nn_plist_t *y, uint64_t pmask, uint64_t qmask)
{
if (piddesc_unalias[0] == NULL)
nn_plist_init_tables ();
if (shift > 0)
{
const dds_qos_t *x = srcx;
const dds_qos_t *y = srcy;
*pdelta = 0;
pcheck = 0;
*qdelta = (x->present ^ y->present) & qmask;
qcheck = (x->present & y->present) & qmask;
}
else
{
const nn_plist_t *x = srcx;
const nn_plist_t *y = srcy;
*pdelta = (x->present ^ y->present) & pmask;
const uint64_t pcheck = (x->present & y->present) & pmask;
pcheck = (x->present & y->present) & pmask;
*qdelta = (x->qos.present ^ y->qos.present) & qmask;
const uint64_t qcheck = (x->qos.present & y->qos.present) & qmask;
qcheck = (x->qos.present & y->qos.present) & qmask;
}
for (size_t k = 0; k < sizeof (piddesc_tables_all) / sizeof (piddesc_tables_all[0]); k++)
{
struct piddesc const * const table = piddesc_tables_all[k];
for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++)
{
struct piddesc const * const entry = &table[i];
if (shift > 0 && !(entry->flags & PDF_QOS))
break;
assert (entry->plist_offset >= shift);
assert (shift == 0 || entry->plist_offset - shift < sizeof (dds_qos_t));
const uint64_t check = (entry->flags & PDF_QOS) ? qcheck : pcheck;
uint64_t * const delta = (entry->flags & PDF_QOS) ? qdelta : pdelta;
/* QoS come first in the table, but for those we use nn_xqos_delta */
if (entry->flags & PDF_QOS)
continue;
if (check & entry->present_flag)
{
const size_t srcoff = entry->plist_offset;
const size_t off = entry->plist_offset - shift;
bool equal;
/* Partition is special-cased because it is a set (with a special rules
for empty sets and empty strings to boot), and normal string sequence
comparison requires the ordering to be the same */
if (entry->pid == PID_PARTITION)
equal = partitions_equal (&x->qos.partition, &y->qos.partition);
equal = partitions_equal (srcx, srcy, off);
else if (!(entry->flags & PDF_FUNCTION))
equal = equal_generic (x, y, srcoff, entry->op.desc);
equal = equal_generic (srcx, srcy, off, entry->op.desc);
else
equal = entry->op.f.equal (x, y, srcoff);
equal = entry->op.f.equal (srcx, srcy, off);
if (!equal)
*delta |= entry->present_flag;
}
@ -1752,6 +1967,18 @@ void nn_plist_delta (uint64_t *pdelta, uint64_t *qdelta, const nn_plist_t *x, co
}
}
uint64_t nn_xqos_delta (const dds_qos_t *x, const dds_qos_t *y, uint64_t mask)
{
uint64_t pdelta, qdelta;
plist_or_xqos_delta (&pdelta, &qdelta, x, y, offsetof (nn_plist_t, qos), 0, mask);
return qdelta;
}
void nn_plist_delta (uint64_t *pdelta, uint64_t *qdelta, const nn_plist_t *x, const nn_plist_t *y, uint64_t pmask, uint64_t qmask)
{
plist_or_xqos_delta (pdelta, qdelta, x, y, 0, pmask, qmask);
}
static dds_return_t validate_external_duration (const ddsi_duration_t *d)
{
/* Accepted are zero, positive, infinite or invalid as defined in
@ -1908,10 +2135,12 @@ static dds_return_t do_locator (nn_locators_t *ls, uint64_t *present, uint64_t w
{
nn_locator_t loc;
if (dd->bufsz < sizeof (loc))
if (dd->bufsz < 24)
return DDS_RETCODE_BAD_PARAMETER;
memcpy (&loc, dd->buf, sizeof (loc));
memcpy (&loc.kind, dd->buf, 4);
memcpy (&loc.port, dd->buf + 4, 4);
memcpy (loc.address, dd->buf + 8, 16);
if (dd->bswap)
{
loc.kind = ddsrt_bswap4 (loc.kind);
@ -1946,19 +2175,22 @@ static dds_return_t do_locator (nn_locators_t *ls, uint64_t *present, uint64_t w
return DDS_RETCODE_BAD_PARAMETER;
if (loc.port != 0)
return DDS_RETCODE_BAD_PARAMETER;
/* silently dropped correctly formatted "invalid" locators. */
/* silently drop correctly formatted "invalid" locators. */
return 0;
case NN_LOCATOR_KIND_RESERVED:
/* silently dropped "reserved" locators. */
/* silently drop "reserved" locators. */
return 0;
default:
return 0;
}
loc.tran = ddsi_factory_supports (factory, loc.kind) ? factory : NULL;
return add_locator (ls, present, wanted, fl, &loc);
}
static void locator_from_ipv4address_port (nn_locator_t *loc, const nn_ipv4address_t *a, const nn_port_t *p, ddsi_tran_factory_t factory)
{
loc->tran = factory;
loc->kind = factory->m_connless ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_TCPv4;
loc->port = *p;
memset (loc->address, 0, 12);
@ -2186,12 +2418,13 @@ static dds_return_t init_one_parameter (nn_plist_t *plist, nn_ipaddress_params_t
ret = entry->deser_validate_xform (dst, dd);
if (ret < 0)
{
DDS_CWARNING (logcfg, "invalid parameter list (vendor %u.%u, version %u.%u): pid %"PRIx16" (%s) invalid, input = ",
char tmp[256], *ptmp = tmp;
size_t tmpsize = sizeof (tmp);
(void) prtf_octetseq (&ptmp, &tmpsize, (uint32_t) dd->bufsz, dd->buf);
DDS_CWARNING (logcfg, "invalid parameter list (vendor %u.%u, version %u.%u): pid %"PRIx16" (%s) invalid, input = %s\n",
dd->vendorid.id[0], dd->vendorid.id[1],
dd->protocol_version.major, dd->protocol_version.minor,
pid, entry->name);
log_octetseq (DDS_LC_WARNING, logcfg, (uint32_t) dd->bufsz, dd->buf);
DDS_CWARNING (logcfg, "\n");
pid, entry->name, tmp);
}
return ret;
}
@ -2404,9 +2637,10 @@ dds_return_t nn_plist_init_frommsg (nn_plist_t *dest, char **nextafterplist, uin
if (src->logconfig->c.mask & DDS_LC_PLIST)
{
DDS_CLOG (DDS_LC_PLIST, src->logconfig, "%4"PRIx32" PID %"PRIx16" len %"PRIu16" ", (uint32_t) (pl - src->buf), pid, length);
log_octetseq (DDS_LC_PLIST, src->logconfig, length, (const unsigned char *) (par + 1));
DDS_CLOG (DDS_LC_PLIST, src->logconfig, "\n");
char tmp[256], *ptmp = tmp;
size_t tmpsize = sizeof (tmp);
(void) prtf_octetseq (&ptmp, &tmpsize, length, (const unsigned char *) (par + 1));
DDS_CLOG (DDS_LC_PLIST, src->logconfig, "%4"PRIx32" PID %"PRIx16" len %"PRIu16" %s\n", (uint32_t) (pl - src->buf), pid, length, tmp);
}
dd.buf = (const unsigned char *) (par + 1);
@ -2818,8 +3052,10 @@ static int partitions_equal_nlogn (const dds_partition_qospolicy_t *a, const dds
return equal;
}
static int partitions_equal (const dds_partition_qospolicy_t *a, const dds_partition_qospolicy_t *b)
static int partitions_equal (const void *srca, const void *srcb, size_t off)
{
const dds_partition_qospolicy_t *a = (const dds_partition_qospolicy_t *) ((const char *) srca + off);
const dds_partition_qospolicy_t *b = (const dds_partition_qospolicy_t *) ((const char *) srcb + off);
/* Return true iff (the set a->strs) equals (the set b->strs); that
is, order doesn't matter. One could argue that "**" and "*" are
equal, but we're not that precise here. */
@ -2870,139 +3106,93 @@ void nn_plist_addtomsg (struct nn_xmsg *m, const nn_plist_t *ps, uint64_t pwante
/*************************/
static uint32_t isprint_runlen (uint32_t n, const unsigned char *xs)
static void plist_or_xqos_print (char * __restrict *buf, size_t * __restrict bufsize, const void * __restrict src, size_t shift, uint64_t pwanted, uint64_t qwanted)
{
uint32_t m;
for (m = 0; m < n && xs[m] != '"' && isprint (xs[m]) && xs[m] < 127; m++)
;
return m;
}
static void log_octetseq (uint32_t cat, const struct ddsrt_log_cfg *logcfg, uint32_t n, const unsigned char *xs)
{
uint32_t i = 0;
while (i < n)
/* shift == 0: plist, shift > 0: just qos */
const char *sep = "";
uint64_t pw, qw;
if (shift > 0)
{
uint32_t m = isprint_runlen (n - i, xs);
if (m >= 4 || (i == 0 && m == n))
{
DDS_CLOG (cat, logcfg, "%s\"%*.*s\"", i == 0 ? "" : ",", m, m, xs);
xs += m;
i += m;
const dds_qos_t *qos = src;
pw = 0;
qw = qos->present & qwanted;
}
else
{
if (m == 0)
m = 1;
while (m--)
const nn_plist_t *plist = src;
pw = plist->present & pwanted;
qw = plist->qos.present & qwanted;
}
for (size_t k = 0; k < sizeof (piddesc_tables_output) / sizeof (piddesc_tables_output[0]); k++)
{
DDS_CLOG (cat, logcfg, "%s%u", i == 0 ? "" : ",", *xs++);
i++;
struct piddesc const * const table = piddesc_tables_output[k];
for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++)
{
struct piddesc const * const entry = &table[i];
if (entry->pid == PID_PAD)
continue;
if (((entry->flags & PDF_QOS) ? qw : pw) & entry->present_flag)
{
assert (entry->plist_offset >= shift);
assert (shift == 0 || entry->plist_offset - shift < sizeof (dds_qos_t));
size_t srcoff = entry->plist_offset - shift;
/* convert name to lower case for making the trace easier on the eyes */
char lcname[64];
const size_t namelen = strlen (entry->name);
assert (namelen < sizeof (lcname));
for (size_t p = 0; p < namelen; p++)
lcname[p] = (char) tolower (entry->name[p]);
lcname[namelen] = 0;
if (!prtf (buf, bufsize, "%s%s=", sep, lcname))
return;
sep = ",";
bool cont;
if (!(entry->flags & PDF_FUNCTION))
cont = print_generic (buf, bufsize, src, srcoff, entry->op.desc);
else
cont = entry->op.f.print (buf, bufsize, src, srcoff);
if (!cont)
return;
}
}
}
}
void nn_log_xqos (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos)
static void plist_or_xqos_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const void * __restrict src, size_t shift, uint64_t pwanted, uint64_t qwanted)
{
uint64_t p = xqos->present;
const char *prefix = "";
#define LOGB0(fmt_) DDS_CLOG (cat, logcfg, "%s" fmt_, prefix)
#define LOGB1(fmt_, ...) DDS_CLOG (cat, logcfg, "%s" fmt_, prefix, __VA_ARGS__)
#define DO(name_, body_) do { if (p & QP_##name_) { { body_ } prefix = ","; } } while (0)
#define FMT_DUR "%"PRId64".%09"PRId32
#define PRINTARG_DUR(d) ((int64_t) ((d) / 1000000000)), ((int32_t) ((d) % 1000000000))
DO (TOPIC_NAME, { LOGB1 ("topic=%s", xqos->topic_name); });
DO (TYPE_NAME, { LOGB1 ("type=%s", xqos->type_name); });
DO (PRESENTATION, { LOGB1 ("presentation=%d:%u:%u", xqos->presentation.access_scope, xqos->presentation.coherent_access, xqos->presentation.ordered_access); });
DO (PARTITION, {
LOGB0 ("partition={");
for (uint32_t i = 0; i < xqos->partition.n; i++) {
DDS_CLOG (cat, logcfg, "%s%s", (i == 0) ? "" : ",", xqos->partition.strs[i]);
if (logcfg->c.mask & cat)
{
char tmp[1024], *ptmp = tmp;
size_t tmpsize = sizeof (tmp);
plist_or_xqos_print (&ptmp, &tmpsize, src, shift, pwanted, qwanted);
DDS_CLOG (cat, logcfg, "%s", tmp);
}
DDS_CLOG (cat, logcfg, "}");
});
DO (GROUP_DATA, {
LOGB1 ("group_data=%"PRIu32"<", xqos->group_data.length);
log_octetseq (cat, logcfg, xqos->group_data.length, xqos->group_data.value);
DDS_CLOG (cat, logcfg, ">");
});
DO (TOPIC_DATA, {
LOGB1 ("topic_data=%"PRIu32"<", xqos->topic_data.length);
log_octetseq (cat, logcfg, xqos->topic_data.length, xqos->topic_data.value);
DDS_CLOG(cat, logcfg, ">");
});
DO (DURABILITY, { LOGB1 ("durability=%d", xqos->durability.kind); });
DO (DURABILITY_SERVICE, {
LOGB0 ("durability_service=");
DDS_CLOG(cat, logcfg, FMT_DUR, PRINTARG_DUR (xqos->durability_service.service_cleanup_delay));
DDS_CLOG(cat, logcfg, ":{%u:%"PRId32"}", xqos->durability_service.history.kind, xqos->durability_service.history.depth);
DDS_CLOG(cat, logcfg, ":{%"PRId32":%"PRId32":%"PRId32"}", xqos->durability_service.resource_limits.max_samples, xqos->durability_service.resource_limits.max_instances, xqos->durability_service.resource_limits.max_samples_per_instance);
});
DO (DEADLINE, { LOGB1 ("deadline="FMT_DUR, PRINTARG_DUR (xqos->deadline.deadline)); });
DO (LATENCY_BUDGET, { LOGB1 ("latency_budget="FMT_DUR, PRINTARG_DUR (xqos->latency_budget.duration)); });
DO (LIVELINESS, { LOGB1 ("liveliness=%d:"FMT_DUR, xqos->liveliness.kind, PRINTARG_DUR (xqos->liveliness.lease_duration)); });
DO (RELIABILITY, { LOGB1 ("reliability=%d:"FMT_DUR, xqos->reliability.kind, PRINTARG_DUR (xqos->reliability.max_blocking_time)); });
DO (DESTINATION_ORDER, { LOGB1 ("destination_order=%d", xqos->destination_order.kind); });
DO (HISTORY, { LOGB1 ("history=%d:%"PRId32, xqos->history.kind, xqos->history.depth); });
DO (RESOURCE_LIMITS, { LOGB1 ("resource_limits=%"PRId32":%"PRId32":%"PRId32, xqos->resource_limits.max_samples, xqos->resource_limits.max_instances, xqos->resource_limits.max_samples_per_instance); });
DO (TRANSPORT_PRIORITY, { LOGB1 ("transport_priority=%"PRId32, xqos->transport_priority.value); });
DO (LIFESPAN, { LOGB1 ("lifespan="FMT_DUR, PRINTARG_DUR (xqos->lifespan.duration)); });
DO (USER_DATA, {
LOGB1 ("user_data=%"PRIu32"<", xqos->user_data.length);
log_octetseq (cat, logcfg, xqos->user_data.length, xqos->user_data.value);
DDS_CLOG (cat, logcfg, ">");
});
DO (OWNERSHIP, { LOGB1 ("ownership=%d", xqos->ownership.kind); });
DO (OWNERSHIP_STRENGTH, { LOGB1 ("ownership_strength=%"PRId32, xqos->ownership_strength.value); });
DO (TIME_BASED_FILTER, { LOGB1 ("time_based_filter="FMT_DUR, PRINTARG_DUR (xqos->time_based_filter.minimum_separation)); });
DO (PRISMTECH_READER_DATA_LIFECYCLE, { LOGB1 ("reader_data_lifecycle="FMT_DUR":"FMT_DUR, PRINTARG_DUR (xqos->reader_data_lifecycle.autopurge_nowriter_samples_delay), PRINTARG_DUR (xqos->reader_data_lifecycle.autopurge_disposed_samples_delay)); });
DO (PRISMTECH_WRITER_DATA_LIFECYCLE, {
LOGB1 ("writer_data_lifecycle={%u}", xqos->writer_data_lifecycle.autodispose_unregistered_instances); });
DO (PRISMTECH_READER_LIFESPAN, { LOGB1 ("reader_lifespan={%u,"FMT_DUR"}", xqos->reader_lifespan.use_lifespan, PRINTARG_DUR (xqos->reader_lifespan.duration)); });
DO (PRISMTECH_SUBSCRIPTION_KEYS, {
LOGB1 ("subscription_keys={%u,{", xqos->subscription_keys.use_key_list);
for (uint32_t i = 0; i < xqos->subscription_keys.key_list.n; i++) {
DDS_CLOG (cat, logcfg, "%s%s", (i == 0) ? "" : ",", xqos->subscription_keys.key_list.strs[i]);
}
DDS_CLOG (cat, logcfg, "}}");
});
DO (PRISMTECH_ENTITY_FACTORY, { LOGB1 ("entity_factory=%u", xqos->entity_factory.autoenable_created_entities); });
DO (CYCLONE_IGNORELOCAL, { LOGB1 ("ignorelocal=%u", xqos->ignorelocal.value); });
DO (PROPERTY_LIST, {
LOGB0 ("property_list={");
DDS_CLOG (cat, logcfg, "value={");
for (uint32_t i = 0; i < xqos->property.value.n; i++) {
DDS_CLOG (cat, logcfg, "%s{%s,%s,%u}",
(i == 0) ? "" : ",",
xqos->property.value.props[i].name,
xqos->property.value.props[i].value,
xqos->property.value.props[i].propagate);
}
DDS_CLOG (cat, logcfg, "}");
DDS_CLOG (cat, logcfg, "binary_value={");
for (uint32_t i = 0; i < xqos->property.binary_value.n; i++) {
DDS_CLOG (cat, logcfg, "%s{%s,(%u,%p),%u}",
(i == 0) ? "" : ",",
xqos->property.binary_value.props[i].name,
xqos->property.binary_value.props[i].value.length,
xqos->property.binary_value.props[i].value.value,
xqos->property.binary_value.props[i].propagate);
}
DDS_CLOG (cat, logcfg, "}");
DDS_CLOG (cat, logcfg, "}");
});
#undef PRINTARG_DUR
#undef FMT_DUR
#undef DO
#undef LOGB5
#undef LOGB4
#undef LOGB3
#undef LOGB2
#undef LOGB1
#undef LOGB0
}
size_t nn_xqos_print (char * __restrict buf, size_t bufsize, const dds_qos_t *xqos)
{
const size_t bufsize_in = bufsize;
(void) prtf (&buf, &bufsize, "{");
plist_or_xqos_print (&buf, &bufsize, xqos, offsetof (nn_plist_t, qos), 0, ~(uint64_t)0);
(void) prtf (&buf, &bufsize, "}");
return bufsize_in - bufsize;
}
size_t nn_plist_print (char * __restrict buf, size_t bufsize, const nn_plist_t *plist)
{
const size_t bufsize_in = bufsize;
(void) prtf (&buf, &bufsize, "{");
plist_or_xqos_print (&buf, &bufsize, plist, 0, ~(uint64_t)0, ~(uint64_t)0);
(void) prtf (&buf, &bufsize, "}");
return bufsize_in - bufsize;
}
void nn_xqos_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos)
{
plist_or_xqos_log (cat, logcfg, xqos, offsetof (nn_plist_t, qos), 0, ~(uint64_t)0);
}
void nn_plist_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const nn_plist_t *plist)
{
plist_or_xqos_log (cat, logcfg, plist, 0, ~(uint64_t)0, ~(uint64_t)0);
}

4
src/core/ddsi/src/q_receive.c
View file

@ -3021,7 +3021,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);
}
@ -3296,7 +3296,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;
}

2
src/core/ddsi/src/q_xmsg.c
View file

@ -1021,7 +1021,7 @@ static ssize_t nn_xpack_send1 (const nn_locator_t *loc, void * varg)
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)

20
src/mpt/tests/qos/procs/rw.c
View file

@ -146,8 +146,8 @@ static bool pubsub_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, "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");
nn_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
nn_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@ -168,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");
nn_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
nn_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@ -190,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");
nn_xqos_log (DDS_LC_ERROR, &logcfg, a); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
nn_xqos_log (DDS_LC_ERROR, &logcfg, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
}
dds_delete_qos (b);
return delta == 0;
@ -275,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");
nn_xqos_log (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
nn_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);
@ -427,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");
nn_xqos_log (DDS_LC_ERROR, &logcfg, qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
nn_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);

11
src/tools/decode-trace
View file

@ -352,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;
}
@ -623,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 => {} };