Enable "missing prototypes" warning for gcc, clang

Missing prototypes for exported functions cause a really huge issue on
Windows.  Enabling the "missing prototypes" warning makes it much easier
to catch this problem.  Naturally, any warnings caused by this have been
fixed.

Signed-off-by: Erik Boasson <eb@ilities.com>

src/CMakeLists.txt

@@ -87,12 +87,12 @@ endif()
 # Set reasonably strict warning options for clang, gcc, msvc
 # Enable coloured ouput if Ninja is used for building
 if(${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-  add_definitions(-Wall -Wextra -Wconversion -Wunused)
+  add_definitions(-Wall -Wextra -Wconversion -Wunused -Wmissing-prototypes)
   if(${CMAKE_GENERATOR} STREQUAL "Ninja")
     add_definitions(-Xclang -fcolor-diagnostics)
   endif()
 elseif(${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-  add_definitions(-Wall -Wextra -Wconversion)
+  add_definitions(-Wall -Wextra -Wconversion -Wmissing-prototypes)
   if(${CMAKE_GENERATOR} STREQUAL "Ninja")
     add_definitions(-fdiagnostics-color=always)
   endif()
@@ -131,6 +131,7 @@ if(${CMAKE_GENERATOR} STREQUAL "Xcode")
   set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VALUE YES)
   set (CMAKE_XCODE_ATTRIBUTE_GCC_WARN_UNUSED_VARIABLE YES)
   set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_DOCUMENTATION_COMMENTS YES)
+  set (CMAKE_XCODE_ATTRIBUTE_CLANG_WARN_MISSING_PROTOTYPES YES)
 endif()
 
 # Make it easy to enable one of Clang's/gcc's analyzers, and default to using

src/cmake/modules/CUnit/include/CUnit/Test.h

@@ -28,21 +28,24 @@ typedef struct {
 #define CU_TestProxyName(suite, test) \
   CU_TestProxy_ ## suite ## _ ## test
 
-#define CU_Init(suite) \
-  int CU_InitName(suite)(void)
 #define CU_InitDecl(suite) \
-  extern CU_Init(suite)
+  extern int CU_InitName(suite)(void)
+#define CU_Init(suite) \
+  CU_InitDecl(suite); \
+  int CU_InitName(suite)(void)
 
-#define CU_Clean(suite) \
-  int CU_CleanName(suite)(void)
 #define CU_CleanDecl(suite) \
-  extern CU_Clean(suite)
+  extern int CU_CleanName(suite)(void)
+#define CU_Clean(suite) \
+  CU_CleanDecl(suite); \
+  int CU_CleanName(suite)(void)
 
 /* CU_Test generates a wrapper function that takes care of per-test
    initialization and deinitialization, if provided in the CU_Test
    signature. */
 #define CU_Test(suite, test, ...)                          \
   static void CU_TestName(suite, test)(void);              \
+  void CU_TestProxyName(suite, test)(void);                \
                                                            \
   void CU_TestProxyName(suite, test)(void) {               \
     cu_data_t data = CU_Fixture(__VA_ARGS__);              \

src/cmake/modules/CUnit/include/CUnit/Theory.h

@@ -44,6 +44,7 @@ extern "C" {
 
 #define CU_Theory(signature, suite, test, ...)                            \
   static void CU_TestName(suite, test) signature;                         \
+  void CU_TestProxyName(suite, test)(void);                               \
                                                                           \
   void CU_TestProxyName(suite, test)(void) {                              \
     cu_data_t data = CU_Fixture(__VA_ARGS__);                             \

src/core/ddsc/src/dds_rhc.c

@@ -217,12 +217,14 @@ static int lwregs_delete (struct lwregs *rt, uint64_t iid, uint64_t wr_iid)
   return ddsrt_ehh_remove (rt->regs, &dummy);
 }
 
+#if 0
 void lwregs_dump (struct lwregs *rt)
 {
   struct ddsrt_ehh_iter it;
   for (struct lwreg *r = ddsrt_ehh_iter_first(rt->regs, &it); r; r = ddsrt_ehh_iter_next(&it))
     printf("iid=%"PRIu64" wr_iid=%"PRIu64"\n", r->iid, r->wr_iid);
 }
+#endif
 
 /*************************
  ******     RHC     ******

src/core/ddsc/src/dds_serdata_builtintopic.c

@@ -126,7 +126,7 @@ static void from_entity_pwr (struct ddsi_serdata_builtintopic *d, const struct p
   assert (d->xqos.present & QP_TYPE_NAME);
 }
 
-struct ddsi_serdata *ddsi_serdata_builtin_from_keyhash (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
+static struct ddsi_serdata *ddsi_serdata_builtin_from_keyhash (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
 {
   /* FIXME: not quite elegant to manage the creation of a serdata for a built-in topic via this function, but I also find it quite unelegant to let from_sample read straight from the underlying internal entity, and to_sample convert to the external format ... I could claim the internal entity is the "serialised form", but that forces wrapping it in a fragchain in one way or another, which, though possible, is also a bit lacking in elegance. */
   const struct ddsi_sertopic_builtintopic *tp = (const struct ddsi_sertopic_builtintopic *)tpcmn;

src/core/ddsc/src/dds_waitset.c

@@ -133,7 +133,7 @@ static bool dds_waitset_remove_from_list (dds_attachment **list, dds_entity_t ob
   return true;
 }
 
-dds_return_t dds_waitset_close (struct dds_entity *e)
+static dds_return_t dds_waitset_close (struct dds_entity *e)
 {
   dds_waitset *ws = (dds_waitset *) e;
   dds_waitset_close_list (&ws->observed,  e->m_hdllink.hdl);
@@ -206,7 +206,7 @@ static void dds_waitset_remove (dds_waitset *ws, dds_entity_t observed)
 }
 
 /* This is called when the observed entity signals a status change. */
-void dds_waitset_observer (dds_entity_t observer, dds_entity_t observed, uint32_t status)
+static void dds_waitset_observer (dds_entity_t observer, dds_entity_t observed, uint32_t status)
 {
   dds_waitset *ws;
   if (dds_waitset_lock (observer, &ws) == DDS_RETCODE_OK) {

src/core/ddsc/tests/entity_api.c

@@ -24,7 +24,7 @@
 static dds_entity_t entity = -1;
 
 /* Fixture to create prerequisite entity */
-void create_entity(void)
+static void create_entity(void)
 {
     CU_ASSERT_EQUAL_FATAL(entity, -1);
     entity = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
@@ -32,7 +32,7 @@ void create_entity(void)
 }
 
 /* Fixture to delete prerequisite entity */
-void delete_entity(void)
+static void delete_entity(void)
 {
     CU_ASSERT_FATAL(entity > 0);
     dds_return_t ret = dds_delete(entity);
@@ -66,7 +66,7 @@ CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity)
     CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
 }
 
-void entity_qos_get_set(dds_entity_t e, const char* info)
+static void entity_qos_get_set(dds_entity_t e, const char* info)
 {
     dds_return_t status;
     dds_qos_t *qos = dds_create_qos();

src/core/ddsc/tests/return_loan.c

@@ -15,9 +15,9 @@
 #include <stdio.h>
 #include "CUnit/Test.h"
 
-dds_entity_t participant = 0, topic = 0, reader = 0, read_condition = 0;
+static dds_entity_t participant = 0, topic = 0, reader = 0, read_condition = 0;
 
-void create_entities(void)
+static void create_entities(void)
 {
     participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
     CU_ASSERT_FATAL(participant > 0);
@@ -32,7 +32,7 @@ void create_entities(void)
     CU_ASSERT_FATAL(read_condition > 0);
 }
 
-void delete_entities(void)
+static void delete_entities(void)
 {
     dds_return_t result;
     result = dds_delete(participant);

src/core/ddsi/include/dds/ddsi/q_plist.h

@@ -230,6 +230,7 @@ DDS_EXPORT nn_plist_t *nn_plist_dup (const nn_plist_t *src);
  */
 DDS_EXPORT dds_return_t nn_plist_init_frommsg (nn_plist_t *dest, char **nextafterplist, uint64_t pwanted, uint64_t qwanted, const nn_plist_src_t *src);
 DDS_EXPORT void nn_plist_fini (nn_plist_t *ps);
+DDS_EXPORT void nn_plist_unalias (nn_plist_t *plist);
 DDS_EXPORT void nn_plist_addtomsg (struct nn_xmsg *m, const nn_plist_t *ps, uint64_t pwanted, uint64_t qwanted);
 DDS_EXPORT void nn_plist_init_default_participant (nn_plist_t *plist);
 

src/core/ddsi/include/dds/ddsi/q_xmsg.h

@@ -120,23 +120,8 @@ void nn_xmsg_submsg_init (struct nn_xmsg *msg, struct nn_xmsg_marker marker, Sub
 void nn_xmsg_add_timestamp (struct nn_xmsg *m, nn_wctime_t t);
 void nn_xmsg_add_entityid (struct nn_xmsg * m);
 void *nn_xmsg_addpar (struct nn_xmsg *m, nn_parameterid_t pid, size_t len);
-void nn_xmsg_addpar_string (struct nn_xmsg *m, nn_parameterid_t pid, const char *str);
-void nn_xmsg_addpar_octetseq (struct nn_xmsg *m, nn_parameterid_t pid, const ddsi_octetseq_t *oseq);
-void nn_xmsg_addpar_stringseq (struct nn_xmsg *m, nn_parameterid_t pid, const ddsi_stringseq_t *sseq);
-void nn_xmsg_addpar_guid (struct nn_xmsg *m, nn_parameterid_t pid, const nn_guid_t *guid);
-void nn_xmsg_addpar_BE4u (struct nn_xmsg *m, nn_parameterid_t pid, uint32_t x);
-void nn_xmsg_addpar_4u (struct nn_xmsg *m, nn_parameterid_t pid, uint32_t x);
 void nn_xmsg_addpar_keyhash (struct nn_xmsg *m, const struct ddsi_serdata *serdata);
-void nn_xmsg_addpar_statusinfo (struct nn_xmsg *m, uint32_t statusinfo);
+void nn_xmsg_addpar_statusinfo (struct nn_xmsg *m, unsigned statusinfo);
-void nn_xmsg_addpar_reliability (struct nn_xmsg *m, nn_parameterid_t pid, const struct dds_reliability_qospolicy *rq);
-void nn_xmsg_addpar_duration (struct nn_xmsg *m, nn_parameterid_t pid, const dds_duration_t dur);
-void nn_xmsg_addpar_subscription_keys (struct nn_xmsg *m, nn_parameterid_t pid, const struct dds_subscription_keys_qospolicy *rq);
-void nn_xmsg_addpar_durability_service (struct nn_xmsg *m, nn_parameterid_t pid, const dds_durability_service_qospolicy_t *rq);
-void nn_xmsg_addpar_reader_lifespan (struct nn_xmsg *m, nn_parameterid_t pid, const dds_reader_lifespan_qospolicy_t *rq);
-void nn_xmsg_addpar_reader_data_lifecycle (struct nn_xmsg *m, nn_parameterid_t pid, const dds_reader_data_lifecycle_qospolicy_t *rq);
-void nn_xmsg_addpar_liveliness (struct nn_xmsg *m, nn_parameterid_t pid, const dds_liveliness_qospolicy_t *rq);
-
-void nn_xmsg_addpar_parvinfo (struct nn_xmsg *m, nn_parameterid_t pid, const struct nn_prismtech_participant_version_info *pvi);
 void nn_xmsg_addpar_sentinel (struct nn_xmsg *m);
 int nn_xmsg_addpar_sentinel_ifparam (struct nn_xmsg *m);
 

src/core/ddsi/src/ddsi_serdata_default.c

@@ -333,7 +333,7 @@ static struct ddsi_serdata *serdata_default_from_ser_nokey (const struct ddsi_se
   return fix_serdata_default_nokey (d, tpcmn->serdata_basehash);
 }
 
-struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
+static struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
 {
   /* FIXME: not quite sure this is correct, though a check against a specially hacked OpenSplice suggests it is */
   const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)tpcmn;
@@ -360,7 +360,7 @@ struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr (const struct ddsi_sertopic *
   }
 }
 
-struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr_nokey (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
+static struct ddsi_serdata *ddsi_serdata_from_keyhash_cdr_nokey (const struct ddsi_sertopic *tpcmn, const nn_keyhash_t *keyhash)
 {
   const struct ddsi_sertopic_default *tp = (const struct ddsi_sertopic_default *)tpcmn;
   struct ddsi_serdata_default *d = serdata_default_new(tp, SDK_KEY);

src/core/ddsi/src/ddsi_udp.c

@@ -408,7 +408,7 @@ static void ddsi_udp_release_conn (ddsi_tran_conn_t conn)
   ddsrt_free (conn);
 }
 
-void ddsi_udp_fini (void)
+static void ddsi_udp_fini (void)
 {
     if(ddsrt_atomic_dec32_nv (&ddsi_udp_init_g) == 0) {
         free_group_membership(ddsi_udp_config_g.mship);

src/core/ddsi/src/q_addrset.c

@@ -384,24 +384,6 @@ void copy_addrset_into_addrset_no_ssm (struct addrset *as, const struct addrset
   copy_addrset_into_addrset_uc (as, asadd);
   copy_addrset_into_addrset_no_ssm_mc (as, asadd);
 }
-
-void addrset_purge_ssm (struct addrset *as)
-{
-  struct addrset_node *n;
-  LOCK (as);
-  n = ddsrt_avl_cfind_min (&addrset_treedef, &as->mcaddrs);
-  while (n)
-  {
-    struct addrset_node *n1 = n;
-    n = ddsrt_avl_cfind_succ (&addrset_treedef, &as->mcaddrs, n);
-    if (ddsi_is_ssm_mcaddr (&n1->loc))
-    {
-      ddsrt_avl_cdelete (&addrset_treedef, &as->mcaddrs, n1);
-      ddsrt_free (n1);
-    }
-  }
-  UNLOCK (as);
-}
 #endif
 
 size_t addrset_count (const struct addrset *as)

src/core/ddsi/src/q_entity.c

@@ -190,7 +190,7 @@ static void entity_common_fini (struct entity_common *e)
   ddsrt_mutex_destroy (&e->lock);
 }
 
-void local_reader_ary_init (struct local_reader_ary *x)
+static void local_reader_ary_init (struct local_reader_ary *x)
 {
   ddsrt_mutex_init (&x->rdary_lock);
   x->valid = 1;
@@ -200,13 +200,13 @@ void local_reader_ary_init (struct local_reader_ary *x)
   x->rdary[0] = NULL;
 }
 
-void local_reader_ary_fini (struct local_reader_ary *x)
+static void local_reader_ary_fini (struct local_reader_ary *x)
 {
   ddsrt_free (x->rdary);
   ddsrt_mutex_destroy (&x->rdary_lock);
 }
 
-void local_reader_ary_insert (struct local_reader_ary *x, struct reader *rd)
+static void local_reader_ary_insert (struct local_reader_ary *x, struct reader *rd)
 {
   ddsrt_mutex_lock (&x->rdary_lock);
   x->n_readers++;
@@ -216,7 +216,7 @@ void local_reader_ary_insert (struct local_reader_ary *x, struct reader *rd)
   ddsrt_mutex_unlock (&x->rdary_lock);
 }
 
-void local_reader_ary_remove (struct local_reader_ary *x, struct reader *rd)
+static void local_reader_ary_remove (struct local_reader_ary *x, struct reader *rd)
 {
   uint32_t i;
   ddsrt_mutex_lock (&x->rdary_lock);
@@ -242,7 +242,7 @@ void local_reader_ary_setfastpath_ok (struct local_reader_ary *x, bool fastpath_
   ddsrt_mutex_unlock (&x->rdary_lock);
 }
 
-void local_reader_ary_setinvalid (struct local_reader_ary *x)
+static void local_reader_ary_setinvalid (struct local_reader_ary *x)
 {
   ddsrt_mutex_lock (&x->rdary_lock);
   x->valid = 0;

src/core/ddsi/src/q_thread.c

@@ -46,7 +46,7 @@ extern inline void thread_state_awake_to_awake_no_nest (struct thread_state1 *ts
 
 static struct thread_state1 *init_thread_state (const char *tname, enum thread_state state);
 
-void *ddsrt_malloc_aligned_cacheline (size_t size)
+static void *ddsrt_malloc_aligned_cacheline (size_t size)
 {
   /* This wastes some space, but we use it only once and it isn't a
      huge amount of memory, just a little over a cache line.

src/core/ddsi/src/q_xmsg.c

@@ -147,7 +147,7 @@ typedef struct {
   ddsrt_cond_t cv;
 } ddsi_sem_t;
 
-dds_return_t
+static dds_return_t
 ddsi_sem_init (ddsi_sem_t *sem, uint32_t value)
 {
   sem->value = value;
@@ -156,7 +156,7 @@ ddsi_sem_init (ddsi_sem_t *sem, uint32_t value)
   return DDS_RETCODE_OK;
 }
 
-dds_return_t
+static dds_return_t
 ddsi_sem_destroy (ddsi_sem_t *sem)
 {
   ddsrt_cond_destroy (&sem->cv);
@@ -164,7 +164,7 @@ ddsi_sem_destroy (ddsi_sem_t *sem)
   return DDS_RETCODE_OK;
 }
 
-dds_return_t
+static dds_return_t
 ddsi_sem_post (ddsi_sem_t *sem)
 {
   ddsrt_mutex_lock (&sem->mtx);
@@ -174,7 +174,7 @@ ddsi_sem_post (ddsi_sem_t *sem)
   return DDS_RETCODE_OK;
 }
 
-dds_return_t
+static dds_return_t
 ddsi_sem_wait (ddsi_sem_t *sem)
 {
   ddsrt_mutex_lock (&sem->mtx);
@@ -763,41 +763,6 @@ void nn_xmsg_setwriterseq_fragid (struct nn_xmsg *msg, const nn_guid_t *wrguid,
   msg->kindspecific.data.wrfragid = wrfragid;
 }
 
-size_t nn_xmsg_add_string_padded(unsigned char *buf, char *str)
-{
-  size_t len = strlen (str) + 1;
-  assert (len <= UINT32_MAX);
-  if (buf) {
-    /* Add cdr string */
-    struct cdrstring *p = (struct cdrstring *) buf;
-    p->length = (uint32_t)len;
-    memcpy (p->contents, str, len);
-    /* clear padding */
-    if (len < align4u (len)) {
-      memset (p->contents + len, 0, align4u (len) - len);
-    }
-  }
-  len = 4 +           /* cdr string len arg + */
-        align4u(len); /* strlen + possible padding */
-  return len;
-}
-
-size_t nn_xmsg_add_octseq_padded(unsigned char *buf, ddsi_octetseq_t *seq)
-{
-  uint32_t len = seq->length;
-  if (buf) {
-    /* Add cdr octet seq */
-    *((uint32_t *) buf) = len;
-    buf += sizeof (uint32_t);
-    memcpy (buf, seq->value, len);
-    /* clear padding */
-    if (len < align4u (len)) {
-      memset (buf + len, 0, align4u (len) - len);
-    }
-  }
-  return 4 + align4u (len);
-}
-
 void *nn_xmsg_addpar (struct nn_xmsg *m, nn_parameterid_t pid, size_t len)
 {
   const size_t len4 = (len + 3) & ~(size_t)3; /* must alloc a multiple of 4 */
@@ -816,43 +781,6 @@ void *nn_xmsg_addpar (struct nn_xmsg *m, nn_parameterid_t pid, size_t len)
   return p;
 }
 
-void nn_xmsg_addpar_string (struct nn_xmsg *m, nn_parameterid_t pid, const char *str)
-{
-  struct cdrstring *p;
-  size_t len = strlen (str) + 1;
-  p = nn_xmsg_addpar (m, pid, 4 + len);
-  p->length = (uint32_t) len;
-  memcpy (p->contents, str, len);
-}
-
-void nn_xmsg_addpar_octetseq (struct nn_xmsg *m, nn_parameterid_t pid, const ddsi_octetseq_t *oseq)
-{
-  char *p = nn_xmsg_addpar (m, pid, 4 + oseq->length);
-  *((unsigned *) p) = oseq->length;
-  memcpy (p + sizeof (int), oseq->value, oseq->length);
-}
-
-void nn_xmsg_addpar_stringseq (struct nn_xmsg *m, nn_parameterid_t pid, const ddsi_stringseq_t *sseq)
-{
-  unsigned char *tmp;
-  uint32_t i;
-  size_t len = 0;
-
-  for (i = 0; i < sseq->n; i++)
-  {
-    len += nn_xmsg_add_string_padded(NULL, sseq->strs[i]);
-  }
-
-  tmp = nn_xmsg_addpar (m, pid, 4 + len);
-
-  *((uint32_t *) tmp) = sseq->n;
-  tmp += sizeof (uint32_t);
-  for (i = 0; i < sseq->n; i++)
-  {
-    tmp += nn_xmsg_add_string_padded(tmp, sseq->strs[i]);
-  }
-}
-
 void nn_xmsg_addpar_keyhash (struct nn_xmsg *m, const struct ddsi_serdata *serdata)
 {
   if (serdata->kind != SDK_EMPTY)
@@ -863,78 +791,7 @@ void nn_xmsg_addpar_keyhash (struct nn_xmsg *m, const struct ddsi_serdata *serda
   }
 }
 
-void nn_xmsg_addpar_guid (struct nn_xmsg *m, nn_parameterid_t pid, const nn_guid_t *guid)
+static void nn_xmsg_addpar_BE4u (struct nn_xmsg *m, nn_parameterid_t pid, uint32_t x)
-{
-  unsigned *pu;
-  int i;
-  pu = nn_xmsg_addpar (m, pid, 16);
-  for (i = 0; i < 3; i++)
-  {
-    pu[i] = toBE4u (guid->prefix.u[i]);
-  }
-  pu[i] = toBE4u (guid->entityid.u);
-}
-
-void nn_xmsg_addpar_reliability (struct nn_xmsg *m, nn_parameterid_t pid, const struct dds_reliability_qospolicy *rq)
-{
-  struct dds_external_reliability_qospolicy *p;
-  p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  switch (rq->kind)
-  {
-    case DDS_RELIABILITY_BEST_EFFORT:
-      p->kind = DDS_EXTERNAL_RELIABILITY_BEST_EFFORT;
-      break;
-    case DDS_RELIABILITY_RELIABLE:
-      p->kind = DDS_EXTERNAL_RELIABILITY_RELIABLE;
-      break;
-    default:
-      assert (0);
-  }
-  p->max_blocking_time = nn_to_ddsi_duration (rq->max_blocking_time);
-}
-
-void nn_xmsg_addpar_duration (struct nn_xmsg *m, nn_parameterid_t pid, const dds_duration_t rq)
-{
-  ddsi_duration_t *p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  *p = nn_to_ddsi_duration (rq);
-}
-
-void nn_xmsg_addpar_durability_service (struct nn_xmsg *m, nn_parameterid_t pid, const dds_durability_service_qospolicy_t *rq)
-{
-  dds_external_durability_service_qospolicy_t *p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  p->history = rq->history;
-  p->resource_limits = rq->resource_limits;
-  p->service_cleanup_delay = nn_to_ddsi_duration (rq->service_cleanup_delay);
-}
-
-void nn_xmsg_addpar_reader_lifespan (struct nn_xmsg *m, nn_parameterid_t pid, const dds_reader_lifespan_qospolicy_t *rq)
-{
-  dds_external_reader_lifespan_qospolicy_t *p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  p->use_lifespan = rq->use_lifespan;
-  p->duration = nn_to_ddsi_duration (rq->duration);
-}
-
-void nn_xmsg_addpar_reader_data_lifecycle (struct nn_xmsg *m, nn_parameterid_t pid, const dds_reader_data_lifecycle_qospolicy_t *rq)
-{
-  dds_external_reader_data_lifecycle_qospolicy_t *p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  p->autopurge_disposed_samples_delay = nn_to_ddsi_duration (rq->autopurge_disposed_samples_delay);
-  p->autopurge_nowriter_samples_delay = nn_to_ddsi_duration (rq->autopurge_nowriter_samples_delay);
-}
-
-void nn_xmsg_addpar_liveliness (struct nn_xmsg *m, nn_parameterid_t pid, const dds_liveliness_qospolicy_t *rq)
-{
-  dds_external_liveliness_qospolicy_t *p = nn_xmsg_addpar (m, pid, sizeof (*p));
-  p->kind = rq->kind;
-  p->lease_duration = nn_to_ddsi_duration (rq->lease_duration);
-}
-
-void nn_xmsg_addpar_4u (struct nn_xmsg *m, nn_parameterid_t pid, uint32_t x)
-{
-  unsigned *p = nn_xmsg_addpar (m, pid, sizeof (x));
-  *p = x;
-}
-
-void nn_xmsg_addpar_BE4u (struct nn_xmsg *m, nn_parameterid_t pid, uint32_t x)
 {
   unsigned *p = nn_xmsg_addpar (m, pid, sizeof (x));
   *p = toBE4u (x);
@@ -956,40 +813,6 @@ void nn_xmsg_addpar_statusinfo (struct nn_xmsg *m, unsigned statusinfo)
   }
 }
 
-void nn_xmsg_addpar_subscription_keys (struct nn_xmsg *m, nn_parameterid_t pid, const struct dds_subscription_keys_qospolicy *q)
-{
-  unsigned char *tmp;
-  size_t len = 8; /* use_key_list, length of key_list */
-
-  for (uint32_t i = 0; i < q->key_list.n; i++)
-  {
-    size_t len1 = strlen (q->key_list.strs[i]) + 1;
-    len += 4 + align4u (len1);
-  }
-
-  tmp = nn_xmsg_addpar (m, pid, len);
-
-  tmp[0] = q->use_key_list;
-  for (uint32_t i = 1; i < sizeof (int); i++)
-  {
-      tmp[i] = 0;
-  }
-  tmp += sizeof (int);
-  *((uint32_t *) tmp) = q->key_list.n;
-  tmp += sizeof (uint32_t);
-  for (uint32_t i = 0; i < q->key_list.n; i++)
-  {
-    struct cdrstring *p = (struct cdrstring *) tmp;
-    size_t len1 = strlen (q->key_list.strs[i]) + 1;
-    assert (len1 <= UINT32_MAX);
-    p->length = (uint32_t)len1;
-    memcpy (p->contents, q->key_list.strs[i], len1);
-    if (len1 < align4u (len1))
-      memset (p->contents + len1, 0, align4u (len1) - len1);
-    tmp += 4 + align4u (len1);
-  }
-}
-
 void nn_xmsg_addpar_sentinel (struct nn_xmsg * m)
 {
   nn_xmsg_addpar (m, PID_SENTINEL, 0);
@@ -1005,27 +828,6 @@ int nn_xmsg_addpar_sentinel_ifparam (struct nn_xmsg * m)
   return 0;
 }
 
-void nn_xmsg_addpar_parvinfo (struct nn_xmsg *m, nn_parameterid_t pid, const struct nn_prismtech_participant_version_info *pvi)
-{
-  int i;
-  unsigned slen;
-  unsigned *pu;
-  struct cdrstring *ps;
-
-  /* pvi->internals cannot be NULL here */
-  slen = (unsigned) strlen(pvi->internals) + 1; /* +1 for '\0' terminator */
-  pu = nn_xmsg_addpar (m, pid, NN_PRISMTECH_PARTICIPANT_VERSION_INFO_FIXED_CDRSIZE + slen);
-  pu[0] = pvi->version;
-  pu[1] = pvi->flags;
-  for (i = 0; i < 3; i++)
-  {
-    pu[i+2] = (pvi->unused[i]);
-  }
-  ps = (struct cdrstring *)&pu[5];
-  ps->length = slen;
-  memcpy(ps->contents, pvi->internals, slen);
-}
-
 /* XMSG_CHAIN ----------------------------------------------------------
 
    Xpacks refer to xmsgs and need to release these after having been

src/ddsrt/src/cdtors.c

@@ -139,6 +139,9 @@ ddsrt_cdtor(
   #pragma data_seg()
  #endif
 #else /* _WIN32 */
+void __attribute__((constructor)) ddsrt_ctor(void);
+void __attribute__((destructor)) ddsrt_dtor(void);
+
 void __attribute__((constructor)) ddsrt_ctor(void)
 {
   ddsrt_init();

src/ddsrt/src/strtol.c

@@ -16,7 +16,7 @@
 
 #include "dds/ddsrt/strtol.h"
 
-int ddsrt_todigit(const int chr)
+static int ddsrt_todigit(const int chr)
 {
   if (chr >= '0' && chr <= '9') {
     return chr - '0';

src/ddsrt/tests/thread.c

@@ -65,7 +65,7 @@ typedef struct {
   ddsrt_threadattr_t *attr;
 } thread_arg_t;
 
-uint32_t thread_main(void *ptr)
+static uint32_t thread_main(void *ptr)
 {
   thread_arg_t *arg = (thread_arg_t *)ptr;
   ddsrt_threadattr_t *attr;
@@ -193,7 +193,7 @@ CU_Test(ddsrt_thread, thread_id)
 
 static ddsrt_mutex_t locks[2];
 
-uint32_t thread_main_waitforme(void *ptr)
+static uint32_t thread_main_waitforme(void *ptr)
 {
   uint32_t ret = 0;
   (void)ptr;
@@ -203,7 +203,7 @@ uint32_t thread_main_waitforme(void *ptr)
   return ret;
 }
 
-uint32_t thread_main_waitforit(void *ptr)
+static uint32_t thread_main_waitforit(void *ptr)
 {
   uint32_t res = 0;
   ddsrt_thread_t *thr = (ddsrt_thread_t *)ptr;

src/mpt/mpt/include/mpt/mpt.h

@@ -52,6 +52,7 @@ void MPT_ProcessEntryName(process)(args)
 #define MPT_TestProcess(suite, test, name, process, args, ...)    \
 MPT_TestInitDeclaration(suite, test);                             \
 MPT_TestFiniDeclaration(suite, test);                             \
+MPT_TestProcessDeclaration(suite, test, name);                    \
 MPT_TestProcessDeclaration(suite, test, name)                     \
 {                                                                 \
   mpt_data_t data = MPT_Fixture(__VA_ARGS__);                     \

src/mpt/tests/basic/procs/hello.c

@@ -5,7 +5,6 @@
 #include "mpt/mpt.h"
 
 #include "dds/dds.h"
-#include "helloworlddata.h"
 
 #include "dds/ddsrt/time.h"
 #include "dds/ddsrt/strtol.h"
@@ -14,6 +13,8 @@
 #include "dds/ddsrt/cdtors.h"
 #include "dds/ddsrt/sync.h"
 
+#include "hello.h"
+#include "helloworlddata.h"
 
 /* An array of one message (aka sample in dds terms) will be used. */
 #define MAX_SAMPLES 1

src/mpt/tests/qos/procs/ppud.c

@@ -14,7 +14,6 @@
 #include <assert.h>
 
 #include "mpt/mpt.h"
-#include "rwdata.h"
 
 #include "dds/dds.h"
 
@@ -23,6 +22,9 @@
 #include "dds/ddsrt/sockets.h"
 #include "dds/ddsrt/heap.h"
 
+#include "ppud.h"
+#include "rwdata.h"
+
 void ppud_init (void) { }
 void ppud_fini (void) { }
 

src/mpt/tests/qos/procs/rw.c

@@ -16,7 +16,6 @@
 #include "mpt/mpt.h"
 
 #include "dds/dds.h"
-#include "rwdata.h"
 
 #include "dds/ddsrt/time.h"
 #include "dds/ddsrt/process.h"
@@ -25,6 +24,9 @@
 
 #include "dds/ddsi/q_xqos.h"
 
+#include "rwdata.h"
+#include "rw.h"
+
 #define NPUB 10
 #define NWR_PUB 2
 

src/tools/ddsls/ddsls.c

@@ -24,7 +24,7 @@
 #define MAX_SAMPLES 10
 
 #define MAX_DURATION_BUFSZ 21
-char *qp_duration_str (char *buf, size_t bufsz, dds_duration_t d)
+static char *qp_duration_str (char *buf, size_t bufsz, dds_duration_t d)
 {
   if (d == DDS_INFINITY)
     snprintf (buf, bufsz, "infinite");
@@ -33,7 +33,7 @@ char *qp_duration_str (char *buf, size_t bufsz, dds_duration_t d)
   return buf;
 }
 
-size_t printable_seq_length (const unsigned char *as, size_t n)
+static size_t printable_seq_length (const unsigned char *as, size_t n)
 {
   size_t i;
   for (i = 0; i < n; i++) {
@@ -43,7 +43,7 @@ size_t printable_seq_length (const unsigned char *as, size_t n)
   return i;
 }
 
-void print_octetseq (const unsigned char *v, size_t sz, FILE *fp)
+static void print_octetseq (const unsigned char *v, size_t sz, FILE *fp)
 {
   size_t i, n;
   fprintf (fp, "%zu<", sz);
@@ -69,7 +69,7 @@ void print_octetseq (const unsigned char *v, size_t sz, FILE *fp)
   fprintf (fp, ">");
 }
 
-void qp_user_data (const dds_qos_t *q, FILE *fp)
+static void qp_user_data (const dds_qos_t *q, FILE *fp)
 {
   void *ud;
   size_t udsz;
@@ -82,7 +82,7 @@ void qp_user_data (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_topic_data (const dds_qos_t *q, FILE *fp)
+static void qp_topic_data (const dds_qos_t *q, FILE *fp)
 {
   void *ud;
   size_t udsz;
@@ -95,7 +95,7 @@ void qp_topic_data (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_group_data (const dds_qos_t *q, FILE *fp)
+static void qp_group_data (const dds_qos_t *q, FILE *fp)
 {
   void *ud;
   size_t udsz;
@@ -108,7 +108,7 @@ void qp_group_data (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_durability (const dds_qos_t *q, FILE *fp)
+static void qp_durability (const dds_qos_t *q, FILE *fp)
 {
   dds_durability_kind_t kind;
   if (dds_qget_durability (q, &kind))
@@ -125,7 +125,7 @@ void qp_durability (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_history (const dds_qos_t *q, FILE *fp)
+static void qp_history (const dds_qos_t *q, FILE *fp)
 {
   dds_history_kind_t kind;
   int32_t depth;
@@ -144,7 +144,7 @@ void qp_history (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_resource_limits_1 (FILE *fp, int32_t max_samples, int32_t max_instances, int32_t max_samples_per_instance, int indent)
+static void qp_resource_limits_1 (FILE *fp, int32_t max_samples, int32_t max_instances, int32_t max_samples_per_instance, int indent)
 {
   fprintf (fp, "%*.*sresource_limits: max_samples = ", indent, indent, "");
   if (max_samples == DDS_LENGTH_UNLIMITED)
@@ -163,14 +163,14 @@ void qp_resource_limits_1 (FILE *fp, int32_t max_samples, int32_t max_instances,
     fprintf (fp, "%"PRId32"\n", max_samples_per_instance);
 }
 
-void qp_resource_limits (const dds_qos_t *q, FILE *fp)
+static void qp_resource_limits (const dds_qos_t *q, FILE *fp)
 {
   int32_t max_samples, max_instances, max_samples_per_instance;
   if (dds_qget_resource_limits (q, &max_samples, &max_instances, &max_samples_per_instance))
     qp_resource_limits_1 (fp, max_samples, max_instances, max_samples_per_instance, 2);
 }
 
-void qp_presentation (const dds_qos_t *q, FILE *fp)
+static void qp_presentation (const dds_qos_t *q, FILE *fp)
 {
   dds_presentation_access_scope_kind_t access_scope;
   bool coherent_access, ordered_access;
@@ -187,7 +187,7 @@ void qp_presentation (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_duration_qos (const dds_qos_t *q, FILE *fp, const char *what, bool (*qget) (const dds_qos_t * __restrict qos, dds_duration_t *d))
+static void qp_duration_qos (const dds_qos_t *q, FILE *fp, const char *what, bool (*qget) (const dds_qos_t * __restrict qos, dds_duration_t *d))
 {
   dds_duration_t d;
   char buf[MAX_DURATION_BUFSZ];
@@ -195,27 +195,27 @@ void qp_duration_qos (const dds_qos_t *q, FILE *fp, const char *what, bool (*qge
     fprintf (fp, "  %s = %s\n", what, qp_duration_str (buf, sizeof (buf), d));
 }
 
-void qp_lifespan (const dds_qos_t *q, FILE *fp)
+static void qp_lifespan (const dds_qos_t *q, FILE *fp)
 {
   qp_duration_qos (q, fp, "lifespan: duration", dds_qget_lifespan);
 }
 
-void qp_deadline (const dds_qos_t *q, FILE *fp)
+static void qp_deadline (const dds_qos_t *q, FILE *fp)
 {
   qp_duration_qos (q, fp, "deadline: period", dds_qget_deadline);
 }
 
-void qp_latency_budget (const dds_qos_t *q, FILE *fp)
+static void qp_latency_budget (const dds_qos_t *q, FILE *fp)
 {
   qp_duration_qos (q, fp, "latency_budget: duration", dds_qget_latency_budget);
 }
 
-void qp_time_based_filter (const dds_qos_t *q, FILE *fp)
+static void qp_time_based_filter (const dds_qos_t *q, FILE *fp)
 {
   qp_duration_qos (q, fp, "time_based_filter: minimum_separation", dds_qget_time_based_filter);
 }
 
-void qp_ownership (const dds_qos_t *q, FILE *fp)
+static void qp_ownership (const dds_qos_t *q, FILE *fp)
 {
   dds_ownership_kind_t kind;
   char *s = "?";
@@ -230,14 +230,14 @@ void qp_ownership (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_ownership_strength (const dds_qos_t *q, FILE *fp)
+static void qp_ownership_strength (const dds_qos_t *q, FILE *fp)
 {
   int32_t value;
   if (dds_qget_ownership_strength (q, &value))
     fprintf (fp, "  ownership_strength: value = %"PRId32"\n", value);
 }
 
-void qp_liveliness (const dds_qos_t *q, FILE *fp)
+static void qp_liveliness (const dds_qos_t *q, FILE *fp)
 {
   dds_liveliness_kind_t kind;
   dds_duration_t lease_duration;
@@ -255,7 +255,7 @@ void qp_liveliness (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_reliability (const dds_qos_t *q, FILE *fp)
+static void qp_reliability (const dds_qos_t *q, FILE *fp)
 {
   dds_reliability_kind_t kind;
   dds_duration_t max_blocking_time;
@@ -272,14 +272,14 @@ void qp_reliability (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_transport_priority (const dds_qos_t *q, FILE *fp)
+static void qp_transport_priority (const dds_qos_t *q, FILE *fp)
 {
   int32_t value;
   if (dds_qget_transport_priority (q, &value))
     fprintf (fp, "  transport_priority: priority = %"PRId32"\n", value);
 }
 
-void qp_destination_order (const dds_qos_t *q, FILE *fp)
+static void qp_destination_order (const dds_qos_t *q, FILE *fp)
 {
   dds_destination_order_kind_t kind;
   if (dds_qget_destination_order (q, &kind))
@@ -294,14 +294,14 @@ void qp_destination_order (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_writer_data_lifecycle (const dds_qos_t *q, FILE *fp)
+static void qp_writer_data_lifecycle (const dds_qos_t *q, FILE *fp)
 {
   bool value;
   if (dds_qget_writer_data_lifecycle (q, &value))
     fprintf (fp, "  writer_data_lifecycle: autodispose_unregistered_instances = %s\n", value ? "true" : "false");
 }
 
-void qp_reader_data_lifecycle (const dds_qos_t *q, FILE *fp)
+static void qp_reader_data_lifecycle (const dds_qos_t *q, FILE *fp)
 {
   dds_duration_t autopurge_nowriter_samples_delay, autopurge_disposed_samples_delay;
   if (dds_qget_reader_data_lifecycle (q, &autopurge_nowriter_samples_delay, &autopurge_disposed_samples_delay))
@@ -311,7 +311,7 @@ void qp_reader_data_lifecycle (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_durability_service (const dds_qos_t *q, FILE *fp)
+static void qp_durability_service (const dds_qos_t *q, FILE *fp)
 {
   dds_duration_t service_cleanup_delay;
   dds_history_kind_t history_kind;
@@ -335,7 +335,7 @@ void qp_durability_service (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_partition (const dds_qos_t *q, FILE *fp)
+static void qp_partition (const dds_qos_t *q, FILE *fp)
 {
   uint32_t n;
   char **ps;
@@ -360,7 +360,7 @@ void qp_partition (const dds_qos_t *q, FILE *fp)
   }
 }
 
-void qp_qos (const dds_qos_t *q, FILE *fp)
+static void qp_qos (const dds_qos_t *q, FILE *fp)
 {
   qp_reliability (q, fp);
   qp_durability (q, fp);
@@ -385,7 +385,7 @@ void qp_qos (const dds_qos_t *q, FILE *fp)
   qp_group_data (q, fp);
 }
 
-void print_key(FILE *fp, const char *label, const dds_builtintopic_guid_t *key)
+static void print_key(FILE *fp, const char *label, const dds_builtintopic_guid_t *key)
 {
   fprintf(fp, "%s", label);
   for(size_t j = 0; j < sizeof (key->v); j++) {
@@ -422,7 +422,7 @@ void print_dcps_topic (FILE *fp, dds_entity_t pp)
 }
 #endif
 
-void print_dcps_participant (FILE *fp, dds_entity_t pp)
+static void print_dcps_participant (FILE *fp, dds_entity_t pp)
 {
   dds_entity_t rd = dds_create_reader (pp, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL);
   (void)dds_reader_wait_for_historical_data (rd, DDS_SECS (5));
@@ -448,7 +448,7 @@ void print_dcps_participant (FILE *fp, dds_entity_t pp)
   dds_delete (rd);
 }
 
-void print_dcps_endpoint (FILE *fp, dds_entity_t pp, const char *type, dds_entity_t topic)
+static void print_dcps_endpoint (FILE *fp, dds_entity_t pp, const char *type, dds_entity_t topic)
 {
   dds_entity_t rd = dds_create_reader (pp, topic, NULL, NULL);
   (void)dds_reader_wait_for_historical_data (rd, DDS_SECS (5));
@@ -477,12 +477,12 @@ void print_dcps_endpoint (FILE *fp, dds_entity_t pp, const char *type, dds_entit
   dds_delete (rd);
 }
 
-void print_dcps_subscription (FILE *fp, dds_entity_t pp)
+static void print_dcps_subscription (FILE *fp, dds_entity_t pp)
 {
   print_dcps_endpoint (fp, pp, "SUBSCRIPTION", DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION);
 }
 
-void print_dcps_publication (FILE *fp, dds_entity_t pp)
+static void print_dcps_publication (FILE *fp, dds_entity_t pp)
 {
   print_dcps_endpoint (fp, pp, "PUBLICATION", DDS_BUILTIN_TOPIC_DCPSPUBLICATION);
 }
@@ -504,7 +504,7 @@ static struct topictab {
 };
 #define TOPICTAB_SIZE (sizeof(topictab)/sizeof(struct topictab))
 
-void usage (void)
+static void usage (void)
 {
   fprintf (stderr, "Usage: ddsls [OPTIONS] TOPIC...  for specified topics\n\n");
   fprintf (stderr, "   or: ddsls [OPTIONS] -a        for all topics\n");

src/tools/pubsub/common.c

@@ -943,7 +943,7 @@ void setqos_from_args(dds_entity_kind_t qt, dds_qos_t *q, int n, const char *arg
 
 #define DDS_ERR_MSG_MAX 128
 
-void dds_fail (const char * msg, const char * where)
+static void dds_fail (const char * msg, const char * where)
 {
   fprintf (stderr, "Aborting Failure: %s %s\n", where, msg);
   abort ();

src/tools/pubsub/common.h

@@ -106,9 +106,11 @@ void qos_ownership(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_transport_priority(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_reliability(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_resource_limits(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
+void qos_durability_service(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_user_data(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_latency_budget(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_lifespan(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
+void qos_presentation(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void qos_autodispose_unregistered_instances(dds_entity_kind_t qt, dds_qos_t *q, const char *arg);
 void set_qosprovider(const char *arg);
 void setqos_from_args(dds_entity_kind_t qt, dds_qos_t *q, int n, const char *args[]);