gfileoutputstream.c 16.3 KB
Newer Older
1 2 3 4 5 6 7
/* GIO - GLib Input, Output and Streaming Library
 * 
 * Copyright (C) 2006-2007 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * 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 11 12 13 14 15
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20
 *
 * Author: Alexander Larsson <alexl@redhat.com>
 */

21
#include "config.h"
22 23 24 25

#include <glib.h>
#include <gfileoutputstream.h>
#include <gseekable.h>
26
#include "gasyncresult.h"
27
#include "gtask.h"
28 29
#include "gcancellable.h"
#include "gioerror.h"
30 31
#include "glibintl.h"

32

33 34
/**
 * SECTION:gfileoutputstream
Matthias Clasen's avatar
Matthias Clasen committed
35
 * @short_description: File output streaming operations
Matthias Clasen's avatar
Matthias Clasen committed
36
 * @include: gio/gio.h
37
 * @see_also: #GOutputStream, #GDataOutputStream, #GSeekable
38
 * 
Matthias Clasen's avatar
Matthias Clasen committed
39 40
 * GFileOutputStream provides output streams that write their
 * content to a file.
41
 *
Matthias Clasen's avatar
Matthias Clasen committed
42 43 44
 * GFileOutputStream implements #GSeekable, which allows the output 
 * stream to jump to arbitrary positions in the file and to truncate
 * the file, provided the filesystem of the file supports these 
45 46 47 48 49 50 51 52
 * operations.
 *
 * To find the position of a file output stream, use g_seekable_tell().
 * To find out if a file output stream supports seeking, use
 * g_seekable_can_seek().To position a file output stream, use
 * g_seekable_seek(). To find out if a file output stream supports
 * truncating, use g_seekable_can_truncate(). To truncate a file output
 * stream, use g_seekable_truncate().
53 54
 **/

55 56 57 58 59 60 61 62 63 64 65 66 67 68
static void       g_file_output_stream_seekable_iface_init    (GSeekableIface       *iface);
static goffset    g_file_output_stream_seekable_tell          (GSeekable            *seekable);
static gboolean   g_file_output_stream_seekable_can_seek      (GSeekable            *seekable);
static gboolean   g_file_output_stream_seekable_seek          (GSeekable            *seekable,
							       goffset               offset,
							       GSeekType             type,
							       GCancellable         *cancellable,
							       GError              **error);
static gboolean   g_file_output_stream_seekable_can_truncate  (GSeekable            *seekable);
static gboolean   g_file_output_stream_seekable_truncate      (GSeekable            *seekable,
							       goffset               offset,
							       GCancellable         *cancellable,
							       GError              **error);
static void       g_file_output_stream_real_query_info_async  (GFileOutputStream    *stream,
69
							       const char           *attributes,
70 71 72 73 74 75 76 77 78 79 80 81
							       int                   io_priority,
							       GCancellable         *cancellable,
							       GAsyncReadyCallback   callback,
							       gpointer              user_data);
static GFileInfo *g_file_output_stream_real_query_info_finish (GFileOutputStream    *stream,
							       GAsyncResult         *result,
							       GError              **error);

struct _GFileOutputStreamPrivate {
  GAsyncReadyCallback outstanding_callback;
};

82 83 84 85 86
G_DEFINE_TYPE_WITH_CODE (GFileOutputStream, g_file_output_stream, G_TYPE_OUTPUT_STREAM,
                         G_ADD_PRIVATE (GFileOutputStream)
			 G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,
						g_file_output_stream_seekable_iface_init));

87 88 89 90 91 92 93 94 95 96 97 98 99 100
static void
g_file_output_stream_class_init (GFileOutputStreamClass *klass)
{
  klass->query_info_async = g_file_output_stream_real_query_info_async;
  klass->query_info_finish = g_file_output_stream_real_query_info_finish;
}

static void
g_file_output_stream_seekable_iface_init (GSeekableIface *iface)
{
  iface->tell = g_file_output_stream_seekable_tell;
  iface->can_seek = g_file_output_stream_seekable_can_seek;
  iface->seek = g_file_output_stream_seekable_seek;
  iface->can_truncate = g_file_output_stream_seekable_can_truncate;
101
  iface->truncate_fn = g_file_output_stream_seekable_truncate;
102 103 104 105 106
}

static void
g_file_output_stream_init (GFileOutputStream *stream)
{
107
  stream->priv = g_file_output_stream_get_instance_private (stream);
108 109 110 111 112
}

