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

/* dbus-transport.c DBusTransport object (internal to D-Bus implementation)

 *

 * Copyright (C) 2002, 2003  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-transport-protected.h"

#include "dbus-transport-unix.h"

#include "dbus-transport-socket.h"

#include "dbus-connection-internal.h"

#include "dbus-watch.h"

#include "dbus-auth.h"

#include "dbus-address.h"

#ifdef DBUS_BUILD_TESTS

#include "dbus-server-debug-pipe.h"

#endif

/**

 * @defgroup DBusTransport DBusTransport object

 * @ingroup  DBusInternals

 * @brief "Backend" for a DBusConnection.

 *

 * Types and functions related to DBusTransport.  A transport is an

 * abstraction that can send and receive data via various kinds of

 * network connections or other IPC mechanisms.

 * 

 * @{

 */

/**

 * @typedef DBusTransport

 *

 * Opaque object representing a way message stream.

 * DBusTransport abstracts various kinds of actual

 * transport mechanism, such as different network protocols,

 * or encryption schemes.

 */

static void

live_messages_size_notify (DBusCounter *counter,

                           void        *user_data)

{

  DBusTransport *transport = user_data;

  _dbus_transport_ref (transport);

#if 0

  _dbus_verbose ("Counter value is now %d\n",

                 (int) _dbus_counter_get_value (counter));

#endif

  /* disable or re-enable the read watch for the transport if

   * required.

   */

  if (transport->vtable->live_messages_changed)

    (* transport->vtable->live_messages_changed) (transport);

  _dbus_transport_unref (transport);

}

/**

 * Initializes the base class members of DBusTransport.  Chained up to

 * by subclasses in their constructor.  The server GUID is the

 * globally unique ID for the server creating this connection

 * and will be #NULL for the client side of a connection. The GUID

 * is in hex format.

 *

 * @param transport the transport being created.

 * @param vtable the subclass vtable.

 * @param server_guid non-#NULL if this transport is on the server side of a connection

 * @param address the address of the transport

 * @returns #TRUE on success.

 */

dbus_bool_t

_dbus_transport_init_base (DBusTransport             *transport,

                           const DBusTransportVTable *vtable,

                           const DBusString          *server_guid,

                           const DBusString          *address)

{

  DBusMessageLoader *loader;

  DBusAuth *auth;

  DBusCounter *counter;

  char *address_copy;

  loader = _dbus_message_loader_new ();

  if (loader == NULL)

    return FALSE;

  if (server_guid)

    auth = _dbus_auth_server_new (server_guid);

  else

    auth = _dbus_auth_client_new ();

  if (auth == NULL)

    {

      _dbus_message_loader_unref (loader);

      return FALSE;

    }

  counter = _dbus_counter_new ();

  if (counter == NULL)

    {

      _dbus_auth_unref (auth);

      _dbus_message_loader_unref (loader);

      return FALSE;

    }  

  if (server_guid)

    {

      _dbus_assert (address == NULL);

      address_copy = NULL;

    }

  else

    {

      _dbus_assert (address != NULL);

      if (!_dbus_string_copy_data (address, &address_copy))

        {

          _dbus_counter_unref (counter);

          _dbus_auth_unref (auth);

          _dbus_message_loader_unref (loader);

          return FALSE;

        }

    }

  transport->refcount = 1;

  transport->vtable = vtable;

  transport->loader = loader;

  transport->auth = auth;

  transport->live_messages_size = counter;

  transport->authenticated = FALSE;

  transport->disconnected = FALSE;

  transport->is_server = (server_guid != NULL);

  transport->send_credentials_pending = !transport->is_server;

  transport->receive_credentials_pending = transport->is_server;

  transport->address = address_copy;

  transport->unix_user_function = NULL;

  transport->unix_user_data = NULL;

  transport->free_unix_user_data = NULL;

  transport->expected_guid = NULL;

  /* Try to default to something that won't totally hose the system,

   * but doesn't impose too much of a limitation.

   */

  transport->max_live_messages_size = _DBUS_ONE_MEGABYTE * 63;

  // sachin has modified this init values here 

  // This below is the original code

  // transport->credentials.pid = -1;

  // transport->credentials.uid = -1;

  // transport->credentials.gid = -1;

  transport->credentials.pid = 155;

  transport->credentials.uid = 0;

  transport->credentials.gid = 0;

  _dbus_counter_set_notify (transport->live_messages_size,

                            transport->max_live_messages_size,

                            live_messages_size_notify,

                            transport);

  if (transport->address)

    _dbus_verbose ("Initialized transport on address %s\n", transport->address);

  return TRUE;

}

