Adapt to skalibs-2.11.0.0, the real one

Signed-off-by: Laurent Bercot <ska@appnovation.com>

61 files changed, 240 insertions, 237 deletions

diff --git a/src/include/skabus/pub.h b/src/include/skabus/pub.h
index e8ee2e3..380e0ed 100644
--- a/src/include/skabus/pub.h
+++ b/src/include/skabus/pub.h
@@ -32,7 +32,7 @@ typedef struct skabus_pub_msginfo_s skabus_pub_msginfo_t, *skabus_pub_msginfo_t_
 struct skabus_pub_msginfo_s
 {
   uint64_t serial ;
-  tain_t timestamp ;
+  tain timestamp ;
   uint8_t flags ;
   char sender[SKABUS_PUB_IDSTR_SIZE + 1] ;
 } ;
@@ -57,10 +57,10 @@ struct skabus_pub_cltinfo_s
 typedef struct skabus_pub_s skabus_pub_t, *skabus_pub_t_ref ;
 struct skabus_pub_s
 {
-  skaclient_t connection ;
+  skaclient connection ;
   genalloc info ; /* array of skabus_pub_cltinfo_t */
   size_t head ;
-  skaclient_buffer_t buffers ;
+  skaclient_buffer buffers ;
 } ;
 #define SKABUS_PUB_ZERO { .connection = SKACLIENT_ZERO, .info = GENALLOC_ZERO, .head = 0 }
 
@@ -70,18 +70,18 @@ struct skabus_pub_s
 typedef struct skabus_pub_start_result_s skabus_pub_start_result_t, *skabus_pub_start_result_t_ref ;
 struct skabus_pub_start_result_s
 {
-  skaclient_cbdata_t skaclient_cbdata ;
+  skaclient_cbdata skaclient_cbdata ;
 } ;
 
 #define skabus_pub_init(a, path, id, sre, wre, deadline, stamp) (skabus_pub_start(a, path, deadline, stamp) && skabus_pub_register(a, id, sre, wre, deadline, stamp))
 #define skabus_pub_init_g(a, path, id, sre, wre, deadline) skabus_pub_init(a, path, id, sre, wre, (deadline), &STAMP)
 
 extern int skabus_pub_start_async (skabus_pub_t *, char const *, skabus_pub_start_result_t *) ;
