/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright © 2009 Codethink Limited

 *

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

 *

 * Authors: Ryan Lortie <desrt@desrt.ca>

 */

/**

 * SECTION:gunixfdmessage

 * @title: GUnixFDMessage

 * @short_description: A GSocketControlMessage containing a GUnixFDList

 * @include: gio/gunixfdmessage.h

 * @see_also: #GUnixConnection, #GUnixFDList, #GSocketControlMessage

 *

 * This #GSocketControlMessage contains a #GUnixFDList.

 * It may be sent using g_socket_send_message() and received using

 * g_socket_receive_message() over UNIX sockets (ie: sockets in the

 * %G_SOCKET_ADDRESS_UNIX family). The file descriptors are copied

 * between processes by the kernel.

 *

 * For an easier way to send and receive file descriptors over

 * stream-oriented UNIX sockets, see g_unix_connection_send_fd() and

 * g_unix_connection_receive_fd().

 *

 * Note that `<gio/gunixfdmessage.h>` belongs to the UNIX-specific GIO

 * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config

 * file when using it.

 */

/**

 * GUnixFDMessage:

 *

 * #GUnixFDMessage is an opaque data structure and can only be accessed

 * using the following functions.

 **/

#include "config.h"

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <errno.h>

#include "gunixfdmessage.h"

#include "gunixfdlist.h"

#include "gnetworking.h"

#include "gioerror.h"

struct _GUnixFDMessagePrivate

{

  GUnixFDList *list;

};

G_DEFINE_TYPE_WITH_PRIVATE (GUnixFDMessage, g_unix_fd_message, G_TYPE_SOCKET_CONTROL_MESSAGE)

static gsize

g_unix_fd_message_get_size (GSocketControlMessage *message)

{

  GUnixFDMessage *fd_message = G_UNIX_FD_MESSAGE (message);

  return g_unix_fd_list_get_length (fd_message->priv->list) * sizeof (gint);

}

static int

g_unix_fd_message_get_level (GSocketControlMessage *message)

{

  return SOL_SOCKET;

}

static int

g_unix_fd_message_get_msg_type (GSocketControlMessage *message)

{

  return SCM_RIGHTS;

}

static GSocketControlMessage *

g_unix_fd_message_deserialize (int      level,

			       int      type,

			       gsize    size,

			       gpointer data)

{

  GSocketControlMessage *message;

  GUnixFDList *list;

  gint n, s, i;

  gint *fds;

  if (level != SOL_SOCKET ||

      type != SCM_RIGHTS)

    return NULL;

  if (size % 4 > 0)

    {

      g_warning ("Kernel returned non-integral number of fds");

      return NULL;

    }

  fds = data;

  n = size / sizeof (gint);

  /* Note we probably handled this in gsocket.c already if we're on

   * Linux and have MSG_CMSG_CLOEXEC, but this code remains as a fallback

   * in case the kernel is too old for MSG_CMSG_CLOEXEC.

   */

  for (i = 0; i < n; i++)

    {

      int errsv;

      do

        {

          s = fcntl (fds[i], F_SETFD, FD_CLOEXEC);

          errsv = errno;

        }

      while (s < 0 && errsv == EINTR);

      if (s < 0)

        {

          g_warning ("Error setting close-on-exec flag on incoming fd: %s",

                     g_strerror (errsv));

          return NULL;

        }

    }

  list = g_unix_fd_list_new_from_array (fds, n);

  message = g_unix_fd_message_new_with_fd_list (list);

  g_object_unref (list);

  return message;

}

static void

g_unix_fd_message_serialize (GSocketControlMessage *message,

			     gpointer               data)

{

  GUnixFDMessage *fd_message = G_UNIX_FD_MESSAGE (message);

  const gint *fds;

  gint n_fds;

  fds = g_unix_fd_list_peek_fds (fd_message->priv->list, &n_fds);

  memcpy (data, fds, sizeof (gint) * n_fds);

}

static void

g_unix_fd_message_set_property (GObject *object, guint prop_id,

                                const GValue *value, GParamSpec *pspec)

{

  GUnixFDMessage *message = G_UNIX_FD_MESSAGE (object);

  g_assert (message->priv->list == NULL);

  g_assert_cmpint (prop_id, ==, 1);

  message->priv->list = g_value_dup_object (value);

  if (message->priv->list == NULL)

    message->priv->list = g_unix_fd_list_new ();

}

/**

 * g_unix_fd_message_get_fd_list:

 * @message: a #GUnixFDMessage

 *

 * Gets the #GUnixFDList contained in @message.  This function does not

 * return a reference to the caller, but the returned list is valid for

 * the lifetime of @message.

 *

 * Returns: (transfer none): the #GUnixFDList from @message

 *

 * Since: 2.24

 **/

GUnixFDList *

g_unix_fd_message_get_fd_list (GUnixFDMessage *message)

