/* -*- 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);

        }

      _dbus_assert (connections->n_completed == 0);

      bus_expire_list_free (connections->pending_replies);

      _dbus_loop_remove_timeout (bus_context_get_loop (connections->context),

                                 connections->expire_timeout,

                                 call_timeout_callback, NULL);

      _dbus_timeout_unref (connections->expire_timeout);

      _dbus_hash_table_unref (connections->completed_by_user);

      dbus_free (connections);

      dbus_connection_free_data_slot (&connection_data_slot);

    }

}

dbus_bool_t

bus_connections_setup_connection (BusConnections *connections,

                                  DBusConnection *connection)

{

  BusConnectionData *d;

  dbus_bool_t retval;

  DBusError error;

  d = dbus_new0 (BusConnectionData, 1);

  if (d == NULL)

    return FALSE;

  d->connections = connections;

  d->connection = connection;

  _dbus_get_current_time (&d->connection_tv_sec,

                          &d->connection_tv_usec);

  _dbus_assert (connection_data_slot >= 0);

  if (!dbus_connection_set_data (connection,

                                 connection_data_slot,

                                 d, free_connection_data))

    {

      dbus_free (d);

      return FALSE;

    }

  dbus_connection_set_route_peer_messages (connection, TRUE);

  retval = FALSE;

  dbus_error_init (&error);

  d->selinux_id = bus_selinux_init_connection_id (connection,

                                                  &error);

  if (dbus_error_is_set (&error))

    {

      /* This is a bit bogus because we pretend all errors

       * are OOM; this is done because we know that in bus.c

       * an OOM error disconnects the connection, which is

       * the same thing we want on any other error.

       */

      dbus_error_free (&error);

      goto out;

    }

  if (!dbus_connection_set_watch_functions (connection,

                                            add_connection_watch,

                                            remove_connection_watch,

                                            NULL,

                                            connection,

                                            NULL))

    goto out;

  if (!dbus_connection_set_timeout_functions (connection,

                                              add_connection_timeout,

                                              remove_connection_timeout,

                                              NULL,

                                              connection, NULL))

    goto out;

  dbus_connection_set_unix_user_function (connection,

                                          allow_user_function,

                                          NULL, NULL);

  dbus_connection_set_dispatch_status_function (connection,

                                                dispatch_status_function,

                                                bus_context_get_loop (connections->context),

                                                NULL);

  d->link_in_connection_list = _dbus_list_alloc_link (connection);

  if (d->link_in_connection_list == NULL)

    goto out;

  /* Setup the connection with the dispatcher */

  if (!bus_dispatch_add_connection (connection))

    goto out;

  if (dbus_connection_get_dispatch_status (connection) != DBUS_DISPATCH_COMPLETE)

    {

      if (!_dbus_loop_queue_dispatch (bus_context_get_loop (connections->context), connection))

        {

          bus_dispatch_remove_connection (connection);

          goto out;

        }

    }

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

  connections->n_incomplete += 1;

  dbus_connection_ref (connection);

  /* Note that we might disconnect ourselves here, but it only takes

   * effect on return to the main loop. We call this to free up

   * expired connections if possible, and to queue the timeout for our

   * own expiration.

   */

  bus_connections_expire_incomplete (connections);

  /* And we might also disconnect ourselves here, but again it

   * only takes effect on return to main loop.

   */

  if (connections->n_incomplete >

      bus_context_get_max_incomplete_connections (connections->context))

    {

      _dbus_verbose ("Number of incomplete connections exceeds max, dropping oldest one\n");

      _dbus_assert (connections->incomplete != NULL);

      /* Disconnect the oldest unauthenticated connection.  FIXME

       * would it be more secure to drop a *random* connection?  This

       * algorithm seems to mean that if someone can create new

       * connections quickly enough, they can keep anyone else from

       * completing authentication. But random may or may not really

       * help with that, a more elaborate solution might be required.

       */

      dbus_connection_close (connections->incomplete->data);

    }

  retval = TRUE;

 out:

  if (!retval)

    {

      if (d->selinux_id)

        bus_selinux_id_unref (d->selinux_id);

      d->selinux_id = NULL;

      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);

      if (d->link_in_connection_list != NULL)

        {

          _dbus_assert (d->link_in_connection_list->next == NULL);

          _dbus_assert (d->link_in_connection_list->prev == NULL);

          _dbus_list_free_link (d->link_in_connection_list);

          d->link_in_connection_list = NULL;

        }

      if (!dbus_connection_set_data (connection,

                                     connection_data_slot,

                                     NULL, NULL))

        _dbus_assert_not_reached ("failed to set connection data to null");

      /* "d" has now been freed */

    }

  return retval;

}

void

bus_connections_expire_incomplete (BusConnections *connections)

{    

  int next_interval;

  next_interval = -1;

  if (connections->incomplete != NULL)

    {

      long tv_sec, tv_usec;

      DBusList *link;

      int auth_timeout;

      _dbus_get_current_time (&tv_sec, &tv_usec);

      auth_timeout = bus_context_get_auth_timeout (connections->context);

      link = _dbus_list_get_first_link (&connections->incomplete);

      while (link != NULL)

        {

          DBusList *next = _dbus_list_get_next_link (&connections->incomplete, link);

          DBusConnection *connection;

          BusConnectionData *d;

          double elapsed;

          connection = link->data;

          d = BUS_CONNECTION_DATA (connection);

          _dbus_assert (d != NULL);

          elapsed = ELAPSED_MILLISECONDS_SINCE (d->connection_tv_sec,

                                                d->connection_tv_usec,

                                                tv_sec, tv_usec);

          if (elapsed >= (double) auth_timeout)

            {

              _dbus_verbose ("Timing out authentication for connection %p\n", connection);

              dbus_connection_close (connection);

            }

          else

            {

              /* We can end the loop, since the connections are in oldest-first order */

              next_interval = ((double)auth_timeout) - elapsed;

              _dbus_verbose ("Connection %p authentication expires in %d milliseconds\n",

                             connection, next_interval);

              break;

            }

          link = next;

        }

    }

  bus_expire_timeout_set_interval (connections->expire_timeout,

                                   next_interval);

}