-extern int skabus_pub_start (skabus_pub_t *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_pub_start (skabus_pub_t *, char const *, tain const *, tain *) ;
 #define skabus_pub_start_g(a, path, deadline) skabus_pub_start(a, path, (deadline), &STAMP)
 
 extern int skabus_pub_register_async (skabus_pub_t *, char const *, char const *, char const *, unsigned char *) ;
-extern int skabus_pub_register (skabus_pub_t *, char const *, char const *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_pub_register (skabus_pub_t *, char const *, char const *, char const *, tain const *, tain *) ;
 #define skabus_pub_register_g(a, id, sre, wre, deadline) skabus_pub_register(a, id, sre, wre, (deadline), &STAMP)
 
 extern void skabus_pub_end (skabus_pub_t *) ;
@@ -107,7 +107,7 @@ struct skabus_pub_send_result_s
 extern int skabus_pub_send_withfds_async (skabus_pub_t *, char const *, size_t, int const *, unsigned int, unsigned char const *, skabus_pub_send_result_t *) ;
 #define skabus_pub_send_async(a, s, len, res) skabus_pub_send_withfds_async(a, s, len, 0, 0, unixmessage_bits_closenone, res)
 
-extern uint64_t skabus_pub_send_withfds (skabus_pub_t *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_pub_send_withfds (skabus_pub_t *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_pub_send_withfds_g(a, s, len, fds, nfds, bits, deadline) skabus_pub_send_withfds(a, s, len, fds, nfds, bits, (deadline), &STAMP)
 #define skabus_pub_send(a, s, len, deadline, stamp) skabus_pub_send_withfds(a, s, len, 0, 0, unixmessage_bits_closenone, deadline, stamp)
 #define skabus_pub_send_g(a, s, len, deadline) skabus_pub_send(a, s, len, (deadline), &STAMP)
@@ -115,7 +115,7 @@ extern uint64_t skabus_pub_send_withfds (skabus_pub_t *, char const *, size_t, i
 extern int skabus_pub_sendv_withfds_async (skabus_pub_t *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, skabus_pub_send_result_t *) ;
 #define skabus_pub_sendv_async(a, v, vlen, res) skabus_pub_sendv_withfds_async(a, v, vlen, 0, 0, unixmessage_bits_closenone, res)
 
-extern uint64_t skabus_pub_sendv_withfds (skabus_pub_t *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_pub_sendv_withfds (skabus_pub_t *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_pub_sendv_withfds_g(a, v, vlen, fds, nfds, bits, deadline) skabus_pub_sendv_withfds(a, v, vlen, fds, nfds, bits, (deadline), &STAMP)
 #define skabus_pub_sendv(a, v, vlen, deadline, stamp) skabus_pub_sendv_withfds(a, v, vlen, 0, 0, unixmessage_bits_closenone, deadline, stamp)
 #define skabus_pub_sendv_g(a, v, vlen, deadline) skabus_pub_sendv(a, v, vlen, (deadline), &STAMP)
@@ -126,7 +126,7 @@ extern uint64_t skabus_pub_sendv_withfds (skabus_pub_t *, struct iovec const *,
 extern int skabus_pub_sendpm_withfds_async (skabus_pub_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, skabus_pub_send_result_t *) ;
 #define skabus_pub_sendpm_async(a, id, s, len, res) skabus_pub_sendpm_withfds_async(a, id, s, len, 0, 0, unixmessage_bits_closenone, res)
 
-extern uint64_t skabus_pub_sendpm_withfds (skabus_pub_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_pub_sendpm_withfds (skabus_pub_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_pub_sendpm_withfds_g(a, id, s, len, fds, nfds, bits, deadline) skabus_pub_sendpm_withfds(a, id, s, len, fds, nfds, bits, (deadline), &STAMP)
 #define skabus_pub_sendpm(a, id, s, len, deadline, stamp) skabus_pub_sendpm_withfds(a, id, s, len, 0, 0, unixmessage_bits_closenone, deadline, stamp)
 #define skabus_pub_sendpm_g(a, id, s, len, deadline) skabus_pub_sendpm(a, id, s, len, (deadline), &STAMP)
@@ -134,7 +134,7 @@ extern uint64_t skabus_pub_sendpm_withfds (skabus_pub_t *, char const *, char co
 extern int skabus_pub_sendvpm_withfds_async (skabus_pub_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, skabus_pub_send_result_t *) ;
 #define skabus_pub_sendvpm_async(a, id, v, vlen, res) skabus_pub_sendvpm_withfds_async(a, id, v, vlen, 0, 0, unixmessage_bits_closenone, res)
 
-extern uint64_t skabus_pub_sendvpm_withfds (skabus_pub_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_pub_sendvpm_withfds (skabus_pub_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_pub_sendvpm_withfds_g(a, id, v, vlen, fds, nfds, bits, deadline) skabus_pub_sendvpm_withfds(a, id, v, vlen, fds, nfds, bits, (deadline), &STAMP)
 #define skabus_pub_sendvpm(a, id, v, vlen, deadline, stamp) skabus_pub_sendvpm_withfds(a, id, v, vlen, 0, 0, unixmessage_bits_closenone, deadline, stamp)
 #define skabus_pub_sendvpm_g(a, id, v, vlen, deadline) skabus_pub_sendvpm(a, id, v, vlen, (deadline), &STAMP)
@@ -145,7 +145,7 @@ extern uint64_t skabus_pub_sendvpm_withfds (skabus_pub_t *, char const *, struct
 extern int skabus_pub_subunsub_async (skabus_pub_t *, char, char const *, unsigned char *) ;
 #define skabus_pub_subscribe_async(a, id, err) skabus_pub_subunsub_async(a, 'S', id, err)
 #define skabus_pub_unsubscribe_async(a, id, err) skabus_pub_subunsub_async(a, 'U', id, err)
-extern int skabus_pub_subunsub (skabus_pub_t *, char, char const *, tain_t const *, tain_t *) ;
+extern int skabus_pub_subunsub (skabus_pub_t *, char, char const *, tain const *, tain *) ;
 #define skabus_pub_subscribe(a, id, deadline, stamp) skabus_pub_subunsub(a, 'S', id, deadline, stamp)
 #define skabus_pub_subscribe_g(a, id, deadline) skabus_pub_subscribe(a, id, (deadline), &STAMP)
 #define skabus_pub_unsubscribe(a, id, deadline, stamp) skabus_pub_subunsub(a, 'U', id, deadline, stamp)
@@ -163,7 +163,7 @@ struct skabus_pub_list_result_s
 } ;
 
 extern int skabus_pub_list_async (skabus_pub_t *, stralloc *, skabus_pub_list_result_t *) ;
-extern int skabus_pub_list (skabus_pub_t *, stralloc *, diuint32 *, tain_t const *, tain_t *) ;
+extern int skabus_pub_list (skabus_pub_t *, stralloc *, diuint32 *, tain const *, tain *) ;
 #define skabus_pub_list_g(a, sa, deadline) skabus_pub_list(a, sa, (deadline), &STAMP)
 
 #endif
diff --git a/src/include/skabus/rpc.h b/src/include/skabus/rpc.h
index 894c763..46b8f39 100644
--- a/src/include/skabus/rpc.h
+++ b/src/include/skabus/rpc.h
@@ -36,8 +36,8 @@ typedef struct skabus_rpc_rinfo_s skabus_rpc_rinfo_t, *skabus_rpc_rinfo_t_ref ;
 struct skabus_rpc_rinfo_s
 {
   uint64_t serial ;
-  tain_t limit ;
-  tain_t timestamp ;
+  tain limit ;
+  tain timestamp ;
   uid_t uid ;
   gid_t gid ;
   char idstr[SKABUS_RPC_IDSTR_SIZE + 1] ;
@@ -52,32 +52,32 @@ extern void skabus_rpc_rinfo_unpack (char const *, skabus_rpc_rinfo_t *) ;
 
  /* Serving queries */
 
-typedef int skabus_rpc_r_func_t (skabus_rpc_t *, skabus_rpc_rinfo_t const *, unixmessage_t const *, void *) ;
-typedef skabus_rpc_r_func_t *skabus_rpc_r_func_t_ref ;
-typedef int skabus_rpc_rcancel_func_t (uint64_t, char, void *) ;
-typedef skabus_rpc_rcancel_func_t *skabus_rpc_rcancel_func_t_ref ;
+typedef int skabus_rpc_r_func (skabus_rpc_t *, skabus_rpc_rinfo_t const *, unixmessage const *, void *) ;
+typedef skabus_rpc_r_func *skabus_rpc_r_func_ref ;
+typedef int skabus_rpc_rcancel_func (uint64_t, char, void *) ;
+typedef skabus_rpc_rcancel_func *skabus_rpc_rcancel_func_ref ;
 
 typedef struct skabus_rpc_interface_s skabus_rpc_interface_t, *skabus_rpc_interface_t_ref ;
 struct skabus_rpc_interface_s
 {
-  skabus_rpc_r_func_t_ref f ;
-  skabus_rpc_rcancel_func_t_ref cancelf ;
+  skabus_rpc_r_func_ref f ;
+  skabus_rpc_rcancel_func_ref cancelf ;
   void *data ;
 } ;
 #define SKABUS_RPC_INTERFACE_ZERO { .f = &skabus_rpc_r_notimpl, .cancelf = &skabus_rpc_rcancel_ignore, .data = 0 }
 extern skabus_rpc_interface_t const skabus_rpc_interface_zero ;
 
-extern skabus_rpc_r_func_t skabus_rpc_r_notimpl ;
-extern skabus_rpc_rcancel_func_t skabus_rpc_rcancel_ignore ;
+extern skabus_rpc_r_func skabus_rpc_r_notimpl ;
+extern skabus_rpc_rcancel_func skabus_rpc_rcancel_ignore ;
 
 extern int skabus_rpc_reply_withfds_async (skabus_rpc_t *, uint64_t, char, char const *, size_t, int const *, unsigned int, unsigned char const *) ;
 #define skabus_rpc_reply_async(a, serial, result, s, len) skabus_rpc_reply_withfds(a, serial, result, s, len, 0, 0, unixmessage_bits_closenone)
 extern int skabus_rpc_replyv_withfds_async (skabus_rpc_t *, uint64_t, char, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *) ;
 #define skabus_rpc_replyv_async(a, serial, result, v, vlen) skabus_rpc_replyv_withfds(a, serial, result, v, vlen, 0, 0, unixmessage_bits_closenone)
 
-extern int skabus_rpc_reply_withfds (skabus_rpc_t *, uint64_t, char, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_reply_withfds (skabus_rpc_t *, uint64_t, char, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_rpc_reply(a, serial, result, s, len, deadline, stamp) skabus_rpc_reply_withfds(a, serial, result, s, len, 0, 0, unixmessage_bits_closenone, deadline, stamp)
-extern int skabus_rpc_replyv_withfds (skabus_rpc_t *, uint64_t, char, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_replyv_withfds (skabus_rpc_t *, uint64_t, char, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain *) ;
 #define skabus_rpc_replyv(a, serial, result, v, vlen, deadline, stamp) skabus_rpc_replyv_withfds(a, serial, result, v, vlen, 0, 0, unixmessage_bits_closenone, deadline, stamp)
 
 #define skabus_rpc_reply_withfds_g(a, serial, result, s, len, fds, nfds, bits, deadline) skabus_rpc_reply_withfds(a, serial, result, s, len, fds, nfds, bits, (deadline), &STAMP)
@@ -105,7 +105,7 @@ struct skabus_rpc_qinfo_s
   uint64_t serial ;
   char status ;
   char result ;
-  unixmessage_t message ;
+  unixmessage message ;
 } ;
 #define SKABUS_RPC_QINFO_ZERO { .serial = 0, .status = EINVAL, .result = ECONNABORTED, .message = UNIXMESSAGE_ZERO }
 extern skabus_rpc_qinfo_t const skabus_rpc_qinfo_zero ;
@@ -115,13 +115,13 @@ extern skabus_rpc_qinfo_t const skabus_rpc_qinfo_zero ;
 
 struct skabus_rpc_s
 {
-  skaclient_t connection ;
+  skaclient connection ;
   uint32_t pmid ; /* index of the object interface */
   gensetdyn r ; /* set of skabus_rpc_ifnode_t */
   genalloc qlist ; /* array of uint64_t */
   gensetdyn q ; /* set of skabus_rpc_qinfo_t */
   avltree qmap ; /* serial -> index in q */
-  skaclient_buffer_t buffers ;
+  skaclient_buffer buffers ;
 } ;
 #define SKABUS_RPC_ZERO \
 { \
@@ -141,18 +141,18 @@ typedef struct skabus_rpc_interface_result_s skabus_rpc_interface_result_t, *ska
 typedef struct skabus_rpc_start_result_s skabus_rpc_start_result_t, *skabus_rpc_start_result_t_ref ;
 struct skabus_rpc_start_result_s
 {
-  skaclient_cbdata_t skaclient_cbdata ;
+  skaclient_cbdata skaclient_cbdata ;
 } ;
 
 #define skabus_rpc_init(a, path, id, ifbody, re, deadline, stamp) (skabus_rpc_start(a, path, deadline, stamp) && skabus_rpc_idstr(a, id, ifbody, re, deadline, stamp))
 #define skabus_rpc_init_g(a, path, id, ifbody, re, deadline) skabus_rpc_init(a, path, id, ifbody, re, (deadline), &STAMP)
 
 extern int skabus_rpc_start_async (skabus_rpc_t *, char const *, skabus_rpc_start_result_t *) ;
-extern int skabus_rpc_start (skabus_rpc_t *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_start (skabus_rpc_t *, char const *, tain const *, tain *) ;
 #define skabus_rpc_start_g(a, path, deadline) skabus_rpc_start(a, path, (deadline), &STAMP)
 
 extern int skabus_rpc_idstr_async (skabus_rpc_t *, char const *, skabus_rpc_interface_t const *, char const *, skabus_rpc_interface_result_t *) ;
-extern int skabus_rpc_idstr (skabus_rpc_t *, char const *, skabus_rpc_interface_t const *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_idstr (skabus_rpc_t *, char const *, skabus_rpc_interface_t const *, char const *, tain const *, tain *) ;
 #define skabus_rpc_idstr_g(a, idstr, ifbody, re, deadline) skabus_rpc_idstr(a, idstr, ifbody, re, (deadline), &STAMP)
 
 extern void skabus_rpc_end (skabus_rpc_t *) ;
@@ -163,7 +163,7 @@ extern void skabus_rpc_end (skabus_rpc_t *) ;
 #define skabus_rpc_fd(a) skaclient_fd(&(a)->connection)
 extern int skabus_rpc_update (skabus_rpc_t *) ;
 extern size_t skabus_rpc_qlist (skabus_rpc_t *, uint64_t **) ;
-extern int skabus_rpc_get (skabus_rpc_t *, uint64_t, int *, unixmessage_t *) ;
+extern int skabus_rpc_get (skabus_rpc_t *, uint64_t, int *, unixmessage *) ;
 extern int skabus_rpc_release (skabus_rpc_t *, uint64_t) ;
 extern void skabus_rpc_qlist_ack(skabus_rpc_t *, size_t) ;
 
@@ -178,11 +178,11 @@ struct skabus_rpc_interface_result_s
 } ;
 
 extern int skabus_rpc_interface_register_async (skabus_rpc_t *, char const *, skabus_rpc_interface_t const *, char const *, skabus_rpc_interface_result_t *) ;
-extern int skabus_rpc_interface_register (skabus_rpc_t *, uint32_t *, char const *, skabus_rpc_interface_t const *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_interface_register (skabus_rpc_t *, uint32_t *, char const *, skabus_rpc_interface_t const *, char const *, tain const *, tain *) ;
 #define skabus_rpc_interface_register_g(a, ifid, ifname, ifbody, re, deadline) skabus_rpc_interface_register(a, ifid, ifname, ifbody, re, (deadline), &STAMP)
 
 extern int skabus_rpc_interface_unregister_async (skabus_rpc_t *, uint32_t, skabus_rpc_interface_result_t *) ;
-extern int skabus_rpc_interface_unregister (skabus_rpc_t *, uint32_t, tain_t const *, tain_t *) ;
+extern int skabus_rpc_interface_unregister (skabus_rpc_t *, uint32_t, tain const *, tain *) ;
 #define skabus_rpc_interface_unregister_g(a, ifid, deadline) skabus_rpc_interface_unregister(a, ifid, (deadline), &STAMP)
 
 
@@ -197,34 +197,34 @@ struct skabus_rpc_send_result_s
   unsigned char err ;
 } ;
 
-extern int skabus_rpc_send_withfds_async (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
+extern int skabus_rpc_send_withfds_async (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
 #define skabus_rpc_send_async(a, ifname, s, len, limit, r) skabus_rpc_send_withfds_async(a, ifname, s, len, 0, 0, unixmessage_bits_closenone, limit, r)
 
-extern uint64_t skabus_rpc_send_withfds (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_rpc_send_withfds (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
 #define skabus_rpc_send_withfds_g(a, ifname, s, len, fds, nfds, bits, limit, deadline) skabus_rpc_send_withfds(a, ifname, s, len, fds, nfds, bits, limit, (deadline), &STAMP)
 #define skabus_rpc_send(a, ifname, s, len, limit, deadline, stamp) skabus_rpc_send_withfds(a, ifname, s, len, 0, 0, unixmessage_bits_closenone, limit, deadline, stamp)
 #define skabus_rpc_send_g(a, ifname, s, len, limit, deadline) skabus_rpc_send(a, ifname, s, len, limit, (deadline), &STAMP)
 
-extern int skabus_rpc_sendv_withfds_async (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
+extern int skabus_rpc_sendv_withfds_async (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
 #define skabus_rpc_sendv_async(a, ifname, v, vlen, limit, r) skabus_rpc_sendv_withfds_async(a, ifname, v, vlen, 0, 0, unixmessage_bits_closenone, limit, r)
 
-extern uint64_t skabus_rpc_sendv_withfds (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_rpc_sendv_withfds (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
 #define skabus_rpc_sendv_withfds_g(a, ifname, v, vlen, fds, nfds, bits, limit, deadline) skabus_rpc_sendv_withfds(a, ifname, v, vlen, fds, nfds, bits, limit, (deadline), &STAMP)
 #define skabus_rpc_sendv(a, ifname, v, vlen, limit, deadline, stamp) skabus_rpc_sendv_withfds(a, ifname, v, vlen, 0, 0, unixmessage_bits_closenone, limit, deadline, stamp)
 #define skabus_rpc_sendv_g(a, ifname, v, vlen, limit, deadline) skabus_rpc_sendv(a, ifname, v, vlen, limit, (deadline), &STAMP)
 
-extern int skabus_rpc_sendpm_withfds_async (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
+extern int skabus_rpc_sendpm_withfds_async (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
 #define skabus_rpc_sendpm_async(a, cname, s, len, limit, r) skabus_rpc_sendpm_withfds_async(a, cname, s, len, 0, 0, unixmessage_bits_closenone, limit, r)
 
-extern uint64_t skabus_rpc_sendpm_withfds (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_rpc_sendpm_withfds (skabus_rpc_t *, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
 #define skabus_rpc_sendpm_withfds_g(a, cname, s, len, fds, nfds, bits, limit, deadline) skabus_rpc_sendpm_withfds(a, cname, s, len, fds, nfds, bits, limit, (deadline), &STAMP)
 #define skabus_rpc_sendpm(a, cname, s, len, limit, deadline, stamp) skabus_rpc_sendpm_withfds(a, cname, s, len, 0, 0, unixmessage_bits_closenone, limit, deadline, stamp)
 #define skabus_rpc_sendpm_g(a, cname, s, len, limit, deadline) skabus_rpc_sendpm(a, cname, s, len, limit, (deadline), &STAMP)
 
-extern int skabus_rpc_sendvpm_withfds_async (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
+extern int skabus_rpc_sendvpm_withfds_async (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
 #define skabus_rpc_sendvpm_async(a, cname, v, vlen, limit, r) skabus_rpc_sendvpm_withfds_async(a, cname, v, vlen, 0, 0, unixmessage_bits_closenone, limit, r)
 
-extern uint64_t skabus_rpc_sendvpm_withfds (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
+extern uint64_t skabus_rpc_sendvpm_withfds (skabus_rpc_t *, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
 #define skabus_rpc_sendvpm_withfds_g(a, cname, v, vlen, fds, nfds, bits, limit, deadline) skabus_rpc_sendvpm_withfds(a, cname, v, vlen, fds, nfds, bits, limit, (deadline), &STAMP)
 #define skabus_rpc_sendvpm(a, cname, v, vlen, limit, deadline, stamp) skabus_rpc_sendvpm_withfds(a, cname, v, vlen, 0, 0, unixmessage_bits_closenone, limit, deadline, stamp)
 #define skabus_rpc_sendvpm_g(a, cname, v, vlen, limit, deadline) skabus_rpc_sendvpm(a, cname, v, vlen, limit, (deadline), &STAMP)
@@ -233,7 +233,7 @@ extern uint64_t skabus_rpc_sendvpm_withfds (skabus_rpc_t *, char const *, struct
  /* Cancelling an in-flight query */
 
 extern int skabus_rpc_cancel_async (skabus_rpc_t *, uint64_t, unsigned char *) ;
-extern int skabus_rpc_cancel (skabus_rpc_t *, uint64_t, tain_t const *, tain_t *) ;
+extern int skabus_rpc_cancel (skabus_rpc_t *, uint64_t, tain const *, tain *) ;
 #define skabus_rpc_cancel_g(a, qid, deadline) skabus_rpc_cancel(a, qid, (deadine), &STAMP)
 
 #endif
diff --git a/src/libskabus/skabus-pub-internal.h b/src/libskabus/skabus-pub-internal.h
index efe8bb9..32fb4b5 100644
--- a/src/libskabus/skabus-pub-internal.h
+++ b/src/libskabus/skabus-pub-internal.h
@@ -7,6 +7,6 @@
 
 #define SKABUS_HEAD_MAX 64
 
-extern unixmessage_handler_func_t skabus_pub_send_cb ;
+extern unixmessage_handler_func skabus_pub_send_cb ;
 
 #endif
diff --git a/src/libskabus/skabus-rpc-internal.h b/src/libskabus/skabus-rpc-internal.h
index 04f29e4..8a590b8 100644
--- a/src/libskabus/skabus-rpc-internal.h
+++ b/src/libskabus/skabus-rpc-internal.h
@@ -9,12 +9,12 @@
 #include <skalibs/unixmessage.h>
 #include <skabus/rpc.h>
 
-extern int skabus_rpc_sendq_withfds_async (skabus_rpc_t *, char const *, size_t, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
-extern uint64_t skabus_rpc_sendq_withfds (skabus_rpc_t *, char const *, size_t, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
-extern int skabus_rpc_sendvq_withfds_async (skabus_rpc_t *, char const *, size_t, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, skabus_rpc_send_result_t *) ;
-extern uint64_t skabus_rpc_sendvq_withfds (skabus_rpc_t *, char const *, size_t, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain_t const *, tain_t const *, tain_t *) ;
+extern int skabus_rpc_sendq_withfds_async (skabus_rpc_t *, char const *, size_t, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
+extern uint64_t skabus_rpc_sendq_withfds (skabus_rpc_t *, char const *, size_t, char const *, char const *, size_t, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
+extern int skabus_rpc_sendvq_withfds_async (skabus_rpc_t *, char const *, size_t, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, skabus_rpc_send_result_t *) ;
+extern uint64_t skabus_rpc_sendvq_withfds (skabus_rpc_t *, char const *, size_t, char const *, struct iovec const *, unsigned int, int const *, unsigned int, unsigned char const *, tain const *, tain const *, tain *) ;
 
-extern unixmessage_handler_func_t skabus_rpc_send_cb ;
-extern unixmessage_handler_func_t skabus_rpc_interface_register_cb ;
+extern unixmessage_handler_func skabus_rpc_send_cb ;
+extern unixmessage_handler_func skabus_rpc_interface_register_cb ;
 
 #endif
diff --git a/src/libskabus/skabus_pub_list.c b/src/libskabus/skabus_pub_list.c
index 4b8ceeb..0f7a4e3 100644
--- a/src/libskabus/skabus_pub_list.c
+++ b/src/libskabus/skabus_pub_list.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-int skabus_pub_list (skabus_pub_t *a, stralloc *sa, diuint32 *n, tain_t const *deadline, tain_t *stamp)
+int skabus_pub_list (skabus_pub_t *a, stralloc *sa, diuint32 *n, tain const *deadline, tain *stamp)
 {
   skabus_pub_list_result_t r ;
   if (!skabus_pub_list_async(a, sa, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_list_async.c b/src/libskabus/skabus_pub_list_async.c
index 48797b5..a809f43 100644
--- a/src/libskabus/skabus_pub_list_async.c
+++ b/src/libskabus/skabus_pub_list_async.c
@@ -11,7 +11,7 @@
 
 #include <skabus/pub.h>
 
-static int skabus_pub_list_cb (unixmessage_t const *m, void *p)
+static int skabus_pub_list_cb (unixmessage const *m, void *p)
 {
   skabus_pub_list_result_t *r = p ;
   uint32_t n ;
diff --git a/src/libskabus/skabus_pub_register.c b/src/libskabus/skabus_pub_register.c
index 30a08a3..4503990 100644
--- a/src/libskabus/skabus_pub_register.c
+++ b/src/libskabus/skabus_pub_register.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-int skabus_pub_register (skabus_pub_t *a, char const *id, char const *sre, char const *wre, tain_t const *deadline, tain_t *stamp)
+int skabus_pub_register (skabus_pub_t *a, char const *id, char const *sre, char const *wre, tain const *deadline, tain *stamp)
 {
   unsigned char r ;
   if (!skabus_pub_register_async(a, id, sre, wre, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_send.c b/src/libskabus/skabus_pub_send.c
index f41ede3..ffbeac9 100644
--- a/src/libskabus/skabus_pub_send.c
+++ b/src/libskabus/skabus_pub_send.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-uint64_t skabus_pub_send_withfds (skabus_pub_t *a, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_pub_send_withfds (skabus_pub_t *a, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   skabus_pub_send_result_t r ;
   if (!skabus_pub_send_withfds_async(a, s, len, fds, nfds, bits, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_send_async.c b/src/libskabus/skabus_pub_send_async.c
index 1a2bb58..214f541 100644
--- a/src/libskabus/skabus_pub_send_async.c
+++ b/src/libskabus/skabus_pub_send_async.c
@@ -11,6 +11,6 @@
 int skabus_pub_send_withfds_async (skabus_pub_t *a, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, skabus_pub_send_result_t *result)
 {
   struct iovec v[2] = { { .iov_base = "!", .iov_len = 1 }, { .iov_base = (char *)s, .iov_len = len } } ;
-  unixmessage_v_t m = { .v = v, .vlen = 2, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = v, .vlen = 2, .fds = (int *)fds, .nfds = nfds } ;
   return skaclient_putmsgv_and_close(&a->connection, &m, bits, &skabus_pub_send_cb, result) ;
 }
diff --git a/src/libskabus/skabus_pub_send_cb.c b/src/libskabus/skabus_pub_send_cb.c
index e95ab6c..008a280 100644
--- a/src/libskabus/skabus_pub_send_cb.c
+++ b/src/libskabus/skabus_pub_send_cb.c
@@ -8,7 +8,7 @@
 
 #include <skabus/pub.h>
 
-int skabus_pub_send_cb (unixmessage_t const *m, void *p)
+int skabus_pub_send_cb (unixmessage const *m, void *p)
 {
   skabus_pub_send_result_t *r = p ;
   if (!m->len || m->nfds) return (errno = EPROTO, 0) ;
diff --git a/src/libskabus/skabus_pub_sendpm.c b/src/libskabus/skabus_pub_sendpm.c
index 073633a..d1a73ef 100644
--- a/src/libskabus/skabus_pub_sendpm.c
+++ b/src/libskabus/skabus_pub_sendpm.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-uint64_t skabus_pub_sendpm_withfds (skabus_pub_t *a, char const *id, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_pub_sendpm_withfds (skabus_pub_t *a, char const *id, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   skabus_pub_send_result_t r ;
   if (!skabus_pub_sendpm_withfds_async(a, id, s, len, fds, nfds, bits, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_sendpm_async.c b/src/libskabus/skabus_pub_sendpm_async.c
index d43b01f..dd7aeec 100644
--- a/src/libskabus/skabus_pub_sendpm_async.c
+++ b/src/libskabus/skabus_pub_sendpm_async.c
@@ -20,7 +20,7 @@ int skabus_pub_sendpm_withfds_async (skabus_pub_t *a, char const *idstr, char co
     { .iov_base = (char *)idstr, .iov_len = idlen+1 },
     { .iov_base = (char *)s, .iov_len = len }
   } ;
-  unixmessage_v_t m = { .v = v, .vlen = 3, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = v, .vlen = 3, .fds = (int *)fds, .nfds = nfds } ;
   if (idlen > SKABUS_PUB_IDSTR_SIZE) return (errno = ERANGE, 0) ;
   tmp[1] = (unsigned char)idlen ;
   return skaclient_putmsgv_and_close(&a->connection, &m, bits, &skabus_pub_send_cb, result) ;
diff --git a/src/libskabus/skabus_pub_sendv.c b/src/libskabus/skabus_pub_sendv.c
index ff1c743..bc4fa1f 100644
--- a/src/libskabus/skabus_pub_sendv.c
+++ b/src/libskabus/skabus_pub_sendv.c
@@ -7,7 +7,7 @@
 
 #include <skabus/pub.h>
 
-uint64_t skabus_pub_sendv_withfds (skabus_pub_t *a, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_pub_sendv_withfds (skabus_pub_t *a, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   skabus_pub_send_result_t r ;
   if (!skabus_pub_sendv_withfds_async(a, v, vlen, fds, nfds, bits, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_sendv_async.c b/src/libskabus/skabus_pub_sendv_async.c
index 54ce94e..8f4e6e0 100644
--- a/src/libskabus/skabus_pub_sendv_async.c
+++ b/src/libskabus/skabus_pub_sendv_async.c
@@ -11,7 +11,7 @@
 int skabus_pub_sendv_withfds_async (skabus_pub_t *a, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, skabus_pub_send_result_t *result)
 {
   struct iovec vv[vlen+1] ;
-  unixmessage_v_t m = { .v = vv, .vlen = vlen+1, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = vv, .vlen = vlen+1, .fds = (int *)fds, .nfds = nfds } ;
   vv[0].iov_base = "!" ; vv[0].iov_len = 1 ;
   for (unsigned int i = 0 ; i < vlen ; i++) vv[1+i] = v[i] ;
   return skaclient_putmsgv_and_close(&a->connection, &m, bits, &skabus_pub_send_cb, result) ;
diff --git a/src/libskabus/skabus_pub_sendvpm.c b/src/libskabus/skabus_pub_sendvpm.c
index a898bbc..58ce243 100644
--- a/src/libskabus/skabus_pub_sendvpm.c
+++ b/src/libskabus/skabus_pub_sendvpm.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-uint64_t skabus_pub_sendvpm_withfds (skabus_pub_t *a, char const *idstr, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_pub_sendvpm_withfds (skabus_pub_t *a, char const *idstr, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   skabus_pub_send_result_t r ;
   if (!skabus_pub_sendvpm_withfds_async(a, idstr, v, vlen, fds, nfds, bits, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_sendvpm_async.c b/src/libskabus/skabus_pub_sendvpm_async.c
index b1bab4d..82fd7e6 100644
--- a/src/libskabus/skabus_pub_sendvpm_async.c
+++ b/src/libskabus/skabus_pub_sendvpm_async.c
@@ -15,7 +15,7 @@ int skabus_pub_sendvpm_withfds_async (skabus_pub_t *a, char const *idstr, struct
   size_t idlen = strlen(idstr) ;
   char tmp[2] = "+" ;
   struct iovec vv[vlen + 2] ;
-  unixmessage_v_t m = { .v = vv, .vlen = vlen + 2, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = vv, .vlen = vlen + 2, .fds = (int *)fds, .nfds = nfds } ;
   if (idlen > SKABUS_PUB_IDSTR_SIZE) return (errno = ERANGE, 0) ;
   tmp[1] = (unsigned char)idlen ;
   vv[0].iov_base = tmp ; vv[0].iov_len = 2 ;
diff --git a/src/libskabus/skabus_pub_start.c b/src/libskabus/skabus_pub_start.c
index d72b0f7..3cb3177 100644
--- a/src/libskabus/skabus_pub_start.c
+++ b/src/libskabus/skabus_pub_start.c
@@ -4,7 +4,7 @@
 
 #include <skabus/pub.h>
 
-int skabus_pub_start (skabus_pub_t *a, char const *path, tain_t const *deadline, tain_t *stamp)
+int skabus_pub_start (skabus_pub_t *a, char const *path, tain const *deadline, tain *stamp)
 {
   return skaclient_start_b(
     &a->connection,
diff --git a/src/libskabus/skabus_pub_subunsub.c b/src/libskabus/skabus_pub_subunsub.c
index 29e61f1..e45b143 100644
--- a/src/libskabus/skabus_pub_subunsub.c
+++ b/src/libskabus/skabus_pub_subunsub.c
@@ -6,7 +6,7 @@
 
 #include <skabus/pub.h>
 
-int skabus_pub_subunsub (skabus_pub_t *a, char what, char const *id, tain_t const *deadline, tain_t *stamp)
+int skabus_pub_subunsub (skabus_pub_t *a, char what, char const *id, tain const *deadline, tain *stamp)
 {
   unsigned char r ;
   if (!skabus_pub_subunsub_async(a, what, id, &r)) return 0 ;
diff --git a/src/libskabus/skabus_pub_update.c b/src/libskabus/skabus_pub_update.c
index 46e699c..859c562 100644
--- a/src/libskabus/skabus_pub_update.c
+++ b/src/libskabus/skabus_pub_update.c
@@ -14,7 +14,7 @@
 
 #include <skabus/pub.h>
 
-static int handler (unixmessage_t const *m, void *x)
+static int handler (unixmessage const *m, void *x)
 {
   skabus_pub_t *a = (skabus_pub_t *)x ;
   size_t n = genalloc_len(skabus_pub_cltinfo_t, &a->info) ;
diff --git a/src/libskabus/skabus_rpc_cancel.c b/src/libskabus/skabus_rpc_cancel.c
index fe77d48..ad8bf6a 100644
--- a/src/libskabus/skabus_rpc_cancel.c
+++ b/src/libskabus/skabus_rpc_cancel.c
@@ -7,7 +7,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_cancel (skabus_rpc_t *a, uint64_t serial, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_cancel (skabus_rpc_t *a, uint64_t serial, tain const *deadline, tain *stamp)
 {
   unsigned char r ;
   if (!skabus_rpc_cancel_async(a, serial, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_get.c b/src/libskabus/skabus_rpc_get.c
index 0f427f5..958c379 100644
--- a/src/libskabus/skabus_rpc_get.c
+++ b/src/libskabus/skabus_rpc_get.c
@@ -9,7 +9,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_get (skabus_rpc_t *a, uint64_t serial, int *result, unixmessage_t *m)
+int skabus_rpc_get (skabus_rpc_t *a, uint64_t serial, int *result, unixmessage *m)
 {
   uint32_t id ;
   skabus_rpc_qinfo_t *p ;
diff --git a/src/libskabus/skabus_rpc_idstr.c b/src/libskabus/skabus_rpc_idstr.c
index 29497c4..8e48e85 100644
--- a/src/libskabus/skabus_rpc_idstr.c
+++ b/src/libskabus/skabus_rpc_idstr.c
@@ -7,7 +7,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_idstr (skabus_rpc_t *a, char const *idstr, skabus_rpc_interface_t const *ifbody, char const *re, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_idstr (skabus_rpc_t *a, char const *idstr, skabus_rpc_interface_t const *ifbody, char const *re, tain const *deadline, tain *stamp)
 {
   skabus_rpc_interface_result_t r ;
   if (!skabus_rpc_idstr_async(a, idstr, ifbody, re, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_interface_register.c b/src/libskabus/skabus_rpc_interface_register.c
index e4b18d9..d5d525f 100644
--- a/src/libskabus/skabus_rpc_interface_register.c
+++ b/src/libskabus/skabus_rpc_interface_register.c
@@ -7,7 +7,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_interface_register (skabus_rpc_t *a, uint32_t *ifid, char const *ifname, skabus_rpc_interface_t const *ifbody, char const *re, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_interface_register (skabus_rpc_t *a, uint32_t *ifid, char const *ifname, skabus_rpc_interface_t const *ifbody, char const *re, tain const *deadline, tain *stamp)
 {
   skabus_rpc_interface_result_t r ;
   if (!skabus_rpc_interface_register_async(a, ifname, ifbody, re, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_interface_register_cb.c b/src/libskabus/skabus_rpc_interface_register_cb.c
index b786794..9ede974 100644
--- a/src/libskabus/skabus_rpc_interface_register_cb.c
+++ b/src/libskabus/skabus_rpc_interface_register_cb.c
@@ -9,7 +9,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_interface_register_cb (unixmessage_t const *m, void *p)
+int skabus_rpc_interface_register_cb (unixmessage const *m, void *p)
 {
   skabus_rpc_interface_result_t *r = p ;
   if (m->len != 1 || m->nfds) return (errno = EPROTO, 0) ;
diff --git a/src/libskabus/skabus_rpc_interface_unregister.c b/src/libskabus/skabus_rpc_interface_unregister.c
index add587c..793b954 100644
--- a/src/libskabus/skabus_rpc_interface_unregister.c
+++ b/src/libskabus/skabus_rpc_interface_unregister.c
@@ -7,7 +7,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_interface_unregister (skabus_rpc_t *a, uint32_t ifid, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_interface_unregister (skabus_rpc_t *a, uint32_t ifid, tain const *deadline, tain *stamp)
 {
   skabus_rpc_interface_result_t r ;
   if (!skabus_rpc_interface_unregister_async(a, ifid, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_interface_unregister_async.c b/src/libskabus/skabus_rpc_interface_unregister_async.c
index daa4a11..819a868 100644
--- a/src/libskabus/skabus_rpc_interface_unregister_async.c
+++ b/src/libskabus/skabus_rpc_interface_unregister_async.c
@@ -11,7 +11,7 @@
 
 #include <skabus/rpc.h>
 
-static int skabus_rpc_interface_unregister_cb (unixmessage_t const *m, void *p)
+static int skabus_rpc_interface_unregister_cb (unixmessage const *m, void *p)
 {
   skabus_rpc_interface_result_t *r = p ;
   if (m->len != 1 || m->nfds) return (errno = EPROTO, 0) ;
diff --git a/src/libskabus/skabus_rpc_r_notimpl.c b/src/libskabus/skabus_rpc_r_notimpl.c
index a8bc026..c947d4b 100644
--- a/src/libskabus/skabus_rpc_r_notimpl.c
+++ b/src/libskabus/skabus_rpc_r_notimpl.c
@@ -4,7 +4,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_r_notimpl (skabus_rpc_t *a, skabus_rpc_rinfo_t const *info, unixmessage_t const *m, void *data)
+int skabus_rpc_r_notimpl (skabus_rpc_t *a, skabus_rpc_rinfo_t const *info, unixmessage const *m, void *data)
 {
   (void)m ;
   (void)data ;
diff --git a/src/libskabus/skabus_rpc_reply.c b/src/libskabus/skabus_rpc_reply.c
index 0b48734..237956d 100644
--- a/src/libskabus/skabus_rpc_reply.c
+++ b/src/libskabus/skabus_rpc_reply.c
@@ -4,7 +4,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_reply_withfds (skabus_rpc_t *a, uint64_t serial, char result, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_reply_withfds (skabus_rpc_t *a, uint64_t serial, char result, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_reply_withfds_async(a, serial, result, s, len, fds, nfds, bits)
    && skaclient_timed_aflush(&a->connection, deadline, stamp) ;
diff --git a/src/libskabus/skabus_rpc_reply_async.c b/src/libskabus/skabus_rpc_reply_async.c
index 6f3df39..498c1e0 100644
--- a/src/libskabus/skabus_rpc_reply_async.c
+++ b/src/libskabus/skabus_rpc_reply_async.c
@@ -12,7 +12,7 @@ int skabus_rpc_reply_withfds_async (skabus_rpc_t *a, uint64_t serial, char resul
 {
   char pack[10] = "R" ;
   struct iovec v[2] = { { .iov_base = pack, .iov_len = 10 }, { .iov_base = (char *)s, .iov_len = len } } ;
-  unixmessage_v_t m = { .v = v, .vlen = 2, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = v, .vlen = 2, .fds = (int *)fds, .nfds = nfds } ;
   uint64_pack_big(pack+1, serial) ;
   pack[9] = result ;
   return skaclient_aputv_and_close(&a->connection, &m, bits) ;
diff --git a/src/libskabus/skabus_rpc_replyv.c b/src/libskabus/skabus_rpc_replyv.c
index c972ce4..3c6f092 100644
--- a/src/libskabus/skabus_rpc_replyv.c
+++ b/src/libskabus/skabus_rpc_replyv.c
@@ -3,7 +3,7 @@
 #include <skalibs/skaclient.h>
 #include <skabus/rpc.h>
 
-int skabus_rpc_replyv_withfds (skabus_rpc_t *a, uint64_t serial, char result, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_replyv_withfds (skabus_rpc_t *a, uint64_t serial, char result, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_replyv_withfds_async(a, serial, result, v, vlen, fds, nfds, bits)
    && skaclient_timed_aflush(&a->connection, deadline, stamp) ;
diff --git a/src/libskabus/skabus_rpc_replyv_async.c b/src/libskabus/skabus_rpc_replyv_async.c
index 7bd4397..7c8880a 100644
--- a/src/libskabus/skabus_rpc_replyv_async.c
+++ b/src/libskabus/skabus_rpc_replyv_async.c
@@ -10,7 +10,7 @@ int skabus_rpc_replyv_withfds_async (skabus_rpc_t *a, uint64_t serial, char resu
 {
   char pack[10] = "R" ;
   struct iovec vv[vlen + 1] ;
-  unixmessage_v_t m = { .v = vv, .vlen = vlen+1, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = vv, .vlen = vlen+1, .fds = (int *)fds, .nfds = nfds } ;
   vv[0].iov_base = pack ; vv[0].iov_len = 10 ;
   for (unsigned int i = 0 ; i < vlen ; i++) vv[1+i] = v[i] ;
   uint64_pack_big(pack+1, serial) ;
diff --git a/src/libskabus/skabus_rpc_send.c b/src/libskabus/skabus_rpc_send.c
index aa0131c..08a10eb 100644
--- a/src/libskabus/skabus_rpc_send.c
+++ b/src/libskabus/skabus_rpc_send.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_send_withfds (skabus_rpc_t *a, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_send_withfds (skabus_rpc_t *a, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_sendq_withfds(a, 0, 0, ifname, s, len, fds, nfds, bits, limit, deadline, stamp) ;
 }
diff --git a/src/libskabus/skabus_rpc_send_async.c b/src/libskabus/skabus_rpc_send_async.c
index 7fc29d2..04cdf99 100644
--- a/src/libskabus/skabus_rpc_send_async.c
+++ b/src/libskabus/skabus_rpc_send_async.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_send_withfds_async (skabus_rpc_t *a, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_send_withfds_async (skabus_rpc_t *a, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   return skabus_rpc_sendq_withfds_async(a, 0, 0, ifname, s, len, fds, nfds, bits, limit, r) ;
 }
diff --git a/src/libskabus/skabus_rpc_send_cb.c b/src/libskabus/skabus_rpc_send_cb.c
index 52cb5c0..4156dfb 100644
--- a/src/libskabus/skabus_rpc_send_cb.c
+++ b/src/libskabus/skabus_rpc_send_cb.c
@@ -13,14 +13,14 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-static int autocancel_cb (unixmessage_t const *m, void *p)
+static int autocancel_cb (unixmessage const *m, void *p)
 {
   (void)m ;
   (void)p ;
   return 1 ;
 }
 
-int skabus_rpc_send_cb (unixmessage_t const *m, void *p)
+int skabus_rpc_send_cb (unixmessage const *m, void *p)
 {
   skabus_rpc_send_result_t *r = p ;
   skabus_rpc_qinfo_t *info = GENSETDYN_P(skabus_rpc_qinfo_t, &r->a->q, r->i) ;
diff --git a/src/libskabus/skabus_rpc_sendpm.c b/src/libskabus/skabus_rpc_sendpm.c
index 5f175e4..9488d39 100644
--- a/src/libskabus/skabus_rpc_sendpm.c
+++ b/src/libskabus/skabus_rpc_sendpm.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_sendpm_withfds (skabus_rpc_t *a, char const *cname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_sendpm_withfds (skabus_rpc_t *a, char const *cname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_sendq_withfds(a, "\xff", 1, cname, s, len, fds, nfds, bits, limit, deadline, stamp) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendpm_async.c b/src/libskabus/skabus_rpc_sendpm_async.c
index b1b09d4..f3fdd99 100644
--- a/src/libskabus/skabus_rpc_sendpm_async.c
+++ b/src/libskabus/skabus_rpc_sendpm_async.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_sendpm_withfds_async (skabus_rpc_t *a, char const *cname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_sendpm_withfds_async (skabus_rpc_t *a, char const *cname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   return skabus_rpc_sendq_withfds_async(a, "\xff", 1, cname, s, len, fds, nfds, bits, limit, r) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendq.c b/src/libskabus/skabus_rpc_sendq.c
index ac31551..b828d4f 100644
--- a/src/libskabus/skabus_rpc_sendq.c
+++ b/src/libskabus/skabus_rpc_sendq.c
@@ -7,7 +7,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_sendq_withfds (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_sendq_withfds (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   skabus_rpc_send_result_t r ;
   if (!skabus_rpc_sendq_withfds_async(a, prefix, plen, ifname, s, len, fds, nfds, bits, limit, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_sendq_async.c b/src/libskabus/skabus_rpc_sendq_async.c
index 7202500..534e962 100644
--- a/src/libskabus/skabus_rpc_sendq_async.c
+++ b/src/libskabus/skabus_rpc_sendq_async.c
@@ -12,12 +12,12 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_sendq_withfds_async (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_sendq_withfds_async (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, char const *s, size_t len, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   size_t iflen = strlen(ifname) ;
   char pack[2 + TAIN_PACK] = "Q" ;
   struct iovec v[4] = { { .iov_base = pack, .iov_len = 2 + TAIN_PACK }, { .iov_base = (char *)prefix, .iov_len = plen }, { .iov_base = (char *)ifname, .iov_len = iflen + 1 }, { .iov_base = (char *)s, .iov_len = len } } ;
-  unixmessage_v_t m = { .v = v, .vlen = 4, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = v, .vlen = 4, .fds = (int *)fds, .nfds = nfds } ;
   iflen += plen ;
   if (iflen > SKABUS_RPC_INTERFACE_MAXLEN) return (errno = ENAMETOOLONG, 0) ;
   if (!gensetdyn_new(&a->q, &r->i)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_sendv.c b/src/libskabus/skabus_rpc_sendv.c
index 24d598d..4f907a0 100644
--- a/src/libskabus/skabus_rpc_sendv.c
+++ b/src/libskabus/skabus_rpc_sendv.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_sendv_withfds (skabus_rpc_t *a, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_sendv_withfds (skabus_rpc_t *a, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_sendvq_withfds(a, 0, 0, ifname, v, vlen, fds, nfds, bits, limit, deadline, stamp) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendv_async.c b/src/libskabus/skabus_rpc_sendv_async.c
index c9b7910..791fd08 100644
--- a/src/libskabus/skabus_rpc_sendv_async.c
+++ b/src/libskabus/skabus_rpc_sendv_async.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_sendv_withfds_async (skabus_rpc_t *a, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_sendv_withfds_async (skabus_rpc_t *a, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   return skabus_rpc_sendvq_withfds_async(a, 0, 0, ifname, v, vlen, fds, nfds, bits, limit, r) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendvpm.c b/src/libskabus/skabus_rpc_sendvpm.c
index 8ca74e6..a145dae 100644
--- a/src/libskabus/skabus_rpc_sendvpm.c
+++ b/src/libskabus/skabus_rpc_sendvpm.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_sendvpm_withfds (skabus_rpc_t *a, char const *cname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_sendvpm_withfds (skabus_rpc_t *a, char const *cname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   return skabus_rpc_sendvq_withfds(a, "\xff", 1, cname, v, vlen, fds, nfds, bits, limit, deadline, stamp) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendvpm_async.c b/src/libskabus/skabus_rpc_sendvpm_async.c
index 090423c..6d4d237 100644
--- a/src/libskabus/skabus_rpc_sendvpm_async.c
+++ b/src/libskabus/skabus_rpc_sendvpm_async.c
@@ -3,7 +3,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_sendvpm_withfds_async (skabus_rpc_t *a, char const *cname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_sendvpm_withfds_async (skabus_rpc_t *a, char const *cname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   return skabus_rpc_sendvq_withfds_async(a, "\xff", 1, cname, v, vlen, fds, nfds, bits, limit, r) ;
 }
diff --git a/src/libskabus/skabus_rpc_sendvq.c b/src/libskabus/skabus_rpc_sendvq.c
index f5313ca..63b48bd 100644
--- a/src/libskabus/skabus_rpc_sendvq.c
+++ b/src/libskabus/skabus_rpc_sendvq.c
@@ -5,7 +5,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-uint64_t skabus_rpc_sendvq_withfds (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, tain_t const *deadline, tain_t *stamp)
+uint64_t skabus_rpc_sendvq_withfds (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, tain const *deadline, tain *stamp)
 {
   skabus_rpc_send_result_t r ;
   if (!skabus_rpc_sendvq_withfds_async(a, prefix, plen, ifname, v, vlen, fds, nfds, bits, limit, &r)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_sendvq_async.c b/src/libskabus/skabus_rpc_sendvq_async.c
index 4fb8da3..2e7b238 100644
--- a/src/libskabus/skabus_rpc_sendvq_async.c
+++ b/src/libskabus/skabus_rpc_sendvq_async.c
@@ -12,12 +12,12 @@
 #include <skabus/rpc.h>
 #include "skabus-rpc-internal.h"
 
-int skabus_rpc_sendvq_withfds_async (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain_t const *limit, skabus_rpc_send_result_t *r)
+int skabus_rpc_sendvq_withfds_async (skabus_rpc_t *a, char const *prefix, size_t plen, char const *ifname, struct iovec const *v, unsigned int vlen, int const *fds, unsigned int nfds, unsigned char const *bits, tain const *limit, skabus_rpc_send_result_t *r)
 {
   size_t iflen = strlen(ifname) ;
   char pack[2 + TAIN_PACK] = "Q" ;
   struct iovec vv[vlen + 3] ;
-  unixmessage_v_t m = { .v = vv, .vlen = vlen + 3, .fds = (int *)fds, .nfds = nfds } ;
+  unixmessagev m = { .v = vv, .vlen = vlen + 3, .fds = (int *)fds, .nfds = nfds } ;
   iflen += plen ;
   if (iflen > SKABUS_RPC_INTERFACE_MAXLEN) return (errno = ENAMETOOLONG, 0) ;
   if (!gensetdyn_new(&a->q, &r->i)) return 0 ;
diff --git a/src/libskabus/skabus_rpc_start.c b/src/libskabus/skabus_rpc_start.c
index 3e5e332..a39d4ae 100644
--- a/src/libskabus/skabus_rpc_start.c
+++ b/src/libskabus/skabus_rpc_start.c
@@ -4,7 +4,7 @@
 
 #include <skabus/rpc.h>
 
-int skabus_rpc_start (skabus_rpc_t *a, char const *path, tain_t const *deadline, tain_t *stamp)
+int skabus_rpc_start (skabus_rpc_t *a, char const *path, tain const *deadline, tain *stamp)
 {
   return skaclient_start_b(
     &a->connection,
diff --git a/src/libskabus/skabus_rpc_update.c b/src/libskabus/skabus_rpc_update.c
index 84de1b0..81e7cf5 100644
--- a/src/libskabus/skabus_rpc_update.c
+++ b/src/libskabus/skabus_rpc_update.c
@@ -17,10 +17,10 @@
 
 #include <skabus/rpc.h>
 
-typedef int localhandler_func_t (skabus_rpc_t *, unixmessage_t *) ;
-typedef localhandler_func_t *localhandler_func_t_ref ;
+typedef int localhandler_func (skabus_rpc_t *, unixmessage *) ;
+typedef localhandler_func *localhandler_func_ref ;
 
-static int skabus_rpc_serve (skabus_rpc_t *a, unixmessage_t *m)
+static int skabus_rpc_serve (skabus_rpc_t *a, unixmessage *m)
 {
   skabus_rpc_rinfo_t rinfo ;
   uint32_t ifid ;
@@ -34,7 +34,7 @@ static int skabus_rpc_serve (skabus_rpc_t *a, unixmessage_t *m)
   return (*p->f)(a, &rinfo, m, p->data) ;
 }
 
-static int skabus_rpc_cancelr (skabus_rpc_t *a, unixmessage_t *m)
+static int skabus_rpc_cancelr (skabus_rpc_t *a, unixmessage *m)
 {
   uint64_t serial ;
   uint32_t ifid ;
@@ -47,7 +47,7 @@ static int skabus_rpc_cancelr (skabus_rpc_t *a, unixmessage_t *m)
   return (*p->cancelf)(serial, m->s[12], p->data) ;
 }
 
-static int skabus_rpc_handle_reply (skabus_rpc_t *a, unixmessage_t *m)
+static int skabus_rpc_handle_reply (skabus_rpc_t *a, unixmessage *m)
 {
   skabus_rpc_qinfo_t *p ;
   uint64_t serial ;
@@ -84,18 +84,18 @@ static int skabus_rpc_handle_reply (skabus_rpc_t *a, unixmessage_t *m)
   return 1 ;
 }
 
-static int skabus_rpc_error (skabus_rpc_t *a, unixmessage_t *m)
+static int skabus_rpc_error (skabus_rpc_t *a, unixmessage *m)
 {
   (void)a ;
   (void)m ;
   return (errno = EPROTO, 0) ;
 }
 
-static int handler (unixmessage_t const *m, void *x)
+static int handler (unixmessage const *m, void *x)
 {
   skabus_rpc_t *a = x ;
-  unixmessage_t mm = { .s = m->s + 1, .len = m->len - 1, .fds = m->fds, .nfds = m->nfds } ;
-  static localhandler_func_t_ref const f[4] = 
+  unixmessage mm = { .s = m->s + 1, .len = m->len - 1, .fds = m->fds, .nfds = m->nfds } ;
+  static localhandler_func_ref const f[4] = 
   {
     &skabus_rpc_serve,
     &skabus_rpc_handle_reply,
diff --git a/src/misc/skabus-dyntee-client.c b/src/misc/skabus-dyntee-client.c
index 6679e91..61f3788 100644
--- a/src/misc/skabus-dyntee-client.c
+++ b/src/misc/skabus-dyntee-client.c
@@ -14,7 +14,7 @@ int main (int argc, char const *const *argv)
   int fd ;
   PROG = "skabus-dyntee-client" ;
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       int opt = subgetopt_r(argc, argv, "", &l) ;
diff --git a/src/misc/skabus-dyntee.c b/src/misc/skabus-dyntee.c
index 1fd389b..34a7e9a 100644
--- a/src/misc/skabus-dyntee.c
+++ b/src/misc/skabus-dyntee.c
@@ -34,7 +34,7 @@ int main (int argc, char const *const *argv)
   char const *rulesfile = 0 ;
   PROG = "skabus-dyntee" ;
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       register int opt = subgetopt_r(argc, argv, "Dd1Uc:b:u:g:G:t:T:i:x:", &l) ;
diff --git a/src/misc/skabus-dynteed.c b/src/misc/skabus-dynteed.c
index 90e0fe8..3c5bb0e 100644
--- a/src/misc/skabus-dynteed.c
+++ b/src/misc/skabus-dynteed.c
@@ -35,7 +35,7 @@
 #define SKABUS_DYNTEE_MAX 1000
 
 static int cont = 1 ;
-static tain_t lameduckdeadline ;
+static tain lameduckdeadline ;
 
 static unsigned int rulestype = 0 ;
 static char const *rules = 0 ;
@@ -45,7 +45,7 @@ typedef struct client_s client_t, *client_t_ref ;
 struct client_s
 {
   unsigned int xindex ;
-  tain_t deadline ;
+  tain deadline ;
   bufalloc ba ;
 } ;
 
@@ -102,7 +102,7 @@ static inline int new_connection (int fd)
 
 int main (int argc, char const *const *argv, char const *const *envp)
 {
-  tain_t readtto ;
+  tain readtto ;
   int spfd ;
   int flag1 = 0 ;
   unsigned int maxconn = 40 ;
@@ -110,7 +110,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
   PROG = "skabus-dynteed" ;
 
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     unsigned int t = 0, T = 0 ;
     for (;;)
     {
@@ -150,13 +150,13 @@ int main (int argc, char const *const *argv, char const *const *envp)
   if (ndelay_on(0) < 0) strerr_diefu1sys(111, "set stdin non-blocking") ;
   spfd = selfpipe_init() ;
   if (spfd < 0) strerr_diefu1sys(111, "selfpipe_init") ;
-  if (sig_ignore(SIGPIPE) < 0) strerr_diefu1sys(111, "ignore SIGPIPE") ;
+  if (!sig_ignore(SIGPIPE)) strerr_diefu1sys(111, "ignore SIGPIPE") ;
   {
     sigset_t set ;
     sigemptyset(&set) ;
     sigaddset(&set, SIGTERM) ;
     sigaddset(&set, SIGHUP) ;
-    if (selfpipe_trapset(&set) < 0) strerr_diefu1sys(111, "trap signals") ;
+    if (!selfpipe_trapset(&set)) strerr_diefu1sys(111, "trap signals") ;
   }
 
   if (rulestype == 2)
@@ -178,7 +178,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
 
     for (;;)
     {
-      tain_t deadline ;
+      tain deadline ;
       int r = 2 ;
       iopause_fd x[2 + cont + numconn] ;
       x[0].fd = spfd ;
diff --git a/src/pub/skabus-pub-daemon.c b/src/pub/skabus-pub-daemon.c
index b27c04e..c64ae7d 100644
--- a/src/pub/skabus-pub-daemon.c
+++ b/src/pub/skabus-pub-daemon.c
@@ -35,7 +35,7 @@ int main (int argc, char const *const *argv)
   char const *announcere = 0 ;
   PROG = "skabus-pub-daemon" ;
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       int opt = subgetopt_r(argc, argv, "Dd1USsv:c:b:u:g:G:t:T:i:x:k:", &l) ;
diff --git a/src/pub/skabus-pubd.c b/src/pub/skabus-pubd.c
index 5346717..8bbaae0 100644
--- a/src/pub/skabus-pubd.c
+++ b/src/pub/skabus-pubd.c
@@ -10,7 +10,6 @@
 #include <stdlib.h>
 #include <regex.h>
 
-#include <skalibs/posixishard.h>
 #include <skalibs/uint32.h>
 #include <skalibs/uint64.h>
 #include <skalibs/types.h>
@@ -35,6 +34,8 @@
 #include <skalibs/unixconnection.h>
 #include <skalibs/skaclient.h>
 
+#include <skalibs/posixishard.h>
+
 #include <s6/accessrules.h>
 
 #include <skabus/pub.h>
@@ -49,8 +50,8 @@
 static unsigned int verbosity = 1 ;
 static int cont = 1 ;
 static uint64_t serial = 1 ;
-static tain_t answertto = TAIN_INFINITE_RELATIVE ;
-static tain_t lameduckdeadline = TAIN_INFINITE_RELATIVE ;
+static tain answertto = TAIN_INFINITE_RELATIVE ;
+static tain lameduckdeadline = TAIN_INFINITE_RELATIVE ;
 static int flagidstrpub = 0 ;
 static unsigned int maxfds = 1000 ;
 static uint32_t *fdcount ;
@@ -120,13 +121,13 @@ struct client_s
   uint32_t next ;
   uint32_t xindexsync ;
   uint32_t xindexasync ;
-  tain_t deadline ;
+  tain deadline ;
   regex_t idstr_re ;
   regex_t subscribe_re ;
   regex_t write_re ;
   avltree subscribers ;
-  unixmessage_sender_t asyncout ;
-  unixconnection_t sync ;
+  unixmessage_sender asyncout ;
+  unixconnection sync ;
   char idstr[SKABUS_PUB_IDSTR_SIZE + 1] ;
 } ;
 
@@ -188,14 +189,14 @@ static void remove (uint32_t *i, uint32_t j)
 
 static void client_setdeadline (client_t *c)
 {
-  tain_t blah ;
+  tain blah ;
   tain_half(&blah, &tain_infinite_relative) ;
   tain_add_g(&blah, &blah) ;
   if (tain_less(&blah, &c->deadline))
     tain_add_g(&c->deadline, &answertto) ;
 }
 
-static inline int client_prepare_iopause (uint32_t i, tain_t *deadline, iopause_fd *x, uint32_t *j)
+static inline int client_prepare_iopause (uint32_t i, tain *deadline, iopause_fd *x, uint32_t *j)
 {
   client_t *c = CLIENT(i) ;
   if (tain_less(&c->deadline, deadline)) *deadline = c->deadline ;
@@ -230,7 +231,7 @@ static inline void client_add (int fd, regex_t const *idstr_re, unsigned int fla
   CLIENT(sentinel)->next = i ;
 }
 
-static int enqueue_message (uint32_t dd, unixmessage_t const *m)
+static int enqueue_message (uint32_t dd, unixmessage const *m)
 {
   client_t *d = CLIENT(dd) ;
   if (!unixmessage_put_and_close(&d->asyncout, m, unixmessage_bits_closeall)) return 0 ;
@@ -250,7 +251,7 @@ static int unsendmessage_iter (uint32_t dd, unsigned int h, void *data)
 static int sendmessage_iter (uint32_t dd, unsigned int h, void *data)
 {
   (void)h ;
-  return enqueue_message(dd, (unixmessage_t *)data) ;
+  return enqueue_message(dd, (unixmessage *)data) ;
 }
 
 static int store_text (char const *s, size_t len)
@@ -290,7 +291,7 @@ static int announce (char const *what, size_t whatlen, char const *idstr)
   size_t idlen = strlen(idstr) ;
   int fd ;
   char s[MSGINFO_PACK(idlen)] ;
-  unixmessage_t m = { .s = s, .len = MSGINFO_PACK(idlen), .fds = &fd, .nfds = 1 } ;
+  unixmessage m = { .s = s, .len = MSGINFO_PACK(idlen), .fds = &fd, .nfds = 1 } ;
   if (!*idstr) return 1 ;
   fill_msginfo(s, idstr, idlen, 0) ;
   fd = store_text(what, whatlen) ;
@@ -339,13 +340,13 @@ static inline int client_flush (uint32_t i, iopause_fd const *x)
 
 static int answer (client_t *c, char e)
 {
-  unixmessage_t m = { .s = &e, .len = 1, .fds = 0, .nfds = 0 } ;
+  unixmessage m = { .s = &e, .len = 1, .fds = 0, .nfds = 0 } ;
   if (!unixmessage_put(&c->sync.out, &m)) return 0 ;
   client_setdeadline(c) ;
   return 1 ;
 }
 
-static int do_register (uint32_t cc, unixmessage_t const *m)
+static int do_register (uint32_t cc, unixmessage const *m)
 {
   uint32_t srelen, wrelen, dummy ;
   client_t *c = CLIENT(cc) ;
@@ -384,7 +385,7 @@ static int do_register (uint32_t cc, unixmessage_t const *m)
   return answer(c, 0) ;
 }
 
-static int do_list (uint32_t cc, unixmessage_t const *m)
+static int do_list (uint32_t cc, unixmessage const *m)
 {
   client_t *c = CLIENT(cc) ;
   uint32_t dd = CLIENT(sentinel)->next ;
@@ -394,7 +395,7 @@ static int do_list (uint32_t cc, unixmessage_t const *m)
     char pack[9] = "" ;
     char lens[n] ;
     struct iovec v[1+(n<<1)] ;
-    unixmessage_v_t mreply = { .v = v, .vlen = 1+(n<<1), .fds = 0, .nfds = 0 } ;
+    unixmessagev mreply = { .v = v, .vlen = 1+(n<<1), .fds = 0, .nfds = 0 } ;
     unsigned int registered = 0 ;
     v[0].iov_base = pack ; v[0].iov_len = 9 ;
     for (unsigned int i = 0 ; i < n ; i++)
@@ -420,7 +421,7 @@ static int do_list (uint32_t cc, unixmessage_t const *m)
   return 1 ;
 }
 
-static int do_unsubscribe (uint32_t cc, unixmessage_t const *m)
+static int do_unsubscribe (uint32_t cc, unixmessage const *m)
 {
   uint32_t dd ;
   char const *s = m->s ;
@@ -435,7 +436,7 @@ static int do_unsubscribe (uint32_t cc, unixmessage_t const *m)
   return answer(c, 0) ;
 }
 
-static int do_subscribe (uint32_t cc, unixmessage_t const *m)
+static int do_subscribe (uint32_t cc, unixmessage const *m)
 {
   client_t *c = CLIENT(cc) ;
   char const *s = m->s ;
@@ -456,7 +457,7 @@ static int do_subscribe (uint32_t cc, unixmessage_t const *m)
   return answer(c, 0) ;
 }
 
-static int do_sendpm (uint32_t cc, unixmessage_t const *m)
+static int do_sendpm (uint32_t cc, unixmessage const *m)
 {
   client_t *c = CLIENT(cc) ;
   char const *s = m->s ;
@@ -499,7 +500,7 @@ static int do_sendpm (uint32_t cc, unixmessage_t const *m)
     size_t cidlen = strlen(c->idstr) ;
     char pack[1 + MSGINFO_PACK(cidlen)] ;
     int fds[1 + m->nfds] ;
-    unixmessage_t mtosend = { .s = pack + 1, .len = MSGINFO_PACK(cidlen), .fds = fds, .nfds = 1 + m->nfds } ;
+    unixmessage mtosend = { .s = pack + 1, .len = MSGINFO_PACK(cidlen), .fds = fds, .nfds = 1 + m->nfds } ;
     fds[0] = store_text(s, len) ;
     if (fds[0] < 0)
     {
@@ -523,7 +524,7 @@ static int do_sendpm (uint32_t cc, unixmessage_t const *m)
   }
 }
 
-static int do_send (uint32_t cc, unixmessage_t const *m)
+static int do_send (uint32_t cc, unixmessage const *m)
 {
   client_t *c = CLIENT(cc) ;
   size_t cidlen = strlen(c->idstr) ;
@@ -535,7 +536,7 @@ static int do_send (uint32_t cc, unixmessage_t const *m)
   {
     char pack[1 + MSGINFO_PACK(cidlen)] ;
     int fds[1 + m->nfds] ;
-    unixmessage_t mtosend = { .s = pack + 1, .len = MSGINFO_PACK(cidlen), .fds = fds, .nfds = 1 + m->nfds } ;
+    unixmessage mtosend = { .s = pack + 1, .len = MSGINFO_PACK(cidlen), .fds = fds, .nfds = 1 + m->nfds } ;
     fds[0] = store_text(m->s, m->len) ;
     if (fds[0] < 0)
     {
@@ -558,19 +559,19 @@ static int do_send (uint32_t cc, unixmessage_t const *m)
   }
 }
 
-static int do_error (uint32_t cc, unixmessage_t const *m)
+static int do_error (uint32_t cc, unixmessage const *m)
 {
   (void)cc ;
   (void)m ;
   return (errno = EPROTO, 0) ;
 }
 
-typedef int parsefunc_t (uint32_t, unixmessage_t const *) ;
-typedef parsefunc_t *parsefunc_t_ref ;
+typedef int parse_func (uint32_t, unixmessage const *) ;
+typedef parse_func *parse_func_ref ;
 
-static inline int parse_protocol (unixmessage_t const *m, void *p)
+static inline int parse_protocol (unixmessage const *m, void *p)
 {
-  static parsefunc_t_ref const f[7] =
+  static parse_func_ref const f[7] =
   {
     &do_send,
     &do_sendpm,
@@ -580,7 +581,7 @@ static inline int parse_protocol (unixmessage_t const *m, void *p)
     &do_register,
     &do_error
   } ;
-  unixmessage_t mcopy = { .s = m->s + 1, .len = m->len - 1, .fds = m->fds, .nfds = m->nfds } ;
+  unixmessage mcopy = { .s = m->s + 1, .len = m->len - 1, .fds = m->fds, .nfds = m->nfds } ;
   if (!m->len)
   {
     unixmessage_drop(m) ;
@@ -601,7 +602,7 @@ static inline int client_read (uint32_t cc, iopause_fd const *x)
   {
     if (unixmessage_sender_fd(&c->asyncout) < 0)
     {
-      unixmessage_t m ;
+      unixmessage m ;
       int r = unixmessage_receive(&c->sync.in, &m) ;
       if (r < 0) return -1 ;
       if (r)
@@ -750,7 +751,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
   PROG = "skabus-pubd" ;
 
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     unsigned int t = 0, T = 0 ;
     for (;;)
     {
@@ -805,13 +806,13 @@ int main (int argc, char const *const *argv, char const *const *envp)
   msgfsdir = argv[0] ;
   spfd = selfpipe_init() ;
   if (spfd < 0) strerr_diefu1sys(111, "selfpipe_init") ;
-  if (sig_ignore(SIGPIPE) < 0) strerr_diefu1sys(111, "ignore SIGPIPE") ;
+  if (!sig_ignore(SIGPIPE)) strerr_diefu1sys(111, "ignore SIGPIPE") ;
   {
     sigset_t set ;
     sigemptyset(&set) ;
     sigaddset(&set, SIGTERM) ;
     sigaddset(&set, SIGHUP) ;
-    if (selfpipe_trapset(&set) < 0) strerr_diefu1sys(111, "trap signals") ;
+    if (!selfpipe_trapset(&set)) strerr_diefu1sys(111, "trap signals") ;
   }
 
   if (rulestype == 2)
@@ -858,7 +859,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
 
     for (;;)
     {
-      tain_t deadline ;
+      tain deadline ;
       uint32_t i = clientstorage[sentinel].next, j = 2 ;
       int r = 1 ;
       if (cont) tain_add_g(&deadline, &tain_infinite_relative) ;
diff --git a/src/rpc/skabus-rpc-client.c b/src/rpc/skabus-rpc-client.c
index bd7566d..5ab1a4b 100644
--- a/src/rpc/skabus-rpc-client.c
+++ b/src/rpc/skabus-rpc-client.c
@@ -26,7 +26,7 @@ int main (int argc, char const *const *argv)
   unsigned int ifn = 1 ;
   char const *interfaces[SKABUS_RPCC_INTERFACES_MAX] = { 0 } ;
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       register int opt = subgetopt_r(argc, argv, "Dd1v:c:b:t:T:C:y:", &l) ;
diff --git a/src/rpc/skabus-rpc-daemon.c b/src/rpc/skabus-rpc-daemon.c
index 76a8e1e..67697f4 100644
--- a/src/rpc/skabus-rpc-daemon.c
+++ b/src/rpc/skabus-rpc-daemon.c
@@ -35,7 +35,7 @@ int main (int argc, char const *const *argv)
   char const *rulesfile = 0 ;
   PROG = "skabus-rpc-daemon" ;
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       int opt = subgetopt_r(argc, argv, "Dd1USsJjv:c:b:u:g:G:t:T:i:x:", &l) ;
diff --git a/src/rpc/skabus-rpcc.c b/src/rpc/skabus-rpcc.c
index 58d0cab..6c43a97 100644
--- a/src/rpc/skabus-rpcc.c
+++ b/src/rpc/skabus-rpcc.c
@@ -10,7 +10,6 @@
 #include <errno.h>
 #include <signal.h>
 
-#include <skalibs/posixishard.h>
 #include <skalibs/posixplz.h>
 #include <skalibs/uint32.h>
 #include <skalibs/uint64.h>
@@ -39,14 +38,16 @@
 #include <skabus/rpc.h>
 #include "skabus-rpcc.h"
 
+#include <skalibs/posixishard.h>
+
 #define USAGE "skabus-rpcc [ -v verbosity ] [ -1 ] [ -c maxconn ] [ -t timeout ] [ -T lameducktimeout ] [ -C pmprog:sep:flags ] [ -y ifname:ifprog:sep:flags ... ] rpcdpath clientname"
 #define dieusage() strerr_dieusage(100, USAGE) ;
 
-static tain_t answertto = TAIN_INFINITE_RELATIVE ;
+static tain answertto = TAIN_INFINITE_RELATIVE ;
 
 static unsigned int verbosity = 1 ;
 static int cont = 1 ;
-static tain_t lameduckdeadline = TAIN_INFINITE_RELATIVE ;
+static tain lameduckdeadline = TAIN_INFINITE_RELATIVE ;
 static skabus_rpc_t a = SKABUS_RPC_ZERO ;
 
 static void quit (void)
@@ -72,8 +73,8 @@ struct interface_s
   buffer in ;
   stralloc insa ;
   bufalloc out ;
-  tain_t tto ;
-  tain_t deadline ;
+  tain tto ;
+  tain deadline ;
   genqdyn serialq ;
   char sep[2] ;
   char buf[SKABUS_RPCC_BUFSIZE] ;
@@ -103,9 +104,9 @@ static inline void interface_delete (uint32_t i, uint32_t prev)
   gensetdyn_delete(&interfaces, i) ; 
 }
 
-static int rclient_function (skabus_rpc_t *a, skabus_rpc_rinfo_t const *info, unixmessage_t const *m, void *aux)
+static int rclient_function (skabus_rpc_t *a, skabus_rpc_rinfo_t const *info, unixmessage const *m, void *aux)
 {
-  tain_t deadline ;
+  tain deadline ;
   interface_t *y = aux ;
   if (m->nfds) { unixmessage_drop(m) ; return (errno = EPROTO, 0) ; }
   if (cont)
@@ -143,7 +144,7 @@ static int interface_add (char const *ifname, char const *ifprog, char const *re
   uint32_t yy ;
   interface_t *y ;
   int fd[2] ;
-  tain_t deadline ;
+  tain deadline ;
   skabus_rpc_interface_t ifbody = { .f = &rclient_function, .cancelf = &rclient_cancel_function, .aux = y }
   char const *argv[4] = { EXECLINE_EXTBINPREFIX "execlineb", "-Pc", ifprog, 0 } ; 
   pid_t pid = child_spawn2(argv[0], argv, (char const *const *)environ, fd) ;
@@ -196,7 +197,7 @@ static inline int interface_lookup_by_name (char const *ifname, uint32_t *n, uin
 
 static int interface_remove (char const *ifname)
 {
-  tain_t deadline ;
+  tain deadline ;
   uint32_t i, prev, id ;
   if (!interface_lookup_by_name(ifname, &i, &prev)) return 0 ;
   id = INTERFACE(i)->id ;
@@ -206,7 +207,7 @@ static int interface_remove (char const *ifname)
   return skabus_rpc_interface_unregister_g(a, INTERFACE(i)->id, &deadline) ;
 }
 
-static inline int interface_prepare_iopause (uint32_t i, tain_t *deadline, iopause_fd *x, uint32_t *j)
+static inline int interface_prepare_iopause (uint32_t i, tain *deadline, iopause_fd *x, uint32_t *j)
 {
   interface_t *y = INTERFACE(i) ;
   if (tain_less(&y->deadline, deadline)) *deadline = y->deadline ;
@@ -235,7 +236,7 @@ static inline int interface_event (iopause_fd const *x, uint32_t i)
     if (!genqdyn_n(&y->serialq)) return 0 ;
     while (genqdyn_n(&y->serialq))
     {
-      tain_t deadline ;
+      tain deadline ;
       int r = sanitize_read(skagetln(&y->in, &y->insa, y->sep[1])) ;
       if (r < 0) return 0 ;
       if (!r) break ;
@@ -253,10 +254,10 @@ static inline int interface_event (iopause_fd const *x, uint32_t i)
 
 
 
-static int query (char const *ifname, char const *q, tain_t const *limit, uint64_t *qid)
+static int query (char const *ifname, char const *q, tain const *limit, uint64_t *qid)
 {
   uint64_t id ;
-  tain_t deadline ;
+  tain deadline ;
   tain_uint(&deadline, 2) ;
   tain_add_g(&deadline, &deadline) ;
   id = skabus_rpc_send_g(a, ifname, q, strlen(q), limit, &deadline) ;
@@ -273,9 +274,9 @@ struct client_s
 {
   uint32_t next ;
   uint32_t xindex ;
-  textmessage_sender_t out ;
-  textmessage_receiver_t in ;
-  tain_t deadline ;
+  textmessage_sender out ;
+  textmessage_receiver in ;
+  tain deadline ;
   uint64_t query ;
 } ;
 
@@ -301,14 +302,14 @@ static inline void client_delete (uint32_t cc, uint32_t prev)
 
 static void client_setdeadline (client_t *c)
 {
-  tain_t blah ;
+  tain blah ;
   tain_half(&blah, &tain_infinite_relative) ;
   tain_add_g(&blah, &blah) ;
   if (tain_less(&blah, &c->deadline))
     tain_add_g(&c->deadline, &answertto) ;
 }
 
-static inline int client_prepare_iopause (uint32_t i, tain_t *deadline, iopause_fd *x, uint32_t *j)
+static inline int client_prepare_iopause (uint32_t i, tain *deadline, iopause_fd *x, uint32_t *j)
 {
   client_t *c = CLIENT(i) ;
   if (tain_less(&c->deadline, deadline)) *deadline = c->deadline ;
@@ -397,7 +398,7 @@ static int do_interface_unregister (uint32_t cc, char const *s, size_t len)
 static int do_query (uint32_t cc, char const *s, size_t len)
 {
   client_t *c = CLIENT(cc) ;
-  tain_t limit ;
+  tain limit ;
   uint32_t querylen, timeout ;
   unsigned char ifnamelen ;
   if (len < 12) return (errno = EPROTO, 0) ;
@@ -428,12 +429,12 @@ static int do_error (uint32_t cc, char const *s, size_t len)
   return (errno = EPROTO, 0) ;
 }
 
-typedef int parsefunc_t (uint32_t, char const *, size_t) ;
-typedef parsefunc_t *parsefunc_t_ref ;
+typedef int parse_func (uint32_t, char const *, size_t) ;
+typedef parse_func *parse_func_ref ;
 
 static int parse_client_protocol (struct iovec const *v, void *p)
 {
-  static parsefunc_t_ref const f[5] =
+  static parse_func_ref const f[5] =
   {
     &do_interface_register,
     &do_interface_unregister,
@@ -459,7 +460,7 @@ static void removeclient (uint32_t *i, uint32_t j)
 
 int main (int argc, char const *const *argv, char const *const *envp)
 {
-  tain_t deadline ;
+  tain deadline ;
   int spfd ;
   int flag1 = 0 ;
   uint32_t maxconn = 8 ;
@@ -467,7 +468,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
   PROG = "skabus-rpcc" ;
 
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     unsigned int t = 0, T = 0 ;
     for (;;)
     {
@@ -511,13 +512,13 @@ int main (int argc, char const *const *argv, char const *const *envp)
   else close(1) ;
   spfd = selfpipe_init() ;
   if (spfd < 0) strerr_diefu1sys(111, "selfpipe_init") ;
-  if (sig_ignore(SIGPIPE) < 0) strerr_diefu1sys(111, "ignore SIGPIPE") ;
+  if (!sig_ignore(SIGPIPE)) strerr_diefu1sys(111, "ignore SIGPIPE") ;
   {
     sigset_t set ;
     sigemptyset(&set) ;
     sigaddset(&set, SIGTERM) ;
     sigaddset(&set, SIGHUP) ;
-    if (selfpipe_trapset(&set) < 0) strerr_diefu1sys(111, "trap signals") ;
+    if (!selfpipe_trapset(&set)) strerr_diefu1sys(111, "trap signals") ;
   }
 
   tain_now_set_stopwatch_g() ;
diff --git a/src/rpc/skabus-rpccctl.c b/src/rpc/skabus-rpccctl.c
index e6d8b6a..7c21e69 100644
--- a/src/rpc/skabus-rpccctl.c
+++ b/src/rpc/skabus-rpccctl.c
@@ -13,7 +13,7 @@
 #define USAGE "skabus-rpccctl [ -t timeout ] help|interface|interface-remove|query args..."
 #define dieusage() strerr_dieusage(100, USAGE)
 
-static tain_t deadline ;
+static tain deadline ;
 static skabus_rpcc_t a = SKABUS_RPCC_ZERO ;
 
 static void add_interface (char const *rpccpath, char const *ifname, char const *ifprog, char const *re)
@@ -98,7 +98,7 @@ int main (int argc, char const *const *argv)
   PROG = "skabus-rpccctl" ;
   {
     unsigned int t = 0 ;
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     for (;;)
     {
       int opt = subgetopt_r(argc, argv, "t:T:", &l) ;
diff --git a/src/rpc/skabus-rpccctl.h b/src/rpc/skabus-rpccctl.h
index fe5b620..6be6a7f 100644
--- a/src/rpc/skabus-rpccctl.h
+++ b/src/rpc/skabus-rpccctl.h
@@ -11,26 +11,26 @@
 typedef struct skabus_rpcc_s skabus_rpcc_t, *skabus_rpcc_t_ref ;
 struct skabus_rpcc_s
 {
-  textmessage_sender_t out ;
-  textmessage_receiver_t in ;
+  textmessage_sender out ;
+  textmessage_receiver in ;
 } ;
 #define SKABUS_RPCC_ZERO { .in = TEXTMESSAGE_RECEIVER_ZERO, .out = TEXTMESSAGE_SENDER_ZERO }
 
-extern int skabus_rpcc_start (skabus_rpcc_t *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpcc_start (skabus_rpcc_t *, char const *, tain const *, tain *) ;
 #define skabus_rpcc_start_g(a, name, deadline) skabus_rpcc_start(a, name, (deadline), &STAMP)
 
 extern void skabus_rpcc_end (skabus_rpcc_t *) ;
 
-extern int skabus_rpcc_interface_register (skabus_rpcc_t *, char const *, char const *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpcc_interface_register (skabus_rpcc_t *, char const *, char const *, char const *, tain const *, tain *) ;
 #define skabus_rpcc_interface_register_g(a, ifname, ifprog, re, deadline) skabus_rpcc_interface_register(a, ifname, ifprog, re, (deadline), &STAMP)
 
-extern int skabus_rpcc_interface_unregister (skabus_rpcc_t *, char const *, tain_t const *, tain_t *) ;
+extern int skabus_rpcc_interface_unregister (skabus_rpcc_t *, char const *, tain const *, tain *) ;
 #define skabus_rpcc_interface_unregister_g(a, ifname, deadline) skabus_rpcc_interface_unregister(a, ifname, (deadline), &STAMP)
 
-extern int skabus_rpcc_query (skabus_rpcc_t *, stralloc *, char const *, char const *, uint32_t, tain_t const *, tain_t *) ;
+extern int skabus_rpcc_query (skabus_rpcc_t *, stralloc *, char const *, char const *, uint32_t, tain const *, tain *) ;
 #define skabus_rpcc_query_g(a, reply, ifname, query, timeout, deadline) skabus_rpcc_query(a, reply, ifname, query, timeout, (deadline), &STAMP)
 
-extern int skabus_rpcc_quit (skabus_rpcc_t *, tain_t const *, tain_t *) ;
+extern int skabus_rpcc_quit (skabus_rpcc_t *, tain const *, tain *) ;
 #define skabus_rpcc_quit_g(a, deadline) skabus_rpcc_quit(a, (deadline), &STAMP)
 
 #endif
diff --git a/src/rpc/skabus-rpcd.c b/src/rpc/skabus-rpcd.c
index 9535887..aaa0566 100644
--- a/src/rpc/skabus-rpcd.c
+++ b/src/rpc/skabus-rpcd.c
@@ -11,7 +11,6 @@
 #include <signal.h>
 
 #include <skalibs/posixplz.h>
-#include <skalibs/posixishard.h>
 #include <skalibs/uint32.h>
 #include <skalibs/uint64.h>
 #include <skalibs/types.h>
@@ -37,14 +36,16 @@
 #include <skabus/rpc.h>
 #include "skabus-rpcd.h"
 
+#include <skalibs/posixishard.h>
+
 #define USAGE "skabus-rpcd [ -v verbosity ] [ -1 ] [ -c maxconn ] [ -t timeout ] [ -T lameducktimeout ] [ -i rulesdir | -x rulesfile ] [ -S | -s ] [ -J | -j ]"
 #define dieusage() strerr_dieusage(100, USAGE) ;
 
-tain_t answertto = TAIN_INFINITE_RELATIVE ;
+tain answertto = TAIN_INFINITE_RELATIVE ;
 
 static unsigned int verbosity = 1 ;
 static int cont = 1 ;
-static tain_t lameduckdeadline = TAIN_INFINITE_RELATIVE ;
+static tain lameduckdeadline = TAIN_INFINITE_RELATIVE ;
 
 static unsigned int rulestype = 0 ;
 static char const *rules = 0 ;
@@ -78,11 +79,11 @@ static inline void handle_signals (void)
   }
 }
 
-int parse_protocol_async (unixmessage_t const *m, void *p)
+int parse_protocol_async (unixmessage const *m, void *p)
 {
   uint64_t serial ;
   uint32_t qq ;
-  unixmessage_t mtosend = { .s = m->s + 10, .len = m->len - 10, .fds = m->fds, .nfds = m->nfds } ;
+  unixmessage mtosend = { .s = m->s + 10, .len = m->len - 10, .fds = m->fds, .nfds = m->nfds } ;
   if (m->len < 10 || m->s[0] != 'R')
   {
     unixmessage_drop(m) ;
@@ -103,19 +104,19 @@ int parse_protocol_async (unixmessage_t const *m, void *p)
   return 1 ;
 }
 
-typedef int hlparsefunc_t (uint32_t, unixmessage_t *) ;
-typedef hlparsefunc_t *hlparsefunc_t_ref ;
+typedef int hlparse_func (uint32_t, unixmessage *) ;
+typedef hlparse_func *hlparse_func_ref ;
 
 static int answer (uint32_t cc, char e)
 {
-  unixmessage_t m = { .s = &e, .len = 1, .fds = 0, .nfds = 0 } ;
+  unixmessage m = { .s = &e, .len = 1, .fds = 0, .nfds = 0 } ;
   client_t *c = CLIENT(cc) ;
   if (!unixmessage_put(&c->sync.out, &m)) return 0 ;
   if (client_isregistered(cc)) client_setdeadline(c) ;
   return 1 ;
 }
 
-static int do_idstr (uint32_t cc, unixmessage_t *m)
+static int do_idstr (uint32_t cc, unixmessage *m)
 {
   uint32_t relen, pmid, yy ;
   unsigned char idlen ;
@@ -134,7 +135,7 @@ static int do_idstr (uint32_t cc, unixmessage_t *m)
   return answer(cc, 0) ;
 }
 
-static int do_interface_register (uint32_t cc, unixmessage_t *m)
+static int do_interface_register (uint32_t cc, unixmessage *m)
 {
   uint32_t id, relen, yy ;
   unsigned char iflen ;
@@ -151,7 +152,7 @@ static int do_interface_register (uint32_t cc, unixmessage_t *m)
   return answer(cc, 0) ;
 }
 
-static int do_interface_unregister (uint32_t cc, unixmessage_t *m)
+static int do_interface_unregister (uint32_t cc, unixmessage *m)
 {
   uint32_t yy ;
   unsigned char iflen ;
@@ -166,9 +167,9 @@ static int do_interface_unregister (uint32_t cc, unixmessage_t *m)
   return answer(cc, 0) ;
 }
 
-static int do_query_send (uint32_t cc, unixmessage_t *m)
+static int do_query_send (uint32_t cc, unixmessage *m)
 {
-  tain_t limit ;
+  tain limit ;
   uint32_t yy, qq ;
   unsigned char iflen ;
   int e ;
@@ -190,7 +191,7 @@ static int do_query_send (uint32_t cc, unixmessage_t *m)
   return 1 ;
 }
 
-static int do_query_cancel (uint32_t cc, unixmessage_t *m)
+static int do_query_cancel (uint32_t cc, unixmessage *m)
 {
   uint64_t serial ;
   uint32_t qq ;
@@ -203,16 +204,16 @@ static int do_query_cancel (uint32_t cc, unixmessage_t *m)
   return answer(cc, 0) ;
 }
 
-static int do_error (uint32_t cc, unixmessage_t *m)
+static int do_error (uint32_t cc, unixmessage *m)
 {
   (void)cc ;
   (void)m ;
   return (errno = EPROTO, 0) ;
 }
 
-int parse_protocol_sync (unixmessage_t const *m, void *p)
+int parse_protocol_sync (unixmessage const *m, void *p)
 {
-  static hlparsefunc_t_ref const f[6] =
+  static hlparse_func_ref const f[6] =
   {
     &do_idstr,
     &do_interface_register,
@@ -221,7 +222,7 @@ int parse_protocol_sync (unixmessage_t const *m, void *p)
     &do_query_cancel,
     &do_error
   } ;
-  unixmessage_t mcopy = { .s = m->s + 1, .len = m->len -1, .fds = m->fds, .nfds = m->nfds } ;
+  unixmessage mcopy = { .s = m->s + 1, .len = m->len -1, .fds = m->fds, .nfds = m->nfds } ;
   if (!m->len)
   {
     unixmessage_drop(m) ;
@@ -383,7 +384,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
   PROG = "skabus-rpcd" ;
 
   {
-    subgetopt_t l = SUBGETOPT_ZERO ;
+    subgetopt l = SUBGETOPT_ZERO ;
     unsigned int t = 0, T = 0 ;
     for (;;)
     {
@@ -424,13 +425,13 @@ int main (int argc, char const *const *argv, char const *const *envp)
   else close(1) ;
   spfd = selfpipe_init() ;
   if (spfd < 0) strerr_diefu1sys(111, "selfpipe_init") ;
-  if (sig_ignore(SIGPIPE) < 0) strerr_diefu1sys(111, "ignore SIGPIPE") ;
+  if (!sig_ignore(SIGPIPE)) strerr_diefu1sys(111, "ignore SIGPIPE") ;
   {
     sigset_t set ;
     sigemptyset(&set) ;
     sigaddset(&set, SIGTERM) ;
     sigaddset(&set, SIGHUP) ;
-    if (selfpipe_trapset(&set) < 0) strerr_diefu1sys(111, "trap signals") ;
+    if (!selfpipe_trapset(&set)) strerr_diefu1sys(111, "trap signals") ;
   }
 
   if (rulestype == 2)
@@ -460,7 +461,7 @@ int main (int argc, char const *const *argv, char const *const *envp)
 
     for (;;)
     {
-      tain_t deadline ;
+      tain deadline ;
       int r = 1 ;
       uint32_t i = clientstorage[sentinel].next, j = 2 ;
       query_get_mindeadline(&deadline) ;
diff --git a/src/rpc/skabus-rpcd.h b/src/rpc/skabus-rpcd.h
index fec72f1..e9b63fe 100644
--- a/src/rpc/skabus-rpcd.h
+++ b/src/rpc/skabus-rpcd.h
@@ -29,7 +29,7 @@ typedef struct query_s query_t, *query_t_ref ;
 struct query_s
 {
   uint64_t serial ;
-  tain_t deadline ;
+  tain deadline ;
   uint32_t client ;
   uint32_t clientindex ;
   uint32_t interface ;
@@ -78,11 +78,11 @@ struct client_s
   uint32_t next ;
   uid_t uid ;
   gid_t gid ;
-  tain_t deadline ;
+  tain deadline ;
   genalloc interfaces ; /* uint32_t */
   gensetdyn queries ; /* uint32_t */
-  unixconnection_t sync ;
-  unixconnection_t async ;
+  unixconnection sync ;
+  unixconnection async ;
   uint32_t xindex[2] ;
   regex_t idstr_re ;
   regex_t interfaces_re ;
@@ -118,11 +118,11 @@ extern int query_cancel (uint32_t, char) ;
 extern int query_cancelremove (uint32_t, char) ;
 extern int query_lookup_by_serial (uint64_t, uint32_t *) ;
 extern int query_lookup_by_mindeadline (uint32_t *) ;
-extern void query_get_mindeadline (tain_t *) ;
-extern int query_add (uint32_t *, tain_t const *, uint32_t, uint32_t) ;
-extern int query_send (uint32_t, unixmessage_t const *) ;
-extern int query_sendpm (uint32_t, unixmessage_t const *) ;
-extern void query_reply (uint32_t, char, unixmessage_t const *) ;
+extern void query_get_mindeadline (tain *) ;
+extern int query_add (uint32_t *, tain const *, uint32_t, uint32_t) ;
+extern int query_send (uint32_t, unixmessage const *) ;
+extern int query_sendpm (uint32_t, unixmessage const *) ;
+extern void query_reply (uint32_t, char, unixmessage const *) ;
 
 extern void interface_remove (uint32_t) ;
 extern int interface_lookup_by_name (char const *, uint32_t *) ;
@@ -132,15 +132,15 @@ extern int interface_add (uint32_t *, char const *, size_t, uint32_t, char const
 #define client_idstr(c) (INTERFACE(genalloc_s(uint32_t, &(c)->interfaces)[0])->name + 1)
 extern void client_remove (uint32_t, uint32_t) ;
 extern void client_add (uint32_t *, regex_t const *, regex_t const *, uid_t, gid_t, int, uint32_t) ;
-extern void client_nextdeadline (uint32_t, tain_t *) ;
+extern void client_nextdeadline (uint32_t, tain *) ;
 extern void client_setdeadline (client_t *) ;
-extern int client_prepare_iopause (uint32_t, tain_t *, iopause_fd *, uint32_t *, int) ;
+extern int client_prepare_iopause (uint32_t, tain *, iopause_fd *, uint32_t *, int) ;
 extern int client_flush (uint32_t, iopause_fd const *) ;
 extern int client_read (uint32_t, iopause_fd const *) ;
 
-extern int parse_protocol_sync (unixmessage_t const *, void *) ;
-extern int parse_protocol_async (unixmessage_t const *, void *) ;
+extern int parse_protocol_sync (unixmessage const *, void *) ;
+extern int parse_protocol_async (unixmessage const *, void *) ;
 
-extern tain_t answertto ;
+extern tain answertto ;
 
 #endif
diff --git a/src/rpc/skabus_rpccctl.c b/src/rpc/skabus_rpccctl.c
index d3ee6ef..1e9efcf 100644
--- a/src/rpc/skabus_rpccctl.c
+++ b/src/rpc/skabus_rpccctl.c
@@ -17,7 +17,7 @@
 #include <skabus/rpc.h>
 #include "skabus-rpccctl.h"
 
-int skabus_rpcc_start (skabus_rpcc_t *a, char const *path, tain_t const *deadline, tain_t *stamp)
+int skabus_rpcc_start (skabus_rpcc_t *a, char const *path, tain const *deadline, tain *stamp)
 {
   int fd = ipc_stream_nb() ;
   if (fd < 0) return 0 ;
@@ -38,7 +38,7 @@ void skabus_rpcc_end (skabus_rpcc_t *a)
   textmessage_receiver_free(&a->in) ;
 }
 
-int skabus_rpcc_interface_register (skabus_rpcc_t *a, char const *ifname, char const *ifprog, char const *re, tain_t const *deadline, tain_t *stamp)
+int skabus_rpcc_interface_register (skabus_rpcc_t *a, char const *ifname, char const *ifprog, char const *re, tain const *deadline, tain *stamp)
 {
   size_t ifnamelen, ifproglen, relen ;
   char *ifprogfn = realpath(ifprog, 0) ;
@@ -72,7 +72,7 @@ int skabus_rpcc_interface_register (skabus_rpcc_t *a, char const *ifname, char c
   return 0 ;
 }
 
-int skabus_rpcc_interface_unregister (skabus_rpcc_t *a, char const *ifname, tain_t const *deadline, tain_t *stamp)
+int skabus_rpcc_interface_unregister (skabus_rpcc_t *a, char const *ifname, tain const *deadline, tain *stamp)
 {
   size_t ifnamelen = strlen(ifname) ;
   if (ifnamelen > SKABUS_RPC_INTERFACE_MAXLEN) return (errno = ENAMETOOLONG, 0) ;
@@ -89,7 +89,7 @@ int skabus_rpcc_interface_unregister (skabus_rpcc_t *a, char const *ifname, tain
   return 1 ;
 }
 
-int skabus_rpcc_query (skabus_rpcc_t *a, stralloc *reply, char const *ifname, char const *query, uint32_t timeout, tain_t const *deadline, tain_t *stamp)
+int skabus_rpcc_query (skabus_rpcc_t *a, stralloc *reply, char const *ifname, char const *query, uint32_t timeout, tain const *deadline, tain *stamp)
 {
   size_t ifnamelen = strlen(ifname) ;
   size_t querylen = strlen(query) ;
@@ -118,7 +118,7 @@ int skabus_rpcc_query (skabus_rpcc_t *a, stralloc *reply, char const *ifname, ch
   return 1 ;
 }
 
-int skabus_rpcc_quit (skabus_rpcc_t *a, tain_t const *deadline, tain_t *stamp)
+int skabus_rpcc_quit (skabus_rpcc_t *a, tain const *deadline, tain *stamp)
 {
   return textmessage_timed_command(&a->out, ".", 1, deadline, stamp) ; 
 }
diff --git a/src/rpc/skabus_rpcd_client.c b/src/rpc/skabus_rpcd_client.c
index deac459..198f0da 100644
--- a/src/rpc/skabus_rpcd_client.c
+++ b/src/rpc/skabus_rpcd_client.c
@@ -62,7 +62,7 @@ void client_remove (uint32_t i, uint32_t prev)
 
 void client_setdeadline (client_t *c)
 {
-  tain_t blah ;
+  tain blah ;
   tain_half(&blah, &tain_infinite_relative) ;
   tain_add_g(&blah, &blah) ;
   if (tain_less(&blah, &c->deadline)) tain_add_g(&c->deadline, &answertto) ;
@@ -87,13 +87,13 @@ void client_add (uint32_t *d, regex_t const *idstr_re, regex_t const *interfaces
   *d = cc ;
 }
 
-void client_nextdeadline (uint32_t i, tain_t *deadline)
+void client_nextdeadline (uint32_t i, tain *deadline)
 {
   client_t *c = CLIENT(i) ;
   if (tain_less(&c->deadline, deadline)) *deadline = c->deadline ;
 }
 
-int client_prepare_iopause (uint32_t cc, tain_t *deadline, iopause_fd *x, uint32_t *j, int notlameduck)
+int client_prepare_iopause (uint32_t cc, tain *deadline, iopause_fd *x, uint32_t *j, int notlameduck)
 {
   client_t *c = CLIENT(cc) ;
   int inflight = 0 ;
@@ -158,7 +158,7 @@ int client_read (uint32_t cc, iopause_fd const *x)
   {
     if (unixmessage_sender_fd(&c->async.out) < 0)
     {
-      unixmessage_t m ;
+      unixmessage m ;
       int r = unixmessage_receive(&c->sync.in, &m) ;
       if (r < 0) return -1 ;
       if (r)
diff --git a/src/rpc/skabus_rpcd_query.c b/src/rpc/skabus_rpcd_query.c
index baa6df5..13f3ebe 100644
--- a/src/rpc/skabus_rpcd_query.c
+++ b/src/rpc/skabus_rpcd_query.c
@@ -36,8 +36,8 @@ static int query_serial_cmp (void const *a, void const *b, void *x)
 
 static int query_deadline_cmp (void const *a, void const *b, void *x)
 {
-  tain_t const *aa = (tain_t const *)a ;
-  tain_t const *bb = (tain_t const *)b ;
+  tain const *aa = (tain const *)a ;
+  tain const *bb = (tain const *)b ;
   (void)x ;
   return tain_less(aa, bb) ? -1 : tain_less(bb, aa) ;
 }
@@ -73,7 +73,7 @@ void query_fail (uint32_t i, char status)
   query_t *q = QUERY(i) ;
   client_t *c = CLIENT(q->client) ;
   char pack[10] = "Rssssssssr" ;
-  unixmessage_t m = { .s = pack, .len = 10, .fds = 0, .nfds = 0 } ;
+  unixmessage m = { .s = pack, .len = 10, .fds = 0, .nfds = 0 } ;
   uint64_pack_big(pack+1, q->serial) ;
   pack[9] = status ;
   if (!unixmessage_put(&c->async.out, &m))
@@ -88,7 +88,7 @@ int query_cancel (uint32_t i, char reason)
   interface_t *y = INTERFACE(q->interface) ;
   client_t *c = CLIENT(y->client) ;
   char pack[14] = "Ciiiissssssssr" ;
-  unixmessage_t m = { .s = pack, .len = 14, .fds = 0, .nfds = 0 } ;
+  unixmessage m = { .s = pack, .len = 14, .fds = 0, .nfds = 0 } ;
   uint32_pack_big(pack+1, y->id) ;
   uint64_pack_big(pack+5, q->serial) ;
   pack[13] = reason ;
@@ -114,14 +114,14 @@ int query_lookup_by_mindeadline (uint32_t *d)
   return avltree_min(&qdeadlinedict, d) ;
 }
 
-void query_get_mindeadline (tain_t *deadline)
+void query_get_mindeadline (tain *deadline)
 {
   uint32_t d ;
   if (query_lookup_by_mindeadline(&d)) *deadline = QUERY(d)->deadline ;
   else tain_add_g(deadline, &tain_infinite_relative) ;
 }
 
-int query_add (uint32_t *d, tain_t const *deadline, uint32_t client, uint32_t interface)
+int query_add (uint32_t *d, tain const *deadline, uint32_t client, uint32_t interface)
 {
   static uint64_t serial = 1 ;
   uint32_t qq, cc, yy ;
@@ -139,7 +139,7 @@ int query_add (uint32_t *d, tain_t const *deadline, uint32_t client, uint32_t in
   if (!avltree_insert(&qserialdict, qq)) goto end2 ;
   for (;;)
   {
-    static tain_t const nano1 = { .sec = TAI_ZERO, .nano = 1 } ;
+    static tain const nano1 = { .sec = TAI_ZERO, .nano = 1 } ;
     uint32_t d ;
     if (!avltree_search(&qdeadlinedict, &q->deadline, &d)) break ;
     tain_add(&q->deadline, &q->deadline, &nano1) ;
@@ -164,12 +164,12 @@ int query_add (uint32_t *d, tain_t const *deadline, uint32_t client, uint32_t in
   return 0 ;
 }
 
-int query_send (uint32_t qq, unixmessage_t const *m)
+int query_send (uint32_t qq, unixmessage const *m)
 {
   skabus_rpc_rinfo_t rinfo ;
   char pack[4 + SKABUS_RPC_RINFO_PACK] = "Q" ;
   struct iovec v[2] = { { .iov_base = pack, .iov_len = 4 + SKABUS_RPC_RINFO_PACK }, { .iov_base = m->s, .iov_len = m->len } } ;
-  unixmessage_v_t mtosend = { .v = v, .vlen = 2, .fds = m->fds, .nfds = m->nfds } ;
+  unixmessagev mtosend = { .v = v, .vlen = 2, .fds = m->fds, .nfds = m->nfds } ;
   query_t *q = QUERY(qq) ;
   interface_t *y = INTERFACE(q->interface) ;
   client_t *c = CLIENT(q->client) ;
@@ -190,11 +190,11 @@ int query_send (uint32_t qq, unixmessage_t const *m)
   return 1 ;
 }
 
-void query_reply (uint32_t qq, char result, unixmessage_t const *m)
+void query_reply (uint32_t qq, char result, unixmessage const *m)
 {
   char pack[11] = "R" ;
   struct iovec v[2] = { { .iov_base = pack, .iov_len = 11 }, { .iov_base = m->s, .iov_len = m->len } } ;
-  unixmessage_v_t mtosend = { .v = v, .vlen = 2, .fds = m->fds, .nfds = m->nfds } ;
+  unixmessagev mtosend = { .v = v, .vlen = 2, .fds = m->fds, .nfds = m->nfds } ;
   query_t *q = QUERY(qq) ;
   client_t *c = CLIENT(q->client) ;
   uint64_pack_big(pack+1, q->serial) ;