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

/* connection.c  Client connections

 *

 * Copyright (C) 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 "connection.h"

#include "dispatch.h"

#include "policy.h"

#include "services.h"

#include "utils.h"

#include "signals.h"

#include "expirelist.h"

#include "selinux.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-list.h>

#include <dbus/dbus-hash.h>

#include <dbus/dbus-timeout.h>

#else

#include "dbus-list.h"

#include "dbus-hash.h"

#include "dbus-timeout.h"

#endif //__SYMBIAN32__

#ifdef __SYMBIAN32__

#include "config.h"

#endif //__SYMBIAN32__

static void bus_connection_remove_transactions (DBusConnection *connection);

typedef struct

{

  BusExpireItem expire_item;

  DBusConnection *will_get_reply;

  DBusConnection *will_send_reply;

  dbus_uint32_t reply_serial;

} BusPendingReply;

struct BusConnections

{

  int refcount;

  DBusList *completed;  /**< List of all completed connections */

  int n_completed;      /**< Length of completed list */

  DBusList *incomplete; /**< List of all not-yet-active connections */

  int n_incomplete;     /**< Length of incomplete list */

  BusContext *context;

  DBusHashTable *completed_by_user; /**< Number of completed connections for each UID */

  DBusTimeout *expire_timeout; /**< Timeout for expiring incomplete connections. */

  int stamp;                   /**< Incrementing number */

  BusExpireList *pending_replies; /**< List of pending replies */

};

static dbus_int32_t connection_data_slot = -1;

typedef struct

{

  BusConnections *connections;

  DBusList *link_in_connection_list;

  DBusConnection *connection;

  DBusList *services_owned;

  int n_services_owned;

  DBusList *match_rules;

  int n_match_rules;

  char *name;

  DBusList *transaction_messages; /**< Stuff we need to send as part of a transaction */

  DBusMessage *oom_message;

  DBusPreallocatedSend *oom_preallocated;

  BusClientPolicy *policy;

  BusSELinuxID *selinux_id;

  long connection_tv_sec;  /**< Time when we connected (seconds component) */

  long connection_tv_usec; /**< Time when we connected (microsec component) */

  int stamp;               /**< connections->stamp last time we were traversed */

} BusConnectionData;

static dbus_bool_t bus_pending_reply_expired (BusExpireList *list,

                                              DBusList      *link,

                                              void          *data);

static void bus_connection_drop_pending_replies (BusConnections  *connections,

                                                 DBusConnection  *connection);

static dbus_bool_t expire_incomplete_timeout (void *data);

#define BUS_CONNECTION_DATA(connection) (dbus_connection_get_data ((connection), connection_data_slot))

static DBusLoop*

connection_get_loop (DBusConnection *connection)

{

  BusConnectionData *d;

  d = BUS_CONNECTION_DATA (connection);

  return bus_context_get_loop (d->connections->context);

}

static int

get_connections_for_uid (BusConnections *connections,

                         dbus_uid_t      uid)

{

  void *val;

  int current_count;

  /* val is NULL is 0 when it isn't in the hash yet */

  val = _dbus_hash_table_lookup_ulong (connections->completed_by_user,

                                       uid);

  current_count = _DBUS_POINTER_TO_INT (val);

  return current_count;

}

static dbus_bool_t

adjust_connections_for_uid (BusConnections *connections,

                            dbus_uid_t      uid,

                            int             adjustment)

{

  int current_count;

  current_count = get_connections_for_uid (connections, uid);

  _dbus_verbose ("Adjusting connection count for UID " DBUS_UID_FORMAT

                 ": was %d adjustment %d making %d\n",

                 uid, current_count, adjustment, current_count + adjustment);

  _dbus_assert (current_count >= 0);

  current_count += adjustment;

  _dbus_assert (current_count >= 0);

  if (current_count == 0)

    {

      _dbus_hash_table_remove_ulong (connections->completed_by_user, uid);

      return TRUE;

    }

  else

    {

      dbus_bool_t retval;

      retval = _dbus_hash_table_insert_ulong (connections->completed_by_user,

                                              uid, _DBUS_INT_TO_POINTER (current_count));

      /* only positive adjustment can fail as otherwise

       * a hash entry should already exist

       */

      _dbus_assert (adjustment > 0 ||

                    (adjustment <= 0 && retval));

      return retval;

    }

}

void

bus_connection_disconnected (DBusConnection *connection)

