Added a strategy for selecting default protocol type.

When a message is created, it is created without context
of a bus. Thus, we have to guess what type of protocol
is correct for the message. This commit introduces
a possibility to influence guessing.

An environment variable is introduced (DBUS_DEFAULT_PROTOCOL_STRATEGY),
with following values recognized:
* first-bus - messages created for type of first opened bus;
* last-bus - messages created for type of last opened bus;
* last-message - messages created for type of last sent message;
* dbus1 - messages created with dbus1 protocol;
* gvariant - messages created with GVariant protocol.

last-bus is a default strategy.

Change-Id: I2a185761973191ad5917bc2b6f4bfb2f4a3ed547

diff --git a/dbus/dbus-bus.c b/dbus/dbus-bus.c
index dbaa2a6..d910127 100644 (file)
--- a/dbus/dbus-bus.c
+++ b/dbus/dbus-bus.c
@@ -289,6 +289,13 @@ init_connections_unlocked (void)
                 return FALSE;
             }
         }
+
+      s = _dbus_getenv ("DBUS_DEFAULT_PROTOCOL_STRATEGY");
+
+      if (s != NULL)
+        {
+          dbus_set_default_protocol_strategy (s);
+        }
       
       /* If we return FALSE we have to be sure that restarting
        * the above code will work right

diff --git a/dbus/dbus-message-internal.h b/dbus/dbus-message-internal.h
index fbb19d3..e1c27fa 100644 (file)
--- a/dbus/dbus-message-internal.h
+++ b/dbus/dbus-message-internal.h
@@ -129,6 +129,8 @@ DBusMessage *      _dbus_generate_local_error_message           (dbus_uint32_t s
 dbus_bool_t       _dbus_message_assure_dbus1                    (DBusMessage **message);
 dbus_bool_t       _dbus_message_assure_gvariant                 (DBusMessage **message);
 
+void              _dbus_on_new_bus                              (int type);
+
 DBUS_END_DECLS
 
 #endif /* DBUS_MESSAGE_INTERNAL_H */

diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index 54056f3..b11d0aa 100644 (file)
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -48,7 +48,15 @@
   (type == DBUS_TYPE_STRING || type == DBUS_TYPE_SIGNATURE || \
    type == DBUS_TYPE_OBJECT_PATH)
 
-unsigned char _dbus_default_protocol_version = DBUS_MAJOR_PROTOCOL_VERSION; /* DBUS_PROTOCOL_VERSION_GVARIANT; */
+static unsigned char _dbus_default_protocol_version = DBUS_MAJOR_PROTOCOL_VERSION; /* DBUS_PROTOCOL_VERSION_GVARIANT; */
+static dbus_bool_t _dbus_first_bus_open = FALSE;
+
+static void protocol_strategy_last_type (int type);
+static void protocol_strategy_static (int type);
+
+typedef void (*DBusProtocolStrategyFunction)(int type);
+static DBusProtocolStrategyFunction _dbus_protocol_strategy_bus_function = protocol_strategy_last_type;
+static DBusProtocolStrategyFunction _dbus_protocol_strategy_message_function = protocol_strategy_static;
 
 static void dbus_message_finalize (DBusMessage *message);
 
@@ -5153,6 +5161,20 @@ _dbus_message_copy_recursive(DBusMessageIter *iter, DBusMessageIter *dest)
   return TRUE;
 }
 
