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