Merge "Optional autogen.sh flag --enable-kdbus-transport added allowing to compile...

[platform/upstream/dbus.git] / dbus / dbus-message-factory.c

diff --git a/dbus/dbus-message-factory.c b/dbus/dbus-message-factory.c
index 7432cf2..b742e4c 100644 (file)
--- a/dbus/dbus-message-factory.c
+++ b/dbus/dbus-message-factory.c
@@ -24,9 +24,10 @@
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
 #include "dbus-message-factory.h"
 #include "dbus-message-private.h"
+#include "dbus-signature.h"
 #include "dbus-test.h"
 #include <stdio.h>
 
@@ -169,6 +170,7 @@ generate_many_bodies_inner (DBusMessageDataIter *iter,
   DBusMessage *message;
   DBusString signature;
   DBusString body;
+  char byte_order;
 
   /* Keeping this small makes things go faster */
   message = dbus_message_new_method_call ("o.z.F",
@@ -178,13 +180,15 @@ generate_many_bodies_inner (DBusMessageDataIter *iter,
   if (message == NULL)
     _dbus_assert_not_reached ("oom");
 
+  byte_order = _dbus_header_get_byte_order (&message->header);
+
   set_reply_serial (message);
 
   if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
     _dbus_assert_not_reached ("oom");
   
   if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
-                                                message->byte_order,
+                                                byte_order,
                                                 &signature, &body))
     {
       const char *v_SIGNATURE;
@@ -201,7 +205,7 @@ generate_many_bodies_inner (DBusMessageDataIter *iter,
 
       _dbus_marshal_set_uint32 (&message->header.data, BODY_LENGTH_OFFSET,
                                 _dbus_string_get_length (&message->body),
-                                message->byte_order);
+                                byte_order);
       
       *message_p = message;
     }
@@ -333,6 +337,53 @@ simple_error (void)
   return message;
 }
 
+static DBusMessage*
+message_with_nesting_levels (int levels)
+{
+  DBusMessage *message;
+  dbus_int32_t v_INT32;
+  DBusMessageIter *parents;
+  DBusMessageIter *children;
+  int i;
+
+  /* If levels is higher it breaks sig_refcount in DBusMessageRealIter
+   * in dbus-message.c, this assert is just to help you know you need
+   * to fix that if you hit it
+   */
+  _dbus_assert (levels < 256);
+
+  parents = dbus_new(DBusMessageIter, levels + 1);
+  children = dbus_new(DBusMessageIter, levels + 1);
+
+  v_INT32 = 42;
+  message = simple_method_call ();
+
+  i = 0;
+  dbus_message_iter_init_append (message, &parents[i]);
+  while (i < levels)
+    {
+      dbus_message_iter_open_container (&parents[i], DBUS_TYPE_VARIANT,
+                                        i == (levels - 1) ?
+                                        DBUS_TYPE_INT32_AS_STRING :
+                                        DBUS_TYPE_VARIANT_AS_STRING,
+                                        &children[i]);
+      ++i;
+      parents[i] = children[i-1];
+    }
+  --i;
+  dbus_message_iter_append_basic (&children[i], DBUS_TYPE_INT32, &v_INT32);
+  while (i >= 0)
+    {
+      dbus_message_iter_close_container (&parents[i], &children[i]);
+      --i;
+    }
+
+  dbus_free(parents);
+  dbus_free(children);
+
+  return message;
+}
+
 static dbus_bool_t
 generate_special (DBusMessageDataIter   *iter,
                   DBusString            *data,
@@ -530,15 +581,18 @@ generate_special (DBusMessageDataIter   *iter,
     }
   else if (item_seq == 8)
     {
+      char byte_order;
+
       message = simple_method_call ();
+      byte_order = _dbus_header_get_byte_order (&message->header);
       generate_from_message (data, expected_validity, message);
       
       _dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
                                 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
-                                message->byte_order);
+                                byte_order);
       _dbus_marshal_set_uint32 (data, FIELDS_ARRAY_LENGTH_OFFSET,
                                 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
-                                message->byte_order);
+                                byte_order);
       *expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
     }
   else if (item_seq == 9)
@@ -735,6 +789,24 @@ generate_special (DBusMessageDataIter   *iter,
       
       *expected_validity = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
     }
+  else if (item_seq == 20)
+    {
+      /* 64 levels of nesting is OK */
+      message = message_with_nesting_levels(64);
+
+      generate_from_message (data, expected_validity, message);
+
+      *expected_validity = DBUS_VALID;
+    }
+  else if (item_seq == 21)
+    {
+      /* 65 levels of nesting is not OK */
+      message = message_with_nesting_levels(65);
+
+      generate_from_message (data, expected_validity, message);
+
+      *expected_validity = DBUS_INVALID_NESTED_TOO_DEEPLY;
+    }
   else
     {
       return FALSE;
@@ -870,6 +942,9 @@ generate_byte_changed (DBusMessageDataIter *iter,
   return TRUE;
 }
 
+#if 0
+/* This is really expensive and doesn't add too much coverage */
+
 static dbus_bool_t
 find_next_typecode (DBusMessageDataIter *iter,
                     DBusString          *data,
@@ -913,7 +988,7 @@ find_next_typecode (DBusMessageDataIter *iter,
 
       _dbus_assert (byte_seq < _dbus_string_get_length (data));
 
-      if (_dbus_type_is_valid (_dbus_string_get_byte (data, byte_seq)))
+      if (dbus_type_is_valid (_dbus_string_get_byte (data, byte_seq)))
         break;
       else
         iter_next (iter);
@@ -952,7 +1027,7 @@ static const int typecodes[] = {
   DBUS_TYPE_UNIX_FD,
   255 /* random invalid typecode */
 };
-  
+
 static dbus_bool_t
 generate_typecode_changed (DBusMessageDataIter *iter,
                            DBusString          *data,
@@ -1009,6 +1084,7 @@ generate_typecode_changed (DBusMessageDataIter *iter,
   *expected_validity = DBUS_VALIDITY_UNKNOWN;
   return TRUE;
 }
+#endif
 
 typedef struct
 {
@@ -1226,4 +1302,4 @@ _dbus_message_data_iter_get_and_next (DBusMessageDataIter *iter,
 
 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */
 
-#endif /* DBUS_BUILD_TESTS */
+#endif /* DBUS_ENABLE_EMBEDDED_TESTS */