/**
 * g_file_output_stream_query_info:
 * @stream: a #GFileOutputStream.
113
 * @attributes: a file attribute query string.
114
 * @cancellable: optional #GCancellable object, %NULL to ignore. 
115
 * @error: a #GError, %NULL to ignore.
116
 *
117 118 119 120 121 122
 * Queries a file output stream for the given @attributes. 
 * This function blocks while querying the stream. For the asynchronous 
 * version of this function, see g_file_output_stream_query_info_async(). 
 * While the stream is blocked, the stream will set the pending flag 
 * internally, and any other operations on the stream will fail with 
 * %G_IO_ERROR_PENDING.
123
 * 
124 125 126 127 128 129 130 131 132 133 134
 * Can fail if the stream was already closed (with @error being set to 
 * %G_IO_ERROR_CLOSED), the stream has pending operations (with @error being
 * set to %G_IO_ERROR_PENDING), or if querying info is not supported for 
 * the stream's interface (with @error being set to %G_IO_ERROR_NOT_SUPPORTED). In
 * all cases of failure, %NULL will be returned.
 * 
 * If @cancellable is not %NULL, then the operation can be cancelled by
 * triggering the cancellable object from another thread. If the operation
 * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will 
 * be returned. 
 * 
135
 * Returns: (transfer full): a #GFileInfo for the @stream, or %NULL on error.
136 137 138
 **/
GFileInfo *
g_file_output_stream_query_info (GFileOutputStream      *stream,
139
				    const char             *attributes,
140 141 142 143 144 145 146 147 148 149 150
				    GCancellable           *cancellable,
				    GError                **error)
{
  GFileOutputStreamClass *class;
  GOutputStream *output_stream;
  GFileInfo *info;
  
  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
  
  output_stream = G_OUTPUT_STREAM (stream);
  
151 152
  if (!g_output_stream_set_pending (output_stream, error))
    return NULL;
153 154 155 156
      
  info = NULL;
  
  if (cancellable)
157
    g_cancellable_push_current (cancellable);
158 159 160 161 162
  
  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
  if (class->query_info)
    info = class->query_info (stream, attributes, cancellable, error);
  else
163
    g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
164
                         _("Stream doesn’t support query_info"));
165 166
  
  if (cancellable)
167
    g_cancellable_pop_current (cancellable);
168
  
169
  g_output_stream_clear_pending (output_stream);
170 171 172 173 174 175 176 177 178 179 180
  
  return info;
}

static void
async_ready_callback_wrapper (GObject *source_object,
			      GAsyncResult *res,
			      gpointer      user_data)
{
  GFileOutputStream *stream = G_FILE_OUTPUT_STREAM (source_object);

181
  g_output_stream_clear_pending (G_OUTPUT_STREAM (stream));
182 183 184 185 186 187 188 189
  if (stream->priv->outstanding_callback)
    (*stream->priv->outstanding_callback) (source_object, res, user_data);
  g_object_unref (stream);
}

/**
 * g_file_output_stream_query_info_async:
 * @stream: a #GFileOutputStream.
190
 * @attributes: a file attribute query string.
191
 * @io_priority: the [I/O priority][gio-GIOScheduler] of the request
192
 * @cancellable: optional #GCancellable object, %NULL to ignore. 
193 194
 * @callback: callback to call when the request is satisfied
 * @user_data: the data to pass to callback function
195 196 197 198 199 200 201 202 203 204 205
 * 
 * Asynchronously queries the @stream for a #GFileInfo. When completed,
 * @callback will be called with a #GAsyncResult which can be used to 
 * finish the operation with g_file_output_stream_query_info_finish().
 * 
 * For the synchronous version of this function, see 
 * g_file_output_stream_query_info().
 *
 **/
void
g_file_output_stream_query_info_async (GFileOutputStream     *stream,
206
					  const char           *attributes,
207 208 209 210 211 212 213
					  int                   io_priority,
					  GCancellable         *cancellable,
					  GAsyncReadyCallback   callback,
					  gpointer              user_data)
{
  GFileOutputStreamClass *klass;
  GOutputStream *output_stream;
214
  GError *error = NULL;
215 216 217 218 219

  g_return_if_fail (G_IS_FILE_OUTPUT_STREAM (stream));

  output_stream = G_OUTPUT_STREAM (stream);
 
220
  if (!g_output_stream_set_pending (output_stream, &error))
221
    {
222 223 224
      g_task_report_error (stream, callback, user_data,
                           g_file_output_stream_query_info_async,
                           error);
225 226 227 228 229 230 231 232
      return;
    }

  klass = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

  stream->priv->outstanding_callback = callback;
  g_object_ref (stream);
  klass->query_info_async (stream, attributes, io_priority, cancellable,
233
                           async_ready_callback_wrapper, user_data);
234 235 236 237 238 239
}

