Redo the control code

Make a simple connection object that you can use to send and receive our
commands.

pinos/client/connection.c

@@ -0,0 +1,850 @@
+/* Simple Plugin API
+ * Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+
+#include "connection.h"
+#include "serialize.h"
+
+#define MAX_BUFFER_SIZE 4096
+#define MAX_FDS 28
+
+typedef struct {
+  uint8_t buffer_data[MAX_BUFFER_SIZE];
+  size_t buffer_size;
+  int fds[MAX_FDS];
+  unsigned int n_fds;
+
+  SpaControlCmd   cmd;
+  off_t           offset;
+  void           *data;
+  size_t          size;
+} ConnectionBuffer;
+
+struct _SpaConnection {
+  ConnectionBuffer in, out;
+  int fd;
+  bool update;
+};
+
+#if 0
+#define SPA_DEBUG_CONTROL(format,args...) fprintf(stderr,format,##args)
+#else
+#define SPA_DEBUG_CONTROL(format,args...)
+#endif
+
+static bool
+read_length (uint8_t * data, unsigned int size, size_t * length, size_t * skip)
+{
+  size_t len, offset;
+  uint8_t b;
+
+  /* start reading the length, we need this to skip to the data later */
+  len = offset = 0;
+  do {
+    if (offset >= size)
+      return false;
+
+    b = data[offset++];
+    len = (len << 7) | (b & 0x7f);
+  } while (b & 0x80);
+
+  /* check remaining command size */
+  if (size - offset < len)
+    return false;
+
+  *length = len;
+  *skip = offset;
+
+  return true;
+}
+
+static void
+connection_parse_node_update (SpaConnection *conn, SpaControlCmdNodeUpdate *nu)
+{
+  memcpy (nu, conn->in.data, sizeof (SpaControlCmdNodeUpdate));
+  if (nu->props)
+    nu->props = spa_serialize_props_deserialize (conn->in.data, SPA_PTR_TO_INT (nu->props));
+}
+
+static void
+connection_parse_port_update (SpaConnection *conn, SpaControlCmdPortUpdate *pu)
+{
+  void *p;
+  unsigned int i;
+
+  memcpy (pu, conn->in.data, sizeof (SpaControlCmdPortUpdate));
+
+  p = conn->in.data;
+
+  if (pu->possible_formats)
+    pu->possible_formats = SPA_MEMBER (p,
+                        SPA_PTR_TO_INT (pu->possible_formats), SpaFormat *);
+  for (i = 0; i < pu->n_possible_formats; i++) {
+    if (pu->possible_formats[i]) {
+      pu->possible_formats[i] = spa_serialize_format_deserialize (p,
+                          SPA_PTR_TO_INT (pu->possible_formats[i]));
+    }
+  }
+  if (pu->format)
+    pu->format = spa_serialize_format_deserialize (p, SPA_PTR_TO_INT (pu->format));
+  if (pu->props)
+    pu->props = spa_serialize_props_deserialize (p, SPA_PTR_TO_INT (pu->props));
+  if (pu->info)
+    pu->info = spa_serialize_port_info_deserialize (p, SPA_PTR_TO_INT (pu->info));
+}
+
+static void
+connection_parse_set_format (SpaConnection *conn, SpaControlCmdSetFormat *cmd)
+{
+  memcpy (cmd, conn->in.data, sizeof (SpaControlCmdSetFormat));
+  if (cmd->format)
+    cmd->format = spa_serialize_format_deserialize (conn->in.data, SPA_PTR_TO_INT (cmd->format));
+}
+
+static void
+connection_parse_use_buffers (SpaConnection *conn, SpaControlCmdUseBuffers *cmd)
+{
+  void *p;
+
+  p = conn->in.data;
+  memcpy (cmd, p, sizeof (SpaControlCmdUseBuffers));
+  if (cmd->buffers)
+    cmd->buffers = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->buffers), SpaControlMemRef);
+}
+
+static void
+connection_parse_node_event (SpaConnection *conn, SpaControlCmdNodeEvent *cmd)
+{
+  void *p = conn->in.data;
+  memcpy (cmd, p, sizeof (SpaControlCmdNodeEvent));
+  if (cmd->event)
+    cmd->event = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->event), SpaNodeEvent);
+  if (cmd->event->data)
+    cmd->event->data = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->event->data), void);
+}
+
+static void
+connection_parse_node_command (SpaConnection *conn, SpaControlCmdNodeCommand *cmd)
+{
+  void *p = conn->in.data;
+  memcpy (cmd, p, sizeof (SpaControlCmdNodeCommand));
+  if (cmd->command)
+    cmd->command = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->command), SpaNodeCommand);
+  if (cmd->command->data)
+    cmd->command->data = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->command->data), void);
+}
+
+#define MAX(a,b)  ((a) > (b) ? (a) : (b))
+
+static void *
+connection_ensure_size (SpaConnection *conn, size_t size)
+{
+  if (conn->out.buffer_size + size > MAX_BUFFER_SIZE) {
+    fprintf (stderr, "error connection %p: overflow\n", conn);
+  }
+  return (uint8_t *) conn->out.buffer_data + conn->out.buffer_size;
+}
+
+static void *
+connection_add_cmd (SpaConnection *conn, SpaControlCmd cmd, size_t size)
+{
+  uint8_t *p;
+  unsigned int plen;
+
+  plen = 1;
+  while (size >> (7 * plen))
+    plen++;
+
+  /* 1 for cmd, plen for size and size for payload */
+  p = connection_ensure_size (conn, 1 + plen + size);
+
+  conn->out.cmd = cmd;
+  conn->out.offset = conn->out.buffer_size;
+  conn->out.buffer_size += 1 + plen + size;
+
+  *p++ = cmd;
+  /* write length */
+  while (plen) {
+    plen--;
+    *p++ = ((plen > 0) ? 0x80 : 0) | ((size >> (7 * plen)) & 0x7f);
+  }
+  return p;
+}
+
+static void
+connection_add_node_update (SpaConnection *conn, SpaControlCmdNodeUpdate *nu)
+{
+  size_t len;
+  void *p;
+  SpaControlCmdNodeUpdate *d;
+
+  /* calc len */
+  len = sizeof (SpaControlCmdNodeUpdate);
+  len += spa_serialize_props_get_size (nu->props);
+
+  p = connection_add_cmd (conn, SPA_CONTROL_CMD_NODE_UPDATE, len);
+  memcpy (p, nu, sizeof (SpaControlCmdNodeUpdate));
+  d = p;
+
+  p = SPA_MEMBER (d, sizeof (SpaControlCmdNodeUpdate), void);
+  if (nu->props) {
+    len = spa_serialize_props_serialize (p, nu->props);
+    d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+  } else {
+    d->props = 0;
+  }
+}
+
+static void
+connection_add_port_update (SpaConnection *conn, SpaControlCmdPortUpdate *pu)
+{
+  size_t len;
+  void *p;
+  int i;
+  SpaFormat **bfa;
+  SpaControlCmdPortUpdate *d;
+
+  /* calc len */
+  len = sizeof (SpaControlCmdPortUpdate);
+  len += pu->n_possible_formats * sizeof (SpaFormat *);
+  for (i = 0; i < pu->n_possible_formats; i++) {
+    len += spa_serialize_format_get_size (pu->possible_formats[i]);
+  }
+  len += spa_serialize_format_get_size (pu->format);
+  len += spa_serialize_props_get_size (pu->props);
+  if (pu->info)
+    len += spa_serialize_port_info_get_size (pu->info);
+
+  p = connection_add_cmd (conn, SPA_CONTROL_CMD_PORT_UPDATE, len);
+  memcpy (p, pu, sizeof (SpaControlCmdPortUpdate));
+  d = p;
+
+  p = SPA_MEMBER (d, sizeof (SpaControlCmdPortUpdate), void);
+  bfa = p;
+  if (pu->n_possible_formats)
+    d->possible_formats = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+  else
+    d->possible_formats = 0;
+
+  p = SPA_MEMBER (p, sizeof (SpaFormat*) * pu->n_possible_formats, void);
+
+  for (i = 0; i < pu->n_possible_formats; i++) {
+    len = spa_serialize_format_serialize (p, pu->possible_formats[i]);
+    bfa[i] = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+    p = SPA_MEMBER (p, len, void);
+  }
+  if (pu->format) {
+    len = spa_serialize_format_serialize (p, pu->format);
+    d->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+    p = SPA_MEMBER (p, len, void);
+  } else {
+    d->format = 0;
+  }
+  if (pu->props) {
+    len = spa_serialize_props_serialize (p, pu->props);
+    d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+    p = SPA_MEMBER (p, len, void);
+  } else {
+    d->props = 0;
+  }
+  if (pu->info) {
+    len = spa_serialize_port_info_serialize (p, pu->info);
+    d->info = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+    p = SPA_MEMBER (p, len, void);
+  } else {
+    d->info = 0;
+  }
+}
+
+static void
+connection_add_set_format (SpaConnection *conn, SpaControlCmdSetFormat *sf)
+{
+  size_t len;
+  void *p;
+
+  /* calculate length */
+  /* port_id + format + mask  */
+  len = sizeof (SpaControlCmdSetFormat) + spa_serialize_format_get_size (sf->format);
+  p = connection_add_cmd (conn, SPA_CONTROL_CMD_SET_FORMAT, len);
+  memcpy (p, sf, sizeof (SpaControlCmdSetFormat));
+  sf = p;
+
+  p = SPA_MEMBER (sf, sizeof (SpaControlCmdSetFormat), void);
+  if (sf->format) {
+    len = spa_serialize_format_serialize (p, sf->format);
+    sf->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, sf));
+  } else
+    sf->format = 0;
+}
+
+static void
+connection_add_use_buffers (SpaConnection *conn, SpaControlCmdUseBuffers *ub)
+{
+  size_t len;
+  int i;
+  SpaControlCmdUseBuffers *d;
+  SpaControlMemRef *mr;
+
+  /* calculate length */
+  len = sizeof (SpaControlCmdUseBuffers);
+  len += ub->n_buffers * sizeof (SpaControlMemRef);
+
+  d = connection_add_cmd (conn, SPA_CONTROL_CMD_USE_BUFFERS, len);
+  memcpy (d, ub, sizeof (SpaControlCmdUseBuffers));
+
+  mr = SPA_MEMBER (d, sizeof (SpaControlCmdUseBuffers), void);
+
+  if (d->n_buffers)
+    d->buffers = SPA_INT_TO_PTR (SPA_PTRDIFF (mr, d));
+  else
+    d->buffers = 0;
+
+  for (i = 0; i < ub->n_buffers; i++)
+    memcpy (&mr[i], &ub->buffers[i], sizeof (SpaControlMemRef));
+}
+
+static void
+connection_add_node_event (SpaConnection *conn, SpaControlCmdNodeEvent *ev)
+{
+  size_t len;
+  void *p;
+  SpaControlCmdNodeEvent *d;
+  SpaNodeEvent *ne;
+
+  /* calculate length */
+  len = sizeof (SpaControlCmdNodeEvent);
+  len += sizeof (SpaNodeEvent);
+  len += ev->event->size;
+
+  p = connection_add_cmd (conn, SPA_CONTROL_CMD_NODE_EVENT, len);
+  memcpy (p, ev, sizeof (SpaControlCmdNodeEvent));
+  d = p;
+
+  p = SPA_MEMBER (d, sizeof (SpaControlCmdNodeEvent), void);
+  d->event = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+
+  ne = p;
+  memcpy (p, ev->event, sizeof (SpaNodeEvent));
+  p = SPA_MEMBER (p, sizeof (SpaNodeEvent), void);
+  ne->data = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+  memcpy (p, ev->event->data, ev->event->size);
+}
+
+
+static void
+connection_add_node_command (SpaConnection *conn, SpaControlCmdNodeCommand *cm)
+{
+  size_t len;
+  void *p;
+  SpaControlCmdNodeCommand *d;
+  SpaNodeCommand *nc;
+
+  /* calculate length */
+  len = sizeof (SpaControlCmdNodeCommand);
+  len += sizeof (SpaNodeCommand);
+  len += cm->command->size;
+
+  p = connection_add_cmd (conn, SPA_CONTROL_CMD_NODE_COMMAND, len);
+  memcpy (p, cm, sizeof (SpaControlCmdNodeCommand));
+  d = p;
+
+  p = SPA_MEMBER (d, sizeof (SpaControlCmdNodeCommand), void);
+  d->command = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+
+  nc = p;
+  memcpy (p, cm->command, sizeof (SpaNodeCommand));
+  p = SPA_MEMBER (p, sizeof (SpaNodeCommand), void);
+  nc->data = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+  memcpy (p, cm->command->data, cm->command->size);
+}
+
+static SpaResult
+refill_buffer (SpaConnection *conn)
+{
+  ssize_t len;
+  struct cmsghdr *cmsg;
+  struct msghdr msg = {0};
+  struct iovec iov[1];
+  char cmsgbuf[CMSG_SPACE (MAX_FDS * sizeof (int))];
+
+  conn->in.cmd = SPA_CONTROL_CMD_INVALID;
+  conn->in.offset = 0;
+  conn->in.size = 0;
+  conn->in.buffer_size = 0;
+
+  iov[0].iov_base = conn->in.buffer_data;
+  iov[0].iov_len = MAX_BUFFER_SIZE;
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = cmsgbuf;
+  msg.msg_controllen = sizeof (cmsgbuf);
+  msg.msg_flags = MSG_CMSG_CLOEXEC;
+
+  while (true) {
+    len = recvmsg (conn->fd, &msg, msg.msg_flags);
+    if (len < 0) {
+      if (errno == EINTR)
+        continue;
+      else
+        goto recv_error;
+    }
+    break;
+  }
+
+  if (len < 4)
+    return SPA_RESULT_ERROR;
+
+  conn->in.buffer_size = len;
+
+  /* handle control messages */
+  for (cmsg = CMSG_FIRSTHDR (&msg); cmsg != NULL; cmsg = CMSG_NXTHDR (&msg, cmsg)) {
+    if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS)
+      continue;
+
+    conn->in.n_fds = (cmsg->cmsg_len - ((char *)CMSG_DATA (cmsg) - (char *)cmsg)) / sizeof (int);
+    memcpy (conn->in.fds, CMSG_DATA (cmsg), conn->in.n_fds * sizeof (int));
+  }
+  SPA_DEBUG_CONTROL ("connection %p: %d read %zd bytes and %d fds\n", conn, conn->fd, len, conn->in.n_fds);
+
+  return SPA_RESULT_OK;
+
+  /* ERRORS */
+recv_error:
+  {
+    fprintf (stderr, "could not recvmsg on fd %d: %s\n", conn->fd, strerror (errno));
+    return SPA_RESULT_ERROR;
+  }
+}
+
+SpaConnection *
+spa_connection_new (int fd)
+{
+  SpaConnection *c;
+
+  c = calloc (1, sizeof (SpaConnection));
+  c->fd = fd;
+
+  return c;
+}
+
+/**
+ * spa_connection_has_next:
+ * @iter: a #SpaConnection
+ *
+ * Move to the next packet in @conn.
+ *
+ * Returns: %SPA_RESULT_OK if more packets are available.
+ */
+SpaResult
+spa_connection_has_next (SpaConnection *conn)
+{
+  size_t len, size, skip;
+  uint8_t *data;
+
+  if (conn == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  /* move to next packet */
+  conn->in.offset += conn->in.size;
+
+  if (conn->update) {
+    refill_buffer (conn);
+    conn->update = false;
+  }
+
+  /* now read packet */
+  data = conn->in.buffer_data;
+  size = conn->in.buffer_size;
+
+  if (conn->in.offset >= size) {
+    conn->update = true;
+    return SPA_RESULT_ERROR;
+  }
+
+  data += conn->in.offset;
+  size -= conn->in.offset;
+
+  if (size < 1)
+    return SPA_RESULT_ERROR;
+
+  conn->in.cmd = *data;
+
+  data++;
+  size--;
+
+  if (!read_length (data, size, &len, &skip))
+    return SPA_RESULT_ERROR;
+
+  conn->in.size = len;
+  conn->in.data = data + skip;
+  conn->in.offset += 1 + skip;
+
+  return SPA_RESULT_OK;
+}
+
+SpaControlCmd
+spa_connection_get_cmd (SpaConnection *conn)
+{
+  if (conn == NULL)
+    return SPA_CONTROL_CMD_INVALID;
+
+  return conn->in.cmd;
+}
+
+SpaResult
+spa_connection_parse_cmd (SpaConnection *conn,
+                          void          *command)
+{
+  SpaResult res = SPA_RESULT_OK;
+
+  if (conn == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  switch (conn->in.cmd) {
+    /* C -> S */
+    case SPA_CONTROL_CMD_NODE_UPDATE:
+      connection_parse_node_update (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PORT_UPDATE:
+      connection_parse_port_update (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PORT_STATUS_CHANGE:
+      fprintf (stderr, "implement iter of %d\n", conn->in.cmd);
+      break;
+
+    case SPA_CONTROL_CMD_NODE_STATE_CHANGE:
+      if (conn->in.size < sizeof (SpaControlCmdNodeStateChange))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdNodeStateChange));
+      break;
+
+    /* S -> C */
+    case SPA_CONTROL_CMD_ADD_PORT:
+      if (conn->in.size < sizeof (SpaControlCmdAddPort))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdAddPort));
+      break;
+
+    case SPA_CONTROL_CMD_REMOVE_PORT:
+      if (conn->in.size < sizeof (SpaControlCmdRemovePort))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdRemovePort));
+      break;
+
+    case SPA_CONTROL_CMD_SET_FORMAT:
+      connection_parse_set_format (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_SET_PROPERTY:
+      fprintf (stderr, "implement iter of %d\n", conn->in.cmd);
+      break;
+
+    /* bidirectional */
+    case SPA_CONTROL_CMD_ADD_MEM:
+      if (conn->in.size < sizeof (SpaControlCmdAddMem))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdAddMem));
+      break;
+
+    case SPA_CONTROL_CMD_REMOVE_MEM:
+      if (conn->in.size < sizeof (SpaControlCmdRemoveMem))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdRemoveMem));
+      break;
+
+    case SPA_CONTROL_CMD_USE_BUFFERS:
+      connection_parse_use_buffers (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PROCESS_BUFFER:
+      if (conn->in.size < sizeof (SpaControlCmdProcessBuffer))
+        return SPA_RESULT_ERROR;
+      memcpy (command, conn->in.data, sizeof (SpaControlCmdProcessBuffer));
+      break;
+
+    case SPA_CONTROL_CMD_NODE_EVENT:
+      connection_parse_node_event (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_NODE_COMMAND:
+      connection_parse_node_command (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_INVALID:
+      return SPA_RESULT_ERROR;
+  }
+  return res;
+}
+
+/**
+ * spa_connection_get_fd:
+ * @conn: a #SpaConnection
+ * @index: an index
+ * @steal: steal the fd
+ *
+ * Get the file descriptor at @index in @conn.
+ *
+ * Returns: a file descriptor at @index in @conn. The file descriptor
+ * is not duplicated in any way. -1 is returned on error.
+ */
+int
+spa_connection_get_fd (SpaConnection *conn,
+                       unsigned int   index,
+                       bool           close)
+{
+  int fd;
+
+  if (conn == NULL)
+    return -1;
+
+  if (conn->in.n_fds < index)
+    return -1;
+
+  fd = conn->in.fds[index];
+  if (fd < 0)
+    fd = -fd;
+  conn->in.fds[index] = close ? fd : -fd;
+
+  return fd;
+}
+
+/**
+ * spa_connection_add_fd:
+ * @conn: a #SpaConnection
+ * @fd: a valid fd
+ * @close: if the descriptor should be closed when sent
+ *
+ * Add the file descriptor @fd to @builder.
+ *
+ * Returns: the index of the file descriptor in @builder.
+ */
+int
+spa_connection_add_fd (SpaConnection *conn,
+                       int            fd,
+                       bool           close)
+{
+  int index, i;
+
+  if (conn == NULL)
+    return -1;
+
+  for (i = 0; i < conn->out.n_fds; i++) {
+    if (conn->out.fds[i] == fd || conn->out.fds[i] == -fd)
+      return i;
+  }
+
+  index = conn->out.n_fds;
+  conn->out.fds[index] = close ? fd : -fd;
+  conn->out.n_fds++;
+
+  return index;
+}
+
+/**
+ * spa_connection_add_cmd:
+ * @conn: a #SpaConnection
+ * @cmd: a #SpaControlCmd
+ * @command: a command
+ *
+ * Add a @cmd to @conn with data from @command.
+ *
+ * Returns: %SPA_RESULT_OK on success.
+ */
+SpaResult
+spa_connection_add_cmd (SpaConnection *conn,
+                        SpaControlCmd  cmd,
+                        void          *command)
+{
+  void *p;
+
+  if (conn == NULL || command == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  switch (cmd) {
+    /* C -> S */
+    case SPA_CONTROL_CMD_NODE_UPDATE:
+      connection_add_node_update (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PORT_UPDATE:
+      connection_add_port_update (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PORT_STATUS_CHANGE:
+      p = connection_add_cmd (conn, cmd, 0);
+      break;
+
+    case SPA_CONTROL_CMD_NODE_STATE_CHANGE:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdNodeStateChange));
+      memcpy (p, command, sizeof (SpaControlCmdNodeStateChange));
+      break;
+
+    /* S -> C */
+    case SPA_CONTROL_CMD_ADD_PORT:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdAddPort));
+      memcpy (p, command, sizeof (SpaControlCmdAddPort));
+      break;
+
+    case SPA_CONTROL_CMD_REMOVE_PORT:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdRemovePort));
+      memcpy (p, command, sizeof (SpaControlCmdRemovePort));
+      break;
+
+    case SPA_CONTROL_CMD_SET_FORMAT:
+      connection_add_set_format (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_SET_PROPERTY:
+      fprintf (stderr, "implement builder of %d\n", cmd);
+      break;
+
+    /* bidirectional */
+    case SPA_CONTROL_CMD_ADD_MEM:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdAddMem));
+      memcpy (p, command, sizeof (SpaControlCmdAddMem));
+      break;
+
+    case SPA_CONTROL_CMD_REMOVE_MEM:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdRemoveMem));
+      memcpy (p, command, sizeof (SpaControlCmdRemoveMem));
+      break;
+
+    case SPA_CONTROL_CMD_USE_BUFFERS:
+      connection_add_use_buffers (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_PROCESS_BUFFER:
+      p = connection_add_cmd (conn, cmd, sizeof (SpaControlCmdProcessBuffer));
+      memcpy (p, command, sizeof (SpaControlCmdProcessBuffer));
+      break;
+
+    case SPA_CONTROL_CMD_NODE_EVENT:
+      connection_add_node_event (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_NODE_COMMAND:
+      connection_add_node_command (conn, command);
+      break;
+
+    case SPA_CONTROL_CMD_INVALID:
+      return SPA_RESULT_INVALID_ARGUMENTS;
+  }
+  return SPA_RESULT_OK;
+}
+
+SpaResult
+spa_connection_flush (SpaConnection *conn)
+{
+  ssize_t len;
+  struct msghdr msg = {0};
+  struct iovec iov[1];
+  struct cmsghdr *cmsg;
+  char cmsgbuf[CMSG_SPACE (MAX_FDS * sizeof (int))];
+  int *cm, i, fds_len;
+
+  if (conn == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  if (conn->out.buffer_size == 0)
+    return SPA_RESULT_OK;
+
+  fds_len = conn->out.n_fds * sizeof (int);
+
+  iov[0].iov_base = conn->out.buffer_data;
+  iov[0].iov_len = conn->out.buffer_size;
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+
+  if (conn->out.n_fds > 0) {
+    msg.msg_control = cmsgbuf;
+    msg.msg_controllen = CMSG_SPACE (fds_len);
+    cmsg = CMSG_FIRSTHDR(&msg);
+    cmsg->cmsg_level = SOL_SOCKET;
+    cmsg->cmsg_type = SCM_RIGHTS;
+    cmsg->cmsg_len = CMSG_LEN (fds_len);
+    cm = (int*)CMSG_DATA (cmsg);
+    for (i = 0; i < conn->out.n_fds; i++)
+      cm[i] = conn->out.fds[i] > 0 ? conn->out.fds[i] : -conn->out.fds[i];
+    msg.msg_controllen = cmsg->cmsg_len;
+  } else {
+    msg.msg_control = NULL;
+    msg.msg_controllen = 0;
+  }
+
+  while (true) {
+    len = sendmsg (conn->fd, &msg, 0);
+    if (len < 0) {
+      if (errno == EINTR)
+        continue;
+      else
+        goto send_error;
+    }
+    break;
+  }
+  conn->out.buffer_size -= len;
+  conn->out.n_fds = 0;
+
+  SPA_DEBUG_CONTROL ("connection %p: %d written %zd bytes and %u fds\n", conn, conn->fd, len, conn->out.n_fds);
+
+  return SPA_RESULT_OK;
+
+  /* ERRORS */
+send_error:
+  {
+    fprintf (stderr, "could not sendmsg: %s\n", strerror (errno));
+    return SPA_RESULT_ERROR;
+  }
+}
+
+SpaResult
+spa_connection_clear (SpaConnection *conn)
+{
+  unsigned int i;
+
+  if (conn == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  for (i = 0; i < conn->out.n_fds; i++) {
+    if (conn->out.fds[i] > 0) {
+      if (close (conn->out.fds[i]) < 0)
+        perror ("close");
+    }
+  }
+  conn->out.n_fds = 0;
+  conn->out.buffer_size = 0;
+  for (i = 0; i < conn->in.n_fds; i++) {
+    if (conn->in.fds[i] > 0) {
+      if (close (conn->in.fds[i]) < 0)
+        perror ("close");
+    }
+  }
+  conn->in.n_fds = 0;
+  conn->in.buffer_size = 0;
+
+  return SPA_RESULT_OK;
+}