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

     2 /* connection.c  Client connections

     3  *

     4  * Copyright (C) 2003  Red Hat, Inc.

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

     6  * Licensed under the Academic Free License version 2.1

     7  * 

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

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

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

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  * 

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

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

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

    21  *

    22  */

    23 #include "connection.h"

    24 #include "dispatch.h"

    25 #include "policy.h"

    26 #include "services.h"

    27 #include "utils.h"

    28 #include "signals.h"

    29 #include "expirelist.h"

    30 #include "selinux.h"

    31 #ifndef __SYMBIAN32__

    32 #include <dbus/dbus-list.h>

    33 #include <dbus/dbus-hash.h>

    34 #include <dbus/dbus-timeout.h>

    35 #else

    36 #include "dbus-list.h"

    37 #include "dbus-hash.h"

    38 #include "dbus-timeout.h"

    39 #endif //__SYMBIAN32__

    40 

    41 #ifdef __SYMBIAN32__

    42 #include "config.h"

    43 #endif //__SYMBIAN32__

    44 

    45 static void bus_connection_remove_transactions (DBusConnection *connection);

    46 

    47 typedef struct

    48 {

    49   BusExpireItem expire_item;

    50 

    51   DBusConnection *will_get_reply;

    52   DBusConnection *will_send_reply;

    53 

    54   dbus_uint32_t reply_serial;

    55   

    56 } BusPendingReply;

    57 

    58 struct BusConnections

    59 {

    60   int refcount;

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

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

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

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

    65   BusContext *context;

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

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

    68   int stamp;                   /**< Incrementing number */

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

    70 };

    71 

    72 static dbus_int32_t connection_data_slot = -1;

    73 

    74 typedef struct

    75 {

    76   BusConnections *connections;

    77   DBusList *link_in_connection_list;

    78   DBusConnection *connection;

    79   DBusList *services_owned;

    80   int n_services_owned;

    81   DBusList *match_rules;

    82   int n_match_rules;

    83   char *name;

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

    85   DBusMessage *oom_message;

    86   DBusPreallocatedSend *oom_preallocated;

    87   BusClientPolicy *policy;

    88 

    89   BusSELinuxID *selinux_id;

    90 

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

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

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

    94 } BusConnectionData;

    95 

    96 static dbus_bool_t bus_pending_reply_expired (BusExpireList *list,

    97                                               DBusList      *link,

    98                                               void          *data);

    99 

   100 static void bus_connection_drop_pending_replies (BusConnections  *connections,

   101                                                  DBusConnection  *connection);

   102 

   103 static dbus_bool_t expire_incomplete_timeout (void *data);

   104 

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

   106 

   107 static DBusLoop*

   108 connection_get_loop (DBusConnection *connection)

   109 {

   110   BusConnectionData *d;

   111 

   112   d = BUS_CONNECTION_DATA (connection);

   113 

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

   115 }

   116 

   117 

   118 static int

   119 get_connections_for_uid (BusConnections *connections,

   120                          dbus_uid_t      uid)

   121 {

   122   void *val;

   123   int current_count;

   124 

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

   126   

   127   val = _dbus_hash_table_lookup_ulong (connections->completed_by_user,

   128                                        uid);

   129 

   130   current_count = _DBUS_POINTER_TO_INT (val);

   131 

   132   return current_count;

   133 }

   134 

   135 static dbus_bool_t

   136 adjust_connections_for_uid (BusConnections *connections,

   137                             dbus_uid_t      uid,

   138                             int             adjustment)

   139 {

   140   int current_count;

   141 

   142   current_count = get_connections_for_uid (connections, uid);

   143 

   144   _dbus_verbose ("Adjusting connection count for UID " DBUS_UID_FORMAT

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

   146                  uid, current_count, adjustment, current_count + adjustment);

   147   

   148   _dbus_assert (current_count >= 0);

   149   

   150   current_count += adjustment;

   151 

   152   _dbus_assert (current_count >= 0);

   153 

   154   if (current_count == 0)

   155     {

   156       _dbus_hash_table_remove_ulong (connections->completed_by_user, uid);

   157       return TRUE;

   158     }

   159   else

   160     {

   161       dbus_bool_t retval;

   162       

   163       retval = _dbus_hash_table_insert_ulong (connections->completed_by_user,

   164                                               uid, _DBUS_INT_TO_POINTER (current_count));

   165 

   166       /* only positive adjustment can fail as otherwise

   167        * a hash entry should already exist

   168        */

   169       _dbus_assert (adjustment > 0 ||

   170                     (adjustment <= 0 && retval));

   171 

   172       return retval;

   173     }

   174 }

   175 

   176 void

   177 bus_connection_disconnected (DBusConnection *connection)

   178 {

   179   BusConnectionData *d;

   180   BusService *service;

   181   BusMatchmaker *matchmaker;

   182   

   183   d = BUS_CONNECTION_DATA (connection);

   184   _dbus_assert (d != NULL);

   185 

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

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

   188 

   189   /* Delete our match rules */

   190   if (d->n_match_rules > 0)

   191     {

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

   193       bus_matchmaker_disconnected (matchmaker, connection);

   194     }

   195   

   196   /* Drop any service ownership. Unfortunately, this requires

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

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

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

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

   201    * involved.

   202    */

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

   204     {

   205       BusTransaction *transaction;

   206       DBusError error;

   207 

   208     retry:

   209       

   210       dbus_error_init (&error);

   211         

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

   213         _dbus_wait_for_memory ();

   214         

   215       if (!bus_service_remove_owner (service, connection,

   216                                      transaction, &error))

   217         {

   218           _DBUS_ASSERT_ERROR_IS_SET (&error);

   219           

   220           if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))

   221             {

   222               dbus_error_free (&error);

   223               bus_transaction_cancel_and_free (transaction);

   224               _dbus_wait_for_memory ();

   225               goto retry;

   226             }

   227           else

   228             {

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

   230                              error.name, error.message);

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

   232             }

   233         }

   234         

   235       bus_transaction_execute_and_free (transaction);

   236     }

   237 

   238   bus_dispatch_remove_connection (connection);

   239   

   240   /* no more watching */

   241   if (!dbus_connection_set_watch_functions (connection,

   242                                             NULL, NULL, NULL,

   243                                             connection,

   244                                             NULL))

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

   246 

   247   if (!dbus_connection_set_timeout_functions (connection,

   248                                               NULL, NULL, NULL,

   249                                               connection,

   250                                               NULL))

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

   252   

   253   dbus_connection_set_unix_user_function (connection,

   254                                           NULL, NULL, NULL);

   255 

   256   dbus_connection_set_dispatch_status_function (connection,

   257                                                 NULL, NULL, NULL);

   258   

   259   bus_connection_remove_transactions (connection);

   260 

   261   if (d->link_in_connection_list != NULL)

   262     {

   263       if (d->name != NULL)

   264         {

   265           unsigned long uid;

   266           

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

   268           d->link_in_connection_list = NULL;

   269           d->connections->n_completed -= 1;

   270 

   271           if (dbus_connection_get_unix_user (connection, &uid))

   272             {

   273               if (!adjust_connections_for_uid (d->connections,

   274                                                uid, -1))

   275                 _dbus_assert_not_reached ("adjusting downward should never fail");

   276             }

   277         }

   278       else

   279         {

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

   281           d->link_in_connection_list = NULL;

   282           d->connections->n_incomplete -= 1;

   283         }

   284       

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

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

   287     }

   288 

   289   bus_connection_drop_pending_replies (d->connections, connection);

   290   

   291   /* frees "d" as side effect */

   292   dbus_connection_set_data (connection,

   293                             connection_data_slot,

   294                             NULL, NULL);

   295   

   296   dbus_connection_unref (connection);

   297 }

   298 

   299 static dbus_bool_t

   300 connection_watch_callback (DBusWatch     *watch,

   301                            unsigned int   condition,

   302                            void          *data)

   303 {

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

   305   * if the code in activation.c for the babysitter

   306   * watch handler is fixed.

   307   */

   308   

   309 #if 0

   310   _dbus_verbose ("Calling handle_watch\n");

   311 #endif

   312   return dbus_watch_handle (watch, condition);

   313 }

   314 

   315 static dbus_bool_t

   316 add_connection_watch (DBusWatch      *watch,

   317                       void           *data)

   318 {

   319   DBusConnection *connection = data;

   320 

   321   return _dbus_loop_add_watch (connection_get_loop (connection),

   322                                watch, connection_watch_callback, connection,

   323                                NULL);

   324 }

   325 

   326 static void

   327 remove_connection_watch (DBusWatch      *watch,

   328                          void           *data)

   329 {

   330   DBusConnection *connection = data;

   331   

   332   _dbus_loop_remove_watch (connection_get_loop (connection),

   333                            watch, connection_watch_callback, connection);

   334 }

   335 

   336 static void

   337 connection_timeout_callback (DBusTimeout   *timeout,

   338                              void          *data)

   339 {

   340   /* DBusConnection *connection = data; */

   341 

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

   343   dbus_timeout_handle (timeout);

   344 }

   345 

   346 static dbus_bool_t

   347 add_connection_timeout (DBusTimeout    *timeout,

   348                         void           *data)

   349 {

   350   DBusConnection *connection = data;

   351   

   352   return _dbus_loop_add_timeout (connection_get_loop (connection),

   353                                  timeout, connection_timeout_callback, connection, NULL);

   354 }

   355 

   356 static void

   357 remove_connection_timeout (DBusTimeout    *timeout,

   358                            void           *data)

   359 {

   360   DBusConnection *connection = data;

   361   

   362   _dbus_loop_remove_timeout (connection_get_loop (connection),

   363                              timeout, connection_timeout_callback, connection);

   364 }

   365 

   366 static void

   367 dispatch_status_function (DBusConnection    *connection,

   368                           DBusDispatchStatus new_status,

   369                           void              *data)

   370 {

   371   DBusLoop *loop = data;

   372   

   373   if (new_status != DBUS_DISPATCH_COMPLETE)

   374     {

   375       while (!_dbus_loop_queue_dispatch (loop, connection))

   376         _dbus_wait_for_memory ();

   377     }

   378 }

   379 

   380 static dbus_bool_t

   381 allow_user_function (DBusConnection *connection,

   382                      unsigned long   uid,

   383                      void           *data)

   384 {

   385   BusConnectionData *d;

   386     

   387   d = BUS_CONNECTION_DATA (connection);

   388 

   389   _dbus_assert (d != NULL);

   390   

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

   392 }

   393 

   394 static void

   395 free_connection_data (void *data)

   396 {

   397   BusConnectionData *d = data;

   398 

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

   400   _dbus_assert (d->services_owned == NULL);

   401   _dbus_assert (d->n_services_owned == 0);

   402   /* similarly */

   403   _dbus_assert (d->transaction_messages == NULL);

   404 

   405   if (d->oom_preallocated)

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

   407 

   408   if (d->oom_message)

   409     dbus_message_unref (d->oom_message);

   410 

   411   if (d->policy)

   412     bus_client_policy_unref (d->policy);

   413 

   414   if (d->selinux_id)

   415     bus_selinux_id_unref (d->selinux_id);

   416   

   417   dbus_free (d->name);

   418   

   419   dbus_free (d);

   420 }

   421 

   422 static void

   423 call_timeout_callback (DBusTimeout   *timeout,

   424                        void          *data)

   425 {

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

   427   dbus_timeout_handle (timeout);

   428 }

   429 

   430 BusConnections*

   431 bus_connections_new (BusContext *context)

   432 {

   433   BusConnections *connections;

   434 

   435   if (!dbus_connection_allocate_data_slot (&connection_data_slot))

   436     goto failed_0;

   437 

   438   connections = dbus_new0 (BusConnections, 1);

   439   if (connections == NULL)

   440     goto failed_1;

   441 

   442   connections->completed_by_user = _dbus_hash_table_new (DBUS_HASH_ULONG,

   443                                                          NULL, NULL);

   444   if (connections->completed_by_user == NULL)

   445     goto failed_2;

   446 

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

   448                                                    expire_incomplete_timeout,

   449                                                    connections, NULL);

   450   if (connections->expire_timeout == NULL)

   451     goto failed_3;

   452 

   453   _dbus_timeout_set_enabled (connections->expire_timeout, FALSE);

   454 

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

   456                                                       bus_context_get_reply_timeout (context),

   457                                                       bus_pending_reply_expired,

   458                                                       connections);

   459   if (connections->pending_replies == NULL)

   460     goto failed_4;

   461   

   462   if (!_dbus_loop_add_timeout (bus_context_get_loop (context),

   463                                connections->expire_timeout,

   464                                call_timeout_callback, NULL, NULL))

   465     goto failed_5;

   466   

   467   connections->refcount = 1;

   468   connections->context = context;

   469   

   470   return connections;

   471 

   472  failed_5:

   473   bus_expire_list_free (connections->pending_replies);

   474  failed_4:

   475   _dbus_timeout_unref (connections->expire_timeout);

   476  failed_3:

   477   _dbus_hash_table_unref (connections->completed_by_user);

   478  failed_2:

   479   dbus_free (connections);

   480  failed_1:

   481   dbus_connection_free_data_slot (&connection_data_slot);

   482  failed_0:

   483   return NULL;

   484 }

   485 

   486 BusConnections *

   487 bus_connections_ref (BusConnections *connections)

   488 {

   489   _dbus_assert (connections->refcount > 0);

   490   connections->refcount += 1;

   491 

   492   return connections;

   493 }

   494 

   495 void

   496 bus_connections_unref (BusConnections *connections)

   497 {

   498   _dbus_assert (connections->refcount > 0);

   499   connections->refcount -= 1;

   500   if (connections->refcount == 0)

   501     {

   502       /* drop all incomplete */

   503       while (connections->incomplete != NULL)

   504         {

   505           DBusConnection *connection;

   506 

   507           connection = connections->incomplete->data;

   508 

   509           dbus_connection_ref (connection);

   510           dbus_connection_close (connection);

   511           bus_connection_disconnected (connection);

   512           dbus_connection_unref (connection);

   513         }

   514 

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

   516       

   517       /* drop all real connections */

   518       while (connections->completed != NULL)

   519         {

   520           DBusConnection *connection;

   521 

   522           connection = connections->completed->data;

   523 

   524           dbus_connection_ref (connection);

   525           dbus_connection_close (connection);

   526           bus_connection_disconnected (connection);

   527           dbus_connection_unref (connection);

   528         }

   529 

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

   531 

   532       bus_expire_list_free (connections->pending_replies);

   533       

   534       _dbus_loop_remove_timeout (bus_context_get_loop (connections->context),

   535                                  connections->expire_timeout,

   536                                  call_timeout_callback, NULL);

   537       

   538       _dbus_timeout_unref (connections->expire_timeout);

   539       

   540       _dbus_hash_table_unref (connections->completed_by_user);

   541       

   542       dbus_free (connections);

   543 

   544       dbus_connection_free_data_slot (&connection_data_slot);

   545     }

   546 }

   547 

   548 dbus_bool_t

   549 bus_connections_setup_connection (BusConnections *connections,

   550                                   DBusConnection *connection)

   551 {

   552   BusConnectionData *d;

   553   dbus_bool_t retval;

   554   DBusError error;

   555   

   556   d = dbus_new0 (BusConnectionData, 1);

   557   

   558   if (d == NULL)

   559     return FALSE;

   560 

   561   d->connections = connections;

   562   d->connection = connection;

   563   

   564   _dbus_get_current_time (&d->connection_tv_sec,

   565                           &d->connection_tv_usec);

   566   

   567   _dbus_assert (connection_data_slot >= 0);

   568   

   569   if (!dbus_connection_set_data (connection,

   570                                  connection_data_slot,

   571                                  d, free_connection_data))

   572     {

   573       dbus_free (d);

   574       return FALSE;

   575     }

   576 

   577   dbus_connection_set_route_peer_messages (connection, TRUE);

   578   

   579   retval = FALSE;

   580 

   581   dbus_error_init (&error);

   582   d->selinux_id = bus_selinux_init_connection_id (connection,

   583                                                   &error);

   584   if (dbus_error_is_set (&error))

   585     {

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

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

   588        * an OOM error disconnects the connection, which is

   589        * the same thing we want on any other error.

   590        */

   591       dbus_error_free (&error);

   592       goto out;

   593     }

   594   

   595   if (!dbus_connection_set_watch_functions (connection,

   596                                             add_connection_watch,

   597                                             remove_connection_watch,

   598                                             NULL,

   599                                             connection,

   600                                             NULL))

   601     goto out;

   602   

   603   if (!dbus_connection_set_timeout_functions (connection,

   604                                               add_connection_timeout,

   605                                               remove_connection_timeout,

   606                                               NULL,

   607                                               connection, NULL))

   608     goto out;

   609   

   610   dbus_connection_set_unix_user_function (connection,

   611                                           allow_user_function,

   612                                           NULL, NULL);

   613 

   614   dbus_connection_set_dispatch_status_function (connection,

   615                                                 dispatch_status_function,

   616                                                 bus_context_get_loop (connections->context),

   617                                                 NULL);

   618 

   619   d->link_in_connection_list = _dbus_list_alloc_link (connection);

   620   if (d->link_in_connection_list == NULL)

   621     goto out;

   622   

   623   /* Setup the connection with the dispatcher */

   624   if (!bus_dispatch_add_connection (connection))

   625     goto out;

   626 

   627   if (dbus_connection_get_dispatch_status (connection) != DBUS_DISPATCH_COMPLETE)

   628     {

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

   630         {

   631           bus_dispatch_remove_connection (connection);

   632           goto out;

   633         }

   634     }

   635 

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

   637   connections->n_incomplete += 1;

   638   

   639   dbus_connection_ref (connection);

   640 

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

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

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

   644    * own expiration.

   645    */

   646   bus_connections_expire_incomplete (connections);

   647   

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

   649    * only takes effect on return to main loop.

   650    */

   651   if (connections->n_incomplete >

   652       bus_context_get_max_incomplete_connections (connections->context))

   653     {

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

   655       

   656       _dbus_assert (connections->incomplete != NULL);

   657       /* Disconnect the oldest unauthenticated connection.  FIXME

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

   659        * algorithm seems to mean that if someone can create new

   660        * connections quickly enough, they can keep anyone else from

   661        * completing authentication. But random may or may not really

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

   663        */

   664       dbus_connection_close (connections->incomplete->data);

   665     }

   666   

   667   retval = TRUE;

   668 

   669  out:

   670   if (!retval)

   671     {

   672       if (d->selinux_id)

   673         bus_selinux_id_unref (d->selinux_id);

   674       d->selinux_id = NULL;

   675       

   676       if (!dbus_connection_set_watch_functions (connection,

   677                                                 NULL, NULL, NULL,

   678                                                 connection,

   679                                                 NULL))

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

   681       

   682       if (!dbus_connection_set_timeout_functions (connection,

   683                                                   NULL, NULL, NULL,

   684                                                   connection,

   685                                                   NULL))

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

   687 

   688       dbus_connection_set_unix_user_function (connection,

   689                                               NULL, NULL, NULL);

   690 

   691       dbus_connection_set_dispatch_status_function (connection,

   692                                                     NULL, NULL, NULL);

   693 

   694       if (d->link_in_connection_list != NULL)

   695         {

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

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

   698           _dbus_list_free_link (d->link_in_connection_list);

   699           d->link_in_connection_list = NULL;

   700         }

   701       

   702       if (!dbus_connection_set_data (connection,

   703                                      connection_data_slot,

   704                                      NULL, NULL))

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

   706 

   707       /* "d" has now been freed */

   708     }

   709   

   710   return retval;

   711 }

   712 

   713 void

   714 bus_connections_expire_incomplete (BusConnections *connections)

   715 {    

   716   int next_interval;

   717 

   718   next_interval = -1;

   719   

   720   if (connections->incomplete != NULL)

   721     {

   722       long tv_sec, tv_usec;

   723       DBusList *link;

   724       int auth_timeout;

   725       

   726       _dbus_get_current_time (&tv_sec, &tv_usec);

   727       auth_timeout = bus_context_get_auth_timeout (connections->context);

   728   

   729       link = _dbus_list_get_first_link (&connections->incomplete);

   730       while (link != NULL)

   731         {

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

   733           DBusConnection *connection;

   734           BusConnectionData *d;

   735           double elapsed;

   736       

   737           connection = link->data;

   738       

   739           d = BUS_CONNECTION_DATA (connection);

   740       

   741           _dbus_assert (d != NULL);

   742       

   743           elapsed = ELAPSED_MILLISECONDS_SINCE (d->connection_tv_sec,

   744                                                 d->connection_tv_usec,

   745                                                 tv_sec, tv_usec);

   746 

   747           if (elapsed >= (double) auth_timeout)

   748             {

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

   750               dbus_connection_close (connection);

   751             }

   752           else

   753             {

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

   755               next_interval = ((double)auth_timeout) - elapsed;

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

   757                              connection, next_interval);

   758           

   759               break;

   760             }

   761       

   762           link = next;

   763         }

   764     }

   765 

   766   bus_expire_timeout_set_interval (connections->expire_timeout,

   767                                    next_interval);

   768 }

   769 

   770 static dbus_bool_t

   771 expire_incomplete_timeout (void *data)

   772 {

   773   BusConnections *connections = data;

   774 

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

   776   

   777   /* note that this may remove the timeout */

   778   bus_connections_expire_incomplete (connections);

   779 

   780   return TRUE;

   781 }

   782 

   783 dbus_bool_t

   784 bus_connection_get_groups  (DBusConnection   *connection,

   785                             unsigned long   **groups,

   786                             int              *n_groups,

   787                             DBusError        *error)

   788 {

   789   BusConnectionData *d;

   790   unsigned long uid;

   791   DBusUserDatabase *user_database;

   792   

   793   d = BUS_CONNECTION_DATA (connection);

   794 

   795   _dbus_assert (d != NULL);

   796 

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

   798   

   799   *groups = NULL;

   800   *n_groups = 0;

   801 

   802   if (dbus_connection_get_unix_user (connection, &uid))

   803     {

   804       if (!_dbus_user_database_get_groups (user_database,

   805                                            uid, groups, n_groups,

   806                                            error))

   807         {

   808           _DBUS_ASSERT_ERROR_IS_SET (error);

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

   810                          uid);

   811           return FALSE;

   812         }

   813       else

   814         {

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

   816                          *n_groups, uid);

   817           return TRUE;

   818         }

   819     }

   820   else

   821     return TRUE; /* successfully got 0 groups */

   822 }

   823 

   824 dbus_bool_t

   825 bus_connection_is_in_group (DBusConnection *connection,

   826                             unsigned long   gid)

   827 {

   828   int i;

   829   unsigned long *group_ids;

   830   int n_group_ids;

   831 

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

   833                                   NULL))

   834     return FALSE;

   835 

   836   i = 0;

   837   while (i < n_group_ids)

   838     {

   839       if (group_ids[i] == gid)

   840         {

   841           dbus_free (group_ids);

   842           return TRUE;

   843         }

   844       ++i;

   845     }

   846 

   847   dbus_free (group_ids);

   848   return FALSE;

   849 }

   850 

   851 BusClientPolicy*

   852 bus_connection_get_policy (DBusConnection *connection)

   853 {

   854   BusConnectionData *d;

   855     

   856   d = BUS_CONNECTION_DATA (connection);

   857 

   858   _dbus_assert (d != NULL);

   859   _dbus_assert (d->policy != NULL);

   860   

   861   return d->policy;

   862 }

   863 

   864 static dbus_bool_t

   865 foreach_active (BusConnections               *connections,

   866                 BusConnectionForeachFunction  function,

   867                 void                         *data)

   868 {

   869   DBusList *link;

   870   

   871   link = _dbus_list_get_first_link (&connections->completed);

   872   while (link != NULL)

   873     {

   874       DBusConnection *connection = link->data;

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

   876 

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

   878         return FALSE;

   879       

   880       link = next;

   881     }

   882 

   883   return TRUE;

   884 }

   885 

   886 static dbus_bool_t

   887 foreach_inactive (BusConnections               *connections,

   888                   BusConnectionForeachFunction  function,

   889                   void                         *data)

   890 {

   891   DBusList *link;

   892   

   893   link = _dbus_list_get_first_link (&connections->incomplete);

   894   while (link != NULL)

   895     {

   896       DBusConnection *connection = link->data;

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

   898 

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

   900         return FALSE;

   901       

   902       link = next;

   903     }

   904 

   905   return TRUE;

   906 }

   907 

   908 /**

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

   910  * #FALSE, stops iterating. Active connections are authenticated

   911  * and have sent a Hello message.

   912  *

   913  * @param connections the connections object

   914  * @param function the function

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

   916  */

   917 void

   918 bus_connections_foreach_active (BusConnections               *connections,

   919                                 BusConnectionForeachFunction  function,

   920                                 void                         *data)

   921 {

   922   foreach_active (connections, function, data);

   923 }

   924 

   925 /**

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

   927  * #FALSE, stops iterating.

   928  *

   929  * @param connections the connections object

   930  * @param function the function

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

   932  */

   933 void

   934 bus_connections_foreach (BusConnections               *connections,

   935                          BusConnectionForeachFunction  function,

   936                          void                         *data)

   937 {

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

   939     return;

   940 

   941   foreach_inactive (connections, function, data);

   942 }

   943 

   944 BusContext*

   945 bus_connections_get_context (BusConnections *connections)

   946 {

   947   return connections->context;

   948 }

   949 

   950 /*

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

   952  * traversing connections. Note that it assumes we will

   953  * bus_connection_mark_stamp() each connection at least once per

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

   955  * things.

   956  */

   957 void

   958 bus_connections_increment_stamp (BusConnections *connections)

   959 {

   960   connections->stamp += 1;

   961 }

   962 

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

   964  * didn't already have that stamp

   965  */

   966 dbus_bool_t

   967 bus_connection_mark_stamp (DBusConnection *connection)

   968 {

   969   BusConnectionData *d;

   970   

   971   d = BUS_CONNECTION_DATA (connection);

   972   

   973   _dbus_assert (d != NULL);

   974 

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

   976     return FALSE;

   977   else

   978     {

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

   980       return TRUE;

   981     }

   982 }

   983 

   984 BusContext*

   985 bus_connection_get_context (DBusConnection *connection)

   986 {

   987   BusConnectionData *d;

   988 

   989   d = BUS_CONNECTION_DATA (connection);

   990 

   991   _dbus_assert (d != NULL);

   992 

   993   return d->connections->context;

   994 }

   995 

   996 BusConnections*

   997 bus_connection_get_connections (DBusConnection *connection)

   998 {

   999   BusConnectionData *d;

  1000     

  1001   d = BUS_CONNECTION_DATA (connection);

  1002 

  1003   _dbus_assert (d != NULL);

  1004 

  1005   return d->connections;

  1006 }

  1007 

  1008 BusRegistry*

  1009 bus_connection_get_registry (DBusConnection *connection)

  1010 {

  1011   BusConnectionData *d;

  1012 

  1013   d = BUS_CONNECTION_DATA (connection);

  1014 

  1015   _dbus_assert (d != NULL);

  1016 

  1017   return bus_context_get_registry (d->connections->context);

  1018 }

  1019 

  1020 BusActivation*

  1021 bus_connection_get_activation (DBusConnection *connection)

  1022 {

  1023   BusConnectionData *d;

  1024 

  1025   d = BUS_CONNECTION_DATA (connection);

  1026 

  1027   _dbus_assert (d != NULL);

  1028 

  1029   return bus_context_get_activation (d->connections->context);

  1030 }

  1031 

  1032 BusMatchmaker*

  1033 bus_connection_get_matchmaker (DBusConnection *connection)

  1034 {

  1035   BusConnectionData *d;

  1036 

  1037   d = BUS_CONNECTION_DATA (connection);

  1038 

  1039   _dbus_assert (d != NULL);

  1040 

  1041   return bus_context_get_matchmaker (d->connections->context);

  1042 }

  1043 

  1044 BusSELinuxID*

  1045 bus_connection_get_selinux_id (DBusConnection *connection)

  1046 {

  1047   BusConnectionData *d;

  1048 

  1049   d = BUS_CONNECTION_DATA (connection);

  1050 

  1051   _dbus_assert (d != NULL);

  1052 

  1053   return d->selinux_id;

  1054 }

  1055 

  1056 /**

  1057  * Checks whether the connection is registered with the message bus.

  1058  *

  1059  * @param connection the connection

  1060  * @returns #TRUE if we're an active message bus participant

  1061  */

  1062 dbus_bool_t

  1063 bus_connection_is_active (DBusConnection *connection)

  1064 {

  1065   BusConnectionData *d;

  1066 

  1067   d = BUS_CONNECTION_DATA (connection);

  1068   

  1069   return d != NULL && d->name != NULL;

  1070 }

  1071 

  1072 dbus_bool_t

  1073 bus_connection_preallocate_oom_error (DBusConnection *connection)

  1074 {

  1075   DBusMessage *message;

  1076   DBusPreallocatedSend *preallocated;

  1077   BusConnectionData *d;

  1078 

  1079   d = BUS_CONNECTION_DATA (connection);  

  1080 

  1081   _dbus_assert (d != NULL);

  1082 

  1083   if (d->oom_preallocated != NULL)

  1084     return TRUE;

  1085   

  1086   preallocated = dbus_connection_preallocate_send (connection);

  1087   if (preallocated == NULL)

  1088     return FALSE;

  1089 

  1090   message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);

  1091 

  1092   if (message == NULL)

  1093     {

  1094       dbus_connection_free_preallocated_send (connection, preallocated);

  1095       return FALSE;

  1096     }

  1097 

  1098   /* d->name may be NULL, but that is OK */

  1099   if (!dbus_message_set_error_name (message, DBUS_ERROR_NO_MEMORY) ||

  1100       !dbus_message_set_destination (message, d->name) ||

  1101       !dbus_message_set_sender (message,

  1102                                 DBUS_SERVICE_DBUS))

  1103     {

  1104       dbus_connection_free_preallocated_send (connection, preallocated);

  1105       dbus_message_unref (message);

  1106       return FALSE;

  1107     }

  1108   

  1109   /* set reply serial to placeholder value just so space is already allocated

  1110    * for it.

  1111    */

  1112   if (!dbus_message_set_reply_serial (message, 14))

  1113     {

  1114       dbus_connection_free_preallocated_send (connection, preallocated);

  1115       dbus_message_unref (message);

  1116       return FALSE;

  1117     }

  1118 

  1119   d->oom_message = message;

  1120   d->oom_preallocated = preallocated;

  1121   

  1122   return TRUE;

  1123 }

  1124 

  1125 void

  1126 bus_connection_send_oom_error (DBusConnection *connection,

  1127                                DBusMessage    *in_reply_to)

  1128 {

  1129   BusConnectionData *d;

  1130 

  1131   d = BUS_CONNECTION_DATA (connection);  

  1132 

  1133   _dbus_assert (d != NULL);  

  1134   _dbus_assert (d->oom_message != NULL);

  1135