/* GIO - GLib Input, IO and Streaming Library

 *

 * Copyright (C) 2006-2007 Red Hat, Inc.

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 *

 * 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

 * version 2.1 of the License, or (at your option) any later version.

 *

 * 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

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include <glib.h>

#include <gfileiostream.h>

#include <gseekable.h>

#include "gasyncresult.h"

#include "gtask.h"

#include "gcancellable.h"

#include "gioerror.h"

#include "gfileoutputstream.h"

#include "glibintl.h"

/**

 * GFileIOStream:

 *

 * `GFileIOStream` provides I/O streams that both read and write to the same

 * file handle.

 *

 * `GFileIOStream` implements [iface@Gio.Seekable], which allows the I/O

 * stream to jump to arbitrary positions in the file and to truncate

 * the file, provided the filesystem of the file supports these

 * operations.

 *

 * To find the position of a file I/O stream, use [method@Gio.Seekable.tell].

 *

 * To find out if a file I/O stream supports seeking, use

 * [method@Gio.Seekable.can_seek]. To position a file I/O stream, use

 * [method@Gio.Seekable.seek]. To find out if a file I/O stream supports

 * truncating, use [method@Gio.Seekable.can_truncate]. To truncate a file I/O

 * stream, use [method@Gio.Seekable.truncate].

 *

 * The default implementation of all the `GFileIOStream` operations

 * and the implementation of [iface@Gio.Seekable] just call into the same

 * operations on the output stream.

 *

 * Since: 2.22

 **/

static void       g_file_io_stream_seekable_iface_init    (GSeekableIface       *iface);

static goffset    g_file_io_stream_seekable_tell          (GSeekable            *seekable);

static gboolean   g_file_io_stream_seekable_can_seek      (GSeekable            *seekable);

static gboolean   g_file_io_stream_seekable_seek          (GSeekable            *seekable,

                 goffset               offset,

                 GSeekType             type,

                 GCancellable         *cancellable,

                 GError              **error);

static gboolean   g_file_io_stream_seekable_can_truncate  (GSeekable            *seekable);

static gboolean   g_file_io_stream_seekable_truncate      (GSeekable            *seekable,

                 goffset               offset,

                 GCancellable         *cancellable,

                 GError              **error);

static void       g_file_io_stream_real_query_info_async  (GFileIOStream    *stream,

                 const char           *attributes,

                 int                   io_priority,

                 GCancellable         *cancellable,

                 GAsyncReadyCallback   callback,

                 gpointer              user_data);

static GFileInfo *g_file_io_stream_real_query_info_finish (GFileIOStream    *stream,

                 GAsyncResult         *result,

                 GError              **error);

struct _GFileIOStreamPrivate {

  GAsyncReadyCallback outstanding_callback;

};

G_DEFINE_TYPE_WITH_CODE (GFileIOStream, g_file_io_stream, G_TYPE_IO_STREAM,

                         G_ADD_PRIVATE (GFileIOStream)

       G_IMPLEMENT_INTERFACE (G_TYPE_SEEKABLE,

            g_file_io_stream_seekable_iface_init))

static void

g_file_io_stream_seekable_iface_init (GSeekableIface *iface)

{

  iface->tell = g_file_io_stream_seekable_tell;

  iface->can_seek = g_file_io_stream_seekable_can_seek;

  iface->seek = g_file_io_stream_seekable_seek;

  iface->can_truncate = g_file_io_stream_seekable_can_truncate;

  iface->truncate_fn = g_file_io_stream_seekable_truncate;

}

static void

g_file_io_stream_init (GFileIOStream *stream)

{

  stream->priv = g_file_io_stream_get_instance_private (stream);

}

/**

 * g_file_io_stream_query_info:

 * @stream: a #GFileIOStream.

 * @attributes: a file attribute query string.

 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.

 * @error: a #GError, %NULL to ignore.

 *

 * Queries a file io stream for the given @attributes.

 * This function blocks while querying the stream. For the asynchronous

 * version of this function, see g_file_io_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.

 *

 * 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). I

 * 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.

 *

 * Returns: (transfer full): a #GFileInfo for the @stream, or %NULL on error.

 *

 * Since: 2.22

 **/

GFileInfo *

g_file_io_stream_query_info (GFileIOStream      *stream,

           const char             *attributes,

           GCancellable           *cancellable,

           GError                **error)