{

  BusConnectionData *d;

  BusService *service;

  BusMatchmaker *matchmaker;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  _dbus_verbose ("%s disconnected, dropping all service ownership and releasing\n",

                 d->name ? d->name : "(inactive)");

  /* Delete our match rules */

  if (d->n_match_rules > 0)

    {

      matchmaker = bus_context_get_matchmaker (d->connections->context);

      bus_matchmaker_disconnected (matchmaker, connection);

    }

  /* Drop any service ownership. Unfortunately, this requires

   * memory allocation and there doesn't seem to be a good way to

   * handle it other than sleeping; we can't "fail" the operation of

   * disconnecting a client, and preallocating a broadcast "service is

   * now gone" message for every client-service pair seems kind of

   * involved.

   */

  while ((service = _dbus_list_get_last (&d->services_owned)))

    {

      BusTransaction *transaction;

      DBusError error;

    retry:

      dbus_error_init (&error);

      while ((transaction = bus_transaction_new (d->connections->context)) == NULL)

        _dbus_wait_for_memory ();

      if (!bus_service_remove_owner (service, connection,

                                     transaction, &error))

        {

          _DBUS_ASSERT_ERROR_IS_SET (&error);

          if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

            {

              dbus_error_free (&error);

              bus_transaction_cancel_and_free (transaction);

              _dbus_wait_for_memory ();

              goto retry;

            }

          else

            {

              _dbus_verbose ("Failed to remove service owner: %s %s\n",

                             error.name, error.message);

              _dbus_assert_not_reached ("Removing service owner failed for non-memory-related reason");

            }

        }

      bus_transaction_execute_and_free (transaction);

    }

  bus_dispatch_remove_connection (connection);

  /* no more watching */

  if (!dbus_connection_set_watch_functions (connection,

                                            NULL, NULL, NULL,

                                            connection,

                                            NULL))

    _dbus_assert_not_reached ("setting watch functions to NULL failed");

  if (!dbus_connection_set_timeout_functions (connection,

                                              NULL, NULL, NULL,

                                              connection,

                                              NULL))

    _dbus_assert_not_reached ("setting timeout functions to NULL failed");

  dbus_connection_set_unix_user_function (connection,

                                          NULL, NULL, NULL);

  dbus_connection_set_dispatch_status_function (connection,

                                                NULL, NULL, NULL);

  bus_connection_remove_transactions (connection);

  if (d->link_in_connection_list != NULL)

    {

      if (d->name != NULL)

        {

          unsigned long uid;

          _dbus_list_remove_link (&d->connections->completed, d->link_in_connection_list);

          d->link_in_connection_list = NULL;

          d->connections->n_completed -= 1;

          if (dbus_connection_get_unix_user (connection, &uid))

            {

              if (!adjust_connections_for_uid (d->connections,

                                               uid, -1))

                _dbus_assert_not_reached ("adjusting downward should never fail");

            }

        }

      else

        {

          _dbus_list_remove_link (&d->connections->incomplete, d->link_in_connection_list);

          d->link_in_connection_list = NULL;

          d->connections->n_incomplete -= 1;

        }

      _dbus_assert (d->connections->n_incomplete >= 0);

      _dbus_assert (d->connections->n_completed >= 0);

    }

  bus_connection_drop_pending_replies (d->connections, connection);

  /* frees "d" as side effect */

  dbus_connection_set_data (connection,

                            connection_data_slot,

                            NULL, NULL);

  dbus_connection_unref (connection);

}

static dbus_bool_t

connection_watch_callback (DBusWatch     *watch,

                           unsigned int   condition,

                           void          *data)

{

 /* FIXME this can be done in dbus-mainloop.c

  * if the code in activation.c for the babysitter

  * watch handler is fixed.

  */

#if 0

  _dbus_verbose ("Calling handle_watch\n");

#endif

  return dbus_watch_handle (watch, condition);

}

static dbus_bool_t

add_connection_watch (DBusWatch      *watch,

                      void           *data)

{

  DBusConnection *connection = data;

  return _dbus_loop_add_watch (connection_get_loop (connection),

                               watch, connection_watch_callback, connection,

                               NULL);

}

static void

remove_connection_watch (DBusWatch      *watch,

                         void           *data)

{

  DBusConnection *connection = data;

  _dbus_loop_remove_watch (connection_get_loop (connection),

                           watch, connection_watch_callback, connection);

}

static void

connection_timeout_callback (DBusTimeout   *timeout,

                             void          *data)

{

  /* DBusConnection *connection = data; */

  /* can return FALSE on OOM but we just let it fire again later */

  dbus_timeout_handle (timeout);

}

static dbus_bool_t

add_connection_timeout (DBusTimeout    *timeout,

                        void           *data)

