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)); 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)); 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->native_encoding_identifier = (DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE);
st->serpool = ppent->m_domain->gv.serpool; st->serpool = ppent->m_domain->gv.serpool;
st->type = (void*) desc; st->type = (void*) desc;

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

@ -18,11 +18,11 @@
extern "C" { extern "C" {
#endif #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); 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); 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); char *ddsi_ipaddr_to_string (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); 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); void ddsi_ipaddr_from_loc (struct sockaddr_storage *dst, const nn_locator_t *src);
#if defined (__cplusplus) #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; struct ddsi_sertopic c;
uint16_t native_encoding_identifier; /* (PL_)?CDR_(LE|BE) */ uint16_t native_encoding_identifier; /* (PL_)?CDR_(LE|BE) */
struct serdatapool *serpool; struct serdatapool *serpool;
struct q_globals *gv;
struct dds_topic_descriptor * type; struct dds_topic_descriptor * type;
unsigned nkeys; 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 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 { enum ddsi_locator_from_string_result {
AFSR_OK, /* conversion succeeded */ 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 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); 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_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_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); 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); 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 #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 (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_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); 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_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_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_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_rmsg;
struct nn_rsample_info; 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; typedef int32_t nn_count_t;
#define DDSI_COUNT_MIN (-2147483647 - 1) #define DDSI_COUNT_MIN (-2147483647 - 1)
#define DDSI_COUNT_MAX (2147483647) #define DDSI_COUNT_MAX (2147483647)
/* address field in locator maintained in network byte order, the rest /* address field in locator maintained in network byte order, the rest in host */
in host (yes: that's a FIXME) */
typedef struct { typedef struct {
const struct ddsi_tran_factory *tran;
int32_t kind; int32_t kind;
uint32_t port; uint32_t port;
unsigned char address[16]; 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 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 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_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); DDS_EXPORT dds_qos_t *nn_xqos_dup (const dds_qos_t *src);
#if defined (__cplusplus) #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; 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; struct sockaddr_storage tmp, iftmp, nmtmp, ownip;
size_t i; size_t i;
(void)tran;
ddsi_ipaddr_from_loc(&tmp, loc); ddsi_ipaddr_from_loc(&tmp, loc);
for (i = 0; i < ninterf; i++) 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) { if (tmpaddr.ss_family != af) {
return AFSR_MISMATCH; 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. /* 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 */ Without a guarantee that tmpaddr has port 0, best is to set it explicitly here */
loc->port = NN_LOCATOR_PORT_INVALID; loc->port = NN_LOCATOR_PORT_INVALID;
return AFSR_OK; 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); assert (sizeof_dst > 1);
if (loc->kind == NN_LOCATOR_KIND_INVALID) if (loc->kind == NN_LOCATOR_KIND_INVALID)
(void) snprintf (dst, sizeof_dst, "(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; 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; dst->kind = kind;
switch (src->sa_family) 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); assert (kind == NN_LOCATOR_KIND_UDPv4 || kind == NN_LOCATOR_KIND_TCPv4);
if (x->sin_addr.s_addr == htonl (INADDR_ANY)) if (x->sin_addr.s_addr == htonl (INADDR_ANY))
{ {
dst->tran = NULL;
dst->kind = NN_LOCATOR_KIND_INVALID; dst->kind = NN_LOCATOR_KIND_INVALID;
dst->port = NN_LOCATOR_PORT_INVALID; dst->port = NN_LOCATOR_PORT_INVALID;
memset (dst->address, 0, sizeof (dst->address)); 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); assert (kind == NN_LOCATOR_KIND_UDPv6 || kind == NN_LOCATOR_KIND_TCPv6);
if (IN6_IS_ADDR_UNSPECIFIED (&x->sin6_addr)) if (IN6_IS_ADDR_UNSPECIFIED (&x->sin6_addr))
{ {
dst->tran = NULL;
dst->kind = NN_LOCATOR_KIND_INVALID; dst->kind = NN_LOCATOR_KIND_INVALID;
dst->port = NN_LOCATOR_PORT_INVALID; dst->port = NN_LOCATOR_PORT_INVALID;
memset (dst->address, 0, sizeof (dst->address)); 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; int n;
#ifdef DDSI_INCLUDE_SSM #ifdef DDSI_INCLUDE_SSM
if (srcloc) { 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 #else
DDSRT_UNUSED_ARG (srcloc); DDSRT_UNUSED_ARG (srcloc);
#endif #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) 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 else
(void) snprintf (interfstr, sizeof (interfstr), "(default)"); (void) snprintf (interfstr, sizeof (interfstr), "(default)");
n = err ? snprintf (buf, bufsz, "error %d in ", err) : 0; 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; int m_ifindex;
} *ddsi_raweth_conn_t; } *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) if (with_port)
(void) snprintf(dst, sizeof_dst, "[%02x:%02x:%02x:%02x:%02x:%02x]:%u", (void) snprintf(dst, sizeof_dst, "[%02x:%02x:%02x:%02x:%02x:%02x]:%u",
loc->address[10], loc->address[11], loc->address[12], 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) if (srcloc)
{ {
srcloc->tran = conn->m_factory;
srcloc->kind = NN_LOCATOR_KIND_RAWETH; srcloc->kind = NN_LOCATOR_KIND_RAWETH;
srcloc->port = ntohs (src.sll_protocol); srcloc->port = ntohs (src.sll_protocol);
memset(srcloc->address, 0, 10); 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; 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) loc;
(void) ownloc; (void) ownloc;
(void) ninterf; (void) ninterf;
@ -319,6 +318,7 @@ static enum ddsi_locator_from_string_result ddsi_raweth_address_from_string (dds
{ {
int i = 0; int i = 0;
(void)tran; (void)tran;
loc->tran = tran;
loc->kind = NN_LOCATOR_KIND_RAWETH; loc->kind = NN_LOCATOR_KIND_RAWETH;
loc->port = NN_LOCATOR_PORT_INVALID; loc->port = NN_LOCATOR_PORT_INVALID;
memset (loc->address, 0, sizeof (loc->address)); 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) 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 const struct ddsi_serdata_default *d = (const struct ddsi_serdata_default *)serdata_common;
logging of QoS in the rest of code, instead relying on this */ const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)sertopic_common;
(void)sertopic_common; (void)serdata_common; nn_plist_src_t src;
return (size_t) snprintf (buf, size, "(plist)"); 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) 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 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; nn_locator_t loc;
ddsi_ipaddr_to_loc(&loc, src, src->sa_family == AF_INET ? NN_LOCATOR_KIND_TCPv4 : NN_LOCATOR_KIND_TCPv6); 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(gv, dst, sizeof_dst, &loc); ddsi_locator_to_string(dst, sizeof_dst, &loc);
return dst; 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) 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; struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_base.m_factory;
#endif
char buff[DDSI_LOCSTRLEN]; char buff[DDSI_LOCSTRLEN];
ddsrt_socket_t sock; ddsrt_socket_t sock;
dds_return_t ret; dds_return_t ret;
@ -219,7 +217,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const ddsrt_msghdr_t *
} }
#endif #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); 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 */ /* 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); 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); node = ddsrt_avl_lookup_dpath (&ddsi_tcp_treedef, &fact->ddsi_tcp_cache_g, conn, &path);
if (node) 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); 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); ddsrt_avl_delete_dpath (&ddsi_tcp_treedef, &fact->ddsi_tcp_cache_g, node, &path);
ddsi_tcp_node_free (node); 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) 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; struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_factory;
#endif
dds_return_t rc; dds_return_t rc;
ddsi_tcp_conn_t tcp = (ddsi_tcp_conn_t) conn; 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; 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) 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; 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) if (sock == DDSRT_INVALID_SOCKET)
{ {
(void)ddsrt_getsockname (tl->m_sock, (struct sockaddr *) &addr, &addrlen); (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); 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) 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 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); 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); (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]; char buff[DDSI_LOCSTRLEN];
ddsi_tcp_conn_t tc = (ddsi_tcp_conn_t) conn; ddsi_tcp_conn_t tc = (ddsi_tcp_conn_t) conn;
assert (tc->m_sock != DDSRT_INVALID_SOCKET); 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_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(conn->m_base.gv, buff, sizeof(buff), loc); ddsi_locator_to_string(buff, sizeof(buff), loc);
DDS_CLOG (DDS_LC_TCP, &conn->m_base.gv->logconfig, "(tcp EP:%s)", buff); 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; struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr); socklen_t addrlen = sizeof (addr);
ddsi_tcp_listener_t tl = NULL; ddsi_tcp_listener_t tl = NULL;
struct ddsi_tran_factory_tcp * const fact_tcp = (struct ddsi_tran_factory_tcp *) fact;
(void) qos; (void) qos;
@ -894,7 +891,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (ddsi_tran_factory_t fact,
return NULL; 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); 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) 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; struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) conn->m_base.m_factory;
#endif
char buff[DDSI_LOCSTRLEN]; 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); 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 #ifdef DDSI_INCLUDE_SSL
@ -932,10 +927,10 @@ static void ddsi_tcp_close_conn (ddsi_tran_conn_t tc)
char buff[DDSI_LOCSTRLEN]; char buff[DDSI_LOCSTRLEN];
nn_locator_t loc; nn_locator_t loc;
ddsi_tcp_conn_t conn = (ddsi_tcp_conn_t) tc; 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); 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); (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; loc.port = conn->m_peer_port;
purge_proxy_participants (conn->m_base.m_base.gv, &loc, conn->m_base.m_server); 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); } while (ret == DDS_RETCODE_INTERRUPTED);
if (ret != DDS_RETCODE_OK) if (ret != DDS_RETCODE_OK)
{ {
struct ddsi_tran_factory_tcp * const fact = (struct ddsi_tran_factory_tcp *) listener->m_factory;
char buff[DDSI_LOCSTRLEN]; 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); 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; 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) 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/heap.h"
#include "dds/ddsrt/ifaddrs.h" #include "dds/ddsrt/ifaddrs.h"
#include "dds/ddsi/ddsi_tran.h" #include "dds/ddsi/ddsi_tran.h"
#include "dds/ddsi/ddsi_ipaddr.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_globals.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; 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); if (loc->tran != ownloc->tran || loc->kind != ownloc->kind)
return tran ? tran->m_is_nearby_address_fn (tran, loc, ownloc, ninterf, interf) : DNAR_DISTANT; 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 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); 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 */ /* FIXME: should add a "factory" for INVALID locators */
if (loc->kind != NN_LOCATOR_KIND_INVALID) { 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 {
(void) snprintf (dst, sizeof_dst, "invalid/0:0"); (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; 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) { 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 {
(void) snprintf (dst, sizeof_dst, "invalid/0"); (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; 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 (ret > 0)
{ {
if (srcloc) 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) 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]; char addrbuf[DDSI_LOCSTRLEN];
nn_locator_t tmp; 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_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(conn->m_base.gv, addrbuf, sizeof(addrbuf), &tmp); 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); 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); 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) { 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 { } else {
struct sockaddr_in src; struct sockaddr_in src;
nn_udpv4mcgen_address_t mcgen; 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) if (port_mode >= 0)
{ {
loc.port = (unsigned) port_mode; 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); add_to_addrset (gv, as, &loc);
} }
else 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); loc.port = ddsi_get_port (&gv->config, DDSI_PORT_UNI_DISC, i);
if (i == 0) 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 else
GVLOG (DDS_LC_CONFIG, ", :%"PRIu32, loc.port); GVLOG (DDS_LC_CONFIG, ", :%"PRIu32, loc.port);
add_to_addrset (gv, as, &loc); 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); loc.port = ddsi_get_port (&gv->config, DDSI_PORT_MULTI_DISC, 0);
else else
loc.port = (uint32_t) port_mode; 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); add_to_addrset (gv, as, &loc);
} }
} }
@ -231,6 +231,7 @@ void unref_addrset (struct addrset *as)
void set_unspec_locator (nn_locator_t *loc) void set_unspec_locator (nn_locator_t *loc)
{ {
loc->tran = NULL;
loc->kind = NN_LOCATOR_KIND_INVALID; loc->kind = NN_LOCATOR_KIND_INVALID;
loc->port = NN_LOCATOR_PORT_INVALID; loc->port = NN_LOCATOR_PORT_INVALID;
memset (loc->address, 0, sizeof (loc->address)); 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; const struct q_globals *gv = arg->gv;
char buf[DDSI_LOCSTRLEN]; char buf[DDSI_LOCSTRLEN];
if (gv->logconfig.c.mask & arg->tf) 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 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; 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: case DNAR_DISTANT:
break; break;
@ -738,7 +738,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
} }
GVLOGDISC (" QOS={"); GVLOGDISC (" QOS={");
nn_log_xqos (DDS_LC_DISCOVERY, &gv->logconfig, &datap->qos); nn_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, &datap->qos);
GVLOGDISC ("}\n"); GVLOGDISC ("}\n");
maybe_add_pp_as_meta_to_as_disc (gv, as_meta); 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); GVLOGDISC (" ssm=%u", ssm);
#endif #endif
GVLOGDISC (") QOS={"); GVLOGDISC (") QOS={");
nn_log_xqos (DDS_LC_DISCOVERY, &gv->logconfig, xqos); nn_xqos_log (DDS_LC_DISCOVERY, &gv->logconfig, xqos);
GVLOGDISC ("}\n"); GVLOGDISC ("}\n");
if ((datap->endpoint_guid.entityid.u & NN_ENTITYID_SOURCE_MASK) == NN_ENTITYID_SOURCE_VENDOR && !vendor_is_eclipse_or_prismtech (vendorid)) 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; struct print_address_arg *arg = varg;
char buf[DDSI_LOCSTRLEN]; 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) 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; nn_locator_t loc;
char buf[DDSI_LOCSTRLEN]; char buf[DDSI_LOCSTRLEN];
(void) ddsi_listener_locator(dm->servsock, &loc); (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); 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)); !!(mask & QP_TOPIC_DATA));
#endif #endif
EELOGDISC (e, "update_qos_locked "PGUIDFMT" delta=%"PRIu64" QOS={", PGUID(e->guid), mask); 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"); EELOGDISC (e, "}\n");
if (mask == 0) 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) if (gv->logconfig.c.mask & DDS_LC_DISCOVERY)
{ {
GVLOGDISC ("PARTICIPANT "PGUIDFMT" QOS={", PGUID (pp->e.guid)); 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"); 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++) for (i = 0; i < nlocs; i++)
{ {
char buf[DDSI_LOCATORSTRLEN]; 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]); GVLOGDISC (" loc %2d = %-30s %2d {", i, buf, locs_nrds[i]);
for (j = 0; j < nreaders; j++) for (j = 0; j < nreaders; j++)
if (covered[j * nlocs + i] >= 0) 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]; char str[DDSI_LOCATORSTRLEN];
if (locs[locidx].kind != NN_LOCATOR_KIND_UDPv4MCGEN) 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); GVLOGDISC (" simple %s\n", str);
add_to_addrset(gv, newas, &locs[locidx]); 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]; iph |= 1u << covered[i * nlocs + locidx];
ipn = htonl(iph); ipn = htonl(iph);
memcpy(l.address + 12, &ipn, 4); 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); GVLOGDISC (" mcgen %s\n", str);
add_to_addrset(gv, newas, &l); 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); set_topic_type_name (wr->xqos, topic);
ELOGDISC (wr, "WRITER "PGUIDFMT" QOS={", PGUID (wr->e.guid)); 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"); ELOGDISC (wr, "}\n");
assert (wr->xqos->present & QP_RELIABILITY); 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) if (rd->e.gv->logconfig.c.mask & DDS_LC_DISCOVERY)
{ {
ELOGDISC (rd, "READER "PGUIDFMT" QOS={", PGUID (rd->e.guid)); 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"); ELOGDISC (rd, "}\n");
} }
assert (rd->xqos->present & QP_RELIABILITY); 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); const uint32_t port = ddsi_get_port (&gv->config, DDSI_PORT_MULTI_DISC, 0);
int rc = 0; int rc = 0;
/* FIXME: FIXME: FIXME: */ /* FIXME: FIXME: FIXME: */
gv->loc_spdp_mc.tran = NULL;
gv->loc_spdp_mc.kind = NN_LOCATOR_KIND_INVALID; gv->loc_spdp_mc.kind = NN_LOCATOR_KIND_INVALID;
if (strcmp (gv->config.spdpMulticastAddressString, "239.255.0.1") != 0) 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) if (!gv->config.externalMaskString || strcmp (gv->config.externalMaskString, "0.0.0.0") == 0)
{ {
memset(&gv->extmask.address, 0, sizeof(gv->extmask.address)); memset(&gv->extmask.address, 0, sizeof(gv->extmask.address));
gv->extmask.tran = NULL;
gv->extmask.kind = NN_LOCATOR_KIND_INVALID; gv->extmask.kind = NN_LOCATOR_KIND_INVALID;
gv->extmask.port = NN_LOCATOR_PORT_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) /* FIXME: two things (at least)
- it claims there is a key, but the underlying type description is missing - 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)); struct ddsi_sertopic_default *st = ddsrt_malloc (sizeof (*st));
memset (st, 0, sizeof (*st)); memset (st, 0, sizeof (*st));
ddsi_sertopic_init_anon (&st->c, &ddsi_sertopic_ops_default, ops, false); ddsi_sertopic_init_anon (&st->c, &ddsi_sertopic_ops_default, ops, false);
st->gv = gv;
st->native_encoding_identifier = enc_id; st->native_encoding_identifier = enc_id;
st->serpool = serpool; st->serpool = serpool;
st->nkeys = 1; 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) 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->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->serpool, DDSRT_ENDIAN == DDSRT_LITTLE_ENDIAN ? CDR_LE : CDR_BE, &ddsi_serdata_ops_rawcdr); 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) static void free_special_topics (struct q_globals *gv)
@ -1024,12 +1027,12 @@ int rtps_init (struct q_globals *gv)
{ {
char buf[DDSI_LOCSTRLEN]; 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 */ /* 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, "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 (gv, buf, sizeof(buf), &gv->extloc)); 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 (gv, buf, sizeof(buf), &gv->extmask), gv->m_factory->m_kind != NN_LOCATOR_KIND_UDPv4 ? " (not applicable)" : ""); 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, "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, "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 (gv, buf, sizeof(buf), &gv->loc_default_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 #ifdef DDSI_INCLUDE_SSM
GVLOG (DDS_LC_CONFIG, "SSM support included\n"); GVLOG (DDS_LC_CONFIG, "SSM support included\n");
#endif #endif
@ -1342,7 +1345,7 @@ int rtps_init (struct q_globals *gv)
{ {
struct config_peer_listelem peer_local; struct config_peer_listelem peer_local;
char local_addr[DDSI_LOCSTRLEN]; 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.next = NULL;
peer_local.peer = local_addr; peer_local.peer = local_addr;
add_peer_addresses (gv, gv->as_disc, &peer_local); 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 else
#endif #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); GVLOG (DDS_LC_CONFIG, " %s(", addrbuf);
if (!(ifa->flags & IFF_MULTICAST) && multicast_override (if_name, &gv->config)) 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) 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 else
{ {
@ -593,7 +593,7 @@ int find_own_ip (struct q_globals *gv, const char *requested_address)
const int idx = maxq_list[0]; const int idx = maxq_list[0];
char *names; char *names;
int p; 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); names = ddsrt_malloc (maxq_strlen + 1);
p = 0; p = 0;
for (i = 0; i < maxq_count && (size_t) p < maxq_strlen; i++) for (i = 0; i < maxq_count && (size_t) p < maxq_strlen; i++)

588
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 (*fini) (void * __restrict dst, size_t * __restrict dstoff, struct flagset *flagset, uint64_t flag);
dds_return_t (*valid) (const void *src, size_t srcoff); dds_return_t (*valid) (const void *src, size_t srcoff);
bool (*equal) (const void *srcx, const void *srcy, 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; } f;
} op; } op;
dds_return_t (*deser_validate_xform) (void * __restrict dst, const struct dd * __restrict dd); 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); 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_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_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); 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 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 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 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 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) 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; 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) #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) 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; 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) 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)); 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; 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) 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)); 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)); 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) 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)); char * const p = nn_xmsg_addpar (xmsg, pid, 24);
memcpy (p, &l->loc, sizeof (nn_locator_t)); memcpy (p, &l->loc.kind, 4);
memcpy (p + 4, &l->loc.port, 4);
memcpy (p + 8, l->loc.address, 16);
} }
return 0; return 0;
} }
@ -310,6 +352,21 @@ static dds_return_t fini_locator (void * __restrict dst, size_t * __restrict dst
return 0; 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) static size_t ser_generic_srcsize (const enum pserop * __restrict desc)
{ {
size_t srcoff = 0, srcalign = 0; 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); 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 membersize(type, member) sizeof (((type *) 0)->member)
#define ENTRY(PFX_, NAME_, member_, flag_, validate_, ...) \ #define ENTRY(PFX_, NAME_, member_, flag_, validate_, ...) \
{ PID_##NAME_, flag_, PFX_##_##NAME_, #NAME_, offsetof (struct nn_plist, member_), \ { 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 #endif
/* Standardized parameters -- QoS _MUST_ come first (nn_plist_init_tables verifies this) because /* 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 */ it allows early-out when processing a dds_qos_t instead of an nn_plist_t */
static const struct piddesc piddesc_omg[] = { 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 */ /* 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", { PID_RELIABILITY, PDF_QOS | PDF_FUNCTION, QP_RELIABILITY, "RELIABILITY",
offsetof (struct nn_plist, qos.reliability), membersize (struct nn_plist, qos.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 (LIFESPAN, lifespan, XD),
QP (DESTINATION_ORDER, destination_order, XE1), 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" */ /* 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), PP (DOMAIN_TAG, domain_tag, XS),
{ PID_STATUSINFO, PDF_FUNCTION, PP_STATUSINFO, "STATUSINFO", { PID_STATUSINFO, PDF_FUNCTION, PP_STATUSINFO, "STATUSINFO",
offsetof (struct nn_plist, statusinfo), membersize (struct nn_plist, 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; /* 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 that is manageable for deser, unalias and fini, but it breaks ser because that one only
generates a single parameter header */ generates a single parameter header */
{ PID_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI, { PID_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_UNICAST_LOCATOR, "UNICAST_LOCATOR", PP_UNICAST_LOCATOR, "UNICAST_LOCATOR",
offsetof (struct nn_plist, unicast_locators), membersize (struct nn_plist, unicast_locators), 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, { PID_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_MULTICAST_LOCATOR, "MULTICAST_LOCATOR", PP_MULTICAST_LOCATOR, "MULTICAST_LOCATOR",
offsetof (struct nn_plist, multicast_locators), membersize (struct nn_plist, multicast_locators), 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, { PID_DEFAULT_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_DEFAULT_UNICAST_LOCATOR, "DEFAULT_UNICAST_LOCATOR", PP_DEFAULT_UNICAST_LOCATOR, "DEFAULT_UNICAST_LOCATOR",
offsetof (struct nn_plist, default_unicast_locators), membersize (struct nn_plist, default_unicast_locators), 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, { PID_DEFAULT_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_DEFAULT_MULTICAST_LOCATOR, "DEFAULT_MULTICAST_LOCATOR", PP_DEFAULT_MULTICAST_LOCATOR, "DEFAULT_MULTICAST_LOCATOR",
offsetof (struct nn_plist, default_multicast_locators), membersize (struct nn_plist, default_multicast_locators), 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, { PID_METATRAFFIC_UNICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_METATRAFFIC_UNICAST_LOCATOR, "METATRAFFIC_UNICAST_LOCATOR", PP_METATRAFFIC_UNICAST_LOCATOR, "METATRAFFIC_UNICAST_LOCATOR",
offsetof (struct nn_plist, metatraffic_unicast_locators), membersize (struct nn_plist, metatraffic_unicast_locators), 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, { PID_METATRAFFIC_MULTICAST_LOCATOR, PDF_FUNCTION | PDF_ALLOWMULTI,
PP_METATRAFFIC_MULTICAST_LOCATOR, "METATRAFFIC_MULTICAST_LOCATOR", PP_METATRAFFIC_MULTICAST_LOCATOR, "METATRAFFIC_MULTICAST_LOCATOR",
offsetof (struct nn_plist, metatraffic_multicast_locators), membersize (struct nn_plist, metatraffic_multicast_locators), 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. /* 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 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 */ 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); 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) uint64_t pcheck, qcheck;
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;
}
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) if (piddesc_unalias[0] == NULL)
nn_plist_init_tables (); nn_plist_init_tables ();
*pdelta = (x->present ^ y->present) & pmask; if (shift > 0)
const uint64_t pcheck = (x->present & y->present) & pmask; {
*qdelta = (x->qos.present ^ y->qos.present) & qmask; const dds_qos_t *x = srcx;
const uint64_t qcheck = (x->qos.present & y->qos.present) & qmask; 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;
pcheck = (x->present & y->present) & pmask;
*qdelta = (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++) 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]; struct piddesc const * const table = piddesc_tables_all[k];
for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++) for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++)
{ {
struct piddesc const * const entry = &table[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; const uint64_t check = (entry->flags & PDF_QOS) ? qcheck : pcheck;
uint64_t * const delta = (entry->flags & PDF_QOS) ? qdelta : pdelta; 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) if (check & entry->present_flag)
{ {
const size_t srcoff = entry->plist_offset; const size_t off = entry->plist_offset - shift;
bool equal; bool equal;
/* Partition is special-cased because it is a set (with a special rules /* 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 for empty sets and empty strings to boot), and normal string sequence
comparison requires the ordering to be the same */ comparison requires the ordering to be the same */
if (entry->pid == PID_PARTITION) 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)) 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 else
equal = entry->op.f.equal (x, y, srcoff); equal = entry->op.f.equal (srcx, srcy, off);
if (!equal) if (!equal)
*delta |= entry->present_flag; *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) static dds_return_t validate_external_duration (const ddsi_duration_t *d)
{ {
/* Accepted are zero, positive, infinite or invalid as defined in /* 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; nn_locator_t loc;
if (dd->bufsz < sizeof (loc)) if (dd->bufsz < 24)
return DDS_RETCODE_BAD_PARAMETER; 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) if (dd->bswap)
{ {
loc.kind = ddsrt_bswap4 (loc.kind); 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; return DDS_RETCODE_BAD_PARAMETER;
if (loc.port != 0) if (loc.port != 0)
return DDS_RETCODE_BAD_PARAMETER; return DDS_RETCODE_BAD_PARAMETER;
/* silently dropped correctly formatted "invalid" locators. */ /* silently drop correctly formatted "invalid" locators. */
return 0; return 0;
case NN_LOCATOR_KIND_RESERVED: case NN_LOCATOR_KIND_RESERVED:
/* silently dropped "reserved" locators. */ /* silently drop "reserved" locators. */
return 0; return 0;
default: default:
return 0; return 0;
} }
loc.tran = ddsi_factory_supports (factory, loc.kind) ? factory : NULL;
return add_locator (ls, present, wanted, fl, &loc); 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) 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->kind = factory->m_connless ? NN_LOCATOR_KIND_UDPv4 : NN_LOCATOR_KIND_TCPv4;
loc->port = *p; loc->port = *p;
memset (loc->address, 0, 12); 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); ret = entry->deser_validate_xform (dst, dd);
if (ret < 0) 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->vendorid.id[0], dd->vendorid.id[1],
dd->protocol_version.major, dd->protocol_version.minor, dd->protocol_version.major, dd->protocol_version.minor,
pid, entry->name); pid, entry->name, tmp);
log_octetseq (DDS_LC_WARNING, logcfg, (uint32_t) dd->bufsz, dd->buf);
DDS_CWARNING (logcfg, "\n");
} }
return ret; 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) 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); char tmp[256], *ptmp = tmp;
log_octetseq (DDS_LC_PLIST, src->logconfig, length, (const unsigned char *) (par + 1)); size_t tmpsize = sizeof (tmp);
DDS_CLOG (DDS_LC_PLIST, src->logconfig, "\n"); (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); 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; 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 /* Return true iff (the set a->strs) equals (the set b->strs); that
is, order doesn't matter. One could argue that "**" and "*" are is, order doesn't matter. One could argue that "**" and "*" are
equal, but we're not that precise here. */ 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; /* shift == 0: plist, shift > 0: just qos */
for (m = 0; m < n && xs[m] != '"' && isprint (xs[m]) && xs[m] < 127; m++) const char *sep = "";
; uint64_t pw, qw;
return m; if (shift > 0)
}
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)
{ {
uint32_t m = isprint_runlen (n - i, xs); const dds_qos_t *qos = src;
if (m >= 4 || (i == 0 && m == n)) pw = 0;
qw = qos->present & qwanted;
}
else
{
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++)
{
struct piddesc const * const table = piddesc_tables_output[k];
for (uint32_t i = 0; table[i].pid != PID_SENTINEL; i++)
{ {
DDS_CLOG (cat, logcfg, "%s\"%*.*s\"", i == 0 ? "" : ",", m, m, xs); struct piddesc const * const entry = &table[i];
xs += m; if (entry->pid == PID_PAD)
i += m; continue;
} if (((entry->flags & PDF_QOS) ? qw : pw) & entry->present_flag)
else
{
if (m == 0)
m = 1;
while (m--)
{ {
DDS_CLOG (cat, logcfg, "%s%u", i == 0 ? "" : ",", *xs++); assert (entry->plist_offset >= shift);
i++; 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; if (logcfg->c.mask & cat)
const char *prefix = ""; {
#define LOGB0(fmt_) DDS_CLOG (cat, logcfg, "%s" fmt_, prefix) char tmp[1024], *ptmp = tmp;
#define LOGB1(fmt_, ...) DDS_CLOG (cat, logcfg, "%s" fmt_, prefix, __VA_ARGS__) size_t tmpsize = sizeof (tmp);
#define DO(name_, body_) do { if (p & QP_##name_) { { body_ } prefix = ","; } } while (0) plist_or_xqos_print (&ptmp, &tmpsize, src, shift, pwanted, qwanted);
DDS_CLOG (cat, logcfg, "%s", tmp);
#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); }); size_t nn_xqos_print (char * __restrict buf, size_t bufsize, const dds_qos_t *xqos)
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); }); const size_t bufsize_in = bufsize;
DO (PARTITION, { (void) prtf (&buf, &bufsize, "{");
LOGB0 ("partition={"); plist_or_xqos_print (&buf, &bufsize, xqos, offsetof (nn_plist_t, qos), 0, ~(uint64_t)0);
for (uint32_t i = 0; i < xqos->partition.n; i++) { (void) prtf (&buf, &bufsize, "}");
DDS_CLOG (cat, logcfg, "%s%s", (i == 0) ? "" : ",", xqos->partition.strs[i]); return bufsize_in - bufsize;
} }
DDS_CLOG (cat, logcfg, "}");
}); size_t nn_plist_print (char * __restrict buf, size_t bufsize, const nn_plist_t *plist)
DO (GROUP_DATA, { {
LOGB1 ("group_data=%"PRIu32"<", xqos->group_data.length); const size_t bufsize_in = bufsize;
log_octetseq (cat, logcfg, xqos->group_data.length, xqos->group_data.value); (void) prtf (&buf, &bufsize, "{");
DDS_CLOG (cat, logcfg, ">"); plist_or_xqos_print (&buf, &bufsize, plist, 0, ~(uint64_t)0, ~(uint64_t)0);
}); (void) prtf (&buf, &bufsize, "}");
DO (TOPIC_DATA, { return bufsize_in - bufsize;
LOGB1 ("topic_data=%"PRIu32"<", xqos->topic_data.length); }
log_octetseq (cat, logcfg, xqos->topic_data.length, xqos->topic_data.value);
DDS_CLOG(cat, logcfg, ">"); void nn_xqos_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const dds_qos_t *xqos)
}); {
DO (DURABILITY, { LOGB1 ("durability=%d", xqos->durability.kind); }); plist_or_xqos_log (cat, logcfg, xqos, offsetof (nn_plist_t, qos), 0, ~(uint64_t)0);
DO (DURABILITY_SERVICE, { }
LOGB0 ("durability_service=");
DDS_CLOG(cat, logcfg, FMT_DUR, PRINTARG_DUR (xqos->durability_service.service_cleanup_delay)); void nn_plist_log (uint32_t cat, const struct ddsrt_log_cfg *logcfg, const nn_plist_t *plist)
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); plist_or_xqos_log (cat, logcfg, plist, 0, ~(uint64_t)0, ~(uint64_t)0);
});
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
} }

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) if (gv->logconfig.c.mask & DDS_LC_TRACE)
{ {
char addrstr[DDSI_LOCSTRLEN]; 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", 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); 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; ddsrt_iovec_t iov;
iov.iov_base = &dummy; iov.iov_base = &dummy;
iov.iov_len = 1; 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); ddsi_conn_write (gv->data_conn_uc, dst, 1, &iov, 0);
break; 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) if (gv->logconfig.c.mask & DDS_LC_TRACE)
{ {
char buf[DDSI_LOCSTRLEN]; 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) 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; struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr); dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "pub/sub: delta = %"PRIx64"\n", delta); 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_xqos_log (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, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
} }
dds_delete_qos (b); dds_delete_qos (b);
return delta == 0; 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; struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr); dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "reader: delta = %"PRIx64"\n", delta); 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_xqos_log (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, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
} }
dds_delete_qos (b); dds_delete_qos (b);
return delta == 0; 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; struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr); dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "writer: delta = %"PRIx64"\n", delta); 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_xqos_log (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, b); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
} }
dds_delete_qos (b); dds_delete_qos (b);
return delta == 0; return delta == 0;
@ -275,8 +275,8 @@ MPT_ProcessEntry (rw_publisher,
struct ddsrt_log_cfg logcfg; struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr); dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "matched reader: delta = %"PRIx64"\n", delta); 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_xqos_log (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, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
} }
MPT_ASSERT (delta == 0, "writer %zu %zu matched reader QoS mismatch\n", i, j); MPT_ASSERT (delta == 0, "writer %zu %zu matched reader QoS mismatch\n", i, j);
dds_delete_qos (ep->qos); dds_delete_qos (ep->qos);
@ -427,8 +427,8 @@ MPT_ProcessEntry (rw_subscriber,
struct ddsrt_log_cfg logcfg; struct ddsrt_log_cfg logcfg;
dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr); dds_log_cfg_init (&logcfg, 0, DDS_LC_ERROR, stderr, stderr);
DDS_CLOG (DDS_LC_ERROR, &logcfg, "matched writer: delta = %"PRIx64"\n", delta); 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_xqos_log (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, ep->qos); DDS_CLOG (DDS_LC_ERROR, &logcfg, "\n");
} }
MPT_ASSERT (delta == 0, "reader %zu %zu matched writer QoS mismatch\n", i, j); MPT_ASSERT (delta == 0, "reader %zu %zu matched writer QoS mismatch\n", i, j);
dds_delete_qos (ep->qos); dds_delete_qos (ep->qos);