{

  GFileIOStreamClass *class;

  GIOStream *io_stream;

  GFileInfo *info;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), NULL);

  io_stream = G_IO_STREAM (stream);

  if (!g_io_stream_set_pending (io_stream, error))

    return NULL;

  info = NULL;

  if (cancellable)

    g_cancellable_push_current (cancellable);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  if (class->query_info)

    info = class->query_info (stream, attributes, cancellable, error);

  else

    g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,

                         _("Stream doesn’t support query_info"));

  if (cancellable)

    g_cancellable_pop_current (cancellable);

  g_io_stream_clear_pending (io_stream);

  return info;

}

static void

async_ready_callback_wrapper (GObject *source_object,

            GAsyncResult *res,

            gpointer      user_data)

{

  GFileIOStream *stream = G_FILE_IO_STREAM (source_object);

  g_io_stream_clear_pending (G_IO_STREAM (stream));

  if (stream->priv->outstanding_callback)

    (*stream->priv->outstanding_callback) (source_object, res, user_data);

  g_object_unref (stream);

}

/**

 * g_file_io_stream_query_info_async:

 * @stream: a #GFileIOStream.

 * @attributes: a file attribute query string.

 * @io_priority: the [I/O priority](iface.AsyncResult.html#io-priority) of the

 *   request

 * @cancellable: (nullable): optional #GCancellable object, %NULL to ignore.

 * @callback: (scope async): a #GAsyncReadyCallback

 *   to call when the request is satisfied

 * @user_data: the data to pass to callback function

 *

 * 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_io_stream_query_info_finish().

 *

 * For the synchronous version of this function, see

 * g_file_io_stream_query_info().

 *

 * Since: 2.22

 **/

void

g_file_io_stream_query_info_async (GFileIOStream     *stream,

            const char           *attributes,

            int                   io_priority,

            GCancellable         *cancellable,

            GAsyncReadyCallback   callback,

            gpointer              user_data)

{

  GFileIOStreamClass *klass;

  GIOStream *io_stream;

  GError *error = NULL;

  g_return_if_fail (G_IS_FILE_IO_STREAM (stream));

  io_stream = G_IO_STREAM (stream);

  if (!g_io_stream_set_pending (io_stream, &error))

    {

      g_task_report_error (stream, callback, user_data,

                           g_file_io_stream_query_info_async,

                           error);

      return;

    }

  klass = G_FILE_IO_STREAM_GET_CLASS (stream);

  stream->priv->outstanding_callback = callback;

  g_object_ref (stream);

  klass->query_info_async (stream, attributes, io_priority, cancellable,

                           async_ready_callback_wrapper, user_data);

}

/**

 * g_file_io_stream_query_info_finish:

 * @stream: a #GFileIOStream.

 * @result: a #GAsyncResult.

 * @error: a #GError, %NULL to ignore.

 *

 * Finalizes the asynchronous query started

 * by g_file_io_stream_query_info_async().

 *

 * Returns: (transfer full): A #GFileInfo for the finished query.

 *

 * Since: 2.22

 **/

GFileInfo *

g_file_io_stream_query_info_finish (GFileIOStream     *stream,

            GAsyncResult         *result,

            GError              **error)

{

  GFileIOStreamClass *class;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), NULL);

  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);

  if (g_async_result_legacy_propagate_error (result, error))

    return NULL;

  else if (g_async_result_is_tagged (result, g_file_io_stream_query_info_async))

    return g_task_propagate_pointer (G_TASK (result), error);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

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

}

/**

 * g_file_io_stream_get_etag:

 * @stream: a #GFileIOStream.

 *

 * Gets the entity tag for the file when it has been written.

 * This must be called after the stream has been written

 * and closed, as the etag can change while writing.

 *

 * Returns: (nullable) (transfer full): the entity tag for the stream.

 *

 * Since: 2.22

 **/

char *

g_file_io_stream_get_etag (GFileIOStream  *stream)

{

  GFileIOStreamClass *class;

  GIOStream *io_stream;

  char *etag;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), NULL);

  io_stream = G_IO_STREAM (stream);

  if (!g_io_stream_is_closed (io_stream))

    {

      g_warning ("stream is not closed yet, can't get etag");

      return NULL;

    }

  etag = NULL;

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  if (class->get_etag)

    etag = class->get_etag (stream);

  return etag;

}

