X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-connection.c;h=2c624367074e97e55290aea11a69a9970ff6d8a2;hb=c1a77d2c58c78abc606f1cb7918704596ebf2bfe;hp=8e0239459ce05077b56b2416437ff5a3f0bfd9cb;hpb=ca26f36b25beaf3d436043d551489e1ef5e2b661;p=platform%2Fupstream%2Fdbus.git

diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c
index 8e02394..2c62436 100644
--- a/dbus/dbus-connection.c
+++ b/dbus/dbus-connection.c
@@ -2,6 +2,7 @@
 /* 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
  * 
@@ -44,8 +45,11 @@
 #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)
@@ -335,8 +339,6 @@ struct DBusConnection
 #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);
@@ -1248,9 +1250,14 @@ _dbus_connection_do_iteration_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;
@@ -1280,7 +1287,7 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
 
   pending_replies =
     _dbus_hash_table_new (DBUS_HASH_INT,
-			  NULL,
+              NULL,
                           (DBusFreeFunction)free_pending_call_on_hash_removal);
   if (pending_replies == NULL)
     goto error;
@@ -1350,7 +1357,7 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   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
@@ -1361,18 +1368,23 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
 
   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;
@@ -1412,6 +1424,29 @@ _dbus_connection_new_for_transport (DBusTransport *transport)
   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.
@@ -1994,26 +2029,6 @@ _dbus_connection_preallocate_send_unlocked (DBusConnection *connection)
   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,
@@ -2022,7 +2037,6 @@ _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection       *con
                                                        dbus_uint32_t        *client_serial)
 {
   dbus_uint32_t serial;
-  char* sender;
 
   preallocated->queue_link->data = message;
   _dbus_list_prepend_link (&connection->outgoing_messages,
@@ -2075,12 +2089,6 @@ _dbus_connection_send_preallocated_unlocked_no_update (DBusConnection       *con
   _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
@@ -2707,12 +2715,13 @@ free_outgoing_message (void *element,
   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;
 
@@ -2723,7 +2732,10 @@ _dbus_connection_last_unref (DBusConnection *connection)
   /* 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... */
@@ -2767,17 +2779,20 @@ _dbus_connection_last_unref (DBusConnection *connection)
   
   _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)
     {
@@ -2799,6 +2814,18 @@ _dbus_connection_last_unref (DBusConnection *connection)
   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.
@@ -2847,6 +2874,24 @@ dbus_connection_unref (DBusConnection *connection)
     }
 }
 
+#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
@@ -3010,10 +3055,11 @@ dbus_connection_get_is_authenticated (DBusConnection *connection)
   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
@@ -3021,12 +3067,13 @@ dbus_connection_set_is_authenticated (DBusConnection *connection)
 {
   _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
@@ -5186,7 +5233,6 @@ dbus_connection_get_socket(DBusConnection              *connection,
   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
@@ -5220,16 +5266,26 @@ dbus_connection_get_unix_user (DBusConnection *connection,
 
   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;
@@ -5256,11 +5312,21 @@ dbus_connection_get_unix_process_id (DBusConnection *connection,
 
   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);
 
@@ -6340,6 +6406,7 @@ _dbus_connection_get_address (DBusConnection *connection)
   return _dbus_transport_get_address (connection->transport);
 }
 
+#ifdef ENABLE_KDBUS_TRANSPORT
 DBusTransport*
 dbus_connection_get_transport(DBusConnection *connection)
 {
@@ -6347,6 +6414,6 @@ dbus_connection_get_transport(DBusConnection *connection)
 
 	return connection->transport;
 }
-
+#endif
 
 /** @} */