glib/gio/tests/gdbus-method-invocation.c

/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright © 2022 Endless OS Foundation, LLC
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include <gio/gio.h>
#include <gio/gunixfdlist.h>
#include <string.h>
#include <unistd.h>

#include "gdbus-tests.h"

static const GDBusArgInfo foo_get_fds_in_args =
{
  -1,
  "type",
  "s",
  NULL
};
static const GDBusArgInfo * const foo_get_fds_in_arg_pointers[] = {&foo_get_fds_in_args, NULL};

static const GDBusArgInfo foo_get_fds_out_args =
{
  -1,
  "some_fd",
  "h",
  NULL
};
static const GDBusArgInfo * const foo_get_fds_out_arg_pointers[] = {&foo_get_fds_out_args, NULL};

static const GDBusMethodInfo foo_method_info_wrong_return_type =
{
  -1,
  "WrongReturnType",
  NULL,  /* in args */
  NULL,  /* out args */
  NULL  /* annotations */
};
static const GDBusMethodInfo foo_method_info_close_before_returning =
{
  -1,
  "CloseBeforeReturning",
  NULL,  /* in args */
  NULL,  /* out args */
  NULL  /* annotations */
};
static const GDBusMethodInfo foo_method_info_get_fds =
{
  -1,
  "GetFDs",
  (GDBusArgInfo **) foo_get_fds_in_arg_pointers,
  (GDBusArgInfo **) foo_get_fds_out_arg_pointers,
  NULL  /* annotations */
};
static const GDBusMethodInfo foo_method_info_return_error =
{
  -1,
  "ReturnError",
  NULL,  /* in args */
  NULL,  /* out args */
  NULL  /* annotations */
};
static const GDBusMethodInfo * const foo_method_info_pointers[] = {
  &foo_method_info_wrong_return_type,
  &foo_method_info_close_before_returning,
  &foo_method_info_get_fds,
  &foo_method_info_return_error,
  NULL
};

static const GDBusPropertyInfo foo_property_info[] =
{
  {
    -1,
    "InvalidType",
    "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE,
    NULL
  },
  {
    -1,
    "InvalidTypeNull",
    "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE,
    NULL
  },
  {
    -1,
    "InvalidValueType",
    "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE,
    NULL
  },
};
static const GDBusPropertyInfo * const foo_property_info_pointers[] =
{
  &foo_property_info[0],
  &foo_property_info[1],
  &foo_property_info[2],
  NULL
};

static const GDBusInterfaceInfo foo_interface_info =
{
  -1,
  "org.example.Foo",
  (GDBusMethodInfo **) &foo_method_info_pointers,
  NULL,  /* signals */
  (GDBusPropertyInfo **) &foo_property_info_pointers,
  NULL,  /* annotations */
};

/* ---------------------------------------------------------------------------------------------------- */

