gio/gconverterinputstream.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2009 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include "gconverterinputstream.h"
  28 #include "gpollableinputstream.h"
  29 #include "gsimpleasyncresult.h"
  30 #include "gcancellable.h"
  31 #include "gioenumtypes.h"
  32 #include "gioerror.h"
  33 #include "glibintl.h"
  34
  35
  36 /**
  37  * SECTION:gconverterinputstream
  38  * @short_description: Converter Input Stream
  39  * @include: gio/gio.h
  40  * @see_also: #GInputStream, #GConverter
  41  *
  42  * Converter input stream implements #GInputStream and allows
  43  * conversion of data of various types during reading.
  44  *
  45  * As of GLib 2.34, #GConverterInputStream implements
  46  * #GPollableInputStream.
  47  **/
  48
  49 #define INITIAL_BUFFER_SIZE 4096
  50
  51 typedef struct {
  52   char *data;
  53   gsize start;
  54   gsize end;
  55   gsize size;
  56 } Buffer;
  57
  58 struct _GConverterInputStreamPrivate {
  59   gboolean at_input_end;
  60   gboolean finished;
  61   gboolean need_input;
  62   GConverter *converter;
  63   Buffer input_buffer;
  64   Buffer converted_buffer;
  65 };
  66
  67 enum {
  68   PROP_0,
  69   PROP_CONVERTER
  70 };
  71
  72 static void   g_converter_input_stream_set_property (GObject       *object,
  73                                                      guint          prop_id,
  74                                                      const GValue  *value,
  75                                                      GParamSpec    *pspec);
  76 static void   g_converter_input_stream_get_property (GObject       *object,
  77                                                      guint          prop_id,
  78                                                      GValue        *value,
  79                                                      GParamSpec    *pspec);
  80 static void   g_converter_input_stream_finalize     (GObject       *object);
  81 static gssize g_converter_input_stream_read         (GInputStream  *stream,
  82                                                      void          *buffer,
  83                                                      gsize          count,
  84                                                      GCancellable  *cancellable,
  85                                                      GError       **error);
  86
  87 static gboolean g_converter_input_stream_can_poll         (GPollableInputStream *stream);
  88 static gboolean g_converter_input_stream_is_readable      (GPollableInputStream *stream);
  89 static gssize   g_converter_input_stream_read_nonblocking (GPollableInputStream  *stream,
  90                                                            void                  *buffer,
  91                                                            gsize                  size,
  92                                                            GError               **error);
  93
  94 static GSource *g_converter_input_stream_create_source    (GPollableInputStream *stream,
  95                                                            GCancellable          *cancellable);
  96
  97 static void g_converter_input_stream_pollable_iface_init  (GPollableInputStreamInterface *iface);
  98
  99 G_DEFINE_TYPE_WITH_CODE (GConverterInputStream,
 100                          g_converter_input_stream,
 101                          G_TYPE_FILTER_INPUT_STREAM,
 102                          G_ADD_PRIVATE (GConverterInputStream)
 103                          G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_INPUT_STREAM,
 104                                                 g_converter_input_stream_pollable_iface_init))
 105
 106 static void
 107 g_converter_input_stream_class_init (GConverterInputStreamClass *klass)
 108 {
 109   GObjectClass *object_class;
 110   GInputStreamClass *istream_class;
 111
 112   object_class = G_OBJECT_CLASS (klass);
 113   object_class->get_property = g_converter_input_stream_get_property;
 114   object_class->set_property = g_converter_input_stream_set_property;
 115   object_class->finalize     = g_converter_input_stream_finalize;
 116
 117   istream_class = G_INPUT_STREAM_CLASS (klass);
 118   istream_class->read_fn = g_converter_input_stream_read;
 119
 120   g_object_class_install_property (object_class,
 121                                    PROP_CONVERTER,
 122                                    g_param_spec_object ("converter",
 123                                                         P_("Converter"),
 124                                                         P_("The converter object"),
 125                                                         G_TYPE_CONVERTER,
 126                                                         G_PARAM_READWRITE|
 127                                                         G_PARAM_CONSTRUCT_ONLY|
 128                                                         G_PARAM_STATIC_STRINGS));
 129
 130 }
 131
 132 static void
 133 g_converter_input_stream_pollable_iface_init (GPollableInputStreamInterface *iface)
 134 {
 135   iface->can_poll = g_converter_input_stream_can_poll;
 136   iface->is_readable = g_converter_input_stream_is_readable;
 137   iface->read_nonblocking = g_converter_input_stream_read_nonblocking;
 138   iface->create_source = g_converter_input_stream_create_source;
 139 }
 140
 141 static void
 142 g_converter_input_stream_finalize (GObject *object)
 143 {
 144   GConverterInputStreamPrivate *priv;
 145   GConverterInputStream        *stream;
 146
 147   stream = G_CONVERTER_INPUT_STREAM (object);
 148   priv = stream->priv;
 149
 150   g_free (priv->input_buffer.data);
 151   g_free (priv->converted_buffer.data);
 152   if (priv->converter)
 153     g_object_unref (priv->converter);
 154
 155   G_OBJECT_CLASS (g_converter_input_stream_parent_class)->finalize (object);
 156 }
 157
 158 static void
 159 g_converter_input_stream_set_property (GObject      *object,
 160                                        guint         prop_id,
 161                                        const GValue *value,
 162                                        GParamSpec   *pspec)
 163 {
 164   GConverterInputStream *cstream;
 165
 166   cstream = G_CONVERTER_INPUT_STREAM (object);
 167
 168    switch (prop_id)
 169     {
 170     case PROP_CONVERTER:
 171       cstream->priv->converter = g_value_dup_object (value);
 172       break;
 173
 174     default:
 175       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 176       break;
 177     }
 178
 179 }
 180
 181 static void
 182 g_converter_input_stream_get_property (GObject    *object,
 183                                        guint       prop_id,
 184                                        GValue     *value,
 185                                        GParamSpec *pspec)
 186 {
 187   GConverterInputStreamPrivate *priv;
 188   GConverterInputStream        *cstream;
 189
 190   cstream = G_CONVERTER_INPUT_STREAM (object);
 191   priv = cstream->priv;
 192
 193   switch (prop_id)
 194     {
 195     case PROP_CONVERTER:
 196       g_value_set_object (value, priv->converter);
 197       break;
 198
 199     default:
 200       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 201       break;
 202     }
 203
 204 }
 205 static void
 206 g_converter_input_stream_init (GConverterInputStream *stream)
 207 {
 208   stream->priv = g_converter_input_stream_get_private (stream);
 209 }
 210
 211 /**
 212  * g_converter_input_stream_new:
 213  * @base_stream: a #GInputStream
 214  * @converter: a #GConverter
 215  *
 216  * Creates a new converter input stream for the @base_stream.
 217  *
 218  * Returns: a new #GInputStream.
 219  **/
 220 GInputStream *
 221 g_converter_input_stream_new (GInputStream *base_stream,
 222                               GConverter   *converter)
 223 {
 224   GInputStream *stream;
 225
 226   g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream), NULL);
 227
 228   stream = g_object_new (G_TYPE_CONVERTER_INPUT_STREAM,
 229                          "base-stream", base_stream,
 230                          "converter", converter,
 231                          NULL);
 232
 233   return stream;
 234 }
 235
 236 static gsize
 237 buffer_data_size (Buffer *buffer)
 238 {
 239   return buffer->end - buffer->start;
 240 }
 241
 242 static gsize
 243 buffer_tailspace (Buffer *buffer)
 244 {
 245   return buffer->size - buffer->end;
 246 }
 247
 248 static char *
 249 buffer_data (Buffer *buffer)
 250 {
 251   return buffer->data + buffer->start;
 252 }
 253
 254 static void
 255 buffer_consumed (Buffer *buffer,
 256                  gsize count)
 257 {
 258   buffer->start += count;
 259   if (buffer->start == buffer->end)
 260     buffer->start = buffer->end = 0;
 261 }
 262
 263 static void
 264 buffer_read (Buffer *buffer,
 265              char *dest,
 266              gsize count)
 267 {
 268   memcpy (dest, buffer->data + buffer->start, count);
 269   buffer_consumed (buffer, count);
 270 }
 271
 272 static void
 273 compact_buffer (Buffer *buffer)
 274 {
 275   gsize in_buffer;
 276
 277   in_buffer = buffer_data_size (buffer);
 278   memmove (buffer->data,
 279            buffer->data + buffer->start,
 280            in_buffer);
 281   buffer->end -= buffer->start;
 282   buffer->start = 0;
 283 }
 284
 285 static void
 286 grow_buffer (Buffer *buffer)
 287 {
 288   char *data;
 289   gsize size, in_buffer;
 290
 291   if (buffer->size == 0)
 292     size = INITIAL_BUFFER_SIZE;
 293   else
 294     size = buffer->size * 2;
 295
 296   data = g_malloc (size);
 297   in_buffer = buffer_data_size (buffer);
 298
 299   memcpy (data,
 300           buffer->data + buffer->start,
 301           in_buffer);
 302   g_free (buffer->data);
 303   buffer->data = data;
 304   buffer->end -= buffer->start;
 305   buffer->start = 0;
 306   buffer->size = size;
 307 }
 308
 309 /* Ensures that the buffer can fit at_least_size bytes,
 310  * *including* the current in-buffer data */
 311 static void
 312 buffer_ensure_space (Buffer *buffer,
 313                      gsize at_least_size)
 314 {
 315   gsize in_buffer, left_to_fill;
 316
 317   in_buffer = buffer_data_size (buffer);
 318
 319   if (in_buffer >= at_least_size)
 320     return;
 321
 322   left_to_fill = buffer_tailspace (buffer);
 323
 324   if (in_buffer + left_to_fill >= at_least_size)
 325     {
 326       /* We fit in remaining space at end */
 327       /* If the copy is small, compact now anyway so we can fill more */
 328       if (in_buffer < 256)
 329         compact_buffer (buffer);
 330     }
 331   else if (buffer->size >= at_least_size)
 332     {
 333       /* We fit, but only if we compact */
 334       compact_buffer (buffer);
 335     }
 336   else
 337     {
 338       /* Need to grow buffer */
 339       while (buffer->size < at_least_size)
 340         grow_buffer (buffer);
 341     }
 342 }
 343
 344 static gssize
 345 fill_input_buffer (GConverterInputStream  *stream,
 346                    gsize                   at_least_size,
 347                    gboolean                blocking,
 348                    GCancellable           *cancellable,
 349                    GError                **error)
 350 {
 351   GConverterInputStreamPrivate *priv;
 352   GInputStream *base_stream;
 353   gssize nread;
 354
 355   priv = stream->priv;
 356
 357   buffer_ensure_space (&priv->input_buffer, at_least_size);
 358
 359   base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
 360   nread = g_pollable_stream_read (base_stream,
 361                                   priv->input_buffer.data + priv->input_buffer.end,
 362                                   buffer_tailspace (&priv->input_buffer),
 363                                   blocking,
 364                                   cancellable,
 365                                   error);
 366
 367   if (nread > 0)
 368     {
 369       priv->input_buffer.end += nread;
 370       priv->need_input = FALSE;
 371     }
 372
 373   return nread;
 374 }
 375
 376
 377 static gssize
 378 read_internal (GInputStream *stream,
 379                void         *buffer,
 380                gsize         count,
 381                gboolean      blocking,
 382                GCancellable *cancellable,
 383                GError      **error)
 384 {
 385   GConverterInputStream *cstream;
 386   GConverterInputStreamPrivate *priv;
 387   gsize available, total_bytes_read;
 388   gssize nread;
 389   GConverterResult res;
 390   gsize bytes_read;
 391   gsize bytes_written;
 392   GError *my_error;
 393   GError *my_error2;
 394
 395   cstream = G_CONVERTER_INPUT_STREAM (stream);
 396   priv = cstream->priv;
 397
 398   available = buffer_data_size (&priv->converted_buffer);
 399
 400   if (available > 0 &&
 401       count <= available)
 402     {
 403       /* Converted data available, return that */
 404       buffer_read (&priv->converted_buffer, buffer, count);
 405       return count;
 406     }
 407
 408   /* Full request not available, read all currently available and request
 409      refill/conversion for more */
 410
 411   buffer_read (&priv->converted_buffer, buffer, available);
 412
 413   total_bytes_read = available;
 414   buffer = (char *) buffer + available;
 415   count -= available;
 416
 417   /* If there is no data to convert, and no pre-converted data,
 418      do some i/o for more input */
 419   if (buffer_data_size (&priv->input_buffer) == 0 &&
 420       total_bytes_read == 0 &&
 421       !priv->at_input_end)
 422     {
 423       nread = fill_input_buffer (cstream, count, blocking, cancellable, error);
 424       if (nread < 0)
 425         return -1;
 426       if (nread == 0)
 427         priv->at_input_end = TRUE;
 428     }
 429
 430   /* First try to convert any available data (or state) directly to the user buffer: */
 431   if (!priv->finished)
 432     {
 433       my_error = NULL;
 434       res = g_converter_convert (priv->converter,
 435                                  buffer_data (&priv->input_buffer),
 436                                  buffer_data_size (&priv->input_buffer),
 437                                  buffer, count,
 438                                  priv->at_input_end ? G_CONVERTER_INPUT_AT_END : 0,
 439                                  &bytes_read,
 440                                  &bytes_written,
 441                                  &my_error);
 442       if (res != G_CONVERTER_ERROR)
 443         {
 444           total_bytes_read += bytes_written;
 445           buffer_consumed (&priv->input_buffer, bytes_read);
 446           if (res == G_CONVERTER_FINISHED)
 447             priv->finished = TRUE; /* We're done converting */
 448         }
 449       else if (total_bytes_read == 0 &&
 450                !g_error_matches (my_error,
 451                                  G_IO_ERROR,
 452                                  G_IO_ERROR_PARTIAL_INPUT) &&
 453                !g_error_matches (my_error,
 454                                  G_IO_ERROR,
 455                                  G_IO_ERROR_NO_SPACE))
 456         {
 457           /* No previously read data and no "special" error, return error */
 458           g_propagate_error (error, my_error);
 459           return -1;
 460         }
 461       else
 462         g_error_free (my_error);
 463     }
 464
 465   /* We had some pre-converted data and/or we converted directly to the
 466      user buffer */
 467   if (total_bytes_read > 0)
 468     return total_bytes_read;
 469
 470   /* If there is no more to convert, return EOF */
 471   if (priv->finished)
 472     {
 473       g_assert (buffer_data_size (&priv->converted_buffer) == 0);
 474       return 0;
 475     }
 476
 477   /* There was "complexity" in the straight-to-buffer conversion,
 478    * convert to our own buffer and write from that.
 479    * At this point we didn't produce any data into @buffer.
 480    */
 481
 482   /* Ensure we have *some* initial target space */
 483   buffer_ensure_space (&priv->converted_buffer, count);
 484
 485   while (TRUE)
 486     {
 487       g_assert (!priv->finished);
 488
 489       /* Try to convert to our buffer */
 490       my_error = NULL;
 491       res = g_converter_convert (priv->converter,
 492                                  buffer_data (&priv->input_buffer),
 493                                  buffer_data_size (&priv->input_buffer),
 494                                  buffer_data (&priv->converted_buffer),
 495                                  buffer_tailspace (&priv->converted_buffer),
 496                                  priv->at_input_end ? G_CONVERTER_INPUT_AT_END : 0,
 497                                  &bytes_read,
 498                                  &bytes_written,
 499                                  &my_error);
 500       if (res != G_CONVERTER_ERROR)
 501         {
 502           priv->converted_buffer.end += bytes_written;
 503           buffer_consumed (&priv->input_buffer, bytes_read);
 504
 505           /* Maybe we consumed without producing any output */
 506           if (buffer_data_size (&priv->converted_buffer) == 0 && res != G_CONVERTER_FINISHED)
 507             continue; /* Convert more */
 508
 509           if (res == G_CONVERTER_FINISHED)
 510             priv->finished = TRUE;
 511
 512           total_bytes_read = MIN (count, buffer_data_size (&priv->converted_buffer));
 513           buffer_read (&priv->converted_buffer, buffer, total_bytes_read);
 514
 515           g_assert (priv->finished || total_bytes_read > 0);
 516
 517           return total_bytes_read;
 518         }
 519
 520       /* There was some kind of error filling our buffer */
 521
 522       if (g_error_matches (my_error,
 523                            G_IO_ERROR,
 524                            G_IO_ERROR_PARTIAL_INPUT) &&
 525           !priv->at_input_end)
 526         {
 527           /* Need more data */
 528           my_error2 = NULL;
 529           nread = fill_input_buffer (cstream,
 530                                      buffer_data_size (&priv->input_buffer) + 4096,
 531                                      blocking,
 532                                      cancellable,
 533                                      &my_error2);
 534           if (nread < 0)
 535             {
 536               /* Can't read any more data, return that error */
 537               g_error_free (my_error);
 538               g_propagate_error (error, my_error2);
 539               priv->need_input = TRUE;
 540               return -1;
 541             }
 542           else if (nread == 0)
 543             {
 544               /* End of file, try INPUT_AT_END */
 545               priv->at_input_end = TRUE;
 546             }
 547           g_error_free (my_error);
 548           continue;
 549         }
 550
 551       if (g_error_matches (my_error,
 552                            G_IO_ERROR,
 553                            G_IO_ERROR_NO_SPACE))
 554         {
 555           /* Need more destination space, grow it
 556            * Note: if we actually grow the buffer (as opposed to compacting it),
 557            * this will double the size, not just add one byte. */
 558           buffer_ensure_space (&priv->converted_buffer,
 559                                priv->converted_buffer.size + 1);
 560           g_error_free (my_error);
 561           continue;
 562         }
 563
 564       /* Any other random error, return it */
 565       g_propagate_error (error, my_error);
 566       return -1;
 567     }
 568
 569   g_assert_not_reached ();
 570 }
 571
 572 static gssize
 573 g_converter_input_stream_read (GInputStream *stream,
 574                                void         *buffer,
 575                                gsize         count,
 576                                GCancellable *cancellable,
 577                                GError      **error)
 578 {
 579   return read_internal (stream, buffer, count, TRUE, cancellable, error);
 580 }
 581
 582 static gboolean
 583 g_converter_input_stream_can_poll (GPollableInputStream *stream)
 584 {
 585   GInputStream *base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
 586
 587   return (G_IS_POLLABLE_INPUT_STREAM (base_stream) &&
 588           g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (base_stream)));
 589 }
 590
 591 static gboolean
 592 g_converter_input_stream_is_readable (GPollableInputStream *stream)
 593 {
 594   GInputStream *base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
 595   GConverterInputStream *cstream = G_CONVERTER_INPUT_STREAM (stream);
 596
 597   if (buffer_data_size (&cstream->priv->converted_buffer))
 598     return TRUE;
 599   else if (buffer_data_size (&cstream->priv->input_buffer) &&
 600            !cstream->priv->need_input)
 601     return TRUE;
 602   else
 603     return g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (base_stream));
 604 }
 605
 606 static gssize
 607 g_converter_input_stream_read_nonblocking (GPollableInputStream  *stream,
 608                                            void                  *buffer,
 609                                            gsize                  count,
 610                                            GError               **error)
 611 {
 612   return read_internal (G_INPUT_STREAM (stream), buffer, count,
 613                         FALSE, NULL, error);
 614 }
 615
 616 static GSource *
 617 g_converter_input_stream_create_source (GPollableInputStream *stream,
 618                                         GCancellable         *cancellable)
 619 {
 620   GInputStream *base_stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
 621   GSource *base_source, *pollable_source;
 622
 623   if (g_pollable_input_stream_is_readable (stream))
 624     base_source = g_timeout_source_new (0);
 625   else
 626     base_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (base_stream), NULL);
 627
 628   pollable_source = g_pollable_source_new_full (stream, base_source,
 629                                                 cancellable);
 630   g_source_unref (base_source);
 631
 632   return pollable_source;
 633 }
 634
 635
 636 /**
 637  * g_converter_input_stream_get_converter:
 638  * @converter_stream: a #GConverterInputStream
 639  *
 640  * Gets the #GConverter that is used by @converter_stream.
 641  *
 642  * Returns: (transfer none): the converter of the converter input stream
 643  *
 644  * Since: 2.24
 645  */
 646 GConverter *
 647 g_converter_input_stream_get_converter (GConverterInputStream *converter_stream)
 648 {
 649   return converter_stream->priv->converter;
 650 }