1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 * Copyright (C) 2007 Jürg Billeter
5 * Copyright © 2009 Codethink Limited
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 * Author: Alexander Larsson <alexl@redhat.com>
24 #include "gdatainputstream.h"
26 #include "gcancellable.h"
27 #include "gioenumtypes.h"
34 * SECTION:gdatainputstream
35 * @short_description: Data Input Stream
37 * @see_also: #GInputStream
39 * Data input stream implements #GInputStream and includes functions for
40 * reading structured data directly from a binary input stream.
44 struct _GDataInputStreamPrivate
{
45 GDataStreamByteOrder byte_order
;
46 GDataStreamNewlineType newline_type
;
55 static void g_data_input_stream_set_property (GObject
*object
,
59 static void g_data_input_stream_get_property (GObject
*object
,
64 G_DEFINE_TYPE_WITH_PRIVATE (GDataInputStream
,
66 G_TYPE_BUFFERED_INPUT_STREAM
)
70 g_data_input_stream_class_init (GDataInputStreamClass
*klass
)
72 GObjectClass
*object_class
;
74 object_class
= G_OBJECT_CLASS (klass
);
75 object_class
->get_property
= g_data_input_stream_get_property
;
76 object_class
->set_property
= g_data_input_stream_set_property
;
79 * GDataStream:byte-order:
81 * The ::byte-order property determines the byte ordering that
82 * is used when reading multi-byte entities (such as integers)
85 g_object_class_install_property (object_class
,
87 g_param_spec_enum ("byte-order",
90 G_TYPE_DATA_STREAM_BYTE_ORDER
,
91 G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
,
92 G_PARAM_READWRITE
|G_PARAM_STATIC_NAME
|G_PARAM_STATIC_BLURB
));
95 * GDataStream:newline-type:
97 * The :newline-type property determines what is considered
98 * as a line ending when reading complete lines from the stream.
100 g_object_class_install_property (object_class
,
102 g_param_spec_enum ("newline-type",
104 P_("The accepted types of line ending"),
105 G_TYPE_DATA_STREAM_NEWLINE_TYPE
,
106 G_DATA_STREAM_NEWLINE_TYPE_LF
,
107 G_PARAM_READWRITE
|G_PARAM_STATIC_NAME
|G_PARAM_STATIC_BLURB
));
111 g_data_input_stream_set_property (GObject
*object
,
116 GDataInputStream
*dstream
;
118 dstream
= G_DATA_INPUT_STREAM (object
);
122 case PROP_BYTE_ORDER
:
123 g_data_input_stream_set_byte_order (dstream
, g_value_get_enum (value
));
126 case PROP_NEWLINE_TYPE
:
127 g_data_input_stream_set_newline_type (dstream
, g_value_get_enum (value
));
131 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
138 g_data_input_stream_get_property (GObject
*object
,
143 GDataInputStreamPrivate
*priv
;
144 GDataInputStream
*dstream
;
146 dstream
= G_DATA_INPUT_STREAM (object
);
147 priv
= dstream
->priv
;
151 case PROP_BYTE_ORDER
:
152 g_value_set_enum (value
, priv
->byte_order
);
155 case PROP_NEWLINE_TYPE
:
156 g_value_set_enum (value
, priv
->newline_type
);
160 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
166 g_data_input_stream_init (GDataInputStream
*stream
)
168 stream
->priv
= g_data_input_stream_get_instance_private (stream
);
169 stream
->priv
->byte_order
= G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
;
170 stream
->priv
->newline_type
= G_DATA_STREAM_NEWLINE_TYPE_LF
;
174 * g_data_input_stream_new:
175 * @base_stream: a #GInputStream.
177 * Creates a new data input stream for the @base_stream.
179 * Returns: a new #GDataInputStream.
182 g_data_input_stream_new (GInputStream
*base_stream
)
184 GDataInputStream
*stream
;
186 g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream
), NULL
);
188 stream
= g_object_new (G_TYPE_DATA_INPUT_STREAM
,
189 "base-stream", base_stream
,
196 * g_data_input_stream_set_byte_order:
197 * @stream: a given #GDataInputStream.
198 * @order: a #GDataStreamByteOrder to set.
200 * This function sets the byte order for the given @stream. All subsequent
201 * reads from the @stream will be read in the given @order.
205 g_data_input_stream_set_byte_order (GDataInputStream
*stream
,
206 GDataStreamByteOrder order
)
208 GDataInputStreamPrivate
*priv
;
210 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream
));
214 if (priv
->byte_order
!= order
)
216 priv
->byte_order
= order
;
218 g_object_notify (G_OBJECT (stream
), "byte-order");
223 * g_data_input_stream_get_byte_order:
224 * @stream: a given #GDataInputStream.
226 * Gets the byte order for the data input stream.
228 * Returns: the @stream's current #GDataStreamByteOrder.
231 g_data_input_stream_get_byte_order (GDataInputStream
*stream
)
233 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
);
235 return stream
->priv
->byte_order
;
239 * g_data_input_stream_set_newline_type:
240 * @stream: a #GDataInputStream.
241 * @type: the type of new line return as #GDataStreamNewlineType.
243 * Sets the newline type for the @stream.
245 * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
246 * chunk ends in "CR" we must read an additional byte to know if this is "CR" or
247 * "CR LF", and this might block if there is no more data available.
251 g_data_input_stream_set_newline_type (GDataInputStream
*stream
,
252 GDataStreamNewlineType type
)
254 GDataInputStreamPrivate
*priv
;
256 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream
));
260 if (priv
->newline_type
!= type
)
262 priv
->newline_type
= type
;
264 g_object_notify (G_OBJECT (stream
), "newline-type");
269 * g_data_input_stream_get_newline_type:
270 * @stream: a given #GDataInputStream.
272 * Gets the current newline type for the @stream.
274 * Returns: #GDataStreamNewlineType for the given @stream.
276 GDataStreamNewlineType
277 g_data_input_stream_get_newline_type (GDataInputStream
*stream
)
279 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), G_DATA_STREAM_NEWLINE_TYPE_ANY
);
281 return stream
->priv
->newline_type
;
285 read_data (GDataInputStream
*stream
,
288 GCancellable
*cancellable
,
294 while ((available
= g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (stream
))) < size
)
296 res
= g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (stream
),
303 g_set_error_literal (error
, G_IO_ERROR
, G_IO_ERROR_FAILED
,
304 _("Unexpected early end-of-stream"));
309 /* This should always succeed, since it's in the buffer */
310 res
= g_input_stream_read (G_INPUT_STREAM (stream
),
313 g_warn_if_fail (res
== size
);
319 * g_data_input_stream_read_byte:
320 * @stream: a given #GDataInputStream.
321 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
322 * @error: #GError for error reporting.
324 * Reads an unsigned 8-bit/1-byte value from @stream.
326 * Returns: an unsigned 8-bit/1-byte value read from the @stream or %0
327 * if an error occurred.
330 g_data_input_stream_read_byte (GDataInputStream
*stream
,
331 GCancellable
*cancellable
,
336 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), '\0');
338 if (read_data (stream
, &c
, 1, cancellable
, error
))
346 * g_data_input_stream_read_int16:
347 * @stream: a given #GDataInputStream.
348 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
349 * @error: #GError for error reporting.
351 * Reads a 16-bit/2-byte value from @stream.
353 * In order to get the correct byte order for this read operation,
354 * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
356 * Returns: a signed 16-bit/2-byte value read from @stream or %0 if
360 g_data_input_stream_read_int16 (GDataInputStream
*stream
,
361 GCancellable
*cancellable
,
366 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
368 if (read_data (stream
, &v
, 2, cancellable
, error
))
370 switch (stream
->priv
->byte_order
)
372 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
373 v
= GINT16_FROM_BE (v
);
375 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
376 v
= GINT16_FROM_LE (v
);
378 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
390 * g_data_input_stream_read_uint16:
391 * @stream: a given #GDataInputStream.
392 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
393 * @error: #GError for error reporting.
395 * Reads an unsigned 16-bit/2-byte value from @stream.
397 * In order to get the correct byte order for this read operation,
398 * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
400 * Returns: an unsigned 16-bit/2-byte value read from the @stream or %0 if
404 g_data_input_stream_read_uint16 (GDataInputStream
*stream
,
405 GCancellable
*cancellable
,
410 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
412 if (read_data (stream
, &v
, 2, cancellable
, error
))
414 switch (stream
->priv
->byte_order
)
416 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
417 v
= GUINT16_FROM_BE (v
);
419 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
420 v
= GUINT16_FROM_LE (v
);
422 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
434 * g_data_input_stream_read_int32:
435 * @stream: a given #GDataInputStream.
436 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
437 * @error: #GError for error reporting.
439 * Reads a signed 32-bit/4-byte value from @stream.
441 * In order to get the correct byte order for this read operation,
442 * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
444 * If @cancellable is not %NULL, then the operation can be cancelled by
445 * triggering the cancellable object from another thread. If the operation
446 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
448 * Returns: a signed 32-bit/4-byte value read from the @stream or %0 if
452 g_data_input_stream_read_int32 (GDataInputStream
*stream
,
453 GCancellable
*cancellable
,
458 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
460 if (read_data (stream
, &v
, 4, cancellable
, error
))
462 switch (stream
->priv
->byte_order
)
464 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
465 v
= GINT32_FROM_BE (v
);
467 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
468 v
= GINT32_FROM_LE (v
);
470 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
482 * g_data_input_stream_read_uint32:
483 * @stream: a given #GDataInputStream.
484 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
485 * @error: #GError for error reporting.
487 * Reads an unsigned 32-bit/4-byte value from @stream.
489 * In order to get the correct byte order for this read operation,
490 * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
492 * If @cancellable is not %NULL, then the operation can be cancelled by
493 * triggering the cancellable object from another thread. If the operation
494 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
496 * Returns: an unsigned 32-bit/4-byte value read from the @stream or %0 if
500 g_data_input_stream_read_uint32 (GDataInputStream
*stream
,
501 GCancellable
*cancellable
,
506 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
508 if (read_data (stream
, &v
, 4, cancellable
, error
))
510 switch (stream
->priv
->byte_order
)
512 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
513 v
= GUINT32_FROM_BE (v
);
515 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
516 v
= GUINT32_FROM_LE (v
);
518 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
530 * g_data_input_stream_read_int64:
531 * @stream: a given #GDataInputStream.
532 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
533 * @error: #GError for error reporting.
535 * Reads a 64-bit/8-byte value from @stream.
537 * In order to get the correct byte order for this read operation,
538 * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
540 * If @cancellable is not %NULL, then the operation can be cancelled by
541 * triggering the cancellable object from another thread. If the operation
542 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
544 * Returns: a signed 64-bit/8-byte value read from @stream or %0 if
548 g_data_input_stream_read_int64 (GDataInputStream
*stream
,
549 GCancellable
*cancellable
,
554 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
556 if (read_data (stream
, &v
, 8, cancellable
, error
))
558 switch (stream
->priv
->byte_order
)
560 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
561 v
= GINT64_FROM_BE (v
);
563 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
564 v
= GINT64_FROM_LE (v
);
566 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
578 * g_data_input_stream_read_uint64:
579 * @stream: a given #GDataInputStream.
580 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
581 * @error: #GError for error reporting.
583 * Reads an unsigned 64-bit/8-byte value from @stream.
585 * In order to get the correct byte order for this read operation,
586 * see g_data_input_stream_get_byte_order().
588 * If @cancellable is not %NULL, then the operation can be cancelled by
589 * triggering the cancellable object from another thread. If the operation
590 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
592 * Returns: an unsigned 64-bit/8-byte read from @stream or %0 if
596 g_data_input_stream_read_uint64 (GDataInputStream
*stream
,
597 GCancellable
*cancellable
,
602 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), 0);
604 if (read_data (stream
, &v
, 8, cancellable
, error
))
606 switch (stream
->priv
->byte_order
)
608 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN
:
609 v
= GUINT64_FROM_BE (v
);
611 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN
:
612 v
= GUINT64_FROM_LE (v
);
614 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN
:
625 scan_for_newline (GDataInputStream
*stream
,
627 gboolean
*last_saw_cr_out
,
628 int *newline_len_out
)
630 GBufferedInputStream
*bstream
;
631 GDataInputStreamPrivate
*priv
;
633 gsize start
, end
, peeked
;
637 gsize available
, checked
;
638 gboolean last_saw_cr
;
642 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
644 checked
= *checked_out
;
645 last_saw_cr
= *last_saw_cr_out
;
650 buffer
= (const char*)g_buffered_input_stream_peek_buffer (bstream
, &available
) + start
;
652 peeked
= end
- start
;
654 for (i
= 0; checked
< available
&& i
< peeked
; i
++)
656 switch (priv
->newline_type
)
658 case G_DATA_STREAM_NEWLINE_TYPE_LF
:
661 found_pos
= start
+ i
;
665 case G_DATA_STREAM_NEWLINE_TYPE_CR
:
668 found_pos
= start
+ i
;
672 case G_DATA_STREAM_NEWLINE_TYPE_CR_LF
:
673 if (last_saw_cr
&& buffer
[i
] == 10)
675 found_pos
= start
+ i
- 1;
680 case G_DATA_STREAM_NEWLINE_TYPE_ANY
:
681 if (buffer
[i
] == 10) /* LF */
686 found_pos
= start
+ i
- 1;
692 found_pos
= start
+ i
;
696 else if (last_saw_cr
)
698 /* Last was cr, this is not LF, end is CR */
699 found_pos
= start
+ i
- 1;
702 /* Don't check for CR here, instead look at last_saw_cr on next byte */
706 last_saw_cr
= (buffer
[i
] == 13);
710 *newline_len_out
= newline_len
;
717 *checked_out
= checked
;
718 *last_saw_cr_out
= last_saw_cr
;
724 * g_data_input_stream_read_line:
725 * @stream: a given #GDataInputStream.
726 * @length: (out): a #gsize to get the length of the data read in.
727 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
728 * @error: #GError for error reporting.
730 * Reads a line from the data input stream. Note that no encoding
731 * checks or conversion is performed; the input is not guaranteed to
732 * be UTF-8, and may in fact have embedded NUL characters.
734 * If @cancellable is not %NULL, then the operation can be cancelled by
735 * triggering the cancellable object from another thread. If the operation
736 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
738 * Returns: (nullable) (transfer full) (array zero-terminated=1) (element-type guint8):
739 * a NUL terminated byte array with the line that was read in
740 * (without the newlines). Set @length to a #gsize to get the length
741 * of the read line. On an error, it will return %NULL and @error
742 * will be set. If there's no content to read, it will still return
743 * %NULL, but @error won't be set.
746 g_data_input_stream_read_line (GDataInputStream
*stream
,
748 GCancellable
*cancellable
,
751 GBufferedInputStream
*bstream
;
753 gboolean last_saw_cr
;
759 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), NULL
);
761 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
767 while ((found_pos
= scan_for_newline (stream
, &checked
, &last_saw_cr
, &newline_len
)) == -1)
769 if (g_buffered_input_stream_get_available (bstream
) ==
770 g_buffered_input_stream_get_buffer_size (bstream
))
771 g_buffered_input_stream_set_buffer_size (bstream
,
772 2 * g_buffered_input_stream_get_buffer_size (bstream
));
774 res
= g_buffered_input_stream_fill (bstream
, -1, cancellable
, error
);
780 if (g_buffered_input_stream_get_available (bstream
) == 0)
795 line
= g_malloc (found_pos
+ newline_len
+ 1);
797 res
= g_input_stream_read (G_INPUT_STREAM (stream
),
799 found_pos
+ newline_len
,
802 *length
= (gsize
)found_pos
;
803 g_warn_if_fail (res
== found_pos
+ newline_len
);
810 * g_data_input_stream_read_line_utf8:
811 * @stream: a given #GDataInputStream.
812 * @length: (out): a #gsize to get the length of the data read in.
813 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
814 * @error: #GError for error reporting.
816 * Reads a UTF-8 encoded line from the data input stream.
818 * If @cancellable is not %NULL, then the operation can be cancelled by
819 * triggering the cancellable object from another thread. If the operation
820 * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
822 * Returns: (nullable) (transfer full): a NUL terminated UTF-8 string
823 * with the line that was read in (without the newlines). Set
824 * @length to a #gsize to get the length of the read line. On an
825 * error, it will return %NULL and @error will be set. For UTF-8
826 * conversion errors, the set error domain is %G_CONVERT_ERROR. If
827 * there's no content to read, it will still return %NULL, but @error
833 g_data_input_stream_read_line_utf8 (GDataInputStream
*stream
,
835 GCancellable
*cancellable
,
840 res
= g_data_input_stream_read_line (stream
, length
, cancellable
, error
);
844 if (!g_utf8_validate (res
, -1, NULL
))
846 g_set_error_literal (error
, G_CONVERT_ERROR
,
847 G_CONVERT_ERROR_ILLEGAL_SEQUENCE
,
848 _("Invalid byte sequence in conversion input"));
856 scan_for_chars (GDataInputStream
*stream
,
858 const char *stop_chars
,
859 gssize stop_chars_len
)
861 GBufferedInputStream
*bstream
;
863 gsize start
, end
, peeked
;
865 gsize available
, checked
;
866 const char *stop_char
;
867 const char *stop_end
;
869 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
870 stop_end
= stop_chars
+ stop_chars_len
;
872 checked
= *checked_out
;
875 buffer
= (const char *)g_buffered_input_stream_peek_buffer (bstream
, &available
) + start
;
877 peeked
= end
- start
;
879 for (i
= 0; checked
< available
&& i
< peeked
; i
++)
881 for (stop_char
= stop_chars
; stop_char
!= stop_end
; stop_char
++)
883 if (buffer
[i
] == *stop_char
)
890 *checked_out
= checked
;
895 * g_data_input_stream_read_until:
896 * @stream: a given #GDataInputStream.
897 * @stop_chars: characters to terminate the read.
898 * @length: (out): a #gsize to get the length of the data read in.
899 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
900 * @error: #GError for error reporting.
902 * Reads a string from the data input stream, up to the first
903 * occurrence of any of the stop characters.
905 * Note that, in contrast to g_data_input_stream_read_until_async(),
906 * this function consumes the stop character that it finds.
908 * Don't use this function in new code. Its functionality is
909 * inconsistent with g_data_input_stream_read_until_async(). Both
910 * functions will be marked as deprecated in a future release. Use
911 * g_data_input_stream_read_upto() instead, but note that that function
912 * does not consume the stop character.
914 * Returns: (transfer full): a string with the data that was read
915 * before encountering any of the stop characters. Set @length to
916 * a #gsize to get the length of the string. This function will
917 * return %NULL on an error.
920 g_data_input_stream_read_until (GDataInputStream
*stream
,
921 const gchar
*stop_chars
,
923 GCancellable
*cancellable
,
926 GBufferedInputStream
*bstream
;
929 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
931 result
= g_data_input_stream_read_upto (stream
, stop_chars
, -1,
932 length
, cancellable
, error
);
934 /* If we're not at end of stream then we have a stop_char to consume. */
935 if (result
!= NULL
&& g_buffered_input_stream_get_available (bstream
) > 0)
940 res
= g_input_stream_read (G_INPUT_STREAM (stream
), &b
, 1, NULL
, NULL
);
949 gboolean last_saw_cr
;
953 gssize stop_chars_len
;
955 } GDataInputStreamReadData
;
958 g_data_input_stream_read_complete (GTask
*task
,
962 GDataInputStreamReadData
*data
= g_task_get_task_data (task
);
963 GInputStream
*stream
= g_task_get_source_object (task
);
966 if (read_length
|| skip_length
)
970 data
->length
= read_length
;
971 line
= g_malloc (read_length
+ 1);
972 line
[read_length
] = '\0';
974 /* we already checked the buffer. this shouldn't fail. */
975 bytes
= g_input_stream_read (stream
, line
, read_length
, NULL
, NULL
);
976 g_assert_cmpint (bytes
, ==, read_length
);
978 bytes
= g_input_stream_skip (stream
, skip_length
, NULL
, NULL
);
979 g_assert_cmpint (bytes
, ==, skip_length
);
982 g_task_return_pointer (task
, line
, g_free
);
983 g_object_unref (task
);
987 g_data_input_stream_read_line_ready (GObject
*object
,
988 GAsyncResult
*result
,
991 GTask
*task
= user_data
;
992 GDataInputStreamReadData
*data
= g_task_get_task_data (task
);
993 GBufferedInputStream
*buffer
= g_task_get_source_object (task
);
998 /* this is a callback. finish the async call. */
1000 GError
*error
= NULL
;
1003 bytes
= g_buffered_input_stream_fill_finish (buffer
, result
, &error
);
1010 g_task_return_error (task
, error
);
1011 g_object_unref (task
);
1015 g_data_input_stream_read_complete (task
, data
->checked
, 0);
1019 /* only proceed if we got more bytes... */
1022 if (data
->stop_chars
)
1024 found_pos
= scan_for_chars (G_DATA_INPUT_STREAM (buffer
),
1027 data
->stop_chars_len
);
1031 found_pos
= scan_for_newline (G_DATA_INPUT_STREAM (buffer
), &data
->checked
,
1032 &data
->last_saw_cr
, &newline_len
);
1034 if (found_pos
== -1)
1035 /* didn't find a full line; need to buffer some more bytes */
1039 size
= g_buffered_input_stream_get_buffer_size (buffer
);
1041 if (g_buffered_input_stream_get_available (buffer
) == size
)
1042 /* need to grow the buffer */
1043 g_buffered_input_stream_set_buffer_size (buffer
, size
* 2);
1046 g_buffered_input_stream_fill_async (buffer
, -1,
1047 g_task_get_priority (task
),
1048 g_task_get_cancellable (task
),
1049 g_data_input_stream_read_line_ready
,
1054 /* read the line and the EOL. no error is possible. */
1055 g_data_input_stream_read_complete (task
, found_pos
, newline_len
);
1060 g_data_input_stream_read_data_free (gpointer user_data
)
1062 GDataInputStreamReadData
*data
= user_data
;
1064 g_free (data
->stop_chars
);
1065 g_slice_free (GDataInputStreamReadData
, data
);
1069 g_data_input_stream_read_async (GDataInputStream
*stream
,
1070 const gchar
*stop_chars
,
1071 gssize stop_chars_len
,
1073 GCancellable
*cancellable
,
1074 GAsyncReadyCallback callback
,
1077 GDataInputStreamReadData
*data
;
1080 data
= g_slice_new0 (GDataInputStreamReadData
);
1081 if (stop_chars_len
== -1)
1082 stop_chars_len
= strlen (stop_chars
);
1083 data
->stop_chars
= g_memdup (stop_chars
, stop_chars_len
);
1084 data
->stop_chars_len
= stop_chars_len
;
1085 data
->last_saw_cr
= FALSE
;
1087 task
= g_task_new (stream
, cancellable
, callback
, user_data
);
1088 g_task_set_source_tag (task
, g_data_input_stream_read_async
);
1089 g_task_set_task_data (task
, data
, g_data_input_stream_read_data_free
);
1090 g_task_set_priority (task
, io_priority
);
1092 g_data_input_stream_read_line_ready (NULL
, NULL
, task
);
1096 g_data_input_stream_read_finish (GDataInputStream
*stream
,
1097 GAsyncResult
*result
,
1101 GTask
*task
= G_TASK (result
);
1104 line
= g_task_propagate_pointer (task
, error
);
1108 GDataInputStreamReadData
*data
= g_task_get_task_data (task
);
1110 *length
= data
->length
;
1117 * g_data_input_stream_read_line_async:
1118 * @stream: a given #GDataInputStream.
1119 * @io_priority: the [I/O priority][io-priority] of the request
1120 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
1121 * @callback: (scope async): callback to call when the request is satisfied.
1122 * @user_data: (closure): the data to pass to callback function.
1124 * The asynchronous version of g_data_input_stream_read_line(). It is
1125 * an error to have two outstanding calls to this function.
1127 * When the operation is finished, @callback will be called. You
1128 * can then call g_data_input_stream_read_line_finish() to get
1129 * the result of the operation.
1134 g_data_input_stream_read_line_async (GDataInputStream
*stream
,
1136 GCancellable
*cancellable
,
1137 GAsyncReadyCallback callback
,
1140 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream
));
1141 g_return_if_fail (cancellable
== NULL
|| G_IS_CANCELLABLE (cancellable
));
1143 g_data_input_stream_read_async (stream
, NULL
, 0, io_priority
,
1144 cancellable
, callback
, user_data
);
1148 * g_data_input_stream_read_until_async:
1149 * @stream: a given #GDataInputStream.
1150 * @stop_chars: characters to terminate the read.
1151 * @io_priority: the [I/O priority][io-priority] of the request
1152 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.
1153 * @callback: (scope async): callback to call when the request is satisfied.
1154 * @user_data: (closure): the data to pass to callback function.
1156 * The asynchronous version of g_data_input_stream_read_until().
1157 * It is an error to have two outstanding calls to this function.
1159 * Note that, in contrast to g_data_input_stream_read_until(),
1160 * this function does not consume the stop character that it finds. You
1161 * must read it for yourself.
1163 * When the operation is finished, @callback will be called. You
1164 * can then call g_data_input_stream_read_until_finish() to get
1165 * the result of the operation.
1167 * Don't use this function in new code. Its functionality is
1168 * inconsistent with g_data_input_stream_read_until(). Both functions
1169 * will be marked as deprecated in a future release. Use
1170 * g_data_input_stream_read_upto_async() instead.
1175 g_data_input_stream_read_until_async (GDataInputStream
*stream
,
1176 const gchar
*stop_chars
,
1178 GCancellable
*cancellable
,
1179 GAsyncReadyCallback callback
,
1182 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream
));
1183 g_return_if_fail (cancellable
== NULL
|| G_IS_CANCELLABLE (cancellable
));
1184 g_return_if_fail (stop_chars
!= NULL
);
1186 g_data_input_stream_read_async (stream
, stop_chars
, -1, io_priority
,
1187 cancellable
, callback
, user_data
);
1191 * g_data_input_stream_read_line_finish:
1192 * @stream: a given #GDataInputStream.
1193 * @result: the #GAsyncResult that was provided to the callback.
1194 * @length: (out): a #gsize to get the length of the data read in.
1195 * @error: #GError for error reporting.
1197 * Finish an asynchronous call started by
1198 * g_data_input_stream_read_line_async(). Note the warning about
1199 * string encoding in g_data_input_stream_read_line() applies here as
1202 * Returns: (nullable) (transfer full) (array zero-terminated=1) (element-type guint8):
1203 * a NUL-terminated byte array with the line that was read in
1204 * (without the newlines). Set @length to a #gsize to get the length
1205 * of the read line. On an error, it will return %NULL and @error
1206 * will be set. If there's no content to read, it will still return
1207 * %NULL, but @error won't be set.
1212 g_data_input_stream_read_line_finish (GDataInputStream
*stream
,
1213 GAsyncResult
*result
,
1217 g_return_val_if_fail (g_task_is_valid (result
, stream
), NULL
);
1219 return g_data_input_stream_read_finish (stream
, result
, length
, error
);
1223 * g_data_input_stream_read_line_finish_utf8:
1224 * @stream: a given #GDataInputStream.
1225 * @result: the #GAsyncResult that was provided to the callback.
1226 * @length: (out): a #gsize to get the length of the data read in.
1227 * @error: #GError for error reporting.
1229 * Finish an asynchronous call started by
1230 * g_data_input_stream_read_line_async().
1232 * Returns: (nullable) (transfer full): a string with the line that
1233 * was read in (without the newlines). Set @length to a #gsize to
1234 * get the length of the read line. On an error, it will return
1235 * %NULL and @error will be set. For UTF-8 conversion errors, the set
1236 * error domain is %G_CONVERT_ERROR. If there's no content to read,
1237 * it will still return %NULL, but @error won't be set.
1242 g_data_input_stream_read_line_finish_utf8 (GDataInputStream
*stream
,
1243 GAsyncResult
*result
,
1249 res
= g_data_input_stream_read_line_finish (stream
, result
, length
, error
);
1253 if (!g_utf8_validate (res
, -1, NULL
))
1255 g_set_error_literal (error
, G_CONVERT_ERROR
,
1256 G_CONVERT_ERROR_ILLEGAL_SEQUENCE
,
1257 _("Invalid byte sequence in conversion input"));
1265 * g_data_input_stream_read_until_finish:
1266 * @stream: a given #GDataInputStream.
1267 * @result: the #GAsyncResult that was provided to the callback.
1268 * @length: (out): a #gsize to get the length of the data read in.
1269 * @error: #GError for error reporting.
1271 * Finish an asynchronous call started by
1272 * g_data_input_stream_read_until_async().
1276 * Returns: (transfer full): a string with the data that was read
1277 * before encountering any of the stop characters. Set @length to
1278 * a #gsize to get the length of the string. This function will
1279 * return %NULL on an error.
1282 g_data_input_stream_read_until_finish (GDataInputStream
*stream
,
1283 GAsyncResult
*result
,
1287 g_return_val_if_fail (g_task_is_valid (result
, stream
), NULL
);
1289 return g_data_input_stream_read_finish (stream
, result
, length
, error
);
1293 * g_data_input_stream_read_upto:
1294 * @stream: a #GDataInputStream
1295 * @stop_chars: characters to terminate the read
1296 * @stop_chars_len: length of @stop_chars. May be -1 if @stop_chars is
1298 * @length: (out): a #gsize to get the length of the data read in
1299 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore
1300 * @error: #GError for error reporting
1302 * Reads a string from the data input stream, up to the first
1303 * occurrence of any of the stop characters.
1305 * In contrast to g_data_input_stream_read_until(), this function
1306 * does not consume the stop character. You have to use
1307 * g_data_input_stream_read_byte() to get it before calling
1308 * g_data_input_stream_read_upto() again.
1310 * Note that @stop_chars may contain '\0' if @stop_chars_len is
1313 * Returns: (transfer full): a string with the data that was read
1314 * before encountering any of the stop characters. Set @length to
1315 * a #gsize to get the length of the string. This function will
1316 * return %NULL on an error
1321 g_data_input_stream_read_upto (GDataInputStream
*stream
,
1322 const gchar
*stop_chars
,
1323 gssize stop_chars_len
,
1325 GCancellable
*cancellable
,
1328 GBufferedInputStream
*bstream
;
1334 g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream
), NULL
);
1336 if (stop_chars_len
< 0)
1337 stop_chars_len
= strlen (stop_chars
);
1339 bstream
= G_BUFFERED_INPUT_STREAM (stream
);
1343 while ((found_pos
= scan_for_chars (stream
, &checked
, stop_chars
, stop_chars_len
)) == -1)
1345 if (g_buffered_input_stream_get_available (bstream
) ==
1346 g_buffered_input_stream_get_buffer_size (bstream
))
1347 g_buffered_input_stream_set_buffer_size (bstream
,
1348 2 * g_buffered_input_stream_get_buffer_size (bstream
));
1350 res
= g_buffered_input_stream_fill (bstream
, -1, cancellable
, error
);
1356 if (g_buffered_input_stream_get_available (bstream
) == 0)
1364 found_pos
= checked
;
1370 data_until
= g_malloc (found_pos
+ 1);
1372 res
= g_input_stream_read (G_INPUT_STREAM (stream
),
1377 *length
= (gsize
)found_pos
;
1378 g_warn_if_fail (res
== found_pos
);
1379 data_until
[found_pos
] = 0;
1385 * g_data_input_stream_read_upto_async:
1386 * @stream: a #GDataInputStream
1387 * @stop_chars: characters to terminate the read
1388 * @stop_chars_len: length of @stop_chars. May be -1 if @stop_chars is
1390 * @io_priority: the [I/O priority][io-priority] of the request
1391 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore
1392 * @callback: (scope async): callback to call when the request is satisfied
1393 * @user_data: (closure): the data to pass to callback function
1395 * The asynchronous version of g_data_input_stream_read_upto().
1396 * It is an error to have two outstanding calls to this function.
1398 * In contrast to g_data_input_stream_read_until(), this function
1399 * does not consume the stop character. You have to use
1400 * g_data_input_stream_read_byte() to get it before calling
1401 * g_data_input_stream_read_upto() again.
1403 * Note that @stop_chars may contain '\0' if @stop_chars_len is
1406 * When the operation is finished, @callback will be called. You
1407 * can then call g_data_input_stream_read_upto_finish() to get
1408 * the result of the operation.
1413 g_data_input_stream_read_upto_async (GDataInputStream
*stream
,
1414 const gchar
*stop_chars
,
1415 gssize stop_chars_len
,
1417 GCancellable
*cancellable
,
1418 GAsyncReadyCallback callback
,
1421 g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream
));
1422 g_return_if_fail (cancellable
== NULL
|| G_IS_CANCELLABLE (cancellable
));
1423 g_return_if_fail (stop_chars
!= NULL
);
1425 g_data_input_stream_read_async (stream
, stop_chars
, stop_chars_len
, io_priority
,
1426 cancellable
, callback
, user_data
);
1430 * g_data_input_stream_read_upto_finish:
1431 * @stream: a #GDataInputStream
1432 * @result: the #GAsyncResult that was provided to the callback
1433 * @length: (out): a #gsize to get the length of the data read in
1434 * @error: #GError for error reporting
1436 * Finish an asynchronous call started by
1437 * g_data_input_stream_read_upto_async().
1439 * Note that this function does not consume the stop character. You
1440 * have to use g_data_input_stream_read_byte() to get it before calling
1441 * g_data_input_stream_read_upto_async() again.
1443 * Returns: (transfer full): a string with the data that was read
1444 * before encountering any of the stop characters. Set @length to
1445 * a #gsize to get the length of the string. This function will
1446 * return %NULL on an error.
1451 g_data_input_stream_read_upto_finish (GDataInputStream
*stream
,
1452 GAsyncResult
*result
,
1456 g_return_val_if_fail (g_task_is_valid (result
, stream
), NULL
);
1458 return g_data_input_stream_read_finish (stream
, result
, length
, error
);