static goffset

g_file_io_stream_tell (GFileIOStream  *stream)

{

  GFileIOStreamClass *class;

  goffset offset;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), 0);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  offset = 0;

  if (class->tell)

    offset = class->tell (stream);

  return offset;

}

static goffset

g_file_io_stream_seekable_tell (GSeekable *seekable)

{

  return g_file_io_stream_tell (G_FILE_IO_STREAM (seekable));

}

static gboolean

g_file_io_stream_can_seek (GFileIOStream  *stream)

{

  GFileIOStreamClass *class;

  gboolean can_seek;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), FALSE);

  class = G_FILE_IO_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_io_stream_seekable_can_seek (GSeekable *seekable)

{

  return g_file_io_stream_can_seek (G_FILE_IO_STREAM (seekable));

}

static gboolean

g_file_io_stream_seek (GFileIOStream  *stream,

           goffset             offset,

           GSeekType           type,

           GCancellable       *cancellable,

           GError            **error)

{

  GFileIOStreamClass *class;

  GIOStream *io_stream;

  gboolean res;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), FALSE);

  io_stream = G_IO_STREAM (stream);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  if (!class->seek)

    {

      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,

                           _("Seek not supported on stream"));

      return FALSE;

    }

  if (!g_io_stream_set_pending (io_stream, error))

    return FALSE;

  if (cancellable)

    g_cancellable_push_current (cancellable);

  res = class->seek (stream, offset, type, cancellable, error);

  if (cancellable)

    g_cancellable_pop_current (cancellable);

  g_io_stream_clear_pending (io_stream);

  return res;

}

static gboolean

g_file_io_stream_seekable_seek (GSeekable  *seekable,

            goffset     offset,

            GSeekType   type,

            GCancellable  *cancellable,

            GError    **error)

{

  return g_file_io_stream_seek (G_FILE_IO_STREAM (seekable),

        offset, type, cancellable, error);

}

static gboolean

g_file_io_stream_can_truncate (GFileIOStream  *stream)

{

  GFileIOStreamClass *class;

  gboolean can_truncate;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), FALSE);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  can_truncate = FALSE;

  if (class->truncate_fn)

    {

      can_truncate = TRUE;

      if (class->can_truncate)

  can_truncate = class->can_truncate (stream);

    }

  return can_truncate;

}

static gboolean

g_file_io_stream_seekable_can_truncate (GSeekable  *seekable)

{

  return g_file_io_stream_can_truncate (G_FILE_IO_STREAM (seekable));

}

static gboolean

g_file_io_stream_truncate (GFileIOStream  *stream,

         goffset             size,

         GCancellable       *cancellable,

         GError            **error)

{

  GFileIOStreamClass *class;

  GIOStream *io_stream;

  gboolean res;

  g_return_val_if_fail (G_IS_FILE_IO_STREAM (stream), FALSE);

  io_stream = G_IO_STREAM (stream);

  class = G_FILE_IO_STREAM_GET_CLASS (stream);

  if (!class->truncate_fn)

    {

      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,

                           _("Truncate not supported on stream"));

      return FALSE;

    }

  if (!g_io_stream_set_pending (io_stream, error))

    return FALSE;

  if (cancellable)

    g_cancellable_push_current (cancellable);

  res = class->truncate_fn (stream, size, cancellable, error);

  if (cancellable)

    g_cancellable_pop_current (cancellable);

  g_io_stream_clear_pending (io_stream);

  return res;

}

static gboolean

g_file_io_stream_seekable_truncate (GSeekable     *seekable,

            goffset        size,

            GCancellable  *cancellable,

            GError       **error)

{

  return g_file_io_stream_truncate (G_FILE_IO_STREAM (seekable),

          size, cancellable, error);

}

/*****************************************************

 *   Default implementations based on output stream  *

 *****************************************************/

static goffset

g_file_io_stream_real_tell (GFileIOStream    *stream)

{

  GOutputStream *out;

  GSeekable *seekable;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  seekable = G_SEEKABLE (out);

  return g_seekable_tell (seekable);

}

static gboolean

g_file_io_stream_real_can_seek (GFileIOStream    *stream)

