gio/tests/gdbus-close-pending.c

   1 /* GDBus regression test - close a stream when a message remains to be written
   2  *
   3  * Copyright © 2006-2010 Red Hat, Inc.
   4  * Copyright © 2011 Nokia Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  * Author: Simon McVittie <simon.mcvittie@collabora.co.uk>
  20  */
  21
  22 #include <config.h>
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include <gio/gio.h>
  28
  29 #ifdef G_OS_UNIX
  30 # include <unistd.h>
  31
  32 # include <glib/glib-unix.h>
  33 # include <gio/gunixinputstream.h>
  34 # include <gio/gunixoutputstream.h>
  35 # include <gio/gunixconnection.h>
  36 #else
  37 # error This test is currently Unix-specific due to use of g_unix_open_pipe()
  38 #endif
  39
  40 #include "gdbus-tests.h"
  41
  42 #define CLOSE_TIME_MS 1
  43 #define N_REPEATS_SLOW 5000
  44 #define N_REPEATS 100
  45
  46 /* ---------- MyIOStream ------------------------------------------------- */
  47
  48 #define MY_TYPE_IO_STREAM  (my_io_stream_get_type ())
  49 #define MY_IO_STREAM(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), MY_TYPE_IO_STREAM, MyIOStream))
  50 #define MY_IS_IO_STREAM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MY_TYPE_IO_STREAM))
  51
  52 typedef struct
  53 {
  54   GIOStream parent_instance;
  55   GInputStream *input_stream;
  56   GOutputStream *output_stream;
  57 } MyIOStream;
  58
  59 typedef struct
  60 {
  61   GIOStreamClass parent_class;
  62 } MyIOStreamClass;
  63
  64 static GType my_io_stream_get_type (void) G_GNUC_CONST;
  65
  66 G_DEFINE_TYPE (MyIOStream, my_io_stream, G_TYPE_IO_STREAM)
  67
  68 static void
  69 my_io_stream_finalize (GObject *object)
  70 {
  71   MyIOStream *stream = MY_IO_STREAM (object);
  72   g_object_unref (stream->input_stream);
  73   g_object_unref (stream->output_stream);
  74   G_OBJECT_CLASS (my_io_stream_parent_class)->finalize (object);
  75 }
  76
  77 static void
  78 my_io_stream_init (MyIOStream *stream)
  79 {
  80 }
  81
  82 static GInputStream *
  83 my_io_stream_get_input_stream (GIOStream *_stream)
  84 {
  85   MyIOStream *stream = MY_IO_STREAM (_stream);
  86   return stream->input_stream;
  87 }
  88
  89 static GOutputStream *
  90 my_io_stream_get_output_stream (GIOStream *_stream)
  91 {
  92   MyIOStream *stream = MY_IO_STREAM (_stream);
  93   return stream->output_stream;
  94 }
  95
  96 static void
  97 my_io_stream_class_init (MyIOStreamClass *klass)
  98 {
  99   GObjectClass *gobject_class;
 100   GIOStreamClass *giostream_class;
 101
 102   gobject_class = G_OBJECT_CLASS (klass);
 103   gobject_class->finalize = my_io_stream_finalize;
 104
 105   giostream_class = G_IO_STREAM_CLASS (klass);
 106   giostream_class->get_input_stream  = my_io_stream_get_input_stream;
 107   giostream_class->get_output_stream = my_io_stream_get_output_stream;
 108 }
 109
 110 static GIOStream *
 111 my_io_stream_new (GInputStream  *input_stream,
 112                   GOutputStream *output_stream)
 113 {
 114   MyIOStream *stream;
 115   g_return_val_if_fail (G_IS_INPUT_STREAM (input_stream), NULL);
 116   g_return_val_if_fail (G_IS_OUTPUT_STREAM (output_stream), NULL);
 117   stream = MY_IO_STREAM (g_object_new (MY_TYPE_IO_STREAM, NULL));
 118   stream->input_stream = g_object_ref (input_stream);
 119   stream->output_stream = g_object_ref (output_stream);
 120   return G_IO_STREAM (stream);
 121 }
 122
 123 /* ---------- MySlowCloseOutputStream ------------------------------------ */
 124
 125 typedef struct
 126 {
 127   GFilterOutputStream parent_instance;
 128 } MySlowCloseOutputStream;
 129
 130 typedef struct
 131 {
 132   GFilterOutputStreamClass parent_class;
 133 } MySlowCloseOutputStreamClass;
 134
 135 #define MY_TYPE_SLOW_CLOSE_OUTPUT_STREAM \
 136   (my_slow_close_output_stream_get_type ())
 137 #define MY_OUTPUT_STREAM(o) \
 138   (G_TYPE_CHECK_INSTANCE_CAST ((o), MY_TYPE_SLOW_CLOSE_OUTPUT_STREAM, \
 139                                MySlowCloseOutputStream))
 140 #define MY_IS_SLOW_CLOSE_OUTPUT_STREAM(o) \
 141   (G_TYPE_CHECK_INSTANCE_TYPE ((o), MY_TYPE_SLOW_CLOSE_OUTPUT_STREAM))
 142
 143 static GType my_slow_close_output_stream_get_type (void) G_GNUC_CONST;
 144
 145 G_DEFINE_TYPE (MySlowCloseOutputStream, my_slow_close_output_stream,
 146                G_TYPE_FILTER_OUTPUT_STREAM)
 147
 148 static void
 149 my_slow_close_output_stream_init (MySlowCloseOutputStream *stream)
 150 {
 151 }
 152
 153 static gboolean
 154 my_slow_close_output_stream_close (GOutputStream  *stream,
 155                                    GCancellable   *cancellable,
 156                                    GError        **error)
 157 {
 158   g_usleep (CLOSE_TIME_MS * 1000);
 159   return G_OUTPUT_STREAM_CLASS (my_slow_close_output_stream_parent_class)->
 160     close_fn (stream, cancellable, error);
 161 }
 162
 163 typedef struct {
 164     GOutputStream *stream;
 165     gint io_priority;
 166     GCancellable *cancellable;
 167     GAsyncReadyCallback callback;
 168     gpointer user_data;
 169 } DelayedClose;
 170
 171 static void
 172 delayed_close_free (gpointer data)
 173 {
 174   DelayedClose *df = data;
 175
 176   g_object_unref (df->stream);
 177   g_object_unref (df->cancellable);
 178   g_free (df);
 179 }
 180
 181 static gboolean
 182 delayed_close_cb (gpointer data)
 183 {
 184   DelayedClose *df = data;
 185
 186   G_OUTPUT_STREAM_CLASS (my_slow_close_output_stream_parent_class)->
 187     close_async (df->stream, df->io_priority, df->cancellable, df->callback,
 188                  df->user_data);
 189
 190   return FALSE;
 191 }
 192
 193 static void
 194 my_slow_close_output_stream_close_async  (GOutputStream            *stream,
 195                                           int                       io_priority,
 196                                           GCancellable             *cancellable,
 197                                           GAsyncReadyCallback       callback,
 198                                           gpointer                  user_data)
 199 {
 200   GSource *later;
 201   DelayedClose *df;
 202
 203   df = g_new0 (DelayedClose, 1);
 204   df->stream = g_object_ref (stream);
 205   df->io_priority = io_priority;
 206   df->cancellable = (cancellable != NULL ? g_object_ref (cancellable) : NULL);
 207   df->callback = callback;
 208   df->user_data = user_data;
 209
 210   later = g_timeout_source_new (CLOSE_TIME_MS);
 211   g_source_set_callback (later, delayed_close_cb, df, delayed_close_free);
 212   g_source_attach (later, g_main_context_get_thread_default ());
 213 }
 214
 215 static gboolean
 216 my_slow_close_output_stream_close_finish  (GOutputStream  *stream,
 217                                 GAsyncResult   *result,
 218                                 GError        **error)
 219 {
 220   return G_OUTPUT_STREAM_CLASS (my_slow_close_output_stream_parent_class)->
 221     close_finish (stream, result, error);
 222 }
 223
 224 static void
 225 my_slow_close_output_stream_class_init (MySlowCloseOutputStreamClass *klass)
 226 {
 227   GOutputStreamClass *ostream_class;
 228
 229   ostream_class = G_OUTPUT_STREAM_CLASS (klass);
 230   ostream_class->close_fn = my_slow_close_output_stream_close;
 231   ostream_class->close_async = my_slow_close_output_stream_close_async;
 232   ostream_class->close_finish = my_slow_close_output_stream_close_finish;
 233 }
 234
 235 static GIOStream *
 236 my_io_stream_new_for_fds (gint fd_in, gint fd_out)
 237 {
 238   GIOStream *stream;
 239   GInputStream *input_stream;
 240   GOutputStream *real_output_stream;
 241   GOutputStream *output_stream;
 242
 243   input_stream = g_unix_input_stream_new (fd_in, TRUE);
 244   real_output_stream = g_unix_output_stream_new (fd_out, TRUE);
 245   output_stream = g_object_new (MY_TYPE_SLOW_CLOSE_OUTPUT_STREAM,
 246                                 "base-stream", real_output_stream,
 247                                 NULL);
 248   stream = my_io_stream_new (input_stream, output_stream);
 249   g_object_unref (input_stream);
 250   g_object_unref (output_stream);
 251   g_object_unref (real_output_stream);
 252   return stream;
 253 }
 254
 255 /* ---------- Tests ------------------------------------------------------ */
 256
 257 typedef struct {
 258   gint server_to_client[2];
 259   gint client_to_server[2];
 260   GIOStream *server_iostream;
 261   GDBusConnection *server_conn;
 262   GIOStream *iostream;
 263   GDBusConnection *connection;
 264   gchar *guid;
 265   GError *error;
 266 } Fixture;
 267
 268 static void
 269 setup (Fixture       *f,
 270        gconstpointer  context)
 271 {
 272   f->guid = g_dbus_generate_guid ();
 273 }
 274
 275 static void
 276 teardown (Fixture       *f,
 277           gconstpointer  context)
 278 {
 279   g_clear_object (&f->server_iostream);
 280   g_clear_object (&f->server_conn);
 281   g_clear_object (&f->iostream);
 282   g_clear_object (&f->connection);
 283   g_clear_error (&f->error);
 284   g_free (f->guid);
 285 }
 286
 287 static void
 288 on_new_conn (GObject      *source,
 289              GAsyncResult *res,
 290              gpointer      user_data)
 291 {
 292   GDBusConnection **connection = user_data;
 293   GError *error = NULL;
 294
 295   *connection = g_dbus_connection_new_for_address_finish (res, &error);
 296   g_assert_no_error (error);
 297 }
 298
 299 static void
 300 test_once (Fixture       *f,
 301            gconstpointer  context)
 302 {
 303   GDBusMessage *message;
 304   gboolean pipe_res;
 305
 306   pipe_res = g_unix_open_pipe (f->server_to_client, FD_CLOEXEC, &f->error);
 307   g_assert (pipe_res);
 308   pipe_res = g_unix_open_pipe (f->client_to_server, FD_CLOEXEC, &f->error);
 309   g_assert (pipe_res);
 310
 311   f->server_iostream = my_io_stream_new_for_fds (f->client_to_server[0],
 312                                                  f->server_to_client[1]);
 313   f->iostream = my_io_stream_new_for_fds (f->server_to_client[0],
 314                                           f->client_to_server[1]);
 315
 316   g_dbus_connection_new (f->server_iostream,
 317                          f->guid,
 318                          (G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER |
 319                           G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS),
 320                          NULL /* auth observer */,
 321                          NULL /* cancellable */,
 322                          on_new_conn, &f->server_conn);
 323
 324   g_dbus_connection_new (f->iostream,
 325                          NULL,
 326                          G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 327                          NULL /* auth observer */,
 328                          NULL /* cancellable */,
 329                          on_new_conn, &f->connection);
 330
 331   while (f->server_conn == NULL || f->connection == NULL)
 332     g_main_context_iteration (NULL, TRUE);
 333
 334   /*
 335    * queue a message - it'll sometimes be sent while the close is pending,
 336    * triggering the bug
 337    */
 338   message = g_dbus_message_new_signal ("/", "com.example.Foo", "Bar");
 339   g_dbus_connection_send_message (f->connection, message, 0, NULL, &f->error);
 340   g_assert_no_error (f->error);
 341   g_object_unref (message);
 342
 343   /* close the connection (deliberately or via last-unref) */
 344   if (g_strcmp0 (context, "unref") == 0)
 345     {
 346       g_clear_object (&f->connection);
 347     }
 348   else
 349     {
 350       g_dbus_connection_close_sync (f->connection, NULL, &f->error);
 351       g_assert_no_error (f->error);
 352     }
 353
 354   /* either way, wait for the connection to close */
 355   while (!g_dbus_connection_is_closed (f->server_conn))
 356     g_main_context_iteration (NULL, TRUE);
 357
 358   /* clean up before the next run */
 359   g_clear_object (&f->iostream);
 360   g_clear_object (&f->server_iostream);
 361   g_clear_object (&f->connection);
 362   g_clear_object (&f->server_conn);
 363   g_clear_error (&f->error);
 364 }
 365
 366 static void
 367 test_many_times (Fixture       *f,
 368                  gconstpointer  context)
 369 {
 370   guint i, n_repeats;
 371
 372   if (g_test_slow ())
 373     n_repeats = N_REPEATS_SLOW;
 374   else
 375     n_repeats = N_REPEATS;
 376
 377   for (i = 0; i < n_repeats; i++)
 378     test_once (f, context);
 379 }
 380
 381 int
 382 main (int   argc,
 383       char *argv[])
 384 {
 385   g_test_init (&argc, &argv, NULL);
 386
 387   g_test_add ("/gdbus/close-pending", Fixture, "close",
 388       setup, test_many_times, teardown);
 389   g_test_add ("/gdbus/unref-pending", Fixture, "unref",
 390       setup, test_many_times, teardown);
 391
 392   return g_test_run();
 393 }