gio/gdatainputstream.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  * Copyright (C) 2007 Jürg Billeter
   5  * Copyright © 2009 Codethink Limited
   6  *
   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 of the License, or (at your option) any later version.
  11  *
  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.
  16  *
  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/>.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24 #include "gdatainputstream.h"
  25 #include "gtask.h"
  26 #include "gcancellable.h"
  27 #include "gioenumtypes.h"
  28 #include "gioerror.h"
  29 #include "glibintl.h"
  30
  31 #include <string.h>
  32
  33 /**
  34  * SECTION:gdatainputstream
  35  * @short_description: Data Input Stream
  36  * @include: gio/gio.h
  37  * @see_also: #GInputStream
  38  *
  39  * Data input stream implements #GInputStream and includes functions for
  40  * reading structured data directly from a binary input stream.
  41  *
  42  **/
  43
  44 struct _GDataInputStreamPrivate {
  45   GDataStreamByteOrder byte_order;
  46   GDataStreamNewlineType newline_type;
  47 };
  48
  49 enum {
  50   PROP_0,
  51   PROP_BYTE_ORDER,
  52   PROP_NEWLINE_TYPE
  53 };
  54
  55 static void g_data_input_stream_set_property (GObject      *object,
  56                                               guint         prop_id,
  57                                               const GValue *value,
  58                                               GParamSpec   *pspec);
  59 static void g_data_input_stream_get_property (GObject      *object,
  60                                               guint         prop_id,
  61                                               GValue       *value,
  62                                               GParamSpec   *pspec);
  63
  64 G_DEFINE_TYPE_WITH_PRIVATE (GDataInputStream,
  65                             g_data_input_stream,
  66                             G_TYPE_BUFFERED_INPUT_STREAM)
  67
  68
  69 static void
  70 g_data_input_stream_class_init (GDataInputStreamClass *klass)
  71 {
  72   GObjectClass *object_class;
  73
  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;
  77
  78   /**
  79    * GDataStream:byte-order:
  80    *
  81    * The ::byte-order property determines the byte ordering that
  82    * is used when reading multi-byte entities (such as integers)
  83    * from the stream.
  84    */
  85   g_object_class_install_property (object_class,
  86                                    PROP_BYTE_ORDER,
  87                                    g_param_spec_enum ("byte-order",
  88                                                       P_("Byte order"),
  89                                                       P_("The 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));
  93
  94   /**
  95    * GDataStream:newline-type:
  96    *
  97    * The :newline-type property determines what is considered
  98    * as a line ending when reading complete lines from the stream.
  99    */
 100   g_object_class_install_property (object_class,
 101                                    PROP_NEWLINE_TYPE,
 102                                    g_param_spec_enum ("newline-type",
 103                                                       P_("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));
 108 }
 109
 110 static void
 111 g_data_input_stream_set_property (GObject      *object,
 112                                   guint         prop_id,
 113                                   const GValue *value,
 114                                   GParamSpec   *pspec)
 115 {
 116   GDataInputStream        *dstream;
 117
 118   dstream = G_DATA_INPUT_STREAM (object);
 119
 120    switch (prop_id)
 121     {
 122     case PROP_BYTE_ORDER:
 123       g_data_input_stream_set_byte_order (dstream, g_value_get_enum (value));
 124       break;
 125
 126     case PROP_NEWLINE_TYPE:
 127       g_data_input_stream_set_newline_type (dstream, g_value_get_enum (value));
 128       break;
 129
 130     default:
 131       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 132       break;
 133     }
 134
 135 }
 136
 137 static void
 138 g_data_input_stream_get_property (GObject    *object,
 139                                   guint       prop_id,
 140                                   GValue     *value,
 141                                   GParamSpec *pspec)
 142 {
 143   GDataInputStreamPrivate *priv;
 144   GDataInputStream        *dstream;
 145
 146   dstream = G_DATA_INPUT_STREAM (object);
 147   priv = dstream->priv;
 148
 149   switch (prop_id)
 150     {
 151     case PROP_BYTE_ORDER:
 152       g_value_set_enum (value, priv->byte_order);
 153       break;
 154
 155     case PROP_NEWLINE_TYPE:
 156       g_value_set_enum (value, priv->newline_type);
 157       break;
 158
 159     default:
 160       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 161       break;
 162     }
 163
 164 }
 165 static void
 166 g_data_input_stream_init (GDataInputStream *stream)
 167 {
 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;
 171 }
 172
 173 /**
 174  * g_data_input_stream_new:
 175  * @base_stream: a #GInputStream.
 176  *
 177  * Creates a new data input stream for the @base_stream.
 178  *
 179  * Returns: a new #GDataInputStream.
 180  **/
 181 GDataInputStream *
 182 g_data_input_stream_new (GInputStream *base_stream)
 183 {
 184   GDataInputStream *stream;
 185
 186   g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream), NULL);
 187
 188   stream = g_object_new (G_TYPE_DATA_INPUT_STREAM,
 189                          "base-stream", base_stream,
 190                          NULL);
 191
 192   return stream;
 193 }
 194
 195 /**
 196  * g_data_input_stream_set_byte_order:
 197  * @stream: a given #GDataInputStream.
 198  * @order: a #GDataStreamByteOrder to set.
 199  *
 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.
 202  *
 203  **/
 204 void
 205 g_data_input_stream_set_byte_order (GDataInputStream     *stream,
 206                                     GDataStreamByteOrder  order)
 207 {
 208   GDataInputStreamPrivate *priv;
 209
 210   g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
 211
 212   priv = stream->priv;
 213
 214   if (priv->byte_order != order)
 215     {
 216       priv->byte_order = order;
 217
 218       g_object_notify (G_OBJECT (stream), "byte-order");
 219     }
 220 }
 221
 222 /**
 223  * g_data_input_stream_get_byte_order:
 224  * @stream: a given #GDataInputStream.
 225  *
 226  * Gets the byte order for the data input stream.
 227  *
 228  * Returns: the @stream's current #GDataStreamByteOrder.
 229  **/
 230 GDataStreamByteOrder
 231 g_data_input_stream_get_byte_order (GDataInputStream *stream)
 232 {
 233   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN);
 234
 235   return stream->priv->byte_order;
 236 }
 237
 238 /**
 239  * g_data_input_stream_set_newline_type:
 240  * @stream: a #GDataInputStream.
 241  * @type: the type of new line return as #GDataStreamNewlineType.
 242  *
 243  * Sets the newline type for the @stream.
 244  *
 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.
 248  *
 249  **/
 250 void
 251 g_data_input_stream_set_newline_type (GDataInputStream       *stream,
 252                                       GDataStreamNewlineType  type)
 253 {
 254   GDataInputStreamPrivate *priv;
 255
 256   g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
 257
 258   priv = stream->priv;
 259
 260   if (priv->newline_type != type)
 261     {
 262       priv->newline_type = type;
 263
 264       g_object_notify (G_OBJECT (stream), "newline-type");
 265     }
 266 }
 267
 268 /**
 269  * g_data_input_stream_get_newline_type:
 270  * @stream: a given #GDataInputStream.
 271  *
 272  * Gets the current newline type for the @stream.
 273  *
 274  * Returns: #GDataStreamNewlineType for the given @stream.
 275  **/
 276 GDataStreamNewlineType
 277 g_data_input_stream_get_newline_type (GDataInputStream *stream)
 278 {
 279   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_NEWLINE_TYPE_ANY);
 280
 281   return stream->priv->newline_type;
 282 }
 283
 284 static gboolean
 285 read_data (GDataInputStream  *stream,
 286            void              *buffer,
 287            gsize              size,
 288            GCancellable      *cancellable,
 289            GError           **error)
 290 {
 291   gsize available;
 292   gssize res;
 293
 294   while ((available = g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (stream))) < size)
 295     {
 296       res = g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (stream),
 297                                           size - available,
 298                                           cancellable, error);
 299       if (res < 0)
 300         return FALSE;
 301       if (res == 0)
 302         {
 303           g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 304                                _("Unexpected early end-of-stream"));
 305           return FALSE;
 306         }
 307     }
 308
 309   /* This should always succeed, since it's in the buffer */
 310   res = g_input_stream_read (G_INPUT_STREAM (stream),
 311                              buffer, size,
 312                              NULL, NULL);
 313   g_warn_if_fail (res == size);
 314   return TRUE;
 315 }
 316
 317
 318 /**
 319  * g_data_input_stream_read_byte:
 320  * @stream: a given #GDataInputStream.
 321  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 322  * @error: #GError for error reporting.
 323  *
 324  * Reads an unsigned 8-bit/1-byte value from @stream.
 325  *
 326  * Returns: an unsigned 8-bit/1-byte value read from the @stream or %0
 327  * if an error occurred.
 328  **/
 329 guchar
 330 g_data_input_stream_read_byte (GDataInputStream  *stream,
 331                                GCancellable       *cancellable,
 332                                GError            **error)
 333 {
 334   guchar c;
 335
 336   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), '\0');
 337
 338   if (read_data (stream, &c, 1, cancellable, error))
 339       return c;
 340
 341   return 0;
 342 }
 343
 344
 345 /**
 346  * g_data_input_stream_read_int16:
 347  * @stream: a given #GDataInputStream.
 348  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 349  * @error: #GError for error reporting.
 350  *
 351  * Reads a 16-bit/2-byte value from @stream.
 352  *
 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().
 355  *
 356  * Returns: a signed 16-bit/2-byte value read from @stream or %0 if
 357  * an error occurred.
 358  **/
 359 gint16
 360 g_data_input_stream_read_int16 (GDataInputStream  *stream,
 361                                GCancellable       *cancellable,
 362                                GError            **error)
 363 {
 364   gint16 v;
 365
 366   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 367
 368   if (read_data (stream, &v, 2, cancellable, error))
 369     {
 370       switch (stream->priv->byte_order)
 371         {
 372         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 373           v = GINT16_FROM_BE (v);
 374           break;
 375         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 376           v = GINT16_FROM_LE (v);
 377           break;
 378         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 379         default:
 380           break;
 381         }
 382       return v;
 383     }
 384
 385   return 0;
 386 }
 387
 388
 389 /**
 390  * g_data_input_stream_read_uint16:
 391  * @stream: a given #GDataInputStream.
 392  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 393  * @error: #GError for error reporting.
 394  *
 395  * Reads an unsigned 16-bit/2-byte value from @stream.
 396  *
 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().
 399  *
 400  * Returns: an unsigned 16-bit/2-byte value read from the @stream or %0 if
 401  * an error occurred.
 402  **/
 403 guint16
 404 g_data_input_stream_read_uint16 (GDataInputStream  *stream,
 405                                  GCancellable       *cancellable,
 406                                  GError            **error)
 407 {
 408   guint16 v;
 409
 410   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 411
 412   if (read_data (stream, &v, 2, cancellable, error))
 413     {
 414       switch (stream->priv->byte_order)
 415         {
 416         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 417           v = GUINT16_FROM_BE (v);
 418           break;
 419         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 420           v = GUINT16_FROM_LE (v);
 421           break;
 422         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 423         default:
 424           break;
 425         }
 426       return v;
 427     }
 428
 429   return 0;
 430 }
 431
 432
 433 /**
 434  * g_data_input_stream_read_int32:
 435  * @stream: a given #GDataInputStream.
 436  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 437  * @error: #GError for error reporting.
 438  *
 439  * Reads a signed 32-bit/4-byte value from @stream.
 440  *
 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().
 443  *
 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.
 447  *
 448  * Returns: a signed 32-bit/4-byte value read from the @stream or %0 if
 449  * an error occurred.
 450  **/
 451 gint32
 452 g_data_input_stream_read_int32 (GDataInputStream  *stream,
 453                                 GCancellable       *cancellable,
 454                                 GError            **error)
 455 {
 456   gint32 v;
 457
 458   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 459
 460   if (read_data (stream, &v, 4, cancellable, error))
 461     {
 462       switch (stream->priv->byte_order)
 463         {
 464         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 465           v = GINT32_FROM_BE (v);
 466           break;
 467         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 468           v = GINT32_FROM_LE (v);
 469           break;
 470         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 471         default:
 472           break;
 473         }
 474       return v;
 475     }
 476
 477   return 0;
 478 }
 479
 480
 481 /**
 482  * g_data_input_stream_read_uint32:
 483  * @stream: a given #GDataInputStream.
 484  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 485  * @error: #GError for error reporting.
 486  *
 487  * Reads an unsigned 32-bit/4-byte value from @stream.
 488  *
 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().
 491  *
 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.
 495  *
 496  * Returns: an unsigned 32-bit/4-byte value read from the @stream or %0 if
 497  * an error occurred.
 498  **/
 499 guint32
 500 g_data_input_stream_read_uint32 (GDataInputStream  *stream,
 501                                  GCancellable       *cancellable,
 502                                  GError            **error)
 503 {
 504   guint32 v;
 505
 506   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 507
 508   if (read_data (stream, &v, 4, cancellable, error))
 509     {
 510       switch (stream->priv->byte_order)
 511         {
 512         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 513           v = GUINT32_FROM_BE (v);
 514           break;
 515         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 516           v = GUINT32_FROM_LE (v);
 517           break;
 518         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 519         default:
 520           break;
 521         }
 522       return v;
 523     }
 524
 525   return 0;
 526 }
 527
 528
 529 /**
 530  * g_data_input_stream_read_int64:
 531  * @stream: a given #GDataInputStream.
 532  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 533  * @error: #GError for error reporting.
 534  *
 535  * Reads a 64-bit/8-byte value from @stream.
 536  *
 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().
 539  *
 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.
 543  *
 544  * Returns: a signed 64-bit/8-byte value read from @stream or %0 if
 545  * an error occurred.
 546  **/
 547 gint64
 548 g_data_input_stream_read_int64 (GDataInputStream  *stream,
 549                                GCancellable       *cancellable,
 550                                GError            **error)
 551 {
 552   gint64 v;
 553
 554   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 555
 556   if (read_data (stream, &v, 8, cancellable, error))
 557     {
 558       switch (stream->priv->byte_order)
 559         {
 560         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 561           v = GINT64_FROM_BE (v);
 562           break;
 563         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 564           v = GINT64_FROM_LE (v);
 565           break;
 566         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 567         default:
 568           break;
 569         }
 570       return v;
 571     }
 572
 573   return 0;
 574 }
 575
 576
 577 /**
 578  * g_data_input_stream_read_uint64:
 579  * @stream: a given #GDataInputStream.
 580  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
 581  * @error: #GError for error reporting.
 582  *
 583  * Reads an unsigned 64-bit/8-byte value from @stream.
 584  *
 585  * In order to get the correct byte order for this read operation,
 586  * see g_data_input_stream_get_byte_order().
 587  *
 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.
 591  *
 592  * Returns: an unsigned 64-bit/8-byte read from @stream or %0 if
 593  * an error occurred.
 594  **/
 595 guint64
 596 g_data_input_stream_read_uint64 (GDataInputStream  *stream,
 597                                 GCancellable       *cancellable,
 598                                 GError            **error)
 599 {
 600   guint64 v;
 601
 602   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0);
 603
 604   if (read_data (stream, &v, 8, cancellable, error))
 605     {
 606       switch (stream->priv->byte_order)
 607         {
 608         case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
 609           v = GUINT64_FROM_BE (v);
 610           break;
 611         case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
 612           v = GUINT64_FROM_LE (v);
 613           break;
 614         case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
 615         default:
 616           break;
 617         }
 618       return v;
 619     }
 620
 621   return 0;
 622 }
 623
 624 static gssize
 625 scan_for_newline (GDataInputStream *stream,
 626                   gsize            *checked_out,
 627                   gboolean         *last_saw_cr_out,
 628                   int              *newline_len_out)
 629 {
 630   GBufferedInputStream *bstream;
 631   GDataInputStreamPrivate *priv;
 632   const char *buffer;
 633   gsize start, end, peeked;
 634   int i;
 635   gssize found_pos;
 636   int newline_len;
 637   gsize available, checked;
 638   gboolean last_saw_cr;
 639
 640   priv = stream->priv;
 641
 642   bstream = G_BUFFERED_INPUT_STREAM (stream);
 643
 644   checked = *checked_out;
 645   last_saw_cr = *last_saw_cr_out;
 646   found_pos = -1;
 647   newline_len = 0;
 648
 649   start = checked;
 650   buffer = (const char*)g_buffered_input_stream_peek_buffer (bstream, &available) + start;
 651   end = available;
 652   peeked = end - start;
 653
 654   for (i = 0; checked < available && i < peeked; i++)
 655     {
 656       switch (priv->newline_type)
 657         {
 658         case G_DATA_STREAM_NEWLINE_TYPE_LF:
 659           if (buffer[i] == 10)
 660             {
 661               found_pos = start + i;
 662               newline_len = 1;
 663             }
 664           break;
 665         case G_DATA_STREAM_NEWLINE_TYPE_CR:
 666           if (buffer[i] == 13)
 667             {
 668               found_pos = start + i;
 669               newline_len = 1;
 670             }
 671           break;
 672         case G_DATA_STREAM_NEWLINE_TYPE_CR_LF:
 673           if (last_saw_cr && buffer[i] == 10)
 674             {
 675               found_pos = start + i - 1;
 676               newline_len = 2;
 677             }
 678           break;
 679         default:
 680         case G_DATA_STREAM_NEWLINE_TYPE_ANY:
 681           if (buffer[i] == 10) /* LF */
 682             {
 683               if (last_saw_cr)
 684                 {
 685                   /* CR LF */
 686                   found_pos = start + i - 1;
 687                   newline_len = 2;
 688                 }
 689               else
 690                 {
 691                   /* LF */
 692                   found_pos = start + i;
 693                   newline_len = 1;
 694                 }
 695             }
 696           else if (last_saw_cr)
 697             {
 698               /* Last was cr, this is not LF, end is CR */
 699               found_pos = start + i - 1;
 700               newline_len = 1;
 701             }
 702           /* Don't check for CR here, instead look at last_saw_cr on next byte */
 703           break;
 704         }
 705
 706       last_saw_cr = (buffer[i] == 13);
 707
 708       if (found_pos != -1)
 709         {
 710           *newline_len_out = newline_len;
 711           return found_pos;
 712         }
 713     }
 714
 715   checked = end;
 716
 717   *checked_out = checked;
 718   *last_saw_cr_out = last_saw_cr;
 719   return -1;
 720 }
 721
 722
 723 /**
 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: (allow-none): optional #GCancellable object, %NULL to ignore.
 728  * @error: #GError for error reporting.
 729  *
 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.
 733  *
 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.
 737  *
 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.
 744  **/
 745 char *
 746 g_data_input_stream_read_line (GDataInputStream  *stream,
 747                                gsize             *length,
 748                                GCancellable      *cancellable,
 749                                GError           **error)
 750 {
 751   GBufferedInputStream *bstream;
 752   gsize checked;
 753   gboolean last_saw_cr;
 754   gssize found_pos;
 755   gssize res;
 756   int newline_len;
 757   char *line;
 758
 759   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL);
 760
 761   bstream = G_BUFFERED_INPUT_STREAM (stream);
 762
 763   newline_len = 0;
 764   checked = 0;
 765   last_saw_cr = FALSE;
 766
 767   while ((found_pos = scan_for_newline (stream, &checked, &last_saw_cr, &newline_len)) == -1)
 768     {
 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));
 773
 774       res = g_buffered_input_stream_fill (bstream, -1, cancellable, error);
 775       if (res < 0)
 776         return NULL;
 777       if (res == 0)
 778         {
 779           /* End of stream */
 780           if (g_buffered_input_stream_get_available (bstream) == 0)
 781             {
 782               if (length)
 783                 *length = 0;
 784               return NULL;
 785             }
 786           else
 787             {
 788               found_pos = checked;
 789               newline_len = 0;
 790               break;
 791             }
 792         }
 793     }
 794
 795   line = g_malloc (found_pos + newline_len + 1);
 796
 797   res = g_input_stream_read (G_INPUT_STREAM (stream),
 798                              line,
 799                              found_pos + newline_len,
 800                              NULL, NULL);
 801   if (length)
 802     *length = (gsize)found_pos;
 803   g_warn_if_fail (res == found_pos + newline_len);
 804   line[found_pos] = 0;
 805
 806   return line;
 807 }
 808
 809 /**
 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: (allow-none): optional #GCancellable object, %NULL to ignore.
 814  * @error: #GError for error reporting.
 815  *
 816  * Reads a UTF-8 encoded line from the data input stream.
 817  *
 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.
 821  *
 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
 828  *  won't be set.
 829  *
 830  * Since: 2.30
 831  **/
 832 char *
 833 g_data_input_stream_read_line_utf8 (GDataInputStream  *stream,
 834                                     gsize             *length,
 835                                     GCancellable      *cancellable,
 836                                     GError           **error)
 837 {
 838   char *res;
 839
 840   res = g_data_input_stream_read_line (stream, length, cancellable, error);
 841   if (!res)
 842     return NULL;
 843
 844   if (!g_utf8_validate (res, -1, NULL))
 845     {
 846       g_set_error_literal (error, G_CONVERT_ERROR,
 847                            G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
 848                            _("Invalid byte sequence in conversion input"));
 849       g_free (res);
 850       return NULL;
 851     }
 852   return res;
 853 }
 854
 855 static gssize
 856 scan_for_chars (GDataInputStream *stream,
 857                 gsize            *checked_out,
 858                 const char       *stop_chars,
 859                 gssize            stop_chars_len)
 860 {
 861   GBufferedInputStream *bstream;
 862   const char *buffer;
 863   gsize start, end, peeked;
 864   int i;
 865   gsize available, checked;
 866   const char *stop_char;
 867   const char *stop_end;
 868
 869   bstream = G_BUFFERED_INPUT_STREAM (stream);
 870   stop_end = stop_chars + stop_chars_len;
 871
 872   checked = *checked_out;
 873
 874   start = checked;
 875   buffer = (const char *)g_buffered_input_stream_peek_buffer (bstream, &available) + start;
 876   end = available;
 877   peeked = end - start;
 878
 879   for (i = 0; checked < available && i < peeked; i++)
 880     {
 881       for (stop_char = stop_chars; stop_char != stop_end; stop_char++)
 882         {
 883           if (buffer[i] == *stop_char)
 884             return (start + i);
 885         }
 886     }
 887
 888   checked = end;
 889
 890   *checked_out = checked;
 891   return -1;
 892 }
 893
 894 /**
 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: (allow-none): optional #GCancellable object, %NULL to ignore.
 900  * @error: #GError for error reporting.
 901  *
 902  * Reads a string from the data input stream, up to the first
 903  * occurrence of any of the stop characters.
 904  *
 905  * Note that, in contrast to g_data_input_stream_read_until_async(),
 906  * this function consumes the stop character that it finds.
 907  *
 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.
 913  *
 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.
 918  */
 919 char *
 920 g_data_input_stream_read_until (GDataInputStream  *stream,
 921                                const gchar        *stop_chars,
 922                                gsize              *length,
 923                                GCancellable       *cancellable,
 924                                GError            **error)
 925 {
 926   GBufferedInputStream *bstream;
 927   gchar *result;
 928
 929   bstream = G_BUFFERED_INPUT_STREAM (stream);
 930
 931   result = g_data_input_stream_read_upto (stream, stop_chars, -1,
 932                                           length, cancellable, error);
 933
 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)
 936     {
 937       gsize res;
 938       gchar b;
 939
 940       res = g_input_stream_read (G_INPUT_STREAM (stream), &b, 1, NULL, NULL);
 941       g_assert (res == 1);
 942     }
 943
 944   return result;
 945 }
 946
 947 typedef struct
 948 {
 949   gboolean last_saw_cr;
 950   gsize checked;
 951
 952   gchar *stop_chars;
 953   gssize stop_chars_len;
 954   gsize length;
 955 } GDataInputStreamReadData;
 956
 957 static void
 958 g_data_input_stream_read_complete (GTask *task,
 959                                    gsize  read_length,
 960                                    gsize  skip_length)
 961 {
 962   GDataInputStreamReadData *data = g_task_get_task_data (task);
 963   GInputStream *stream = g_task_get_source_object (task);
 964   char *line = NULL;
 965
 966   if (read_length || skip_length)
 967     {
 968       gssize bytes;
 969
 970       data->length = read_length;
 971       line = g_malloc (read_length + 1);
 972       line[read_length] = '\0';
 973
 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);
 977
 978       bytes = g_input_stream_skip (stream, skip_length, NULL, NULL);
 979       g_assert_cmpint (bytes, ==, skip_length);
 980     }
 981
 982   g_task_return_pointer (task, line, g_free);
 983   g_object_unref (task);
 984 }
 985
 986 static void
 987 g_data_input_stream_read_line_ready (GObject      *object,
 988                                      GAsyncResult *result,
 989                                      gpointer      user_data)
 990 {
 991   GTask *task = user_data;
 992   GDataInputStreamReadData *data = g_task_get_task_data (task);
 993   GBufferedInputStream *buffer = g_task_get_source_object (task);
 994   gssize found_pos;
 995   gint newline_len;
 996
 997   if (result)
 998     /* this is a callback.  finish the async call. */
 999     {
1000       GError *error = NULL;
1001       gssize bytes;
1002
1003       bytes = g_buffered_input_stream_fill_finish (buffer, result, &error);
1004
1005       if (bytes <= 0)
1006         {
1007           if (bytes < 0)
1008             /* stream error. */
1009             {
1010               g_task_return_error (task, error);
1011               g_object_unref (task);
1012               return;
1013             }
1014
1015           g_data_input_stream_read_complete (task, data->checked, 0);
1016           return;
1017         }
1018
1019       /* only proceed if we got more bytes... */
1020     }
1021
1022   if (data->stop_chars)
1023     {
1024       found_pos = scan_for_chars (G_DATA_INPUT_STREAM (buffer),
1025                                   &data->checked,
1026                                   data->stop_chars,
1027                                   data->stop_chars_len);
1028       newline_len = 0;
1029     }
1030   else
1031     found_pos = scan_for_newline (G_DATA_INPUT_STREAM (buffer), &data->checked,
1032                                   &data->last_saw_cr, &newline_len);
1033
1034   if (found_pos == -1)
1035     /* didn't find a full line; need to buffer some more bytes */
1036     {
1037       gsize size;
1038
1039       size = g_buffered_input_stream_get_buffer_size (buffer);
1040
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);
1044
1045       /* try again */
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,
1050                                           user_data);
1051     }
1052   else
1053     {
1054       /* read the line and the EOL.  no error is possible. */
1055       g_data_input_stream_read_complete (task, found_pos, newline_len);
1056     }
1057 }
1058
1059 static void
1060 g_data_input_stream_read_data_free (gpointer user_data)
1061 {
1062   GDataInputStreamReadData *data = user_data;
1063
1064   g_free (data->stop_chars);
1065   g_slice_free (GDataInputStreamReadData, data);
1066 }
1067
1068 static void
1069 g_data_input_stream_read_async (GDataInputStream    *stream,
1070                                 const gchar         *stop_chars,
1071                                 gssize               stop_chars_len,
1072                                 gint                 io_priority,
1073                                 GCancellable        *cancellable,
1074                                 GAsyncReadyCallback  callback,
1075                                 gpointer             user_data)
1076 {
1077   GDataInputStreamReadData *data;
1078   GTask *task;
1079
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;
1086
1087   task = g_task_new (stream, cancellable, callback, user_data);
1088   g_task_set_task_data (task, data, g_data_input_stream_read_data_free);
1089   g_task_set_priority (task, io_priority);
1090
1091   g_data_input_stream_read_line_ready (NULL, NULL, task);
1092 }
1093
1094 static gchar *
1095 g_data_input_stream_read_finish (GDataInputStream  *stream,
1096                                  GAsyncResult      *result,
1097                                  gsize             *length,
1098                                  GError           **error)
1099 {
1100   GTask *task = G_TASK (result);
1101   gchar *line;
1102
1103   line = g_task_propagate_pointer (task, error);
1104
1105   if (length && line)
1106     {
1107       GDataInputStreamReadData *data = g_task_get_task_data (task);
1108
1109       *length = data->length;
1110     }
1111
1112   return line;
1113 }
1114
1115 /**
1116  * g_data_input_stream_read_line_async:
1117  * @stream: a given #GDataInputStream.
1118  * @io_priority: the [I/O priority][io-priority] of the request
1119  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1120  * @callback: (scope async): callback to call when the request is satisfied.
1121  * @user_data: (closure): the data to pass to callback function.
1122  *
1123  * The asynchronous version of g_data_input_stream_read_line().  It is
1124  * an error to have two outstanding calls to this function.
1125  *
1126  * When the operation is finished, @callback will be called. You
1127  * can then call g_data_input_stream_read_line_finish() to get
1128  * the result of the operation.
1129  *
1130  * Since: 2.20
1131  */
1132 void
1133 g_data_input_stream_read_line_async (GDataInputStream    *stream,
1134                                      gint                 io_priority,
1135                                      GCancellable        *cancellable,
1136                                      GAsyncReadyCallback  callback,
1137                                      gpointer             user_data)
1138 {
1139   g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
1140   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1141
1142   g_data_input_stream_read_async (stream, NULL, 0, io_priority,
1143                                   cancellable, callback, user_data);
1144 }
1145
1146 /**
1147  * g_data_input_stream_read_until_async:
1148  * @stream: a given #GDataInputStream.
1149  * @stop_chars: characters to terminate the read.
1150  * @io_priority: the [I/O priority][io-priority] of the request
1151  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
1152  * @callback: (scope async): callback to call when the request is satisfied.
1153  * @user_data: (closure): the data to pass to callback function.
1154  *
1155  * The asynchronous version of g_data_input_stream_read_until().
1156  * It is an error to have two outstanding calls to this function.
1157  *
1158  * Note that, in contrast to g_data_input_stream_read_until(),
1159  * this function does not consume the stop character that it finds.  You
1160  * must read it for yourself.
1161  *
1162  * When the operation is finished, @callback will be called. You
1163  * can then call g_data_input_stream_read_until_finish() to get
1164  * the result of the operation.
1165  *
1166  * Don't use this function in new code.  Its functionality is
1167  * inconsistent with g_data_input_stream_read_until().  Both functions
1168  * will be marked as deprecated in a future release.  Use
1169  * g_data_input_stream_read_upto_async() instead.
1170  *
1171  * Since: 2.20
1172  */
1173 void
1174 g_data_input_stream_read_until_async (GDataInputStream    *stream,
1175                                       const gchar         *stop_chars,
1176                                       gint                 io_priority,
1177                                       GCancellable        *cancellable,
1178                                       GAsyncReadyCallback  callback,
1179                                       gpointer             user_data)
1180 {
1181   g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
1182   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1183   g_return_if_fail (stop_chars != NULL);
1184
1185   g_data_input_stream_read_async (stream, stop_chars, -1, io_priority,
1186                                   cancellable, callback, user_data);
1187 }
1188
1189 /**
1190  * g_data_input_stream_read_line_finish:
1191  * @stream: a given #GDataInputStream.
1192  * @result: the #GAsyncResult that was provided to the callback.
1193  * @length: (out): a #gsize to get the length of the data read in.
1194  * @error: #GError for error reporting.
1195  *
1196  * Finish an asynchronous call started by
1197  * g_data_input_stream_read_line_async().  Note the warning about
1198  * string encoding in g_data_input_stream_read_line() applies here as
1199  * well.
1200  *
1201  * Returns: (nullable) (transfer full) (array zero-terminated=1) (element-type guint8):
1202  *  a NUL-terminated byte array with the line that was read in
1203  *  (without the newlines).  Set @length to a #gsize to get the length
1204  *  of the read line.  On an error, it will return %NULL and @error
1205  *  will be set. If there's no content to read, it will still return
1206  *  %NULL, but @error won't be set.
1207  *
1208  * Since: 2.20
1209  */
1210 gchar *
1211 g_data_input_stream_read_line_finish (GDataInputStream  *stream,
1212                                       GAsyncResult      *result,
1213                                       gsize             *length,
1214                                       GError           **error)
1215 {
1216   g_return_val_if_fail (g_task_is_valid (result, stream), NULL);
1217
1218   return g_data_input_stream_read_finish (stream, result, length, error);
1219 }
1220
1221 /**
1222  * g_data_input_stream_read_line_finish_utf8:
1223  * @stream: a given #GDataInputStream.
1224  * @result: the #GAsyncResult that was provided to the callback.
1225  * @length: (out): a #gsize to get the length of the data read in.
1226  * @error: #GError for error reporting.
1227  *
1228  * Finish an asynchronous call started by
1229  * g_data_input_stream_read_line_async().
1230  *
1231  * Returns: (nullable) (transfer full): a string with the line that
1232  *  was read in (without the newlines).  Set @length to a #gsize to
1233  *  get the length of the read line.  On an error, it will return
1234  *  %NULL and @error will be set. For UTF-8 conversion errors, the set
1235  *  error domain is %G_CONVERT_ERROR.  If there's no content to read,
1236  *  it will still return %NULL, but @error won't be set.
1237  *
1238  * Since: 2.30
1239  */
1240 gchar *
1241 g_data_input_stream_read_line_finish_utf8 (GDataInputStream  *stream,
1242                                            GAsyncResult      *result,
1243                                            gsize             *length,
1244                                            GError           **error)
1245 {
1246   gchar *res;
1247
1248   res = g_data_input_stream_read_line_finish (stream, result, length, error);
1249   if (!res)
1250     return NULL;
1251
1252   if (!g_utf8_validate (res, -1, NULL))
1253     {
1254       g_set_error_literal (error, G_CONVERT_ERROR,
1255                            G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1256                            _("Invalid byte sequence in conversion input"));
1257       g_free (res);
1258       return NULL;
1259     }
1260   return res;
1261 }
1262
1263 /**
1264  * g_data_input_stream_read_until_finish:
1265  * @stream: a given #GDataInputStream.
1266  * @result: the #GAsyncResult that was provided to the callback.
1267  * @length: (out): a #gsize to get the length of the data read in.
1268  * @error: #GError for error reporting.
1269  *
1270  * Finish an asynchronous call started by
1271  * g_data_input_stream_read_until_async().
1272  *
1273  * Since: 2.20
1274  *
1275  * Returns: (transfer full): a string with the data that was read
1276  *     before encountering any of the stop characters. Set @length to
1277  *     a #gsize to get the length of the string. This function will
1278  *     return %NULL on an error.
1279  */
1280 gchar *
1281 g_data_input_stream_read_until_finish (GDataInputStream  *stream,
1282                                        GAsyncResult      *result,
1283                                        gsize             *length,
1284                                        GError           **error)
1285 {
1286   g_return_val_if_fail (g_task_is_valid (result, stream), NULL);
1287
1288   return g_data_input_stream_read_finish (stream, result, length, error);
1289 }
1290
1291 /**
1292  * g_data_input_stream_read_upto:
1293  * @stream: a #GDataInputStream
1294  * @stop_chars: characters to terminate the read
1295  * @stop_chars_len: length of @stop_chars. May be -1 if @stop_chars is
1296  *     nul-terminated
1297  * @length: (out): a #gsize to get the length of the data read in
1298  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
1299  * @error: #GError for error reporting
1300  *
1301  * Reads a string from the data input stream, up to the first
1302  * occurrence of any of the stop characters.
1303  *
1304  * In contrast to g_data_input_stream_read_until(), this function
1305  * does not consume the stop character. You have to use
1306  * g_data_input_stream_read_byte() to get it before calling
1307  * g_data_input_stream_read_upto() again.
1308  *
1309  * Note that @stop_chars may contain '\0' if @stop_chars_len is
1310  * specified.
1311  *
1312  * Returns: (transfer full): a string with the data that was read
1313  *     before encountering any of the stop characters. Set @length to
1314  *     a #gsize to get the length of the string. This function will
1315  *     return %NULL on an error
1316  *
1317  * Since: 2.26
1318  */
1319 char *
1320 g_data_input_stream_read_upto (GDataInputStream  *stream,
1321                                const gchar       *stop_chars,
1322                                gssize             stop_chars_len,
1323                                gsize             *length,
1324                                GCancellable      *cancellable,
1325                                GError           **error)
1326 {
1327   GBufferedInputStream *bstream;
1328   gsize checked;
1329   gssize found_pos;
1330   gssize res;
1331   char *data_until;
1332
1333   g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL);
1334
1335   if (stop_chars_len < 0)
1336     stop_chars_len = strlen (stop_chars);
1337
1338   bstream = G_BUFFERED_INPUT_STREAM (stream);
1339
1340   checked = 0;
1341
1342   while ((found_pos = scan_for_chars (stream, &checked, stop_chars, stop_chars_len)) == -1)
1343     {
1344       if (g_buffered_input_stream_get_available (bstream) ==
1345           g_buffered_input_stream_get_buffer_size (bstream))
1346         g_buffered_input_stream_set_buffer_size (bstream,
1347                                                  2 * g_buffered_input_stream_get_buffer_size (bstream));
1348
1349       res = g_buffered_input_stream_fill (bstream, -1, cancellable, error);
1350       if (res < 0)
1351         return NULL;
1352       if (res == 0)
1353         {
1354           /* End of stream */
1355           if (g_buffered_input_stream_get_available (bstream) == 0)
1356             {
1357               if (length)
1358                 *length = 0;
1359               return NULL;
1360             }
1361           else
1362             {
1363               found_pos = checked;
1364               break;
1365             }
1366         }
1367     }
1368
1369   data_until = g_malloc (found_pos + 1);
1370
1371   res = g_input_stream_read (G_INPUT_STREAM (stream),
1372                              data_until,
1373                              found_pos,
1374                              NULL, NULL);
1375   if (length)
1376     *length = (gsize)found_pos;
1377   g_warn_if_fail (res == found_pos);
1378   data_until[found_pos] = 0;
1379
1380   return data_until;
1381 }
1382
1383 /**
1384  * g_data_input_stream_read_upto_async:
1385  * @stream: a #GDataInputStream
1386  * @stop_chars: characters to terminate the read
1387  * @stop_chars_len: length of @stop_chars. May be -1 if @stop_chars is
1388  *     nul-terminated
1389  * @io_priority: the [I/O priority][io-priority] of the request
1390  * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore
1391  * @callback: (scope async): callback to call when the request is satisfied
1392  * @user_data: (closure): the data to pass to callback function
1393  *
1394  * The asynchronous version of g_data_input_stream_read_upto().
1395  * It is an error to have two outstanding calls to this function.
1396  *
1397  * In contrast to g_data_input_stream_read_until(), this function
1398  * does not consume the stop character. You have to use
1399  * g_data_input_stream_read_byte() to get it before calling
1400  * g_data_input_stream_read_upto() again.
1401  *
1402  * Note that @stop_chars may contain '\0' if @stop_chars_len is
1403  * specified.
1404  *
1405  * When the operation is finished, @callback will be called. You
1406  * can then call g_data_input_stream_read_upto_finish() to get
1407  * the result of the operation.
1408  *
1409  * Since: 2.26
1410  */
1411 void
1412 g_data_input_stream_read_upto_async (GDataInputStream    *stream,
1413                                      const gchar         *stop_chars,
1414                                      gssize               stop_chars_len,
1415                                      gint                 io_priority,
1416                                      GCancellable        *cancellable,
1417                                      GAsyncReadyCallback  callback,
1418                                      gpointer             user_data)
1419 {
1420   g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream));
1421   g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1422   g_return_if_fail (stop_chars != NULL);
1423
1424   g_data_input_stream_read_async (stream, stop_chars, stop_chars_len, io_priority,
1425                                   cancellable, callback, user_data);
1426 }
1427
1428 /**
1429  * g_data_input_stream_read_upto_finish:
1430  * @stream: a #GDataInputStream
1431  * @result: the #GAsyncResult that was provided to the callback
1432  * @length: (out): a #gsize to get the length of the data read in
1433  * @error: #GError for error reporting
1434  *
1435  * Finish an asynchronous call started by
1436  * g_data_input_stream_read_upto_async().
1437  *
1438  * Note that this function does not consume the stop character. You
1439  * have to use g_data_input_stream_read_byte() to get it before calling
1440  * g_data_input_stream_read_upto_async() again.
1441  *
1442  * Returns: (transfer full): a string with the data that was read
1443  *     before encountering any of the stop characters. Set @length to
1444  *     a #gsize to get the length of the string. This function will
1445  *     return %NULL on an error.
1446  *
1447  * Since: 2.24
1448  */
1449 gchar *
1450 g_data_input_stream_read_upto_finish (GDataInputStream  *stream,
1451                                       GAsyncResult      *result,
1452                                       gsize             *length,
1453                                       GError           **error)
1454 {
1455   g_return_val_if_fail (g_task_is_valid (result, stream), NULL);
1456
1457   return g_data_input_stream_read_finish (stream, result, length, error);
1458 }