11
src/tools/decode-trace
View file

@ -352,8 +352,10 @@ while(<>) {
$rwguid{$tid} = $guid; # if $is_cyclone; $rwguid{$tid} = $guid; # if $is_cyclone;
die "$guid $rwguid{$tid}" unless $guid eq $rwguid{$tid}; die "$guid $rwguid{$tid}" unless $guid eq $rwguid{$tid};
my $topic; my $type; my $groupcoh; my $partitions; my $keepall; my $topic; my $type; my $groupcoh; my $partitions; my $keepall;
if ($3 =~ /topic=([^,]+?),type=([^,]+?).*?,presentation=(\d:\d):\d,partition=\{([^}]*?)\}.*?,history=([01]):/) { if ($qos =~ /topic(?:_name)?=([^,]+?),type(?:_name)=([^,]+?).*?,partition=\{([^}]*?)\}/) {
$topic = $1; $type = $2; $groupcoh = ($3 eq "2:1"); $partitions = $4; $keepall = $5; $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 unless (defined $rwguid{$tid} && ($ftrflag{$tid} || (defined $psgid{$tid} && defined $psguid{$tid} && defined $rwgid{$tid})) || 1) { # $is_cyclone
die; die;
} }
@ -623,15 +625,14 @@ while(<>) {
my $h = ($kind eq "READER") ? \%prd : \%pwr; my $h = ($kind eq "READER") ? \%prd : \%pwr;
my $hk = ($kind eq "READER") ? "prd" : "pwr"; my $hk = ($kind eq "READER") ? "prd" : "pwr";
my $qos = $3; 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]$/; 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/; (my $ppguid = $prwguid) =~ s/:[0-9a-f]+$/:1c1/;
die unless exists $proxypp{$ppguid} && !defined $proxypp{$ppguid}->{tdel}; die unless exists $proxypp{$ppguid} && !defined $proxypp{$ppguid}->{tdel};
my @ps = split ',', $partitions; my @ps = split ',', $partitions;
my $stopic = make_stopic($partitions, $topic); 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, my $prw = { guid => $prwguid, ppguid => $ppguid,
topic => $topic, stopic => $stopic, type => $type, partition => \@ps, topic => $topic, stopic => $stopic, type => $type, partition => \@ps,
matches => {}, checklost => 0, suppressbegin => 0, tcreate => $ts, tstamps => {} }; matches => {}, checklost => 0, suppressbegin => 0, tcreate => $ts, tstamps => {} };