more distcheck fixes
[platform/upstream/glib.git] / gio / giostream.c
1 /* GIO - GLib Input, Output and Streaming Library
2  *
3  * Copyright © 2008 codethink
4  * Copyright © 2009 Red Hat, Inc.
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, write to the
18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19  * Boston, MA 02111-1307, USA.
20  *
21  * Authors: Ryan Lortie <desrt@desrt.ca>
22  *          Alexander Larsson <alexl@redhat.com>
23  */
24
25 #include "config.h"
26 #include <glib.h>
27 #include "glibintl.h"
28
29 #include "giostream.h"
30 #include "gasyncresult.h"
31 #include "gtask.h"
32
33 /**
34  * SECTION:giostream
35  * @short_description: Base class for implementing read/write streams
36  * @include: gio/gio.h
37  * @see_also: #GInputStream, #GOutputStream
38  *
39  * GIOStream represents an object that has both read and write streams.
40  * Generally the two streams acts as separate input and output streams,
41  * but they share some common resources and state. For instance, for
42  * seekable streams they may use the same position in both streams.
43  *
44  * Examples of #GIOStream objects are #GSocketConnection which represents
45  * a two-way network connection, and #GFileIOStream which represent a
46  * file handle opened in read-write mode.
47  *
48  * To do the actual reading and writing you need to get the substreams
49  * with g_io_stream_get_input_stream() and g_io_stream_get_output_stream().
50  *
51  * The #GIOStream object owns the input and the output streams, not the other
52  * way around, so keeping the substreams alive will not keep the #GIOStream
53  * object alive. If the #GIOStream object is freed it will be closed, thus
54  * closing the substream, so even if the substreams stay alive they will
55  * always just return a %G_IO_ERROR_CLOSED for all operations.
56  *
57  * To close a stream use g_io_stream_close() which will close the common
58  * stream object and also the individual substreams. You can also close
59  * the substreams themselves. In most cases this only marks the
60  * substream as closed, so further I/O on it fails. However, some streams
61  * may support "half-closed" states where one direction of the stream
62  * is actually shut down.
63  *
64  * Since: 2.22
65  */
66
67 enum
68 {
69   PROP_0,
70   PROP_INPUT_STREAM,
71   PROP_OUTPUT_STREAM,
72   PROP_CLOSED
73 };
74
75 struct _GIOStreamPrivate {
76   guint closed : 1;
77   guint pending : 1;
78   GAsyncReadyCallback outstanding_callback;
79 };
80
81 static gboolean g_io_stream_real_close        (GIOStream            *stream,
82                                                GCancellable         *cancellable,
83                                                GError              **error);
84 static void     g_io_stream_real_close_async  (GIOStream            *stream,
85                                                int                   io_priority,
86                                                GCancellable         *cancellable,
87                                                GAsyncReadyCallback   callback,
88                                                gpointer              user_data);
89 static gboolean g_io_stream_real_close_finish (GIOStream            *stream,
90                                                GAsyncResult         *result,
91                                                GError              **error);
92
93 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GIOStream, g_io_stream, G_TYPE_OBJECT)
94
95 static void
96 g_io_stream_dispose (GObject *object)
97 {
98   GIOStream *stream;
99
100   stream = G_IO_STREAM (object);
101
102   if (!stream->priv->closed)
103     g_io_stream_close (stream, NULL, NULL);
104
105   G_OBJECT_CLASS (g_io_stream_parent_class)->dispose (object);
106 }
107
108 static void
109 g_io_stream_init (GIOStream *stream)
110 {
111   stream->priv = g_io_stream_get_instance_private (stream);
112 }
113
114 static void
115 g_io_stream_get_property (GObject    *object,
116                           guint       prop_id,
117                           GValue     *value,
118                           GParamSpec *pspec)
119 {
120   GIOStream *stream = G_IO_STREAM (object);
121
122   switch (prop_id)
123     {
124       case PROP_CLOSED:
125         g_value_set_boolean (value, stream->priv->closed);
126         break;
127
128       case PROP_INPUT_STREAM:
129         g_value_set_object (value, g_io_stream_get_input_stream (stream));
130         break;
131
132       case PROP_OUTPUT_STREAM:
133         g_value_set_object (value, g_io_stream_get_output_stream (stream));
134         break;
135
136       default:
137         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
138     }
139 }
140
141 static void
142 g_io_stream_class_init (GIOStreamClass *klass)
143 {
144   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
145
146   gobject_class->dispose = g_io_stream_dispose;
147   gobject_class->get_property = g_io_stream_get_property;
148
149   klass->close_fn = g_io_stream_real_close;
150   klass->close_async = g_io_stream_real_close_async;
151   klass->close_finish = g_io_stream_real_close_finish;
152
153   g_object_class_install_property (gobject_class, PROP_CLOSED,
154                                    g_param_spec_boolean ("closed",
155                                                          P_("Closed"),
156                                                          P_("Is the stream closed"),
157                                                          FALSE,
158                                                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
159
160   g_object_class_install_property (gobject_class, PROP_INPUT_STREAM,
161                                    g_param_spec_object ("input-stream",
162                                                         P_("Input stream"),
163                                                         P_("The GInputStream to read from"),
164                                                         G_TYPE_INPUT_STREAM,
165                                                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
166   g_object_class_install_property (gobject_class, PROP_OUTPUT_STREAM,
167                                    g_param_spec_object ("output-stream",
168                                                         P_("Output stream"),
169                                                         P_("The GOutputStream to write to"),
170                                                         G_TYPE_OUTPUT_STREAM,
171                                                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
172 }
173
174 /**
175  * g_io_stream_is_closed:
176  * @stream: a #GIOStream
177  *
178  * Checks if a stream is closed.
179  *
180  * Returns: %TRUE if the stream is closed.
181  *
182  * Since: 2.22
183  */
184 gboolean
185 g_io_stream_is_closed (GIOStream *stream)
186 {
187   g_return_val_if_fail (G_IS_IO_STREAM (stream), TRUE);
188
189   return stream->priv->closed;
190 }
191
192 /**
193  * g_io_stream_get_input_stream:
194  * @stream: a #GIOStream
195  *
196  * Gets the input stream for this object. This is used
197  * for reading.
198  *
199  * Returns: (transfer none): a #GInputStream, owned by the #GIOStream.
200  * Do not free.
201  *
202  * Since: 2.22
203  */
204 GInputStream *
205 g_io_stream_get_input_stream (GIOStream *stream)
206 {
207   GIOStreamClass *klass;
208
209   klass = G_IO_STREAM_GET_CLASS (stream);
210
211   g_assert (klass->get_input_stream != NULL);
212
213   return klass->get_input_stream (stream);
214 }
215
216 /**
217  * g_io_stream_get_output_stream:
218  * @stream: a #GIOStream
219  *
220  * Gets the output stream for this object. This is used for
221  * writing.
222  *
223  * Returns: (transfer none): a #GOutputStream, owned by the #GIOStream.
224  * Do not free.
225  *
226  * Since: 2.22
227  */
228 GOutputStream *
229 g_io_stream_get_output_stream (GIOStream *stream)
230 {
231   GIOStreamClass *klass;
232
233   klass = G_IO_STREAM_GET_CLASS (stream);
234
235   g_assert (klass->get_output_stream != NULL);
236   return klass->get_output_stream (stream);
237 }
238
239 /**
240  * g_io_stream_has_pending:
241  * @stream: a #GIOStream
242  *
243  * Checks if a stream has pending actions.
244  *
245  * Returns: %TRUE if @stream has pending actions.
246  *
247  * Since: 2.22
248  **/
249 gboolean
250 g_io_stream_has_pending (GIOStream *stream)
251 {
252   g_return_val_if_fail (G_IS_IO_STREAM (stream), FALSE);
253
254   return stream->priv->pending;
255 }
256
257 /**
258  * g_io_stream_set_pending:
259  * @stream: a #GIOStream
260  * @error: a #GError location to store the error occurring, or %NULL to
261  *     ignore
262  *
263  * Sets @stream to have actions pending. If the pending flag is
264  * already set or @stream is closed, it will return %FALSE and set
265  * @error.
266  *
267  * Return value: %TRUE if pending was previously unset and is now set.
268  *
269  * Since: 2.22
270  */
271 gboolean
272 g_io_stream_set_pending (GIOStream  *stream,
273                          GError    **error)
274 {
275   g_return_val_if_fail (G_IS_IO_STREAM (stream), FALSE);
276
277   if (stream->priv->closed)
278     {
279       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
280                            _("Stream is already closed"));
281       return FALSE;
282     }
283
284   if (stream->priv->pending)
285     {
286       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
287                            /* Translators: This is an error you get if there is
288                             * already an operation running against this stream when
289                             * you try to start one */
290                            _("Stream has outstanding operation"));
291       return FALSE;
292     }
293
294   stream->priv->pending = TRUE;
295   return TRUE;
296 }
297
298 /**
299  * g_io_stream_clear_pending:
300  * @stream: a #GIOStream
301  *
302  * Clears the pending flag on @stream.
303  *
304  * Since: 2.22
305  */
306 void
307 g_io_stream_clear_pending (GIOStream *stream)
308 {
309   g_return_if_fail (G_IS_IO_STREAM (stream));
310
311   stream->priv->pending = FALSE;
312 }
313
314 static gboolean
315 g_io_stream_real_close (GIOStream     *stream,
316                         GCancellable  *cancellable,
317                         GError       **error)
318 {
319   gboolean res;
320
321   res = g_output_stream_close (g_io_stream_get_output_stream (stream),
322                                cancellable, error);
323
324   /* If this errored out, unset error so that we don't report
325      further errors, but still do the following ops */
326   if (error != NULL && *error != NULL)
327     error = NULL;
328
329   res &= g_input_stream_close (g_io_stream_get_input_stream (stream),
330                                cancellable, error);
331
332   return res;
333 }
334
335 /**
336  * g_io_stream_close:
337  * @stream: a #GIOStream
338  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
339  * @error: location to store the error occurring, or %NULL to ignore
340  *
341  * Closes the stream, releasing resources related to it. This will also
342  * closes the individual input and output streams, if they are not already
343  * closed.
344  *
345  * Once the stream is closed, all other operations will return
346  * %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
347  * return an error.
348  *
349  * Closing a stream will automatically flush any outstanding buffers
350  * in the stream.
351  *
352  * Streams will be automatically closed when the last reference
353  * is dropped, but you might want to call this function to make sure
354  * resources are released as early as possible.
355  *
356  * Some streams might keep the backing store of the stream (e.g. a file
357  * descriptor) open after the stream is closed. See the documentation for
358  * the individual stream for details.
359  *
360  * On failure the first error that happened will be reported, but the
361  * close operation will finish as much as possible. A stream that failed
362  * to close will still return %G_IO_ERROR_CLOSED for all operations.
363  * Still, it is important to check and report the error to the user,
364  * otherwise there might be a loss of data as all data might not be written.
365  *
366  * If @cancellable is not NULL, then the operation can be cancelled by
367  * triggering the cancellable object from another thread. If the operation
368  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
369  * Cancelling a close will still leave the stream closed, but some streams
370  * can use a faster close that doesn't block to e.g. check errors.
371  *
372  * The default implementation of this method just calls close on the
373  * individual input/output streams.
374  *
375  * Return value: %TRUE on success, %FALSE on failure
376  *
377  * Since: 2.22
378  */
379 gboolean
380 g_io_stream_close (GIOStream     *stream,
381                    GCancellable  *cancellable,
382                    GError       **error)
383 {
384   GIOStreamClass *class;
385   gboolean res;
386
387   g_return_val_if_fail (G_IS_IO_STREAM (stream), FALSE);
388
389   class = G_IO_STREAM_GET_CLASS (stream);
390
391   if (stream->priv->closed)
392     return TRUE;
393
394   if (!g_io_stream_set_pending (stream, error))
395     return FALSE;
396
397   if (cancellable)
398     g_cancellable_push_current (cancellable);
399
400   res = TRUE;
401   if (class->close_fn)
402     res = class->close_fn (stream, cancellable, error);
403
404   if (cancellable)
405     g_cancellable_pop_current (cancellable);
406
407   stream->priv->closed = TRUE;
408   g_io_stream_clear_pending (stream);
409
410   return res;
411 }
412
413 static void
414 async_ready_close_callback_wrapper (GObject      *source_object,
415                                     GAsyncResult *res,
416                                     gpointer      user_data)
417 {
418   GIOStream *stream = G_IO_STREAM (source_object);
419
420   stream->priv->closed = TRUE;
421   g_io_stream_clear_pending (stream);
422   if (stream->priv->outstanding_callback)
423     (*stream->priv->outstanding_callback) (source_object, res, user_data);
424   g_object_unref (stream);
425 }
426
427 /**
428  * g_io_stream_close_async:
429  * @stream: a #GIOStream
430  * @io_priority: the io priority of the request
431  * @cancellable: (allow-none): optional cancellable object
432  * @callback: (scope async): callback to call when the request is satisfied
433  * @user_data: (closure): the data to pass to callback function
434  *
435  * Requests an asynchronous close of the stream, releasing resources
436  * related to it. When the operation is finished @callback will be
437  * called. You can then call g_io_stream_close_finish() to get
438  * the result of the operation.
439  *
440  * For behaviour details see g_io_stream_close().
441  *
442  * The asynchronous methods have a default fallback that uses threads
443  * to implement asynchronicity, so they are optional for inheriting
444  * classes. However, if you override one you must override all.
445  *
446  * Since: 2.22
447  */
448 void
449 g_io_stream_close_async (GIOStream           *stream,
450                          int                  io_priority,
451                          GCancellable        *cancellable,
452                          GAsyncReadyCallback  callback,
453                          gpointer             user_data)
454 {
455   GIOStreamClass *class;
456   GError *error = NULL;
457
458   g_return_if_fail (G_IS_IO_STREAM (stream));
459
460   if (stream->priv->closed)
461     {
462       GTask *task;
463
464       task = g_task_new (stream, cancellable, callback, user_data);
465       g_task_set_source_tag (task, g_io_stream_close_async);
466       g_task_return_boolean (task, TRUE);
467       g_object_unref (task);
468       return;
469     }
470
471   if (!g_io_stream_set_pending (stream, &error))
472     {
473       g_task_report_error (stream, callback, user_data,
474                            g_io_stream_close_async,
475                            error);
476       return;
477     }
478
479   class = G_IO_STREAM_GET_CLASS (stream);
480   stream->priv->outstanding_callback = callback;
481   g_object_ref (stream);
482   class->close_async (stream, io_priority, cancellable,
483                       async_ready_close_callback_wrapper, user_data);
484 }
485
486 /**
487  * g_io_stream_close_finish:
488  * @stream: a #GIOStream
489  * @result: a #GAsyncResult
490  * @error: a #GError location to store the error occurring, or %NULL to
491  *    ignore
492  *
493  * Closes a stream.
494  *
495  * Returns: %TRUE if stream was successfully closed, %FALSE otherwise.
496  *
497  * Since: 2.22
498  */
499 gboolean
500 g_io_stream_close_finish (GIOStream     *stream,
501                           GAsyncResult  *result,
502                           GError       **error)
503 {
504   GIOStreamClass *class;
505
506   g_return_val_if_fail (G_IS_IO_STREAM (stream), FALSE);
507   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
508
509   if (g_async_result_legacy_propagate_error (result, error))
510     return FALSE;
511   else if (g_async_result_is_tagged (result, g_io_stream_close_async))
512     return g_task_propagate_boolean (G_TASK (result), error);
513
514   class = G_IO_STREAM_GET_CLASS (stream);
515   return class->close_finish (stream, result, error);
516 }
517
518
519 static void
520 close_async_thread (GTask        *task,
521                     gpointer      source_object,
522                     gpointer      task_data,
523                     GCancellable *cancellable)
524 {
525   GIOStream *stream = source_object;
526   GIOStreamClass *class;
527   GError *error = NULL;
528   gboolean result;
529
530   class = G_IO_STREAM_GET_CLASS (stream);
531   if (class->close_fn)
532     {
533       result = class->close_fn (stream,
534                                 g_task_get_cancellable (task),
535                                 &error);
536       if (!result)
537         {
538           g_task_return_error (task, error);
539           return;
540         }
541     }
542
543   g_task_return_boolean (task, TRUE);
544 }
545
546 static void
547 g_io_stream_real_close_async (GIOStream           *stream,
548                               int                  io_priority,
549                               GCancellable        *cancellable,
550                               GAsyncReadyCallback  callback,
551                               gpointer             user_data)
552 {
553   GTask *task;
554
555   task = g_task_new (stream, cancellable, callback, user_data);
556   g_task_set_check_cancellable (task, FALSE);
557   g_task_set_priority (task, io_priority);
558   
559   g_task_run_in_thread (task, close_async_thread);
560   g_object_unref (task);
561 }
562
563 static gboolean
564 g_io_stream_real_close_finish (GIOStream     *stream,
565                                GAsyncResult  *result,
566                                GError       **error)
567 {
568   g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
569
570   return g_task_propagate_boolean (G_TASK (result), error);
571 }
572
573 typedef struct
574 {
575   GIOStream *stream1;
576   GIOStream *stream2;
577   GIOStreamSpliceFlags flags;
578   gint io_priority;
579   GCancellable *cancellable;
580   gulong cancelled_id;
581   GCancellable *op1_cancellable;
582   GCancellable *op2_cancellable;
583   guint completed;
584   GError *error;
585 } SpliceContext;
586
587 static void
588 splice_context_free (SpliceContext *ctx)
589 {
590   g_object_unref (ctx->stream1);
591   g_object_unref (ctx->stream2);
592   if (ctx->cancellable != NULL)
593     g_object_unref (ctx->cancellable);
594   g_object_unref (ctx->op1_cancellable);
595   g_object_unref (ctx->op2_cancellable);
596   g_clear_error (&ctx->error);
597   g_slice_free (SpliceContext, ctx);
598 }
599
600 static void
601 splice_complete (GTask         *task,
602                  SpliceContext *ctx)
603 {
604   if (ctx->cancelled_id != 0)
605     g_cancellable_disconnect (ctx->cancellable, ctx->cancelled_id);
606   ctx->cancelled_id = 0;
607
608   if (ctx->error != NULL)
609     {
610       g_task_return_error (task, ctx->error);
611       ctx->error = NULL;
612     }
613   else
614     g_task_return_boolean (task, TRUE);
615 }
616
617 static void
618 splice_close_cb (GObject      *iostream,
619                  GAsyncResult *res,
620                  gpointer      user_data)
621 {
622   GTask *task = user_data;
623   SpliceContext *ctx = g_task_get_task_data (task);
624   GError *error = NULL;
625
626   g_io_stream_close_finish (G_IO_STREAM (iostream), res, &error);
627
628   ctx->completed++;
629
630   /* Keep the first error that occurred */
631   if (error != NULL && ctx->error == NULL)
632     ctx->error = error;
633   else
634     g_clear_error (&error);
635
636   /* If all operations are done, complete now */
637   if (ctx->completed == 4)
638     splice_complete (task, ctx);
639
640   g_object_unref (task);
641 }
642
643 static void
644 splice_cb (GObject      *ostream,
645            GAsyncResult *res,
646            gpointer      user_data)
647 {
648   GTask *task = user_data;
649   SpliceContext *ctx = g_task_get_task_data (task);
650   GError *error = NULL;
651
652   g_output_stream_splice_finish (G_OUTPUT_STREAM (ostream), res, &error);
653
654   ctx->completed++;
655
656   /* ignore cancellation error if it was not requested by the user */
657   if (error != NULL &&
658       g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
659       (ctx->cancellable == NULL ||
660        !g_cancellable_is_cancelled (ctx->cancellable)))
661     g_clear_error (&error);
662
663   /* Keep the first error that occurred */
664   if (error != NULL && ctx->error == NULL)
665     ctx->error = error;
666   else
667     g_clear_error (&error);
668
669    if (ctx->completed == 1 &&
670        (ctx->flags & G_IO_STREAM_SPLICE_WAIT_FOR_BOTH) == 0)
671     {
672       /* We don't want to wait for the 2nd operation to finish, cancel it */
673       g_cancellable_cancel (ctx->op1_cancellable);
674       g_cancellable_cancel (ctx->op2_cancellable);
675     }
676   else if (ctx->completed == 2)
677     {
678       if (ctx->cancellable == NULL ||
679           !g_cancellable_is_cancelled (ctx->cancellable))
680         {
681           g_cancellable_reset (ctx->op1_cancellable);
682           g_cancellable_reset (ctx->op2_cancellable);
683         }
684
685       /* Close the IO streams if needed */
686       if ((ctx->flags & G_IO_STREAM_SPLICE_CLOSE_STREAM1) != 0)
687         {
688           g_io_stream_close_async (ctx->stream1,
689                                    g_task_get_priority (task),
690                                    ctx->op1_cancellable,
691                                    splice_close_cb, g_object_ref (task));
692         }
693       else
694         ctx->completed++;
695
696       if ((ctx->flags & G_IO_STREAM_SPLICE_CLOSE_STREAM2) != 0)
697         {
698           g_io_stream_close_async (ctx->stream2,
699                                    g_task_get_priority (task),
700                                    ctx->op2_cancellable,
701                                    splice_close_cb, g_object_ref (task));
702         }
703       else
704         ctx->completed++;
705
706       /* If all operations are done, complete now */
707       if (ctx->completed == 4)
708         splice_complete (task, ctx);
709     }
710
711   g_object_unref (task);
712 }
713
714 static void
715 splice_cancelled_cb (GCancellable *cancellable,
716                      GTask        *task)
717 {
718   SpliceContext *ctx;
719
720   ctx = g_task_get_task_data (task);
721   g_cancellable_cancel (ctx->op1_cancellable);
722   g_cancellable_cancel (ctx->op2_cancellable);
723 }
724
725 /**
726  * g_io_stream_splice_async:
727  * @stream1: a #GIOStream.
728  * @stream2: a #GIOStream.
729  * @flags: a set of #GIOStreamSpliceFlags.
730  * @io_priority: the io priority of the request.
731  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
732  * @callback: (scope async): a #GAsyncReadyCallback.
733  * @user_data: (closure): user data passed to @callback.
734  *
735  * Asyncronously splice the output stream of @stream1 to the input stream of
736  * @stream2, and splice the output stream of @stream2 to the input stream of
737  * @stream1.
738  *
739  * When the operation is finished @callback will be called.
740  * You can then call g_io_stream_splice_finish() to get the
741  * result of the operation.
742  *
743  * Since: 2.28
744  **/
745 void
746 g_io_stream_splice_async (GIOStream            *stream1,
747                           GIOStream            *stream2,
748                           GIOStreamSpliceFlags  flags,
749                           gint                  io_priority,
750                           GCancellable         *cancellable,
751                           GAsyncReadyCallback   callback,
752                           gpointer              user_data)
753 {
754   GTask *task;
755   SpliceContext *ctx;
756   GInputStream *istream;
757   GOutputStream *ostream;
758
759   if (cancellable != NULL && g_cancellable_is_cancelled (cancellable))
760     {
761       g_task_report_new_error (NULL, callback, user_data,
762                                g_io_stream_splice_async,
763                                G_IO_ERROR, G_IO_ERROR_CANCELLED,
764                                "Operation has been cancelled");
765       return;
766     }
767
768   ctx = g_slice_new0 (SpliceContext);
769   ctx->stream1 = g_object_ref (stream1);
770   ctx->stream2 = g_object_ref (stream2);
771   ctx->flags = flags;
772   ctx->op1_cancellable = g_cancellable_new ();
773   ctx->op2_cancellable = g_cancellable_new ();
774   ctx->completed = 0;
775
776   task = g_task_new (NULL, cancellable, callback, user_data);
777   g_task_set_task_data (task, ctx, (GDestroyNotify) splice_context_free);
778
779   if (cancellable != NULL)
780     {
781       ctx->cancellable = g_object_ref (cancellable);
782       ctx->cancelled_id = g_cancellable_connect (cancellable,
783           G_CALLBACK (splice_cancelled_cb), g_object_ref (task),
784           g_object_unref);
785     }
786
787   istream = g_io_stream_get_input_stream (stream1);
788   ostream = g_io_stream_get_output_stream (stream2);
789   g_output_stream_splice_async (ostream, istream, G_OUTPUT_STREAM_SPLICE_NONE,
790       io_priority, ctx->op1_cancellable, splice_cb,
791       g_object_ref (task));
792
793   istream = g_io_stream_get_input_stream (stream2);
794   ostream = g_io_stream_get_output_stream (stream1);
795   g_output_stream_splice_async (ostream, istream, G_OUTPUT_STREAM_SPLICE_NONE,
796       io_priority, ctx->op2_cancellable, splice_cb,
797       g_object_ref (task));
798
799   g_object_unref (task);
800 }
801
802 /**
803  * g_io_stream_splice_finish:
804  * @result: a #GAsyncResult.
805  * @error: a #GError location to store the error occurring, or %NULL to
806  * ignore.
807  *
808  * Finishes an asynchronous io stream splice operation.
809  *
810  * Returns: %TRUE on success, %FALSE otherwise.
811  *
812  * Since: 2.28
813  **/
814 gboolean
815 g_io_stream_splice_finish (GAsyncResult  *result,
816                            GError       **error)
817 {
818   g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
819
820   return g_task_propagate_boolean (G_TASK (result), error);
821 }