1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 * Author: Alexander Larsson <alexl@redhat.com>
23 #include "goutputstream.h"
24 #include "gcancellable.h"
25 #include "gasyncresult.h"
27 #include "ginputstream.h"
29 #include "gioprivate.h"
31 #include "gpollableoutputstream.h"
34 * SECTION:goutputstream
35 * @short_description: Base class for implementing streaming output
38 * #GOutputStream has functions to write to a stream (g_output_stream_write()),
39 * to close a stream (g_output_stream_close()) and to flush pending writes
40 * (g_output_stream_flush()).
42 * To copy the content of an input stream to an output stream without
43 * manually handling the reads and writes, use g_output_stream_splice().
45 * See the documentation for #GIOStream for details of thread safety of
48 * All of these functions have async variants too.
51 struct _GOutputStreamPrivate
{
55 GAsyncReadyCallback outstanding_callback
;
58 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GOutputStream
, g_output_stream
, G_TYPE_OBJECT
)
60 static gssize
g_output_stream_real_splice (GOutputStream
*stream
,
62 GOutputStreamSpliceFlags flags
,
63 GCancellable
*cancellable
,
65 static void g_output_stream_real_write_async (GOutputStream
*stream
,
69 GCancellable
*cancellable
,
70 GAsyncReadyCallback callback
,
72 static gssize
g_output_stream_real_write_finish (GOutputStream
*stream
,
75 static void g_output_stream_real_splice_async (GOutputStream
*stream
,
77 GOutputStreamSpliceFlags flags
,
79 GCancellable
*cancellable
,
80 GAsyncReadyCallback callback
,
82 static gssize
g_output_stream_real_splice_finish (GOutputStream
*stream
,
85 static void g_output_stream_real_flush_async (GOutputStream
*stream
,
87 GCancellable
*cancellable
,
88 GAsyncReadyCallback callback
,
90 static gboolean
g_output_stream_real_flush_finish (GOutputStream
*stream
,
93 static void g_output_stream_real_close_async (GOutputStream
*stream
,
95 GCancellable
*cancellable
,
96 GAsyncReadyCallback callback
,
98 static gboolean
g_output_stream_real_close_finish (GOutputStream
*stream
,
101 static gboolean
g_output_stream_internal_close (GOutputStream
*stream
,
102 GCancellable
*cancellable
,
104 static void g_output_stream_internal_close_async (GOutputStream
*stream
,
106 GCancellable
*cancellable
,
107 GAsyncReadyCallback callback
,
109 static gboolean
g_output_stream_internal_close_finish (GOutputStream
*stream
,
110 GAsyncResult
*result
,
114 g_output_stream_dispose (GObject
*object
)
116 GOutputStream
*stream
;
118 stream
= G_OUTPUT_STREAM (object
);
120 if (!stream
->priv
->closed
)
121 g_output_stream_close (stream
, NULL
, NULL
);
123 G_OBJECT_CLASS (g_output_stream_parent_class
)->dispose (object
);
127 g_output_stream_class_init (GOutputStreamClass
*klass
)
129 GObjectClass
*gobject_class
= G_OBJECT_CLASS (klass
);
131 gobject_class
->dispose
= g_output_stream_dispose
;
133 klass
->splice
= g_output_stream_real_splice
;
135 klass
->write_async
= g_output_stream_real_write_async
;
136 klass
->write_finish
= g_output_stream_real_write_finish
;
137 klass
->splice_async
= g_output_stream_real_splice_async
;
138 klass
->splice_finish
= g_output_stream_real_splice_finish
;
139 klass
->flush_async
= g_output_stream_real_flush_async
;
140 klass
->flush_finish
= g_output_stream_real_flush_finish
;
141 klass
->close_async
= g_output_stream_real_close_async
;
142 klass
->close_finish
= g_output_stream_real_close_finish
;
146 g_output_stream_init (GOutputStream
*stream
)
148 stream
->priv
= g_output_stream_get_instance_private (stream
);
152 * g_output_stream_write:
153 * @stream: a #GOutputStream.
154 * @buffer: (array length=count) (element-type guint8): the buffer containing the data to write.
155 * @count: the number of bytes to write
156 * @cancellable: (nullable): optional cancellable object
157 * @error: location to store the error occurring, or %NULL to ignore
159 * Tries to write @count bytes from @buffer into the stream. Will block
160 * during the operation.
162 * If count is 0, returns 0 and does nothing. A value of @count
163 * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
165 * On success, the number of bytes written to the stream is returned.
166 * It is not an error if this is not the same as the requested size, as it
167 * can happen e.g. on a partial I/O error, or if there is not enough
168 * storage in the stream. All writes block until at least one byte
169 * is written or an error occurs; 0 is never returned (unless
172 * If @cancellable is not %NULL, then the operation can be cancelled by
173 * triggering the cancellable object from another thread. If the operation
174 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
175 * operation was partially finished when the operation was cancelled the
176 * partial result will be returned, without an error.
178 * On error -1 is returned and @error is set accordingly.
182 * Returns: Number of bytes written, or -1 on error
185 g_output_stream_write (GOutputStream
*stream
,
188 GCancellable
*cancellable
,
191 GOutputStreamClass
*class;
194 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), -1);
195 g_return_val_if_fail (buffer
!= NULL
, 0);
200 if (((gssize
) count
) < 0)
202 g_set_error (error
, G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
203 _("Too large count value passed to %s"), G_STRFUNC
);
207 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
209 if (class->write_fn
== NULL
)
211 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
212 _("Output stream doesn’t implement write"));
216 if (!g_output_stream_set_pending (stream
, error
))
220 g_cancellable_push_current (cancellable
);
222 res
= class->write_fn (stream
, buffer
, count
, cancellable
, error
);
225 g_cancellable_pop_current (cancellable
);
227 g_output_stream_clear_pending (stream
);
233 * g_output_stream_write_all:
234 * @stream: a #GOutputStream.
235 * @buffer: (array length=count) (element-type guint8): the buffer containing the data to write.
236 * @count: the number of bytes to write
237 * @bytes_written: (out): location to store the number of bytes that was
238 * written to the stream
239 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
240 * @error: location to store the error occurring, or %NULL to ignore
242 * Tries to write @count bytes from @buffer into the stream. Will block
243 * during the operation.
245 * This function is similar to g_output_stream_write(), except it tries to
246 * write as many bytes as requested, only stopping on an error.
248 * On a successful write of @count bytes, %TRUE is returned, and @bytes_written
251 * If there is an error during the operation %FALSE is returned and @error
252 * is set to indicate the error status.
254 * As a special exception to the normal conventions for functions that
255 * use #GError, if this function returns %FALSE (and sets @error) then
256 * @bytes_written will be set to the number of bytes that were
257 * successfully written before the error was encountered. This
258 * functionality is only available from C. If you need it from another
259 * language then you must write your own loop around
260 * g_output_stream_write().
262 * Returns: %TRUE on success, %FALSE if there was an error
265 g_output_stream_write_all (GOutputStream
*stream
,
268 gsize
*bytes_written
,
269 GCancellable
*cancellable
,
272 gsize _bytes_written
;
275 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
276 g_return_val_if_fail (buffer
!= NULL
, FALSE
);
279 while (_bytes_written
< count
)
281 res
= g_output_stream_write (stream
, (char *)buffer
+ _bytes_written
, count
- _bytes_written
,
286 *bytes_written
= _bytes_written
;
291 g_warning ("Write returned zero without error");
293 _bytes_written
+= res
;
297 *bytes_written
= _bytes_written
;
303 * g_output_stream_printf:
304 * @stream: a #GOutputStream.
305 * @bytes_written: (out): location to store the number of bytes that was
306 * written to the stream
307 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
308 * @error: location to store the error occurring, or %NULL to ignore
309 * @format: the format string. See the printf() documentation
310 * @...: the parameters to insert into the format string
312 * This is a utility function around g_output_stream_write_all(). It
313 * uses g_strdup_vprintf() to turn @format and @... into a string that
314 * is then written to @stream.
316 * See the documentation of g_output_stream_write_all() about the
317 * behavior of the actual write operation.
319 * Note that partial writes cannot be properly checked with this
320 * function due to the variable length of the written string, if you
321 * need precise control over partial write failures, you need to
322 * create you own printf()-like wrapper around g_output_stream_write()
323 * or g_output_stream_write_all().
327 * Returns: %TRUE on success, %FALSE if there was an error
330 g_output_stream_printf (GOutputStream
*stream
,
331 gsize
*bytes_written
,
332 GCancellable
*cancellable
,
340 va_start (args
, format
);
341 success
= g_output_stream_vprintf (stream
, bytes_written
, cancellable
,
342 error
, format
, args
);
349 * g_output_stream_vprintf:
350 * @stream: a #GOutputStream.
351 * @bytes_written: (out): location to store the number of bytes that was
352 * written to the stream
353 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
354 * @error: location to store the error occurring, or %NULL to ignore
355 * @format: the format string. See the printf() documentation
356 * @args: the parameters to insert into the format string
358 * This is a utility function around g_output_stream_write_all(). It
359 * uses g_strdup_vprintf() to turn @format and @args into a string that
360 * is then written to @stream.
362 * See the documentation of g_output_stream_write_all() about the
363 * behavior of the actual write operation.
365 * Note that partial writes cannot be properly checked with this
366 * function due to the variable length of the written string, if you
367 * need precise control over partial write failures, you need to
368 * create you own printf()-like wrapper around g_output_stream_write()
369 * or g_output_stream_write_all().
373 * Returns: %TRUE on success, %FALSE if there was an error
376 g_output_stream_vprintf (GOutputStream
*stream
,
377 gsize
*bytes_written
,
378 GCancellable
*cancellable
,
386 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
387 g_return_val_if_fail (cancellable
== NULL
|| G_IS_CANCELLABLE (stream
), FALSE
);
388 g_return_val_if_fail (error
== NULL
|| *error
== NULL
, FALSE
);
389 g_return_val_if_fail (format
!= NULL
, FALSE
);
391 text
= g_strdup_vprintf (format
, args
);
392 success
= g_output_stream_write_all (stream
,
394 bytes_written
, cancellable
, error
);
401 * g_output_stream_write_bytes:
402 * @stream: a #GOutputStream.
403 * @bytes: the #GBytes to write
404 * @cancellable: (nullable): optional cancellable object
405 * @error: location to store the error occurring, or %NULL to ignore
407 * A wrapper function for g_output_stream_write() which takes a
408 * #GBytes as input. This can be more convenient for use by language
409 * bindings or in other cases where the refcounted nature of #GBytes
410 * is helpful over a bare pointer interface.
412 * However, note that this function may still perform partial writes,
413 * just like g_output_stream_write(). If that occurs, to continue
414 * writing, you will need to create a new #GBytes containing just the
415 * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
416 * #GBytes instance multiple times potentially can result in duplicated
417 * data in the output stream.
419 * Returns: Number of bytes written, or -1 on error
422 g_output_stream_write_bytes (GOutputStream
*stream
,
424 GCancellable
*cancellable
,
430 data
= g_bytes_get_data (bytes
, &size
);
432 return g_output_stream_write (stream
,
439 * g_output_stream_flush:
440 * @stream: a #GOutputStream.
441 * @cancellable: (nullable): optional cancellable object
442 * @error: location to store the error occurring, or %NULL to ignore
444 * Forces a write of all user-space buffered data for the given
445 * @stream. Will block during the operation. Closing the stream will
446 * implicitly cause a flush.
448 * This function is optional for inherited classes.
450 * If @cancellable is not %NULL, then the operation can be cancelled by
451 * triggering the cancellable object from another thread. If the operation
452 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
454 * Returns: %TRUE on success, %FALSE on error
457 g_output_stream_flush (GOutputStream
*stream
,
458 GCancellable
*cancellable
,
461 GOutputStreamClass
*class;
464 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
466 if (!g_output_stream_set_pending (stream
, error
))
469 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
475 g_cancellable_push_current (cancellable
);
477 res
= class->flush (stream
, cancellable
, error
);
480 g_cancellable_pop_current (cancellable
);
483 g_output_stream_clear_pending (stream
);
489 * g_output_stream_splice:
490 * @stream: a #GOutputStream.
491 * @source: a #GInputStream.
492 * @flags: a set of #GOutputStreamSpliceFlags.
493 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
494 * @error: a #GError location to store the error occurring, or %NULL to
497 * Splices an input stream into an output stream.
499 * Returns: a #gssize containing the size of the data spliced, or
500 * -1 if an error occurred. Note that if the number of bytes
501 * spliced is greater than %G_MAXSSIZE, then that will be
502 * returned, and there is no way to determine the actual number
506 g_output_stream_splice (GOutputStream
*stream
,
507 GInputStream
*source
,
508 GOutputStreamSpliceFlags flags
,
509 GCancellable
*cancellable
,
512 GOutputStreamClass
*class;
515 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), -1);
516 g_return_val_if_fail (G_IS_INPUT_STREAM (source
), -1);
518 if (g_input_stream_is_closed (source
))
520 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_CLOSED
,
521 _("Source stream is already closed"));
525 if (!g_output_stream_set_pending (stream
, error
))
528 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
531 g_cancellable_push_current (cancellable
);
533 bytes_copied
= class->splice (stream
, source
, flags
, cancellable
, error
);
536 g_cancellable_pop_current (cancellable
);
538 g_output_stream_clear_pending (stream
);
544 g_output_stream_real_splice (GOutputStream
*stream
,
545 GInputStream
*source
,
546 GOutputStreamSpliceFlags flags
,
547 GCancellable
*cancellable
,
550 GOutputStreamClass
*class = G_OUTPUT_STREAM_GET_CLASS (stream
);
551 gssize n_read
, n_written
;
553 char buffer
[8192], *p
;
557 if (class->write_fn
== NULL
)
559 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_NOT_SUPPORTED
,
560 _("Output stream doesn’t implement write"));
568 n_read
= g_input_stream_read (source
, buffer
, sizeof (buffer
), cancellable
, error
);
581 n_written
= class->write_fn (stream
, p
, n_read
, cancellable
, error
);
590 bytes_copied
+= n_written
;
593 if (bytes_copied
> G_MAXSSIZE
)
594 bytes_copied
= G_MAXSSIZE
;
600 error
= NULL
; /* Ignore further errors */
602 if (flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE
)
604 /* Don't care about errors in source here */
605 g_input_stream_close (source
, cancellable
, NULL
);
608 if (flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET
)
610 /* But write errors on close are bad! */
611 if (!g_output_stream_internal_close (stream
, cancellable
, error
))
621 /* Must always be called inside
622 * g_output_stream_set_pending()/g_output_stream_clear_pending(). */
624 g_output_stream_internal_close (GOutputStream
*stream
,
625 GCancellable
*cancellable
,
628 GOutputStreamClass
*class;
631 if (stream
->priv
->closed
)
634 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
636 stream
->priv
->closing
= TRUE
;
639 g_cancellable_push_current (cancellable
);
642 res
= class->flush (stream
, cancellable
, error
);
648 /* flushing caused the error that we want to return,
649 * but we still want to close the underlying stream if possible
652 class->close_fn (stream
, cancellable
, NULL
);
658 res
= class->close_fn (stream
, cancellable
, error
);
662 g_cancellable_pop_current (cancellable
);
664 stream
->priv
->closing
= FALSE
;
665 stream
->priv
->closed
= TRUE
;
671 * g_output_stream_close:
672 * @stream: A #GOutputStream.
673 * @cancellable: (nullable): optional cancellable object
674 * @error: location to store the error occurring, or %NULL to ignore
676 * Closes the stream, releasing resources related to it.
678 * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
679 * Closing a stream multiple times will not return an error.
681 * Closing a stream will automatically flush any outstanding buffers in the
684 * Streams will be automatically closed when the last reference
685 * is dropped, but you might want to call this function to make sure
686 * resources are released as early as possible.
688 * Some streams might keep the backing store of the stream (e.g. a file descriptor)
689 * open after the stream is closed. See the documentation for the individual
690 * stream for details.
692 * On failure the first error that happened will be reported, but the close
693 * operation will finish as much as possible. A stream that failed to
694 * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
695 * is important to check and report the error to the user, otherwise
696 * there might be a loss of data as all data might not be written.
698 * If @cancellable is not %NULL, then the operation can be cancelled by
699 * triggering the cancellable object from another thread. If the operation
700 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
701 * Cancelling a close will still leave the stream closed, but there some streams
702 * can use a faster close that doesn't block to e.g. check errors. On
703 * cancellation (as with any error) there is no guarantee that all written
704 * data will reach the target.
706 * Returns: %TRUE on success, %FALSE on failure
709 g_output_stream_close (GOutputStream
*stream
,
710 GCancellable
*cancellable
,
715 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
717 if (stream
->priv
->closed
)
720 if (!g_output_stream_set_pending (stream
, error
))
723 res
= g_output_stream_internal_close (stream
, cancellable
, error
);
725 g_output_stream_clear_pending (stream
);
731 async_ready_write_callback_wrapper (GObject
*source_object
,
735 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
736 GOutputStreamClass
*class;
737 GTask
*task
= user_data
;
739 GError
*error
= NULL
;
741 g_output_stream_clear_pending (stream
);
743 if (g_async_result_legacy_propagate_error (res
, &error
))
747 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
748 nwrote
= class->write_finish (stream
, res
, &error
);
752 g_task_return_int (task
, nwrote
);
754 g_task_return_error (task
, error
);
755 g_object_unref (task
);
759 * g_output_stream_write_async:
760 * @stream: A #GOutputStream.
761 * @buffer: (array length=count) (element-type guint8): the buffer containing the data to write.
762 * @count: the number of bytes to write
763 * @io_priority: the io priority of the request.
764 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
765 * @callback: (scope async): callback to call when the request is satisfied
766 * @user_data: (closure): the data to pass to callback function
768 * Request an asynchronous write of @count bytes from @buffer into
769 * the stream. When the operation is finished @callback will be called.
770 * You can then call g_output_stream_write_finish() to get the result of the
773 * During an async request no other sync and async calls are allowed,
774 * and will result in %G_IO_ERROR_PENDING errors.
776 * A value of @count larger than %G_MAXSSIZE will cause a
777 * %G_IO_ERROR_INVALID_ARGUMENT error.
779 * On success, the number of bytes written will be passed to the
780 * @callback. It is not an error if this is not the same as the
781 * requested size, as it can happen e.g. on a partial I/O error,
782 * but generally we try to write as many bytes as requested.
784 * You are guaranteed that this method will never fail with
785 * %G_IO_ERROR_WOULD_BLOCK - if @stream can't accept more data, the
786 * method will just wait until this changes.
788 * Any outstanding I/O request with higher priority (lower numerical
789 * value) will be executed before an outstanding request with lower
790 * priority. Default priority is %G_PRIORITY_DEFAULT.
792 * The asynchronous methods have a default fallback that uses threads
793 * to implement asynchronicity, so they are optional for inheriting
794 * classes. However, if you override one you must override all.
796 * For the synchronous, blocking version of this function, see
797 * g_output_stream_write().
799 * Note that no copy of @buffer will be made, so it must stay valid
800 * until @callback is called. See g_output_stream_write_bytes_async()
801 * for a #GBytes version that will automatically hold a reference to
802 * the contents (without copying) for the duration of the call.
805 g_output_stream_write_async (GOutputStream
*stream
,
809 GCancellable
*cancellable
,
810 GAsyncReadyCallback callback
,
813 GOutputStreamClass
*class;
814 GError
*error
= NULL
;
817 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
818 g_return_if_fail (buffer
!= NULL
);
820 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
821 g_task_set_source_tag (task
, g_output_stream_write_async
);
822 g_task_set_priority (task
, io_priority
);
826 g_task_return_int (task
, 0);
827 g_object_unref (task
);
831 if (((gssize
) count
) < 0)
833 g_task_return_new_error (task
, G_IO_ERROR
, G_IO_ERROR_INVALID_ARGUMENT
,
834 _("Too large count value passed to %s"),
836 g_object_unref (task
);
840 if (!g_output_stream_set_pending (stream
, &error
))
842 g_task_return_error (task
, error
);
843 g_object_unref (task
);
847 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
849 class->write_async (stream
, buffer
, count
, io_priority
, cancellable
,
850 async_ready_write_callback_wrapper
, task
);
854 * g_output_stream_write_finish:
855 * @stream: a #GOutputStream.
856 * @result: a #GAsyncResult.
857 * @error: a #GError location to store the error occurring, or %NULL to
860 * Finishes a stream write operation.
862 * Returns: a #gssize containing the number of bytes written to the stream.
865 g_output_stream_write_finish (GOutputStream
*stream
,
866 GAsyncResult
*result
,
869 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
870 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
871 g_return_val_if_fail (g_async_result_is_tagged (result
, g_output_stream_write_async
), FALSE
);
873 /* @result is always the GTask created by g_output_stream_write_async();
874 * we called class->write_finish() from async_ready_write_callback_wrapper.
876 return g_task_propagate_int (G_TASK (result
), error
);
881 const guint8
*buffer
;
887 free_async_write_all (gpointer data
)
889 g_slice_free (AsyncWriteAll
, data
);
893 write_all_callback (GObject
*stream
,
894 GAsyncResult
*result
,
897 GTask
*task
= user_data
;
898 AsyncWriteAll
*data
= g_task_get_task_data (task
);
902 GError
*error
= NULL
;
905 nwritten
= g_output_stream_write_finish (G_OUTPUT_STREAM (stream
), result
, &error
);
909 g_task_return_error (task
, error
);
910 g_object_unref (task
);
914 g_assert_cmpint (nwritten
, <=, data
->to_write
);
915 g_warn_if_fail (nwritten
> 0);
917 data
->to_write
-= nwritten
;
918 data
->bytes_written
+= nwritten
;
921 if (data
->to_write
== 0)
923 g_task_return_boolean (task
, TRUE
);
924 g_object_unref (task
);
928 g_output_stream_write_async (G_OUTPUT_STREAM (stream
),
929 data
->buffer
+ data
->bytes_written
,
931 g_task_get_priority (task
),
932 g_task_get_cancellable (task
),
933 write_all_callback
, task
);
937 write_all_async_thread (GTask
*task
,
938 gpointer source_object
,
940 GCancellable
*cancellable
)
942 GOutputStream
*stream
= source_object
;
943 AsyncWriteAll
*data
= task_data
;
944 GError
*error
= NULL
;
946 if (g_output_stream_write_all (stream
, data
->buffer
, data
->to_write
, &data
->bytes_written
,
947 g_task_get_cancellable (task
), &error
))
948 g_task_return_boolean (task
, TRUE
);
950 g_task_return_error (task
, error
);
954 * g_output_stream_write_all_async:
955 * @stream: A #GOutputStream
956 * @buffer: (array length=count) (element-type guint8): the buffer containing the data to write
957 * @count: the number of bytes to write
958 * @io_priority: the io priority of the request
959 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore
960 * @callback: (scope async): callback to call when the request is satisfied
961 * @user_data: (closure): the data to pass to callback function
963 * Request an asynchronous write of @count bytes from @buffer into
964 * the stream. When the operation is finished @callback will be called.
965 * You can then call g_output_stream_write_all_finish() to get the result of the
968 * This is the asynchronous version of g_output_stream_write_all().
970 * Call g_output_stream_write_all_finish() to collect the result.
972 * Any outstanding I/O request with higher priority (lower numerical
973 * value) will be executed before an outstanding request with lower
974 * priority. Default priority is %G_PRIORITY_DEFAULT.
976 * Note that no copy of @buffer will be made, so it must stay valid
977 * until @callback is called.
982 g_output_stream_write_all_async (GOutputStream
*stream
,
986 GCancellable
*cancellable
,
987 GAsyncReadyCallback callback
,
993 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
994 g_return_if_fail (buffer
!= NULL
|| count
== 0);
996 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
997 data
= g_slice_new0 (AsyncWriteAll
);
998 data
->buffer
= buffer
;
999 data
->to_write
= count
;
1001 g_task_set_source_tag (task
, g_output_stream_write_all_async
);
1002 g_task_set_task_data (task
, data
, free_async_write_all
);
1003 g_task_set_priority (task
, io_priority
);
1005 /* If async writes are going to be handled via the threadpool anyway
1006 * then we may as well do it with a single dispatch instead of
1007 * bouncing in and out.
1009 if (g_output_stream_async_write_is_via_threads (stream
))
1011 g_task_run_in_thread (task
, write_all_async_thread
);
1012 g_object_unref (task
);
1015 write_all_callback (G_OBJECT (stream
), NULL
, task
);
1019 * g_output_stream_write_all_finish:
1020 * @stream: a #GOutputStream
1021 * @result: a #GAsyncResult
1022 * @bytes_written: (out): location to store the number of bytes that was written to the stream
1023 * @error: a #GError location to store the error occurring, or %NULL to ignore.
1025 * Finishes an asynchronous stream write operation started with
1026 * g_output_stream_write_all_async().
1028 * As a special exception to the normal conventions for functions that
1029 * use #GError, if this function returns %FALSE (and sets @error) then
1030 * @bytes_written will be set to the number of bytes that were
1031 * successfully written before the error was encountered. This
1032 * functionality is only available from C. If you need it from another
1033 * language then you must write your own loop around
1034 * g_output_stream_write_async().
1036 * Returns: %TRUE on success, %FALSE if there was an error
1041 g_output_stream_write_all_finish (GOutputStream
*stream
,
1042 GAsyncResult
*result
,
1043 gsize
*bytes_written
,
1048 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1049 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1051 task
= G_TASK (result
);
1055 AsyncWriteAll
*data
= (AsyncWriteAll
*)g_task_get_task_data (task
);
1057 *bytes_written
= data
->bytes_written
;
1060 return g_task_propagate_boolean (task
, error
);
1064 write_bytes_callback (GObject
*stream
,
1065 GAsyncResult
*result
,
1068 GTask
*task
= user_data
;
1069 GError
*error
= NULL
;
1072 nwrote
= g_output_stream_write_finish (G_OUTPUT_STREAM (stream
),
1075 g_task_return_error (task
, error
);
1077 g_task_return_int (task
, nwrote
);
1078 g_object_unref (task
);
1082 * g_output_stream_write_bytes_async:
1083 * @stream: A #GOutputStream.
1084 * @bytes: The bytes to write
1085 * @io_priority: the io priority of the request.
1086 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
1087 * @callback: (scope async): callback to call when the request is satisfied
1088 * @user_data: (closure): the data to pass to callback function
1090 * This function is similar to g_output_stream_write_async(), but
1091 * takes a #GBytes as input. Due to the refcounted nature of #GBytes,
1092 * this allows the stream to avoid taking a copy of the data.
1094 * However, note that this function may still perform partial writes,
1095 * just like g_output_stream_write_async(). If that occurs, to continue
1096 * writing, you will need to create a new #GBytes containing just the
1097 * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
1098 * #GBytes instance multiple times potentially can result in duplicated
1099 * data in the output stream.
1101 * For the synchronous, blocking version of this function, see
1102 * g_output_stream_write_bytes().
1105 g_output_stream_write_bytes_async (GOutputStream
*stream
,
1108 GCancellable
*cancellable
,
1109 GAsyncReadyCallback callback
,
1116 data
= g_bytes_get_data (bytes
, &size
);
1118 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1119 g_task_set_source_tag (task
, g_output_stream_write_bytes_async
);
1120 g_task_set_task_data (task
, g_bytes_ref (bytes
),
1121 (GDestroyNotify
) g_bytes_unref
);
1123 g_output_stream_write_async (stream
,
1127 write_bytes_callback
,
1132 * g_output_stream_write_bytes_finish:
1133 * @stream: a #GOutputStream.
1134 * @result: a #GAsyncResult.
1135 * @error: a #GError location to store the error occurring, or %NULL to
1138 * Finishes a stream write-from-#GBytes operation.
1140 * Returns: a #gssize containing the number of bytes written to the stream.
1143 g_output_stream_write_bytes_finish (GOutputStream
*stream
,
1144 GAsyncResult
*result
,
1147 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), -1);
1148 g_return_val_if_fail (g_task_is_valid (result
, stream
), -1);
1150 return g_task_propagate_int (G_TASK (result
), error
);
1154 async_ready_splice_callback_wrapper (GObject
*source_object
,
1158 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
1159 GOutputStreamClass
*class;
1160 GTask
*task
= _data
;
1162 GError
*error
= NULL
;
1164 g_output_stream_clear_pending (stream
);
1166 if (g_async_result_legacy_propagate_error (res
, &error
))
1170 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1171 nspliced
= class->splice_finish (stream
, res
, &error
);
1175 g_task_return_int (task
, nspliced
);
1177 g_task_return_error (task
, error
);
1178 g_object_unref (task
);
1182 * g_output_stream_splice_async:
1183 * @stream: a #GOutputStream.
1184 * @source: a #GInputStream.
1185 * @flags: a set of #GOutputStreamSpliceFlags.
1186 * @io_priority: the io priority of the request.
1187 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
1188 * @callback: (scope async): a #GAsyncReadyCallback.
1189 * @user_data: (closure): user data passed to @callback.
1191 * Splices a stream asynchronously.
1192 * When the operation is finished @callback will be called.
1193 * You can then call g_output_stream_splice_finish() to get the
1194 * result of the operation.
1196 * For the synchronous, blocking version of this function, see
1197 * g_output_stream_splice().
1200 g_output_stream_splice_async (GOutputStream
*stream
,
1201 GInputStream
*source
,
1202 GOutputStreamSpliceFlags flags
,
1204 GCancellable
*cancellable
,
1205 GAsyncReadyCallback callback
,
1208 GOutputStreamClass
*class;
1210 GError
*error
= NULL
;
1212 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
1213 g_return_if_fail (G_IS_INPUT_STREAM (source
));
1215 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1216 g_task_set_source_tag (task
, g_output_stream_splice_async
);
1217 g_task_set_priority (task
, io_priority
);
1218 g_task_set_task_data (task
, g_object_ref (source
), g_object_unref
);
1220 if (g_input_stream_is_closed (source
))
1222 g_task_return_new_error (task
,
1223 G_IO_ERROR
, G_IO_ERROR_CLOSED
,
1224 _("Source stream is already closed"));
1225 g_object_unref (task
);
1229 if (!g_output_stream_set_pending (stream
, &error
))
1231 g_task_return_error (task
, error
);
1232 g_object_unref (task
);
1236 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1238 class->splice_async (stream
, source
, flags
, io_priority
, cancellable
,
1239 async_ready_splice_callback_wrapper
, task
);
1243 * g_output_stream_splice_finish:
1244 * @stream: a #GOutputStream.
1245 * @result: a #GAsyncResult.
1246 * @error: a #GError location to store the error occurring, or %NULL to
1249 * Finishes an asynchronous stream splice operation.
1251 * Returns: a #gssize of the number of bytes spliced. Note that if the
1252 * number of bytes spliced is greater than %G_MAXSSIZE, then that
1253 * will be returned, and there is no way to determine the actual
1254 * number of bytes spliced.
1257 g_output_stream_splice_finish (GOutputStream
*stream
,
1258 GAsyncResult
*result
,
1261 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1262 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1263 g_return_val_if_fail (g_async_result_is_tagged (result
, g_output_stream_splice_async
), FALSE
);
1265 /* @result is always the GTask created by g_output_stream_splice_async();
1266 * we called class->splice_finish() from async_ready_splice_callback_wrapper.
1268 return g_task_propagate_int (G_TASK (result
), error
);
1272 async_ready_flush_callback_wrapper (GObject
*source_object
,
1276 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
1277 GOutputStreamClass
*class;
1278 GTask
*task
= user_data
;
1280 GError
*error
= NULL
;
1282 g_output_stream_clear_pending (stream
);
1284 if (g_async_result_legacy_propagate_error (res
, &error
))
1288 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1289 flushed
= class->flush_finish (stream
, res
, &error
);
1293 g_task_return_boolean (task
, TRUE
);
1295 g_task_return_error (task
, error
);
1296 g_object_unref (task
);
1300 * g_output_stream_flush_async:
1301 * @stream: a #GOutputStream.
1302 * @io_priority: the io priority of the request.
1303 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
1304 * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
1305 * @user_data: (closure): the data to pass to callback function
1307 * Forces an asynchronous write of all user-space buffered data for
1308 * the given @stream.
1309 * For behaviour details see g_output_stream_flush().
1311 * When the operation is finished @callback will be
1312 * called. You can then call g_output_stream_flush_finish() to get the
1313 * result of the operation.
1316 g_output_stream_flush_async (GOutputStream
*stream
,
1318 GCancellable
*cancellable
,
1319 GAsyncReadyCallback callback
,
1322 GOutputStreamClass
*class;
1324 GError
*error
= NULL
;
1326 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
1328 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1329 g_task_set_source_tag (task
, g_output_stream_flush_async
);
1330 g_task_set_priority (task
, io_priority
);
1332 if (!g_output_stream_set_pending (stream
, &error
))
1334 g_task_return_error (task
, error
);
1335 g_object_unref (task
);
1339 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1341 if (class->flush_async
== NULL
)
1343 g_task_return_boolean (task
, TRUE
);
1344 g_object_unref (task
);
1348 class->flush_async (stream
, io_priority
, cancellable
,
1349 async_ready_flush_callback_wrapper
, task
);
1353 * g_output_stream_flush_finish:
1354 * @stream: a #GOutputStream.
1355 * @result: a GAsyncResult.
1356 * @error: a #GError location to store the error occurring, or %NULL to
1359 * Finishes flushing an output stream.
1361 * Returns: %TRUE if flush operation succeeded, %FALSE otherwise.
1364 g_output_stream_flush_finish (GOutputStream
*stream
,
1365 GAsyncResult
*result
,
1368 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1369 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1370 g_return_val_if_fail (g_async_result_is_tagged (result
, g_output_stream_flush_async
), FALSE
);
1372 /* @result is always the GTask created by g_output_stream_flush_async();
1373 * we called class->flush_finish() from async_ready_flush_callback_wrapper.
1375 return g_task_propagate_boolean (G_TASK (result
), error
);
1380 async_ready_close_callback_wrapper (GObject
*source_object
,
1384 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
1385 GOutputStreamClass
*class;
1386 GTask
*task
= user_data
;
1387 GError
*error
= g_task_get_task_data (task
);
1389 stream
->priv
->closing
= FALSE
;
1390 stream
->priv
->closed
= TRUE
;
1392 if (!error
&& !g_async_result_legacy_propagate_error (res
, &error
))
1394 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1396 class->close_finish (stream
, res
,
1397 error
? NULL
: &error
);
1401 g_task_return_error (task
, error
);
1403 g_task_return_boolean (task
, TRUE
);
1404 g_object_unref (task
);
1408 async_ready_close_flushed_callback_wrapper (GObject
*source_object
,
1412 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
1413 GOutputStreamClass
*class;
1414 GTask
*task
= user_data
;
1415 GError
*error
= NULL
;
1417 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1419 if (!g_async_result_legacy_propagate_error (res
, &error
))
1421 class->flush_finish (stream
, res
, &error
);
1424 /* propagate the possible error */
1426 g_task_set_task_data (task
, error
, NULL
);
1428 /* we still close, even if there was a flush error */
1429 class->close_async (stream
,
1430 g_task_get_priority (task
),
1431 g_task_get_cancellable (task
),
1432 async_ready_close_callback_wrapper
, task
);
1436 real_close_async_cb (GObject
*source_object
,
1440 GOutputStream
*stream
= G_OUTPUT_STREAM (source_object
);
1441 GTask
*task
= user_data
;
1442 GError
*error
= NULL
;
1445 g_output_stream_clear_pending (stream
);
1447 ret
= g_output_stream_internal_close_finish (stream
, res
, &error
);
1450 g_task_return_error (task
, error
);
1452 g_task_return_boolean (task
, ret
);
1454 g_object_unref (task
);
1458 * g_output_stream_close_async:
1459 * @stream: A #GOutputStream.
1460 * @io_priority: the io priority of the request.
1461 * @cancellable: (nullable): optional cancellable object
1462 * @callback: (scope async): callback to call when the request is satisfied
1463 * @user_data: (closure): the data to pass to callback function
1465 * Requests an asynchronous close of the stream, releasing resources
1466 * related to it. When the operation is finished @callback will be
1467 * called. You can then call g_output_stream_close_finish() to get
1468 * the result of the operation.
1470 * For behaviour details see g_output_stream_close().
1472 * The asynchronous methods have a default fallback that uses threads
1473 * to implement asynchronicity, so they are optional for inheriting
1474 * classes. However, if you override one you must override all.
1477 g_output_stream_close_async (GOutputStream
*stream
,
1479 GCancellable
*cancellable
,
1480 GAsyncReadyCallback callback
,
1484 GError
*error
= NULL
;
1486 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
1488 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1489 g_task_set_source_tag (task
, g_output_stream_close_async
);
1490 g_task_set_priority (task
, io_priority
);
1492 if (!g_output_stream_set_pending (stream
, &error
))
1494 g_task_return_error (task
, error
);
1495 g_object_unref (task
);
1499 g_output_stream_internal_close_async (stream
, io_priority
, cancellable
,
1500 real_close_async_cb
, task
);
1503 /* Must always be called inside
1504 * g_output_stream_set_pending()/g_output_stream_clear_pending().
1507 g_output_stream_internal_close_async (GOutputStream
*stream
,
1509 GCancellable
*cancellable
,
1510 GAsyncReadyCallback callback
,
1513 GOutputStreamClass
*class;
1516 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1517 g_task_set_source_tag (task
, g_output_stream_internal_close_async
);
1518 g_task_set_priority (task
, io_priority
);
1520 if (stream
->priv
->closed
)
1522 g_task_return_boolean (task
, TRUE
);
1523 g_object_unref (task
);
1527 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1528 stream
->priv
->closing
= TRUE
;
1530 /* Call close_async directly if there is no need to flush, or if the flush
1531 can be done sync (in the output stream async close thread) */
1532 if (class->flush_async
== NULL
||
1533 (class->flush_async
== g_output_stream_real_flush_async
&&
1534 (class->flush
== NULL
|| class->close_async
== g_output_stream_real_close_async
)))
1536 class->close_async (stream
, io_priority
, cancellable
,
1537 async_ready_close_callback_wrapper
, task
);
1541 /* First do an async flush, then do the async close in the callback
1542 wrapper (see async_ready_close_flushed_callback_wrapper) */
1543 class->flush_async (stream
, io_priority
, cancellable
,
1544 async_ready_close_flushed_callback_wrapper
, task
);
1549 g_output_stream_internal_close_finish (GOutputStream
*stream
,
1550 GAsyncResult
*result
,
1553 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1554 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1555 g_return_val_if_fail (g_async_result_is_tagged (result
, g_output_stream_internal_close_async
), FALSE
);
1557 return g_task_propagate_boolean (G_TASK (result
), error
);
1561 * g_output_stream_close_finish:
1562 * @stream: a #GOutputStream.
1563 * @result: a #GAsyncResult.
1564 * @error: a #GError location to store the error occurring, or %NULL to
1567 * Closes an output stream.
1569 * Returns: %TRUE if stream was successfully closed, %FALSE otherwise.
1572 g_output_stream_close_finish (GOutputStream
*stream
,
1573 GAsyncResult
*result
,
1576 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1577 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1578 g_return_val_if_fail (g_async_result_is_tagged (result
, g_output_stream_close_async
), FALSE
);
1580 /* @result is always the GTask created by g_output_stream_close_async();
1581 * we called class->close_finish() from async_ready_close_callback_wrapper.
1583 return g_task_propagate_boolean (G_TASK (result
), error
);
1587 * g_output_stream_is_closed:
1588 * @stream: a #GOutputStream.
1590 * Checks if an output stream has already been closed.
1592 * Returns: %TRUE if @stream is closed. %FALSE otherwise.
1595 g_output_stream_is_closed (GOutputStream
*stream
)
1597 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), TRUE
);
1599 return stream
->priv
->closed
;
1603 * g_output_stream_is_closing:
1604 * @stream: a #GOutputStream.
1606 * Checks if an output stream is being closed. This can be
1607 * used inside e.g. a flush implementation to see if the
1608 * flush (or other i/o operation) is called from within
1609 * the closing operation.
1611 * Returns: %TRUE if @stream is being closed. %FALSE otherwise.
1616 g_output_stream_is_closing (GOutputStream
*stream
)
1618 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), TRUE
);
1620 return stream
->priv
->closing
;
1624 * g_output_stream_has_pending:
1625 * @stream: a #GOutputStream.
1627 * Checks if an output stream has pending actions.
1629 * Returns: %TRUE if @stream has pending actions.
1632 g_output_stream_has_pending (GOutputStream
*stream
)
1634 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1636 return stream
->priv
->pending
;
1640 * g_output_stream_set_pending:
1641 * @stream: a #GOutputStream.
1642 * @error: a #GError location to store the error occurring, or %NULL to
1645 * Sets @stream to have actions pending. If the pending flag is
1646 * already set or @stream is closed, it will return %FALSE and set
1649 * Returns: %TRUE if pending was previously unset and is now set.
1652 g_output_stream_set_pending (GOutputStream
*stream
,
1655 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1657 if (stream
->priv
->closed
)
1659 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_CLOSED
,
1660 _("Stream is already closed"));
1664 if (stream
->priv
->pending
)
1666 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_PENDING
,
1667 /* Translators: This is an error you get if there is
1668 * already an operation running against this stream when
1669 * you try to start one */
1670 _("Stream has outstanding operation"));
1674 stream
->priv
->pending
= TRUE
;
1679 * g_output_stream_clear_pending:
1680 * @stream: output stream
1682 * Clears the pending flag on @stream.
1685 g_output_stream_clear_pending (GOutputStream
*stream
)
1687 g_return_if_fail (G_IS_OUTPUT_STREAM (stream
));
1689 stream
->priv
->pending
= FALSE
;
1693 * g_output_stream_async_write_is_via_threads:
1694 * @stream: a #GOutputStream.
1696 * Checks if an output stream's write_async function uses threads.
1698 * Returns: %TRUE if @stream's write_async function uses threads.
1701 g_output_stream_async_write_is_via_threads (GOutputStream
*stream
)
1703 GOutputStreamClass
*class;
1705 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1707 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1709 return (class->write_async
== g_output_stream_real_write_async
&&
1710 !(G_IS_POLLABLE_OUTPUT_STREAM (stream
) &&
1711 g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (stream
))));
1715 * g_output_stream_async_close_is_via_threads:
1716 * @stream: output stream
1718 * Checks if an output stream's close_async function uses threads.
1720 * Returns: %TRUE if @stream's close_async function uses threads.
1723 g_output_stream_async_close_is_via_threads (GOutputStream
*stream
)
1725 GOutputStreamClass
*class;
1727 g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream
), FALSE
);
1729 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1731 return class->close_async
== g_output_stream_real_close_async
;
1734 /********************************************
1735 * Default implementation of async ops *
1736 ********************************************/
1740 gsize count_requested
;
1741 gssize count_written
;
1745 free_write_data (WriteData
*op
)
1747 g_slice_free (WriteData
, op
);
1751 write_async_thread (GTask
*task
,
1752 gpointer source_object
,
1754 GCancellable
*cancellable
)
1756 GOutputStream
*stream
= source_object
;
1757 WriteData
*op
= task_data
;
1758 GOutputStreamClass
*class;
1759 GError
*error
= NULL
;
1760 gssize count_written
;
1762 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
1763 count_written
= class->write_fn (stream
, op
->buffer
, op
->count_requested
,
1764 cancellable
, &error
);
1765 if (count_written
== -1)
1766 g_task_return_error (task
, error
);
1768 g_task_return_int (task
, count_written
);
1771 static void write_async_pollable (GPollableOutputStream
*stream
,
1775 write_async_pollable_ready (GPollableOutputStream
*stream
,
1778 GTask
*task
= user_data
;
1780 write_async_pollable (stream
, task
);
1785 write_async_pollable (GPollableOutputStream
*stream
,
1788 GError
*error
= NULL
;
1789 WriteData
*op
= g_task_get_task_data (task
);
1790 gssize count_written
;
1792 if (g_task_return_error_if_cancelled (task
))
1795 count_written
= G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream
)->
1796 write_nonblocking (stream
, op
->buffer
, op
->count_requested
, &error
);
1798 if (g_error_matches (error
, G_IO_ERROR
, G_IO_ERROR_WOULD_BLOCK
))
1802 g_error_free (error
);
1804 source
= g_pollable_output_stream_create_source (stream
,
1805 g_task_get_cancellable (task
));
1806 g_task_attach_source (task
, source
,
1807 (GSourceFunc
) write_async_pollable_ready
);
1808 g_source_unref (source
);
1812 if (count_written
== -1)
1813 g_task_return_error (task
, error
);
1815 g_task_return_int (task
, count_written
);
1819 g_output_stream_real_write_async (GOutputStream
*stream
,
1823 GCancellable
*cancellable
,
1824 GAsyncReadyCallback callback
,
1830 op
= g_slice_new0 (WriteData
);
1831 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1832 g_task_set_check_cancellable (task
, FALSE
);
1833 g_task_set_task_data (task
, op
, (GDestroyNotify
) free_write_data
);
1834 op
->buffer
= buffer
;
1835 op
->count_requested
= count
;
1837 if (!g_output_stream_async_write_is_via_threads (stream
))
1838 write_async_pollable (G_POLLABLE_OUTPUT_STREAM (stream
), task
);
1840 g_task_run_in_thread (task
, write_async_thread
);
1841 g_object_unref (task
);
1845 g_output_stream_real_write_finish (GOutputStream
*stream
,
1846 GAsyncResult
*result
,
1849 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
1851 return g_task_propagate_int (G_TASK (result
), error
);
1855 GInputStream
*source
;
1856 GOutputStreamSpliceFlags flags
;
1865 free_splice_data (SpliceData
*op
)
1867 g_clear_pointer (&op
->buffer
, g_free
);
1868 g_object_unref (op
->source
);
1869 g_clear_error (&op
->error
);
1874 real_splice_async_complete_cb (GTask
*task
)
1876 SpliceData
*op
= g_task_get_task_data (task
);
1878 if (op
->flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE
&&
1879 !g_input_stream_is_closed (op
->source
))
1882 if (op
->flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET
&&
1883 !g_output_stream_is_closed (g_task_get_source_object (task
)))
1886 if (op
->error
!= NULL
)
1888 g_task_return_error (task
, op
->error
);
1893 g_task_return_int (task
, op
->bytes_copied
);
1896 g_object_unref (task
);
1900 real_splice_async_close_input_cb (GObject
*source
,
1904 GTask
*task
= user_data
;
1906 g_input_stream_close_finish (G_INPUT_STREAM (source
), res
, NULL
);
1908 real_splice_async_complete_cb (task
);
1912 real_splice_async_close_output_cb (GObject
*source
,
1916 GTask
*task
= G_TASK (user_data
);
1917 SpliceData
*op
= g_task_get_task_data (task
);
1918 GError
**error
= (op
->error
== NULL
) ? &op
->error
: NULL
;
1920 g_output_stream_internal_close_finish (G_OUTPUT_STREAM (source
), res
, error
);
1922 real_splice_async_complete_cb (task
);
1926 real_splice_async_complete (GTask
*task
)
1928 SpliceData
*op
= g_task_get_task_data (task
);
1929 gboolean done
= TRUE
;
1931 if (op
->flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE
)
1934 g_input_stream_close_async (op
->source
, g_task_get_priority (task
),
1935 g_task_get_cancellable (task
),
1936 real_splice_async_close_input_cb
, task
);
1939 if (op
->flags
& G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET
)
1942 g_output_stream_internal_close_async (g_task_get_source_object (task
),
1943 g_task_get_priority (task
),
1944 g_task_get_cancellable (task
),
1945 real_splice_async_close_output_cb
,
1950 real_splice_async_complete_cb (task
);
1953 static void real_splice_async_read_cb (GObject
*source
,
1955 gpointer user_data
);
1958 real_splice_async_write_cb (GObject
*source
,
1962 GOutputStreamClass
*class;
1963 GTask
*task
= G_TASK (user_data
);
1964 SpliceData
*op
= g_task_get_task_data (task
);
1967 class = G_OUTPUT_STREAM_GET_CLASS (g_task_get_source_object (task
));
1969 ret
= class->write_finish (G_OUTPUT_STREAM (source
), res
, &op
->error
);
1973 real_splice_async_complete (task
);
1977 op
->n_written
+= ret
;
1978 op
->bytes_copied
+= ret
;
1979 if (op
->bytes_copied
> G_MAXSSIZE
)
1980 op
->bytes_copied
= G_MAXSSIZE
;
1982 if (op
->n_written
< op
->n_read
)
1984 class->write_async (g_task_get_source_object (task
),
1985 op
->buffer
+ op
->n_written
,
1986 op
->n_read
- op
->n_written
,
1987 g_task_get_priority (task
),
1988 g_task_get_cancellable (task
),
1989 real_splice_async_write_cb
, task
);
1993 g_input_stream_read_async (op
->source
, op
->buffer
, 8192,
1994 g_task_get_priority (task
),
1995 g_task_get_cancellable (task
),
1996 real_splice_async_read_cb
, task
);
2000 real_splice_async_read_cb (GObject
*source
,
2004 GOutputStreamClass
*class;
2005 GTask
*task
= G_TASK (user_data
);
2006 SpliceData
*op
= g_task_get_task_data (task
);
2009 class = G_OUTPUT_STREAM_GET_CLASS (g_task_get_source_object (task
));
2011 ret
= g_input_stream_read_finish (op
->source
, res
, &op
->error
);
2012 if (ret
== -1 || ret
== 0)
2014 real_splice_async_complete (task
);
2021 class->write_async (g_task_get_source_object (task
), op
->buffer
,
2022 op
->n_read
, g_task_get_priority (task
),
2023 g_task_get_cancellable (task
),
2024 real_splice_async_write_cb
, task
);
2028 splice_async_thread (GTask
*task
,
2029 gpointer source_object
,
2031 GCancellable
*cancellable
)
2033 GOutputStream
*stream
= source_object
;
2034 SpliceData
*op
= task_data
;
2035 GOutputStreamClass
*class;
2036 GError
*error
= NULL
;
2037 gssize bytes_copied
;
2039 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
2041 bytes_copied
= class->splice (stream
,
2046 if (bytes_copied
== -1)
2047 g_task_return_error (task
, error
);
2049 g_task_return_int (task
, bytes_copied
);
2053 g_output_stream_real_splice_async (GOutputStream
*stream
,
2054 GInputStream
*source
,
2055 GOutputStreamSpliceFlags flags
,
2057 GCancellable
*cancellable
,
2058 GAsyncReadyCallback callback
,
2064 op
= g_new0 (SpliceData
, 1);
2065 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
2066 g_task_set_task_data (task
, op
, (GDestroyNotify
)free_splice_data
);
2068 op
->source
= g_object_ref (source
);
2070 if (g_input_stream_async_read_is_via_threads (source
) &&
2071 g_output_stream_async_write_is_via_threads (stream
))
2073 g_task_run_in_thread (task
, splice_async_thread
);
2074 g_object_unref (task
);
2078 op
->buffer
= g_malloc (8192);
2079 g_input_stream_read_async (op
->source
, op
->buffer
, 8192,
2080 g_task_get_priority (task
),
2081 g_task_get_cancellable (task
),
2082 real_splice_async_read_cb
, task
);
2087 g_output_stream_real_splice_finish (GOutputStream
*stream
,
2088 GAsyncResult
*result
,
2091 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
2093 return g_task_propagate_int (G_TASK (result
), error
);
2098 flush_async_thread (GTask
*task
,
2099 gpointer source_object
,
2101 GCancellable
*cancellable
)
2103 GOutputStream
*stream
= source_object
;
2104 GOutputStreamClass
*class;
2106 GError
*error
= NULL
;
2108 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
2111 result
= class->flush (stream
, cancellable
, &error
);
2114 g_task_return_boolean (task
, TRUE
);
2116 g_task_return_error (task
, error
);
2120 g_output_stream_real_flush_async (GOutputStream
*stream
,
2122 GCancellable
*cancellable
,
2123 GAsyncReadyCallback callback
,
2128 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
2129 g_task_set_priority (task
, io_priority
);
2130 g_task_run_in_thread (task
, flush_async_thread
);
2131 g_object_unref (task
);
2135 g_output_stream_real_flush_finish (GOutputStream
*stream
,
2136 GAsyncResult
*result
,
2139 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
2141 return g_task_propagate_boolean (G_TASK (result
), error
);
2145 close_async_thread (GTask
*task
,
2146 gpointer source_object
,
2148 GCancellable
*cancellable
)
2150 GOutputStream
*stream
= source_object
;
2151 GOutputStreamClass
*class;
2152 GError
*error
= NULL
;
2153 gboolean result
= TRUE
;
2155 class = G_OUTPUT_STREAM_GET_CLASS (stream
);
2157 /* Do a flush here if there is a flush function, and we did not have to do
2158 * an async flush before (see g_output_stream_close_async)
2160 if (class->flush
!= NULL
&&
2161 (class->flush_async
== NULL
||
2162 class->flush_async
== g_output_stream_real_flush_async
))
2164 result
= class->flush (stream
, cancellable
, &error
);
2167 /* Auto handling of cancelation disabled, and ignore
2168 cancellation, since we want to close things anyway, although
2169 possibly in a quick-n-dirty way. At least we never want to leak
2172 if (class->close_fn
)
2174 /* Make sure to close, even if the flush failed (see sync close) */
2176 class->close_fn (stream
, cancellable
, NULL
);
2178 result
= class->close_fn (stream
, cancellable
, &error
);
2182 g_task_return_boolean (task
, TRUE
);
2184 g_task_return_error (task
, error
);
2188 g_output_stream_real_close_async (GOutputStream
*stream
,
2190 GCancellable
*cancellable
,
2191 GAsyncReadyCallback callback
,
2196 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
2197 g_task_set_priority (task
, io_priority
);
2198 g_task_run_in_thread (task
, close_async_thread
);
2199 g_object_unref (task
);
2203 g_output_stream_real_close_finish (GOutputStream
*stream
,
2204 GAsyncResult
*result
,
2207 g_return_val_if_fail (g_task_is_valid (result
, stream
), FALSE
);
2209 return g_task_propagate_boolean (G_TASK (result
), error
);