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 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: Christian Kellner <gicmo (at) gnome.org> 21 */ 22 23 #include "config.h" 24 #include "gmemoryinputstream.h" 25 #include "ginputstream.h" 26 #include "gseekable.h" 27 #include "string.h" 28 #include "gsimpleasyncresult.h" 29 #include "gioerror.h" 30 #include "glibintl.h" 31 32 #include "gioalias.h" 33 34 /** 35 * SECTION:gmemoryinputstream 36 * @short_description: Streaming input operations on memory chunks 37 * @include: gio/gio.h 38 * @see_also: #GMemoryOutputStream 39 * 40 * #GMemoryInputStream is a class for using arbitrary 41 * memory chunks as input for GIO streaming input operations. 42 * 43 */ 44 45 typedef struct _Chunk Chunk; 46 47 struct _Chunk { 48 guint8 *data; 49 gsize len; 50 GDestroyNotify destroy; 51 }; 52 53 struct _GMemoryInputStreamPrivate { 54 GSList *chunks; 55 gsize len; 56 gsize pos; 57 }; 58 59 static gssize g_memory_input_stream_read (GInputStream *stream, 60 void *buffer, 61 gsize count, 62 GCancellable *cancellable, 63 GError **error); 64 static gssize g_memory_input_stream_skip (GInputStream *stream, 65 gsize count, 66 GCancellable *cancellable, 67 GError **error); 68 static gboolean g_memory_input_stream_close (GInputStream *stream, 69 GCancellable *cancellable, 70 GError **error); 71 static void g_memory_input_stream_read_async (GInputStream *stream, 72 void *buffer, 73 gsize count, 74 int io_priority, 75 GCancellable *cancellable, 76 GAsyncReadyCallback callback, 77 gpointer user_data); 78 static gssize g_memory_input_stream_read_finish (GInputStream *stream, 79 GAsyncResult *result, 80 GError **error); 81 static void g_memory_input_stream_skip_async (GInputStream *stream, 82 gsize count, 83 int io_priority, 84 GCancellable *cancellabl, 85 GAsyncReadyCallback callback, 86 gpointer datae); 87 static gssize g_memory_input_stream_skip_finish (GInputStream *stream, 88 GAsyncResult *result, 89 GError **error); 90 static void g_memory_input_stream_close_async (GInputStream *stream, 91 int io_priority, 92 GCancellable *cancellabl, 93 GAsyncReadyCallback callback, 94 gpointer data); 95 static gboolean g_memory_input_stream_close_finish (GInputStream *stream, 96 GAsyncResult *result, 97 GError **error); 98 99 static void g_memory_input_stream_seekable_iface_init (GSeekableIface *iface); 100 static goffset g_memory_input_stream_tell (GSeekable *seekable); 101 static gboolean g_memory_input_stream_can_seek (GSeekable *seekable); 102 static gboolean g_memory_input_stream_seek (GSeekable *seekable, 103 goffset offset, 104 GSeekType type, 105 GCancellable *cancellable, 106 GError **error); 107 static gboolean g_memory_input_stream_can_truncate (GSeekable *seekable); 108 static gboolean g_memory_input_stream_truncate (GSeekable *seekable, 109 goffset offset, 110 GCancellable *cancellable, 111 GError **error); 112 static void g_memory_input_stream_finalize (GObject *object); 113 114 G_DEFINE_TYPE_WITH_CODE (GMemoryInputStream, g_memory_input_stream, G_TYPE_INPUT_STREAM, 115 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE, 116 g_memory_input_stream_seekable_iface_init)) 117 118 119 static void 120 g_memory_input_stream_class_init (GMemoryInputStreamClass *klass) 121 { 122 GObjectClass *object_class; 123 GInputStreamClass *istream_class; 124 125 g_type_class_add_private (klass, sizeof (GMemoryInputStreamPrivate)); 126 127 object_class = G_OBJECT_CLASS (klass); 128 object_class->finalize = g_memory_input_stream_finalize; 129 130 istream_class = G_INPUT_STREAM_CLASS (klass); 131 istream_class->read_fn = g_memory_input_stream_read; 132 istream_class->skip = g_memory_input_stream_skip; 133 istream_class->close_fn = g_memory_input_stream_close; 134 135 istream_class->read_async = g_memory_input_stream_read_async; 136 istream_class->read_finish = g_memory_input_stream_read_finish; 137 istream_class->skip_async = g_memory_input_stream_skip_async; 138 istream_class->skip_finish = g_memory_input_stream_skip_finish; 139 istream_class->close_async = g_memory_input_stream_close_async; 140 istream_class->close_finish = g_memory_input_stream_close_finish; 141 } 142 143 static void 144 free_chunk (gpointer data, 145 gpointer user_data) 146 { 147 Chunk *chunk = data; 148 149 if (chunk->destroy) 150 chunk->destroy (chunk->data); 151 152 g_slice_free (Chunk, chunk); 153 } 154 155 static void 156 g_memory_input_stream_finalize (GObject *object) 157 { 158 GMemoryInputStream *stream; 159 GMemoryInputStreamPrivate *priv; 160 161 stream = G_MEMORY_INPUT_STREAM (object); 162 priv = stream->priv; 163 164 g_slist_foreach (priv->chunks, free_chunk, NULL); 165 g_slist_free (priv->chunks); 166 167 G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize (object); 168 } 169 170 static void 171 g_memory_input_stream_seekable_iface_init (GSeekableIface *iface) 172 { 173 iface->tell = g_memory_input_stream_tell; 174 iface->can_seek = g_memory_input_stream_can_seek; 175 iface->seek = g_memory_input_stream_seek; 176 iface->can_truncate = g_memory_input_stream_can_truncate; 177 iface->truncate_fn = g_memory_input_stream_truncate; 178 } 179 180 static void 181 g_memory_input_stream_init (GMemoryInputStream *stream) 182 { 183 stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, 184 G_TYPE_MEMORY_INPUT_STREAM, 185 GMemoryInputStreamPrivate); 186 } 187 188 /** 189 * g_memory_input_stream_new: 190 * 191 * Creates a new empty #GMemoryInputStream. 192 * 193 * Returns: a new #GInputStream 194 */ 195 GInputStream * 196 g_memory_input_stream_new (void) 197 { 198 GInputStream *stream; 199 200 stream = g_object_new (G_TYPE_MEMORY_INPUT_STREAM, NULL); 201 202 return stream; 203 } 204 205 /** 206 * g_memory_input_stream_new_from_data: 207 * @data: input data 208 * @len: length of the data, may be -1 if @data is a nul-terminated string 209 * @destroy: function that is called to free @data, or %NULL 210 * 211 * Creates a new #GMemoryInputStream with data in memory of a given size. 212 * 213 * Returns: new #GInputStream read from @data of @len bytes. 214 **/ 215 GInputStream * 216 g_memory_input_stream_new_from_data (const void *data, 217 gssize len, 218 GDestroyNotify destroy) 219 { 220 GInputStream *stream; 221 222 stream = g_memory_input_stream_new (); 223 224 g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (stream), 225 data, len, destroy); 226 227 return stream; 228 } 229 230 /** 231 * g_memory_input_stream_add_data: 232 * @stream: a #GMemoryInputStream 233 * @data: input data 234 * @len: length of the data, may be -1 if @data is a nul-terminated string 235 * @destroy: function that is called to free @data, or %NULL 236 * 237 * Appends @data to data that can be read from the input stream 238 */ 239 void 240 g_memory_input_stream_add_data (GMemoryInputStream *stream, 241 const void *data, 242 gssize len, 243 GDestroyNotify destroy) 244 { 245 GMemoryInputStreamPrivate *priv; 246 Chunk *chunk; 247 248 g_return_if_fail (G_IS_MEMORY_INPUT_STREAM (stream)); 249 g_return_if_fail (data != NULL); 250 251 priv = stream->priv; 252 253 if (len == -1) 254 len = strlen (data); 255 256 chunk = g_slice_new (Chunk); 257 chunk->data = (guint8 *)data; 258 chunk->len = len; 259 chunk->destroy = destroy; 260 261 priv->chunks = g_slist_append (priv->chunks, chunk); 262 priv->len += chunk->len; 263 } 264 265 static gssize 266 g_memory_input_stream_read (GInputStream *stream, 267 void *buffer, 268 gsize count, 269 GCancellable *cancellable, 270 GError **error) 271 { 272 GMemoryInputStream *memory_stream; 273 GMemoryInputStreamPrivate *priv; 274 GSList *l; 275 Chunk *chunk; 276 gsize offset, start, rest, size; 277 278 memory_stream = G_MEMORY_INPUT_STREAM (stream); 279 priv = memory_stream->priv; 280 281 count = MIN (count, priv->len - priv->pos); 282 283 offset = 0; 284 for (l = priv->chunks; l; l = l->next) 285 { 286 chunk = (Chunk *)l->data; 287 288 if (offset + chunk->len > priv->pos) 289 break; 290 291 offset += chunk->len; 292 } 293 294 start = priv->pos - offset; 295 rest = count; 296 297 for (; l && rest > 0; l = l->next) 298 { 299 chunk = (Chunk *)l->data; 300 size = MIN (rest, chunk->len - start); 301 302 memcpy ((guint8 *)buffer + (count - rest), chunk->data + start, size); 303 rest -= size; 304 305 start = 0; 306 } 307 308 priv->pos += count; 309 310 return count; 311 } 312 313 static gssize 314 g_memory_input_stream_skip (GInputStream *stream, 315 gsize count, 316 GCancellable *cancellable, 317 GError **error) 318 { 319 GMemoryInputStream *memory_stream; 320 GMemoryInputStreamPrivate *priv; 321 322 memory_stream = G_MEMORY_INPUT_STREAM (stream); 323 priv = memory_stream->priv; 324 325 count = MIN (count, priv->len - priv->pos); 326 priv->pos += count; 327 328 return count; 329 } 330 331 static gboolean 332 g_memory_input_stream_close (GInputStream *stream, 333 GCancellable *cancellable, 334 GError **error) 335 { 336 return TRUE; 337 } 338 339 static void 340 g_memory_input_stream_read_async (GInputStream *stream, 341 void *buffer, 342 gsize count, 343 int io_priority, 344 GCancellable *cancellable, 345 GAsyncReadyCallback callback, 346 gpointer user_data) 347 { 348 GSimpleAsyncResult *simple; 349 gssize nread; 350 351 nread = g_memory_input_stream_read (stream, buffer, count, cancellable, NULL); 352 simple = g_simple_async_result_new (G_OBJECT (stream), 353 callback, 354 user_data, 355 g_memory_input_stream_read_async); 356 g_simple_async_result_set_op_res_gssize (simple, nread); 357 g_simple_async_result_complete_in_idle (simple); 358 g_object_unref (simple); 359 } 360 361 static gssize 362 g_memory_input_stream_read_finish (GInputStream *stream, 363 GAsyncResult *result, 364 GError **error) 365 { 366 GSimpleAsyncResult *simple; 367 gssize nread; 368 369 simple = G_SIMPLE_ASYNC_RESULT (result); 370 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_memory_input_stream_read_async); 371 372 nread = g_simple_async_result_get_op_res_gssize (simple); 373 return nread; 374 } 375 376 static void 377 g_memory_input_stream_skip_async (GInputStream *stream, 378 gsize count, 379 int io_priority, 380 GCancellable *cancellable, 381 GAsyncReadyCallback callback, 382 gpointer user_data) 383 { 384 GSimpleAsyncResult *simple; 385 gssize nskipped; 386 387 nskipped = g_memory_input_stream_skip (stream, count, cancellable, NULL); 388 simple = g_simple_async_result_new (G_OBJECT (stream), 389 callback, 390 user_data, 391 g_memory_input_stream_skip_async); 392 g_simple_async_result_set_op_res_gssize (simple, nskipped); 393 g_simple_async_result_complete_in_idle (simple); 394 g_object_unref (simple); 395 } 396 397 static gssize 398 g_memory_input_stream_skip_finish (GInputStream *stream, 399 GAsyncResult *result, 400 GError **error) 401 { 402 GSimpleAsyncResult *simple; 403 gssize nskipped; 404 405 simple = G_SIMPLE_ASYNC_RESULT (result); 406 g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_memory_input_stream_skip_async); 407 408 nskipped = g_simple_async_result_get_op_res_gssize (simple); 409 return nskipped; 410 } 411 412 static void 413 g_memory_input_stream_close_async (GInputStream *stream, 414 int io_priority, 415 GCancellable *cancellable, 416 GAsyncReadyCallback callback, 417 gpointer user_data) 418 { 419 GSimpleAsyncResult *simple; 420 421 simple = g_simple_async_result_new (G_OBJECT (stream), 422 callback, 423 user_data, 424 g_memory_input_stream_close_async); 425 g_simple_async_result_complete_in_idle (simple); 426 g_object_unref (simple); 427 } 428 429 static gboolean 430 g_memory_input_stream_close_finish (GInputStream *stream, 431 GAsyncResult *result, 432 GError **error) 433 { 434 return TRUE; 435 } 436 437 static goffset 438 g_memory_input_stream_tell (GSeekable *seekable) 439 { 440 GMemoryInputStream *memory_stream; 441 GMemoryInputStreamPrivate *priv; 442 443 memory_stream = G_MEMORY_INPUT_STREAM (seekable); 444 priv = memory_stream->priv; 445 446 return priv->pos; 447 } 448 449 static 450 gboolean g_memory_input_stream_can_seek (GSeekable *seekable) 451 { 452 return TRUE; 453 } 454 455 static gboolean 456 g_memory_input_stream_seek (GSeekable *seekable, 457 goffset offset, 458 GSeekType type, 459 GCancellable *cancellable, 460 GError **error) 461 { 462 GMemoryInputStream *memory_stream; 463 GMemoryInputStreamPrivate *priv; 464 goffset absolute; 465 466 memory_stream = G_MEMORY_INPUT_STREAM (seekable); 467 priv = memory_stream->priv; 468 469 switch (type) 470 { 471 case G_SEEK_CUR: 472 absolute = priv->pos + offset; 473 break; 474 475 case G_SEEK_SET: 476 absolute = offset; 477 break; 478 479 case G_SEEK_END: 480 absolute = priv->len + offset; 481 break; 482 483 default: 484 g_set_error_literal (error, 485 G_IO_ERROR, 486 G_IO_ERROR_INVALID_ARGUMENT, 487 _("Invalid GSeekType supplied")); 488 489 return FALSE; 490 } 491 492 if (absolute < 0 || absolute > priv->len) 493 { 494 g_set_error_literal (error, 495 G_IO_ERROR, 496 G_IO_ERROR_INVALID_ARGUMENT, 497 _("Invalid seek request")); 498 return FALSE; 499 } 500 501 priv->pos = absolute; 502 503 return TRUE; 504 } 505 506 static gboolean 507 g_memory_input_stream_can_truncate (GSeekable *seekable) 508 { 509 return FALSE; 510 } 511 512 static gboolean 513 g_memory_input_stream_truncate (GSeekable *seekable, 514 goffset offset, 515 GCancellable *cancellable, 516 GError **error) 517 { 518 g_set_error_literal (error, 519 G_IO_ERROR, 520 G_IO_ERROR_NOT_SUPPORTED, 521 _("Cannot truncate GMemoryInputStream")); 522 return FALSE; 523 } 524 525 #define __G_MEMORY_INPUT_STREAM_C__ 526 #include "gioaliasdef.c" 527
