27 #include "dbus-protocol.h" 
   28 #include "dbus-internals.h" 
   29 #include "dbus-message.h" 
   30 #include "dbus-marshal-validate.h" 
   31 #include "dbus-misc.h" 
   32 #include "dbus-threads-internal.h" 
   33 #include "dbus-connection-internal.h" 
   34 #include "dbus-string.h" 
  100 addresses_shutdown_func (
void *data)
 
  107       if (bus_connections[i] != 
NULL)
 
  108         _dbus_warn_check_failed (
"dbus_shutdown() called but connections were still live. This probably means the application did not drop all its references to bus connections.");
 
  111       bus_connection_addresses[i] = 
NULL;
 
  121 get_from_env (
char           **connection_p,
 
  129   if (s == 
NULL || *s == 
'\0')
 
  134       return *connection_p != 
NULL;
 
  139 init_session_address (
void)
 
  148                      "DBUS_SESSION_BUS_ADDRESS");
 
  164       if (supported && retval)
 
  168       else if (supported && !retval)
 
  173             _dbus_warn (
"Dynamic session lookup supported but failed silently");
 
  196 init_connections_unlocked (
void)
 
  206           bus_connections[i] = 
NULL;
 
  219            _dbus_verbose (
"Filling in system bus address...\n");
 
  222                               "DBUS_SYSTEM_BUS_ADDRESS"))
 
  236            _dbus_verbose (
"  used default system bus \"%s\"\n",
 
  240          _dbus_verbose (
"  used env var system bus \"%s\"\n",
 
  245           _dbus_verbose (
"Filling in session bus address...\n");
 
  247           if (!init_session_address ())
 
  256           _dbus_verbose (
"Filling in activation bus address...\n");
 
  259                              "DBUS_STARTER_ADDRESS"))
 
  273               _dbus_verbose (
"Bus activation type was set to \"%s\"\n", s);
 
  275               if (strcmp (s, 
"system") == 0)
 
  277               else if (strcmp (s, 
"session") == 0)
 
  308 bus_data_free (
void *data)
 
  318             "when we attached bus data");
 
  329             bus_connections[i] = 
NULL;
 
  406       if (bus_connections[i] == connection)
 
  408           bus_connections[i] = 
NULL;
 
  426   _dbus_return_val_if_error_is_set (error, 
NULL);
 
  432       _DBUS_SET_OOM (error);
 
  437   if (!init_connections_unlocked ())
 
  439       _DBUS_SET_OOM (error);
 
  455       bus_connection_addresses[activation_bus_type] != 
NULL)
 
  456     type = activation_bus_type;
 
  458   if (!
private && bus_connections[type] != 
NULL)
 
  460       connection = bus_connections[type];
 
  465   address = bus_connection_addresses[address_type];
 
  469                       "Unable to determine the address of the message bus (try 'man dbus-launch' and 'man dbus-daemon' for help)");
 
  497       bus_connections[type] = connection;
 
  509   bd = ensure_bus_data (connection);
 
  517   if (connection == 
NULL)
 
  518     _DBUS_ASSERT_ERROR_IS_SET (error);
 
  561   return internal_bus_get (type, 
FALSE, error);
 
  593   return internal_bus_get (type, 
TRUE, error);
 
  654   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
 
  655   _dbus_return_val_if_error_is_set (error, 
FALSE);
 
  663       _DBUS_SET_OOM (error);
 
  668   bd = ensure_bus_data (connection);
 
  671       _DBUS_SET_OOM (error);
 
  677       _dbus_verbose (
"Ignoring attempt to register the same DBusConnection %s with the message bus a second time.\n",
 
  691       _DBUS_SET_OOM (error);
 
  709       _DBUS_SET_OOM (error);
 
  725     _DBUS_ASSERT_ERROR_IS_SET (error);
 
  767                           const char     *unique_name)
 
  772   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
 
  773   _dbus_return_val_if_fail (unique_name != 
NULL, 
FALSE);
 
  781   bd = ensure_bus_data (connection);
 
  818   const char *unique_name = 
NULL;
 
  820   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
 
  829   bd = ensure_bus_data (connection);
 
  874   _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 
