Doc improvements
[platform/upstream/glib.git] / gio / ginputstream.c
1 /* GIO - GLib Input, Output and Streaming Library
2  * 
3  * Copyright (C) 2006-2007 Red Hat, Inc.
4  *
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.
9  *
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.
14  *
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.
19  *
20  * Author: Alexander Larsson <alexl@redhat.com>
21  */
22
23 #include <config.h>
24 #include <glib.h>
25 #include "glibintl.h"
26
27 #include "ginputstream.h"
28 #include "gseekable.h"
29 #include "gsimpleasyncresult.h"
30
31 #include "gioalias.h"
32
33 /**
34  * SECTION:ginputstream
35  * @short_description: Base class for implementing streaming input
36  *
37  * 
38  * 
39  **/
40
41 G_DEFINE_TYPE (GInputStream, g_input_stream, G_TYPE_OBJECT);
42
43 struct _GInputStreamPrivate {
44   guint closed : 1;
45   guint pending : 1;
46   GAsyncReadyCallback outstanding_callback;
47 };
48
49 static gssize   g_input_stream_real_skip         (GInputStream         *stream,
50                                                   gsize                 count,
51                                                   GCancellable         *cancellable,
52                                                   GError              **error);
53 static void     g_input_stream_real_read_async   (GInputStream         *stream,
54                                                   void                 *buffer,
55                                                   gsize                 count,
56                                                   int                   io_priority,
57                                                   GCancellable         *cancellable,
58                                                   GAsyncReadyCallback   callback,
59                                                   gpointer              user_data);
60 static gssize   g_input_stream_real_read_finish  (GInputStream         *stream,
61                                                   GAsyncResult         *result,
62                                                   GError              **error);
63 static void     g_input_stream_real_skip_async   (GInputStream         *stream,
64                                                   gsize                 count,
65                                                   int                   io_priority,
66                                                   GCancellable         *cancellable,
67                                                   GAsyncReadyCallback   callback,
68                                                   gpointer              data);
69 static gssize   g_input_stream_real_skip_finish  (GInputStream         *stream,
70                                                   GAsyncResult         *result,
71                                                   GError              **error);
72 static void     g_input_stream_real_close_async  (GInputStream         *stream,
73                                                   int                   io_priority,
74                                                   GCancellable         *cancellable,
75                                                   GAsyncReadyCallback   callback,
76                                                   gpointer              data);
77 static gboolean g_input_stream_real_close_finish (GInputStream         *stream,
78                                                   GAsyncResult         *result,
79                                                   GError              **error);
80
81 static void
82 g_input_stream_finalize (GObject *object)
83 {
84   GInputStream *stream;
85
86   stream = G_INPUT_STREAM (object);
87   
88   if (!stream->priv->closed)
89     g_input_stream_close (stream, NULL, NULL);
90
91   if (G_OBJECT_CLASS (g_input_stream_parent_class)->finalize)
92     (*G_OBJECT_CLASS (g_input_stream_parent_class)->finalize) (object);
93 }
94
95 static void
96 g_input_stream_dispose (GObject *object)
97 {
98   GInputStream *stream;
99
100   stream = G_INPUT_STREAM (object);
101   
102   if (!stream->priv->closed)
103     g_input_stream_close (stream, NULL, NULL);
104   
105   if (G_OBJECT_CLASS (g_input_stream_parent_class)->dispose)
106     (*G_OBJECT_CLASS (g_input_stream_parent_class)->dispose) (object);
107 }
108
109
110 static void
111 g_input_stream_class_init (GInputStreamClass *klass)
112 {
113   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
114   
115   g_type_class_add_private (klass, sizeof (GInputStreamPrivate));
116   
117   gobject_class->finalize = g_input_stream_finalize;
118   gobject_class->dispose = g_input_stream_dispose;
119   
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;
127 }
128
129 static void
130 g_input_stream_init (GInputStream *stream)
131 {
132   stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
133                                               G_TYPE_INPUT_STREAM,
134                                               GInputStreamPrivate);
135 }
136
137 /**
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: optional #GCancellable object, %NULL to ignore.
143  * @error: location to store the error occuring, or %NULL to ignore
144  *
145  * Tries to read @count bytes from the stream into the buffer starting at
146  * @buffer. Will block during this read.
147  * 
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.
150  *
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.
155  *
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.
161  *
162  * On error -1 is returned and @error is set accordingly.
163  * 
164  * Return value: Number of bytes read, or -1 on error
165  **/
166 gssize
167 g_input_stream_read  (GInputStream  *stream,
168                       void          *buffer,
169                       gsize          count,
170                       GCancellable  *cancellable,
171                       GError       **error)
172 {
173   GInputStreamClass *class;
174   gssize res;
175
176   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
177   g_return_val_if_fail (buffer != NULL, 0);
178
179   if (count == 0)
180     return 0;
181   
182   if (((gssize) count) < 0)
183     {
184       g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
185                    _("Too large count value passed to g_input_stream_read"));
186       return -1;
187     }
188
189   if (stream->priv->closed)
190     {
191       g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
192                    _("Stream is already closed"));
193       return -1;
194     }
195   
196   if (stream->priv->pending)
197     {
198       g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
199                    _("Stream has outstanding operation"));
200       return -1;
201     }
202   
203   class = G_INPUT_STREAM_GET_CLASS (stream);
204
205   if (class->read == NULL) 
206     {
207       g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
208                    _("Input stream doesn't implement read"));
209       return -1;
210     }
211
212   if (cancellable)
213     g_push_current_cancellable (cancellable);
214   
215   stream->priv->pending = TRUE;
216   res = class->read (stream, buffer, count, cancellable, error);
217   stream->priv->pending = FALSE;
218
219   if (cancellable)
220     g_pop_current_cancellable (cancellable);
221   
222   return res;
223 }
224
225 /**
226  * g_input_stream_read_all:
227  * @stream: a #GInputStream.
228  * @buffer: a buffer to read data into (which should be at least count bytes long).
229  * @count: the number of bytes that will be read from the stream
230  * @bytes_read: location to store the number of bytes that was read from the stream
231  * @cancellable: optional #GCancellable object, %NULL to ignore.
232  * @error: location to store the error occuring, or %NULL to ignore
233  *
234  * Tries to read @count bytes from the stream into the buffer starting at
235  * @buffer. Will block during this read.
236  *
237  * This function is similar to g_input_stream_read(), except it tries to
238  * read as many bytes as requested, only stopping on an error or end of stream.
239  *
240  * On a successful read of @count bytes, or if we reached the end of the
241  * stream,  %TRUE is returned, and @bytes_read is set to the number of bytes
242  * read into @buffer.
243  * 
244  * If there is an error during the operation %FALSE is returned and @error
245  * is set to indicate the error status, @bytes_read is updated to contain
246  * the number of bytes read into @buffer before the error occured.
247  *
248  * Return value: %TRUE on success, %FALSE if there was an error
249  **/
250 gboolean
251 g_input_stream_read_all (GInputStream  *stream,
252                          void          *buffer,
253                          gsize          count,
254                          gsize         *bytes_read,
255                          GCancellable  *cancellable,
256                          GError       **error)
257 {
258   gsize _bytes_read;
259   gssize res;
260
261   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
262   g_return_val_if_fail (buffer != NULL, FALSE);
263
264   _bytes_read = 0;
265   while (_bytes_read < count)
266     {
267       res = g_input_stream_read (stream, (char *)buffer + _bytes_read, count - _bytes_read,
268                                  cancellable, error);
269       if (res == -1)
270         {
271           if (bytes_read)
272             *bytes_read = _bytes_read;
273           return FALSE;
274         }
275       
276       if (res == 0)
277         break;
278
279       _bytes_read += res;
280     }
281
282   if (bytes_read)
283     *bytes_read = _bytes_read;
284   return TRUE;
285 }
286
287 /**
288  * g_input_stream_skip:
289  * @stream: a #GInputStream.
290  * @count: the number of bytes that will be skipped from the stream
291  * @cancellable: optional #GCancellable object, %NULL to ignore. 
292  * @error: location to store the error occuring, or %NULL to ignore
293  *
294  * Tries to skip @count bytes from the stream. Will block during the operation.
295  *
296  * This is identical to g_input_stream_read(), from a behaviour standpoint,
297  * but the bytes that are skipped are not returned to the user. Some
298  * streams have an implementation that is more efficient than reading the data.
299  *
300  * This function is optional for inherited classes, as the default implementation
301  * emulates it using read.
302  *
303  * If @cancellable is not %NULL, then the operation can be cancelled by
304  * triggering the cancellable object from another thread. If the operation
305  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
306  * operation was partially finished when the operation was cancelled the
307  * partial result will be returned, without an error.
308  *
309  * Return value: Number of bytes skipped, or -1 on error
310  **/
311 gssize
312 g_input_stream_skip (GInputStream  *stream,
313                      gsize          count,
314                      GCancellable  *cancellable,
315                      GError       **error)
316 {
317   GInputStreamClass *class;
318   gssize res;
319
320   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
321
322   if (count == 0)
323     return 0;
324
325   if (((gssize) count) < 0)
326     {
327       g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
328                    _("Too large count value passed to g_input_stream_skip"));
329       return -1;
330     }
331   
332   if (stream->priv->closed)
333     {
334       g_set_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
335                    _("Stream is already closed"));
336       return -1;
337     }
338
339   if (stream->priv->pending)
340     {
341       g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
342                    _("Stream has outstanding operation"));
343       return -1;
344     }
345   
346   class = G_INPUT_STREAM_GET_CLASS (stream);
347
348   if (cancellable)
349     g_push_current_cancellable (cancellable);
350   
351   stream->priv->pending = TRUE;
352   res = class->skip (stream, count, cancellable, error);
353   stream->priv->pending = FALSE;
354
355   if (cancellable)
356     g_pop_current_cancellable (cancellable);
357   
358   return res;
359 }
360
361 static gssize
362 g_input_stream_real_skip (GInputStream  *stream,
363                           gsize          count,
364                           GCancellable  *cancellable,
365                           GError       **error)
366 {
367   GInputStreamClass *class;
368   gssize ret, read_bytes;
369   char buffer[8192];
370   GError *my_error;
371
372   class = G_INPUT_STREAM_GET_CLASS (stream);
373
374   if (G_IS_SEEKABLE (stream) && g_seekable_can_seek (G_SEEKABLE (stream)))
375     {
376       if (g_seekable_seek (G_SEEKABLE (stream),
377                            count,
378                            G_SEEK_CUR,
379                            cancellable,
380                            NULL))
381         return count;
382     }
383
384   /* If not seekable, or seek failed, fall back to reading data: */
385
386   class = G_INPUT_STREAM_GET_CLASS (stream);
387   
388   read_bytes = 0;
389   while (1)
390     {
391       my_error = NULL;
392
393       ret = class->read (stream, buffer, MIN (sizeof (buffer), count),
394                          cancellable, &my_error);
395       if (ret == -1)
396         {
397           if (read_bytes > 0 &&
398               my_error->domain == G_IO_ERROR &&
399               my_error->code == G_IO_ERROR_CANCELLED)
400             {
401               g_error_free (my_error);
402               return read_bytes;
403             }
404           
405           g_propagate_error (error, my_error);
406           return -1;
407         }
408
409       count -= ret;
410       read_bytes += ret;
411       
412       if (ret == 0 || count == 0)
413         return read_bytes;
414     }
415 }
416
417 /**
418  * g_input_stream_close:
419  * @stream: A #GInputStream.
420  * @cancellable: optional #GCancellable object, %NULL to ignore.
421  * @error: location to store the error occuring, or %NULL to ignore
422  *
423  * Closes the stream, releasing resources related to it.
424  *
425  * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
426  * Closing a stream multiple times will not return an error.
427  *
428  * Streams will be automatically closed when the last reference
429  * is dropped, but you might want to call make sure resources
430  * are released as early as possible.
431  *
432  * Some streams might keep the backing store of the stream (e.g. a file descriptor)
433  * open after the stream is closed. See the documentation for the individual
434  * stream for details.
435  *
436  * On failure the first error that happened will be reported, but the close
437  * operation will finish as much as possible. A stream that failed to
438  * close will still return %G_IO_ERROR_CLOSED all operations. Still, it
439  * is important to check and report the error to the user.
440  *
441  * If @cancellable is not NULL, then the operation can be cancelled by
442  * triggering the cancellable object from another thread. If the operation
443  * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
444  * Cancelling a close will still leave the stream closed, but some streams
445  * can use a faster close that doesn't block to e.g. check errors. 
446  *
447  * Return value: %TRUE on success, %FALSE on failure
448  **/
449 gboolean
450 g_input_stream_close (GInputStream  *stream,
451                       GCancellable  *cancellable,
452                       GError       **error)
453 {
454   GInputStreamClass *class;
455   gboolean res;
456
457   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
458
459   class = G_INPUT_STREAM_GET_CLASS (stream);
460
461   if (stream->priv->closed)
462     return TRUE;
463
464   if (stream->priv->pending)
465     {
466       g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING,
467                    _("Stream has outstanding operation"));
468       return FALSE;
469     }
470   
471   res = TRUE;
472
473   stream->priv->pending = TRUE;
474
475   if (cancellable)
476     g_push_current_cancellable (cancellable);
477
478   if (class->close)
479     res = class->close (stream, cancellable, error);
480
481   if (cancellable)
482     g_pop_current_cancellable (cancellable);
483   
484   stream->priv->closed = TRUE;
485   
486   stream->priv->pending = FALSE;
487
488   return res;
489 }
490
491 static void
492 async_ready_callback_wrapper (GObject      *source_object,
493                               GAsyncResult *res,
494                               gpointer      user_data)
495 {
496   GInputStream *stream = G_INPUT_STREAM (source_object);
497
498   stream->priv->pending = FALSE;
499   if (stream->priv->outstanding_callback)
500     (*stream->priv->outstanding_callback) (source_object, res, user_data);
501   g_object_unref (stream);
502 }
503
504 static void
505 async_ready_close_callback_wrapper (GObject      *source_object,
506                                     GAsyncResult *res,
507                                     gpointer      user_data)
508 {
509   GInputStream *stream = G_INPUT_STREAM (source_object);
510
511   stream->priv->pending = FALSE;
512   stream->priv->closed = TRUE;
513   if (stream->priv->outstanding_callback)
514     (*stream->priv->outstanding_callback) (source_object, res, user_data);
515   g_object_unref (stream);
516 }
517
518 /**
519  * g_input_stream_read_async:
520  * @stream: A #GInputStream.
521  * @buffer: a buffer to read data into (which should be at least count bytes long).
522  * @count: the number of bytes that will be read from the stream
523  * @io_priority: the <link linkend="io-priority">I/O priority</link> 
524  * of the request. 
525  * @cancellable: optional #GCancellable object, %NULL to ignore.
526  * @callback: callback to call when the request is satisfied
527  * @user_data: the data to pass to callback function
528  *
529  * Request an asynchronous read of @count bytes from the stream into the buffer
530  * starting at @buffer. When the operation is finished @callback will be called,
531  * giving the results.
532  *
533  * During an async request no other sync and async calls are allowed, and will
534  * result in %G_IO_ERROR_PENDING errors. 
535  *
536  * A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
537  *
538  * On success, the number of bytes read into the buffer will be passed to the
539  * callback. It is not an error if this is not the same as the requested size, as it
540  * can happen e.g. near the end of a file, but generally we try to read
541  * as many bytes as requested. Zero is returned on end of file
542  * (or if @count is zero),  but never otherwise.
543  *
544  * Any outstanding i/o request with higher priority (lower numerical value) will
545  * be executed before an outstanding request with lower priority. Default
546  * priority is %G_PRIORITY_DEFAULT.
547  *
548  * The asyncronous methods have a default fallback that uses threads to implement
549  * asynchronicity, so they are optional for inheriting classes. However, if you
550  * override one you must override all.
551  **/
552 void
553 g_input_stream_read_async (GInputStream        *stream,
554                            void                *buffer,
555                            gsize                count,
556                            int                  io_priority,
557                            GCancellable        *cancellable,
558                            GAsyncReadyCallback  callback,
559                            gpointer             user_data)
560 {
561   GInputStreamClass *class;
562   GSimpleAsyncResult *simple;
563
564   g_return_if_fail (G_IS_INPUT_STREAM (stream));
565   g_return_if_fail (buffer != NULL);
566
567   if (count == 0)
568     {
569       simple = g_simple_async_result_new (G_OBJECT (stream),
570                                           callback,
571                                           user_data,
572                                           g_input_stream_read_async);
573       g_simple_async_result_complete_in_idle (simple);
574       g_object_unref (simple);
575       return;
576     }
577   
578   if (((gssize) count) < 0)
579     {
580       g_simple_async_report_error_in_idle (G_OBJECT (stream),
581                                            callback,
582                                            user_data,
583                                            G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
584                                            _("Too large count value passed to g_input_stream_read_async"));
585       return;
586     }
587
588   if (stream->priv->closed)
589     {
590       g_simple_async_report_error_in_idle (G_OBJECT (stream),
591                                            callback,
592                                            user_data,
593                                            G_IO_ERROR, G_IO_ERROR_CLOSED,
594                                            _("Stream is already closed"));
595       return;
596     }
597   
598   if (stream->priv->pending)
599     {
600       g_simple_async_report_error_in_idle (G_OBJECT (stream),
601                                            callback,
602                                            user_data,
603                                            G_IO_ERROR, G_IO_ERROR_PENDING,
604                                            _("Stream has outstanding operation"));
605       return;
606     }
607
608   class = G_INPUT_STREAM_GET_CLASS (stream);
609   
610   stream->priv->pending = TRUE;
611   stream->priv->outstanding_callback = callback;
612   g_object_ref (stream);
613   class->read_async (stream, buffer, count, io_priority, cancellable,
614                      async_ready_callback_wrapper, user_data);
615 }
616
617 /**
618  * g_input_stream_read_finish:
619  * @stream: a #GInputStream.
620  * @result: a #GAsyncResult.
621  * @error: a #GError location to store the error occuring, or %NULL to 
622  * ignore.
623  * 
624  * Finishes an asynchronous stream read operation. 
625  * 
626  * Returns: number of bytes read in, or -1 on error.
627  **/
628 gssize
629 g_input_stream_read_finish (GInputStream  *stream,
630                             GAsyncResult  *result,
631                             GError       **error)
632 {
633   GSimpleAsyncResult *simple;
634   GInputStreamClass *class;
635   
636   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
637   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
638
639   if (G_IS_SIMPLE_ASYNC_RESULT (result))
640     {
641       simple = G_SIMPLE_ASYNC_RESULT (result);
642       if (g_simple_async_result_propagate_error (simple, error))
643         return -1;
644
645       /* Special case read of 0 bytes */
646       if (g_simple_async_result_get_source_tag (simple) == g_input_stream_read_async)
647         return 0;
648     }
649
650   class = G_INPUT_STREAM_GET_CLASS (stream);
651   return class->read_finish (stream, result, error);
652 }
653
654 /**
655  * g_input_stream_skip_async:
656  * @stream: A #GInputStream.
657  * @count: the number of bytes that will be skipped from the stream
658  * @io_priority: the <link linkend="io-priority">I/O priority</link> 
659  * of the request. 
660  * @cancellable: optional #GCancellable object, %NULL to ignore. 
661  * @callback: callback to call when the request is satisfied
662  * @user_data: the data to pass to callback function
663  *
664  * Request an asynchronous skip of @count bytes from the stream into the buffer
665  * starting at @buffer. When the operation is finished @callback will be called,
666  * giving the results.
667  *
668  * During an async request no other sync and async calls are allowed, and will
669  * result in %G_IO_ERROR_PENDING errors. 
670  *
671  * A value of @count larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
672  *
673  * On success, the number of bytes skipped will be passed to the
674  * callback. It is not an error if this is not the same as the requested size, as it
675  * can happen e.g. near the end of a file, but generally we try to skip
676  * as many bytes as requested. Zero is returned on end of file
677  * (or if @count is zero), but never otherwise.
678  *
679  * Any outstanding i/o request with higher priority (lower numerical value) will
680  * be executed before an outstanding request with lower priority. Default
681  * priority is %G_PRIORITY_DEFAULT.
682  *
683  * The asyncronous methods have a default fallback that uses threads to implement
684  * asynchronicity, so they are optional for inheriting classes. However, if you
685  * override one you must override all.
686  **/
687 void
688 g_input_stream_skip_async (GInputStream        *stream,
689                            gsize                count,
690                            int                  io_priority,
691                            GCancellable        *cancellable,
692                            GAsyncReadyCallback  callback,
693                            gpointer             user_data)
694 {
695   GInputStreamClass *class;
696   GSimpleAsyncResult *simple;
697
698   g_return_if_fail (G_IS_INPUT_STREAM (stream));
699
700   if (count == 0)
701     {
702       simple = g_simple_async_result_new (G_OBJECT (stream),
703                                           callback,
704                                           user_data,
705                                           g_input_stream_skip_async);
706
707       g_simple_async_result_complete_in_idle (simple);
708       g_object_unref (simple);
709       return;
710     }
711   
712   if (((gssize) count) < 0)
713     {
714       g_simple_async_report_error_in_idle (G_OBJECT (stream),
715                                            callback,
716                                            user_data,
717                                            G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
718                                            _("Too large count value passed to g_input_stream_skip_async"));
719       return;
720     }
721
722   if (stream->priv->closed)
723     {
724       g_simple_async_report_error_in_idle (G_OBJECT (stream),
725                                            callback,
726                                            user_data,
727                                            G_IO_ERROR, G_IO_ERROR_CLOSED,
728                                            _("Stream is already closed"));
729       return;
730     }
731   
732   if (stream->priv->pending)
733     {
734       g_simple_async_report_error_in_idle (G_OBJECT (stream),
735                                            callback,
736                                            user_data,
737                                            G_IO_ERROR, G_IO_ERROR_PENDING,
738                                            _("Stream has outstanding operation"));
739       return;
740     }
741
742   class = G_INPUT_STREAM_GET_CLASS (stream);
743   stream->priv->pending = TRUE;
744   stream->priv->outstanding_callback = callback;
745   g_object_ref (stream);
746   class->skip_async (stream, count, io_priority, cancellable,
747                      async_ready_callback_wrapper, user_data);
748 }
749
750 /**
751  * g_input_stream_skip_finish:
752  * @stream: a #GInputStream.
753  * @result: a #GAsyncResult.
754  * @error: a #GError location to store the error occuring, or %NULL to 
755  * ignore.
756  * 
757  * Finishes a stream skip operation.
758  * 
759  * Returns: the size of the bytes skipped, or %-1 on error.
760  **/
761 gssize
762 g_input_stream_skip_finish (GInputStream  *stream,
763                             GAsyncResult  *result,
764                             GError       **error)
765 {
766   GSimpleAsyncResult *simple;
767   GInputStreamClass *class;
768
769   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1);
770   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), -1);
771
772   if (G_IS_SIMPLE_ASYNC_RESULT (result))
773     {
774       simple = G_SIMPLE_ASYNC_RESULT (result);
775       if (g_simple_async_result_propagate_error (simple, error))
776         return -1;
777
778       /* Special case skip of 0 bytes */
779       if (g_simple_async_result_get_source_tag (simple) == g_input_stream_skip_async)
780         return 0;
781     }
782
783   class = G_INPUT_STREAM_GET_CLASS (stream);
784   return class->skip_finish (stream, result, error);
785 }
786
787 /**
788  * g_input_stream_close_async:
789  * @stream: A #GInputStream.
790  * @io_priority: the <link linkend="io-priority">I/O priority</link> 
791  * of the request. 
792  * @cancellable: optional cancellable object
793  * @callback: callback to call when the request is satisfied
794  * @user_data: the data to pass to callback function
795  *
796  * Requests an asynchronous closes of the stream, releasing resources related to it.
797  * When the operation is finished @callback will be called, giving the results.
798  *
799  * For behaviour details see g_input_stream_close().
800  *
801  * The asyncronous methods have a default fallback that uses threads to implement
802  * asynchronicity, so they are optional for inheriting classes. However, if you
803  * override one you must override all.
804  **/
805 void
806 g_input_stream_close_async (GInputStream        *stream,
807                             int                  io_priority,
808                             GCancellable        *cancellable,
809                             GAsyncReadyCallback  callback,
810                             gpointer             user_data)
811 {
812   GInputStreamClass *class;
813   GSimpleAsyncResult *simple;
814
815   g_return_if_fail (G_IS_INPUT_STREAM (stream));
816
817   if (stream->priv->closed)
818     {
819       simple = g_simple_async_result_new (G_OBJECT (stream),
820                                           callback,
821                                           user_data,
822                                           g_input_stream_close_async);
823
824       g_simple_async_result_complete_in_idle (simple);
825       g_object_unref (simple);
826       return;
827     }
828
829   if (stream->priv->pending)
830     {
831       g_simple_async_report_error_in_idle (G_OBJECT (stream),
832                                            callback,
833                                            user_data,
834                                            G_IO_ERROR, G_IO_ERROR_PENDING,
835                                            _("Stream has outstanding operation"));
836       return;
837     }
838   
839   class = G_INPUT_STREAM_GET_CLASS (stream);
840   stream->priv->pending = TRUE;
841   stream->priv->outstanding_callback = callback;
842   g_object_ref (stream);
843   class->close_async (stream, io_priority, cancellable,
844                       async_ready_close_callback_wrapper, user_data);
845 }
846
847 /**
848  * g_input_stream_close_finish:
849  * @stream: a #GInputStream.
850  * @result: a #GAsyncResult.
851  * @error: a #GError location to store the error occuring, or %NULL to 
852  * ignore.
853  * 
854  * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
855  * 
856  * Returns: %TRUE if the stream was closed successfully.
857  **/
858 gboolean
859 g_input_stream_close_finish (GInputStream  *stream,
860                              GAsyncResult  *result,
861                              GError       **error)
862 {
863   GSimpleAsyncResult *simple;
864   GInputStreamClass *class;
865
866   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE);
867   g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
868
869   if (G_IS_SIMPLE_ASYNC_RESULT (result))
870     {
871       simple = G_SIMPLE_ASYNC_RESULT (result);
872       if (g_simple_async_result_propagate_error (simple, error))
873         return FALSE;
874
875       /* Special case already closed */
876       if (g_simple_async_result_get_source_tag (simple) == g_input_stream_close_async)
877         return TRUE;
878     }
879
880   class = G_INPUT_STREAM_GET_CLASS (stream);
881   return class->close_finish (stream, result, error);
882 }
883
884 /**
885  * g_input_stream_is_closed:
886  * @stream: input stream.
887  * 
888  * Checks if an input stream is closed.
889  * 
890  * Returns: %TRUE if the stream is closed.
891  **/
892 gboolean
893 g_input_stream_is_closed (GInputStream *stream)
894 {
895   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), TRUE);
896   
897   return stream->priv->closed;
898 }
899  
900 /**
901  * g_input_stream_has_pending:
902  * @stream: input stream.
903  * 
904  * Checks if an input stream has pending actions.
905  * 
906  * Returns: %TRUE if @stream has pending actions.
907  **/  
908 gboolean
909 g_input_stream_has_pending (GInputStream *stream)
910 {
911   g_return_val_if_fail (G_IS_INPUT_STREAM (stream), TRUE);
912   
913   return stream->priv->pending;
914 }
915
916 /**
917  * g_input_stream_set_pending:
918  * @stream: input stream
919  * @pending: boolean.
920  * 
921  * Sets @stream has actions pending.
922  **/
923 void
924 g_input_stream_set_pending (GInputStream *stream,
925                             gboolean      pending)
926 {
927   g_return_if_fail (G_IS_INPUT_STREAM (stream));
928   
929   stream->priv->pending = pending;
930 }
931
932 /********************************************
933  *   Default implementation of async ops    *
934  ********************************************/
935
936 typedef struct {
937   void              *buffer;
938   gsize              count_requested;
939   gssize             count_read;
940 } ReadData;
941
942 static void
943 read_async_thread (GSimpleAsyncResult *res,
944                    GObject            *object,
945                    GCancellable       *cancellable)
946 {
947   ReadData *op;
948   GInputStreamClass *class;
949   GError *error = NULL;
950  
951   op = g_simple_async_result_get_op_res_gpointer (res);
952
953   class = G_INPUT_STREAM_GET_CLASS (object);
954
955   op->count_read = class->read (G_INPUT_STREAM (object),
956                                 op->buffer, op->count_requested,
957                                 cancellable, &error);
958   if (op->count_read == -1)
959     {
960       g_simple_async_result_set_from_error (res, error);
961       g_error_free (error);
962     }
963 }
964
965 static void
966 g_input_stream_real_read_async (GInputStream        *stream,
967                                 void                *buffer,
968                                 gsize                count,
969                                 int                  io_priority,
970                                 GCancellable        *cancellable,
971                                 GAsyncReadyCallback  callback,
972                                 gpointer             user_data)
973 {
974   GSimpleAsyncResult *res;
975   ReadData *op;
976   
977   op = g_new (ReadData, 1);
978   res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, g_input_stream_real_read_async);
979   g_simple_async_result_set_op_res_gpointer (res, op, g_free);
980   op->buffer = buffer;
981   op->count_requested = count;
982   
983   g_simple_async_result_run_in_thread (res, read_async_thread, io_priority, cancellable);
984   g_object_unref (res);
985 }
986
987 static gssize
988 g_input_stream_real_read_finish (GInputStream  *stream,
989                                  GAsyncResult  *result,
990                                  GError       **error)
991 {
992   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
993   ReadData *op;
994
995   g_assert (g_simple_async_result_get_source_tag (simple) == 
996             g_input_stream_real_read_async);
997
998   op = g_simple_async_result_get_op_res_gpointer (simple);
999
1000   return op->count_read;
1001 }
1002
1003 typedef struct {
1004   gsize count_requested;
1005   gssize count_skipped;
1006 } SkipData;
1007
1008
1009 static void
1010 skip_async_thread (GSimpleAsyncResult *res,
1011                    GObject            *object,
1012                    GCancellable       *cancellable)
1013 {
1014   SkipData *op;
1015   GInputStreamClass *class;
1016   GError *error = NULL;
1017   
1018   class = G_INPUT_STREAM_GET_CLASS (object);
1019   op = g_simple_async_result_get_op_res_gpointer (res);
1020   op->count_skipped = class->skip (G_INPUT_STREAM (object),
1021                                    op->count_requested,
1022                                    cancellable, &error);
1023   if (op->count_skipped == -1)
1024     {
1025       g_simple_async_result_set_from_error (res, error);
1026       g_error_free (error);
1027     }
1028 }
1029
1030 typedef struct {
1031   char buffer[8192];
1032   gsize count;
1033   gsize count_skipped;
1034   int io_prio;
1035   GCancellable *cancellable;
1036   gpointer user_data;
1037   GAsyncReadyCallback callback;
1038 } SkipFallbackAsyncData;
1039
1040 static void
1041 skip_callback_wrapper (GObject      *source_object,
1042                        GAsyncResult *res,
1043                        gpointer      user_data)
1044 {
1045   GInputStreamClass *class;
1046   SkipFallbackAsyncData *data = user_data;
1047   SkipData *op;
1048   GSimpleAsyncResult *simple;
1049   GError *error = NULL;
1050   gssize ret;
1051
1052   ret = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);
1053
1054   if (ret > 0)
1055     {
1056       data->count -= ret;
1057       data->count_skipped += ret;
1058
1059       if (data->count > 0)
1060         {
1061           class = G_INPUT_STREAM_GET_CLASS (source_object);
1062           class->read_async (G_INPUT_STREAM (source_object), data->buffer, MIN (8192, data->count), data->io_prio, data->cancellable,
1063                              skip_callback_wrapper, data);
1064           return;
1065         }
1066     }
1067
1068   op = g_new0 (SkipData, 1);
1069   op->count_skipped = data->count_skipped;
1070   simple = g_simple_async_result_new (source_object,
1071                                       data->callback, data->user_data,
1072                                       g_input_stream_real_skip_async);
1073
1074   g_simple_async_result_set_op_res_gpointer (simple, op, g_free);
1075
1076   if (ret == -1)
1077     {
1078       if (data->count_skipped && 
1079           error->domain == G_IO_ERROR &&
1080           error->code == G_IO_ERROR_CANCELLED)
1081         { /* No error, return partial read */ }
1082       else
1083         g_simple_async_result_set_from_error (simple, error);
1084       g_error_free (error);
1085     }
1086
1087   /* Complete immediately, not in idle, since we're already in a mainloop callout */
1088   g_simple_async_result_complete (simple);
1089   g_object_unref (simple);
1090   
1091   g_free (data);
1092  }
1093
1094 static void
1095 g_input_stream_real_skip_async (GInputStream        *stream,
1096                                 gsize                count,
1097                                 int                  io_priority,
1098                                 GCancellable        *cancellable,
1099                                 GAsyncReadyCallback  callback,
1100                                 gpointer             user_data)
1101 {
1102   GInputStreamClass *class;
1103   SkipData *op;
1104   SkipFallbackAsyncData *data;
1105   GSimpleAsyncResult *res;
1106
1107   class = G_INPUT_STREAM_GET_CLASS (stream);
1108
1109   if (class->read_async == g_input_stream_real_read_async)
1110     {
1111       /* Read is thread-using async fallback.
1112        * Make skip use threads too, so that we can use a possible sync skip
1113        * implementation. */
1114       op = g_new0 (SkipData, 1);
1115       
1116       res = g_simple_async_result_new (G_OBJECT (stream), callback, user_data,
1117                                        g_input_stream_real_skip_async);
1118
1119       g_simple_async_result_set_op_res_gpointer (res, op, g_free);
1120
1121       op->count_requested = count;
1122
1123       g_simple_async_result_run_in_thread (res, skip_async_thread, io_priority, cancellable);
1124       g_object_unref (res);
1125     }
1126   else
1127     {
1128       /* TODO: Skip fallback uses too much memory, should do multiple read calls */
1129       
1130       /* There is a custom async read function, lets use that. */
1131       data = g_new (SkipFallbackAsyncData, 1);
1132       data->count = count;
1133       data->count_skipped = 0;
1134       data->io_prio = io_priority;
1135       data->cancellable = cancellable;
1136       data->callback = callback;
1137       data->user_data = user_data;
1138       class->read_async (stream, data->buffer, MIN (8192, count), io_priority, cancellable,
1139                          skip_callback_wrapper, data);
1140     }
1141
1142 }
1143
1144 static gssize
1145 g_input_stream_real_skip_finish (GInputStream  *stream,
1146                                  GAsyncResult  *result,
1147                                  GError       **error)
1148 {
1149   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1150   SkipData *op;
1151
1152   g_assert (g_simple_async_result_get_source_tag (simple) == g_input_stream_real_skip_async);
1153   op = g_simple_async_result_get_op_res_gpointer (simple);
1154   return op->count_skipped;
1155 }
1156
1157 static void
1158 close_async_thread (GSimpleAsyncResult *res,
1159                     GObject            *object,
1160                     GCancellable       *cancellable)
1161 {
1162   GInputStreamClass *class;
1163   GError *error = NULL;
1164   gboolean result;
1165
1166   /* Auto handling of cancelation disabled, and ignore
1167      cancellation, since we want to close things anyway, although
1168      possibly in a quick-n-dirty way. At least we never want to leak
1169      open handles */
1170   
1171   class = G_INPUT_STREAM_GET_CLASS (object);
1172   result = class->close (G_INPUT_STREAM (object), cancellable, &error);
1173   if (!result)
1174     {
1175       g_simple_async_result_set_from_error (res, error);
1176       g_error_free (error);
1177     }
1178 }
1179
1180 static void
1181 g_input_stream_real_close_async (GInputStream        *stream,
1182                                  int                  io_priority,
1183                                  GCancellable        *cancellable,
1184                                  GAsyncReadyCallback  callback,
1185                                  gpointer             user_data)
1186 {
1187   GSimpleAsyncResult *res;
1188   
1189   res = g_simple_async_result_new (G_OBJECT (stream),
1190                                    callback,
1191                                    user_data,
1192                                    g_input_stream_real_close_async);
1193
1194   g_simple_async_result_set_handle_cancellation (res, FALSE);
1195   
1196   g_simple_async_result_run_in_thread (res,
1197                                        close_async_thread,
1198                                        io_priority,
1199                                        cancellable);
1200   g_object_unref (res);
1201 }
1202
1203 static gboolean
1204 g_input_stream_real_close_finish (GInputStream  *stream,
1205                                   GAsyncResult  *result,
1206                                   GError       **error)
1207 {
1208   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
1209   g_assert (g_simple_async_result_get_source_tag (simple) == g_input_stream_real_close_async);
1210   return TRUE;
1211 }
1212
1213 #define __G_INPUT_STREAM_C__
1214 #include "gioaliasdef.c"