static void
test_method_invocation_return_method_call (GDBusConnection       *connection,
                                           const gchar           *sender,
                                           const gchar           *object_path,
                                           const gchar           *interface_name,
                                           const gchar           *method_name,
                                           GVariant              *parameters,
                                           GDBusMethodInvocation *invocation,
                                           gpointer               user_data)
{
  gboolean no_reply = g_dbus_message_get_flags (g_dbus_method_invocation_get_message (invocation)) & G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;

  if (g_str_equal (interface_name, "org.freedesktop.DBus.Properties") &&
      g_str_equal (method_name, "Get"))
    {
      const gchar *iface_name, *prop_name;

      g_variant_get (parameters, "(&s&s)", &iface_name, &prop_name);
      g_assert_cmpstr (iface_name, ==, "org.example.Foo");

      /* Do different things depending on the property name. */
      if (g_str_equal (prop_name, "InvalidType"))
        {
          if (!no_reply)
            g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                                   "Type of return value for property 'Get' call should be '(v)' but got '(s)'");
          g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", "this type is invalid"));
        }
      else if (g_str_equal (prop_name, "InvalidTypeNull"))
        {
          if (!no_reply)
            g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                                   "Type of return value for property 'Get' call should be '(v)' but got '()'");
          g_dbus_method_invocation_return_value (invocation, NULL);
        }
      else if (g_str_equal (prop_name, "InvalidValueType"))
        {
          if (!no_reply)
            g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                                   "Value returned from property 'Get' call for 'InvalidValueType' should be 's' but is 'u'");
          g_dbus_method_invocation_return_value (invocation, g_variant_new ("(v)", g_variant_new_uint32 (123)));
        }
      else
        {
          g_assert_not_reached ();
        }

      g_test_assert_expected_messages ();
    }
  else if (g_str_equal (interface_name, "org.freedesktop.DBus.Properties") &&
           g_str_equal (method_name, "Set"))
    {
      const gchar *iface_name, *prop_name;
      GVariant *value;

      g_variant_get (parameters, "(&s&sv)", &iface_name, &prop_name, &value);
      g_assert_cmpstr (iface_name, ==, "org.example.Foo");

      if (g_str_equal (prop_name, "InvalidType"))
        {
          if (!no_reply)
            g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                                   "Type of return value for property 'Set' call should be '()' but got '(s)'");
          g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", "should be unit"));
        }
      else
        {
          g_assert_not_reached ();
        }

      g_test_assert_expected_messages ();
      g_variant_unref (value);
    }
  else if (g_str_equal (interface_name, "org.freedesktop.DBus.Properties") &&
           g_str_equal (method_name, "GetAll"))
    {
      const gchar *iface_name;

      g_variant_get (parameters, "(&s)", &iface_name);
      g_assert_cmpstr (iface_name, ==, "org.example.Foo");

      if (!no_reply)
        g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                               "Type of return value for property 'GetAll' call should be '(a{sv})' but got '(s)'");
      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", "should be a different type"));
    }
  else if (g_str_equal (interface_name, "org.example.Foo") &&
           g_str_equal (method_name, "WrongReturnType"))
    {
      if (!no_reply)
        g_test_expect_message ("GLib-GIO", G_LOG_LEVEL_WARNING,
                               "Type of return value is incorrect: expected '()', got '(s)'");
      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", "should be a different type"));
    }
  else if (g_str_equal (interface_name, "org.example.Foo") &&
           g_str_equal (method_name, "CloseBeforeReturning"))
    {
      g_dbus_connection_close (connection, NULL, NULL, NULL);

      g_dbus_method_invocation_return_value (invocation, NULL);
    }
  else if (g_str_equal (interface_name, "org.example.Foo") &&
           g_str_equal (method_name, "GetFDs"))
    {
      const gchar *action;
      GUnixFDList *list = NULL;
      GError *local_error = NULL;

      g_variant_get (parameters, "(&s)", &action);

      list = g_unix_fd_list_new ();
      g_unix_fd_list_append (list, 1, &local_error);
      g_assert_no_error (local_error);

      if (g_str_equal (action, "WrongNumber"))
        {
          g_unix_fd_list_append (list, 1, &local_error);
          g_assert_no_error (local_error);
        }

      if (g_str_equal (action, "Valid") ||
          g_str_equal (action, "WrongNumber"))
        g_dbus_method_invocation_return_value_with_unix_fd_list (invocation, g_variant_new ("(h)"), list);
      else
        g_assert_not_reached ();

      g_object_unref (list);
    }
  else if (g_str_equal (interface_name, "org.example.Foo") &&
           g_str_equal (method_name, "ReturnError"))
    {
      g_dbus_method_invocation_return_dbus_error (invocation, "org.example.Foo", "SomeError");
    }
  else
    g_assert_not_reached ();
}

static void
ensure_result_cb (GObject      *source,
                  GAsyncResult *result,
                  gpointer      user_data)
{
  GDBusConnection *connection = G_DBUS_CONNECTION (source);
  GVariant *reply;
  guint *n_outstanding_calls = user_data;

  reply = g_dbus_connection_call_finish (connection, result, NULL);

  /* We don’t care what the reply is. */
  g_clear_pointer (&reply, g_variant_unref);

  g_assert_cmpint (*n_outstanding_calls, >, 0);
  *n_outstanding_calls = *n_outstanding_calls - 1;
}