{

  return message->priv->list;

}

static void

g_unix_fd_message_get_property (GObject *object, guint prop_id,

                                GValue *value, GParamSpec *pspec)

{

  GUnixFDMessage *message = G_UNIX_FD_MESSAGE (object);

  g_assert_cmpint (prop_id, ==, 1);

  g_value_set_object (value, g_unix_fd_message_get_fd_list (message));

}

static void

g_unix_fd_message_init (GUnixFDMessage *message)

{

  message->priv = g_unix_fd_message_get_instance_private (message);

}

static void

g_unix_fd_message_finalize (GObject *object)

{

  GUnixFDMessage *message = G_UNIX_FD_MESSAGE (object);

  g_object_unref (message->priv->list);

  G_OBJECT_CLASS (g_unix_fd_message_parent_class)

    ->finalize (object);

}

static void

g_unix_fd_message_class_init (GUnixFDMessageClass *class)

{

  GSocketControlMessageClass *scm_class = G_SOCKET_CONTROL_MESSAGE_CLASS (class);

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  scm_class->get_size = g_unix_fd_message_get_size;

  scm_class->get_level = g_unix_fd_message_get_level;

  scm_class->get_type = g_unix_fd_message_get_msg_type;

  scm_class->serialize = g_unix_fd_message_serialize;

  scm_class->deserialize = g_unix_fd_message_deserialize;

  object_class->finalize = g_unix_fd_message_finalize;

  object_class->set_property = g_unix_fd_message_set_property;

  object_class->get_property = g_unix_fd_message_get_property;

  g_object_class_install_property (object_class, 1,

    g_param_spec_object ("fd-list", "file descriptor list",

                         "The GUnixFDList object to send with the message",

                         G_TYPE_UNIX_FD_LIST, G_PARAM_STATIC_STRINGS |

                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

}

/**

 * g_unix_fd_message_new:

 *

 * Creates a new #GUnixFDMessage containing an empty file descriptor

 * list.

 *

 * Returns: a new #GUnixFDMessage

 *

 * Since: 2.22

 **/

GSocketControlMessage *

g_unix_fd_message_new (void)

{

  return g_object_new (G_TYPE_UNIX_FD_MESSAGE, NULL);

}

/**

 * g_unix_fd_message_new_with_fd_list:

 * @fd_list: a #GUnixFDList

 *

 * Creates a new #GUnixFDMessage containing @list.

 *

 * Returns: a new #GUnixFDMessage

 *

 * Since: 2.24

 **/

GSocketControlMessage *

g_unix_fd_message_new_with_fd_list (GUnixFDList *fd_list)

{

  return g_object_new (G_TYPE_UNIX_FD_MESSAGE,

                       "fd-list", fd_list,

                       NULL);

}

/**

 * g_unix_fd_message_steal_fds:

 * @message: a #GUnixFDMessage

 * @length: (out) (optional): pointer to the length of the returned

 *     array, or %NULL

 *

 * Returns the array of file descriptors that is contained in this

 * object.

 *

 * After this call, the descriptors are no longer contained in

 * @message. Further calls will return an empty list (unless more

 * descriptors have been added).

 *

 * The return result of this function must be freed with g_free().

 * The caller is also responsible for closing all of the file

 * descriptors.

 *

 * If @length is non-%NULL then it is set to the number of file

 * descriptors in the returned array. The returned array is also

 * terminated with -1.

 *

 * This function never returns %NULL. In case there are no file

 * descriptors contained in @message, an empty array is returned.

 *

 * Returns: (array length=length) (transfer full): an array of file

 *     descriptors

 *

 * Since: 2.22

 **/

gint *

g_unix_fd_message_steal_fds (GUnixFDMessage *message,

                             gint           *length)

{

  g_return_val_if_fail (G_UNIX_FD_MESSAGE (message), NULL);

  return g_unix_fd_list_steal_fds (message->priv->list, length);

}

/**

 * g_unix_fd_message_append_fd:

 * @message: a #GUnixFDMessage

 * @fd: a valid open file descriptor

 * @error: a #GError pointer

 *

 * Adds a file descriptor to @message.

 *

 * The file descriptor is duplicated using dup(). You keep your copy

 * of the descriptor and the copy contained in @message will be closed

 * when @message is finalized.

 *

 * A possible cause of failure is exceeding the per-process or

 * system-wide file descriptor limit.

 *

 * Returns: %TRUE in case of success, else %FALSE (and @error is set)

 *

 * Since: 2.22

 **/

gboolean

g_unix_fd_message_append_fd (GUnixFDMessage  *message,

                             gint             fd,

                             GError         **error)

{

  g_return_val_if_fail (G_UNIX_FD_MESSAGE (message), FALSE);

  return g_unix_fd_list_append (message->priv->list, fd, error) >= 0;

}