• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List

dbus-message-util.c

00001 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
00002 /* dbus-message-util.c Would be in dbus-message.c, but only used by bus/tests
00003  *
00004  * Copyright (C) 2002, 2003, 2004, 2005  Red Hat Inc.
00005  * Copyright (C) 2002, 2003  CodeFactory AB
00006  *
00007  * Licensed under the Academic Free License version 2.1
00008  *
00009  * This program is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version.
00013  *
00014  * This program is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU General Public License
00020  * along with this program; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00022  *
00023  */
00024 
00025 #include <config.h>
00026 #include "dbus-internals.h"
00027 #include "dbus-test.h"
00028 #include "dbus-message-private.h"
00029 #include "dbus-marshal-recursive.h"
00030 #include "dbus-string.h"
00031 #ifdef HAVE_UNIX_FD_PASSING
00032 #include "dbus-sysdeps-unix.h"
00033 #endif
00034 
00035 #ifdef __linux__
00036 /* Necessary for the Linux-specific fd leak checking code only */
00037 #include <sys/types.h>
00038 #include <dirent.h>
00039 #include <stdlib.h>
00040 #include <errno.h>
00041 #endif
00042 
00048 #ifdef DBUS_BUILD_TESTS
00049 
00061 static dbus_bool_t
00062 dbus_message_iter_get_args (DBusMessageIter *iter,
00063                             DBusError       *error,
00064                             int              first_arg_type,
00065                             ...)
00066 {
00067   dbus_bool_t retval;
00068   va_list var_args;
00069 
00070   _dbus_return_val_if_fail (iter != NULL, FALSE);
00071   _dbus_return_val_if_error_is_set (error, FALSE);
00072 
00073   va_start (var_args, first_arg_type);
00074   retval = _dbus_message_iter_get_args_valist (iter, error, first_arg_type, var_args);
00075   va_end (var_args);
00076 
00077   return retval;
00078 }
00079 #endif /* DBUS_BUILD_TESTS */
00080 
00083 #ifdef DBUS_BUILD_TESTS
00084 #include "dbus-test.h"
00085 #include "dbus-message-factory.h"
00086 #include <stdio.h>
00087 #include <stdlib.h>
00088 
00089 static int validities_seen[DBUS_VALIDITY_LAST + _DBUS_NEGATIVE_VALIDITY_COUNT];
00090 
00091 static void
00092 reset_validities_seen (void)
00093 {
00094   int i;
00095   i = 0;
00096   while (i < _DBUS_N_ELEMENTS (validities_seen))
00097     {
00098       validities_seen[i] = 0;
00099       ++i;
00100     }
00101 }
00102 
00103 static void
00104 record_validity_seen (DBusValidity validity)
00105 {
00106   validities_seen[validity + _DBUS_NEGATIVE_VALIDITY_COUNT] += 1;
00107 }
00108 
00109 static void
00110 print_validities_seen (dbus_bool_t not_seen)
00111 {
00112   int i;
00113   i = 0;
00114   while (i < _DBUS_N_ELEMENTS (validities_seen))
00115     {
00116       if ((i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_VALIDITY_UNKNOWN ||
00117           (i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_INVALID_FOR_UNKNOWN_REASON)
00118         ;
00119       else if ((not_seen && validities_seen[i] == 0) ||
00120                (!not_seen && validities_seen[i] > 0))
00121         printf ("validity %3d seen %d times\n",
00122                 i - _DBUS_NEGATIVE_VALIDITY_COUNT,
00123                 validities_seen[i]);
00124       ++i;
00125     }
00126 }
00127 
00128 static void
00129 check_memleaks (void)
00130 {
00131   dbus_shutdown ();
00132 
00133   if (_dbus_get_malloc_blocks_outstanding () != 0)
00134     {
00135       _dbus_warn ("%d dbus_malloc blocks were not freed in %s\n",
00136                   _dbus_get_malloc_blocks_outstanding (), __FILE__);
00137       _dbus_assert_not_reached ("memleaks");
00138     }
00139 }
00140 
00141 void
00142 _dbus_check_fdleaks(void)
00143 {
00144 
00145 #ifdef __linux__
00146 
00147   DIR *d;
00148 
00149   /* This works on Linux only */
00150 
00151   if ((d = opendir("/proc/self/fd")))
00152     {
00153       struct dirent *de;
00154 
00155       while ((de = readdir(d)))
00156         {
00157           long l;
00158           char *e = NULL;
00159           int fd;
00160 
00161           if (de->d_name[0] == '.')
00162             continue;
00163 
00164           errno = 0;
00165           l = strtol(de->d_name, &e, 10);
00166           _dbus_assert(errno == 0 && e && !*e);
00167 
00168           fd = (int) l;
00169 
00170           if (fd < 3)
00171             continue;
00172 
00173           if (fd == dirfd(d))
00174             continue;
00175 
00176           _dbus_warn("file descriptor %i leaked in %s.\n", fd, __FILE__);
00177           _dbus_assert_not_reached("fdleaks");
00178         }
00179 
00180       closedir(d);
00181     }
00182 #endif
00183 }
00184 
00185 static dbus_bool_t
00186 check_have_valid_message (DBusMessageLoader *loader)
00187 {
00188   DBusMessage *message;
00189   dbus_bool_t retval;
00190 
00191   message = NULL;
00192   retval = FALSE;
00193 
00194   if (_dbus_message_loader_get_is_corrupted (loader))
00195     {
00196       _dbus_warn ("loader corrupted on message that was expected to be valid; invalid reason %d\n",
00197                   loader->corruption_reason);
00198       goto failed;
00199     }
00200 
00201   message = _dbus_message_loader_pop_message (loader);
00202   if (message == NULL)
00203     {
00204       _dbus_warn ("didn't load message that was expected to be valid (message not popped)\n");
00205       goto failed;
00206     }
00207 
00208   if (_dbus_string_get_length (&loader->data) > 0)
00209     {
00210       _dbus_warn ("had leftover bytes from expected-to-be-valid single message\n");
00211       goto failed;
00212     }
00213 
00214 #if 0
00215   /* FIXME */
00216   /* Verify that we're able to properly deal with the message.
00217    * For example, this would detect improper handling of messages
00218    * in nonstandard byte order.
00219    */
00220   if (!check_message_handling (message))
00221     goto failed;
00222 #endif
00223 
00224   record_validity_seen (DBUS_VALID);
00225   
00226   retval = TRUE;
00227 
00228  failed:
00229   if (message)
00230     dbus_message_unref (message);
00231 
00232   return retval;
00233 }
00234 
00235 static dbus_bool_t
00236 check_invalid_message (DBusMessageLoader *loader,
00237                        DBusValidity       expected_validity)
00238 {
00239   dbus_bool_t retval;
00240 
00241   retval = FALSE;
00242 
00243   if (!_dbus_message_loader_get_is_corrupted (loader))
00244     {
00245       _dbus_warn ("loader not corrupted on message that was expected to be invalid\n");
00246       goto failed;
00247     }
00248 
00249   record_validity_seen (loader->corruption_reason);
00250   
00251   if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
00252       loader->corruption_reason != expected_validity)
00253     {
00254       _dbus_warn ("expected message to be corrupted for reason %d and was corrupted for %d instead\n",
00255                   expected_validity, loader->corruption_reason);
00256       goto failed;
00257     }
00258 
00259   retval = TRUE;
00260 
00261  failed:
00262   return retval;
00263 }
00264 
00265 static dbus_bool_t
00266 check_incomplete_message (DBusMessageLoader *loader)
00267 {
00268   DBusMessage *message;
00269   dbus_bool_t retval;
00270 
00271   message = NULL;
00272   retval = FALSE;
00273 
00274   if (_dbus_message_loader_get_is_corrupted (loader))
00275     {
00276       _dbus_warn ("loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d\n",
00277                   loader->corruption_reason);
00278       goto failed;
00279     }
00280 
00281   message = _dbus_message_loader_pop_message (loader);
00282   if (message != NULL)
00283     {
00284       _dbus_warn ("loaded message that was expected to be incomplete\n");
00285       goto failed;
00286     }
00287 
00288   record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
00289   retval = TRUE;
00290 
00291  failed:
00292   if (message)
00293     dbus_message_unref (message);
00294   return retval;
00295 }
00296 
00297 static dbus_bool_t
00298 check_loader_results (DBusMessageLoader      *loader,
00299                       DBusValidity            expected_validity)
00300 {
00301   if (!_dbus_message_loader_queue_messages (loader))
00302     _dbus_assert_not_reached ("no memory to queue messages");
00303 
00304   if (expected_validity == DBUS_VALID)
00305     return check_have_valid_message (loader);
00306   else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
00307     return check_incomplete_message (loader);
00308   else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
00309     {
00310       /* here we just know we didn't segfault and that was the
00311        * only test. Also, we record that we got coverage
00312        * for the validity reason.
00313        */
00314       if (_dbus_message_loader_get_is_corrupted (loader))
00315         record_validity_seen (loader->corruption_reason);
00316       
00317       return TRUE;
00318     }
00319   else
00320     return check_invalid_message (loader, expected_validity);
00321 }
00322 
00330 dbus_bool_t
00331 dbus_internal_do_not_use_load_message_file (const DBusString    *filename,
00332                                             DBusString          *data)
00333 {
00334   dbus_bool_t retval;
00335   DBusError error = DBUS_ERROR_INIT;
00336 
00337   retval = FALSE;
00338 
00339   _dbus_verbose ("Loading raw %s\n", _dbus_string_get_const_data (filename));
00340   if (!_dbus_file_get_contents (data, filename, &error))
00341     {
00342       _dbus_warn ("Could not load message file %s: %s\n",
00343                   _dbus_string_get_const_data (filename),
00344                   error.message);
00345       dbus_error_free (&error);
00346       goto failed;
00347     }
00348 
00349   retval = TRUE;
00350 
00351  failed:
00352 
00353   return retval;
00354 }
00355 
00364 dbus_bool_t
00365 dbus_internal_do_not_use_try_message_file (const DBusString    *filename,
00366                                            DBusValidity         expected_validity)
00367 {
00368   DBusString data;
00369   dbus_bool_t retval;
00370 
00371   retval = FALSE;
00372 
00373   if (!_dbus_string_init (&data))
00374     _dbus_assert_not_reached ("could not allocate string\n");
00375 
00376   if (!dbus_internal_do_not_use_load_message_file (filename, &data))
00377     goto failed;
00378 
00379   retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
00380 
00381  failed:
00382 
00383   if (!retval)
00384     {
00385       if (_dbus_string_get_length (&data) > 0)
00386         _dbus_verbose_bytes_of_string (&data, 0,
00387                                        _dbus_string_get_length (&data));
00388 
00389       _dbus_warn ("Failed message loader test on %s\n",
00390                   _dbus_string_get_const_data (filename));
00391     }
00392 
00393   _dbus_string_free (&data);
00394 
00395   return retval;
00396 }
00397 
00406 dbus_bool_t
00407 dbus_internal_do_not_use_try_message_data (const DBusString    *data,
00408                                            DBusValidity         expected_validity)
00409 {
00410   DBusMessageLoader *loader;
00411   dbus_bool_t retval;
00412   int len;
00413   int i;
00414 
00415   loader = NULL;
00416   retval = FALSE;
00417 
00418   /* Write the data one byte at a time */
00419 
00420   loader = _dbus_message_loader_new ();
00421 
00422   /* check some trivial loader functions */
00423   _dbus_message_loader_ref (loader);
00424   _dbus_message_loader_unref (loader);
00425   _dbus_message_loader_get_max_message_size (loader);
00426 
00427   len = _dbus_string_get_length (data);
00428   for (i = 0; i < len; i++)
00429     {
00430       DBusString *buffer;
00431 
00432       _dbus_message_loader_get_buffer (loader, &buffer);
00433       _dbus_string_append_byte (buffer,
00434                                 _dbus_string_get_byte (data, i));
00435       _dbus_message_loader_return_buffer (loader, buffer, 1);
00436     }
00437 
00438   if (!check_loader_results (loader, expected_validity))
00439     goto failed;
00440 
00441   _dbus_message_loader_unref (loader);
00442   loader = NULL;
00443 
00444   /* Write the data all at once */
00445 
00446   loader = _dbus_message_loader_new ();
00447 
00448   {
00449     DBusString *buffer;
00450 
00451     _dbus_message_loader_get_buffer (loader, &buffer);
00452     _dbus_string_copy (data, 0, buffer,
00453                        _dbus_string_get_length (buffer));
00454     _dbus_message_loader_return_buffer (loader, buffer, 1);
00455   }
00456 
00457   if (!check_loader_results (loader, expected_validity))
00458     goto failed;
00459 
00460   _dbus_message_loader_unref (loader);
00461   loader = NULL;
00462 
00463   /* Write the data 2 bytes at a time */
00464 
00465   loader = _dbus_message_loader_new ();
00466 
00467   len = _dbus_string_get_length (data);
00468   for (i = 0; i < len; i += 2)
00469     {
00470       DBusString *buffer;
00471 
00472       _dbus_message_loader_get_buffer (loader, &buffer);
00473       _dbus_string_append_byte (buffer,
00474                                 _dbus_string_get_byte (data, i));
00475       if ((i+1) < len)
00476         _dbus_string_append_byte (buffer,
00477                                   _dbus_string_get_byte (data, i+1));
00478       _dbus_message_loader_return_buffer (loader, buffer, 1);
00479     }
00480 
00481   if (!check_loader_results (loader, expected_validity))
00482     goto failed;
00483 
00484   _dbus_message_loader_unref (loader);
00485   loader = NULL;
00486 
00487   retval = TRUE;
00488 
00489  failed:
00490 
00491   if (loader)
00492     _dbus_message_loader_unref (loader);
00493 
00494   return retval;
00495 }
00496 
00497 static dbus_bool_t
00498 process_test_subdir (const DBusString          *test_base_dir,
00499                      const char                *subdir,
00500                      DBusValidity               expected_validity,
00501                      DBusForeachMessageFileFunc function,
00502                      void                      *user_data)
00503 {
00504   DBusString test_directory;
00505   DBusString filename;
00506   DBusDirIter *dir;
00507   dbus_bool_t retval;
00508   DBusError error = DBUS_ERROR_INIT;
00509 
00510   retval = FALSE;
00511   dir = NULL;
00512 
00513   if (!_dbus_string_init (&test_directory))
00514     _dbus_assert_not_reached ("didn't allocate test_directory\n");
00515 
00516   _dbus_string_init_const (&filename, subdir);
00517 
00518   if (!_dbus_string_copy (test_base_dir, 0,
00519                           &test_directory, 0))
00520     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
00521 
00522   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
00523     _dbus_assert_not_reached ("couldn't allocate full path");
00524 
00525   _dbus_string_free (&filename);
00526   if (!_dbus_string_init (&filename))
00527     _dbus_assert_not_reached ("didn't allocate filename string\n");
00528 
00529   dir = _dbus_directory_open (&test_directory, &error);
00530   if (dir == NULL)
00531     {
00532       _dbus_warn ("Could not open %s: %s\n",
00533                   _dbus_string_get_const_data (&test_directory),
00534                   error.message);
00535       dbus_error_free (&error);
00536       goto failed;
00537     }
00538 
00539   printf ("Testing %s:\n", subdir);
00540 
00541  next:
00542   while (_dbus_directory_get_next_file (dir, &filename, &error))
00543     {
00544       DBusString full_path;
00545 
00546       if (!_dbus_string_init (&full_path))
00547         _dbus_assert_not_reached ("couldn't init string");
00548 
00549       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
00550         _dbus_assert_not_reached ("couldn't copy dir to full_path");
00551 
00552       if (!_dbus_concat_dir_and_file (&full_path, &filename))
00553         _dbus_assert_not_reached ("couldn't concat file to dir");
00554 
00555       if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
00556         ;
00557       else
00558         {
00559           if (_dbus_string_ends_with_c_str (&filename, ".message"))
00560             {
00561               _dbus_warn ("Could not load %s, message builder language no longer supported\n",
00562                           _dbus_string_get_const_data (&filename));
00563             }
00564           
00565           _dbus_verbose ("Skipping non-.message file %s\n",
00566                          _dbus_string_get_const_data (&filename));
00567           _dbus_string_free (&full_path);
00568           goto next;
00569         }
00570 
00571       printf ("    %s\n",
00572               _dbus_string_get_const_data (&filename));
00573 
00574       if (! (*function) (&full_path,
00575                          expected_validity, user_data))
00576         {
00577           _dbus_string_free (&full_path);
00578           goto failed;
00579         }
00580       else
00581         _dbus_string_free (&full_path);
00582     }
00583 
00584   if (dbus_error_is_set (&error))
00585     {
00586       _dbus_warn ("Could not get next file in %s: %s\n",
00587                   _dbus_string_get_const_data (&test_directory),
00588                   error.message);
00589       dbus_error_free (&error);
00590       goto failed;
00591     }
00592 
00593   retval = TRUE;
00594 
00595  failed:
00596 
00597   if (dir)
00598     _dbus_directory_close (dir);
00599   _dbus_string_free (&test_directory);
00600   _dbus_string_free (&filename);
00601 
00602   return retval;
00603 }
00604 
00614 dbus_bool_t
00615 dbus_internal_do_not_use_foreach_message_file (const char                *test_data_dir,
00616                                                DBusForeachMessageFileFunc func,
00617                                                void                      *user_data)
00618 {
00619   DBusString test_directory;
00620   dbus_bool_t retval;
00621 
00622   retval = FALSE;
00623 
00624   _dbus_string_init_const (&test_directory, test_data_dir);
00625   
00626   if (!process_test_subdir (&test_directory, "valid-messages",
00627                             DBUS_VALID, func, user_data))
00628     goto failed;
00629 
00630   check_memleaks ();
00631   
00632   if (!process_test_subdir (&test_directory, "invalid-messages",
00633                             DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
00634     goto failed;
00635 
00636   check_memleaks ();
00637   
00638   if (!process_test_subdir (&test_directory, "incomplete-messages",
00639                             DBUS_VALID_BUT_INCOMPLETE, func, user_data))
00640     goto failed;
00641 
00642   check_memleaks ();
00643   
00644   retval = TRUE;
00645   
00646  failed:
00647 
00648   _dbus_string_free (&test_directory);
00649 
00650   return retval;
00651 }
00652 
00653 #if 0
00654 #define GET_AND_CHECK(iter, typename, literal)                                  \
00655   do {                                                                          \
00656     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
00657       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
00658     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
00659     if (v_##typename != literal)                                                \
00660       _dbus_assert_not_reached ("got wrong value from message iter");           \
00661   } while (0)
00662 
00663 #define GET_AND_CHECK_STRCMP(iter, typename, literal)                           \
00664   do {                                                                          \
00665     if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename)         \
00666       _dbus_assert_not_reached ("got wrong argument type from message iter");   \
00667     dbus_message_iter_get_basic (&iter, &v_##typename);                         \
00668     if (strcmp (v_##typename, literal) != 0)                                    \
00669       _dbus_assert_not_reached ("got wrong value from message iter");           \
00670   } while (0)
00671 
00672 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal)         \
00673   do {                                                          \
00674     GET_AND_CHECK(iter, typename, literal);                     \
00675     if (!dbus_message_iter_next (&iter))                        \
00676       _dbus_assert_not_reached ("failed to move iter to next"); \
00677   } while (0)
00678 
00679 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal)  \
00680   do {                                                          \
00681     GET_AND_CHECK_STRCMP(iter, typename, literal);              \
00682     if (!dbus_message_iter_next (&iter))                        \
00683       _dbus_assert_not_reached ("failed to move iter to next"); \
00684   } while (0)
00685 
00686 static void
00687 message_iter_test (DBusMessage *message)
00688 {
00689   DBusMessageIter iter, array, array2;
00690   const char *v_STRING;
00691   double v_DOUBLE;
00692   dbus_int16_t v_INT16;
00693   dbus_uint16_t v_UINT16;
00694   dbus_int32_t v_INT32;
00695   dbus_uint32_t v_UINT32;
00696 #ifdef DBUS_HAVE_INT64
00697   dbus_int64_t v_INT64;
00698   dbus_uint64_t v_UINT64;
00699 #endif
00700   unsigned char v_BYTE;
00701   dbus_bool_t v_BOOLEAN;
00702 
00703   const dbus_int32_t *our_int_array;
00704   int len;
00705 
00706   dbus_message_iter_init (message, &iter);
00707 
00708   GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, "Test string");
00709   GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
00710   GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
00711   GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
00712 
00713   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00714     _dbus_assert_not_reached ("Argument type not an array");
00715 
00716   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_DOUBLE)
00717     _dbus_assert_not_reached ("Array type not double");
00718 
00719   dbus_message_iter_recurse (&iter, &array);
00720 
00721   GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
00722   GET_AND_CHECK (array, DOUBLE, 2.5);
00723 
00724   if (dbus_message_iter_next (&array))
00725     _dbus_assert_not_reached ("Didn't reach end of array");
00726 
00727   if (!dbus_message_iter_next (&iter))
00728     _dbus_assert_not_reached ("Reached end of arguments");
00729 
00730   GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
00731 
00732   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00733     _dbus_assert_not_reached ("no array");
00734 
00735   if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_INT32)
00736     _dbus_assert_not_reached ("Array type not int32");
00737 
00738   /* Empty array */
00739   dbus_message_iter_recurse (&iter, &array);
00740 
00741   if (dbus_message_iter_next (&array))
00742     _dbus_assert_not_reached ("Didn't reach end of array");
00743 
00744   if (!dbus_message_iter_next (&iter))
00745     _dbus_assert_not_reached ("Reached end of arguments");
00746 
00747   GET_AND_CHECK (iter, BYTE, 0xF0);
00748 
00749   if (dbus_message_iter_next (&iter))
00750     _dbus_assert_not_reached ("Didn't reach end of arguments");
00751 }
00752 #endif
00753 
00754 static void
00755 verify_test_message (DBusMessage *message)
00756 {
00757   DBusMessageIter iter;
00758   DBusError error = DBUS_ERROR_INIT;
00759   dbus_int16_t our_int16;
00760   dbus_uint16_t our_uint16;
00761   dbus_int32_t our_int;
00762   dbus_uint32_t our_uint;
00763   const char *our_str;
00764   double our_double;
00765   double v_DOUBLE;
00766   dbus_bool_t our_bool;
00767   unsigned char our_byte_1, our_byte_2;
00768   const dbus_uint32_t *our_uint32_array = (void*)0xdeadbeef;
00769   int our_uint32_array_len;
00770   dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
00771   int our_int32_array_len;
00772 #ifdef DBUS_HAVE_INT64
00773   dbus_int64_t our_int64;
00774   dbus_uint64_t our_uint64;
00775   dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
00776   int our_uint64_array_len;
00777   const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
00778   int our_int64_array_len;
00779 #endif
00780   const double *our_double_array = (void*)0xdeadbeef;
00781   int our_double_array_len;
00782   const unsigned char *our_byte_array = (void*)0xdeadbeef;
00783   int our_byte_array_len;
00784   const dbus_bool_t *our_boolean_array = (void*)0xdeadbeef;
00785   int our_boolean_array_len;
00786   char **our_string_array;
00787   int our_string_array_len;
00788 
00789   dbus_message_iter_init (message, &iter);
00790 
00791   if (!dbus_message_iter_get_args (&iter, &error,
00792                                    DBUS_TYPE_INT16, &our_int16,
00793                                    DBUS_TYPE_UINT16, &our_uint16,
00794                                    DBUS_TYPE_INT32, &our_int,
00795                                    DBUS_TYPE_UINT32, &our_uint,
00796 #ifdef DBUS_HAVE_INT64
00797                                    DBUS_TYPE_INT64, &our_int64,
00798                                    DBUS_TYPE_UINT64, &our_uint64,
00799 #endif
00800                                    DBUS_TYPE_STRING, &our_str,
00801                                    DBUS_TYPE_DOUBLE, &our_double,
00802                                    DBUS_TYPE_BOOLEAN, &our_bool,
00803                                    DBUS_TYPE_BYTE, &our_byte_1,
00804                                    DBUS_TYPE_BYTE, &our_byte_2,
00805                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
00806                                    &our_uint32_array, &our_uint32_array_len,
00807                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
00808                                    &our_int32_array, &our_int32_array_len,
00809 #ifdef DBUS_HAVE_INT64
00810                                    DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64,
00811                                    &our_uint64_array, &our_uint64_array_len,
00812                                    DBUS_TYPE_ARRAY, DBUS_TYPE_INT64,
00813                                    &our_int64_array, &our_int64_array_len,
00814 #endif
00815                                    DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE,
00816                                    &our_double_array, &our_double_array_len,
00817                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
00818                                    &our_byte_array, &our_byte_array_len,
00819                                    DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN,
00820                                    &our_boolean_array, &our_boolean_array_len,
00821                                    DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
00822                                    &our_string_array, &our_string_array_len,
00823                                    0))
00824     {
00825       _dbus_warn ("error: %s - %s\n", error.name,
00826                   (error.message != NULL) ? error.message : "no message");
00827       _dbus_assert_not_reached ("Could not get arguments");
00828     }
00829 
00830   if (our_int16 != -0x123)
00831     _dbus_assert_not_reached ("16-bit integers differ!");
00832 
00833   if (our_uint16 != 0x123)
00834     _dbus_assert_not_reached ("16-bit uints differ!");
00835   
00836   if (our_int != -0x12345678)
00837     _dbus_assert_not_reached ("integers differ!");
00838 
00839   if (our_uint != 0x12300042)
00840     _dbus_assert_not_reached ("uints differ!");
00841 
00842 #ifdef DBUS_HAVE_INT64
00843   if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
00844     _dbus_assert_not_reached ("64-bit integers differ!");
00845   if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
00846     _dbus_assert_not_reached ("64-bit unsigned integers differ!");
00847 #endif
00848 
00849   v_DOUBLE = 3.14159;
00850   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
00851     _dbus_assert_not_reached ("doubles differ!");
00852 
00853   if (strcmp (our_str, "Test string") != 0)
00854     _dbus_assert_not_reached ("strings differ!");
00855 
00856   if (!our_bool)
00857     _dbus_assert_not_reached ("booleans differ");
00858 
00859   if (our_byte_1 != 42)
00860     _dbus_assert_not_reached ("bytes differ!");
00861 
00862   if (our_byte_2 != 24)
00863     _dbus_assert_not_reached ("bytes differ!");
00864 
00865   if (our_uint32_array_len != 4 ||
00866       our_uint32_array[0] != 0x12345678 ||
00867       our_uint32_array[1] != 0x23456781 ||
00868       our_uint32_array[2] != 0x34567812 ||
00869       our_uint32_array[3] != 0x45678123)
00870     _dbus_assert_not_reached ("uint array differs");
00871 
00872   if (our_int32_array_len != 4 ||
00873       our_int32_array[0] != 0x12345678 ||
00874       our_int32_array[1] != -0x23456781 ||
00875       our_int32_array[2] != 0x34567812 ||
00876       our_int32_array[3] != -0x45678123)
00877     _dbus_assert_not_reached ("int array differs");
00878 
00879 #ifdef DBUS_HAVE_INT64
00880   if (our_uint64_array_len != 4 ||
00881       our_uint64_array[0] != 0x12345678 ||
00882       our_uint64_array[1] != 0x23456781 ||
00883       our_uint64_array[2] != 0x34567812 ||
00884       our_uint64_array[3] != 0x45678123)
00885     _dbus_assert_not_reached ("uint64 array differs");
00886 
00887   if (our_int64_array_len != 4 ||
00888       our_int64_array[0] != 0x12345678 ||
00889       our_int64_array[1] != -0x23456781 ||
00890       our_int64_array[2] != 0x34567812 ||
00891       our_int64_array[3] != -0x45678123)
00892     _dbus_assert_not_reached ("int64 array differs");
00893 #endif /* DBUS_HAVE_INT64 */
00894 
00895   if (our_double_array_len != 3)
00896     _dbus_assert_not_reached ("double array had wrong length");
00897 
00898   /* On all IEEE machines (i.e. everything sane) exact equality
00899    * should be preserved over the wire
00900    */
00901   v_DOUBLE = 0.1234;
00902   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[0], v_DOUBLE))
00903     _dbus_assert_not_reached ("double array had wrong values");
00904   v_DOUBLE = 9876.54321;
00905   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[1], v_DOUBLE))
00906     _dbus_assert_not_reached ("double array had wrong values");
00907   v_DOUBLE = -300.0;
00908   if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[2], v_DOUBLE))
00909     _dbus_assert_not_reached ("double array had wrong values");
00910 
00911   if (our_byte_array_len != 4)
00912     _dbus_assert_not_reached ("byte array had wrong length");
00913 
00914   if (our_byte_array[0] != 'a' ||
00915       our_byte_array[1] != 'b' ||
00916       our_byte_array[2] != 'c' ||
00917       our_byte_array[3] != 234)
00918     _dbus_assert_not_reached ("byte array had wrong values");
00919 
00920   if (our_boolean_array_len != 5)
00921     _dbus_assert_not_reached ("bool array had wrong length");
00922 
00923   if (our_boolean_array[0] != TRUE ||
00924       our_boolean_array[1] != FALSE ||
00925       our_boolean_array[2] != TRUE ||
00926       our_boolean_array[3] != TRUE ||
00927       our_boolean_array[4] != FALSE)
00928     _dbus_assert_not_reached ("bool array had wrong values");
00929 
00930   if (our_string_array_len != 4)
00931     _dbus_assert_not_reached ("string array was wrong length");
00932 
00933   if (strcmp (our_string_array[0], "Foo") != 0 ||
00934       strcmp (our_string_array[1], "bar") != 0 ||
00935       strcmp (our_string_array[2], "") != 0 ||
00936       strcmp (our_string_array[3], "woo woo woo woo") != 0)
00937     _dbus_assert_not_reached ("string array had wrong values");
00938 
00939   dbus_free_string_array (our_string_array);
00940   
00941   if (dbus_message_iter_next (&iter))
00942     _dbus_assert_not_reached ("Didn't reach end of arguments");
00943 }
00944 
00951 dbus_bool_t
00952 _dbus_message_test (const char *test_data_dir)
00953 {
00954   DBusMessage *message, *message_without_unix_fds;
00955   DBusMessageLoader *loader;
00956   int i;
00957   const char *data;
00958   DBusMessage *copy;
00959   const char *name1;
00960   const char *name2;
00961   const dbus_uint32_t our_uint32_array[] =
00962     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
00963   const dbus_int32_t our_int32_array[] =
00964     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
00965   const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
00966   const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
00967 #ifdef DBUS_HAVE_INT64
00968   const dbus_uint64_t our_uint64_array[] =
00969     { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
00970   const dbus_int64_t our_int64_array[] =
00971     { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
00972   const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
00973   const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
00974 #endif
00975   const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
00976   const char **v_ARRAY_STRING = our_string_array;
00977   const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
00978   const double *v_ARRAY_DOUBLE = our_double_array;
00979   const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
00980   const unsigned char *v_ARRAY_BYTE = our_byte_array;
00981   const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
00982   const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
00983   char sig[64];
00984   const char *s;
00985   const char *v_STRING;
00986   double v_DOUBLE;
00987   dbus_int16_t v_INT16;
00988   dbus_uint16_t v_UINT16;
00989   dbus_int32_t v_INT32;
00990   dbus_uint32_t v_UINT32;
00991 #ifdef DBUS_HAVE_INT64
00992   dbus_int64_t v_INT64;
00993   dbus_uint64_t v_UINT64;
00994 #endif
00995   unsigned char v_BYTE;
00996   unsigned char v2_BYTE;
00997   dbus_bool_t v_BOOLEAN;
00998   DBusMessageIter iter, array_iter, struct_iter;
00999 #ifdef HAVE_UNIX_FD_PASSING
01000   int v_UNIX_FD;
01001 #endif
01002   char **decomposed;
01003 
01004   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01005                                           "/org/freedesktop/TestPath",
01006                                           "Foo.TestInterface",
01007                                           "TestMethod");
01008   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
01009   _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
01010                                              "TestMethod"));
01011   _dbus_assert (strcmp (dbus_message_get_path (message),
01012                         "/org/freedesktop/TestPath") == 0);
01013   dbus_message_set_serial (message, 1234);
01014 
01015   /* string length including nul byte not a multiple of 4 */
01016   if (!dbus_message_set_sender (message, "org.foo.bar1"))
01017     _dbus_assert_not_reached ("out of memory");
01018 
01019   _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
01020   dbus_message_set_reply_serial (message, 5678);
01021 
01022   _dbus_verbose_bytes_of_string (&message->header.data, 0,
01023                                  _dbus_string_get_length (&message->header.data));
01024   _dbus_verbose_bytes_of_string (&message->body, 0,
01025                                  _dbus_string_get_length (&message->body));
01026 
01027   if (!dbus_message_set_sender (message, NULL))
01028     _dbus_assert_not_reached ("out of memory");
01029 
01030 
01031   _dbus_verbose_bytes_of_string (&message->header.data, 0,
01032                                  _dbus_string_get_length (&message->header.data));
01033   _dbus_verbose_bytes_of_string (&message->body, 0,
01034                                  _dbus_string_get_length (&message->body));
01035 
01036 
01037   _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
01038   _dbus_assert (dbus_message_get_serial (message) == 1234);
01039   _dbus_assert (dbus_message_get_reply_serial (message) == 5678);
01040   _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
01041 
01042   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
01043   dbus_message_set_no_reply (message, TRUE);
01044   _dbus_assert (dbus_message_get_no_reply (message) == TRUE);
01045   dbus_message_set_no_reply (message, FALSE);
01046   _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
01047 
01048   /* Set/get some header fields */
01049 
01050   if (!dbus_message_set_path (message, "/foo"))
01051     _dbus_assert_not_reached ("out of memory");
01052   _dbus_assert (strcmp (dbus_message_get_path (message),
01053                         "/foo") == 0);
01054 
01055   if (!dbus_message_set_interface (message, "org.Foo"))
01056     _dbus_assert_not_reached ("out of memory");
01057   _dbus_assert (strcmp (dbus_message_get_interface (message),
01058                         "org.Foo") == 0);
01059 
01060   if (!dbus_message_set_member (message, "Bar"))
01061     _dbus_assert_not_reached ("out of memory");
01062   _dbus_assert (strcmp (dbus_message_get_member (message),
01063                         "Bar") == 0);
01064 
01065   /* Set/get them with longer values */
01066   if (!dbus_message_set_path (message, "/foo/bar"))
01067     _dbus_assert_not_reached ("out of memory");
01068   _dbus_assert (strcmp (dbus_message_get_path (message),
01069                         "/foo/bar") == 0);
01070 
01071   if (!dbus_message_set_interface (message, "org.Foo.Bar"))
01072     _dbus_assert_not_reached ("out of memory");
01073   _dbus_assert (strcmp (dbus_message_get_interface (message),
01074                         "org.Foo.Bar") == 0);
01075 
01076   if (!dbus_message_set_member (message, "BarFoo"))
01077     _dbus_assert_not_reached ("out of memory");
01078   _dbus_assert (strcmp (dbus_message_get_member (message),
01079                         "BarFoo") == 0);
01080 
01081   /* Realloc shorter again */
01082 
01083   if (!dbus_message_set_path (message, "/foo"))
01084     _dbus_assert_not_reached ("out of memory");
01085   _dbus_assert (strcmp (dbus_message_get_path (message),
01086                         "/foo") == 0);
01087 
01088   if (!dbus_message_set_interface (message, "org.Foo"))
01089     _dbus_assert_not_reached ("out of memory");
01090   _dbus_assert (strcmp (dbus_message_get_interface (message),
01091                         "org.Foo") == 0);
01092 
01093   if (!dbus_message_set_member (message, "Bar"))
01094     _dbus_assert_not_reached ("out of memory");
01095   _dbus_assert (strcmp (dbus_message_get_member (message),
01096                         "Bar") == 0);
01097 
01098   /* Path decomposing */
01099   dbus_message_set_path (message, NULL);
01100   dbus_message_get_path_decomposed (message, &decomposed);
01101   _dbus_assert (decomposed == NULL);
01102   dbus_free_string_array (decomposed);
01103 
01104   dbus_message_set_path (message, "/");
01105   dbus_message_get_path_decomposed (message, &decomposed);
01106   _dbus_assert (decomposed != NULL);
01107   _dbus_assert (decomposed[0] == NULL);
01108   dbus_free_string_array (decomposed);
01109 
01110   dbus_message_set_path (message, "/a/b");
01111   dbus_message_get_path_decomposed (message, &decomposed);
01112   _dbus_assert (decomposed != NULL);
01113   _dbus_assert (strcmp (decomposed[0], "a") == 0);
01114   _dbus_assert (strcmp (decomposed[1], "b") == 0);
01115   _dbus_assert (decomposed[2] == NULL);
01116   dbus_free_string_array (decomposed);
01117 
01118   dbus_message_set_path (message, "/spam/eggs");
01119   dbus_message_get_path_decomposed (message, &decomposed);
01120   _dbus_assert (decomposed != NULL);
01121   _dbus_assert (strcmp (decomposed[0], "spam") == 0);
01122   _dbus_assert (strcmp (decomposed[1], "eggs") == 0);
01123   _dbus_assert (decomposed[2] == NULL);
01124   dbus_free_string_array (decomposed);
01125 
01126   dbus_message_unref (message);
01127 
01128   /* Test the vararg functions */
01129   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01130                                           "/org/freedesktop/TestPath",
01131                                           "Foo.TestInterface",
01132                                           "TestMethod");
01133   dbus_message_set_serial (message, 1);
01134   dbus_message_set_reply_serial (message, 5678);
01135 
01136   v_INT16 = -0x123;
01137   v_UINT16 = 0x123;
01138   v_INT32 = -0x12345678;
01139   v_UINT32 = 0x12300042;
01140 #ifdef DBUS_HAVE_INT64
01141   v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
01142   v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
01143 #endif
01144   v_STRING = "Test string";
01145   v_DOUBLE = 3.14159;
01146   v_BOOLEAN = TRUE;
01147   v_BYTE = 42;
01148   v2_BYTE = 24;
01149 #ifdef HAVE_UNIX_FD_PASSING
01150   v_UNIX_FD = 1;
01151 #endif
01152 
01153   dbus_message_append_args (message,
01154                             DBUS_TYPE_INT16, &v_INT16,
01155                             DBUS_TYPE_UINT16, &v_UINT16,
01156                             DBUS_TYPE_INT32, &v_INT32,
01157                             DBUS_TYPE_UINT32, &v_UINT32,
01158 #ifdef DBUS_HAVE_INT64
01159                             DBUS_TYPE_INT64, &v_INT64,
01160                             DBUS_TYPE_UINT64, &v_UINT64,
01161 #endif
01162                             DBUS_TYPE_STRING, &v_STRING,
01163                             DBUS_TYPE_DOUBLE, &v_DOUBLE,
01164                             DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
01165                             DBUS_TYPE_BYTE, &v_BYTE,
01166                             DBUS_TYPE_BYTE, &v2_BYTE,
01167                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
01168                             _DBUS_N_ELEMENTS (our_uint32_array),
01169                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
01170                             _DBUS_N_ELEMENTS (our_int32_array),
01171 #ifdef DBUS_HAVE_INT64
01172                             DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
01173                             _DBUS_N_ELEMENTS (our_uint64_array),
01174                             DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
01175                             _DBUS_N_ELEMENTS (our_int64_array),
01176 #endif
01177                             DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
01178                             _DBUS_N_ELEMENTS (our_double_array),
01179                             DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
01180                             _DBUS_N_ELEMENTS (our_byte_array),
01181                             DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
01182                             _DBUS_N_ELEMENTS (our_boolean_array),
01183                             DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
01184                             _DBUS_N_ELEMENTS (our_string_array),
01185 
01186                             DBUS_TYPE_INVALID);
01187 
01188   i = 0;
01189   sig[i++] = DBUS_TYPE_INT16;
01190   sig[i++] = DBUS_TYPE_UINT16;
01191   sig[i++] = DBUS_TYPE_INT32;
01192   sig[i++] = DBUS_TYPE_UINT32;
01193 #ifdef DBUS_HAVE_INT64
01194   sig[i++] = DBUS_TYPE_INT64;
01195   sig[i++] = DBUS_TYPE_UINT64;
01196 #endif
01197   sig[i++] = DBUS_TYPE_STRING;
01198   sig[i++] = DBUS_TYPE_DOUBLE;
01199   sig[i++] = DBUS_TYPE_BOOLEAN;
01200   sig[i++] = DBUS_TYPE_BYTE;
01201   sig[i++] = DBUS_TYPE_BYTE;
01202   sig[i++] = DBUS_TYPE_ARRAY;
01203   sig[i++] = DBUS_TYPE_UINT32;
01204   sig[i++] = DBUS_TYPE_ARRAY;
01205   sig[i++] = DBUS_TYPE_INT32;
01206 #ifdef DBUS_HAVE_INT64
01207   sig[i++] = DBUS_TYPE_ARRAY;
01208   sig[i++] = DBUS_TYPE_UINT64;
01209   sig[i++] = DBUS_TYPE_ARRAY;
01210   sig[i++] = DBUS_TYPE_INT64;
01211 #endif
01212   sig[i++] = DBUS_TYPE_ARRAY;
01213   sig[i++] = DBUS_TYPE_DOUBLE;
01214   sig[i++] = DBUS_TYPE_ARRAY;
01215   sig[i++] = DBUS_TYPE_BYTE;
01216   sig[i++] = DBUS_TYPE_ARRAY;
01217   sig[i++] = DBUS_TYPE_BOOLEAN;
01218   sig[i++] = DBUS_TYPE_ARRAY;
01219   sig[i++] = DBUS_TYPE_STRING;
01220 
01221   message_without_unix_fds = dbus_message_copy(message);
01222   _dbus_assert(message_without_unix_fds);
01223 #ifdef HAVE_UNIX_FD_PASSING
01224   dbus_message_append_args (message,
01225                             DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
01226                             DBUS_TYPE_INVALID);
01227   sig[i++] = DBUS_TYPE_UNIX_FD;
01228 #endif
01229   sig[i++] = DBUS_TYPE_INVALID;
01230 
01231   _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
01232 
01233   _dbus_verbose ("HEADER\n");
01234   _dbus_verbose_bytes_of_string (&message->header.data, 0,
01235                                  _dbus_string_get_length (&message->header.data));
01236   _dbus_verbose ("BODY\n");
01237   _dbus_verbose_bytes_of_string (&message->body, 0,
01238                                  _dbus_string_get_length (&message->body));
01239 
01240   _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
01241                  sig, dbus_message_get_signature (message));
01242 
01243   s = dbus_message_get_signature (message);
01244 
01245   _dbus_assert (dbus_message_has_signature (message, sig));
01246   _dbus_assert (strcmp (s, sig) == 0);
01247 
01248   verify_test_message (message);
01249 
01250   copy = dbus_message_copy (message);
01251 
01252   _dbus_assert (dbus_message_get_reply_serial (message) ==
01253                 dbus_message_get_reply_serial (copy));
01254   _dbus_assert (message->header.padding == copy->header.padding);
01255 
01256   _dbus_assert (_dbus_string_get_length (&message->header.data) ==
01257                 _dbus_string_get_length (&copy->header.data));
01258 
01259   _dbus_assert (_dbus_string_get_length (&message->body) ==
01260                 _dbus_string_get_length (&copy->body));
01261 
01262   verify_test_message (copy);
01263 
01264   name1 = dbus_message_get_interface (message);
01265   name2 = dbus_message_get_interface (copy);
01266 
01267   _dbus_assert (strcmp (name1, name2) == 0);
01268 
01269   name1 = dbus_message_get_member (message);
01270   name2 = dbus_message_get_member (copy);
01271 
01272   _dbus_assert (strcmp (name1, name2) == 0);
01273 
01274   dbus_message_unref (copy);
01275 
01276   /* Message loader test */
01277   dbus_message_lock (message);
01278   loader = _dbus_message_loader_new ();
01279   
01280   /* check ref/unref */
01281   _dbus_message_loader_ref (loader);
01282   _dbus_message_loader_unref (loader);
01283 
01284   /* Write the header data one byte at a time */
01285   data = _dbus_string_get_const_data (&message->header.data);
01286   for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
01287     {
01288       DBusString *buffer;
01289 
01290       _dbus_message_loader_get_buffer (loader, &buffer);
01291       _dbus_string_append_byte (buffer, data[i]);
01292       _dbus_message_loader_return_buffer (loader, buffer, 1);
01293     }
01294 
01295   /* Write the body data one byte at a time */
01296   data = _dbus_string_get_const_data (&message->body);
01297   for (i = 0; i < _dbus_string_get_length (&message->body); i++)
01298     {
01299       DBusString *buffer;
01300 
01301       _dbus_message_loader_get_buffer (loader, &buffer);
01302       _dbus_string_append_byte (buffer, data[i]);
01303       _dbus_message_loader_return_buffer (loader, buffer, 1);
01304     }
01305 
01306 #ifdef HAVE_UNIX_FD_PASSING
01307   {
01308     int *unix_fds;
01309     unsigned n_unix_fds;
01310     /* Write unix fd */
01311     _dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
01312     _dbus_assert(n_unix_fds > 0);
01313     _dbus_assert(message->n_unix_fds == 1);
01314     unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
01315     _dbus_assert(unix_fds[0] >= 0);
01316     _dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
01317   }
01318 #endif
01319 
01320   dbus_message_unref (message);
01321 
01322   /* Now pop back the message */
01323   if (!_dbus_message_loader_queue_messages (loader))
01324     _dbus_assert_not_reached ("no memory to queue messages");
01325 
01326   if (_dbus_message_loader_get_is_corrupted (loader))
01327     _dbus_assert_not_reached ("message loader corrupted");
01328 
01329   message = _dbus_message_loader_pop_message (loader);
01330   if (!message)
01331     _dbus_assert_not_reached ("received a NULL message");
01332 
01333   if (dbus_message_get_reply_serial (message) != 5678)
01334     _dbus_assert_not_reached ("reply serial fields differ");
01335 
01336   dbus_message_unref (message);
01337 
01338   /* ovveride the serial, since it was reset by dbus_message_copy() */
01339   dbus_message_set_serial(message_without_unix_fds, 8901);
01340 
01341   dbus_message_lock (message_without_unix_fds);
01342 
01343   verify_test_message (message_without_unix_fds);
01344 
01345     {
01346       /* Marshal and demarshal the message. */
01347 
01348       DBusMessage *message2;
01349       DBusError error = DBUS_ERROR_INIT;
01350       char *marshalled = NULL;
01351       int len = 0;
01352       char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
01353 
01354       if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
01355         _dbus_assert_not_reached ("failed to marshal message");
01356 
01357       _dbus_assert (len != 0);
01358       _dbus_assert (marshalled != NULL);
01359 
01360       _dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
01361       message2 = dbus_message_demarshal (marshalled, len, &error);
01362 
01363       _dbus_assert (message2 != NULL);
01364       _dbus_assert (!dbus_error_is_set (&error));
01365       verify_test_message (message2);
01366 
01367       dbus_message_unref (message2);
01368       dbus_free (marshalled);
01369 
01370       /* Demarshal invalid message. */
01371 
01372       message2 = dbus_message_demarshal ("invalid", 7, &error);
01373       _dbus_assert (message2 == NULL);
01374       _dbus_assert (dbus_error_is_set (&error));
01375       dbus_error_free (&error);
01376 
01377       /* Demarshal invalid (empty) message. */
01378 
01379       message2 = dbus_message_demarshal ("", 0, &error);
01380       _dbus_assert (message2 == NULL);
01381       _dbus_assert (dbus_error_is_set (&error));
01382       dbus_error_free (&error);
01383 
01384       /* Bytes needed to demarshal empty message: 0 (more) */
01385 
01386       _dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0);
01387       
01388       /* Bytes needed to demarshal invalid message: -1 (error). */
01389 
01390       _dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1);
01391     }
01392 
01393   dbus_message_unref (message_without_unix_fds);
01394   _dbus_message_loader_unref (loader);
01395 
01396   check_memleaks ();
01397   _dbus_check_fdleaks();
01398 
01399   /* Check that we can abandon a container */
01400   message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01401                                           "/org/freedesktop/TestPath",
01402                                           "Foo.TestInterface",
01403                                           "Method");
01404 
01405   dbus_message_iter_init_append (message, &iter);
01406 
01407   _dbus_assert (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
01408                                                   (DBUS_STRUCT_BEGIN_CHAR_AS_STRING
01409                                                    DBUS_TYPE_STRING_AS_STRING
01410                                                    DBUS_TYPE_STRING_AS_STRING
01411                                                    DBUS_STRUCT_END_CHAR_AS_STRING),
01412                                                   &array_iter));
01413   _dbus_assert (dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
01414                                                   NULL, &struct_iter));
01415 
01416   s = "peaches";
01417   _dbus_assert (dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING,
01418                                                 &s));
01419 
01420   /* uh-oh, error, try and unwind */
01421 
01422   dbus_message_iter_abandon_container (&array_iter, &struct_iter);
01423   dbus_message_iter_abandon_container (&array_iter, &iter);
01424 
01425   dbus_message_unref (message);
01426 
01427   /* Load all the sample messages from the message factory */
01428   {
01429     DBusMessageDataIter diter;
01430     DBusMessageData mdata;
01431     int count;
01432 
01433     reset_validities_seen ();
01434     
01435     count = 0;
01436     _dbus_message_data_iter_init (&diter);
01437     
01438     while (_dbus_message_data_iter_get_and_next (&diter,
01439                                                  &mdata))
01440       {
01441         if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
01442                                                         mdata.expected_validity))
01443           {
01444             _dbus_warn ("expected validity %d and did not get it\n",
01445                         mdata.expected_validity);
01446             _dbus_assert_not_reached ("message data failed");
01447           }
01448 
01449         _dbus_message_data_free (&mdata);
01450 
01451         count += 1;
01452       }
01453 
01454     printf ("%d sample messages tested\n", count);
01455 
01456     print_validities_seen (FALSE);
01457     print_validities_seen (TRUE);
01458   }
01459 
01460   check_memleaks ();
01461   _dbus_check_fdleaks();
01462 
01463   /* Now load every message in test_data_dir if we have one */
01464   if (test_data_dir == NULL)
01465     return TRUE;
01466 
01467   return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
01468                                                         (DBusForeachMessageFileFunc)
01469                                                         dbus_internal_do_not_use_try_message_file,
01470                                                         NULL);  
01471 }
01472 
01473 #endif /* DBUS_BUILD_TESTS */

Generated on Fri Jul 22 2011 16:59:34 for D-Bus by  doxygen 1.7.1