static dbus_bool_t

expire_incomplete_timeout (void *data)

{

  BusConnections *connections = data;

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

  /* note that this may remove the timeout */

  bus_connections_expire_incomplete (connections);

  return TRUE;

}

dbus_bool_t

bus_connection_get_groups  (DBusConnection   *connection,

                            unsigned long   **groups,

                            int              *n_groups,

                            DBusError        *error)

{

  BusConnectionData *d;

  unsigned long uid;

  DBusUserDatabase *user_database;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  user_database = bus_context_get_user_database (d->connections->context);

  *groups = NULL;

  *n_groups = 0;

  if (dbus_connection_get_unix_user (connection, &uid))

    {

      if (!_dbus_user_database_get_groups (user_database,

                                           uid, groups, n_groups,

                                           error))

        {

          _DBUS_ASSERT_ERROR_IS_SET (error);

          _dbus_verbose ("Did not get any groups for UID %lu\n",

                         uid);

          return FALSE;

        }

      else

        {

          _dbus_verbose ("Got %d groups for UID %lu\n",

                         *n_groups, uid);

          return TRUE;

        }

    }

  else

    return TRUE; /* successfully got 0 groups */

}

dbus_bool_t

bus_connection_is_in_group (DBusConnection *connection,

                            unsigned long   gid)

{

  int i;

  unsigned long *group_ids;

  int n_group_ids;

  if (!bus_connection_get_groups (connection, &group_ids, &n_group_ids,

                                  NULL))

    return FALSE;

  i = 0;

  while (i < n_group_ids)

    {

      if (group_ids[i] == gid)

        {

          dbus_free (group_ids);

          return TRUE;

        }

      ++i;

    }

  dbus_free (group_ids);

  return FALSE;

}

BusClientPolicy*

bus_connection_get_policy (DBusConnection *connection)

{

  BusConnectionData *d;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  _dbus_assert (d->policy != NULL);

  return d->policy;

}

static dbus_bool_t

foreach_active (BusConnections               *connections,

                BusConnectionForeachFunction  function,

                void                         *data)

{

  DBusList *link;

  link = _dbus_list_get_first_link (&connections->completed);

  while (link != NULL)

    {

      DBusConnection *connection = link->data;

      DBusList *next = _dbus_list_get_next_link (&connections->completed, link);

      if (!(* function) (connection, data))

        return FALSE;

      link = next;

    }

  return TRUE;

}

static dbus_bool_t

foreach_inactive (BusConnections               *connections,

                  BusConnectionForeachFunction  function,

                  void                         *data)

{

  DBusList *link;

  link = _dbus_list_get_first_link (&connections->incomplete);

  while (link != NULL)

    {

      DBusConnection *connection = link->data;

      DBusList *next = _dbus_list_get_next_link (&connections->incomplete, link);

      if (!(* function) (connection, data))

        return FALSE;

      link = next;

    }

  return TRUE;

}

/**

 * Calls function on each active connection; if the function returns

 * #FALSE, stops iterating. Active connections are authenticated

 * and have sent a Hello message.

 *

 * @param connections the connections object

 * @param function the function

 * @param data data to pass to it as a second arg

 */

void

bus_connections_foreach_active (BusConnections               *connections,

                                BusConnectionForeachFunction  function,

                                void                         *data)

{

  foreach_active (connections, function, data);

}

/**

 * Calls function on each connection; if the function returns

 * #FALSE, stops iterating.

 *

 * @param connections the connections object

 * @param function the function

 * @param data data to pass to it as a second arg

 */

void

bus_connections_foreach (BusConnections               *connections,

                         BusConnectionForeachFunction  function,

                         void                         *data)

{

  if (!foreach_active (connections, function, data))

    return;

  foreach_inactive (connections, function, data);

}

BusContext*

bus_connections_get_context (BusConnections *connections)

{

  return connections->context;

}

/*

 * This is used to avoid covering the same connection twice when

 * traversing connections. Note that it assumes we will

 * bus_connection_mark_stamp() each connection at least once per

 * INT_MAX increments of the global stamp, or wraparound would break

 * things.

 */

void

bus_connections_increment_stamp (BusConnections *connections)

{

  connections->stamp += 1;

}

/* Mark connection with current stamp, return TRUE if it

 * didn't already have that stamp

 */

dbus_bool_t

bus_connection_mark_stamp (DBusConnection *connection)

{

  BusConnectionData *d;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  if (d->stamp == d->connections->stamp)

    return FALSE;

  else

    {

      d->stamp = d->connections->stamp;

      return TRUE;

    }

}

BusContext*

bus_connection_get_context (DBusConnection *connection)

{

  BusConnectionData *d;

  d = BUS_CONNECTION_DATA (connection);

  _dbus_assert (d != NULL);

  return d->connections->context;

}