/**
 * g_file_output_stream_query_info_finish:
 * @stream: a #GFileOutputStream.
 * @result: a #GAsyncResult.
240
 * @error: a #GError, %NULL to ignore.
241 242 243 244
 * 
 * Finalizes the asynchronous query started 
 * by g_file_output_stream_query_info_async().
 * 
245
 * Returns: (transfer full): A #GFileInfo for the finished query.
246 247 248 249 250 251 252 253 254 255 256
 **/
GFileInfo *
g_file_output_stream_query_info_finish (GFileOutputStream     *stream,
					   GAsyncResult         *result,
					   GError              **error)
{
  GFileOutputStreamClass *class;

  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
  
257 258
  if (g_async_result_legacy_propagate_error (result, error))
    return NULL;
259 260
  else if (g_async_result_is_tagged (result, g_file_output_stream_query_info_async))
    return g_task_propagate_pointer (G_TASK (result), error);
261 262 263 264 265 266 267

  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
  return class->query_info_finish (stream, result, error);
}

/**
 * g_file_output_stream_get_etag:
268
 * @stream: a #GFileOutputStream.
269
 * 
270
 * Gets the entity tag for the file when it has been written.
271
 * This must be called after the stream has been written
272
 * and closed, as the etag can change while writing.
273 274
 * 
 * Returns: the entity tag for the stream.
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
 **/
char *
g_file_output_stream_get_etag (GFileOutputStream  *stream)
{
  GFileOutputStreamClass *class;
  GOutputStream *output_stream;
  char *etag;
  
  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), NULL);
  
  output_stream = G_OUTPUT_STREAM (stream);
  
  if (!g_output_stream_is_closed (output_stream))
    {
      g_warning ("stream is not closed yet, can't get etag");
      return NULL;
    }

  etag = NULL;
  
  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
  if (class->get_etag)
    etag = class->get_etag (stream);
  
  return etag;
}

302
static goffset
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
g_file_output_stream_tell (GFileOutputStream  *stream)
{
  GFileOutputStreamClass *class;
  goffset offset;
  
  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), 0);  

  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

  offset = 0;
  if (class->tell)
    offset = class->tell (stream);

  return offset;
}

static goffset
g_file_output_stream_seekable_tell (GSeekable *seekable)
{
  return g_file_output_stream_tell (G_FILE_OUTPUT_STREAM (seekable));
}

325
static gboolean
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
g_file_output_stream_can_seek (GFileOutputStream  *stream)
{
  GFileOutputStreamClass *class;
  gboolean can_seek;

  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);

  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

  can_seek = FALSE;
  if (class->seek)
    {
      can_seek = TRUE;
      if (class->can_seek)
	can_seek = class->can_seek (stream);
    }
  
  return can_seek;
}

static gboolean
g_file_output_stream_seekable_can_seek (GSeekable *seekable)
{
  return g_file_output_stream_can_seek (G_FILE_OUTPUT_STREAM (seekable));
}

352
static gboolean
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
g_file_output_stream_seek (GFileOutputStream  *stream,
			   goffset             offset,
			   GSeekType           type,
			   GCancellable       *cancellable,
			   GError            **error)
{
  GFileOutputStreamClass *class;
  GOutputStream *output_stream;
  gboolean res;

  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);

  output_stream = G_OUTPUT_STREAM (stream);
  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

  if (!class->seek)
    {
370 371
      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                           _("Seek not supported on stream"));
372 373 374
      return FALSE;
    }

375 376
  if (!g_output_stream_set_pending (output_stream, error))
    return FALSE;
377 378
  
  if (cancellable)
379
    g_cancellable_push_current (cancellable);
380 381 382 383
  
  res = class->seek (stream, offset, type, cancellable, error);
  
  if (cancellable)
384
    g_cancellable_pop_current (cancellable);
385

386
  g_output_stream_clear_pending (output_stream);
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
  
  return res;
}