DBUS_UID_UNSET);
 
  880                                           "GetConnectionUnixUser");
 
  884       _DBUS_SET_OOM (error);
 
  893       _DBUS_SET_OOM (error);
 
  904       _DBUS_ASSERT_ERROR_IS_SET (error);
 
  910       _DBUS_ASSERT_ERROR_IS_SET (error);
 
  919       _DBUS_ASSERT_ERROR_IS_SET (error);
 
  926   return (
unsigned long) uid;
 
  953   const char *v_STRING;
 
  955   _dbus_return_val_if_fail (connection != 
NULL, 
NULL);
 
  956   _dbus_return_val_if_error_is_set (error, 
NULL);
 
  965       _DBUS_SET_OOM (error);
 
  976       _DBUS_ASSERT_ERROR_IS_SET (error);
 
  982       _DBUS_ASSERT_ERROR_IS_SET (error);
 
  992       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1002     _DBUS_SET_OOM (error);
 
 1120   _dbus_return_val_if_fail (connection != 
NULL, 0);
 
 1121   _dbus_return_val_if_fail (name != 
NULL, 0);
 
 1122   _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
 
 1123   _dbus_return_val_if_error_is_set (error, 0);
 
 1130   if (message == 
NULL)
 
 1132       _DBUS_SET_OOM (error);
 
 1142       _DBUS_SET_OOM (error);
 
 1153       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1159       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1168       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1205   _dbus_return_val_if_fail (connection != 
NULL, 0);
 
 1206   _dbus_return_val_if_fail (name != 
NULL, 0);
 
 1207   _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
 
 1208   _dbus_return_val_if_error_is_set (error, 0);
 
 1215   if (message == 
NULL)
 
 1217       _DBUS_SET_OOM (error);
 
 1226       _DBUS_SET_OOM (error);
 
 1237       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1243       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1252       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1287   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
 
 1288   _dbus_return_val_if_fail (name != 
NULL, 
FALSE);
 
 1289   _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 
FALSE);
 
 1290   _dbus_return_val_if_error_is_set (error, 
FALSE);
 
 1296   if (message == 
NULL)
 
 1298       _DBUS_SET_OOM (error);
 
 1307       _DBUS_SET_OOM (error);
 
 1316       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1324       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1365   _dbus_return_val_if_fail (connection != 
NULL, 
FALSE);
 
 1366   _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 
