dbus/test/header-fields.c

/* Unit tests for detailed header field manipulation
 *
 * Copyright © 2017 Collabora Ltd.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <config.h>

#include <glib.h>

#include <dbus/dbus.h>
#include "dbus/dbus-internals.h"
#include "dbus/dbus-marshal-recursive.h"
#include "dbus/dbus-message-private.h"
#include "dbus/dbus-string.h"
#include "dbus/dbus-test-tap.h"
#include "test-utils-glib.h"

typedef struct {
    const gchar *mode;
    TestMainContext *ctx;
    DBusConnection *left_conn;
    DBusConnection *right_conn;
    GPid daemon_pid;
    gchar *address;
    GQueue held_messages;
    gboolean skip;
} Fixture;

static DBusHandlerResult
hold_filter (DBusConnection *connection,
             DBusMessage *message,
             void *user_data)
{
  Fixture *f = user_data;

  if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

  g_queue_push_tail (&f->held_messages, dbus_message_ref (message));

  return DBUS_HANDLER_RESULT_HANDLED;
}

static void
setup_dbus_daemon (Fixture *f,
                   gconstpointer context G_GNUC_UNUSED)
{
  f->address = test_get_dbus_daemon (NULL, TEST_USER_ME, NULL, &f->daemon_pid);

  if (f->address == NULL)
    {
      f->skip = TRUE;
      return;
    }
}

static void
teardown_dbus_daemon (Fixture *f,
                      gconstpointer context G_GNUC_UNUSED)
{
  if (f->daemon_pid != 0)
    {
      test_kill_pid (f->daemon_pid);
      g_spawn_close_pid (f->daemon_pid);
      f->daemon_pid = 0;
    }

  g_clear_pointer (&f->address, g_free);
}

/* Offset to byte order from start of header */
#define BYTE_ORDER_OFFSET    0
/* Offset to version from start of header */
#define VERSION_OFFSET       3
/* Offset to fields array length from start of header, in protocol v1 */
#define FIELDS_ARRAY_LENGTH_OFFSET 12
/** Offset to first field in header, in protocol v1 */
#define FIRST_FIELD_OFFSET 16

/* Offset from start of _dbus_header_signature_str to the signature of
 * the fields array */
#define FIELDS_ARRAY_SIGNATURE_OFFSET 6

/* A byte that is not a DBUS_HEADER_FIELD_* */
#define NOT_A_HEADER_FIELD 123

_DBUS_STRING_DEFINE_STATIC(_dbus_header_signature_str, DBUS_HEADER_SIGNATURE);

static void
string_overwrite_n (DBusString *str,
                    int         start,
                    const void *bytes,
                    int         len)
{
  unsigned char *data = _dbus_string_get_udata_len (str, start, len);

  g_assert (data != NULL);
  memcpy (data, bytes, len);
}

static void
steal_reply_cb (DBusPendingCall *pc,
                void *data)
{
  DBusMessage **message_p = data;

  g_assert (message_p != NULL);
  g_assert (*message_p == NULL);
  *message_p = dbus_pending_call_steal_reply (pc);
  g_assert (*message_p != NULL);
}

/*
 * Test the handling of unknown header fields.
 *
 * Return TRUE if the right thing happens, but the right thing might include
 * OOM.
 */
