Main Page | Modules | Data Structures | File List | Data Fields | Related Pages

dbus-bus.c

00001 /* -*- mode: C; c-file-style: "gnu" -*- */
00002 /* dbus-bus.c  Convenience functions for communicating with the bus.
00003  *
00004  * Copyright (C) 2003  CodeFactory AB
00005  * Copyright (C) 2003  Red Hat, Inc.
00006  *
00007  * Licensed under the Academic Free License version 2.1
00008  * 
00009  * This program is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version.
00013  *
00014  * This program is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  * 
00019  * You should have received a copy of the GNU General Public License
00020  * along with this program; if not, write to the Free Software
00021  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022  *
00023  */
00024 
00025 #include "dbus-bus.h"
00026 #include "dbus-protocol.h"
00027 #include "dbus-internals.h"
00028 #include "dbus-message.h"
00029 #include <string.h>
00030 
00061 typedef struct
00062 {
00063   DBusConnection *connection; 
00064   char *base_service; 
00066   unsigned int is_well_known : 1; 
00067 } BusData;
00068 
00071 static dbus_int32_t bus_data_slot = -1;
00072 
00074 #define N_BUS_TYPES 3
00075 
00076 static DBusConnection *bus_connections[N_BUS_TYPES];
00077 static char *bus_connection_addresses[N_BUS_TYPES] = { NULL, NULL, NULL };
00078 
00079 static DBusBusType activation_bus_type = DBUS_BUS_ACTIVATION;
00080 
00081 static dbus_bool_t initialized = FALSE;
00082 
00086 _DBUS_DEFINE_GLOBAL_LOCK (bus);
00087 
00088 static void
00089 addresses_shutdown_func (void *data)
00090 {
00091   int i;
00092 
00093   i = 0;
00094   while (i < N_BUS_TYPES)
00095     {
00096       if (bus_connections[i] != NULL)
00097         _dbus_warn ("dbus_shutdown() called but connections were still live!");
00098       
00099       dbus_free (bus_connection_addresses[i]);
00100       bus_connection_addresses[i] = NULL;
00101       ++i;
00102     }
00103 
00104   activation_bus_type = DBUS_BUS_ACTIVATION;
00105 }
00106 
00107 static dbus_bool_t
00108 get_from_env (char           **connection_p,
00109               const char      *env_var)
00110 {
00111   const char *s;
00112   
00113   _dbus_assert (*connection_p == NULL);
00114   
00115   s = _dbus_getenv (env_var);
00116   if (s == NULL || *s == '\0')
00117     return TRUE; /* successfully didn't use the env var */
00118   else
00119     {
00120       *connection_p = _dbus_strdup (s);
00121       return *connection_p != NULL;
00122     }
00123 }
00124 
00125 static dbus_bool_t
00126 init_connections_unlocked (void)
00127 {
00128   if (!initialized)
00129     {
00130       const char *s;
00131       int i;
00132 
00133       i = 0;
00134       while (i < N_BUS_TYPES)
00135         {
00136           bus_connections[i] = NULL;
00137           ++i;
00138         }
00139 
00140       /* Don't init these twice, we may run this code twice if
00141        * init_connections_unlocked() fails midway through.
00142        * In practice, each block below should contain only one
00143        * "return FALSE" or running through twice may not
00144        * work right.
00145        */
00146       
00147        if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00148          {
00149            _dbus_verbose ("Filling in system bus address...\n");
00150            
00151            if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM],
00152                               "DBUS_SYSTEM_BUS_ADDRESS"))
00153              return FALSE;
00154          }
00155 
00156                   
00157        if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00158          {
00159            /* Use default system bus address if none set in environment */
00160            bus_connection_addresses[DBUS_BUS_SYSTEM] =
00161              _dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS);
00162            if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
00163              return FALSE;
00164            
00165            _dbus_verbose ("  used default system bus \"%s\"\n",
00166                           bus_connection_addresses[DBUS_BUS_SYSTEM]);
00167          }
00168        else
00169          _dbus_verbose ("  used env var system bus \"%s\"\n",
00170                         bus_connection_addresses[DBUS_BUS_SYSTEM]);
00171           
00172       if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
00173         {
00174           _dbus_verbose ("Filling in session bus address...\n");
00175           
00176           if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION],
00177                              "DBUS_SESSION_BUS_ADDRESS"))
00178             return FALSE;
00179           _dbus_verbose ("  \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?
00180                          bus_connection_addresses[DBUS_BUS_SESSION] : "none set");
00181         }
00182 
00183       if (bus_connection_addresses[DBUS_BUS_ACTIVATION] == NULL)
00184         {
00185           _dbus_verbose ("Filling in activation bus address...\n");
00186           
00187           if (!get_from_env (&bus_connection_addresses[DBUS_BUS_ACTIVATION],
00188                              "DBUS_ACTIVATION_ADDRESS"))
00189             return FALSE;
00190           
00191           _dbus_verbose ("  \"%s\"\n", bus_connection_addresses[DBUS_BUS_ACTIVATION] ?
00192                          bus_connection_addresses[DBUS_BUS_ACTIVATION] : "none set");
00193         }
00194 
00195 
00196       if (bus_connection_addresses[DBUS_BUS_ACTIVATION] != NULL)
00197         {
00198           s = _dbus_getenv ("DBUS_ACTIVATION_BUS_TYPE");
00199               
00200           if (s != NULL)
00201             {
00202               _dbus_verbose ("Bus activation type was set to \"%s\"\n", s);
00203                   
00204               if (strcmp (s, "system") == 0)
00205                 activation_bus_type = DBUS_BUS_SYSTEM;
00206               else if (strcmp (s, "session") == 0)
00207                 activation_bus_type = DBUS_BUS_SESSION;
00208             }
00209         }
00210       else
00211         {
00212           /* Default to the session bus instead if available */
00213           if (bus_connection_addresses[DBUS_BUS_SESSION] != NULL)
00214             {
00215               bus_connection_addresses[DBUS_BUS_ACTIVATION] =
00216                 _dbus_strdup (bus_connection_addresses[DBUS_BUS_SESSION]);
00217               if (bus_connection_addresses[DBUS_BUS_ACTIVATION] == NULL)
00218                 return FALSE;
00219             }
00220         }
00221       
00222       /* If we return FALSE we have to be sure that restarting
00223        * the above code will work right
00224        */
00225       
00226       if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", NULL))
00227         return FALSE;
00228 
00229       if (!_dbus_setenv ("DBUS_ACTIVATION_BUS_TYPE", NULL))
00230         return FALSE;
00231       
00232       if (!_dbus_register_shutdown_func (addresses_shutdown_func,
00233                                          NULL))
00234         return FALSE;
00235       
00236       initialized = TRUE;
00237     }
00238 
00239   return initialized;
00240 }
00241 
00242 static void
00243 bus_data_free (void *data)
00244 {
00245   BusData *bd = data;
00246   
00247   if (bd->is_well_known)
00248     {
00249       int i;
00250       _DBUS_LOCK (bus);
00251       /* We may be stored in more than one slot */
00252       i = 0;
00253       while (i < N_BUS_TYPES)
00254         {
00255           if (bus_connections[i] == bd->connection)
00256             bus_connections[i] = NULL;
00257           
00258           ++i;
00259         }
00260       _DBUS_UNLOCK (bus);
00261     }
00262   
00263   dbus_free (bd->base_service);
00264   dbus_free (bd);
00265 
00266   dbus_connection_free_data_slot (&bus_data_slot);
00267 }
00268 
00269 static BusData*
00270 ensure_bus_data (DBusConnection *connection)
00271 {
00272   BusData *bd;
00273 
00274   if (!dbus_connection_allocate_data_slot (&bus_data_slot))
00275     return NULL;
00276 
00277   bd = dbus_connection_get_data (connection, bus_data_slot);
00278   if (bd == NULL)
00279     {      
00280       bd = dbus_new0 (BusData, 1);
00281       if (bd == NULL)
00282         {
00283           dbus_connection_free_data_slot (&bus_data_slot);
00284           return NULL;
00285         }
00286 
00287       bd->connection = connection;
00288       
00289       if (!dbus_connection_set_data (connection, bus_data_slot, bd,
00290                                      bus_data_free))
00291         {
00292           dbus_free (bd);
00293           dbus_connection_free_data_slot (&bus_data_slot);
00294           return NULL;
00295         }
00296 
00297       /* Data slot refcount now held by the BusData */
00298     }
00299   else
00300     {
00301       dbus_connection_free_data_slot (&bus_data_slot);
00302     }
00303 
00304   return bd;
00305 }
00306  /* end of implementation details docs */
00308 
00324 DBusConnection *
00325 dbus_bus_get (DBusBusType  type,
00326               DBusError   *error)
00327 {
00328   const char *address;
00329   DBusConnection *connection;
00330   BusData *bd;
00331   DBusBusType address_type;
00332 
00333   _dbus_return_val_if_fail (type >= 0 && type < N_BUS_TYPES, NULL);
00334   _dbus_return_val_if_error_is_set (error, NULL);
00335 
00336   _DBUS_LOCK (bus);
00337 
00338   if (!init_connections_unlocked ())
00339     {
00340       _DBUS_UNLOCK (bus);
00341       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
00342       return NULL;
00343     }
00344 
00345   /* We want to use the activation address even if the
00346    * activating bus is the session or system bus,
00347    * per the spec.
00348    */
00349   address_type = type;
00350   
00351   /* Use the real type of the activation bus for getting its
00352    * connection, but only if the real type's address is available. (If
00353    * the activating bus isn't a well-known bus then
00354    * activation_bus_type == DBUS_BUS_ACTIVATION)
00355    */
00356   if (type == DBUS_BUS_ACTIVATION &&
00357       bus_connection_addresses[activation_bus_type] != NULL)
00358     type = activation_bus_type;
00359   
00360   if (bus_connections[type] != NULL)
00361     {
00362       connection = bus_connections[type];
00363       dbus_connection_ref (connection);
00364       
00365       _DBUS_UNLOCK (bus);
00366       return connection;
00367     }
00368 
00369   address = bus_connection_addresses[address_type];
00370   if (address == NULL)
00371     {
00372       dbus_set_error (error, DBUS_ERROR_FAILED,
00373                       "Unable to determine the address of the message bus");
00374       _DBUS_UNLOCK (bus);
00375       return NULL;
00376     }
00377 
00378   connection = dbus_connection_open (address, error);
00379   
00380   if (!connection)
00381     {
00382       _DBUS_ASSERT_ERROR_IS_SET (error);
00383       _DBUS_UNLOCK (bus);
00384       return NULL;
00385     }
00386 
00387   /* By default we're bound to the lifecycle of
00388    * the message bus.
00389    */
00390   dbus_connection_set_exit_on_disconnect (connection,
00391                                           TRUE);
00392   
00393   if (!dbus_bus_register (connection, error))
00394     {
00395       _DBUS_ASSERT_ERROR_IS_SET (error);
00396       dbus_connection_disconnect (connection);
00397       dbus_connection_unref (connection);
00398 
00399       _DBUS_UNLOCK (bus);
00400       return NULL;
00401     }
00402 
00403   bus_connections[type] = connection;
00404   bd = ensure_bus_data (connection);
00405   _dbus_assert (bd != NULL);
00406 
00407   bd->is_well_known = TRUE;
00408 
00409   _DBUS_UNLOCK (bus);
00410   return connection;
00411 }
00412 
00413 
00427 dbus_bool_t
00428 dbus_bus_register (DBusConnection *connection,
00429                    DBusError      *error)
00430 {
00431   DBusMessage *message, *reply;
00432   char *name;
00433   BusData *bd;
00434   dbus_bool_t retval;
00435 
00436   _dbus_return_val_if_fail (connection != NULL, FALSE);
00437   _dbus_return_val_if_error_is_set (error, FALSE);
00438 
00439   retval = FALSE;
00440   
00441   bd = ensure_bus_data (connection);
00442   if (bd == NULL)
00443     {
00444       _DBUS_SET_OOM (error);
00445       return FALSE;
00446     }
00447 
00448   if (bd->base_service != NULL)
00449     {
00450       _dbus_warn ("Attempt to register the same DBusConnection with the message bus, but it is already registered\n");
00451       /* This isn't an error, it's a programming bug. We'll be nice
00452        * and not _dbus_assert_not_reached()
00453        */
00454       return TRUE;
00455     }
00456   
00457   message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00458                                           DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00459                                           DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00460                                           "Hello"); 
00461 
00462   if (!message)
00463     {
00464       _DBUS_SET_OOM (error);
00465       return FALSE;
00466     }
00467   
00468   reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
00469 
00470   dbus_message_unref (message);
00471   
00472   if (reply == NULL)
00473     goto out;
00474   else if (dbus_set_error_from_message (error, reply))
00475     goto out;
00476   else if (!dbus_message_get_args (reply, error,
00477                                    DBUS_TYPE_STRING, &name,
00478                                    DBUS_TYPE_INVALID))
00479     goto out;
00480   
00481   bd->base_service = name;
00482 
00483   retval = TRUE;
00484   
00485  out:
00486   if (reply)
00487     dbus_message_unref (reply);
00488 
00489   if (!retval)
00490     _DBUS_ASSERT_ERROR_IS_SET (error);
00491   
00492   return retval;
00493 }
00494 
00495 
00507 dbus_bool_t
00508 dbus_bus_set_base_service (DBusConnection *connection,
00509                            const char     *base_service)
00510 {
00511   BusData *bd;
00512 
00513   _dbus_return_val_if_fail (connection != NULL, FALSE);
00514   _dbus_return_val_if_fail (base_service != NULL, FALSE);
00515   
00516   bd = ensure_bus_data (connection);
00517   if (bd == NULL)
00518     return FALSE;
00519 
00520   _dbus_assert (bd->base_service == NULL);
00521   
00522   bd->base_service = _dbus_strdup (base_service);
00523   return bd->base_service != NULL;
00524 }
00525 
00534 const char*
00535 dbus_bus_get_base_service (DBusConnection *connection)
00536 {
00537   BusData *bd;
00538 
00539   _dbus_return_val_if_fail (connection != NULL, NULL);
00540   
00541   bd = ensure_bus_data (connection);
00542   if (bd == NULL)
00543     return NULL;
00544   
00545   return bd->base_service;
00546 }
00547 
00556 unsigned long
00557 dbus_bus_get_unix_user (DBusConnection *connection,
00558                         const char     *service,
00559                         DBusError      *error)
00560 {
00561   DBusMessage *message, *reply;
00562   dbus_uint32_t uid;
00563 
00564   _dbus_return_val_if_fail (connection != NULL, DBUS_UID_UNSET);
00565   _dbus_return_val_if_fail (service != NULL, DBUS_UID_UNSET);
00566   _dbus_return_val_if_error_is_set (error, DBUS_UID_UNSET);
00567   
00568   message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00569                                           DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00570                                           DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00571                                           "GetConnectionUnixUser");
00572 
00573   if (message == NULL)
00574     {
00575       _DBUS_SET_OOM (error);
00576       return DBUS_UID_UNSET;
00577     }
00578  
00579   if (!dbus_message_append_args (message,
00580                                  DBUS_TYPE_STRING, service,
00581                                  DBUS_TYPE_INVALID))
00582     {
00583       dbus_message_unref (message);
00584       _DBUS_SET_OOM (error);
00585       return DBUS_UID_UNSET;
00586     }
00587   
00588   reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
00589                                                      error);
00590   
00591   dbus_message_unref (message);
00592   
00593   if (reply == NULL)
00594     {
00595       _DBUS_ASSERT_ERROR_IS_SET (error);
00596       return DBUS_UID_UNSET;
00597     }  
00598 
00599   if (dbus_set_error_from_message (error, reply))
00600     {
00601       _DBUS_ASSERT_ERROR_IS_SET (error);
00602       dbus_message_unref (reply);
00603       return DBUS_UID_UNSET;
00604     }
00605   
00606   if (!dbus_message_get_args (reply, error,
00607                               DBUS_TYPE_UINT32, &uid,
00608                               DBUS_TYPE_INVALID))
00609     {
00610       _DBUS_ASSERT_ERROR_IS_SET (error);
00611       dbus_message_unref (reply);
00612       return DBUS_UID_UNSET;
00613     }
00614 
00615   dbus_message_unref (reply);
00616   
00617   return (unsigned long) uid;
00618 }
00619 
00620 
00636 int
00637 dbus_bus_acquire_service (DBusConnection *connection,
00638                           const char     *service_name,
00639                           unsigned int    flags,
00640                           DBusError      *error)
00641 {
00642   DBusMessage *message, *reply;
00643   dbus_uint32_t service_result;
00644 
00645   _dbus_return_val_if_fail (connection != NULL, 0);
00646   _dbus_return_val_if_fail (service_name != NULL, 0);
00647   _dbus_return_val_if_error_is_set (error, 0);
00648   
00649   message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00650                                           DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00651                                           DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00652                                           "AcquireService");
00653 
00654   if (message == NULL)
00655     {
00656       _DBUS_SET_OOM (error);
00657       return -1;
00658     }
00659  
00660   if (!dbus_message_append_args (message,
00661                                  DBUS_TYPE_STRING, service_name,
00662                                  DBUS_TYPE_UINT32, flags,
00663                                  DBUS_TYPE_INVALID))
00664     {
00665       dbus_message_unref (message);
00666       _DBUS_SET_OOM (error);
00667       return -1;
00668     }
00669   
00670   reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
00671                                                      error);
00672   
00673   dbus_message_unref (message);
00674   
00675   if (reply == NULL)
00676     {
00677       _DBUS_ASSERT_ERROR_IS_SET (error);
00678       return -1;
00679     }  
00680 
00681   if (dbus_set_error_from_message (error, reply))
00682     {
00683       _DBUS_ASSERT_ERROR_IS_SET (error);
00684       dbus_message_unref (reply);
00685       return -1;
00686     }
00687   
00688   if (!dbus_message_get_args (reply, error,
00689                               DBUS_TYPE_UINT32, &service_result,
00690                               DBUS_TYPE_INVALID))
00691     {
00692       _DBUS_ASSERT_ERROR_IS_SET (error);
00693       dbus_message_unref (reply);
00694       return -1;
00695     }
00696 
00697   dbus_message_unref (reply);
00698   
00699   return service_result;
00700 }
00701 
00710 dbus_bool_t
00711 dbus_bus_service_exists (DBusConnection *connection,
00712                          const char     *service_name,
00713                          DBusError      *error)
00714 {
00715   DBusMessage *message, *reply;
00716   dbus_bool_t exists;
00717 
00718   _dbus_return_val_if_fail (connection != NULL, FALSE);
00719   _dbus_return_val_if_fail (service_name != NULL, FALSE);
00720   _dbus_return_val_if_error_is_set (error, FALSE);
00721   
00722   message = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00723                                           DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00724                                           DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00725                                           "ServiceExists");
00726   if (message == NULL)
00727     {
00728       _DBUS_SET_OOM (error);
00729       return FALSE;
00730     }
00731   
00732   if (!dbus_message_append_args (message,
00733                                  DBUS_TYPE_STRING, service_name,
00734                                  DBUS_TYPE_INVALID))
00735     {
00736       dbus_message_unref (message);
00737       _DBUS_SET_OOM (error);
00738       return FALSE;
00739     }
00740   
00741   reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
00742   dbus_message_unref (message);
00743 
00744   if (reply == NULL)
00745     {
00746       _DBUS_ASSERT_ERROR_IS_SET (error);
00747       return FALSE;
00748     }
00749 
00750   if (!dbus_message_get_args (reply, error,
00751                               DBUS_TYPE_BOOLEAN, &exists,
00752                               DBUS_TYPE_INVALID))
00753     {
00754       _DBUS_ASSERT_ERROR_IS_SET (error);
00755       dbus_message_unref (reply);
00756       return FALSE;
00757     }
00758   
00759   dbus_message_unref (reply);
00760   return exists;
00761 }
00762 
00778 dbus_bool_t
00779 dbus_bus_activate_service (DBusConnection *connection,
00780                            const char     *service_name,
00781                            dbus_uint32_t   flags,
00782                            dbus_uint32_t  *result,
00783                            DBusError      *error)
00784 {
00785   DBusMessage *msg;
00786   DBusMessage *reply;
00787 
00788   msg = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00789                                       DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00790                                       DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00791                                       "ActivateService");
00792 
00793   if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, service_name,
00794                                  DBUS_TYPE_UINT32, flags, DBUS_TYPE_INVALID))
00795     {
00796       dbus_message_unref (msg);
00797       _DBUS_SET_OOM (error);
00798       return FALSE;
00799     }
00800 
00801   reply = dbus_connection_send_with_reply_and_block (connection, msg,
00802                                                      -1, error);
00803   dbus_message_unref (msg);
00804 
00805   if (reply == NULL)
00806     {
00807       _DBUS_ASSERT_ERROR_IS_SET (error);
00808       return FALSE;
00809     }
00810 
00811   if (dbus_set_error_from_message (error, reply))
00812     {
00813       _DBUS_ASSERT_ERROR_IS_SET (error);
00814       dbus_message_unref (reply);
00815       return FALSE;
00816     }
00817 
00818   if (result != NULL &&
00819       !dbus_message_get_args (reply, error, DBUS_TYPE_UINT32,
00820                               result, DBUS_TYPE_INVALID))
00821     {
00822       _DBUS_ASSERT_ERROR_IS_SET (error);
00823       dbus_message_unref (reply);
00824       return FALSE;
00825     }
00826   
00827   dbus_message_unref (reply);
00828   return TRUE;
00829 }
00830 
00831 static void
00832 send_no_return_values (DBusConnection *connection,
00833                        DBusMessage    *msg,
00834                        DBusError      *error)
00835 {
00836   if (error)
00837     {
00838       /* Block to check success codepath */
00839       DBusMessage *reply;
00840       
00841       reply = dbus_connection_send_with_reply_and_block (connection, msg,
00842                                                          -1, error);
00843       
00844       if (reply == NULL)
00845         {
00846           _DBUS_ASSERT_ERROR_IS_SET (error);
00847           return;
00848         }
00849 
00850       if (dbus_set_error_from_message (error, reply))
00851         {
00852           _DBUS_ASSERT_ERROR_IS_SET (error);
00853           dbus_message_unref (reply);
00854           return;
00855         }
00856 
00857       dbus_message_unref (reply);
00858     }
00859   else
00860     {
00861       /* Silently-fail nonblocking codepath */
00862       if (!dbus_connection_send (connection, msg, NULL))
00863         return;
00864     }
00865 }
00866 
00889 void
00890 dbus_bus_add_match (DBusConnection *connection,
00891                     const char     *rule,
00892                     DBusError      *error)
00893 {
00894   DBusMessage *msg;
00895 
00896   msg = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00897                                       DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00898                                       DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00899                                       "AddMatch");
00900 
00901   if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, rule,
00902                                  DBUS_TYPE_INVALID))
00903     {
00904       dbus_message_unref (msg);
00905       _DBUS_SET_OOM (error);
00906       return;
00907     }
00908 
00909   send_no_return_values (connection, msg, error);
00910 
00911   dbus_message_unref (msg);
00912 }
00913 
00927 void
00928 dbus_bus_remove_match (DBusConnection *connection,
00929                        const char     *rule,
00930                        DBusError      *error)
00931 {
00932   DBusMessage *msg;
00933 
00934   msg = dbus_message_new_method_call (DBUS_SERVICE_ORG_FREEDESKTOP_DBUS,
00935                                       DBUS_PATH_ORG_FREEDESKTOP_DBUS,
00936                                       DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
00937                                       "RemoveMatch");
00938 
00939   if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, rule,
00940                                  DBUS_TYPE_INVALID))
00941     {
00942       dbus_message_unref (msg);
00943       _DBUS_SET_OOM (error);
00944       return;
00945     }
00946 
00947   send_no_return_values (connection, msg, error);
00948 
00949   dbus_message_unref (msg);
00950 }
00951 

Generated on Sat Sep 25 19:17:11 2004 for D-BUS by  doxygen 1.3.8-20040913