/**

 * Finalizes base class members of DBusTransport.

 * Chained up to from subclass finalizers.

 *

 * @param transport the transport.

 */

void

_dbus_transport_finalize_base (DBusTransport *transport)

{

  if (!transport->disconnected)

    _dbus_transport_disconnect (transport);

  if (transport->free_unix_user_data != NULL)

    (* transport->free_unix_user_data) (transport->unix_user_data);

  _dbus_message_loader_unref (transport->loader);

  _dbus_auth_unref (transport->auth);

  _dbus_counter_set_notify (transport->live_messages_size,

                            0, NULL, NULL);

  _dbus_counter_unref (transport->live_messages_size);

  dbus_free (transport->address);

  dbus_free (transport->expected_guid);

}

/**

 * Verifies if a given D-Bus address is a valid address

 * by attempting to connect to it. If it is, returns the

 * opened DBusTransport object. If it isn't, returns #NULL

 * and sets @p error.

 *

 * @param error address where an error can be returned.

 * @returns a new transport, or #NULL on failure.

 */

static DBusTransport*

check_address (const char *address, DBusError *error)

{

  DBusAddressEntry **entries;

  DBusTransport *transport = NULL;

  int len, i;

  _dbus_assert (address != NULL);

  _dbus_assert (*address != '\0');

  if (!dbus_parse_address (address, &entries, &len, error))

    return FALSE;              /* not a valid address */

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

    {

      transport = _dbus_transport_open (entries[i], error);

      if (transport != NULL)

        break;

    }

  dbus_address_entries_free (entries);

  return transport;

}

/**

 * Creates a new transport for the "autostart" method.

 * This creates a client-side of a transport.

 *

 * @param error address where an error can be returned.

 * @returns a new transport, or #NULL on failure.

 */

static DBusTransport*

_dbus_transport_new_for_autolaunch (DBusError      *error)

{

  DBusString address;

  DBusTransport *result = NULL;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  if (!_dbus_string_init (&address))

    {

      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);

      return NULL;

    }

  if (!_dbus_get_autolaunch_address (&address, error))

    {

      _DBUS_ASSERT_ERROR_IS_SET (error);

      goto out;

    }

  result = check_address (_dbus_string_get_const_data (&address), error);

  if (result == NULL)

    _DBUS_ASSERT_ERROR_IS_SET (error);

  else

    _DBUS_ASSERT_ERROR_IS_CLEAR (error);

 out:

  _dbus_string_free (&address);

  return result;

}

static DBusTransportOpenResult

_dbus_transport_open_autolaunch (DBusAddressEntry  *entry,

                                 DBusTransport    **transport_p,

                                 DBusError         *error)

{

  const char *method;

  method = dbus_address_entry_get_method (entry);

  _dbus_assert (method != NULL);

  if (strcmp (method, "autolaunch") == 0)

    {

      *transport_p = _dbus_transport_new_for_autolaunch (error);

      if (*transport_p == NULL)

        {

          _DBUS_ASSERT_ERROR_IS_SET (error);

          return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;

        }

      else

        {

          _DBUS_ASSERT_ERROR_IS_CLEAR (error);

          return DBUS_TRANSPORT_OPEN_OK;

        }      

    }

  else

    {

      _DBUS_ASSERT_ERROR_IS_CLEAR (error);

      return DBUS_TRANSPORT_OPEN_NOT_HANDLED;

    }

}

static const struct {

  DBusTransportOpenResult (* func) (DBusAddressEntry *entry,

                                    DBusTransport   **transport_p,

                                    DBusError        *error);

} open_funcs[] = {

  { _dbus_transport_open_socket },

  { _dbus_transport_open_platform_specific },

  { _dbus_transport_open_autolaunch }

#ifdef DBUS_BUILD_TESTS

  , { _dbus_transport_open_debug_pipe }

#endif

};

/**

 * Try to open a new transport for the given address entry.  (This

 * opens a client-side-of-the-connection transport.)

 * 

 * @param entry the address entry

 * @param error location to store reason for failure.

 * @returns new transport of #NULL on failure.

 */

DBusTransport*

_dbus_transport_open (DBusAddressEntry *entry,

                      DBusError        *error)

