/* dbus-connection.c DBusConnection object
*
* Copyright (C) 2002-2006 Red Hat Inc.
+ * Copyright (C) 2013 Samsung Electronics
*
* Licensed under the Academic Free License version 2.1
*
#include "dbus-threads-internal.h"
#include "dbus-bus.h"
#include "dbus-marshal-basic.h"
+#ifdef ENABLE_KDBUS_TRANSPORT
#include "dbus-transport-kdbus.h"
+#include "kdbus-common.h"
#include <stdlib.h>
+#endif
#ifdef DBUS_DISABLE_CHECKS
#define TOOK_LOCK_CHECK(connection)
#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
int generation; /**< _dbus_current_generation that should correspond to this connection */
#endif
- unsigned int is_kdbus; /* Samsung change: to spare comparing address too often. 0 - uninitialized, 1 - not kdbus, 2 - kdbus */
- char* sender; /* Samsung change: to spare building sender name for each message sent */
};
static DBusDispatchStatus _dbus_connection_get_dispatch_status_unlocked (DBusConnection *connection);
*
* @param transport the transport.
* @returns the new connection, or #NULL on failure.
- */
+*/
+#ifdef ENABLE_KDBUS_TRANSPORT
+static DBusConnection*
+_dbus_connection_new_for_transport_internal (DBusTransport *transport, dbus_bool_t exists)
+#else
DBusConnection*
_dbus_connection_new_for_transport (DBusTransport *transport)
+#endif
{
DBusConnection *connection;
DBusWatchList *watch_list;
pending_replies =
_dbus_hash_table_new (DBUS_HASH_INT,
- NULL,
+ NULL,
(DBusFreeFunction)free_pending_call_on_hash_removal);
if (pending_replies == NULL)
goto error;
connection->route_peer_messages = FALSE;
connection->disconnected_message_arrived = FALSE;
connection->disconnected_message_processed = FALSE;
-
+
#if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
connection->generation = _dbus_current_generation;
#endif
connection->disconnect_message_link = disconnect_link;
- CONNECTION_LOCK (connection);
-
- if (!_dbus_transport_set_connection (transport, connection))
- {
- CONNECTION_UNLOCK (connection);
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(!exists)
+#endif
+ {
+ CONNECTION_LOCK (connection);
- goto error;
- }
+ if (!_dbus_transport_set_connection (transport, connection))
+ {
+ CONNECTION_UNLOCK (connection);
- _dbus_transport_ref (transport);
+ goto error;
+ }
- CONNECTION_UNLOCK (connection);
+ _dbus_transport_ref (transport);
+
+ CONNECTION_UNLOCK (connection);
+ }
_dbus_connection_trace_ref (connection, 0, 1, "new_for_transport");
return connection;
return NULL;
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/**
+ * Creates a new connection for the given transport. A transport
+ * represents a message stream that uses some concrete mechanism, such
+ * as UNIX domain sockets. May return #NULL if insufficient
+ * memory exists to create the connection.
+ *
+ * @param transport the transport.
+ * @returns the new connection, or #NULL on failure.
+ */
+DBusConnection*
+_dbus_connection_new_for_transport (DBusTransport *transport)
+{
+ return _dbus_connection_new_for_transport_internal(transport, FALSE);
+}
+
+DBusConnection*
+_dbus_connection_new_for_used_transport (DBusTransport *transport)
+{
+ return _dbus_connection_new_for_transport_internal(transport, TRUE);
+}
+#endif
+
/**
* Increments the reference count of a DBusConnection.
* Requires that the caller already holds the connection lock.
return NULL;
}
-void dbus_connection_set_sender(DBusConnection *connection, char *value)
-{
- connection->sender = value;
-}
-
-char* dbus_connection_get_sender(DBusConnection *connection)
-{
- return connection->sender;
-}
-
-unsigned int dbus_connection_get_is_kdbus(DBusConnection *connection)
-{
- return connection->is_kdbus;
-}
-
-void dbus_connection_set_is_kdbus(DBusConnection *connection, unsigned int value)
-{
- connection->is_kdbus = value;
-}
-
/* Called with lock held, does not update dispatch status */
static void
_dbus_connection_send_preallocated_unlocked_no_update (DBusConnection *connection,
dbus_uint32_t *client_serial)
{
dbus_uint32_t serial;
- char* sender;
preallocated->queue_link->data = message;
_dbus_list_prepend_link (&connection->outgoing_messages,
_dbus_verbose ("Message %p serial is %u\n",
message, dbus_message_get_serial (message));
- if(dbus_transport_is_kdbus(connection))
- {
- sender = dbus_connection_get_sender(connection);
- dbus_message_set_sender(message, sender);
- }
-
dbus_message_lock (message);
/* Now we need to run an iteration to hopefully just write the messages
dbus_message_unref (message);
}
-/* This is run without the mutex held, but after the last reference
- * to the connection has been dropped we should have no thread-related
- * problems
- */
+#ifdef ENABLE_KDBUS_TRANSPORT
+static void
+_dbus_connection_last_unref_internal (DBusConnection *connection, dbus_bool_t unref_transport)
+#else
static void
_dbus_connection_last_unref (DBusConnection *connection)
+#endif
{
DBusList *link;
/* You have to disconnect the connection before unref:ing it. Otherwise
* you won't get the disconnected message.
*/
- _dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(unref_transport)
+#endif
+ _dbus_assert (!_dbus_transport_get_is_connected (connection->transport));
_dbus_assert (connection->server_guid == NULL);
/* ---- We're going to call various application callbacks here, hope it doesn't break anything... */
_dbus_list_foreach (&connection->outgoing_messages,
free_outgoing_message,
- connection);
+ connection);
_dbus_list_clear (&connection->outgoing_messages);
_dbus_list_foreach (&connection->incoming_messages,
- (DBusForeachFunction) dbus_message_unref,
- NULL);
+ (DBusForeachFunction) dbus_message_unref,
+ NULL);
_dbus_list_clear (&connection->incoming_messages);
_dbus_counter_unref (connection->outgoing_counter);
- _dbus_transport_unref (connection->transport);
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if(unref_transport)
+#endif
+ _dbus_transport_unref (connection->transport);
if (connection->disconnect_message_link)
{
dbus_free (connection);
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+/* This is run without the mutex held, but after the last reference
+ * to the connection has been dropped we should have no thread-related
+ * problems
+ */
+static void
+_dbus_connection_last_unref (DBusConnection *connection)
+{
+ _dbus_connection_last_unref_internal(connection, TRUE);
+}
+#endif
+
/**
* Decrements the reference count of a DBusConnection, and finalizes
* it if the count reaches zero.
}
}
+#ifdef ENABLE_KDBUS_TRANSPORT
+void
+dbus_connection_unref_phantom (DBusConnection *connection)
+{
+ dbus_int32_t old_refcount;
+
+ _dbus_return_if_fail (connection != NULL);
+ _dbus_return_if_fail (connection->generation == _dbus_current_generation);
+
+ old_refcount = _dbus_atomic_dec (&connection->refcount);
+
+ _dbus_connection_trace_ref (connection, old_refcount, old_refcount - 1, "unref");
+
+ if (old_refcount == 1)
+ _dbus_connection_last_unref_internal(connection, FALSE);
+}
+#endif
+
/*
* Note that the transport can disconnect itself (other end drops us)
* and in that case this function never runs. So this function must
return res;
}
+#ifdef ENABLE_KDBUS_TRANSPORT
/**
* Sets authenticated status for connection. Needed for kdbus, where authentication is
* made in different manner.
- *
+ * LOCK commented out because called with lock already set
* @param connection the connection
*/
dbus_bool_t
{
_dbus_return_val_if_fail (connection != NULL, FALSE);
- CONNECTION_LOCK (connection);
+// CONNECTION_LOCK (connection);
connection->transport->authenticated = TRUE;
- CONNECTION_UNLOCK (connection);
+// CONNECTION_UNLOCK (connection);
return TRUE;
}
+#endif
/**
* Gets whether the connection is not authenticated as a specific
return retval;
}
-
/**
* Gets the UNIX user ID of the connection if known. Returns #TRUE if
* the uid is filled in. Always returns #FALSE on non-UNIX platforms
CONNECTION_LOCK (connection);
- if (!_dbus_transport_try_to_authenticate (connection->transport))
- result = FALSE;
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if (_dbus_connection_get_address (connection) != NULL)
+ {
+ if (!strncmp (_dbus_connection_get_address (connection), "kdbus:", strlen("kdbus:")))
+ result = kdbus_connection_get_unix_user (connection, dbus_bus_get_unique_name (connection), uid, NULL);
+ }
else
- result = _dbus_transport_get_unix_user (connection->transport,
- uid);
+#endif
+ {
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
+ result = FALSE;
+ else
+ result = _dbus_transport_get_unix_user (connection->transport,
+ uid);
+ }
#ifdef DBUS_WIN
_dbus_assert (!result);
#endif
-
+
CONNECTION_UNLOCK (connection);
return result;
CONNECTION_LOCK (connection);
- if (!_dbus_transport_try_to_authenticate (connection->transport))
- result = FALSE;
+#ifdef ENABLE_KDBUS_TRANSPORT
+ if (_dbus_connection_get_address (connection) != NULL)
+ {
+ if (!strncmp (_dbus_connection_get_address (connection), "kdbus:", strlen("kdbus:")))
+ result = kdbus_connection_get_unix_process_id (connection, dbus_bus_get_unique_name (connection), pid, NULL);
+ }
else
- result = _dbus_transport_get_unix_process_id (connection->transport,
- pid);
+#endif
+ {
+ if (!_dbus_transport_try_to_authenticate (connection->transport))
+ result = FALSE;
+ else
+ result = _dbus_transport_get_unix_process_id (connection->transport,
+ pid);
+ }
CONNECTION_UNLOCK (connection);
return _dbus_transport_get_address (connection->transport);
}
+#ifdef ENABLE_KDBUS_TRANSPORT
DBusTransport*
dbus_connection_get_transport(DBusConnection *connection)
{
return connection->transport;
}
-
+#endif
/** @} */
projects / platform / upstream / dbus.git / blobdiff