/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-transport-socket.c  Socket subclasses of DBusTransport

 *

 * Copyright (C) 2002, 2003, 2004, 2006  Red Hat Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "dbus-internals.h"

#include "dbus-connection-internal.h"

#include "dbus-transport-socket.h"

#include "dbus-transport-protected.h"

#include "dbus-watch.h"

#ifdef __SYMBIAN32__

#include "config.h"

#endif //__SYMBIAN32__

/**

 * @defgroup DBusTransportSocket DBusTransport implementations for sockets

 * @ingroup  DBusInternals

 * @brief Implementation details of DBusTransport on sockets

 *

 * @{

 */

/**

 * Opaque object representing a socket file descriptor transport.

 */

typedef struct DBusTransportSocket DBusTransportSocket;

/**

 * Implementation details of DBusTransportSocket. All members are private.

 */

struct DBusTransportSocket

{

  DBusTransport base;                   /**< Parent instance */

  int fd;                               /**< File descriptor. */

  DBusWatch *read_watch;                /**< Watch for readability. */

  DBusWatch *write_watch;               /**< Watch for writability. */

  int max_bytes_read_per_iteration;     /**< To avoid blocking too long. */

  int max_bytes_written_per_iteration;  /**< To avoid blocking too long. */

  int message_bytes_written;            /**< Number of bytes of current

                                         *   outgoing message that have

                                         *   been written.

                                         */

  DBusString encoded_outgoing;          /**< Encoded version of current

                                         *   outgoing message.

                                         */

  DBusString encoded_incoming;          /**< Encoded version of current

                                         *   incoming data.

                                         */

};

static void

free_watches (DBusTransport *transport)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME);

  if (socket_transport->read_watch)

    {

      if (transport->connection)

        _dbus_connection_remove_watch_unlocked (transport->connection,

                                                socket_transport->read_watch);

      _dbus_watch_invalidate (socket_transport->read_watch);

      _dbus_watch_unref (socket_transport->read_watch);

      socket_transport->read_watch = NULL;

    }

  if (socket_transport->write_watch)

    {

      if (transport->connection)

        _dbus_connection_remove_watch_unlocked (transport->connection,

                                                socket_transport->write_watch);

      _dbus_watch_invalidate (socket_transport->write_watch);

      _dbus_watch_unref (socket_transport->write_watch);

      socket_transport->write_watch = NULL;

    }

  _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);

}

static void

socket_finalize (DBusTransport *transport)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  _dbus_verbose ("%s\n", _DBUS_FUNCTION_NAME);

  free_watches (transport);

  _dbus_string_free (&socket_transport->encoded_outgoing);

  _dbus_string_free (&socket_transport->encoded_incoming);

  _dbus_transport_finalize_base (transport);

  _dbus_assert (socket_transport->read_watch == NULL);

  _dbus_assert (socket_transport->write_watch == NULL);

  dbus_free (transport);

}

static void

check_write_watch (DBusTransport *transport)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  dbus_bool_t needed;

  if (transport->connection == NULL)

    return;

  if (transport->disconnected)

    {

      _dbus_assert (socket_transport->write_watch == NULL);

      return;

    }

  _dbus_transport_ref (transport);

  if (_dbus_transport_get_is_authenticated (transport))

    needed = _dbus_connection_has_messages_to_send_unlocked (transport->connection);

  else

    {

      if (transport->send_credentials_pending)

        needed = TRUE;

      else

        {

          DBusAuthState auth_state;

          auth_state = _dbus_auth_do_work (transport->auth);

          /* If we need memory we install the write watch just in case,

           * if there's no need for it, it will get de-installed

           * next time we try reading.

           */

          if (auth_state == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND ||

              auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY)

            needed = TRUE;

          else

            needed = FALSE;

        }

    }

  _dbus_verbose ("check_write_watch(): needed = %d on connection %p watch %p fd = %d outgoing messages exist %d\n",

                 needed, transport->connection, socket_transport->write_watch,

                 socket_transport->fd,

                 _dbus_connection_has_messages_to_send_unlocked (transport->connection));

  _dbus_connection_toggle_watch_unlocked (transport->connection,

                                          socket_transport->write_watch,

                                          needed);

  _dbus_transport_unref (transport);

}

static void

