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, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: Alexander Larsson <alexl@redhat.com>
27 #include "ginputstream.h"
28 #include "gseekable.h"
29 #include "gcancellable.h"
30 #include "gasyncresult.h"
31 #include "gsimpleasyncresult.h"
33 #include "gpollableinputstream.h"
36 * SECTION:ginputstream
37 * @short_description: Base class for implementing streaming input
40 * #GInputStream has functions to read from a stream (g_input_stream_read()),
41 * to close a stream (g_input_stream_close()) and to skip some content
42 * (g_input_stream_skip()).
44 * To copy the content of an input stream to an output stream without
45 * manually handling the reads and writes, use g_output_stream_splice().
47 * All of these functions have async variants too.
50 G_DEFINE_ABSTRACT_TYPE (GInputStream, g_input_stream, G_TYPE_OBJECT);
52 struct _GInputStreamPrivate {
55 GAsyncReadyCallback outstanding_callback;
58 static gssize g_input_stream_real_skip (GInputStream *stream,
60 GCancellable *cancellable,
62 static void g_input_stream_real_read_async (GInputStream *stream,
66 GCancellable *cancellable,
67 GAsyncReadyCallback callback,
69 static gssize g_input_stream_real_read_finish (GInputStream *stream,
72 static void g_input_stream_real_skip_async (GInputStream *stream,
75 GCancellable *cancellable,
76 GAsyncReadyCallback callback,
78 static gssize g_input_stream_real_skip_finish (GInputStream *stream,
81 static void g_input_stream_real_close_async (GInputStream *stream,
83 GCancellable *cancellable,
84 GAsyncReadyCallback callback,
86 static gboolean g_input_stream_real_close_finish (GInputStream *stream,
91 g_input_stream_finalize (GObject *object)
93 G_OBJECT_CLASS (g_input_stream_parent_class)->finalize (object);
97 g_input_stream_dispose (GObject *object)
101 stream = G_INPUT_STREAM (object);
103 if (!stream->priv->closed)
104 g_input_stream_close (stream, NULL, NULL);
106 G_OBJECT_CLASS (g_input_stream_parent_class)->dispose (object);
111 g_input_stream_class_init (GInputStreamClass *klass)
113 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
115 g_type_class_add_private (klass, sizeof (GInputStreamPrivate));
117 gobject_class->finalize = g_input_stream_finalize;
118 gobject_class->dispose = g_input_stream_dispose;
120 klass->skip = g_input_stream_real_skip;
121 klass->read_async = g_input_stream_real_read_async;
122 klass->read_finish = g_input_stream_real_read_finish;
123 klass->skip_async = g_input_stream_real_skip_async;
124 klass->skip_finish = g_input_stream_real_skip_finish;
125 klass->close_async = g_input_stream_real_close_async;
126 klass->close_finish = g_input_stream_real_close_finish;
130 g_input_stream_init (GInputStream *stream)
132 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
134 GInputStreamPrivate);
138 * g_input_stream_read:
139 * @stream: a #GInputStream.
140 * @buffer: a buffer to read data into (which should be at least count bytes long).
141 * @count: the number of bytes that will be read from the stream
142 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
143 * @error: location to store the error occurring, or %NULL to ignore
145 * Tries to read @count bytes from the stream into the buffer starting at
146 * @buffer. Will block during this read.
148 * If count is zero returns zero and does nothing. A value of @count
149 * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
151 * On success, the number of bytes read into the buffer is returned.
152 * It is not an error if this is not the same as the requested size, as it
153 * can happen e.g. near the end of a file. Zero is returned on end of file
154 * (or if @count is zero), but never otherwise.
156 * If @cancellable is not %NULL, then the operation can be cancelled by
157 * triggering the cancellable object from another thread. If the operation
158 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
159 * operation was partially finished when the operation was cancelled the
160 * partial result will be returned, without an error.
162 * On error -1 is returned and @error is set accordingly.
164 * Return value: Number of bytes read, or -1 on error, or 0 on end of file.
167 g_input_stream_read (GInputStream *stream,
170 GCancellable *cancellable,
173 GInputStreamClass *class;
176 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
177 g_return_val_if_fail (buffer != NULL, 0);
182 if (((gssize) count) < 0)
184 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
185 _("Too large count value passed to %s"), G_STRFUNC);
189 class = G_INPUT_STREAM_GET_CLASS (stream);
191 if (class->read_fn == NULL)
193 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
194 _("Input stream doesn't implement read"));
198 if (!g_input_stream_set_pending (stream, error))
202 g_cancellable_push_current (cancellable);
204 res = class->read_fn (stream, buffer, count, cancellable, error);
207 g_cancellable_pop_current (cancellable);
209 g_input_stream_clear_pending (stream);
215 * g_input_stream_read_all:
216 * @stream: a #GInputStream.
217 * @buffer: a buffer to read data into (which should be at least count bytes long).
218 * @count: the number of bytes that will be read from the stream
219 * @bytes_read: (out): location to store the number of bytes that was read from the stream
220 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
221 * @error: location to store the error occurring, or %NULL to ignore
223 * Tries to read @count bytes from the stream into the buffer starting at
224 * @buffer. Will block during this read.
226 * This function is similar to g_input_stream_read(), except it tries to
227 * read as many bytes as requested, only stopping on an error or end of stream.
229 * On a successful read of @count bytes, or if we reached the end of the
230 * stream, %TRUE is returned, and @bytes_read is set to the number of bytes
233 * If there is an error during the operation %FALSE is returned and @error
234 * is set to indicate the error status, @bytes_read is updated to contain
235 * the number of bytes read into @buffer before the error occurred.
237 * Return value: %TRUE on success, %FALSE if there was an error
240 g_input_stream_read_all (GInputStream *stream,
244 GCancellable *cancellable,
250 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
251 g_return_val_if_fail (buffer != NULL, FALSE);
254 while (_bytes_read < count)
256 res = g_input_stream_read (stream, (char *)buffer + _bytes_read, count - _bytes_read,
261 *bytes_read = _bytes_read;
272 *bytes_read = _bytes_read;
277 * g_input_stream_read_bytes:
278 * @stream: a #GInputStream.
279 * @count: maximum number of bytes that will be read from the stream. Common
280 * values include 4096 and 8192.
281 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
282 * @error: location to store the error occurring, or %NULL to ignore
284 * Like g_input_stream_read(), this tries to read @count bytes from
285 * the stream in a blocking fashion. However, rather than reading into
286 * a user-supplied buffer, this will create a new #GBytes containing
287 * the data that was read. This may be easier to use from language
290 * If count is zero, returns a zero-length #GBytes and does nothing. A
291 * value of @count larger than %G_MAXSSIZE will cause a
292 * %G_IO_ERROR_INVALID_ARGUMENT error.
294 * On success, a new #GBytes is returned. It is not an error if the
295 * size of this object is not the same as the requested size, as it
296 * can happen e.g. near the end of a file. A zero-length #GBytes is
297 * returned on end of file (or if @count is zero), but never
300 * If @cancellable is not %NULL, then the operation can be cancelled by
301 * triggering the cancellable object from another thread. If the operation
302 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
303 * operation was partially finished when the operation was cancelled the
304 * partial result will be returned, without an error.
306 * On error %NULL is returned and @error is set accordingly.
308 * Return value: a new #GBytes, or %NULL on error
311 g_input_stream_read_bytes (GInputStream *stream,
313 GCancellable *cancellable,
319 buf = g_malloc (count);
320 nread = g_input_stream_read (stream, buf, count, cancellable, error);
329 return g_bytes_new_static ("", 0);
332 return g_bytes_new_take (buf, nread);
336 * g_input_stream_skip:
337 * @stream: a #GInputStream.
338 * @count: the number of bytes that will be skipped from the stream
339 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
340 * @error: location to store the error occurring, or %NULL to ignore
342 * Tries to skip @count bytes from the stream. Will block during the operation.
344 * This is identical to g_input_stream_read(), from a behaviour standpoint,
345 * but the bytes that are skipped are not returned to the user. Some
346 * streams have an implementation that is more efficient than reading the data.
348 * This function is optional for inherited classes, as the default implementation
349 * emulates it using read.
351 * If @cancellable is not %NULL, then the operation can be cancelled by
352 * triggering the cancellable object from another thread. If the operation
353 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
354 * operation was partially finished when the operation was cancelled the
355 * partial result will be returned, without an error.
357 * Return value: Number of bytes skipped, or -1 on error
360 g_input_stream_skip (GInputStream *stream,
362 GCancellable *cancellable,
365 GInputStreamClass *class;
368 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
373 if (((gssize) count) < 0)
375 g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
376 _("Too large count value passed to %s"), G_STRFUNC);
380 class = G_INPUT_STREAM_GET_CLASS (stream);
382 if (!g_input_stream_set_pending (stream, error))
386 g_cancellable_push_current (cancellable);
388 res = class->skip (stream, count, cancellable, error);
391 g_cancellable_pop_current (cancellable);
393 g_input_stream_clear_pending (stream);
399 g_input_stream_real_skip (GInputStream *stream,
401 GCancellable *cancellable,
404 GInputStreamClass *class;
405 gssize ret, read_bytes;
409 if (G_IS_SEEKABLE (stream) && g_seekable_can_seek (G_SEEKABLE (stream)))
411 if (g_seekable_seek (G_SEEKABLE (stream),
419 /* If not seekable, or seek failed, fall back to reading data: */
421 class = G_INPUT_STREAM_GET_CLASS (stream);
428 ret = class->read_fn (stream, buffer, MIN (sizeof (buffer), count),
429 cancellable, &my_error);
432 if (read_bytes > 0 &&
433 my_error->domain == G_IO_ERROR &&
434 my_error->code == G_IO_ERROR_CANCELLED)
436 g_error_free (my_error);
440 g_propagate_error (error, my_error);
447 if (ret == 0 || count == 0)
453 * g_input_stream_close:
454 * @stream: A #GInputStream.
455 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
456 * @error: location to store the error occurring, or %NULL to ignore
458 * Closes the stream, releasing resources related to it.
460 * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
461 * Closing a stream multiple times will not return an error.
463 * Streams will be automatically closed when the last reference
464 * is dropped, but you might want to call this function to make sure
465 * resources are released as early as possible.
467 * Some streams might keep the backing store of the stream (e.g. a file descriptor)
468 * open after the stream is closed. See the documentation for the individual
469 * stream for details.
471 * On failure the first error that happened will be reported, but the close
472 * operation will finish as much as possible. A stream that failed to
473 * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
474 * is important to check and report the error to the user.
476 * If @cancellable is not %NULL, then the operation can be cancelled by
477 * triggering the cancellable object from another thread. If the operation
478 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
479 * Cancelling a close will still leave the stream closed, but some streams
480 * can use a faster close that doesn't block to e.g. check errors.
482 * Return value: %TRUE on success, %FALSE on failure
485 g_input_stream_close (GInputStream *stream,
486 GCancellable *cancellable,
489 GInputStreamClass *class;
492 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
494 class = G_INPUT_STREAM_GET_CLASS (stream);
496 if (stream->priv->closed)
501 if (!g_input_stream_set_pending (stream, error))
505 g_cancellable_push_current (cancellable);
508 res = class->close_fn (stream, cancellable, error);
511 g_cancellable_pop_current (cancellable);
513 g_input_stream_clear_pending (stream);
515 stream->priv->closed = TRUE;
521 async_ready_callback_wrapper (GObject *source_object,
525 GInputStream *stream = G_INPUT_STREAM (source_object);
527 g_input_stream_clear_pending (stream);
528 if (stream->priv->outstanding_callback)
529 (*stream->priv->outstanding_callback) (source_object, res, user_data);
530 g_object_unref (stream);
534 async_ready_close_callback_wrapper (GObject *source_object,
538 GInputStream *stream = G_INPUT_STREAM (source_object);
540 g_input_stream_clear_pending (stream);
541 stream->priv->closed = TRUE;
542 if (stream->priv->outstanding_callback)
543 (*stream->priv->outstanding_callback) (source_object, res, user_data);
544 g_object_unref (stream);
548 * g_input_stream_read_async:
549 * @stream: A #GInputStream.
550 * @buffer: a buffer to read data into (which should be at least count bytes long).
551 * @count: the number of bytes that will be read from the stream
552 * @io_priority: the <link linkend="io-priority">I/O priority</link>
554 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
555 * @callback: (scope async): callback to call when the request is satisfied
556 * @user_data: (closure): the data to pass to callback function
558 * Request an asynchronous read of @count bytes from the stream into the buffer
559 * starting at @buffer. When the operation is finished @callback will be called.
560 * You can then call g_input_stream_read_finish() to get the result of the
563 * During an async request no other sync and async calls are allowed on @stream, and will
564 * result in %G_IO_ERROR_PENDING errors.
566 * A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
568 * On success, the number of bytes read into the buffer will be passed to the
569 * callback. It is not an error if this is not the same as the requested size, as it
570 * can happen e.g. near the end of a file, but generally we try to read
571 * as many bytes as requested. Zero is returned on end of file
572 * (or if @count is zero), but never otherwise.
574 * Any outstanding i/o request with higher priority (lower numerical value) will
575 * be executed before an outstanding request with lower priority. Default
576 * priority is %G_PRIORITY_DEFAULT.
578 * The asyncronous methods have a default fallback that uses threads to implement
579 * asynchronicity, so they are optional for inheriting classes. However, if you
580 * override one you must override all.
583 g_input_stream_read_async (GInputStream *stream,
587 GCancellable *cancellable,
588 GAsyncReadyCallback callback,
591 GInputStreamClass *class;
592 GSimpleAsyncResult *simple;
593 GError *error = NULL;
595 g_return_if_fail (G_IS_INPUT_STREAM (stream));
596 g_return_if_fail (buffer != NULL);
600 simple = g_simple_async_result_new (G_OBJECT (stream),
603 g_input_stream_read_async);
604 g_simple_async_result_complete_in_idle (simple);
605 g_object_unref (simple);
609 if (((gssize) count) < 0)
611 g_simple_async_report_error_in_idle (G_OBJECT (stream),
614 G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
615 _("Too large count value passed to %s"),
620 if (!g_input_stream_set_pending (stream, &error))
622 g_simple_async_report_take_gerror_in_idle (G_OBJECT (stream),
629 class = G_INPUT_STREAM_GET_CLASS (stream);
630 stream->priv->outstanding_callback = callback;
631 g_object_ref (stream);
632 class->read_async (stream, buffer, count, io_priority, cancellable,
633 async_ready_callback_wrapper, user_data);
637 * g_input_stream_read_finish:
638 * @stream: a #GInputStream.
639 * @result: a #GAsyncResult.
640 * @error: a #GError location to store the error occurring, or %NULL to
643 * Finishes an asynchronous stream read operation.
645 * Returns: number of bytes read in, or -1 on error, or 0 on end of file.
648 g_input_stream_read_finish (GInputStream *stream,
649 GAsyncResult *result,
652 GInputStreamClass *class;
654 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
655 g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
657 if (g_async_result_legacy_propagate_error (result, error))
659 else if (g_async_result_is_tagged (result, g_input_stream_read_async))
661 /* Special case read of 0 bytes */
665 class = G_INPUT_STREAM_GET_CLASS (stream);
666 return class->read_finish (stream, result, error);
670 read_bytes_callback (GObject *stream,
671 GAsyncResult *result,
674 GSimpleAsyncResult *simple = user_data;
675 guchar *buf = g_simple_async_result_get_op_res_gpointer (simple);
676 GError *error = NULL;
678 GBytes *bytes = NULL;
680 nread = g_input_stream_read_finish (G_INPUT_STREAM (stream),
685 g_simple_async_result_take_error (simple, error);
690 bytes = g_bytes_new_static ("", 0);
693 bytes = g_bytes_new_take (buf, nread);
697 g_simple_async_result_set_op_res_gpointer (simple, bytes,
698 (GDestroyNotify)g_bytes_unref);
700 g_simple_async_result_complete (simple);
701 g_object_unref (simple);
705 * g_input_stream_read_bytes_async:
706 * @stream: A #GInputStream.
707 * @count: the number of bytes that will be read from the stream
708 * @io_priority: the <link linkend="io-priority">I/O priority</link>
710 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
711 * @callback: (scope async): callback to call when the request is satisfied
712 * @user_data: (closure): the data to pass to callback function
714 * Request an asynchronous read of @count bytes from the stream into a
715 * new #GBytes. When the operation is finished @callback will be
716 * called. You can then call g_input_stream_read_bytes_finish() to get the
717 * result of the operation.
719 * During an async request no other sync and async calls are allowed
720 * on @stream, and will result in %G_IO_ERROR_PENDING errors.
722 * A value of @count larger than %G_MAXSSIZE will cause a
723 * %G_IO_ERROR_INVALID_ARGUMENT error.
725 * On success, the new #GBytes will be passed to the callback. It is
726 * not an error if this is smaller than the requested size, as it can
727 * happen e.g. near the end of a file, but generally we try to read as
728 * many bytes as requested. Zero is returned on end of file (or if
729 * @count is zero), but never otherwise.
731 * Any outstanding I/O request with higher priority (lower numerical
732 * value) will be executed before an outstanding request with lower
733 * priority. Default priority is %G_PRIORITY_DEFAULT.
736 g_input_stream_read_bytes_async (GInputStream *stream,
739 GCancellable *cancellable,
740 GAsyncReadyCallback callback,
743 GSimpleAsyncResult *simple;
746 simple = g_simple_async_result_new (G_OBJECT (stream),
748 g_input_stream_read_bytes_async);
749 buf = g_malloc (count);
750 g_simple_async_result_set_op_res_gpointer (simple, buf, NULL);
752 g_input_stream_read_async (stream, buf, count,
753 io_priority, cancellable,
754 read_bytes_callback, simple);
758 * g_input_stream_read_bytes_finish:
759 * @stream: a #GInputStream.
760 * @result: a #GAsyncResult.
761 * @error: a #GError location to store the error occurring, or %NULL to
764 * Finishes an asynchronous stream read-into-#GBytes operation.
766 * Returns: the newly-allocated #GBytes, or %NULL on error
769 g_input_stream_read_bytes_finish (GInputStream *stream,
770 GAsyncResult *result,
773 GSimpleAsyncResult *simple;
775 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), NULL);
776 g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (stream), g_input_stream_read_bytes_async), NULL);
778 simple = G_SIMPLE_ASYNC_RESULT (result);
779 if (g_simple_async_result_propagate_error (simple, error))
781 return g_bytes_ref (g_simple_async_result_get_op_res_gpointer (simple));
785 * g_input_stream_skip_async:
786 * @stream: A #GInputStream.
787 * @count: the number of bytes that will be skipped from the stream
788 * @io_priority: the <link linkend="io-priority">I/O priority</link>
790 * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
791 * @callback: (scope async): callback to call when the request is satisfied
792 * @user_data: (closure): the data to pass to callback function
794 * Request an asynchronous skip of @count bytes from the stream.
795 * When the operation is finished @callback will be called.
796 * You can then call g_input_stream_skip_finish() to get the result
799 * During an async request no other sync and async calls are allowed,
800 * and will result in %G_IO_ERROR_PENDING errors.
802 * A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
804 * On success, the number of bytes skipped will be passed to the callback.
805 * It is not an error if this is not the same as the requested size, as it
806 * can happen e.g. near the end of a file, but generally we try to skip
807 * as many bytes as requested. Zero is returned on end of file
808 * (or if @count is zero), but never otherwise.
810 * Any outstanding i/o request with higher priority (lower numerical value)
811 * will be executed before an outstanding request with lower priority.
812 * Default priority is %G_PRIORITY_DEFAULT.
814 * The asynchronous methods have a default fallback that uses threads to
815 * implement asynchronicity, so they are optional for inheriting classes.
816 * However, if you override one, you must override all.
819 g_input_stream_skip_async (GInputStream *stream,
822 GCancellable *cancellable,
823 GAsyncReadyCallback callback,
826 GInputStreamClass *class;
827 GSimpleAsyncResult *simple;
828 GError *error = NULL;
830 g_return_if_fail (G_IS_INPUT_STREAM (stream));
834 simple = g_simple_async_result_new (G_OBJECT (stream),
837 g_input_stream_skip_async);
839 g_simple_async_result_complete_in_idle (simple);
840 g_object_unref (simple);
844 if (((gssize) count) < 0)
846 g_simple_async_report_error_in_idle (G_OBJECT (stream),
849 G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
850 _("Too large count value passed to %s"),
855 if (!g_input_stream_set_pending (stream, &error))
857 g_simple_async_report_take_gerror_in_idle (G_OBJECT (stream),
864 class = G_INPUT_STREAM_GET_CLASS (stream);
865 stream->priv->outstanding_callback = callback;
866 g_object_ref (stream);
867 class->skip_async (stream, count, io_priority, cancellable,
868 async_ready_callback_wrapper, user_data);
872 * g_input_stream_skip_finish:
873 * @stream: a #GInputStream.
874 * @result: a #GAsyncResult.
875 * @error: a #GError location to store the error occurring, or %NULL to
878 * Finishes a stream skip operation.
880 * Returns: the size of the bytes skipped, or %-1 on error.
883 g_input_stream_skip_finish (GInputStream *stream,
884 GAsyncResult *result,
887 GInputStreamClass *class;
889 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
890 g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
892 if (g_async_result_legacy_propagate_error (result, error))
894 else if (g_async_result_is_tagged (result, g_input_stream_skip_async))
896 /* Special case skip of 0 bytes */
900 class = G_INPUT_STREAM_GET_CLASS (stream);
901 return class->skip_finish (stream, result, error);
905 * g_input_stream_close_async:
906 * @stream: A #GInputStream.
907 * @io_priority: the <link linkend="io-priority">I/O priority</link>
909 * @cancellable: (allow-none): optional cancellable object
910 * @callback: (scope async): callback to call when the request is satisfied
911 * @user_data: (closure): the data to pass to callback function
913 * Requests an asynchronous closes of the stream, releasing resources related to it.
914 * When the operation is finished @callback will be called.
915 * You can then call g_input_stream_close_finish() to get the result of the
918 * For behaviour details see g_input_stream_close().
920 * The asyncronous methods have a default fallback that uses threads to implement
921 * asynchronicity, so they are optional for inheriting classes. However, if you
922 * override one you must override all.
925 g_input_stream_close_async (GInputStream *stream,
927 GCancellable *cancellable,
928 GAsyncReadyCallback callback,
931 GInputStreamClass *class;
932 GSimpleAsyncResult *simple;
933 GError *error = NULL;
935 g_return_if_fail (G_IS_INPUT_STREAM (stream));
937 if (stream->priv->closed)
939 simple = g_simple_async_result_new (G_OBJECT (stream),
942 g_input_stream_close_async);
944 g_simple_async_result_complete_in_idle (simple);
945 g_object_unref (simple);
949 if (!g_input_stream_set_pending (stream, &error))
951 g_simple_async_report_take_gerror_in_idle (G_OBJECT (stream),
958 class = G_INPUT_STREAM_GET_CLASS (stream);
959 stream->priv->outstanding_callback = callback;
960 g_object_ref (stream);
961 class->close_async (stream, io_priority, cancellable,
962 async_ready_close_callback_wrapper, user_data);
966 * g_input_stream_close_finish:
967 * @stream: a #GInputStream.
968 * @result: a #GAsyncResult.
969 * @error: a #GError location to store the error occurring, or %NULL to
972 * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
974 * Returns: %TRUE if the stream was closed successfully.
977 g_input_stream_close_finish (GInputStream *stream,
978 GAsyncResult *result,
981 GInputStreamClass *class;
983 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
984 g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
986 if (g_async_result_legacy_propagate_error (result, error))
988 else if (g_async_result_is_tagged (result, g_input_stream_close_async))
990 /* Special case already closed */
994 class = G_INPUT_STREAM_GET_CLASS (stream);
995 return class->close_finish (stream, result, error);
999 * g_input_stream_is_closed:
1000 * @stream: input stream.
1002 * Checks if an input stream is closed.
1004 * Returns: %TRUE if the stream is closed.
1007 g_input_stream_is_closed (GInputStream *stream)
1009 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), TRUE);
1011 return stream->priv->closed;
1015 * g_input_stream_has_pending:
1016 * @stream: input stream.
1018 * Checks if an input stream has pending actions.
1020 * Returns: %TRUE if @stream has pending actions.
1023 g_input_stream_has_pending (GInputStream *stream)
1025 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), TRUE);
1027 return stream->priv->pending;
1031 * g_input_stream_set_pending:
1032 * @stream: input stream
1033 * @error: a #GError location to store the error occurring, or %NULL to
1036 * Sets @stream to have actions pending. If the pending flag is
1037 * already set or @stream is closed, it will return %FALSE and set
1040 * Return value: %TRUE if pending was previously unset and is now set.
1043 g_input_stream_set_pending (GInputStream *stream, GError **error)
1045 g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
1047 if (stream->priv->closed)
1049 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
1050 _("Stream is already closed"));
1054 if (stream->priv->pending)
1056 g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
1057 /* Translators: This is an error you get if there is already an
1058 * operation running against this stream when you try to start
1060 _("Stream has outstanding operation"));
1064 stream->priv->pending = TRUE;
1069 * g_input_stream_clear_pending:
1070 * @stream: input stream
1072 * Clears the pending flag on @stream.
1075 g_input_stream_clear_pending (GInputStream *stream)
1077 g_return_if_fail (G_IS_INPUT_STREAM (stream));
1079 stream->priv->pending = FALSE;
1082 /********************************************
1083 * Default implementation of async ops *
1084 ********************************************/
1088 gsize count_requested;
1091 GCancellable *cancellable;
1097 free_read_data (ReadData *op)
1099 if (op->cancellable)
1100 g_object_unref (op->cancellable);
1101 g_slice_free (ReadData, op);
1105 read_async_thread (GSimpleAsyncResult *res,
1107 GCancellable *cancellable)
1110 GInputStreamClass *class;
1111 GError *error = NULL;
1113 op = g_simple_async_result_get_op_res_gpointer (res);
1115 class = G_INPUT_STREAM_GET_CLASS (object);
1117 op->count_read = class->read_fn (G_INPUT_STREAM (object),
1118 op->buffer, op->count_requested,
1119 cancellable, &error);
1120 if (op->count_read == -1)
1121 g_simple_async_result_take_error (res, error);
1124 static void read_async_pollable (GPollableInputStream *stream,
1125 GSimpleAsyncResult *result);
1128 read_async_pollable_ready (GPollableInputStream *stream,
1131 GSimpleAsyncResult *result = user_data;
1133 read_async_pollable (stream, result);
1138 read_async_pollable (GPollableInputStream *stream,
1139 GSimpleAsyncResult *result)
1141 GError *error = NULL;
1142 ReadData *op = g_simple_async_result_get_op_res_gpointer (result);
1144 if (g_cancellable_set_error_if_cancelled (op->cancellable, &error))
1145 op->count_read = -1;
1148 op->count_read = G_POLLABLE_INPUT_STREAM_GET_INTERFACE (stream)->
1149 read_nonblocking (stream, op->buffer, op->count_requested, &error);
1152 if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
1156 g_error_free (error);
1157 op->need_idle = FALSE;
1159 source = g_pollable_input_stream_create_source (stream, op->cancellable);
1160 g_source_set_callback (source,
1161 (GSourceFunc) read_async_pollable_ready,
1162 g_object_ref (result), g_object_unref);
1163 g_source_set_priority (source, op->io_priority);
1164 g_source_attach (source, g_main_context_get_thread_default ());
1165 g_source_unref (source);
1169 if (op->count_read == -1)
1170 g_simple_async_result_take_error (result, error);
1173 g_simple_async_result_complete_in_idle (result);
1175 g_simple_async_result_complete (result);
1179 g_input_stream_real_read_async (GInputStream *stream,
1183 GCancellable *cancellable,
1184 GAsyncReadyCallback callback,
1187 GSimpleAsyncResult *res;
1190 op = g_slice_new0 (ReadData);
1191 res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_input_stream_real_read_async);
1192 g_simple_async_result_set_op_res_gpointer (res, op, (GDestroyNotify) free_read_data);
1193 op->buffer = buffer;
1194 op->count_requested = count;
1195 op->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
1196 op->io_priority = io_priority;
1197 op->need_idle = TRUE;
1199 if (G_IS_POLLABLE_INPUT_STREAM (stream) &&
1200 g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (stream)))
1201 read_async_pollable (G_POLLABLE_INPUT_STREAM (stream), res);
1203 g_simple_async_result_run_in_thread (res, read_async_thread, io_priority, cancellable);
1204 g_object_unref (res);
1208 g_input_stream_real_read_finish (GInputStream *stream,
1209 GAsyncResult *result,
1212 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1215 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) ==
1216 g_input_stream_real_read_async);
1218 if (g_simple_async_result_propagate_error (simple, error))
1221 op = g_simple_async_result_get_op_res_gpointer (simple);
1223 return op->count_read;
1227 gsize count_requested;
1228 gssize count_skipped;
1233 skip_async_thread (GSimpleAsyncResult *res,
1235 GCancellable *cancellable)
1238 GInputStreamClass *class;
1239 GError *error = NULL;
1241 class = G_INPUT_STREAM_GET_CLASS (object);
1242 op = g_simple_async_result_get_op_res_gpointer (res);
1243 op->count_skipped = class->skip (G_INPUT_STREAM (object),
1244 op->count_requested,
1245 cancellable, &error);
1246 if (op->count_skipped == -1)
1247 g_simple_async_result_take_error (res, error);
1253 gsize count_skipped;
1255 GCancellable *cancellable;
1257 GAsyncReadyCallback callback;
1258 } SkipFallbackAsyncData;
1261 skip_callback_wrapper (GObject *source_object,
1265 GInputStreamClass *class;
1266 SkipFallbackAsyncData *data = user_data;
1268 GSimpleAsyncResult *simple;
1269 GError *error = NULL;
1272 ret = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);
1277 data->count_skipped += ret;
1279 if (data->count > 0)
1281 class = G_INPUT_STREAM_GET_CLASS (source_object);
1282 class->read_async (G_INPUT_STREAM (source_object), data->buffer, MIN (8192, data->count), data->io_prio, data->cancellable,
1283 skip_callback_wrapper, data);
1288 op = g_new0 (SkipData, 1);
1289 op->count_skipped = data->count_skipped;
1290 simple = g_simple_async_result_new (source_object,
1291 data->callback, data->user_data,
1292 g_input_stream_real_skip_async);
1294 g_simple_async_result_set_op_res_gpointer (simple, op, g_free);
1298 if (data->count_skipped &&
1299 g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
1300 /* No error, return partial read */
1301 g_error_free (error);
1303 g_simple_async_result_take_error (simple, error);
1306 /* Complete immediately, not in idle, since we're already in a mainloop callout */
1307 g_simple_async_result_complete (simple);
1308 g_object_unref (simple);
1314 g_input_stream_real_skip_async (GInputStream *stream,
1317 GCancellable *cancellable,
1318 GAsyncReadyCallback callback,
1321 GInputStreamClass *class;
1323 SkipFallbackAsyncData *data;
1324 GSimpleAsyncResult *res;
1326 class = G_INPUT_STREAM_GET_CLASS (stream);
1328 if (class->read_async == g_input_stream_real_read_async)
1330 /* Read is thread-using async fallback.
1331 * Make skip use threads too, so that we can use a possible sync skip
1332 * implementation. */
1333 op = g_new0 (SkipData, 1);
1335 res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data,
1336 g_input_stream_real_skip_async);
1338 g_simple_async_result_set_op_res_gpointer (res, op, g_free);
1340 op->count_requested = count;
1342 g_simple_async_result_run_in_thread (res, skip_async_thread, io_priority, cancellable);
1343 g_object_unref (res);
1347 /* TODO: Skip fallback uses too much memory, should do multiple read calls */
1349 /* There is a custom async read function, lets use that. */
1350 data = g_new (SkipFallbackAsyncData, 1);
1351 data->count = count;
1352 data->count_skipped = 0;
1353 data->io_prio = io_priority;
1354 data->cancellable = cancellable;
1355 data->callback = callback;
1356 data->user_data = user_data;
1357 class->read_async (stream, data->buffer, MIN (8192, count), io_priority, cancellable,
1358 skip_callback_wrapper, data);
1364 g_input_stream_real_skip_finish (GInputStream *stream,
1365 GAsyncResult *result,
1368 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1371 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_input_stream_real_skip_async);
1373 if (g_simple_async_result_propagate_error (simple, error))
1376 op = g_simple_async_result_get_op_res_gpointer (simple);
1377 return op->count_skipped;
1381 close_async_thread (GSimpleAsyncResult *res,
1383 GCancellable *cancellable)
1385 GInputStreamClass *class;
1386 GError *error = NULL;
1389 /* Auto handling of cancelation disabled, and ignore
1390 cancellation, since we want to close things anyway, although
1391 possibly in a quick-n-dirty way. At least we never want to leak
1394 class = G_INPUT_STREAM_GET_CLASS (object);
1395 if (class->close_fn)
1397 result = class->close_fn (G_INPUT_STREAM (object), cancellable, &error);
1399 g_simple_async_result_take_error (res, error);
1404 g_input_stream_real_close_async (GInputStream *stream,
1406 GCancellable *cancellable,
1407 GAsyncReadyCallback callback,
1410 GSimpleAsyncResult *res;
1412 res = g_simple_async_result_new (G_OBJECT (stream),
1415 g_input_stream_real_close_async);
1417 g_simple_async_result_set_handle_cancellation (res, FALSE);
1419 g_simple_async_result_run_in_thread (res,
1423 g_object_unref (res);
1427 g_input_stream_real_close_finish (GInputStream *stream,
1428 GAsyncResult *result,
1431 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1433 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_input_stream_real_close_async);
1435 if (g_simple_async_result_propagate_error (simple, error))