#include "dbus-bus.h"
#include "dbus-marshal-basic.h"
-#ifdef DBUS_ENABLE_SMACK
-#include <sys/smack.h>
-#include <stdlib.h>
-#endif
-
#ifdef DBUS_DISABLE_CHECKS
#define TOOK_LOCK_CHECK(connection)
#define RELEASING_LOCK_CHECK(connection)
DBusObjectTree *objects; /**< Object path handlers registered with this connection */
char *server_guid; /**< GUID of server if we are in shared_connections, #NULL if server GUID is unknown or connection is private */
-#ifdef DBUS_ENABLE_SMACK
- char *peer_smack_label; /** Smack label of the peer at the time when the connection was established. Allocated with malloc(), NULL if unknown. */
-#endif
/* These two MUST be bools and not bitfields, because they are protected by a separate lock
* from connection->mutex and all bitfields in a word have to be read/written together.
_dbus_connection_queue_synthesized_message_link (DBusConnection *connection,
DBusList *link)
{
+ DBusMessage *msg, *rmsg;
+
HAVE_LOCK_CHECK (connection);
-
+
+ msg = (DBusMessage *)link->data;
+
+ rmsg = msg;
+ if (_dbus_transport_assure_protocol_version (connection->transport, &rmsg))
+ {
+ /* If the message is converted, then we don't need the old format anymore */
+ _dbus_list_free_link(link);
+ link = _dbus_list_alloc_link (rmsg);
+ dbus_message_unref (msg);
+ }
+
_dbus_list_append_link (&connection->incoming_messages, link);
connection->n_incoming += 1;
if (connection == NULL)
goto error;
-#ifdef DBUS_ENABLE_SMACK
- /* If we cannot get the Smack label, proceed without. */
- {
- DBusSocket sock_fd;
- if (_dbus_transport_get_socket_fd(transport, &sock_fd)) {
- char *label;
- if (smack_new_label_from_socket(_dbus_socket_get_int (sock_fd), &label) >= 0) {
- connection->peer_smack_label = label;
- }
- }
- }
-#endif
-
_dbus_rmutex_new_at_location (&connection->mutex);
if (connection->mutex == NULL)
goto error;
{
dbus_uint32_t serial;
+ /* Finish preparing the message */
+ if (dbus_message_get_serial (message) == 0)
+ {
+ serial = _dbus_connection_get_next_client_serial (connection);
+ dbus_message_set_serial (message, serial);
+ if (client_serial)
+ *client_serial = serial;
+ }
+ else
+ {
+ if (client_serial)
+ *client_serial = dbus_message_get_serial (message);
+ }
+
+ _dbus_verbose ("Message %p serial is %u\n",
+ message, dbus_message_get_serial (message));
+
+ dbus_message_lock (message);
+
+ /* This converts message if neccessary */
+ if (!_dbus_transport_assure_protocol_version (connection->transport, &message))
+ {
+ /* Only non-converted messages must be refed.
+ * Converted messages are local anyway.
+ */
+ dbus_message_ref (message);
+ }
+
preallocated->queue_link->data = message;
_dbus_list_prepend_link (&connection->outgoing_messages,
preallocated->queue_link);
dbus_free (preallocated);
preallocated = NULL;
- dbus_message_ref (message);
-
connection->n_outgoing += 1;
_dbus_verbose ("Message %p (%s %s %s %s '%s') for %s added to outgoing queue %p, %d pending to send\n",
connection,
connection->n_outgoing);
- if (dbus_message_get_serial (message) == 0)
- {
- serial = _dbus_connection_get_next_client_serial (connection);
- dbus_message_set_serial (message, serial);
- if (client_serial)
- *client_serial = serial;
- }
- else
- {
- if (client_serial)
- *client_serial = dbus_message_get_serial (message);
- }
-
- _dbus_verbose ("Message %p serial is %u\n",
- message, dbus_message_get_serial (message));
-
- dbus_message_lock (message);
-
/* Now we need to run an iteration to hopefully just write the messages
* out immediately, and otherwise get them queued up
*/
_dbus_sleep_milliseconds (1000);
}
-static DBusMessage *
-generate_local_error_message (dbus_uint32_t serial,
- char *error_name,
- char *error_msg)
-{
- DBusMessage *message;
- message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
- if (!message)
- goto out;
-
- if (!dbus_message_set_error_name (message, error_name))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
-
- dbus_message_set_no_reply (message, TRUE);
-
- if (!dbus_message_set_reply_serial (message,
- serial))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
-
- if (error_msg != NULL)
- {
- DBusMessageIter iter;
-
- dbus_message_iter_init_append (message, &iter);
- if (!dbus_message_iter_append_basic (&iter,
- DBUS_TYPE_STRING,
- &error_msg))
- {
- dbus_message_unref (message);
- message = NULL;
- goto out;
- }
- }
-
- out:
- return message;
-}
-
/*
* Peek the incoming queue to see if we got reply for a specific serial
*/
{
_dbus_pending_call_set_reply_unlocked (pending, message);
_dbus_pending_call_ref_unlocked (pending); /* in case there's no app with a ref held */
+ _dbus_pending_call_start_completion_unlocked(pending);
_dbus_connection_detach_pending_call_and_unlock (connection, pending);
-
+
/* Must be called unlocked since it invokes app callback */
- _dbus_pending_call_complete (pending);
+ _dbus_pending_call_finish_completion (pending);
dbus_pending_call_unref (pending);
}
{
DBusMessage *error_msg;
- error_msg = generate_local_error_message (client_serial,
- DBUS_ERROR_DISCONNECTED,
- "Connection was disconnected before a reply was received");
+ error_msg = _dbus_generate_local_error_message (client_serial,
+ DBUS_ERROR_DISCONNECTED,
+ "Connection was disconnected before a reply was received");
/* on OOM error_msg is set to NULL */
complete_pending_call_and_unlock (connection, pending, error_msg);
+ if (error_msg != NULL)
+ dbus_message_unref (error_msg);
dbus_pending_call_unref (pending);
return;
}
{
/* block again, we don't have the reply buffered yet. */
_dbus_connection_do_iteration_unlocked (connection,
- NULL,
+ pending,
DBUS_ITERATION_DO_READING |
DBUS_ITERATION_BLOCK,
timeout_milliseconds - elapsed_milliseconds);
_dbus_hash_table_unref (connection->pending_replies);
connection->pending_replies = NULL;
- _dbus_list_clear (&connection->filter_list);
-
_dbus_list_foreach (&connection->outgoing_messages,
free_outgoing_message,
connection);
_dbus_rmutex_free_at_location (&connection->mutex);
-#ifdef DBUS_ENABLE_SMACK
- if (connection->peer_smack_label)
- free (connection->peer_smack_label);
-#endif
-
dbus_free (connection);
}
{
_dbus_warn_check_failed ("The last reference on a connection was dropped without closing the connection. This is a bug in an application. See dbus_connection_unref() documentation for details.\n%s",
connection->shareable ?
- "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection.\n" :
- "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.\n");
+ "Most likely, the application called unref() too many times and removed a reference belonging to libdbus, since this is a shared connection." :
+ "Most likely, the application was supposed to call dbus_connection_close(), since this is a private connection.");
return;
}
#endif
{
CONNECTION_UNLOCK (connection);
- _dbus_warn_check_failed ("Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.\n");
+ _dbus_warn_check_failed ("Applications must not close shared connections - see dbus_connection_close() docs. This is a bug in the application.");
return;
}
#endif
* dbus_bus_get_id() instead (which is just a convenience wrapper
* around the org.freedesktop.DBus.GetId method invoked on the bus).
*
- * You can also get a machine ID; see dbus_get_local_machine_id() to
+ * You can also get a machine ID; see dbus_try_get_local_machine_id() to
* get the machine you are on. There isn't a convenience wrapper, but
* you can invoke org.freedesktop.DBus.Peer.GetMachineId on any peer
* to get the machine ID on the other end.
return TRUE;
}
+ _dbus_message_set_timeout_ms(message, timeout_milliseconds);
pending = _dbus_pending_call_new_unlocked (connection,
timeout_milliseconds,
reply_handler_timeout);
_dbus_return_val_if_fail (timeout_milliseconds >= 0 || timeout_milliseconds == -1, NULL);
_dbus_return_val_if_error_is_set (error, NULL);
+ if (_dbus_transport_can_send_sync_call (connection->transport))
+ {
+ dbus_int32_t serial;
+
+ /* set serial */
+ serial = dbus_message_get_serial (message);
+ if (serial == 0)
+ {
+ serial = _dbus_connection_get_next_client_serial (connection);
+ dbus_message_set_serial (message, serial);
+ }
+
+ reply = _dbus_transport_send_sync_call (connection->transport, message);
+ goto out;
+ }
+
#ifdef HAVE_UNIX_FD_PASSING
CONNECTION_LOCK (connection);
/* call_complete_and_unlock() called from pending_call_block() should
* always fill this in.
*/
+
+out:
_dbus_assert (reply != NULL);
- if (dbus_set_error_from_message (error, reply))
+ if (dbus_set_error_from_message (error, reply))
{
dbus_message_unref (reply);
return NULL;
_dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection)
{
HAVE_LOCK_CHECK (connection);
- if (connection->dispatch_disabled && dbus_connection_get_is_connected(connection))
+ if (connection->dispatch_disabled)
return DBUS_DISPATCH_COMPLETE;
else if (connection->n_incoming > 0)
return DBUS_DISPATCH_DATA_REMAINS;
else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
{
dbus_error_free (&error);
+ _dbus_string_free (&uuid);
goto out;
}
else
{
ret = dbus_message_new_error (message, error.name, error.message);
dbus_error_free (&error);
+ _dbus_string_free (&uuid);
if (ret == NULL)
goto out;
return retval;
}
+/**
+ *
+ * Getter for number of messages in incoming queue.
+ * Useful for sending reply to self (see kdbus_do_iteration)
+ */
+int
+_dbus_connection_get_n_incoming (DBusConnection *connection)
+{
+ return connection->n_incoming;
+}
+
+dbus_bool_t
+_dbus_connection_is_overflowed (DBusConnection *connection)
+{
+ return _dbus_transport_get_overflowed (connection->transport);
+}
/**
* Gets the UNIX user ID of the connection if known. Returns #TRUE if
return result;
}
-#ifdef DBUS_ENABLE_SMACK
-/**
- * Gets the Smack label of the peer at the time when the connection
- * was established. Returns #TRUE if the label is filled in.
- *
- * @param connection the connection
- * @param label return location for the Smack label; returned value is valid as long as the connection exists
- * @returns #TRUE if uid is filled in with a valid process ID
- */
-dbus_bool_t
-dbus_connection_get_smack_label (DBusConnection *connection,
- const char **label)
-{
- _dbus_return_val_if_fail (connection != NULL, FALSE);
- _dbus_return_val_if_fail (label != NULL, FALSE);
-
- *label = connection->peer_smack_label;
- return *label != NULL;
-}
-#endif
-
/**
* Gets the ADT audit data of the connection if any.
* Returns #TRUE if the structure pointer is returned.
#ifndef DBUS_DISABLE_CHECKS
if (filter == NULL)
{
- _dbus_warn_check_failed ("Attempt to remove filter function %p user data %p, but no such filter has been added\n",
+ _dbus_warn_check_failed ("Attempt to remove filter function %p user data %p, but no such filter has been added",
function, user_data);
return;
}
if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
{
- _dbus_warn ("%s\n", error.message);
+ _dbus_warn ("%s", error.message);
dbus_error_free (&error);
return FALSE;
}
if (dbus_error_has_name (&error, DBUS_ERROR_OBJECT_PATH_IN_USE))
{
- _dbus_warn ("%s\n", error.message);
+ _dbus_warn ("%s", error.message);
dbus_error_free (&error);
return FALSE;
}
projects / platform / upstream / dbus.git / blobdiff