static gboolean
g_file_output_stream_seekable_seek (GSeekable  *seekable,
				    goffset     offset,
				    GSeekType   type,
				    GCancellable  *cancellable,
				    GError    **error)
{
  return g_file_output_stream_seek (G_FILE_OUTPUT_STREAM (seekable),
				    offset, type, cancellable, error);
}

402
static gboolean
403 404 405 406 407 408 409 410 411 412
g_file_output_stream_can_truncate (GFileOutputStream  *stream)
{
  GFileOutputStreamClass *class;
  gboolean can_truncate;

  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);

  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

  can_truncate = FALSE;
413
  if (class->truncate_fn)
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
    {
      can_truncate = TRUE;
      if (class->can_truncate)
	can_truncate = class->can_truncate (stream);
    }
  
  return can_truncate;
}

static gboolean
g_file_output_stream_seekable_can_truncate (GSeekable  *seekable)
{
  return g_file_output_stream_can_truncate (G_FILE_OUTPUT_STREAM (seekable));
}

429
static gboolean
430 431 432 433 434 435 436 437 438 439 440 441 442 443
g_file_output_stream_truncate (GFileOutputStream  *stream,
			       goffset             size,
			       GCancellable       *cancellable,
			       GError            **error)
{
  GFileOutputStreamClass *class;
  GOutputStream *output_stream;
  gboolean res;

  g_return_val_if_fail (G_IS_FILE_OUTPUT_STREAM (stream), FALSE);

  output_stream = G_OUTPUT_STREAM (stream);
  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);

444
  if (!class->truncate_fn)
445
    {
446 447
      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
                           _("Truncate not supported on stream"));
448 449 450
      return FALSE;
    }

451 452
  if (!g_output_stream_set_pending (output_stream, error))
    return FALSE;
453 454
  
  if (cancellable)
455
    g_cancellable_push_current (cancellable);
456
  
457
  res = class->truncate_fn (stream, size, cancellable, error);
458 459
  
  if (cancellable)
460
    g_cancellable_pop_current (cancellable);
461

462
  g_output_stream_clear_pending (output_stream);
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
  
  return res;
}

static gboolean
g_file_output_stream_seekable_truncate (GSeekable     *seekable,
					goffset        size,
					GCancellable  *cancellable,
					GError       **error)
{
  return g_file_output_stream_truncate (G_FILE_OUTPUT_STREAM (seekable),
					size, cancellable, error);
}
/********************************************
 *   Default implementation of async ops    *
 ********************************************/

static void
481 482 483 484
query_info_async_thread (GTask        *task,
                         gpointer      source_object,
                         gpointer      task_data,
                         GCancellable *cancellable)
485
{
486 487
  GFileOutputStream *stream = source_object;
  const char *attributes = task_data;
488 489
  GFileOutputStreamClass *class;
  GError *error = NULL;
490
  GFileInfo *info = NULL;
491

492
  class = G_FILE_OUTPUT_STREAM_GET_CLASS (stream);
493
  if (class->query_info)
494
    info = class->query_info (stream, attributes, cancellable, &error);
495
  else
496
    g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
497
                         _("Stream doesn’t support query_info"));
498 499

  if (info == NULL)
500
    g_task_return_error (task, error);
501
  else
502
    g_task_return_pointer (task, info, g_object_unref);
503 504 505 506
}

static void
g_file_output_stream_real_query_info_async (GFileOutputStream     *stream,
507
					       const char           *attributes,
508 509 510 511 512
					       int                   io_priority,
					       GCancellable         *cancellable,
					       GAsyncReadyCallback   callback,
					       gpointer              user_data)
{
513
  GTask *task;
514

515
  task = g_task_new (stream, cancellable, callback, user_data);
516
  g_task_set_source_tag (task, g_file_output_stream_real_query_info_async);
517 518
  g_task_set_task_data (task, g_strdup (attributes), g_free);
  g_task_set_priority (task, io_priority);
519
  
520 521
  g_task_run_in_thread (task, query_info_async_thread);
  g_object_unref (task);
522 523 524 525
}

static GFileInfo *
g_file_output_stream_real_query_info_finish (GFileOutputStream     *stream,
526 527
					     GAsyncResult         *res,
					     GError              **error)
528
{
529
  g_return_val_if_fail (g_task_is_valid (res, stream), NULL);
530

531
  return g_task_propagate_pointer (G_TASK (res), error);
532
}