{

  GOutputStream *out;

  GSeekable *seekable;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  seekable = G_SEEKABLE (out);

  return g_seekable_can_seek (seekable);

}

static gboolean

g_file_io_stream_real_seek (GFileIOStream    *stream,

          goffset           offset,

          GSeekType         type,

          GCancellable     *cancellable,

          GError          **error)

{

  GOutputStream *out;

  GSeekable *seekable;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  seekable = G_SEEKABLE (out);

  return g_seekable_seek (seekable, offset, type, cancellable, error);

}

static  gboolean

g_file_io_stream_real_can_truncate (GFileIOStream    *stream)

{

  GOutputStream *out;

  GSeekable *seekable;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  seekable = G_SEEKABLE (out);

  return g_seekable_can_truncate (seekable);

}

static gboolean

g_file_io_stream_real_truncate_fn (GFileIOStream    *stream,

           goffset               size,

           GCancellable         *cancellable,

           GError              **error)

{

  GOutputStream *out;

  GSeekable *seekable;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  seekable = G_SEEKABLE (out);

  return g_seekable_truncate (seekable, size, cancellable, error);

}

static char *

g_file_io_stream_real_get_etag (GFileIOStream    *stream)

{

  GOutputStream *out;

  GFileOutputStream *file_out;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  file_out = G_FILE_OUTPUT_STREAM (out);

  return g_file_output_stream_get_etag (file_out);

}

static GFileInfo *

g_file_io_stream_real_query_info (GFileIOStream    *stream,

          const char           *attributes,

          GCancellable         *cancellable,

          GError              **error)

{

  GOutputStream *out;

  GFileOutputStream *file_out;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  file_out = G_FILE_OUTPUT_STREAM (out);

  return g_file_output_stream_query_info (file_out,

            attributes, cancellable, error);

}

typedef struct {

  GObject *object;

  GAsyncReadyCallback callback;

  gpointer user_data;

} AsyncOpWrapper;

static AsyncOpWrapper *

async_op_wrapper_new (gpointer object,

          GAsyncReadyCallback callback,

          gpointer user_data)

{

  AsyncOpWrapper *data;

  data = g_new0 (AsyncOpWrapper, 1);

  data->object = g_object_ref (object);

  data->callback = callback;

  data->user_data = user_data;

  return data;

}

static void

async_op_wrapper_callback (GObject *source_object,

         GAsyncResult *res,

         gpointer user_data)

{

  AsyncOpWrapper *data  = user_data;

  data->callback (data->object, res, data->user_data);

  g_object_unref (data->object);

  g_free (data);

}

static void

g_file_io_stream_real_query_info_async (GFileIOStream     *stream,

          const char           *attributes,

          int                   io_priority,

          GCancellable         *cancellable,

          GAsyncReadyCallback   callback,

          gpointer              user_data)

{

  GOutputStream *out;

  GFileOutputStream *file_out;

  AsyncOpWrapper *data;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  file_out = G_FILE_OUTPUT_STREAM (out);

  data = async_op_wrapper_new (stream, callback, user_data);

  g_file_output_stream_query_info_async (file_out,

           attributes, io_priority,

           cancellable, async_op_wrapper_callback, data);

}

static GFileInfo *

g_file_io_stream_real_query_info_finish (GFileIOStream     *stream,

           GAsyncResult      *res,

           GError           **error)

{

  GOutputStream *out;

  GFileOutputStream *file_out;

  out = g_io_stream_get_output_stream (G_IO_STREAM (stream));

  file_out = G_FILE_OUTPUT_STREAM (out);

  return g_file_output_stream_query_info_finish (file_out, res, error);

}

static void

g_file_io_stream_class_init (GFileIOStreamClass *klass)

{

  klass->tell = g_file_io_stream_real_tell;

  klass->can_seek = g_file_io_stream_real_can_seek;

  klass->seek = g_file_io_stream_real_seek;

  klass->can_truncate = g_file_io_stream_real_can_truncate;

  klass->truncate_fn = g_file_io_stream_real_truncate_fn;

  klass->query_info = g_file_io_stream_real_query_info;

  klass->query_info_async = g_file_io_stream_real_query_info_async;

  klass->query_info_finish = g_file_io_stream_real_query_info_finish;

  klass->get_etag = g_file_io_stream_real_get_etag;

}