static dbus_bool_t
test_weird_header_field (void        *user_data,
                         dbus_bool_t  have_memory)
{
  Fixture *f = user_data;
  const char *body = "hello";
  const char *new_body = NULL;
  DBusError error = DBUS_ERROR_INIT;
  DBusMessage *original = NULL;
  DBusMessage *modified = NULL;
  DBusMessage *filtered = NULL;
  DBusMessage *relayed = NULL;
  DBusMessage *reply = NULL;
  DBusPendingCall *pc = NULL;
  char *blob = NULL;
  int blob_len;
  DBusString modified_blob = _DBUS_STRING_INIT_INVALID;
  /* This is the serialization of a struct (uv), assumed to be at an
   * 8-byte boundary. */
  const unsigned char weird_header[8] = {
      NOT_A_HEADER_FIELD,   /*< type code */
      1,                    /*< length of signature */
      'u',                  /*< signature: uint32 */
      '\0',                 /*< end of signature */
      /* no padding required */
      '\x12',               /*< uint32 0x12345678 (BE) or 0x78563412 (LE) */
      '\x34',
      '\x56',
      '\x78'
  };
  int bytes_needed;
  DBusTypeReader reader;
  DBusTypeReader array;
  gboolean added_hold_filter = FALSE;
  GError *gerror = NULL;

  if (f->skip)
    return TRUE;

  /* We'd normally do this in setup_dbus_daemon(), but then we couldn't
   * allocate memory that we want freed by dbus_shutdown(). */
  g_assert_cmpint (_dbus_get_malloc_blocks_outstanding (), ==, 0);
  f->ctx = test_main_context_try_get ();

  if (f->ctx == NULL)
    {
      g_assert_false (have_memory);
      goto out;
    }

  f->left_conn = test_try_connect_to_bus (f->ctx, f->address, &gerror);

  if (f->left_conn == NULL)
    {
      g_assert_error (gerror, G_DBUS_ERROR, G_DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  f->right_conn = test_try_connect_to_bus (f->ctx, f->address, &gerror);

  if (f->right_conn == NULL)
    {
      g_assert_error (gerror, G_DBUS_ERROR, G_DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  if (!dbus_connection_add_filter (f->right_conn, hold_filter, f, NULL))
    {
      g_assert_false (have_memory);
      goto out;
    }

  added_hold_filter = TRUE;

  original = dbus_message_new_method_call (dbus_bus_get_unique_name (f->right_conn),
                                           "/com/example/Path",
                                           "com.example.Interface",
                                           "Method");

  if (original == NULL ||
      !dbus_message_append_args (original,
                                 DBUS_TYPE_STRING, &body,
                                 DBUS_TYPE_INVALID))
    {
      g_assert_false (have_memory);
      goto out;
    }

  /* Messages with serial number 0 can't be demarshalled. */
  dbus_message_set_serial (original, 42);

  if (!dbus_message_marshal (original, &blob, &blob_len))
    {
      g_assert_false (have_memory);
      goto out;
    }

  /* We will add up to 8 bytes, so preallocate that much. */
  if (!_dbus_string_init_preallocated (&modified_blob, blob_len + 8) ||
      !_dbus_string_append_len (&modified_blob, blob, blob_len))
    {
      g_assert_false (have_memory);
      goto out;
    }

  /* If these are false then we need to change our byte-twiddling */
  g_assert_cmpint (blob_len, >, FIRST_FIELD_OFFSET);
  g_assert_cmpint (blob[VERSION_OFFSET], ==, 1);
  g_assert_cmpint (blob[BYTE_ORDER_OFFSET], ==, DBUS_COMPILER_BYTE_ORDER);

  if (f->mode == NULL)
    {
      /* Do nothing: don't insert a weird header field at all */
    }
  else if (g_str_equal (f->mode, "change"))
    {
      /* Replace the interface (which is optional anyway) with the
       * weird header field */

      _dbus_type_reader_init (&reader, DBUS_COMPILER_BYTE_ORDER,
                              &_dbus_header_signature_str,
                              FIELDS_ARRAY_SIGNATURE_OFFSET,
                              &modified_blob,
                              FIELDS_ARRAY_LENGTH_OFFSET);
      _dbus_type_reader_recurse (&reader, &array);

      while (_dbus_type_reader_get_current_type (&array) !=
             DBUS_TYPE_INVALID)
        {
          DBusTypeReader sub;
          unsigned char field_code;

          _dbus_type_reader_recurse (&array, &sub);

          g_assert_cmpint (_dbus_type_reader_get_current_type (&sub),
                           ==, DBUS_TYPE_BYTE);
          _dbus_type_reader_read_basic (&sub, &field_code);

          if (field_code == DBUS_HEADER_FIELD_INTERFACE)
            {
              _dbus_string_set_byte (&modified_blob,
                                     _dbus_type_reader_get_value_pos (&sub),
                                     NOT_A_HEADER_FIELD);
              break;
            }

          _dbus_type_reader_next (&array);
        }
    }
  else if (g_str_equal (f->mode, "prepend"))
    {
      dbus_uint32_t header_fields_length;

      memcpy (&header_fields_length, &blob[FIELDS_ARRAY_LENGTH_OFFSET], 4);

      /* Insert a weird header field at the beginning of the fields
       * array. We do this by byte manipulation rather than by using a
       * DBusTypeReader, because we eventually want to get rid of the
       * counterintuitive ability for a DBusTypeReader to write to the
       * message: https://bugs.freedesktop.org/show_bug.cgi?id=38288 */
      if (!_dbus_string_insert_8_aligned (&modified_blob,
                                          FIRST_FIELD_OFFSET,
                                          weird_header))
        {
          g_assert_false (have_memory);
          goto out;
        }

      header_fields_length += 8;
      string_overwrite_n (&modified_blob, FIELDS_ARRAY_LENGTH_OFFSET,
                          &header_fields_length, 4);
    }
  else if (g_str_equal (f->mode, "append"))
    {
      dbus_uint32_t header_fields_length;

      memcpy (&header_fields_length, &blob[FIELDS_ARRAY_LENGTH_OFFSET], 4);

      /* Insert a weird header field at the end of the fields
       * array, after the padding (which was previously the padding between
       * header and body, and is now the padding between the last-but-one
       * header field and the new header field). For simplicity, we've
       * used a weird header field that does not ever need to be followed
       * by padding itself.
       *
       * Old:
       *  | 0   | 1   | 2   | 3   | 4   | 5   | 6   | 7    |
       *  | ... 16-byte fixed-length part ...              |
       *  | ... 16-byte fixed-length part ...              |
       * [A] first header field ...                        |
       *  | last header field    [B] padding              [C]
       * [C] body...
       *
       * New:
       *  | 0   | 1   | 2   | 3   | 4   | 5   | 6   | 7    |
       *  | ... 16-byte fixed-length part ...              |
       *  | ... 16-byte fixed-length part ...              |
       * [A] first header field ...                        |
       *  | previously-last field [B] padding             [C]
       *  | weird header field, exactly 8 bytes long    [B'=C']
       * [B'=C'] body...
       *
       */
      header_fields_length = _DBUS_ALIGN_VALUE (header_fields_length, 8);
      g_assert_cmpint (header_fields_length % 8, ==, 0);

      if (!_dbus_string_insert_8_aligned (&modified_blob,
                                          (FIRST_FIELD_OFFSET +
                                           header_fields_length),
                                          weird_header))
        {
          g_assert_false (have_memory);
          goto out;
        }

      header_fields_length += 8;
      string_overwrite_n (&modified_blob, FIELDS_ARRAY_LENGTH_OFFSET,
                          &header_fields_length, 4);
    }
  else
    {
      g_assert_not_reached ();
    }

  /* OK, now we've hacked up the message, compare it with the original. */
  bytes_needed = dbus_message_demarshal_bytes_needed (_dbus_string_get_const_data (&modified_blob),
                                                      _dbus_string_get_length (&modified_blob));

  if (f->mode == NULL || g_str_equal (f->mode, "change"))
    {
      /* We edited the message in-place so its effective length didn't
       * change */
      g_assert_cmpint (bytes_needed, ==, blob_len);
    }
  else
    {
      g_assert_cmpint (bytes_needed, ==, blob_len + 8);
    }

  g_assert_cmpint (_dbus_string_get_length (&modified_blob), ==,
                   bytes_needed);
  modified = dbus_message_demarshal (_dbus_string_get_const_data (&modified_blob),
                                     _dbus_string_get_length (&modified_blob),
                                     &error);

  if (modified == NULL)
    {
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  /* The modified message has the same fields, except possibly the
   * interface. */
  g_assert_cmpint (dbus_message_get_type (modified), ==,
                   dbus_message_get_type (original));
  g_assert_cmpstr (dbus_message_get_path (modified), ==,
                   dbus_message_get_path (original));
  g_assert_cmpstr (dbus_message_get_member (modified), ==,
                   dbus_message_get_member (original));
  g_assert_cmpstr (dbus_message_get_error_name (modified), ==,
                   dbus_message_get_error_name (original));
  g_assert_cmpstr (dbus_message_get_destination (modified), ==,
                   dbus_message_get_destination (original));
  g_assert_cmpstr (dbus_message_get_sender (modified), ==,
                   dbus_message_get_sender (original));
  g_assert_cmpstr (dbus_message_get_signature (modified), ==,
                   dbus_message_get_signature (original));
  g_assert_cmpint (dbus_message_get_no_reply (modified), ==,
                   dbus_message_get_no_reply (original));
  g_assert_cmpint (dbus_message_get_serial (modified), ==,
                   dbus_message_get_serial (original));
  g_assert_cmpint (dbus_message_get_reply_serial (modified), ==,
                   dbus_message_get_reply_serial (original));
  g_assert_cmpint (dbus_message_get_auto_start (modified), ==,
                   dbus_message_get_auto_start (original));
  g_assert_cmpint (dbus_message_get_allow_interactive_authorization (modified),
                   ==,
                   dbus_message_get_allow_interactive_authorization (original));

  if (dbus_message_get_args (modified, &error,
                             DBUS_TYPE_STRING, &new_body,
                             DBUS_TYPE_INVALID))
    {
      g_assert_cmpstr (new_body, ==, body);
    }
  else
    {
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  if (f->mode != NULL && g_str_equal (f->mode, "change"))
    {
      /* We edited the interface field in-place to turn it into the
       * unknown field, so it doesn't have an interface any more. */
      g_assert_cmpstr (dbus_message_get_interface (modified), ==, NULL);
    }
  else
    {
      /* We didn't change the interface. */
      g_assert_cmpstr (dbus_message_get_interface (modified), ==,
                       dbus_message_get_interface (original));
    }

  /* Copy the modified message so we can filter it. */
  filtered = dbus_message_demarshal (_dbus_string_get_const_data (&modified_blob),
                                     _dbus_string_get_length (&modified_blob),
                                     &error);

  if (filtered == NULL)
    {
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  /* TODO: Actually filter its header */

  /* All known headers are the same as in the modified message that was
   * deserialized from the same blob */
  g_assert_cmpint (dbus_message_get_type (filtered), ==,
                   dbus_message_get_type (modified));
  g_assert_cmpstr (dbus_message_get_path (filtered), ==,
                   dbus_message_get_path (modified));
  g_assert_cmpstr (dbus_message_get_member (filtered), ==,
                   dbus_message_get_member (modified));
  g_assert_cmpstr (dbus_message_get_error_name (filtered), ==,
                   dbus_message_get_error_name (modified));
  g_assert_cmpstr (dbus_message_get_destination (filtered), ==,
                   dbus_message_get_destination (modified));
  g_assert_cmpstr (dbus_message_get_sender (filtered), ==,
                   dbus_message_get_sender (modified));
  g_assert_cmpstr (dbus_message_get_signature (filtered), ==,
                   dbus_message_get_signature (modified));
  g_assert_cmpint (dbus_message_get_no_reply (filtered), ==,
                   dbus_message_get_no_reply (modified));
  g_assert_cmpint (dbus_message_get_serial (filtered), ==,
                   dbus_message_get_serial (modified));
  g_assert_cmpint (dbus_message_get_reply_serial (filtered), ==,
                   dbus_message_get_reply_serial (modified));
  g_assert_cmpint (dbus_message_get_auto_start (filtered), ==,
                   dbus_message_get_auto_start (modified));
  g_assert_cmpint (dbus_message_get_allow_interactive_authorization (modified),
                   ==,
                   dbus_message_get_allow_interactive_authorization (original));

  /* The body is also the same */
  if (dbus_message_get_args (filtered, &error,
                             DBUS_TYPE_STRING, &new_body,
                             DBUS_TYPE_INVALID))
    {
      g_assert_cmpstr (new_body, ==, body);
    }
  else
    {
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  /* We can't use _dbus_header_get_field_raw() because it asserts that
   * the field in question is in range. */
  _dbus_type_reader_init (&reader, DBUS_COMPILER_BYTE_ORDER,
                          &_dbus_header_signature_str,
                          FIELDS_ARRAY_SIGNATURE_OFFSET,
                          &filtered->header.data,
                          FIELDS_ARRAY_LENGTH_OFFSET);
  _dbus_type_reader_recurse (&reader, &array);

  while (_dbus_type_reader_get_current_type (&array) != DBUS_TYPE_INVALID)
    {
      DBusTypeReader sub;
      unsigned char field_code;

      _dbus_type_reader_recurse (&array, &sub);

      g_assert_cmpint (_dbus_type_reader_get_current_type (&sub),
                       ==, DBUS_TYPE_BYTE);
      _dbus_type_reader_read_basic (&sub, &field_code);

      if (field_code == NOT_A_HEADER_FIELD)
        {
          g_test_message ("TODO: header field was not filtered out");
        }

      _dbus_type_reader_next (&array);
    }

  /* Sending a message through the dbus-daemon currently preserves
   * unknown header fields, but it should not.
   * https://bugs.freedesktop.org/show_bug.cgi?id=100317 */

  /* We have to use send_with_reply because if we don't, we won't know
   * if the message was dropped on the floor due to out-of-memory. */
  if (!dbus_connection_send_with_reply (f->left_conn, modified, &pc, -1))
    {
      g_assert_false (have_memory);
      goto out;
    }

  if (dbus_pending_call_get_completed (pc))
    {
      steal_reply_cb (pc, &reply);
    }
  else if (!dbus_pending_call_set_notify (pc, steal_reply_cb, &reply, NULL))
    {
      dbus_pending_call_cancel (pc);
      g_assert_false (have_memory);
      goto out;
    }

  while (g_queue_get_length (&f->held_messages) < 1 && reply == NULL)
    test_main_context_iterate (f->ctx, TRUE);

  if (reply != NULL)
    {
      dbus_set_error_from_message (&error, reply);
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  relayed = g_queue_pop_head (&f->held_messages);
  g_assert_cmpint (g_queue_get_length (&f->held_messages), ==, 0);

  /* The message relayed through the dbus-daemon has the same known
   * fields and content as the one we sent, except that it has a sender
   * and a serial number. */
  g_assert_cmpint (dbus_message_get_type (relayed), ==,
                   dbus_message_get_type (modified));
  g_assert_cmpstr (dbus_message_get_path (relayed), ==,
                   dbus_message_get_path (modified));
  g_assert_cmpstr (dbus_message_get_member (relayed), ==,
                   dbus_message_get_member (modified));
  g_assert_cmpstr (dbus_message_get_error_name (relayed), ==,
                   dbus_message_get_error_name (modified));
  g_assert_cmpstr (dbus_message_get_destination (relayed), ==,
                   dbus_message_get_destination (modified));
  g_assert_cmpstr (dbus_message_get_sender (relayed), ==,
                   dbus_bus_get_unique_name (f->left_conn));
  g_assert_cmpstr (dbus_message_get_signature (relayed), ==,
                   dbus_message_get_signature (modified));
  g_assert_cmpint (dbus_message_get_no_reply (relayed), ==,
                   dbus_message_get_no_reply (modified));
  g_assert_cmpint (dbus_message_get_serial (relayed), !=, 0);
  g_assert_cmpint (dbus_message_get_reply_serial (relayed), ==,
                   dbus_message_get_reply_serial (modified));
  g_assert_cmpint (dbus_message_get_auto_start (relayed), ==,
                   dbus_message_get_auto_start (modified));
  g_assert_cmpint (dbus_message_get_allow_interactive_authorization (modified),
                   ==,
                   dbus_message_get_allow_interactive_authorization (original));

  if (dbus_message_get_args (relayed, &error,
                             DBUS_TYPE_STRING, &new_body,
                             DBUS_TYPE_INVALID))
    {
      g_assert_cmpstr (new_body, ==, body);
    }
  else
    {
      g_assert_cmpstr (error.name, ==, DBUS_ERROR_NO_MEMORY);
      g_assert_false (have_memory);
      goto out;
    }

  _dbus_type_reader_init (&reader, DBUS_COMPILER_BYTE_ORDER,
                          &_dbus_header_signature_str,
                          FIELDS_ARRAY_SIGNATURE_OFFSET,
                          &relayed->header.data,
                          FIELDS_ARRAY_LENGTH_OFFSET);
  _dbus_type_reader_recurse (&reader, &array);

  while (_dbus_type_reader_get_current_type (&array) != DBUS_TYPE_INVALID)
    {
      DBusTypeReader sub;
      unsigned char field_code;

      _dbus_type_reader_recurse (&array, &sub);

      g_assert_cmpint (_dbus_type_reader_get_current_type (&sub),
                       ==, DBUS_TYPE_BYTE);
      _dbus_type_reader_read_basic (&sub, &field_code);

      if (field_code == NOT_A_HEADER_FIELD)
        {
          g_test_message ("TODO: header field was passed through");
        }

      _dbus_type_reader_next (&array);
    }

  /* On success, we don't actually reply: it's one more thing that
   * could hit OOM */

out:
  g_clear_error (&gerror);
  _dbus_string_free (&modified_blob);
  dbus_free (blob);

  if (pc != NULL)
    dbus_pending_call_cancel (pc);

  dbus_clear_pending_call (&pc);
  dbus_clear_message (&reply);
  dbus_clear_message (&relayed);
  dbus_clear_message (&filtered);
  dbus_clear_message (&modified);
  dbus_clear_message (&original);
  dbus_error_free (&error);

  /* We'd normally do this in teardown_dbus_daemon(), but for this test
   * we want to do it here so we can dbus_shutdown(). */
  if (f->left_conn != NULL)
    {
      dbus_connection_close (f->left_conn);
      test_connection_shutdown (f->ctx, f->left_conn);
    }

  if (f->right_conn != NULL)
    {
      if (added_hold_filter)
        dbus_connection_remove_filter (f->right_conn, hold_filter, f);

      g_queue_foreach (&f->held_messages, (GFunc) dbus_message_unref, NULL);
      g_queue_clear (&f->held_messages);

      dbus_connection_close (f->right_conn);
      test_connection_shutdown (f->ctx, f->right_conn);
    }

  dbus_clear_connection (&f->left_conn);
  dbus_clear_connection (&f->right_conn);
  g_clear_pointer (&f->ctx, test_main_context_unref);

  dbus_shutdown ();
  g_assert_cmpint (_dbus_get_malloc_blocks_outstanding (), ==, 0);

  return !g_test_failed ();
}

typedef struct
{
  const gchar *name;
  DBusTestMemoryFunction function;
  const gchar *mode;
} OOMTestCase;

static void
test_oom_wrapper (Fixture *f,
                  gconstpointer data)
{
  const OOMTestCase *test = data;

  f->mode = test->mode;

  if (g_test_slow ())
    {
      /* When we say slow, we mean it. */
      test_timeout_reset (30);
    }
  else
    {
      test_timeout_reset (1);
    }

  if (!_dbus_test_oom_handling (test->name, test->function, f))
    {
      g_test_message ("OOM test failed");
      g_test_fail ();
    }
}

static GQueue *test_cases_to_free = NULL;

static void
add_oom_test (const gchar *name,
              DBusTestMemoryFunction function,
              const gchar *mode)
{
  /* By using GLib memory allocation here, we avoid being affected by
   * dbus_shutdown() or contributing to
   * _dbus_get_malloc_blocks_outstanding() */
  OOMTestCase *test_case = g_new0 (OOMTestCase, 1);

  test_case->name = name;
  test_case->function = function;
  test_case->mode = mode;
  g_test_add (name, Fixture, test_case, setup_dbus_daemon,
              test_oom_wrapper, teardown_dbus_daemon);
  g_queue_push_tail (test_cases_to_free, test_case);
}

int
main (int argc,
      char **argv)
{
  int ret;

  test_init (&argc, &argv);

  /* Normally we test up to 4 consecutive malloc failures, but that's
   * painfully slow here. */
  if (g_getenv ("DBUS_TEST_MALLOC_FAILURES") == NULL)
    {
      if (!g_test_slow ())
        g_setenv ("DBUS_TEST_MALLOC_FAILURES", "2", TRUE);
    }

  test_cases_to_free = g_queue_new ();
  add_oom_test ("/message/weird-header-field/none", test_weird_header_field,
                NULL);
  add_oom_test ("/message/weird-header-field/append", test_weird_header_field,
                "append");
  add_oom_test ("/message/weird-header-field/change", test_weird_header_field,
                "change");
  add_oom_test ("/message/weird-header-field/prepend", test_weird_header_field,
                "prepend");

  ret = g_test_run ();

  g_queue_free_full (test_cases_to_free, g_free);
  return ret;
}