{

  DBusConnection *connection = data;

  return _dbus_loop_add_timeout (connection_get_loop (connection),

                                 timeout, connection_timeout_callback, connection, NULL);

}

static void

remove_connection_timeout (DBusTimeout    *timeout,

                           void           *data)

{

  DBusConnection *connection = data;

  _dbus_loop_remove_timeout (connection_get_loop (connection),

                             timeout, connection_timeout_callback, connection);

}

static void

dispatch_status_function (DBusConnection    *connection,

                          DBusDispatchStatus new_status,

                          void              *data)

{

  DBusLoop *loop = data;

  if (new_status != DBUS_DISPATCH_COMPLETE)

    {

      while (!_dbus_loop_queue_dispatch (loop, connection))

        _dbus_wait_for_memory ();

    }

}

static dbus_bool_t

allow_user_function (DBusConnection *connection,

                     unsigned long   uid,

                     void           *data)

{

  BusConnectionData *d;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  return bus_context_allow_user (d->connections->context, uid);

}

static void

free_connection_data (void *data)

{

  BusConnectionData *d = data;

  /* services_owned should be NULL since we should be disconnected */

  _dbus_assert (d->services_owned == NULL);

  _dbus_assert (d->n_services_owned == 0);

  /* similarly */

  _dbus_assert (d->transaction_messages == NULL);

  if (d->oom_preallocated)

    dbus_connection_free_preallocated_send (d->connection, d->oom_preallocated);

  if (d->oom_message)

    dbus_message_unref (d->oom_message);

  if (d->policy)

    bus_client_policy_unref (d->policy);

  if (d->selinux_id)

    bus_selinux_id_unref (d->selinux_id);

  dbus_free (d->name);

  dbus_free (d);

}

static void

call_timeout_callback (DBusTimeout   *timeout,

                       void          *data)

{

  /* can return FALSE on OOM but we just let it fire again later */

  dbus_timeout_handle (timeout);

}

BusConnections*

bus_connections_new (BusContext *context)

{

  BusConnections *connections;

  if (!dbus_connection_allocate_data_slot (&connection_data_slot))

    goto failed_0;

  connections = dbus_new0 (BusConnections, 1);

  if (connections == NULL)

    goto failed_1;

  connections->completed_by_user = _dbus_hash_table_new (DBUS_HASH_ULONG,

                                                         NULL, NULL);

  if (connections->completed_by_user == NULL)

    goto failed_2;

  connections->expire_timeout = _dbus_timeout_new (100, /* irrelevant */

                                                   expire_incomplete_timeout,

                                                   connections, NULL);

  if (connections->expire_timeout == NULL)

    goto failed_3;

  _dbus_timeout_set_enabled (connections->expire_timeout, FALSE);

  connections->pending_replies = bus_expire_list_new (bus_context_get_loop (context),

                                                      bus_context_get_reply_timeout (context),

                                                      bus_pending_reply_expired,

                                                      connections);

  if (connections->pending_replies == NULL)

    goto failed_4;

  if (!_dbus_loop_add_timeout (bus_context_get_loop (context),

                               connections->expire_timeout,

                               call_timeout_callback, NULL, NULL))

    goto failed_5;

  connections->refcount = 1;

  connections->context = context;

  return connections;

 failed_5:

  bus_expire_list_free (connections->pending_replies);

 failed_4:

  _dbus_timeout_unref (connections->expire_timeout);

 failed_3:

  _dbus_hash_table_unref (connections->completed_by_user);

 failed_2:

  dbus_free (connections);

 failed_1:

  dbus_connection_free_data_slot (&connection_data_slot);

 failed_0:

  return NULL;

}

BusConnections *

bus_connections_ref (BusConnections *connections)

{

  _dbus_assert (connections->refcount > 0);

  connections->refcount += 1;

  return connections;

}

void

bus_connections_unref (BusConnections *connections)

{

  _dbus_assert (connections->refcount > 0);

  connections->refcount -= 1;

  if (connections->refcount == 0)

    {

      /* drop all incomplete */

      while (connections->incomplete != NULL)

        {

          DBusConnection *connection;

          connection = connections->incomplete->data;

          dbus_connection_ref (connection);

          dbus_connection_close (connection);

          bus_connection_disconnected (connection);

          dbus_connection_unref (connection);

        }

      _dbus_assert (connections->n_incomplete == 0);

      /* drop all real connections */

      while (connections->completed != NULL)

        {

          DBusConnection *connection;

          connection = connections->completed->data;

          dbus_connection_ref (connection);

          dbus_connection_close (connection);

          bus_connection_disconnected (connection);

          dbus_connection_unref (connection);

        }