FALSE);
 
 1371                                       "StartServiceByName");
 
 1377       _DBUS_SET_OOM (error);
 
 1387       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1393       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1398   if (result != 
NULL &&
 
 1402       _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1425         _DBUS_ASSERT_ERROR_IS_SET (error);
 
 1532   _dbus_return_if_fail (rule != 
NULL);
 
 1541       _DBUS_SET_OOM (error);
 
 1549       _DBUS_SET_OOM (error);
 
 1553   send_no_return_values (connection, msg, error);
 
 1582   _dbus_return_if_fail (rule != 
NULL);
 
 1593       _DBUS_SET_OOM (error);
 
 1597   send_no_return_values (connection, msg, error);
 
  
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
Sets a flag indicating that the message does not want a reply; if this flag is set,...
Block of message-bus-related data we attach to each DBusConnection used with these convenience functi...
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
unsigned long dbus_bus_get_unix_user(DBusConnection *connection, const char *name, DBusError *error)
Asks the bus to return the UID the named connection authenticated as, if any.
@ DBUS_BUS_STARTER
The bus that started us, if any.
DBusConnection * dbus_connection_ref(DBusConnection *connection)
Increments the reference count of a DBusConnection.
#define DBUS_PATH_DBUS
The object path used to talk to the bus itself.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
dbus_bool_t dbus_bus_set_unique_name(DBusConnection *connection, const char *unique_name)
Sets the unique name of the connection, as assigned by the message bus.
dbus_bool_t dbus_connection_set_data(DBusConnection *connection, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
Stores a pointer on a DBusConnection, along with an optional function to be used for freeing the data...
void dbus_bus_remove_match(DBusConnection *connection, const char *rule, DBusError *error)
Removes a previously-added match rule "by value" (the most recently-added identical rule gets removed...
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0.
DBusConnection * dbus_bus_get_private(DBusBusType type, DBusError *error)
Connects to a bus daemon and registers the client with it as with dbus_bus_register().
DBusConnection * dbus_bus_get(DBusBusType type, DBusError *error)
Connects to a bus daemon and registers the client with it.
const char * dbus_bus_get_unique_name(DBusConnection *connection)
Gets the unique name of the connection as assigned by the message bus.
dbus_bool_t dbus_bus_name_has_owner(DBusConnection *connection, const char *name, DBusError *error)
Asks the bus whether a certain name has an owner.
dbus_bool_t _dbus_lookup_session_address(dbus_bool_t *supported, DBusString *address, DBusError *error)
Determines the address of the session bus by querying a platform-specific method.
#define DBUS_INTERFACE_DBUS
The interface exported by the object with DBUS_SERVICE_DBUS and DBUS_PATH_DBUS.
void dbus_connection_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for connection data slots.
dbus_bool_t dbus_bus_register(DBusConnection *connection, DBusError *error)
Registers a connection with the bus.
Implementation details of DBusConnection.
@ DBUS_BUS_SESSION
The login session bus.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
DBusMessage * dbus_connection_send_with_reply_and_block(DBusConnection *connection, DBusMessage *message, int timeout_milliseconds, DBusError *error)
Sends a message and blocks a certain time period while waiting for a reply.
DBusConnection * connection
Connection we're associated with.
#define DBUS_ERROR_FAILED
A generic error; "something went wrong" - see the error message for more.
dbus_bool_t dbus_message_get_args(DBusMessage *message, DBusError *error, int first_arg_type,...)
Gets arguments from a message given a variable argument list.
dbus_bool_t dbus_connection_send(DBusConnection *connection, DBusMessage *message, dbus_uint32_t *serial)
Adds a message to the outgoing message queue.
void * dbus_connection_get_data(DBusConnection *connection, dbus_int32_t slot)
Retrieves data previously set with dbus_connection_set_data().
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
DBusConnection * dbus_connection_open_private(const char *address, DBusError *error)
Opens a new, dedicated connection to a remote address.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_register_shutdown_func(DBusShutdownFunction function, void *data)
Register a cleanup function to be called exactly once the next time dbus_shutdown() is called.
#define DBUS_SERVICE_DBUS
The bus name used to talk to the bus itself.
void dbus_connection_set_exit_on_disconnect(DBusConnection *connection, dbus_bool_t exit_on_disconnect)
Set whether _exit() should be called when the connection receives a disconnect signal.
void _dbus_bus_notify_shared_connection_disconnected_unlocked(DBusConnection *connection)
Internal function that checks to see if this is a shared connection owned by the bus and if it is unr...
char * unique_name
Unique name of this connection.
void dbus_bus_add_match(DBusConnection *connection, const char *rule, DBusError *error)
Adds a match rule to match messages going through the message bus.
DBusConnection * dbus_connection_open(const char *address, DBusError *error)
Gets a connection to a remote address.
unsigned int dbus_uint32_t
int dbus_bus_release_name(DBusConnection *connection, const char *name, DBusError *error)
Asks the bus to unassign the given name from this connection by invoking the ReleaseName method on th...
char * dbus_bus_get_id(DBusConnection *connection, DBusError *error)
Asks the bus to return its globally unique ID, as described in the D-Bus specification.
dbus_bool_t dbus_connection_allocate_data_slot(dbus_int32_t *slot_p)
Allocates an integer ID to be used for storing application-specific data on any DBusConnection.
@ DBUS_BUS_SYSTEM
The systemwide bus.
Internals of DBusMessage.
#define DBUS_UID_UNSET
an invalid UID used to represent an uninitialized dbus_uid_t field
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
#define _dbus_assert_not_reached(explanation)
#define N_BUS_TYPES
Number of bus types.
unsigned int is_well_known
Is one of the well-known connections in our global array.
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
#define _dbus_assert(condition)
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
int dbus_bus_request_name(DBusConnection *connection, const char *name, unsigned int flags, DBusError *error)
Asks the bus to assign the given name to this connection by invoking the RequestName method on the bu...
char * _dbus_strdup(const char *str)
Duplicates a string.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Object representing an exception.
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
void dbus_connection_unref(DBusConnection *connection)
Decrements the reference count of a DBusConnection, and finalizes it if the count reaches zero.
DBusBusType
Well-known bus types.
#define _DBUS_UNLOCK(name)
const char * message
public error message field
#define dbus_new0(type, count)
void _dbus_connection_close_possibly_shared(DBusConnection *connection)
Closes a shared OR private connection, while dbus_connection_close() can only be used on private conn...
dbus_bool_t dbus_bus_start_service_by_name(DBusConnection *connection, const char *name, dbus_uint32_t flags, dbus_uint32_t *result, DBusError *error)
Starts a service that will request ownership of the given name.
DBusMessage * dbus_message_new_method_call(const char *destination, const char *path, const char *iface, const char *method)
Constructs a new message to invoke a method on a remote object.
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
dbus_bool_t dbus_set_error_from_message(DBusError *error, DBusMessage *message)
Sets a DBusError based on the contents of the given message.
void _dbus_warn_check_failed(const char *format,...)
Prints a "critical" warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
dbus_uint32_t dbus_bool_t