check_read_watch (DBusTransport *transport)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  dbus_bool_t need_read_watch;

  _dbus_verbose ("%s: fd = %d\n",

                 _DBUS_FUNCTION_NAME, socket_transport->fd);

  if (transport->connection == NULL)

    return;

  if (transport->disconnected)

    {

      _dbus_assert (socket_transport->read_watch == NULL);

      return;

    }

  _dbus_transport_ref (transport);

  if (_dbus_transport_get_is_authenticated (transport))

    need_read_watch =

      _dbus_counter_get_value (transport->live_messages_size) < transport->max_live_messages_size;

  else

    {

      if (transport->receive_credentials_pending)

        need_read_watch = TRUE;

      else

        {

          /* The reason to disable need_read_watch when not WAITING_FOR_INPUT

           * is to avoid spinning on the file descriptor when we're waiting

           * to write or for some other part of the auth process

           */

          DBusAuthState auth_state;

          auth_state = _dbus_auth_do_work (transport->auth);

          /* If we need memory we install the read watch just in case,

           * if there's no need for it, it will get de-installed

           * next time we try reading. If we're authenticated we

           * install it since we normally have it installed while

           * authenticated.

           */

          if (auth_state == DBUS_AUTH_STATE_WAITING_FOR_INPUT ||

              auth_state == DBUS_AUTH_STATE_WAITING_FOR_MEMORY ||

              auth_state == DBUS_AUTH_STATE_AUTHENTICATED)

            need_read_watch = TRUE;

          else

            need_read_watch = FALSE;

        }

    }

  _dbus_verbose ("  setting read watch enabled = %d\n", need_read_watch);

  _dbus_connection_toggle_watch_unlocked (transport->connection,

                                          socket_transport->read_watch,

                                          need_read_watch);

  _dbus_transport_unref (transport);

}

static void

do_io_error (DBusTransport *transport)

{

  _dbus_transport_ref (transport);

  _dbus_transport_disconnect (transport);

  _dbus_transport_unref (transport);

}

/* return value is whether we successfully read any new data. */

static dbus_bool_t

read_data_into_auth (DBusTransport *transport,

                     dbus_bool_t   *oom)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  DBusString *buffer;

  int bytes_read;

  *oom = FALSE;

  _dbus_auth_get_buffer (transport->auth, &buffer);

  bytes_read = _dbus_read_socket (socket_transport->fd,

                                  buffer, socket_transport->max_bytes_read_per_iteration);

  _dbus_auth_return_buffer (transport->auth, buffer,

                            bytes_read > 0 ? bytes_read : 0);

  if (bytes_read > 0)

    {

      _dbus_verbose (" read %d bytes in auth phase\n", bytes_read);

      return TRUE;

    }

  else if (bytes_read < 0)

    {

      /* EINTR already handled for us */

      if (errno == ENOMEM)

        {

          *oom = TRUE;

        }

      else if (errno == EAGAIN ||

               errno == EWOULDBLOCK)

        ; /* do nothing, just return FALSE below */

      else

        {

          _dbus_verbose ("Error reading from remote app: %s\n",

                         _dbus_strerror (errno));

          do_io_error (transport);

        }

      return FALSE;

    }

  else

    {

      _dbus_assert (bytes_read == 0);

      _dbus_verbose ("Disconnected from remote app\n");

      do_io_error (transport);

      return FALSE;

    }

}

/* Return value is whether we successfully wrote any bytes */

static dbus_bool_t

write_data_from_auth (DBusTransport *transport)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  int bytes_written;

  const DBusString *buffer;

  if (!_dbus_auth_get_bytes_to_send (transport->auth,

                                     &buffer))

    return FALSE;

  bytes_written = _dbus_write_socket (socket_transport->fd,

                                      buffer,

                                      0, _dbus_string_get_length (buffer));

  if (bytes_written > 0)

    {

      _dbus_auth_bytes_sent (transport->auth, bytes_written);

      return TRUE;

    }

  else if (bytes_written < 0)

    {

      /* EINTR already handled for us */

      if (errno == EAGAIN ||

          errno == EWOULDBLOCK)

        ;

      else

        {

          _dbus_verbose ("Error writing to remote app: %s\n",

                         _dbus_strerror (errno));

          do_io_error (transport);

        }

    }

  return FALSE;

}

static void

exchange_credentials (DBusTransport *transport,

                      dbus_bool_t    do_reading,

                      dbus_bool_t    do_writing)

{

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  DBusError error;

  _dbus_verbose ("exchange_credentials: do_reading = %d, do_writing = %d\n",

                  do_reading, do_writing);

  dbus_error_init (&error);

  if (do_writing && transport->send_credentials_pending)

    {

      if (_dbus_send_credentials_unix_socket (socket_transport->fd,

                                              &error))

        {

          transport->send_credentials_pending = FALSE;

        }

      else

        {

          _dbus_verbose ("Failed to write credentials: %s\n", error.message);

          dbus_error_free (&error);

          do_io_error (transport);

        }

    }

  if (do_reading && transport->receive_credentials_pending)

    {

      if (_dbus_read_credentials_unix_socket (socket_transport->fd,

                                              &transport->credentials,

                                              &error))

        {

          transport->receive_credentials_pending = FALSE;

        }

      else

        {

          _dbus_verbose ("Failed to read credentials %s\n", error.message);

          dbus_error_free (&error);

          do_io_error (transport);

        }

    }

  if (!(transport->send_credentials_pending ||

        transport->receive_credentials_pending))

    {

      _dbus_auth_set_credentials (transport->auth,

                                  &transport->credentials);

    }

}