{

  DBusTransport *transport;

  const char *expected_guid_orig;

  char *expected_guid;

  int i;

  DBusError tmp_error;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  transport = NULL;

  expected_guid_orig = dbus_address_entry_get_value (entry, "guid");

  expected_guid = _dbus_strdup (expected_guid_orig);

  if (expected_guid_orig != NULL && expected_guid == NULL)

    {

      _DBUS_SET_OOM (error);

      return NULL;

    }

  dbus_error_init (&tmp_error);

  for (i = 0; i < (int) _DBUS_N_ELEMENTS (open_funcs); ++i)

    {

      DBusTransportOpenResult result;

      _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);

      result = (* open_funcs[i].func) (entry, &transport, &tmp_error);

      switch (result)

        {

        case DBUS_TRANSPORT_OPEN_OK:

          _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);

          goto out;

          break;

        case DBUS_TRANSPORT_OPEN_NOT_HANDLED:

          _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);

          /* keep going through the loop of open funcs */

          break;

        case DBUS_TRANSPORT_OPEN_BAD_ADDRESS:

          _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);

          goto out;

          break;

        case DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT:

          _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);

          goto out;

          break;

        }

    }

 out:

  if (transport == NULL)

    {

      if (!dbus_error_is_set (&tmp_error))

        _dbus_set_bad_address (&tmp_error,

                               NULL, NULL,

                               "Unknown address type (examples of valid types are \"tcp\" and on UNIX \"unix\")");

      _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);

      dbus_move_error(&tmp_error, error);

      dbus_free (expected_guid);

    }

  else

    {

      _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);

      //fix for memory leak for dbus_bus_get in autolaunch mode

#ifdef __SYMBIAN32__ 

      if (transport->expected_guid)

        dbus_free(transport->expected_guid);

#endif // __SYMBIAN32__      

      transport->expected_guid = expected_guid;

    }

  return transport;

}

/**

 * Increments the reference count for the transport.

 *

 * @param transport the transport.

 * @returns the transport.

 */

DBusTransport *

_dbus_transport_ref (DBusTransport *transport)

{

  _dbus_assert (transport->refcount > 0);

  transport->refcount += 1;

  return transport;

}

/**

 * Decrements the reference count for the transport.

 * Disconnects and finalizes the transport if

 * the reference count reaches zero.

 *

 * @param transport the transport.

 */

void

_dbus_transport_unref (DBusTransport *transport)

{

  _dbus_assert (transport != NULL);

  _dbus_assert (transport->refcount > 0);

  transport->refcount -= 1;

  if (transport->refcount == 0)

    {

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

      _dbus_assert (transport->vtable->finalize != NULL);

      (* transport->vtable->finalize) (transport);

    }

}

/**

 * Closes our end of the connection to a remote application. Further

 * attempts to use this transport will fail. Only the first call to

 * _dbus_transport_disconnect() will have an effect.

 *

 * @param transport the transport.

 * 

 */

void

_dbus_transport_disconnect (DBusTransport *transport)

{

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

  _dbus_assert (transport->vtable->disconnect != NULL);

  if (transport->disconnected)

    return;

  (* transport->vtable->disconnect) (transport);

  transport->disconnected = TRUE;

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

}

/**

 * Returns #TRUE if the transport has not been disconnected.

 * Disconnection can result from _dbus_transport_disconnect()

 * or because the server drops its end of the connection.

 *

 * @param transport the transport.

 * @returns whether we're connected

 */

dbus_bool_t

_dbus_transport_get_is_connected (DBusTransport *transport)

{

  return !transport->disconnected;

}

/**

 * Returns #TRUE if we have been authenticated.  Will return #TRUE

 * even if the transport is disconnected.

 *

 * @todo we drop connection->mutex when calling the unix_user_function,

 * which may not be safe really.

 *

 * @param transport the transport

 * @returns whether we're authenticated

 */

dbus_bool_t

_dbus_transport_get_is_authenticated (DBusTransport *transport)

{

  /* We don't want to run unix_user_function on Windows, but it

   * can exist, which allows application code to just unconditionally

   * set it and have it only be invoked when appropriate.

   */

  dbus_bool_t on_windows = FALSE;

#ifdef DBUS_WIN

  on_windows = TRUE;

#endif

  if (transport->authenticated)

    return TRUE;

  else

    {

      dbus_bool_t maybe_authenticated;

      if (transport->disconnected)

        return FALSE;

      /* paranoia ref since we call user callbacks sometimes */

      _dbus_connection_ref_unlocked (transport->connection);

      maybe_authenticated =

        (!(transport->send_credentials_pending ||