1/* GIO - GLib Input, Output and Streaming Library
2 *
3 * Copyright (C) 2006-2007 Red Hat, Inc.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 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, see <http://www.gnu.org/licenses/>.
17 *
18 * Authors:
19 * Christian Kellner <gicmo@gnome.org>
20 * Krzysztof Kosiński <tweenk.pl@gmail.com>
21 */
22
23#include "config.h"
24#include "gmemoryoutputstream.h"
25#include "goutputstream.h"
26#include "gpollableoutputstream.h"
27#include "gseekable.h"
28#include "gtask.h"
29#include "gioerror.h"
30#include "string.h"
31#include "glibintl.h"
32
33
34/**
35 * SECTION:gmemoryoutputstream
36 * @short_description: Streaming output operations on memory chunks
37 * @include: gio/gio.h
38 * @see_also: #GMemoryInputStream
39 *
40 * #GMemoryOutputStream is a class for using arbitrary
41 * memory chunks as output for GIO streaming output operations.
42 *
43 * As of GLib 2.34, #GMemoryOutputStream trivially implements
44 * #GPollableOutputStream: it always polls as ready.
45 */
46
47#define MIN_ARRAY_SIZE 16
48
49enum {
50 PROP_0,
51 PROP_DATA,
52 PROP_SIZE,
53 PROP_DATA_SIZE,
54 PROP_REALLOC_FUNCTION,
55 PROP_DESTROY_FUNCTION
56};
57
58struct _GMemoryOutputStreamPrivate
59{
60 gpointer data; /* Write buffer */
61 gsize len; /* Current length of the data buffer. Can change with resizing. */
62 gsize valid_len; /* The part of data that has been written to */
63 gsize pos; /* Current position in the stream. Distinct from valid_len,
64 because the stream is seekable. */
65
66 GReallocFunc realloc_fn;
67 GDestroyNotify destroy;
68};
69
70static void g_memory_output_stream_set_property (GObject *object,
71 guint prop_id,
72 const GValue *value,
73 GParamSpec *pspec);
74static void g_memory_output_stream_get_property (GObject *object,
75 guint prop_id,
76 GValue *value,
77 GParamSpec *pspec);
78static void g_memory_output_stream_finalize (GObject *object);
79
80static gssize g_memory_output_stream_write (GOutputStream *stream,
81 const void *buffer,
82 gsize count,
83 GCancellable *cancellable,
84 GError **error);
85
86static gboolean g_memory_output_stream_close (GOutputStream *stream,
87 GCancellable *cancellable,
88 GError **error);
89
90static void g_memory_output_stream_close_async (GOutputStream *stream,
91 int io_priority,
92 GCancellable *cancellable,
93 GAsyncReadyCallback callback,
94 gpointer data);
95static gboolean g_memory_output_stream_close_finish (GOutputStream *stream,
96 GAsyncResult *result,
97 GError **error);
98
99static void g_memory_output_stream_seekable_iface_init (GSeekableIface *iface);
100static goffset g_memory_output_stream_tell (GSeekable *seekable);
101static gboolean g_memory_output_stream_can_seek (GSeekable *seekable);
102static gboolean g_memory_output_stream_seek (GSeekable *seekable,
103 goffset offset,
104 GSeekType type,
105 GCancellable *cancellable,
106 GError **error);
107static gboolean g_memory_output_stream_can_truncate (GSeekable *seekable);
108static gboolean g_memory_output_stream_truncate (GSeekable *seekable,
109 goffset offset,
110 GCancellable *cancellable,
111 GError **error);
112
113static gboolean g_memory_output_stream_is_writable (GPollableOutputStream *stream);
114static GSource *g_memory_output_stream_create_source (GPollableOutputStream *stream,
115 GCancellable *cancellable);
116
117static void g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface);
118
119G_DEFINE_TYPE_WITH_CODE (GMemoryOutputStream, g_memory_output_stream, G_TYPE_OUTPUT_STREAM,
120 G_ADD_PRIVATE (GMemoryOutputStream)
121 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
122 g_memory_output_stream_seekable_iface_init);
123 G_IMPLEMENT_INTERFACE (G_TYPE_POLLABLE_OUTPUT_STREAM,
124 g_memory_output_stream_pollable_iface_init))
125
126
127static void
128g_memory_output_stream_class_init (GMemoryOutputStreamClass *klass)
129{
130 GOutputStreamClass *ostream_class;
131 GObjectClass *gobject_class;
132
133 gobject_class = G_OBJECT_CLASS (klass);
134 gobject_class->set_property = g_memory_output_stream_set_property;
135 gobject_class->get_property = g_memory_output_stream_get_property;
136 gobject_class->finalize = g_memory_output_stream_finalize;
137
138 ostream_class = G_OUTPUT_STREAM_CLASS (klass);
139
140 ostream_class->write_fn = g_memory_output_stream_write;
141 ostream_class->close_fn = g_memory_output_stream_close;
142 ostream_class->close_async = g_memory_output_stream_close_async;
143 ostream_class->close_finish = g_memory_output_stream_close_finish;
144
145 /**
146 * GMemoryOutputStream:data:
147 *
148 * Pointer to buffer where data will be written.
149 *
150 * Since: 2.24
151 **/
152 g_object_class_install_property (oclass: gobject_class,
153 property_id: PROP_DATA,
154 pspec: g_param_spec_pointer (name: "data",
155 P_("Data Buffer"),
156 P_("Pointer to buffer where data will be written."),
157 flags: G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
158 G_PARAM_STATIC_STRINGS));
159
160 /**
161 * GMemoryOutputStream:size:
162 *
163 * Current size of the data buffer.
164 *
165 * Since: 2.24
166 **/
167 g_object_class_install_property (oclass: gobject_class,
168 property_id: PROP_SIZE,
169 pspec: g_param_spec_ulong (name: "size",
170 P_("Data Buffer Size"),
171 P_("Current size of the data buffer."),
172 minimum: 0, G_MAXULONG, default_value: 0,
173 flags: G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
174 G_PARAM_STATIC_STRINGS));
175
176 /**
177 * GMemoryOutputStream:data-size:
178 *
179 * Size of data written to the buffer.
180 *
181 * Since: 2.24
182 **/
183 g_object_class_install_property (oclass: gobject_class,
184 property_id: PROP_DATA_SIZE,
185 pspec: g_param_spec_ulong (name: "data-size",
186 P_("Data Size"),
187 P_("Size of data written to the buffer."),
188 minimum: 0, G_MAXULONG, default_value: 0,
189 flags: G_PARAM_READABLE |
190 G_PARAM_STATIC_STRINGS));
191
192 /**
193 * GMemoryOutputStream:realloc-function: (skip)
194 *
195 * Function with realloc semantics called to enlarge the buffer.
196 *
197 * Since: 2.24
198 **/
199 g_object_class_install_property (oclass: gobject_class,
200 property_id: PROP_REALLOC_FUNCTION,
201 pspec: g_param_spec_pointer (name: "realloc-function",
202 P_("Memory Reallocation Function"),
203 P_("Function with realloc semantics called to enlarge the buffer."),
204 flags: G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
205 G_PARAM_STATIC_STRINGS));
206
207 /**
208 * GMemoryOutputStream:destroy-function: (skip)
209 *
210 * Function called with the buffer as argument when the stream is destroyed.
211 *
212 * Since: 2.24
213 **/
214 g_object_class_install_property (oclass: gobject_class,
215 property_id: PROP_DESTROY_FUNCTION,
216 pspec: g_param_spec_pointer (name: "destroy-function",
217 P_("Destroy Notification Function"),
218 P_("Function called with the buffer as argument when the stream is destroyed."),
219 flags: G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
220 G_PARAM_STATIC_STRINGS));
221}
222
223static void
224g_memory_output_stream_pollable_iface_init (GPollableOutputStreamInterface *iface)
225{
226 iface->is_writable = g_memory_output_stream_is_writable;
227 iface->create_source = g_memory_output_stream_create_source;
228}
229
230static void
231g_memory_output_stream_set_property (GObject *object,
232 guint prop_id,
233 const GValue *value,
234 GParamSpec *pspec)
235{
236 GMemoryOutputStream *stream;
237 GMemoryOutputStreamPrivate *priv;
238
239 stream = G_MEMORY_OUTPUT_STREAM (object);
240 priv = stream->priv;
241
242 switch (prop_id)
243 {
244 case PROP_DATA:
245 priv->data = g_value_get_pointer (value);
246 break;
247 case PROP_SIZE:
248 priv->len = g_value_get_ulong (value);
249 break;
250 case PROP_REALLOC_FUNCTION:
251 priv->realloc_fn = g_value_get_pointer (value);
252 break;
253 case PROP_DESTROY_FUNCTION:
254 priv->destroy = g_value_get_pointer (value);
255 break;
256 default:
257 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
258 break;
259 }
260}
261
262static void
263g_memory_output_stream_get_property (GObject *object,
264 guint prop_id,
265 GValue *value,
266 GParamSpec *pspec)
267{
268 GMemoryOutputStream *stream;
269 GMemoryOutputStreamPrivate *priv;
270
271 stream = G_MEMORY_OUTPUT_STREAM (object);
272 priv = stream->priv;
273
274 switch (prop_id)
275 {
276 case PROP_DATA:
277 g_value_set_pointer (value, v_pointer: priv->data);
278 break;
279 case PROP_SIZE:
280 g_value_set_ulong (value, v_ulong: priv->len);
281 break;
282 case PROP_DATA_SIZE:
283 g_value_set_ulong (value, v_ulong: priv->valid_len);
284 break;
285 case PROP_REALLOC_FUNCTION:
286 g_value_set_pointer (value, v_pointer: priv->realloc_fn);
287 break;
288 case PROP_DESTROY_FUNCTION:
289 g_value_set_pointer (value, v_pointer: priv->destroy);
290 break;
291 default:
292 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
293 break;
294 }
295}
296
297static void
298g_memory_output_stream_finalize (GObject *object)
299{
300 GMemoryOutputStream *stream;
301 GMemoryOutputStreamPrivate *priv;
302
303 stream = G_MEMORY_OUTPUT_STREAM (object);
304 priv = stream->priv;
305
306 if (priv->destroy)
307 priv->destroy (priv->data);
308
309 G_OBJECT_CLASS (g_memory_output_stream_parent_class)->finalize (object);
310}
311
312static void
313g_memory_output_stream_seekable_iface_init (GSeekableIface *iface)
314{
315 iface->tell = g_memory_output_stream_tell;
316 iface->can_seek = g_memory_output_stream_can_seek;
317 iface->seek = g_memory_output_stream_seek;
318 iface->can_truncate = g_memory_output_stream_can_truncate;
319 iface->truncate_fn = g_memory_output_stream_truncate;
320}
321
322
323static void
324g_memory_output_stream_init (GMemoryOutputStream *stream)
325{
326 stream->priv = g_memory_output_stream_get_instance_private (self: stream);
327 stream->priv->pos = 0;
328 stream->priv->valid_len = 0;
329}
330
331/**
332 * g_memory_output_stream_new: (skip)
333 * @data: (nullable): pointer to a chunk of memory to use, or %NULL
334 * @size: the size of @data
335 * @realloc_function: (nullable): a function with realloc() semantics (like g_realloc())
336 * to be called when @data needs to be grown, or %NULL
337 * @destroy_function: (nullable): a function to be called on @data when the stream is
338 * finalized, or %NULL
339 *
340 * Creates a new #GMemoryOutputStream.
341 *
342 * In most cases this is not the function you want. See
343 * g_memory_output_stream_new_resizable() instead.
344 *
345 * If @data is non-%NULL, the stream will use that for its internal storage.
346 *
347 * If @realloc_fn is non-%NULL, it will be used for resizing the internal
348 * storage when necessary and the stream will be considered resizable.
349 * In that case, the stream will start out being (conceptually) empty.
350 * @size is used only as a hint for how big @data is. Specifically,
351 * seeking to the end of a newly-created stream will seek to zero, not
352 * @size. Seeking past the end of the stream and then writing will
353 * introduce a zero-filled gap.
354 *
355 * If @realloc_fn is %NULL then the stream is fixed-sized. Seeking to
356 * the end will seek to @size exactly. Writing past the end will give
357 * an 'out of space' error. Attempting to seek past the end will fail.
358 * Unlike the resizable case, seeking to an offset within the stream and
359 * writing will preserve the bytes passed in as @data before that point
360 * and will return them as part of g_memory_output_stream_steal_data().
361 * If you intend to seek you should probably therefore ensure that @data
362 * is properly initialised.
363 *
364 * It is probably only meaningful to provide @data and @size in the case
365 * that you want a fixed-sized stream. Put another way: if @realloc_fn
366 * is non-%NULL then it makes most sense to give @data as %NULL and
367 * @size as 0 (allowing #GMemoryOutputStream to do the initial
368 * allocation for itself).
369 *
370 * |[<!-- language="C" -->
371 * // a stream that can grow
372 * stream = g_memory_output_stream_new (NULL, 0, realloc, free);
373 *
374 * // another stream that can grow
375 * stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
376 *
377 * // a fixed-size stream
378 * data = malloc (200);
379 * stream3 = g_memory_output_stream_new (data, 200, NULL, free);
380 * ]|
381 *
382 * Returns: A newly created #GMemoryOutputStream object.
383 **/
384GOutputStream *
385g_memory_output_stream_new (gpointer data,
386 gsize size,
387 GReallocFunc realloc_function,
388 GDestroyNotify destroy_function)
389{
390 GOutputStream *stream;
391
392 stream = g_object_new (G_TYPE_MEMORY_OUTPUT_STREAM,
393 first_property_name: "data", data,
394 "size", size,
395 "realloc-function", realloc_function,
396 "destroy-function", destroy_function,
397 NULL);
398
399 return stream;
400}
401
402/**
403 * g_memory_output_stream_new_resizable:
404 *
405 * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
406 * for memory allocation.
407 *
408 * Since: 2.36
409 */
410GOutputStream *
411g_memory_output_stream_new_resizable (void)
412{
413 return g_memory_output_stream_new (NULL, size: 0, realloc_function: g_realloc, destroy_function: g_free);
414}
415
416/**
417 * g_memory_output_stream_get_data:
418 * @ostream: a #GMemoryOutputStream
419 *
420 * Gets any loaded data from the @ostream.
421 *
422 * Note that the returned pointer may become invalid on the next
423 * write or truncate operation on the stream.
424 *
425 * Returns: (transfer none): pointer to the stream's data, or %NULL if the data
426 * has been stolen
427 **/
428gpointer
429g_memory_output_stream_get_data (GMemoryOutputStream *ostream)
430{
431 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
432
433 return ostream->priv->data;
434}
435
436/**
437 * g_memory_output_stream_get_size:
438 * @ostream: a #GMemoryOutputStream
439 *
440 * Gets the size of the currently allocated data area (available from
441 * g_memory_output_stream_get_data()).
442 *
443 * You probably don't want to use this function on resizable streams.
444 * See g_memory_output_stream_get_data_size() instead. For resizable
445 * streams the size returned by this function is an implementation
446 * detail and may be change at any time in response to operations on the
447 * stream.
448 *
449 * If the stream is fixed-sized (ie: no realloc was passed to
450 * g_memory_output_stream_new()) then this is the maximum size of the
451 * stream and further writes will return %G_IO_ERROR_NO_SPACE.
452 *
453 * In any case, if you want the number of bytes currently written to the
454 * stream, use g_memory_output_stream_get_data_size().
455 *
456 * Returns: the number of bytes allocated for the data buffer
457 */
458gsize
459g_memory_output_stream_get_size (GMemoryOutputStream *ostream)
460{
461 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
462
463 return ostream->priv->len;
464}
465
466/**
467 * g_memory_output_stream_get_data_size:
468 * @ostream: a #GMemoryOutputStream
469 *
470 * Returns the number of bytes from the start up to including the last
471 * byte written in the stream that has not been truncated away.
472 *
473 * Returns: the number of bytes written to the stream
474 *
475 * Since: 2.18
476 */
477gsize
478g_memory_output_stream_get_data_size (GMemoryOutputStream *ostream)
479{
480 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), 0);
481
482 return ostream->priv->valid_len;
483}
484
485/**
486 * g_memory_output_stream_steal_data:
487 * @ostream: a #GMemoryOutputStream
488 *
489 * Gets any loaded data from the @ostream. Ownership of the data
490 * is transferred to the caller; when no longer needed it must be
491 * freed using the free function set in @ostream's
492 * #GMemoryOutputStream:destroy-function property.
493 *
494 * @ostream must be closed before calling this function.
495 *
496 * Returns: (transfer full): the stream's data, or %NULL if it has previously
497 * been stolen
498 *
499 * Since: 2.26
500 **/
501gpointer
502g_memory_output_stream_steal_data (GMemoryOutputStream *ostream)
503{
504 gpointer data;
505
506 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
507 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream)), NULL);
508
509 data = ostream->priv->data;
510 ostream->priv->data = NULL;
511
512 return data;
513}
514
515/**
516 * g_memory_output_stream_steal_as_bytes:
517 * @ostream: a #GMemoryOutputStream
518 *
519 * Returns data from the @ostream as a #GBytes. @ostream must be
520 * closed before calling this function.
521 *
522 * Returns: (transfer full): the stream's data
523 *
524 * Since: 2.34
525 **/
526GBytes *
527g_memory_output_stream_steal_as_bytes (GMemoryOutputStream *ostream)
528{
529 GBytes *result;
530
531 g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (ostream), NULL);
532 g_return_val_if_fail (g_output_stream_is_closed (G_OUTPUT_STREAM (ostream)), NULL);
533
534 result = g_bytes_new_with_free_func (data: ostream->priv->data,
535 size: ostream->priv->valid_len,
536 free_func: ostream->priv->destroy,
537 user_data: ostream->priv->data);
538 ostream->priv->data = NULL;
539
540 return result;
541}
542
543static gboolean
544array_resize (GMemoryOutputStream *ostream,
545 gsize size,
546 gboolean allow_partial,
547 GError **error)
548{
549 GMemoryOutputStreamPrivate *priv;
550 gpointer data;
551 gsize len;
552
553 priv = ostream->priv;
554
555 if (priv->len == size)
556 return TRUE;
557
558 if (!priv->realloc_fn)
559 {
560 if (allow_partial &&
561 priv->pos < priv->len)
562 return TRUE; /* Short write */
563
564 g_set_error_literal (err: error,
565 G_IO_ERROR,
566 code: G_IO_ERROR_NO_SPACE,
567 _("Memory output stream not resizable"));
568 return FALSE;
569 }
570
571 len = priv->len;
572 data = priv->realloc_fn (priv->data, size);
573
574 if (size > 0 && !data)
575 {
576 if (allow_partial &&
577 priv->pos < priv->len)
578 return TRUE; /* Short write */
579
580 g_set_error_literal (err: error,
581 G_IO_ERROR,
582 code: G_IO_ERROR_NO_SPACE,
583 _("Failed to resize memory output stream"));
584 return FALSE;
585 }
586
587 if (size > len)
588 memset (s: (guint8 *)data + len, c: 0, n: size - len);
589
590 priv->data = data;
591 priv->len = size;
592
593 if (priv->len < priv->valid_len)
594 priv->valid_len = priv->len;
595
596 return TRUE;
597}
598
599static gsize
600g_nearest_pow (gsize num)
601{
602 gsize n = 1;
603
604 while (n < num && n > 0)
605 n <<= 1;
606
607 return n;
608}
609
610static gssize
611g_memory_output_stream_write (GOutputStream *stream,
612 const void *buffer,
613 gsize count,
614 GCancellable *cancellable,
615 GError **error)
616{
617 GMemoryOutputStream *ostream;
618 GMemoryOutputStreamPrivate *priv;
619 guint8 *dest;
620 gsize new_size;
621
622 ostream = G_MEMORY_OUTPUT_STREAM (stream);
623 priv = ostream->priv;
624
625 if (count == 0)
626 return 0;
627
628 /* Check for address space overflow, but only if the buffer is resizable.
629 Otherwise we just do a short write and don't worry. */
630 if (priv->realloc_fn && priv->pos + count < priv->pos)
631 goto overflow;
632
633 if (priv->pos + count > priv->len)
634 {
635 /* At least enough to fit the write, rounded up for greater than
636 * linear growth.
637 *
638 * Assuming that we're using something like realloc(), the kernel
639 * will overcommit memory to us, so doubling the size each time
640 * will keep the number of realloc calls low without wasting too
641 * much memory.
642 */
643 new_size = g_nearest_pow (num: priv->pos + count);
644 /* Check for overflow again. We have checked if
645 pos + count > G_MAXSIZE, but now check if g_nearest_pow () has
646 overflowed */
647 if (new_size == 0)
648 goto overflow;
649
650 new_size = MAX (new_size, MIN_ARRAY_SIZE);
651 if (!array_resize (ostream, size: new_size, TRUE, error))
652 return -1;
653 }
654
655 /* Make sure we handle short writes if the array_resize
656 only added part of the required memory */
657 count = MIN (count, priv->len - priv->pos);
658
659 dest = (guint8 *)priv->data + priv->pos;
660 memcpy (dest: dest, src: buffer, n: count);
661 priv->pos += count;
662
663 if (priv->pos > priv->valid_len)
664 priv->valid_len = priv->pos;
665
666 return count;
667
668 overflow:
669 /* Overflow: buffer size would need to be bigger than G_MAXSIZE. */
670 g_set_error_literal (err: error,
671 G_IO_ERROR,
672 code: G_IO_ERROR_NO_SPACE,
673 _("Amount of memory required to process the write is "
674 "larger than available address space"));
675 return -1;
676}
677
678static gboolean
679g_memory_output_stream_close (GOutputStream *stream,
680 GCancellable *cancellable,
681 GError **error)
682{
683 return TRUE;
684}
685
686static void
687g_memory_output_stream_close_async (GOutputStream *stream,
688 int io_priority,
689 GCancellable *cancellable,
690 GAsyncReadyCallback callback,
691 gpointer data)
692{
693 GTask *task;
694
695 task = g_task_new (source_object: stream, cancellable, callback, callback_data: data);
696 g_task_set_source_tag (task, g_memory_output_stream_close_async);
697
698 /* will always return TRUE */
699 g_memory_output_stream_close (stream, cancellable, NULL);
700
701 g_task_return_boolean (task, TRUE);
702 g_object_unref (object: task);
703}
704
705static gboolean
706g_memory_output_stream_close_finish (GOutputStream *stream,
707 GAsyncResult *result,
708 GError **error)
709{
710 g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
711
712 return g_task_propagate_boolean (G_TASK (result), error);
713}
714
715static goffset
716g_memory_output_stream_tell (GSeekable *seekable)
717{
718 GMemoryOutputStream *stream;
719 GMemoryOutputStreamPrivate *priv;
720
721 stream = G_MEMORY_OUTPUT_STREAM (seekable);
722 priv = stream->priv;
723
724 return priv->pos;
725}
726
727static gboolean
728g_memory_output_stream_can_seek (GSeekable *seekable)
729{
730 return TRUE;
731}
732
733static gboolean
734g_memory_output_stream_seek (GSeekable *seekable,
735 goffset offset,
736 GSeekType type,
737 GCancellable *cancellable,
738 GError **error)
739{
740 GMemoryOutputStream *stream;
741 GMemoryOutputStreamPrivate *priv;
742 goffset absolute;
743
744 stream = G_MEMORY_OUTPUT_STREAM (seekable);
745 priv = stream->priv;
746
747 switch (type)
748 {
749 case G_SEEK_CUR:
750 absolute = priv->pos + offset;
751 break;
752
753 case G_SEEK_SET:
754 absolute = offset;
755 break;
756
757 case G_SEEK_END:
758 /* For resizable streams, we consider the end to be the data
759 * length. For fixed-sized streams, we consider the end to be the
760 * size of the buffer.
761 */
762 if (priv->realloc_fn)
763 absolute = priv->valid_len + offset;
764 else
765 absolute = priv->len + offset;
766 break;
767
768 default:
769 g_set_error_literal (err: error,
770 G_IO_ERROR,
771 code: G_IO_ERROR_INVALID_ARGUMENT,
772 _("Invalid GSeekType supplied"));
773
774 return FALSE;
775 }
776
777 if (absolute < 0)
778 {
779 g_set_error_literal (err: error,
780 G_IO_ERROR,
781 code: G_IO_ERROR_INVALID_ARGUMENT,
782 _("Requested seek before the beginning of the stream"));
783 return FALSE;
784 }
785
786 /* Can't seek past the end of a fixed-size stream.
787 *
788 * Note: seeking to the non-existent byte at the end of a fixed-sized
789 * stream is valid (eg: a 1-byte fixed sized stream can have position
790 * 0 or 1). Therefore '>' is what we want.
791 * */
792 if (priv->realloc_fn == NULL && (gsize) absolute > priv->len)
793 {
794 g_set_error_literal (err: error,
795 G_IO_ERROR,
796 code: G_IO_ERROR_INVALID_ARGUMENT,
797 _("Requested seek beyond the end of the stream"));
798 return FALSE;
799 }
800
801 priv->pos = absolute;
802
803 return TRUE;
804}
805
806static gboolean
807g_memory_output_stream_can_truncate (GSeekable *seekable)
808{
809 GMemoryOutputStream *ostream;
810 GMemoryOutputStreamPrivate *priv;
811
812 ostream = G_MEMORY_OUTPUT_STREAM (seekable);
813 priv = ostream->priv;
814
815 /* We do not allow truncation of fixed-sized streams */
816 return priv->realloc_fn != NULL;
817}
818
819static gboolean
820g_memory_output_stream_truncate (GSeekable *seekable,
821 goffset offset,
822 GCancellable *cancellable,
823 GError **error)
824{
825 GMemoryOutputStream *ostream = G_MEMORY_OUTPUT_STREAM (seekable);
826
827 if (!array_resize (ostream, size: offset, FALSE, error))
828 return FALSE;
829
830 ostream->priv->valid_len = offset;
831
832 return TRUE;
833}
834
835static gboolean
836g_memory_output_stream_is_writable (GPollableOutputStream *stream)
837{
838 return TRUE;
839}
840
841static GSource *
842g_memory_output_stream_create_source (GPollableOutputStream *stream,
843 GCancellable *cancellable)
844{
845 GSource *base_source, *pollable_source;
846
847 base_source = g_timeout_source_new (interval: 0);
848 pollable_source = g_pollable_source_new_full (pollable_stream: stream, child_source: base_source, cancellable);
849 g_source_unref (source: base_source);
850
851 return pollable_source;
852}
853

source code of gtk/subprojects/glib/gio/gmemoryoutputstream.c