#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.
- */
-DBusConnection*
-_dbus_connection_new_for_transport (DBusTransport *transport)
+*/
+static DBusConnection*
+_dbus_connection_new_for_transport_internal (DBusTransport *transport, dbus_bool_t exists)
{
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);
+ if(!exists)
+ {
+ 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;
}
/**
+ * 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);
+}
+
+/**
* 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
- */
static void
-_dbus_connection_last_unref (DBusConnection *connection)
+_dbus_connection_last_unref_internal (DBusConnection *connection, dbus_bool_t unref_transport)
{
DBusList *link;
_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);
+ if(unref_transport)
+ _dbus_transport_unref (connection->transport);
if (connection->disconnect_message_link)
{
dbus_free (connection);
}
+/* 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);
+}
+
/**
* Decrements the reference count of a DBusConnection, and finalizes
* it if the count reaches zero.
}
}
+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);
+}
+
/*
* Note that the transport can disconnect itself (other end drops us)
* and in that case this function never runs. So this function must
/**
* 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
-
+ _dbus_verbose ("Reply sender: %s, destination: %s\n", dbus_message_get_sender(message), dbus_message_get_destination(message)); //todo kdbus temp addon
_dbus_connection_send_preallocated_and_unlock (connection,
preallocated,
message, client_serial);
return connection->transport;
}
-
/** @} */
projects / platform / upstream / dbus.git / blobdiff