static void
test_method_invocation_return (void)
{
  GDBusConnection *connection = NULL;
  GError *local_error = NULL;
  guint registration_id;
  const GDBusInterfaceVTable vtable = {
    test_method_invocation_return_method_call, NULL, NULL, { 0 }
  };
  guint n_outstanding_calls = 0;

  g_test_summary ("Test calling g_dbus_method_invocation_return_*() in various ways");

  /* Connect to the bus. */
  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &local_error);
  g_assert_no_error (local_error);
  g_assert_nonnull (connection);

  /* Register an object which we can call methods on. */
  registration_id = g_dbus_connection_register_object (connection,
                                                       "/foo",
                                                       (GDBusInterfaceInfo *) &foo_interface_info,
                                                       &vtable, NULL, NULL, &local_error);
  g_assert_no_error (local_error);
  g_assert_cmpint (registration_id, !=, 0);

  /* Test a variety of error cases */
    {
      const struct
        {
          const gchar *interface_name;
          const gchar *method_name;
          const gchar *parameters_string;
          gboolean tests_undefined_behaviour;
        }
      calls[] =
        {
          { "org.freedesktop.DBus.Properties", "Get", "('org.example.Foo', 'InvalidType')", TRUE },
          { "org.freedesktop.DBus.Properties", "Get", "('org.example.Foo', 'InvalidTypeNull')", TRUE },
          { "org.freedesktop.DBus.Properties", "Get", "('org.example.Foo', 'InvalidValueType')", TRUE },
          { "org.freedesktop.DBus.Properties", "Set", "('org.example.Foo', 'InvalidType', <'irrelevant'>)", TRUE },
          { "org.freedesktop.DBus.Properties", "GetAll", "('org.example.Foo',)", TRUE },
          { "org.example.Foo", "WrongReturnType", "()", TRUE },
          { "org.example.Foo", "GetFDs", "('Valid',)", FALSE },
          { "org.example.Foo", "GetFDs", "('WrongNumber',)", TRUE },
          { "org.example.Foo", "ReturnError", "()", FALSE },
          { "org.example.Foo", "CloseBeforeReturning", "()", FALSE },
        };
      gsize i;

      for (i = 0; i < G_N_ELEMENTS (calls); i++)
        {
          if (calls[i].tests_undefined_behaviour && !g_test_undefined ())
            {
              g_test_message ("Skipping %s.%s", calls[i].interface_name, calls[i].method_name);
              continue;
            }
          else
            {
              g_test_message ("Calling %s.%s", calls[i].interface_name, calls[i].method_name);
            }

          /* Call twice, once expecting a result and once not. Do the call which
           * doesn’t expect a result first; message ordering should ensure that
           * it’s completed by the time the second call completes, so we don’t
           * have to account for it separately.
           *
           * That’s good, because the only way to get g_dbus_connection_call()
           * to set %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED is to not provide
           * a callback function. */
          n_outstanding_calls++;

          g_dbus_connection_call (connection,
                                  g_dbus_connection_get_unique_name (connection),
                                  "/foo",
                                  calls[i].interface_name,
                                  calls[i].method_name,
                                  g_variant_new_parsed (calls[i].parameters_string),
                                  NULL,
                                  G_DBUS_CALL_FLAGS_NONE,
                                  -1,
                                  NULL,
                                  NULL,  /* no callback */
                                  NULL);

          g_dbus_connection_call (connection,
                                  g_dbus_connection_get_unique_name (connection),
                                  "/foo",
                                  calls[i].interface_name,
                                  calls[i].method_name,
                                  g_variant_new_parsed (calls[i].parameters_string),
                                  NULL,
                                  G_DBUS_CALL_FLAGS_NONE,
                                  -1,
                                  NULL,
                                  ensure_result_cb,
                                  &n_outstanding_calls);
        }
    }

  /* Wait until all the calls are complete. */
  while (n_outstanding_calls > 0)
    g_main_context_iteration (NULL, TRUE);

  g_dbus_connection_unregister_object (connection, registration_id);
  g_object_unref (connection);
}

int
main (int   argc,
      char *argv[])
{
  g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);

  g_test_add_func ("/gdbus/method-invocation/return", test_method_invocation_return);

  return session_bus_run ();
}