+static void
+read_bytes_callback (GObject *stream,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GTask *task = user_data;
+ guchar *buf = g_task_get_task_data (task);
+ GError *error = NULL;
+ gssize nread;
+ GBytes *bytes = NULL;
+
+ nread = g_input_stream_read_finish (G_INPUT_STREAM (stream),
+ result, &error);
+ if (nread == -1)
+ {
+ g_free (buf);
+ g_task_return_error (task, error);
+ }
+ else if (nread == 0)
+ {
+ g_free (buf);
+ bytes = g_bytes_new_static ("", 0);
+ }
+ else
+ bytes = g_bytes_new_take (buf, nread);
+
+ if (bytes)
+ g_task_return_pointer (task, bytes, (GDestroyNotify)g_bytes_unref);
+
+ g_object_unref (task);
+}
+
+/**
+ * g_input_stream_read_bytes_async:
+ * @stream: A #GInputStream.
+ * @count: the number of bytes that will be read from the stream
+ * @io_priority: the [I/O priority][io-priority] of the request
+ * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
+ * @callback: (scope async): callback to call when the request is satisfied
+ * @user_data: (closure): the data to pass to callback function
+ *
+ * Request an asynchronous read of @count bytes from the stream into a
+ * new #GBytes. When the operation is finished @callback will be
+ * called. You can then call g_input_stream_read_bytes_finish() to get the
+ * result of the operation.
+ *
+ * During an async request no other sync and async calls are allowed
+ * on @stream, and will result in %G_IO_ERROR_PENDING errors.
+ *
+ * A value of @count larger than %G_MAXSSIZE will cause a
+ * %G_IO_ERROR_INVALID_ARGUMENT error.
+ *
+ * On success, the new #GBytes will be passed to the callback. It is
+ * not an error if this is smaller than the requested size, as it can
+ * happen e.g. near the end of a file, but generally we try to read as
+ * many bytes as requested. Zero is returned on end of file (or if
+ * @count is zero), but never otherwise.
+ *
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
+ * priority. Default priority is %G_PRIORITY_DEFAULT.
+ *
+ * Since: 2.34
+ **/
+void
+g_input_stream_read_bytes_async (GInputStream *stream,
+ gsize count,
+ int io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GTask *task;
+ guchar *buf;
+
+ task = g_task_new (stream, cancellable, callback, user_data);
+ buf = g_malloc (count);
+ g_task_set_task_data (task, buf, NULL);
+
+ g_input_stream_read_async (stream, buf, count,
+ io_priority, cancellable,
+ read_bytes_callback, task);
+}
+
+/**
+ * g_input_stream_read_bytes_finish:
+ * @stream: a #GInputStream.
+ * @result: a #GAsyncResult.
+ * @error: a #GError location to store the error occurring, or %NULL to
+ * ignore.
+ *
+ * Finishes an asynchronous stream read-into-#GBytes operation.
+ *
+ * Returns: the newly-allocated #GBytes, or %NULL on error
+ *
+ * Since: 2.34
+ **/
+GBytes *
+g_input_stream_read_bytes_finish (GInputStream *stream,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_return_val_if_fail (G_IS_INPUT_STREAM (stream), NULL);
+ g_return_val_if_fail (g_task_is_valid (result, stream), NULL);
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+