/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright © 2008, 2009 Codethink Limited

 *

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

 *

 * See the included COPYING file for more information.

 */

/**

 * GTcpConnection:

 *

 * This is the subclass of [class@Gio.SocketConnection] that is created

 * for TCP/IP sockets.

 *

 * Since: 2.22

 */

#include "config.h"

#include "gtcpconnection.h"

#include "gasyncresult.h"

#include "gtask.h"

#include "giostream.h"

#include "glibintl.h"

struct _GTcpConnectionPrivate

{

  guint graceful_disconnect : 1;

};

G_DEFINE_TYPE_WITH_CODE (GTcpConnection, g_tcp_connection,

       G_TYPE_SOCKET_CONNECTION,

                         G_ADD_PRIVATE (GTcpConnection)

  g_socket_connection_factory_register_type (g_define_type_id,

               G_SOCKET_FAMILY_IPV4,

               G_SOCKET_TYPE_STREAM,

               G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_connection_factory_register_type (g_define_type_id,

               G_SOCKET_FAMILY_IPV6,

               G_SOCKET_TYPE_STREAM,

               G_SOCKET_PROTOCOL_DEFAULT);

  g_socket_connection_factory_register_type (g_define_type_id,

               G_SOCKET_FAMILY_IPV4,

               G_SOCKET_TYPE_STREAM,

               G_SOCKET_PROTOCOL_TCP);

  g_socket_connection_factory_register_type (g_define_type_id,

               G_SOCKET_FAMILY_IPV6,

               G_SOCKET_TYPE_STREAM,

               G_SOCKET_PROTOCOL_TCP);

       );

static gboolean g_tcp_connection_close       (GIOStream            *stream,

                GCancellable         *cancellable,

                GError              **error);

static void     g_tcp_connection_close_async (GIOStream            *stream,

                int                   io_priority,

                GCancellable         *cancellable,

                GAsyncReadyCallback   callback,

                gpointer              user_data);

enum

{

  PROP_0,

  PROP_GRACEFUL_DISCONNECT

};

static void

g_tcp_connection_init (GTcpConnection *connection)

{

  connection->priv = g_tcp_connection_get_instance_private (connection);

  connection->priv->graceful_disconnect = FALSE;

}

static void

g_tcp_connection_get_property (GObject    *object,

             guint       prop_id,

             GValue     *value,

             GParamSpec *pspec)

{

  GTcpConnection *connection = G_TCP_CONNECTION (object);

  switch (prop_id)

    {

      case PROP_GRACEFUL_DISCONNECT:

  g_value_set_boolean (value, connection->priv->graceful_disconnect);

  break;

      default:

  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static void

g_tcp_connection_set_property (GObject      *object,

             guint         prop_id,

             const GValue *value,

             GParamSpec   *pspec)

{

  GTcpConnection *connection = G_TCP_CONNECTION (object);

  switch (prop_id)

    {

      case PROP_GRACEFUL_DISCONNECT:

  g_tcp_connection_set_graceful_disconnect (connection,

              g_value_get_boolean (value));

  break;

      default:

  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    }

}

static void

g_tcp_connection_class_init (GTcpConnectionClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  GIOStreamClass *stream_class = G_IO_STREAM_CLASS (class);

  gobject_class->set_property = g_tcp_connection_set_property;

  gobject_class->get_property = g_tcp_connection_get_property;

  stream_class->close_fn = g_tcp_connection_close;

  stream_class->close_async = g_tcp_connection_close_async;

  /**

   * GTcpConnection:graceful-disconnect:

   *

   * Whether [method@Gio.IOStream.close] does a graceful disconnect.

   *

   * Since: 2.22

   */

  g_object_class_install_property (gobject_class, PROP_GRACEFUL_DISCONNECT,

           g_param_spec_boolean ("graceful-disconnect", NULL, NULL,

               FALSE,

               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

}

static gboolean

g_tcp_connection_close (GIOStream     *stream,

      GCancellable  *cancellable,

      GError       **error)

{

  GTcpConnection *connection = G_TCP_CONNECTION (stream);

  GSocket *socket;

  char buffer[1024];

  gssize ret;

  gboolean had_error;

  socket = g_socket_connection_get_socket (G_SOCKET_CONNECTION (stream));

  had_error = FALSE;

  if (connection->priv->graceful_disconnect &&

      !g_cancellable_is_cancelled (cancellable) /* Cancelled -> close fast */)

    {

      if (!g_socket_shutdown (socket, FALSE, TRUE, error))

  {

    error = NULL; /* Ignore further errors */

    had_error = TRUE;

  }

      else

  {

    while (TRUE)

      {

        ret = g_socket_receive_with_blocking (socket,  buffer, sizeof (buffer),

                TRUE, cancellable, error);

        if (ret < 0)

    {

      had_error = TRUE;

      error = NULL;

      break;

    }

        if (ret == 0)

    break;

      }

  }

    }

  return G_IO_STREAM_CLASS (g_tcp_connection_parent_class)

    ->close_fn (stream, cancellable, error) && !had_error;

}

/* consumes @error */

static void

async_close_finish (GTask    *task,

                    GError   *error)

{

  GIOStreamClass *parent = G_IO_STREAM_CLASS (g_tcp_connection_parent_class);

  GIOStream *stream = g_task_get_source_object (task);

  GCancellable *cancellable = g_task_get_cancellable (task);

  /* Close underlying stream, ignoring further errors if we already

   * have one.

   */

  if (error)

    parent->close_fn (stream, cancellable, NULL);

  else

    parent->close_fn (stream, cancellable, &error);

  if (error)

    g_task_return_error (task, error);

  else

    g_task_return_boolean (task, TRUE);

  g_object_unref (task);

}

static gboolean

close_read_ready (GSocket        *socket,

      GIOCondition    condition,

      GTask          *task)

{

  GError *error = NULL;

  char buffer[1024];

  gssize ret;

  ret = g_socket_receive_with_blocking (socket,  buffer, sizeof (buffer),

                                        FALSE, g_task_get_cancellable (task),

                                        &error);

  if (ret < 0)

    {

      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))

  {

    g_error_free (error);

    return TRUE;

  }

      else

  {

    async_close_finish (task, error);

    return FALSE;

  }

    }

  if (ret == 0)

    {

      async_close_finish (task, NULL);

      return FALSE;

    }

  return TRUE;

}

static void

g_tcp_connection_close_async (GIOStream           *stream,

            int                  io_priority,

            GCancellable        *cancellable,

            GAsyncReadyCallback  callback,

            gpointer             user_data)

{

  GTcpConnection *connection = G_TCP_CONNECTION (stream);

  GSocket *socket;

  GSource *source;

  GError *error;

  GTask *task;

  if (connection->priv->graceful_disconnect &&

      !g_cancellable_is_cancelled (cancellable) /* Cancelled -> close fast */)

    {

      task = g_task_new (stream, cancellable, callback, user_data);

      g_task_set_source_tag (task, g_tcp_connection_close_async);

      g_task_set_priority (task, io_priority);

      socket = g_socket_connection_get_socket (G_SOCKET_CONNECTION (stream));

      error = NULL;

      if (!g_socket_shutdown (socket, FALSE, TRUE, &error))

  {

    g_task_return_error (task, error);

    g_object_unref (task);

    return;

  }

      source = g_socket_create_source (socket, G_IO_IN, cancellable);

      g_task_attach_source (task, source, (GSourceFunc) close_read_ready);

      g_source_unref (source);

      return;

    }

  G_IO_STREAM_CLASS (g_tcp_connection_parent_class)

    ->close_async (stream, io_priority, cancellable, callback, user_data);

}

/**

 * g_tcp_connection_set_graceful_disconnect:

 * @connection: a #GTcpConnection

 * @graceful_disconnect: Whether to do graceful disconnects or not

 *

 * This enables graceful disconnects on close. A graceful disconnect

 * means that we signal the receiving end that the connection is terminated

 * and wait for it to close the connection before closing the connection.

 *

 * A graceful disconnect means that we can be sure that we successfully sent

 * all the outstanding data to the other end, or get an error reported.

 * However, it also means we have to wait for all the data to reach the

 * other side and for it to acknowledge this by closing the socket, which may

 * take a while. For this reason it is disabled by default.

 *

 * Since: 2.22

 */

void

g_tcp_connection_set_graceful_disconnect (GTcpConnection *connection,

            gboolean        graceful_disconnect)

{

  graceful_disconnect = !!graceful_disconnect;

  if (graceful_disconnect != connection->priv->graceful_disconnect)

    {

      connection->priv->graceful_disconnect = graceful_disconnect;

      g_object_notify (G_OBJECT (connection), "graceful-disconnect");

    }

}

/**

 * g_tcp_connection_get_graceful_disconnect:

 * @connection: a #GTcpConnection

 *

 * Checks if graceful disconnects are used. See

 * g_tcp_connection_set_graceful_disconnect().

 *

 * Returns: %TRUE if graceful disconnect is used on close, %FALSE otherwise

 *

 * Since: 2.22

 */

gboolean

g_tcp_connection_get_graceful_disconnect (GTcpConnection *connection)

{

  return connection->priv->graceful_disconnect;

}