00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
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
00037 #include <sys/types.h>
00038 #include <dirent.h>
00039 #include <stdlib.h>
00040 #include <errno.h>
00041 #endif
00042
00048 #ifdef DBUS_ENABLE_EMBEDDED_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
00080
00083 #ifdef DBUS_ENABLE_EMBEDDED_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 #ifdef __linux__
00142 struct DBusInitialFDs {
00143 fd_set set;
00144 };
00145 #endif
00146
00147 DBusInitialFDs *
00148 _dbus_check_fdleaks_enter (void)
00149 {
00150 #ifdef __linux__
00151 DIR *d;
00152 DBusInitialFDs *fds;
00153
00154
00155 fds = malloc (sizeof (DBusInitialFDs));
00156 _dbus_assert (fds != NULL);
00157
00158
00159
00160 if ((d = opendir ("/proc/self/fd")))
00161 {
00162 struct dirent *de;
00163
00164 while ((de = readdir(d)))
00165 {
00166 long l;
00167 char *e = NULL;
00168 int fd;
00169
00170 if (de->d_name[0] == '.')
00171 continue;
00172
00173 errno = 0;
00174 l = strtol (de->d_name, &e, 10);
00175 _dbus_assert (errno == 0 && e && !*e);
00176
00177 fd = (int) l;
00178
00179 if (fd < 3)
00180 continue;
00181
00182 if (fd == dirfd (d))
00183 continue;
00184
00185 FD_SET (fd, &fds->set);
00186 }
00187
00188 closedir (d);
00189 }
00190
00191 return fds;
00192 #else
00193 return NULL;
00194 #endif
00195 }
00196
00197 void
00198 _dbus_check_fdleaks_leave (DBusInitialFDs *fds)
00199 {
00200 #ifdef __linux__
00201 DIR *d;
00202
00203
00204
00205 if ((d = opendir ("/proc/self/fd")))
00206 {
00207 struct dirent *de;
00208
00209 while ((de = readdir(d)))
00210 {
00211 long l;
00212 char *e = NULL;
00213 int fd;
00214
00215 if (de->d_name[0] == '.')
00216 continue;
00217
00218 errno = 0;
00219 l = strtol (de->d_name, &e, 10);
00220 _dbus_assert (errno == 0 && e && !*e);
00221
00222 fd = (int) l;
00223
00224 if (fd < 3)
00225 continue;
00226
00227 if (fd == dirfd (d))
00228 continue;
00229
00230 if (FD_ISSET (fd, &fds->set))
00231 continue;
00232
00233 _dbus_warn ("file descriptor %i leaked in %s.\n", fd, __FILE__);
00234 _dbus_assert_not_reached ("fdleaks");
00235 }
00236
00237 closedir (d);
00238 }
00239
00240 free (fds);
00241 #else
00242 _dbus_assert (fds == NULL);
00243 #endif
00244 }
00245
00246 static dbus_bool_t
00247 check_have_valid_message (DBusMessageLoader *loader)
00248 {
00249 DBusMessage *message;
00250 dbus_bool_t retval;
00251
00252 message = NULL;
00253 retval = FALSE;
00254
00255 if (_dbus_message_loader_get_is_corrupted (loader))
00256 {
00257 _dbus_warn ("loader corrupted on message that was expected to be valid; invalid reason %d\n",
00258 loader->corruption_reason);
00259 goto failed;
00260 }
00261
00262 message = _dbus_message_loader_pop_message (loader);
00263 if (message == NULL)
00264 {
00265 _dbus_warn ("didn't load message that was expected to be valid (message not popped)\n");
00266 goto failed;
00267 }
00268
00269 if (_dbus_string_get_length (&loader->data) > 0)
00270 {
00271 _dbus_warn ("had leftover bytes from expected-to-be-valid single message\n");
00272 goto failed;
00273 }
00274
00275 #if 0
00276
00277
00278
00279
00280
00281 if (!check_message_handling (message))
00282 goto failed;
00283 #endif
00284
00285 record_validity_seen (DBUS_VALID);
00286
00287 retval = TRUE;
00288
00289 failed:
00290 if (message)
00291 dbus_message_unref (message);
00292
00293 return retval;
00294 }
00295
00296 static dbus_bool_t
00297 check_invalid_message (DBusMessageLoader *loader,
00298 DBusValidity expected_validity)
00299 {
00300 dbus_bool_t retval;
00301
00302 retval = FALSE;
00303
00304 if (!_dbus_message_loader_get_is_corrupted (loader))
00305 {
00306 _dbus_warn ("loader not corrupted on message that was expected to be invalid\n");
00307 goto failed;
00308 }
00309
00310 record_validity_seen (loader->corruption_reason);
00311
00312 if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
00313 loader->corruption_reason != expected_validity)
00314 {
00315 _dbus_warn ("expected message to be corrupted for reason %d and was corrupted for %d instead\n",
00316 expected_validity, loader->corruption_reason);
00317 goto failed;
00318 }
00319
00320 retval = TRUE;
00321
00322 failed:
00323 return retval;
00324 }
00325
00326 static dbus_bool_t
00327 check_incomplete_message (DBusMessageLoader *loader)
00328 {
00329 DBusMessage *message;
00330 dbus_bool_t retval;
00331
00332 message = NULL;
00333 retval = FALSE;
00334
00335 if (_dbus_message_loader_get_is_corrupted (loader))
00336 {
00337 _dbus_warn ("loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d\n",
00338 loader->corruption_reason);
00339 goto failed;
00340 }
00341
00342 message = _dbus_message_loader_pop_message (loader);
00343 if (message != NULL)
00344 {
00345 _dbus_warn ("loaded message that was expected to be incomplete\n");
00346 goto failed;
00347 }
00348
00349 record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
00350 retval = TRUE;
00351
00352 failed:
00353 if (message)
00354 dbus_message_unref (message);
00355 return retval;
00356 }
00357
00358 static dbus_bool_t
00359 check_loader_results (DBusMessageLoader *loader,
00360 DBusValidity expected_validity)
00361 {
00362 if (!_dbus_message_loader_queue_messages (loader))
00363 _dbus_assert_not_reached ("no memory to queue messages");
00364
00365 if (expected_validity == DBUS_VALID)
00366 return check_have_valid_message (loader);
00367 else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
00368 return check_incomplete_message (loader);
00369 else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
00370 {
00371
00372
00373
00374
00375 if (_dbus_message_loader_get_is_corrupted (loader))
00376 record_validity_seen (loader->corruption_reason);
00377
00378 return TRUE;
00379 }
00380 else
00381 return check_invalid_message (loader, expected_validity);
00382 }
00383
00391 dbus_bool_t
00392 dbus_internal_do_not_use_load_message_file (const DBusString *filename,
00393 DBusString *data)
00394 {
00395 dbus_bool_t retval;
00396 DBusError error = DBUS_ERROR_INIT;
00397
00398 retval = FALSE;
00399
00400 _dbus_verbose ("Loading raw %s\n", _dbus_string_get_const_data (filename));
00401 if (!_dbus_file_get_contents (data, filename, &error))
00402 {
00403 _dbus_warn ("Could not load message file %s: %s\n",
00404 _dbus_string_get_const_data (filename),
00405 error.message);
00406 dbus_error_free (&error);
00407 goto failed;
00408 }
00409
00410 retval = TRUE;
00411
00412 failed:
00413
00414 return retval;
00415 }
00416
00425 dbus_bool_t
00426 dbus_internal_do_not_use_try_message_file (const DBusString *filename,
00427 DBusValidity expected_validity)
00428 {
00429 DBusString data;
00430 dbus_bool_t retval;
00431
00432 retval = FALSE;
00433
00434 if (!_dbus_string_init (&data))
00435 _dbus_assert_not_reached ("could not allocate string\n");
00436
00437 if (!dbus_internal_do_not_use_load_message_file (filename, &data))
00438 goto failed;
00439
00440 retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
00441
00442 failed:
00443
00444 if (!retval)
00445 {
00446 if (_dbus_string_get_length (&data) > 0)
00447 _dbus_verbose_bytes_of_string (&data, 0,
00448 _dbus_string_get_length (&data));
00449
00450 _dbus_warn ("Failed message loader test on %s\n",
00451 _dbus_string_get_const_data (filename));
00452 }
00453
00454 _dbus_string_free (&data);
00455
00456 return retval;
00457 }
00458
00467 dbus_bool_t
00468 dbus_internal_do_not_use_try_message_data (const DBusString *data,
00469 DBusValidity expected_validity)
00470 {
00471 DBusMessageLoader *loader;
00472 dbus_bool_t retval;
00473 int len;
00474 int i;
00475
00476 loader = NULL;
00477 retval = FALSE;
00478
00479
00480
00481 loader = _dbus_message_loader_new ();
00482
00483
00484 _dbus_message_loader_ref (loader);
00485 _dbus_message_loader_unref (loader);
00486 _dbus_message_loader_get_max_message_size (loader);
00487
00488 len = _dbus_string_get_length (data);
00489 for (i = 0; i < len; i++)
00490 {
00491 DBusString *buffer;
00492
00493 _dbus_message_loader_get_buffer (loader, &buffer);
00494 _dbus_string_append_byte (buffer,
00495 _dbus_string_get_byte (data, i));
00496 _dbus_message_loader_return_buffer (loader, buffer);
00497 }
00498
00499 if (!check_loader_results (loader, expected_validity))
00500 goto failed;
00501
00502 _dbus_message_loader_unref (loader);
00503 loader = NULL;
00504
00505
00506
00507 loader = _dbus_message_loader_new ();
00508
00509 {
00510 DBusString *buffer;
00511
00512 _dbus_message_loader_get_buffer (loader, &buffer);
00513 _dbus_string_copy (data, 0, buffer,
00514 _dbus_string_get_length (buffer));
00515 _dbus_message_loader_return_buffer (loader, buffer);
00516 }
00517
00518 if (!check_loader_results (loader, expected_validity))
00519 goto failed;
00520
00521 _dbus_message_loader_unref (loader);
00522 loader = NULL;
00523
00524
00525
00526 loader = _dbus_message_loader_new ();
00527
00528 len = _dbus_string_get_length (data);
00529 for (i = 0; i < len; i += 2)
00530 {
00531 DBusString *buffer;
00532
00533 _dbus_message_loader_get_buffer (loader, &buffer);
00534 _dbus_string_append_byte (buffer,
00535 _dbus_string_get_byte (data, i));
00536 if ((i+1) < len)
00537 _dbus_string_append_byte (buffer,
00538 _dbus_string_get_byte (data, i+1));
00539 _dbus_message_loader_return_buffer (loader, buffer);
00540 }
00541
00542 if (!check_loader_results (loader, expected_validity))
00543 goto failed;
00544
00545 _dbus_message_loader_unref (loader);
00546 loader = NULL;
00547
00548 retval = TRUE;
00549
00550 failed:
00551
00552 if (loader)
00553 _dbus_message_loader_unref (loader);
00554
00555 return retval;
00556 }
00557
00558 static dbus_bool_t
00559 process_test_subdir (const DBusString *test_base_dir,
00560 const char *subdir,
00561 DBusValidity expected_validity,
00562 DBusForeachMessageFileFunc function,
00563 void *user_data)
00564 {
00565 DBusString test_directory;
00566 DBusString filename;
00567 DBusDirIter *dir;
00568 dbus_bool_t retval;
00569 DBusError error = DBUS_ERROR_INIT;
00570
00571 retval = FALSE;
00572 dir = NULL;
00573
00574 if (!_dbus_string_init (&test_directory))
00575 _dbus_assert_not_reached ("didn't allocate test_directory\n");
00576
00577 _dbus_string_init_const (&filename, subdir);
00578
00579 if (!_dbus_string_copy (test_base_dir, 0,
00580 &test_directory, 0))
00581 _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
00582
00583 if (!_dbus_concat_dir_and_file (&test_directory, &filename))
00584 _dbus_assert_not_reached ("couldn't allocate full path");
00585
00586 _dbus_string_free (&filename);
00587 if (!_dbus_string_init (&filename))
00588 _dbus_assert_not_reached ("didn't allocate filename string\n");
00589
00590 dir = _dbus_directory_open (&test_directory, &error);
00591 if (dir == NULL)
00592 {
00593 _dbus_warn ("Could not open %s: %s\n",
00594 _dbus_string_get_const_data (&test_directory),
00595 error.message);
00596 dbus_error_free (&error);
00597 goto failed;
00598 }
00599
00600 printf ("Testing %s:\n", subdir);
00601
00602 next:
00603 while (_dbus_directory_get_next_file (dir, &filename, &error))
00604 {
00605 DBusString full_path;
00606
00607 if (!_dbus_string_init (&full_path))
00608 _dbus_assert_not_reached ("couldn't init string");
00609
00610 if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
00611 _dbus_assert_not_reached ("couldn't copy dir to full_path");
00612
00613 if (!_dbus_concat_dir_and_file (&full_path, &filename))
00614 _dbus_assert_not_reached ("couldn't concat file to dir");
00615
00616 if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
00617 ;
00618 else
00619 {
00620 if (_dbus_string_ends_with_c_str (&filename, ".message"))
00621 {
00622 printf ("SKIP: Could not load %s, message builder language no longer supported\n",
00623 _dbus_string_get_const_data (&filename));
00624 }
00625
00626 _dbus_verbose ("Skipping non-.message file %s\n",
00627 _dbus_string_get_const_data (&filename));
00628 _dbus_string_free (&full_path);
00629 goto next;
00630 }
00631
00632 printf (" %s\n",
00633 _dbus_string_get_const_data (&filename));
00634
00635 if (! (*function) (&full_path,
00636 expected_validity, user_data))
00637 {
00638 _dbus_string_free (&full_path);
00639 goto failed;
00640 }
00641 else
00642 _dbus_string_free (&full_path);
00643 }
00644
00645 if (dbus_error_is_set (&error))
00646 {
00647 _dbus_warn ("Could not get next file in %s: %s\n",
00648 _dbus_string_get_const_data (&test_directory),
00649 error.message);
00650 dbus_error_free (&error);
00651 goto failed;
00652 }
00653
00654 retval = TRUE;
00655
00656 failed:
00657
00658 if (dir)
00659 _dbus_directory_close (dir);
00660 _dbus_string_free (&test_directory);
00661 _dbus_string_free (&filename);
00662
00663 return retval;
00664 }
00665
00675 dbus_bool_t
00676 dbus_internal_do_not_use_foreach_message_file (const char *test_data_dir,
00677 DBusForeachMessageFileFunc func,
00678 void *user_data)
00679 {
00680 DBusString test_directory;
00681 dbus_bool_t retval;
00682
00683 retval = FALSE;
00684
00685 _dbus_string_init_const (&test_directory, test_data_dir);
00686
00687 if (!process_test_subdir (&test_directory, "valid-messages",
00688 DBUS_VALID, func, user_data))
00689 goto failed;
00690
00691 check_memleaks ();
00692
00693 if (!process_test_subdir (&test_directory, "invalid-messages",
00694 DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
00695 goto failed;
00696
00697 check_memleaks ();
00698
00699 if (!process_test_subdir (&test_directory, "incomplete-messages",
00700 DBUS_VALID_BUT_INCOMPLETE, func, user_data))
00701 goto failed;
00702
00703 check_memleaks ();
00704
00705 retval = TRUE;
00706
00707 failed:
00708
00709 _dbus_string_free (&test_directory);
00710
00711 return retval;
00712 }
00713
00714 #if 0
00715 #define GET_AND_CHECK(iter, typename, literal) \
00716 do { \
00717 if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
00718 _dbus_assert_not_reached ("got wrong argument type from message iter"); \
00719 dbus_message_iter_get_basic (&iter, &v_##typename); \
00720 if (v_##typename != literal) \
00721 _dbus_assert_not_reached ("got wrong value from message iter"); \
00722 } while (0)
00723
00724 #define GET_AND_CHECK_STRCMP(iter, typename, literal) \
00725 do { \
00726 if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
00727 _dbus_assert_not_reached ("got wrong argument type from message iter"); \
00728 dbus_message_iter_get_basic (&iter, &v_##typename); \
00729 if (strcmp (v_##typename, literal) != 0) \
00730 _dbus_assert_not_reached ("got wrong value from message iter"); \
00731 } while (0)
00732
00733 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal) \
00734 do { \
00735 GET_AND_CHECK(iter, typename, literal); \
00736 if (!dbus_message_iter_next (&iter)) \
00737 _dbus_assert_not_reached ("failed to move iter to next"); \
00738 } while (0)
00739
00740 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal) \
00741 do { \
00742 GET_AND_CHECK_STRCMP(iter, typename, literal); \
00743 if (!dbus_message_iter_next (&iter)) \
00744 _dbus_assert_not_reached ("failed to move iter to next"); \
00745 } while (0)
00746
00747 static void
00748 message_iter_test (DBusMessage *message)
00749 {
00750 DBusMessageIter iter, array, array2;
00751 const char *v_STRING;
00752 double v_DOUBLE;
00753 dbus_int16_t v_INT16;
00754 dbus_uint16_t v_UINT16;
00755 dbus_int32_t v_INT32;
00756 dbus_uint32_t v_UINT32;
00757 dbus_int64_t v_INT64;
00758 dbus_uint64_t v_UINT64;
00759 unsigned char v_BYTE;
00760 dbus_bool_t v_BOOLEAN;
00761
00762 const dbus_int32_t *our_int_array;
00763 int len;
00764
00765 dbus_message_iter_init (message, &iter);
00766
00767 GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, "Test string");
00768 GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
00769 GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
00770 GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
00771
00772 if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00773 _dbus_assert_not_reached ("Argument type not an array");
00774
00775 if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_DOUBLE)
00776 _dbus_assert_not_reached ("Array type not double");
00777
00778 dbus_message_iter_recurse (&iter, &array);
00779
00780 GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
00781 GET_AND_CHECK (array, DOUBLE, 2.5);
00782
00783 if (dbus_message_iter_next (&array))
00784 _dbus_assert_not_reached ("Didn't reach end of array");
00785
00786 if (!dbus_message_iter_next (&iter))
00787 _dbus_assert_not_reached ("Reached end of arguments");
00788
00789 GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
00790
00791 if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
00792 _dbus_assert_not_reached ("no array");
00793
00794 if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_INT32)
00795 _dbus_assert_not_reached ("Array type not int32");
00796
00797
00798 dbus_message_iter_recurse (&iter, &array);
00799
00800 if (dbus_message_iter_next (&array))
00801 _dbus_assert_not_reached ("Didn't reach end of array");
00802
00803 if (!dbus_message_iter_next (&iter))
00804 _dbus_assert_not_reached ("Reached end of arguments");
00805
00806 GET_AND_CHECK (iter, BYTE, 0xF0);
00807
00808 if (dbus_message_iter_next (&iter))
00809 _dbus_assert_not_reached ("Didn't reach end of arguments");
00810 }
00811 #endif
00812
00813 static void
00814 verify_test_message (DBusMessage *message)
00815 {
00816 DBusMessageIter iter;
00817 DBusError error = DBUS_ERROR_INIT;
00818 dbus_int16_t our_int16;
00819 dbus_uint16_t our_uint16;
00820 dbus_int32_t our_int;
00821 dbus_uint32_t our_uint;
00822 const char *our_str;
00823 double our_double;
00824 double v_DOUBLE;
00825 dbus_bool_t our_bool;
00826 unsigned char our_byte_1, our_byte_2;
00827 const dbus_uint32_t *our_uint32_array = (void*)0xdeadbeef;
00828 int our_uint32_array_len;
00829 dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
00830 int our_int32_array_len;
00831 dbus_int64_t our_int64;
00832 dbus_uint64_t our_uint64;
00833 dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
00834 int our_uint64_array_len;
00835 const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
00836 int our_int64_array_len;
00837 const double *our_double_array = (void*)0xdeadbeef;
00838 int our_double_array_len;
00839 const unsigned char *our_byte_array = (void*)0xdeadbeef;
00840 int our_byte_array_len;
00841 const dbus_bool_t *our_boolean_array = (void*)0xdeadbeef;
00842 int our_boolean_array_len;
00843 char **our_string_array;
00844 int our_string_array_len;
00845
00846 dbus_message_iter_init (message, &iter);
00847
00848 if (!dbus_message_iter_get_args (&iter, &error,
00849 DBUS_TYPE_INT16, &our_int16,
00850 DBUS_TYPE_UINT16, &our_uint16,
00851 DBUS_TYPE_INT32, &our_int,
00852 DBUS_TYPE_UINT32, &our_uint,
00853 DBUS_TYPE_INT64, &our_int64,
00854 DBUS_TYPE_UINT64, &our_uint64,
00855 DBUS_TYPE_STRING, &our_str,
00856 DBUS_TYPE_DOUBLE, &our_double,
00857 DBUS_TYPE_BOOLEAN, &our_bool,
00858 DBUS_TYPE_BYTE, &our_byte_1,
00859 DBUS_TYPE_BYTE, &our_byte_2,
00860 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32,
00861 &our_uint32_array, &our_uint32_array_len,
00862 DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
00863 &our_int32_array, &our_int32_array_len,
00864 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64,
00865 &our_uint64_array, &our_uint64_array_len,
00866 DBUS_TYPE_ARRAY, DBUS_TYPE_INT64,
00867 &our_int64_array, &our_int64_array_len,
00868 DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE,
00869 &our_double_array, &our_double_array_len,
00870 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
00871 &our_byte_array, &our_byte_array_len,
00872 DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN,
00873 &our_boolean_array, &our_boolean_array_len,
00874 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
00875 &our_string_array, &our_string_array_len,
00876 0))
00877 {
00878 _dbus_warn ("error: %s - %s\n", error.name,
00879 (error.message != NULL) ? error.message : "no message");
00880 _dbus_assert_not_reached ("Could not get arguments");
00881 }
00882
00883 if (our_int16 != -0x123)
00884 _dbus_assert_not_reached ("16-bit integers differ!");
00885
00886 if (our_uint16 != 0x123)
00887 _dbus_assert_not_reached ("16-bit uints differ!");
00888
00889 if (our_int != -0x12345678)
00890 _dbus_assert_not_reached ("integers differ!");
00891
00892 if (our_uint != 0x12300042)
00893 _dbus_assert_not_reached ("uints differ!");
00894
00895 if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
00896 _dbus_assert_not_reached ("64-bit integers differ!");
00897 if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
00898 _dbus_assert_not_reached ("64-bit unsigned integers differ!");
00899
00900 v_DOUBLE = 3.14159;
00901 if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
00902 _dbus_assert_not_reached ("doubles differ!");
00903
00904 if (strcmp (our_str, "Test string") != 0)
00905 _dbus_assert_not_reached ("strings differ!");
00906
00907 if (!our_bool)
00908 _dbus_assert_not_reached ("booleans differ");
00909
00910 if (our_byte_1 != 42)
00911 _dbus_assert_not_reached ("bytes differ!");
00912
00913 if (our_byte_2 != 24)
00914 _dbus_assert_not_reached ("bytes differ!");
00915
00916 if (our_uint32_array_len != 4 ||
00917 our_uint32_array[0] != 0x12345678 ||
00918 our_uint32_array[1] != 0x23456781 ||
00919 our_uint32_array[2] != 0x34567812 ||
00920 our_uint32_array[3] != 0x45678123)
00921 _dbus_assert_not_reached ("uint array differs");
00922
00923 if (our_int32_array_len != 4 ||
00924 our_int32_array[0] != 0x12345678 ||
00925 our_int32_array[1] != -0x23456781 ||
00926 our_int32_array[2] != 0x34567812 ||
00927 our_int32_array[3] != -0x45678123)
00928 _dbus_assert_not_reached ("int array differs");
00929
00930 if (our_uint64_array_len != 4 ||
00931 our_uint64_array[0] != 0x12345678 ||
00932 our_uint64_array[1] != 0x23456781 ||
00933 our_uint64_array[2] != 0x34567812 ||
00934 our_uint64_array[3] != 0x45678123)
00935 _dbus_assert_not_reached ("uint64 array differs");
00936
00937 if (our_int64_array_len != 4 ||
00938 our_int64_array[0] != 0x12345678 ||
00939 our_int64_array[1] != -0x23456781 ||
00940 our_int64_array[2] != 0x34567812 ||
00941 our_int64_array[3] != -0x45678123)
00942 _dbus_assert_not_reached ("int64 array differs");
00943
00944 if (our_double_array_len != 3)
00945 _dbus_assert_not_reached ("double array had wrong length");
00946
00947
00948
00949
00950 v_DOUBLE = 0.1234;
00951 if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[0], v_DOUBLE))
00952 _dbus_assert_not_reached ("double array had wrong values");
00953 v_DOUBLE = 9876.54321;
00954 if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[1], v_DOUBLE))
00955 _dbus_assert_not_reached ("double array had wrong values");
00956 v_DOUBLE = -300.0;
00957 if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[2], v_DOUBLE))
00958 _dbus_assert_not_reached ("double array had wrong values");
00959
00960 if (our_byte_array_len != 4)
00961 _dbus_assert_not_reached ("byte array had wrong length");
00962
00963 if (our_byte_array[0] != 'a' ||
00964 our_byte_array[1] != 'b' ||
00965 our_byte_array[2] != 'c' ||
00966 our_byte_array[3] != 234)
00967 _dbus_assert_not_reached ("byte array had wrong values");
00968
00969 if (our_boolean_array_len != 5)
00970 _dbus_assert_not_reached ("bool array had wrong length");
00971
00972 if (our_boolean_array[0] != TRUE ||
00973 our_boolean_array[1] != FALSE ||
00974 our_boolean_array[2] != TRUE ||
00975 our_boolean_array[3] != TRUE ||
00976 our_boolean_array[4] != FALSE)
00977 _dbus_assert_not_reached ("bool array had wrong values");
00978
00979 if (our_string_array_len != 4)
00980 _dbus_assert_not_reached ("string array was wrong length");
00981
00982 if (strcmp (our_string_array[0], "Foo") != 0 ||
00983 strcmp (our_string_array[1], "bar") != 0 ||
00984 strcmp (our_string_array[2], "") != 0 ||
00985 strcmp (our_string_array[3], "woo woo woo woo") != 0)
00986 _dbus_assert_not_reached ("string array had wrong values");
00987
00988 dbus_free_string_array (our_string_array);
00989
00990 if (dbus_message_iter_next (&iter))
00991 _dbus_assert_not_reached ("Didn't reach end of arguments");
00992 }
00993
00994 static void
00995 verify_test_message_args_ignored (DBusMessage *message)
00996 {
00997 DBusMessageIter iter;
00998 DBusError error = DBUS_ERROR_INIT;
00999 dbus_uint32_t our_uint;
01000 DBusInitialFDs *initial_fds;
01001
01002 initial_fds = _dbus_check_fdleaks_enter ();
01003
01004
01005 dbus_message_iter_init (message, &iter);
01006 if (!dbus_message_iter_get_args (&iter, &error,
01007 DBUS_TYPE_INVALID))
01008 {
01009 _dbus_warn ("error: %s - %s\n", error.name,
01010 (error.message != NULL) ? error.message : "no message");
01011 }
01012 else
01013 {
01014 _dbus_assert (!dbus_error_is_set (&error));
01015 _dbus_verbose ("arguments ignored.\n");
01016 }
01017
01018
01019 dbus_message_iter_init (message, &iter);
01020 if (!dbus_message_iter_get_args (&iter, &error,
01021 DBUS_TYPE_UINT32, &our_uint,
01022 DBUS_TYPE_INVALID))
01023 {
01024 _dbus_warn ("error: %s - %s\n", error.name,
01025 (error.message != NULL) ? error.message : "no message");
01026 }
01027 else
01028 {
01029 _dbus_assert (!dbus_error_is_set (&error));
01030 _dbus_verbose ("arguments ignored.\n");
01031 }
01032
01033 _dbus_check_fdleaks_leave (initial_fds);
01034 }
01035
01036 static void
01037 verify_test_message_memleak (DBusMessage *message)
01038 {
01039 DBusMessageIter iter;
01040 DBusError error = DBUS_ERROR_INIT;
01041 dbus_uint32_t our_uint1;
01042 dbus_uint32_t our_uint2;
01043 dbus_uint32_t our_uint3;
01044 char **our_string_array1;
01045 int our_string_array_len1;
01046 char **our_string_array2;
01047 int our_string_array_len2;
01048 #ifdef HAVE_UNIX_FD_PASSING
01049 int our_unix_fd1;
01050 int our_unix_fd2;
01051 #endif
01052 DBusInitialFDs *initial_fds;
01053
01054 initial_fds = _dbus_check_fdleaks_enter ();
01055
01056
01057 dbus_error_free (&error);
01058 dbus_message_iter_init (message, &iter);
01059 if (!dbus_message_iter_get_args (&iter, &error,
01060 DBUS_TYPE_UINT32, &our_uint1,
01061 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
01062 &our_string_array1, &our_string_array_len1,
01063 #ifdef HAVE_UNIX_FD_PASSING
01064 DBUS_TYPE_UNIX_FD, &our_unix_fd1,
01065 #endif
01066 DBUS_TYPE_UINT32, &our_uint2,
01067 DBUS_TYPE_UINT32, &our_uint3,
01068 DBUS_TYPE_INVALID))
01069 {
01070 _dbus_verbose ("expected error: %s - %s\n", error.name,
01071 (error.message != NULL) ? error.message : "no message");
01072
01073 _dbus_assert (our_string_array1 == NULL);
01074 #ifdef HAVE_UNIX_FD_PASSING
01075 _dbus_assert (our_unix_fd1 == -1);
01076 #endif
01077 }
01078 else
01079 {
01080 _dbus_warn ("error: parse with wrong signature: 'uashuu'.\n");
01081 }
01082
01083
01084 dbus_message_iter_init (message, &iter);
01085 dbus_error_free (&error);
01086 if (!dbus_message_iter_get_args (&iter, &error,
01087 DBUS_TYPE_UINT32, &our_uint1,
01088 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
01089 &our_string_array1, &our_string_array_len1,
01090 #ifdef HAVE_UNIX_FD_PASSING
01091 DBUS_TYPE_UNIX_FD, &our_unix_fd1,
01092 #endif
01093 DBUS_TYPE_UINT32, &our_uint2,
01094 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
01095 &our_string_array2, &our_string_array_len2,
01096 #ifdef HAVE_UNIX_FD_PASSING
01097 DBUS_TYPE_UNIX_FD, &our_unix_fd2,
01098 #endif
01099 DBUS_TYPE_UINT32, &our_uint3,
01100 DBUS_TYPE_INVALID))
01101 {
01102 _dbus_verbose ("expected error: %s - %s\n", error.name,
01103 (error.message != NULL) ? error.message : "no message");
01104
01105 _dbus_assert (our_string_array1 == NULL);
01106 _dbus_assert (our_string_array2 == NULL);
01107 #ifdef HAVE_UNIX_FD_PASSING
01108 _dbus_assert (our_unix_fd1 == -1);
01109 _dbus_assert (our_unix_fd2 == -1);
01110 #endif
01111 }
01112 else
01113 {
01114 _dbus_warn ("error: parse with wrong signature: 'uashuashu'.\n");
01115 }
01116
01117
01118 dbus_message_iter_init (message, &iter);
01119 dbus_error_free (&error);
01120 if (!dbus_message_iter_get_args (&iter, &error,
01121 DBUS_TYPE_UINT32, &our_uint1,
01122 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
01123 &our_string_array1, &our_string_array_len1,
01124 #ifdef HAVE_UNIX_FD_PASSING
01125 DBUS_TYPE_UNIX_FD, &our_unix_fd1,
01126 #endif
01127 DBUS_TYPE_UINT32, &our_uint2,
01128 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
01129 &our_string_array2, &our_string_array_len2,
01130 #ifdef HAVE_UNIX_FD_PASSING
01131 DBUS_TYPE_UNIX_FD, &our_unix_fd2,
01132 #endif
01133 DBUS_TYPE_INVALID))
01134 {
01135 _dbus_warn ("error: %s - %s\n", error.name,
01136 (error.message != NULL) ? error.message : "no message");
01137 _dbus_assert_not_reached ("Could not get arguments");
01138 }
01139 else
01140 {
01141 dbus_free_string_array (our_string_array1);
01142 dbus_free_string_array (our_string_array2);
01143 #ifdef HAVE_UNIX_FD_PASSING
01144 _dbus_close (our_unix_fd1, &error);
01145 _dbus_close (our_unix_fd2, &error);
01146 #endif
01147 }
01148 _dbus_check_fdleaks_leave (initial_fds);
01149 }
01150
01157 dbus_bool_t
01158 _dbus_message_test (const char *test_data_dir)
01159 {
01160 DBusMessage *message, *message_without_unix_fds;
01161 DBusMessageLoader *loader;
01162 int i;
01163 const char *data;
01164 DBusMessage *copy;
01165 const char *name1;
01166 const char *name2;
01167 const dbus_uint32_t our_uint32_array[] =
01168 { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
01169 const dbus_int32_t our_int32_array[] =
01170 { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
01171 const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
01172 const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
01173 const dbus_uint64_t our_uint64_array[] =
01174 { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
01175 const dbus_int64_t our_int64_array[] =
01176 { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
01177 const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
01178 const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
01179 const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
01180 const char *our_string_array1[] = { "foo", "Bar", "", "Woo woo Woo woo" };
01181 const char **v_ARRAY_STRING = our_string_array;
01182 const char **v1_ARRAY_STRING = our_string_array1;
01183 const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
01184 const double *v_ARRAY_DOUBLE = our_double_array;
01185 const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
01186 const unsigned char *v_ARRAY_BYTE = our_byte_array;
01187 const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
01188 const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
01189 char sig[64];
01190 const char *s;
01191 const char *v_STRING;
01192 double v_DOUBLE;
01193 dbus_int16_t v_INT16;
01194 dbus_uint16_t v_UINT16;
01195 dbus_int32_t v_INT32;
01196 dbus_uint32_t v_UINT32;
01197 dbus_uint32_t v1_UINT32;
01198 dbus_int64_t v_INT64;
01199 dbus_uint64_t v_UINT64;
01200 unsigned char v_BYTE;
01201 unsigned char v2_BYTE;
01202 dbus_bool_t v_BOOLEAN;
01203 DBusMessageIter iter, array_iter, struct_iter;
01204 #ifdef HAVE_UNIX_FD_PASSING
01205 int v_UNIX_FD;
01206 int v1_UNIX_FD;
01207 #endif
01208 char **decomposed;
01209 DBusInitialFDs *initial_fds;
01210 dbus_bool_t ok;
01211 char basic_types[] = DBUS_TYPE_BYTE_AS_STRING \
01212 DBUS_TYPE_BOOLEAN_AS_STRING \
01213 DBUS_TYPE_INT16_AS_STRING \
01214 DBUS_TYPE_INT32_AS_STRING \
01215 DBUS_TYPE_INT64_AS_STRING \
01216 DBUS_TYPE_UINT16_AS_STRING \
01217 DBUS_TYPE_UINT32_AS_STRING \
01218 DBUS_TYPE_UINT64_AS_STRING \
01219 DBUS_TYPE_DOUBLE_AS_STRING \
01220 DBUS_TYPE_STRING_AS_STRING;
01221
01222 initial_fds = _dbus_check_fdleaks_enter ();
01223
01224 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01225 "/org/freedesktop/TestPath",
01226 "Foo.TestInterface",
01227 "TestMethod");
01228 _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
01229 _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
01230 "TestMethod"));
01231 _dbus_assert (strcmp (dbus_message_get_path (message),
01232 "/org/freedesktop/TestPath") == 0);
01233 dbus_message_set_serial (message, 1234);
01234
01235
01236 if (!dbus_message_set_sender (message, "org.foo.bar1"))
01237 _dbus_assert_not_reached ("out of memory");
01238
01239 _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
01240 dbus_message_set_reply_serial (message, 5678);
01241
01242 _dbus_verbose_bytes_of_string (&message->header.data, 0,
01243 _dbus_string_get_length (&message->header.data));
01244 _dbus_verbose_bytes_of_string (&message->body, 0,
01245 _dbus_string_get_length (&message->body));
01246
01247 if (!dbus_message_set_sender (message, NULL))
01248 _dbus_assert_not_reached ("out of memory");
01249
01250
01251 _dbus_verbose_bytes_of_string (&message->header.data, 0,
01252 _dbus_string_get_length (&message->header.data));
01253 _dbus_verbose_bytes_of_string (&message->body, 0,
01254 _dbus_string_get_length (&message->body));
01255
01256
01257 _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
01258 _dbus_assert (dbus_message_get_serial (message) == 1234);
01259 _dbus_assert (dbus_message_get_reply_serial (message) == 5678);
01260 _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
01261
01262 _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
01263 dbus_message_set_no_reply (message, TRUE);
01264 _dbus_assert (dbus_message_get_no_reply (message) == TRUE);
01265 dbus_message_set_no_reply (message, FALSE);
01266 _dbus_assert (dbus_message_get_no_reply (message) == FALSE);
01267
01268
01269
01270 if (!dbus_message_set_path (message, "/foo"))
01271 _dbus_assert_not_reached ("out of memory");
01272 _dbus_assert (strcmp (dbus_message_get_path (message),
01273 "/foo") == 0);
01274
01275 if (!dbus_message_set_interface (message, "org.Foo"))
01276 _dbus_assert_not_reached ("out of memory");
01277 _dbus_assert (strcmp (dbus_message_get_interface (message),
01278 "org.Foo") == 0);
01279
01280 if (!dbus_message_set_member (message, "Bar"))
01281 _dbus_assert_not_reached ("out of memory");
01282 _dbus_assert (strcmp (dbus_message_get_member (message),
01283 "Bar") == 0);
01284
01285
01286 if (!dbus_message_set_path (message, "/foo/bar"))
01287 _dbus_assert_not_reached ("out of memory");
01288 _dbus_assert (strcmp (dbus_message_get_path (message),
01289 "/foo/bar") == 0);
01290
01291 if (!dbus_message_set_interface (message, "org.Foo.Bar"))
01292 _dbus_assert_not_reached ("out of memory");
01293 _dbus_assert (strcmp (dbus_message_get_interface (message),
01294 "org.Foo.Bar") == 0);
01295
01296 if (!dbus_message_set_member (message, "BarFoo"))
01297 _dbus_assert_not_reached ("out of memory");
01298 _dbus_assert (strcmp (dbus_message_get_member (message),
01299 "BarFoo") == 0);
01300
01301
01302
01303 if (!dbus_message_set_path (message, "/foo"))
01304 _dbus_assert_not_reached ("out of memory");
01305 _dbus_assert (strcmp (dbus_message_get_path (message),
01306 "/foo") == 0);
01307
01308 if (!dbus_message_set_interface (message, "org.Foo"))
01309 _dbus_assert_not_reached ("out of memory");
01310 _dbus_assert (strcmp (dbus_message_get_interface (message),
01311 "org.Foo") == 0);
01312
01313 if (!dbus_message_set_member (message, "Bar"))
01314 _dbus_assert_not_reached ("out of memory");
01315 _dbus_assert (strcmp (dbus_message_get_member (message),
01316 "Bar") == 0);
01317
01318
01319 dbus_message_set_path (message, NULL);
01320 dbus_message_get_path_decomposed (message, &decomposed);
01321 _dbus_assert (decomposed == NULL);
01322 dbus_free_string_array (decomposed);
01323
01324 dbus_message_set_path (message, "/");
01325 dbus_message_get_path_decomposed (message, &decomposed);
01326 _dbus_assert (decomposed != NULL);
01327 _dbus_assert (decomposed[0] == NULL);
01328 dbus_free_string_array (decomposed);
01329
01330 dbus_message_set_path (message, "/a/b");
01331 dbus_message_get_path_decomposed (message, &decomposed);
01332 _dbus_assert (decomposed != NULL);
01333 _dbus_assert (strcmp (decomposed[0], "a") == 0);
01334 _dbus_assert (strcmp (decomposed[1], "b") == 0);
01335 _dbus_assert (decomposed[2] == NULL);
01336 dbus_free_string_array (decomposed);
01337
01338 dbus_message_set_path (message, "/spam/eggs");
01339 dbus_message_get_path_decomposed (message, &decomposed);
01340 _dbus_assert (decomposed != NULL);
01341 _dbus_assert (strcmp (decomposed[0], "spam") == 0);
01342 _dbus_assert (strcmp (decomposed[1], "eggs") == 0);
01343 _dbus_assert (decomposed[2] == NULL);
01344 dbus_free_string_array (decomposed);
01345
01346 dbus_message_unref (message);
01347
01348
01349 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01350 "/org/freedesktop/TestPath",
01351 "Foo.TestInterface",
01352 "TestMethod");
01353 dbus_message_set_serial (message, 1);
01354 dbus_message_set_reply_serial (message, 5678);
01355
01356 v_INT16 = -0x123;
01357 v_UINT16 = 0x123;
01358 v_INT32 = -0x12345678;
01359 v_UINT32 = 0x12300042;
01360 v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
01361 v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
01362 v_STRING = "Test string";
01363 v_DOUBLE = 3.14159;
01364 v_BOOLEAN = TRUE;
01365 v_BYTE = 42;
01366 v2_BYTE = 24;
01367 #ifdef HAVE_UNIX_FD_PASSING
01368 v_UNIX_FD = 1;
01369 v1_UNIX_FD = 2;
01370 #endif
01371
01372 dbus_message_append_args (message,
01373 DBUS_TYPE_INT16, &v_INT16,
01374 DBUS_TYPE_UINT16, &v_UINT16,
01375 DBUS_TYPE_INT32, &v_INT32,
01376 DBUS_TYPE_UINT32, &v_UINT32,
01377 DBUS_TYPE_INT64, &v_INT64,
01378 DBUS_TYPE_UINT64, &v_UINT64,
01379 DBUS_TYPE_STRING, &v_STRING,
01380 DBUS_TYPE_DOUBLE, &v_DOUBLE,
01381 DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
01382 DBUS_TYPE_BYTE, &v_BYTE,
01383 DBUS_TYPE_BYTE, &v2_BYTE,
01384 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
01385 _DBUS_N_ELEMENTS (our_uint32_array),
01386 DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
01387 _DBUS_N_ELEMENTS (our_int32_array),
01388 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
01389 _DBUS_N_ELEMENTS (our_uint64_array),
01390 DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
01391 _DBUS_N_ELEMENTS (our_int64_array),
01392 DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
01393 _DBUS_N_ELEMENTS (our_double_array),
01394 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
01395 _DBUS_N_ELEMENTS (our_byte_array),
01396 DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
01397 _DBUS_N_ELEMENTS (our_boolean_array),
01398 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
01399 _DBUS_N_ELEMENTS (our_string_array),
01400
01401 DBUS_TYPE_INVALID);
01402
01403 i = 0;
01404 sig[i++] = DBUS_TYPE_INT16;
01405 sig[i++] = DBUS_TYPE_UINT16;
01406 sig[i++] = DBUS_TYPE_INT32;
01407 sig[i++] = DBUS_TYPE_UINT32;
01408 sig[i++] = DBUS_TYPE_INT64;
01409 sig[i++] = DBUS_TYPE_UINT64;
01410 sig[i++] = DBUS_TYPE_STRING;
01411 sig[i++] = DBUS_TYPE_DOUBLE;
01412 sig[i++] = DBUS_TYPE_BOOLEAN;
01413 sig[i++] = DBUS_TYPE_BYTE;
01414 sig[i++] = DBUS_TYPE_BYTE;
01415 sig[i++] = DBUS_TYPE_ARRAY;
01416 sig[i++] = DBUS_TYPE_UINT32;
01417 sig[i++] = DBUS_TYPE_ARRAY;
01418 sig[i++] = DBUS_TYPE_INT32;
01419 sig[i++] = DBUS_TYPE_ARRAY;
01420 sig[i++] = DBUS_TYPE_UINT64;
01421 sig[i++] = DBUS_TYPE_ARRAY;
01422 sig[i++] = DBUS_TYPE_INT64;
01423 sig[i++] = DBUS_TYPE_ARRAY;
01424 sig[i++] = DBUS_TYPE_DOUBLE;
01425 sig[i++] = DBUS_TYPE_ARRAY;
01426 sig[i++] = DBUS_TYPE_BYTE;
01427 sig[i++] = DBUS_TYPE_ARRAY;
01428 sig[i++] = DBUS_TYPE_BOOLEAN;
01429 sig[i++] = DBUS_TYPE_ARRAY;
01430 sig[i++] = DBUS_TYPE_STRING;
01431
01432 message_without_unix_fds = dbus_message_copy(message);
01433 _dbus_assert(message_without_unix_fds);
01434 #ifdef HAVE_UNIX_FD_PASSING
01435 dbus_message_append_args (message,
01436 DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
01437 DBUS_TYPE_INVALID);
01438 sig[i++] = DBUS_TYPE_UNIX_FD;
01439 #endif
01440 sig[i++] = DBUS_TYPE_INVALID;
01441
01442 _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
01443
01444 _dbus_verbose ("HEADER\n");
01445 _dbus_verbose_bytes_of_string (&message->header.data, 0,
01446 _dbus_string_get_length (&message->header.data));
01447 _dbus_verbose ("BODY\n");
01448 _dbus_verbose_bytes_of_string (&message->body, 0,
01449 _dbus_string_get_length (&message->body));
01450
01451 _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
01452 sig, dbus_message_get_signature (message));
01453
01454 s = dbus_message_get_signature (message);
01455
01456 _dbus_assert (dbus_message_has_signature (message, sig));
01457 _dbus_assert (strcmp (s, sig) == 0);
01458
01459 verify_test_message (message);
01460
01461 copy = dbus_message_copy (message);
01462
01463 _dbus_assert (dbus_message_get_reply_serial (message) ==
01464 dbus_message_get_reply_serial (copy));
01465 _dbus_assert (message->header.padding == copy->header.padding);
01466
01467 _dbus_assert (_dbus_string_get_length (&message->header.data) ==
01468 _dbus_string_get_length (©->header.data));
01469
01470 _dbus_assert (_dbus_string_get_length (&message->body) ==
01471 _dbus_string_get_length (©->body));
01472
01473 verify_test_message (copy);
01474
01475 name1 = dbus_message_get_interface (message);
01476 name2 = dbus_message_get_interface (copy);
01477
01478 _dbus_assert (strcmp (name1, name2) == 0);
01479
01480 name1 = dbus_message_get_member (message);
01481 name2 = dbus_message_get_member (copy);
01482
01483 _dbus_assert (strcmp (name1, name2) == 0);
01484
01485 dbus_message_unref (copy);
01486
01487
01488 dbus_message_lock (message);
01489 loader = _dbus_message_loader_new ();
01490
01491
01492 _dbus_message_loader_ref (loader);
01493 _dbus_message_loader_unref (loader);
01494
01495
01496 data = _dbus_string_get_const_data (&message->header.data);
01497 for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
01498 {
01499 DBusString *buffer;
01500
01501 _dbus_message_loader_get_buffer (loader, &buffer);
01502 _dbus_string_append_byte (buffer, data[i]);
01503 _dbus_message_loader_return_buffer (loader, buffer);
01504 }
01505
01506
01507 data = _dbus_string_get_const_data (&message->body);
01508 for (i = 0; i < _dbus_string_get_length (&message->body); i++)
01509 {
01510 DBusString *buffer;
01511
01512 _dbus_message_loader_get_buffer (loader, &buffer);
01513 _dbus_string_append_byte (buffer, data[i]);
01514 _dbus_message_loader_return_buffer (loader, buffer);
01515 }
01516
01517 #ifdef HAVE_UNIX_FD_PASSING
01518 {
01519 int *unix_fds;
01520 unsigned n_unix_fds;
01521
01522 _dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
01523 _dbus_assert(n_unix_fds > 0);
01524 _dbus_assert(message->n_unix_fds == 1);
01525 unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
01526 _dbus_assert(unix_fds[0] >= 0);
01527 _dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
01528 }
01529 #endif
01530
01531 dbus_message_unref (message);
01532
01533
01534 if (!_dbus_message_loader_queue_messages (loader))
01535 _dbus_assert_not_reached ("no memory to queue messages");
01536
01537 if (_dbus_message_loader_get_is_corrupted (loader))
01538 _dbus_assert_not_reached ("message loader corrupted");
01539
01540 message = _dbus_message_loader_pop_message (loader);
01541 if (!message)
01542 _dbus_assert_not_reached ("received a NULL message");
01543
01544 if (dbus_message_get_reply_serial (message) != 5678)
01545 _dbus_assert_not_reached ("reply serial fields differ");
01546
01547 dbus_message_unref (message);
01548
01549
01550 dbus_message_set_serial(message_without_unix_fds, 8901);
01551
01552 dbus_message_lock (message_without_unix_fds);
01553
01554 verify_test_message (message_without_unix_fds);
01555
01556 {
01557
01558
01559 DBusMessage *message2;
01560 DBusError error = DBUS_ERROR_INIT;
01561 char *marshalled = NULL;
01562 int len = 0;
01563 char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
01564
01565 if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
01566 _dbus_assert_not_reached ("failed to marshal message");
01567
01568 _dbus_assert (len != 0);
01569 _dbus_assert (marshalled != NULL);
01570
01571 _dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
01572 message2 = dbus_message_demarshal (marshalled, len, &error);
01573
01574 _dbus_assert (message2 != NULL);
01575 _dbus_assert (!dbus_error_is_set (&error));
01576 verify_test_message (message2);
01577
01578 dbus_message_unref (message2);
01579 dbus_free (marshalled);
01580
01581
01582
01583 message2 = dbus_message_demarshal ("invalid", 7, &error);
01584 _dbus_assert (message2 == NULL);
01585 _dbus_assert (dbus_error_is_set (&error));
01586 dbus_error_free (&error);
01587
01588
01589
01590 message2 = dbus_message_demarshal ("", 0, &error);
01591 _dbus_assert (message2 == NULL);
01592 _dbus_assert (dbus_error_is_set (&error));
01593 dbus_error_free (&error);
01594
01595
01596
01597 _dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0);
01598
01599
01600
01601 _dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1);
01602 }
01603
01604 dbus_message_unref (message_without_unix_fds);
01605 _dbus_message_loader_unref (loader);
01606
01607 check_memleaks ();
01608 _dbus_check_fdleaks_leave (initial_fds);
01609 initial_fds = _dbus_check_fdleaks_enter ();
01610
01611
01612 for (i = strlen (basic_types) - 1; i > 0; i--)
01613 {
01614 DBusBasicValue val;
01615 int some;
01616 char* signature = _dbus_strdup ("?");
01617
01618 signature[0] = basic_types[i];
01619 s = "SomeThingToSay";
01620 memset (&val, '\0', sizeof (val));
01621
01622 message = dbus_message_new_method_call ("de.ende.test",
01623 "/de/ende/test", "de.ende.Test", "ArtistName");
01624 _dbus_assert (message != NULL);
01625 dbus_message_iter_init_append (message, &iter);
01626 dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
01627 signature, &array_iter);
01628 for (some = 0; some < 3; some++)
01629 {
01630 if (basic_types[i] == DBUS_TYPE_STRING)
01631 dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING, &s);
01632 else
01633 dbus_message_iter_append_basic (&array_iter, basic_types[i], &val);
01634 }
01635 dbus_message_iter_close_container (&iter, &array_iter);
01636 dbus_message_iter_init (message, &iter);
01637 _dbus_assert (dbus_message_iter_get_element_count (&iter) == some);
01638 dbus_message_unref (message);
01639 dbus_free (signature);
01640 }
01641
01642 message = dbus_message_new_method_call ("de.ende.test",
01643 "/de/ende/test", "de.ende.Test", "ArtistName");
01644 _dbus_assert (message != NULL);
01645 dbus_message_iter_init_append (message, &iter);
01646 dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
01647 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
01648 DBUS_TYPE_STRING_AS_STRING
01649 DBUS_STRUCT_END_CHAR_AS_STRING, &array_iter);
01650 dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
01651 NULL, &struct_iter);
01652 s = "SpamAndEggs";
01653 dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING, &s);
01654 dbus_message_iter_close_container (&array_iter, &struct_iter);
01655 dbus_message_iter_close_container (&iter, &array_iter);
01656 dbus_message_iter_init (message, &iter);
01657 _dbus_assert (dbus_message_iter_get_element_count (&iter) == 1);
01658 dbus_message_unref (message);
01659 check_memleaks ();
01660
01661
01662 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01663 "/org/freedesktop/TestPath",
01664 "Foo.TestInterface",
01665 "Method");
01666
01667 dbus_message_iter_init_append (message, &iter);
01668
01669 ok = dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
01670 (DBUS_STRUCT_BEGIN_CHAR_AS_STRING
01671 DBUS_TYPE_STRING_AS_STRING
01672 DBUS_TYPE_STRING_AS_STRING
01673 DBUS_STRUCT_END_CHAR_AS_STRING),
01674 &array_iter);
01675 _dbus_assert (ok);
01676 ok = dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
01677 NULL, &struct_iter);
01678 _dbus_assert (ok);
01679 s = "peaches";
01680 ok = dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING, &s);
01681 _dbus_assert (ok);
01682
01683
01684
01685 dbus_message_iter_abandon_container (&array_iter, &struct_iter);
01686 dbus_message_iter_abandon_container (&array_iter, &iter);
01687
01688 dbus_message_unref (message);
01689
01690
01691 message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
01692 "/org/freedesktop/TestPath",
01693 "Foo.TestInterface",
01694 "Method");
01695
01696
01697 dbus_message_append_args (message,
01698 DBUS_TYPE_UINT32, &v_UINT32,
01699 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
01700 _DBUS_N_ELEMENTS (our_string_array),
01701 #ifdef HAVE_UNIX_FD_PASSING
01702 DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
01703 #endif
01704 DBUS_TYPE_UINT32, &v1_UINT32,
01705 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v1_ARRAY_STRING,
01706 _DBUS_N_ELEMENTS (our_string_array1),
01707 #ifdef HAVE_UNIX_FD_PASSING
01708 DBUS_TYPE_UNIX_FD, &v1_UNIX_FD,
01709 #endif
01710
01711 DBUS_TYPE_INVALID);
01712
01713 i = 0;
01714 sig[i++] = DBUS_TYPE_UINT32;
01715 sig[i++] = DBUS_TYPE_ARRAY;
01716 sig[i++] = DBUS_TYPE_STRING;
01717 #ifdef HAVE_UNIX_FD_PASSING
01718 sig[i++] = DBUS_TYPE_UNIX_FD;
01719 #endif
01720 sig[i++] = DBUS_TYPE_UINT32;
01721 sig[i++] = DBUS_TYPE_ARRAY;
01722 sig[i++] = DBUS_TYPE_STRING;
01723 #ifdef HAVE_UNIX_FD_PASSING
01724 sig[i++] = DBUS_TYPE_UNIX_FD;
01725 #endif
01726 sig[i++] = DBUS_TYPE_INVALID;
01727
01728 _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
01729
01730 verify_test_message_args_ignored (message);
01731 verify_test_message_memleak (message);
01732
01733 dbus_message_unref (message);
01734
01735
01736 {
01737 DBusMessageDataIter diter;
01738 DBusMessageData mdata;
01739 int count;
01740
01741 reset_validities_seen ();
01742
01743 count = 0;
01744 _dbus_message_data_iter_init (&diter);
01745
01746 while (_dbus_message_data_iter_get_and_next (&diter,
01747 &mdata))
01748 {
01749 if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
01750 mdata.expected_validity))
01751 {
01752 _dbus_warn ("expected validity %d and did not get it\n",
01753 mdata.expected_validity);
01754 _dbus_assert_not_reached ("message data failed");
01755 }
01756
01757 _dbus_message_data_free (&mdata);
01758
01759 count += 1;
01760 }
01761
01762 printf ("%d sample messages tested\n", count);
01763
01764 print_validities_seen (FALSE);
01765 print_validities_seen (TRUE);
01766 }
01767
01768 check_memleaks ();
01769 _dbus_check_fdleaks_leave (initial_fds);
01770
01771
01772 if (test_data_dir == NULL)
01773 return TRUE;
01774
01775 initial_fds = _dbus_check_fdleaks_enter ();
01776
01777 if (!dbus_internal_do_not_use_foreach_message_file (test_data_dir,
01778 (DBusForeachMessageFileFunc)
01779 dbus_internal_do_not_use_try_message_file,
01780 NULL))
01781 _dbus_assert_not_reached ("foreach_message_file test failed");
01782
01783 _dbus_check_fdleaks_leave (initial_fds);
01784
01785 return TRUE;
01786 }
01787
01788 #endif