static dbus_bool_t

do_authentication (DBusTransport *transport,

                   dbus_bool_t    do_reading,

                   dbus_bool_t    do_writing,

		   dbus_bool_t   *auth_completed)

{

  dbus_bool_t oom;

  dbus_bool_t orig_auth_state;

  oom = FALSE;

  orig_auth_state = _dbus_transport_get_is_authenticated (transport);

  /* This is essential to avoid the check_write_watch() at the end,

   * we don't want to add a write watch in do_iteration before

   * we try writing and get EAGAIN

   */

  if (orig_auth_state)

    {

      if (auth_completed)

        *auth_completed = FALSE;

      return TRUE;

    }

  _dbus_transport_ref (transport);

  while (!_dbus_transport_get_is_authenticated (transport) &&

         _dbus_transport_get_is_connected (transport))

    {      

      exchange_credentials (transport, do_reading, do_writing);

      if (transport->send_credentials_pending ||

          transport->receive_credentials_pending)

        {

          _dbus_verbose ("send_credentials_pending = %d receive_credentials_pending = %d\n",

                         transport->send_credentials_pending,

                         transport->receive_credentials_pending);

          goto out;

        }

#define TRANSPORT_SIDE(t) ((t)->is_server ? "server" : "client")

      switch (_dbus_auth_do_work (transport->auth))

        {

        case DBUS_AUTH_STATE_WAITING_FOR_INPUT:

          _dbus_verbose (" %s auth state: waiting for input\n",

                         TRANSPORT_SIDE (transport));

          if (!do_reading || !read_data_into_auth (transport, &oom))

            goto out;

          break;

        case DBUS_AUTH_STATE_WAITING_FOR_MEMORY:

          _dbus_verbose (" %s auth state: waiting for memory\n",

                         TRANSPORT_SIDE (transport));

          oom = TRUE;

          goto out;

          break;

        case DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND:

          _dbus_verbose (" %s auth state: bytes to send\n",

                         TRANSPORT_SIDE (transport));

          if (!do_writing || !write_data_from_auth (transport))

            goto out;

          break;

        case DBUS_AUTH_STATE_NEED_DISCONNECT:

          _dbus_verbose (" %s auth state: need to disconnect\n",

                         TRANSPORT_SIDE (transport));

          do_io_error (transport);

          break;

        case DBUS_AUTH_STATE_AUTHENTICATED:

          _dbus_verbose (" %s auth state: authenticated\n",

                         TRANSPORT_SIDE (transport));

          break;

        }

    }

 out:

  if (auth_completed)

    *auth_completed = (orig_auth_state != _dbus_transport_get_is_authenticated (transport));

  check_read_watch (transport);

  check_write_watch (transport);

  _dbus_transport_unref (transport);

  if (oom)

    return FALSE;

  else

    return TRUE;

}

/* returns false on oom */

static dbus_bool_t

do_writing (DBusTransport *transport)

{

  int total;

  DBusTransportSocket *socket_transport = (DBusTransportSocket*) transport;

  dbus_bool_t oom;

  /* No messages without authentication! */

  if (!_dbus_transport_get_is_authenticated (transport))

    {

      _dbus_verbose ("Not authenticated, not writing anything\n");

      return TRUE;

    }

  if (transport->disconnected)

    {

      _dbus_verbose ("Not connected, not writing anything\n");

      return TRUE;

    }

#if 1

  _dbus_verbose ("do_writing(), have_messages = %d, fd = %d\n",

                 _dbus_connection_has_messages_to_send_unlocked (transport->connection),

                 socket_transport->fd);

#endif

  oom = FALSE;

  total = 0;

  while (!transport->disconnected &&

         _dbus_connection_has_messages_to_send_unlocked (transport->connection))

    {

      int bytes_written;

      DBusMessage *message;

      const DBusString *header;

      const DBusString *body;

      int header_len, body_len;

      int total_bytes_to_write;

      if (total > socket_transport->max_bytes_written_per_iteration)

        {

          _dbus_verbose ("%d bytes exceeds %d bytes written per iteration, returning\n",

                         total, socket_transport->max_bytes_written_per_iteration);

          goto out;

        }

      message = _dbus_connection_get_message_to_send (transport->connection);