+void
+_dbus_on_new_bus (int type)
+{
+  _dbus_assert (type == DBUS_MAJOR_PROTOCOL_VERSION || type == DBUS_PROTOCOL_VERSION_GVARIANT);
+  _dbus_protocol_strategy_bus_function (type);
+}
+
+static void
+_dbus_on_send_message (int type)
+{
+  _dbus_assert (type == DBUS_MAJOR_PROTOCOL_VERSION || type == DBUS_PROTOCOL_VERSION_GVARIANT);
+  _dbus_protocol_strategy_message_function (type);
+}
+
 DBusMessage *
 _dbus_message_remarshal (DBusMessage *message, dbus_bool_t gvariant)
 {
@@ -5164,6 +5186,8 @@ _dbus_message_remarshal (DBusMessage *message, dbus_bool_t gvariant)
 
   _dbus_assert (message->locked);
 
+  _dbus_on_send_message (gvariant ? DBUS_PROTOCOL_VERSION_GVARIANT : DBUS_MAJOR_PROTOCOL_VERSION);
+
   ret = _dbus_message_create_protocol_version (dbus_message_get_type(message),
                                               dbus_message_get_destination(message),
                                               dbus_message_get_path(message),
@@ -5268,6 +5292,63 @@ dbus_set_protocol_version (unsigned char version)
   _dbus_default_protocol_version = version;
 }
 
+static void
+protocol_strategy_first_type (int type)
+{
+  /* change protocol once */
+  if (!_dbus_first_bus_open)
+    {
+      _dbus_first_bus_open = TRUE;
+      _dbus_default_protocol_version = type;
+    }
+}
+
+static void
+protocol_strategy_last_type (int type)
+{
+  /* change protocol every time it is needed */
+  if (_dbus_default_protocol_version != type)
+    _dbus_default_protocol_version = type;
+}
+
+static void
+protocol_strategy_static (int type)
+{
+  /* do not change */
+}
+
+void
+dbus_set_default_protocol_strategy (const char *strategy_name)
+{
+  if (strcmp (strategy_name, "first-bus") == 0)
+    {
+      _dbus_protocol_strategy_bus_function = protocol_strategy_first_type;
+      _dbus_protocol_strategy_message_function = protocol_strategy_static;
+    }
+  else if (strcmp (strategy_name, "dbus1") == 0)
+    {
+      _dbus_default_protocol_version = DBUS_MAJOR_PROTOCOL_VERSION;
+      _dbus_protocol_strategy_bus_function = protocol_strategy_static;
+      _dbus_protocol_strategy_message_function = protocol_strategy_static;
+    }
+  else if (strcmp (strategy_name, "gvariant") == 0)
+    {
+      _dbus_default_protocol_version = DBUS_PROTOCOL_VERSION_GVARIANT;
+      _dbus_protocol_strategy_bus_function = protocol_strategy_static;
+      _dbus_protocol_strategy_message_function = protocol_strategy_static;
+    }
+  else if (strcmp (strategy_name, "last-message") == 0)
+    {
+      _dbus_protocol_strategy_bus_function = protocol_strategy_static;
+      _dbus_protocol_strategy_message_function = protocol_strategy_last_type;
+    }
+  else /* "last-bus" is default strategy */
+    {
+      _dbus_protocol_strategy_bus_function = protocol_strategy_last_type;
+      _dbus_protocol_strategy_message_function = protocol_strategy_static;
+    }
+}
+
 DBusMessage *
 _dbus_generate_local_error_message (dbus_uint32_t serial,
                                     char *error_name,

diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h
index d6499a3..1c8f9dd 100644 (file)
--- a/dbus/dbus-message.h
+++ b/dbus/dbus-message.h
@@ -371,6 +371,8 @@ dbus_bool_t dbus_message_get_allow_interactive_authorization (
 
 DBUS_EXPORT
 void        dbus_set_protocol_version (unsigned char version);
+DBUS_EXPORT
+void        dbus_set_default_protocol_strategy (const char *strategy_name);
 
 /** @} */
 

diff --git a/dbus/dbus-transport-kdbus.c b/dbus/dbus-transport-kdbus.c
index d54ae39..168c6ff 100644 (file)
--- a/dbus/dbus-transport-kdbus.c
+++ b/dbus/dbus-transport-kdbus.c
@@ -24,7 +24,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
-#include "../config.h"
+#include <config.h>
 #include "dbus-transport.h"
 #include "dbus-transport-kdbus.h"
 #include "dbus-transport-protected.h"
@@ -37,6 +37,7 @@
 #include "dbus-errors.h"
 #include "dbus-bus.h"
 #include "kdbus-common.h"
+#include "dbus-protocol-gvariant.h"
 #include <linux/types.h>
 #include <errno.h>
 #include <stdio.h>
@@ -67,7 +68,9 @@
 #  include <linux/memfd.h>
 #endif
 
+#ifdef DBUS_ENABLE_VERBOSE_MODE
 int debug = -1;
+#endif
 
 /* FIXME shouldn't it be in fcntl.h header file? copied from systemd's missing.h */
 #ifndef F_LINUX_SPECIFIC_BASE
@@ -621,6 +624,7 @@ kdbus_close_message (DBusTransportKdbus *transport, struct kdbus_msg *msg)
   _kdbus_free_mem (transport->kdbus, msg);
 }
 
+#ifdef DBUS_ENABLE_VERBOSE_MODE
 static void
 debug_c_str (const char *msg, const char *str, int len)
 {
@@ -639,6 +643,7 @@ debug_str (const char *msg, const DBusString *str)
 {
   debug_c_str (msg, _dbus_string_get_const_data (str), _dbus_string_get_length (str));
 }
+#endif
 
 static dbus_bool_t
 can_send (DBusTransportKdbus *transport,
@@ -808,11 +813,13 @@ kdbus_write_msg_internal (DBusTransportKdbus  *transport,
         {
           const char* body_data = _dbus_string_get_const_data (body);
 
+#ifdef DBUS_ENABLE_VERBOSE_MODE
           if (-1 != debug)
-          {
-            debug_str ("Header to send:", header);
-            debug_str ("Body to send:", body);
-          }
+            {
+              debug_str ("Header to send:", header);
+              debug_str ("Body to send:", body);
+            }
+#endif
 
           while (body_size > 0)
             {
@@ -2760,10 +2767,12 @@ kdbus_decode_dbus_message (const struct kdbus_msg *msg,
             data += item->vec.size;
             ret_size += item->vec.size;
 
+#ifdef DBUS_ENABLE_VERBOSE_MODE
             if (-1 != debug)
-            {
-              debug_c_str ("Message part arrived:", (char *)msg+item->vec.offset, item->vec.size);
-            }
+              {
+                debug_c_str ("Message part arrived:", (char *)msg+item->vec.offset, item->vec.size);
+              }
+#endif
 
             _dbus_verbose ("  +%s (%llu bytes) off=%llu size=%llu\n",
                 enum_MSG (item->type), item->size,
@@ -3961,7 +3970,8 @@ new_kdbus_transport (kdbus_t          *kdbus,
   _dbus_transport_set_get_unix_process_id_function (&kdbus_transport->base,
                                                     _dbus_transport_kdbus_get_unix_process_id);
   _dbus_transport_set_assure_protocol_function (&kdbus_transport->base,
-                                                _dbus_message_assure_gvariant);
+                                                _dbus_message_assure_gvariant,
+                                                DBUS_PROTOCOL_VERSION_GVARIANT);
 
   /* These values should probably be tunable or something. */
   kdbus_transport->max_bytes_read_per_iteration = MAX_BYTES_PER_ITERATION;
@@ -4031,7 +4041,8 @@ _dbus_transport_new_for_kdbus (const char *path,
   DBusString address;
   kdbus_t *kdbus;
 
-  const char *dbgenv = getenv ("G_DBUS_DEBUG");
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  const char *dbgenv = _dbus_getenv ("G_DBUS_DEBUG");
   if (dbgenv != NULL)
   {
     if (!strcmp (dbgenv, "message"))
@@ -4039,6 +4050,7 @@ _dbus_transport_new_for_kdbus (const char *path,
     else if (!strcmp (dbgenv, "all"))
       debug = 2;
   }
+#endif
 
   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 

diff --git a/dbus/dbus-transport-protected.h b/dbus/dbus-transport-protected.h
index 71c3857..4af5c3a 100644 (file)
--- a/dbus/dbus-transport-protected.h
+++ b/dbus/dbus-transport-protected.h
@@ -118,6 +118,7 @@ struct DBusTransport
   DBusTransportGetUnixUserFunction get_unix_user_function;      /**< Function for getting Unix user ID */
   DBusTransportGetUnixPIDFunction get_unix_process_id_function; /**< Function for getting Unix process ID */
   DBusTransportAssureProtocolFunction assure_protocol_function; /**< Function for converting messages, if needed */
+  int protocol;                               /**< type of protocol for this transport */
   
   unsigned int disconnected : 1;              /**< #TRUE if we are disconnected. */
   unsigned int authenticated : 1;             /**< Cache of auth state; use _dbus_transport_peek_is_authenticated() to query value */
@@ -143,7 +144,9 @@ void        _dbus_transport_set_get_unix_user_function       (DBusTransport
 void        _dbus_transport_set_get_unix_process_id_function (DBusTransport                    *transport,
                                                               DBusTransportGetUnixPIDFunction   function);
 void        _dbus_transport_set_assure_protocol_function     (DBusTransport                    *transport,
-                                                              DBusTransportAssureProtocolFunction function);
+                                                              DBusTransportAssureProtocolFunction function,
+                                                              int                               protocol);
+int         _dbus_transport_get_protocol                     (DBusTransport                    *transport);
 
 typedef enum
 {

diff --git a/dbus/dbus-transport.c b/dbus/dbus-transport.c
index e94b9e4..4e1caf2 100644 (file)
--- a/dbus/dbus-transport.c
+++ b/dbus/dbus-transport.c
@@ -33,6 +33,7 @@
 #include "dbus-credentials.h"
 #include "dbus-mainloop.h"
 #include "dbus-message.h"
+#include "dbus-message-internal.h"
 #ifdef ENABLE_KDBUS_TRANSPORT
 #include "dbus-transport-kdbus.h"
 #endif
@@ -270,6 +271,7 @@ _dbus_transport_init_base_with_auth (DBusTransport             *transport,
   transport->get_unix_user_function = _dbus_transport_default_get_unix_user;
   transport->get_unix_process_id_function = _dbus_transport_default_get_unix_process_id;
   transport->assure_protocol_function = _dbus_message_assure_dbus1;
+  transport->protocol = DBUS_MAJOR_PROTOCOL_VERSION;
 
   return TRUE;
 }
@@ -281,6 +283,12 @@ _dbus_transport_assure_protocol_version (DBusTransport *transport,
   return transport->assure_protocol_function (message);
 }
 
+int
+_dbus_transport_get_protocol (DBusTransport *transport)
+{
+  return transport->protocol;
+}
+
 /**
  * Initializes the base class members of DBusTransport.  Chained up to
  * by subclasses in their constructor.  The server GUID is the
@@ -571,6 +579,7 @@ _dbus_transport_open (DBusAddressEntry *entry,
        */
       if(expected_guid)
         transport->expected_guid = expected_guid;
+      _dbus_on_new_bus (_dbus_transport_get_protocol (transport));
     }
 
   return transport;
@@ -1461,9 +1470,11 @@ _dbus_transport_set_get_unix_process_id_function (DBusTransport
  */
 void
 _dbus_transport_set_assure_protocol_function (DBusTransport                      *transport,
-                                              DBusTransportAssureProtocolFunction function)
+                                              DBusTransportAssureProtocolFunction function,
+                                              int                                 protocol)
 {
   transport->assure_protocol_function = function;
+  transport->protocol = protocol;
 }
 
 /**