D-Bus  1.8.16
dbus-message-util.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-message-util.c Would be in dbus-message.c, but only used by bus/tests
3  *
4  * Copyright (C) 2002, 2003, 2004, 2005 Red Hat Inc.
5  * Copyright (C) 2002, 2003 CodeFactory AB
6  *
7  * Licensed under the Academic Free License version 2.1
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 #include <config.h>
26 #include "dbus-internals.h"
27 #include "dbus-test.h"
28 #include "dbus-message-private.h"
29 #include "dbus-marshal-recursive.h"
30 #include "dbus-string.h"
31 #ifdef HAVE_UNIX_FD_PASSING
32 #include "dbus-sysdeps-unix.h"
33 #endif
34 
35 #ifdef __linux__
36 /* Necessary for the Linux-specific fd leak checking code only */
37 #include <sys/types.h>
38 #include <dirent.h>
39 #include <stdlib.h>
40 #include <errno.h>
41 #endif
42 
48 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
49 
61 static dbus_bool_t
62 dbus_message_iter_get_args (DBusMessageIter *iter,
63  DBusError *error,
64  int first_arg_type,
65  ...)
66 {
67  dbus_bool_t retval;
68  va_list var_args;
69 
70  _dbus_return_val_if_fail (iter != NULL, FALSE);
71  _dbus_return_val_if_error_is_set (error, FALSE);
72 
73  va_start (var_args, first_arg_type);
74  retval = _dbus_message_iter_get_args_valist (iter, error, first_arg_type, var_args);
75  va_end (var_args);
76 
77  return retval;
78 }
79 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
80 
83 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
84 #include "dbus-test.h"
85 #include "dbus-message-factory.h"
86 #include <stdio.h>
87 #include <stdlib.h>
88 
89 static int validities_seen[DBUS_VALIDITY_LAST + _DBUS_NEGATIVE_VALIDITY_COUNT];
90 
91 static void
92 reset_validities_seen (void)
93 {
94  int i;
95  i = 0;
96  while (i < _DBUS_N_ELEMENTS (validities_seen))
97  {
98  validities_seen[i] = 0;
99  ++i;
100  }
101 }
102 
103 static void
104 record_validity_seen (DBusValidity validity)
105 {
106  validities_seen[validity + _DBUS_NEGATIVE_VALIDITY_COUNT] += 1;
107 }
108 
109 static void
110 print_validities_seen (dbus_bool_t not_seen)
111 {
112  int i;
113  i = 0;
114  while (i < _DBUS_N_ELEMENTS (validities_seen))
115  {
116  if ((i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_VALIDITY_UNKNOWN ||
117  (i - _DBUS_NEGATIVE_VALIDITY_COUNT) == DBUS_INVALID_FOR_UNKNOWN_REASON)
118  ;
119  else if ((not_seen && validities_seen[i] == 0) ||
120  (!not_seen && validities_seen[i] > 0))
121  printf ("validity %3d seen %d times\n",
122  i - _DBUS_NEGATIVE_VALIDITY_COUNT,
123  validities_seen[i]);
124  ++i;
125  }
126 }
127 
128 static void
129 check_memleaks (void)
130 {
131  dbus_shutdown ();
132 
133  if (_dbus_get_malloc_blocks_outstanding () != 0)
134  {
135  _dbus_warn ("%d dbus_malloc blocks were not freed in %s\n",
136  _dbus_get_malloc_blocks_outstanding (), __FILE__);
137  _dbus_assert_not_reached ("memleaks");
138  }
139 }
140 
141 #ifdef __linux__
142 struct DBusInitialFDs {
143  fd_set set;
144 };
145 #endif
146 
147 DBusInitialFDs *
148 _dbus_check_fdleaks_enter (void)
149 {
150 #ifdef __linux__
151  DIR *d;
152  DBusInitialFDs *fds;
153 
154  /* this is plain malloc so it won't interfere with leak checking */
155  fds = malloc (sizeof (DBusInitialFDs));
156  _dbus_assert (fds != NULL);
157 
158  /* This works on Linux only */
159 
160  if ((d = opendir ("/proc/self/fd")))
161  {
162  struct dirent *de;
163 
164  while ((de = readdir(d)))
165  {
166  long l;
167  char *e = NULL;
168  int fd;
169 
170  if (de->d_name[0] == '.')
171  continue;
172 
173  errno = 0;
174  l = strtol (de->d_name, &e, 10);
175  _dbus_assert (errno == 0 && e && !*e);
176 
177  fd = (int) l;
178 
179  if (fd < 3)
180  continue;
181 
182  if (fd == dirfd (d))
183  continue;
184 
185  FD_SET (fd, &fds->set);
186  }
187 
188  closedir (d);
189  }
190 
191  return fds;
192 #else
193  return NULL;
194 #endif
195 }
196 
197 void
198 _dbus_check_fdleaks_leave (DBusInitialFDs *fds)
199 {
200 #ifdef __linux__
201  DIR *d;
202 
203  /* This works on Linux only */
204 
205  if ((d = opendir ("/proc/self/fd")))
206  {
207  struct dirent *de;
208 
209  while ((de = readdir(d)))
210  {
211  long l;
212  char *e = NULL;
213  int fd;
214 
215  if (de->d_name[0] == '.')
216  continue;
217 
218  errno = 0;
219  l = strtol (de->d_name, &e, 10);
220  _dbus_assert (errno == 0 && e && !*e);
221 
222  fd = (int) l;
223 
224  if (fd < 3)
225  continue;
226 
227  if (fd == dirfd (d))
228  continue;
229 
230  if (FD_ISSET (fd, &fds->set))
231  continue;
232 
233  _dbus_warn ("file descriptor %i leaked in %s.\n", fd, __FILE__);
234  _dbus_assert_not_reached ("fdleaks");
235  }
236 
237  closedir (d);
238  }
239 
240  free (fds);
241 #else
242  _dbus_assert (fds == NULL);
243 #endif
244 }
245 
246 static dbus_bool_t
247 check_have_valid_message (DBusMessageLoader *loader)
248 {
249  DBusMessage *message;
250  dbus_bool_t retval;
251 
252  message = NULL;
253  retval = FALSE;
254 
256  {
257  _dbus_warn ("loader corrupted on message that was expected to be valid; invalid reason %d\n",
258  loader->corruption_reason);
259  goto failed;
260  }
261 
262  message = _dbus_message_loader_pop_message (loader);
263  if (message == NULL)
264  {
265  _dbus_warn ("didn't load message that was expected to be valid (message not popped)\n");
266  goto failed;
267  }
268 
269  if (_dbus_string_get_length (&loader->data) > 0)
270  {
271  _dbus_warn ("had leftover bytes from expected-to-be-valid single message\n");
272  goto failed;
273  }
274 
275 #if 0
276  /* FIXME */
277  /* Verify that we're able to properly deal with the message.
278  * For example, this would detect improper handling of messages
279  * in nonstandard byte order.
280  */
281  if (!check_message_handling (message))
282  goto failed;
283 #endif
284 
285  record_validity_seen (DBUS_VALID);
286 
287  retval = TRUE;
288 
289  failed:
290  if (message)
291  dbus_message_unref (message);
292 
293  return retval;
294 }
295 
296 static dbus_bool_t
297 check_invalid_message (DBusMessageLoader *loader,
298  DBusValidity expected_validity)
299 {
300  dbus_bool_t retval;
301 
302  retval = FALSE;
303 
305  {
306  _dbus_warn ("loader not corrupted on message that was expected to be invalid\n");
307  goto failed;
308  }
309 
310  record_validity_seen (loader->corruption_reason);
311 
312  if (expected_validity != DBUS_INVALID_FOR_UNKNOWN_REASON &&
313  loader->corruption_reason != expected_validity)
314  {
315  _dbus_warn ("expected message to be corrupted for reason %d and was corrupted for %d instead\n",
316  expected_validity, loader->corruption_reason);
317  goto failed;
318  }
319 
320  retval = TRUE;
321 
322  failed:
323  return retval;
324 }
325 
326 static dbus_bool_t
327 check_incomplete_message (DBusMessageLoader *loader)
328 {
329  DBusMessage *message;
330  dbus_bool_t retval;
331 
332  message = NULL;
333  retval = FALSE;
334 
336  {
337  _dbus_warn ("loader corrupted on message that was expected to be valid (but incomplete), corruption reason %d\n",
338  loader->corruption_reason);
339  goto failed;
340  }
341 
342  message = _dbus_message_loader_pop_message (loader);
343  if (message != NULL)
344  {
345  _dbus_warn ("loaded message that was expected to be incomplete\n");
346  goto failed;
347  }
348 
349  record_validity_seen (DBUS_VALID_BUT_INCOMPLETE);
350  retval = TRUE;
351 
352  failed:
353  if (message)
354  dbus_message_unref (message);
355  return retval;
356 }
357 
358 static dbus_bool_t
359 check_loader_results (DBusMessageLoader *loader,
360  DBusValidity expected_validity)
361 {
363  _dbus_assert_not_reached ("no memory to queue messages");
364 
365  if (expected_validity == DBUS_VALID)
366  return check_have_valid_message (loader);
367  else if (expected_validity == DBUS_VALID_BUT_INCOMPLETE)
368  return check_incomplete_message (loader);
369  else if (expected_validity == DBUS_VALIDITY_UNKNOWN)
370  {
371  /* here we just know we didn't segfault and that was the
372  * only test. Also, we record that we got coverage
373  * for the validity reason.
374  */
376  record_validity_seen (loader->corruption_reason);
377 
378  return TRUE;
379  }
380  else
381  return check_invalid_message (loader, expected_validity);
382 }
383 
392 dbus_internal_do_not_use_load_message_file (const DBusString *filename,
393  DBusString *data)
394 {
395  dbus_bool_t retval;
396  DBusError error = DBUS_ERROR_INIT;
397 
398  retval = FALSE;
399 
400  _dbus_verbose ("Loading raw %s\n", _dbus_string_get_const_data (filename));
401  if (!_dbus_file_get_contents (data, filename, &error))
402  {
403  _dbus_warn ("Could not load message file %s: %s\n",
404  _dbus_string_get_const_data (filename),
405  error.message);
406  dbus_error_free (&error);
407  goto failed;
408  }
409 
410  retval = TRUE;
411 
412  failed:
413 
414  return retval;
415 }
416 
426 dbus_internal_do_not_use_try_message_file (const DBusString *filename,
427  DBusValidity expected_validity)
428 {
429  DBusString data;
430  dbus_bool_t retval;
431 
432  retval = FALSE;
433 
434  if (!_dbus_string_init (&data))
435  _dbus_assert_not_reached ("could not allocate string\n");
436 
437  if (!dbus_internal_do_not_use_load_message_file (filename, &data))
438  goto failed;
439 
440  retval = dbus_internal_do_not_use_try_message_data (&data, expected_validity);
441 
442  failed:
443 
444  if (!retval)
445  {
446  if (_dbus_string_get_length (&data) > 0)
448  _dbus_string_get_length (&data));
449 
450  _dbus_warn ("Failed message loader test on %s\n",
451  _dbus_string_get_const_data (filename));
452  }
453 
454  _dbus_string_free (&data);
455 
456  return retval;
457 }
458 
468 dbus_internal_do_not_use_try_message_data (const DBusString *data,
469  DBusValidity expected_validity)
470 {
471  DBusMessageLoader *loader;
472  dbus_bool_t retval;
473  int len;
474  int i;
475 
476  loader = NULL;
477  retval = FALSE;
478 
479  /* Write the data one byte at a time */
480 
481  loader = _dbus_message_loader_new ();
482 
483  /* check some trivial loader functions */
484  _dbus_message_loader_ref (loader);
487 
488  len = _dbus_string_get_length (data);
489  for (i = 0; i < len; i++)
490  {
491  DBusString *buffer;
492 
493  _dbus_message_loader_get_buffer (loader, &buffer);
494  _dbus_string_append_byte (buffer,
495  _dbus_string_get_byte (data, i));
496  _dbus_message_loader_return_buffer (loader, buffer);
497  }
498 
499  if (!check_loader_results (loader, expected_validity))
500  goto failed;
501 
503  loader = NULL;
504 
505  /* Write the data all at once */
506 
507  loader = _dbus_message_loader_new ();
508 
509  {
510  DBusString *buffer;
511 
512  _dbus_message_loader_get_buffer (loader, &buffer);
513  _dbus_string_copy (data, 0, buffer,
514  _dbus_string_get_length (buffer));
515  _dbus_message_loader_return_buffer (loader, buffer);
516  }
517 
518  if (!check_loader_results (loader, expected_validity))
519  goto failed;
520 
522  loader = NULL;
523 
524  /* Write the data 2 bytes at a time */
525 
526  loader = _dbus_message_loader_new ();
527 
528  len = _dbus_string_get_length (data);
529  for (i = 0; i < len; i += 2)
530  {
531  DBusString *buffer;
532 
533  _dbus_message_loader_get_buffer (loader, &buffer);
534  _dbus_string_append_byte (buffer,
535  _dbus_string_get_byte (data, i));
536  if ((i+1) < len)
537  _dbus_string_append_byte (buffer,
538  _dbus_string_get_byte (data, i+1));
539  _dbus_message_loader_return_buffer (loader, buffer);
540  }
541 
542  if (!check_loader_results (loader, expected_validity))
543  goto failed;
544 
546  loader = NULL;
547 
548  retval = TRUE;
549 
550  failed:
551 
552  if (loader)
554 
555  return retval;
556 }
557 
558 static dbus_bool_t
559 process_test_subdir (const DBusString *test_base_dir,
560  const char *subdir,
561  DBusValidity expected_validity,
562  DBusForeachMessageFileFunc function,
563  void *user_data)
564 {
565  DBusString test_directory;
566  DBusString filename;
567  DBusDirIter *dir;
568  dbus_bool_t retval;
569  DBusError error = DBUS_ERROR_INIT;
570 
571  retval = FALSE;
572  dir = NULL;
573 
574  if (!_dbus_string_init (&test_directory))
575  _dbus_assert_not_reached ("didn't allocate test_directory\n");
576 
577  _dbus_string_init_const (&filename, subdir);
578 
579  if (!_dbus_string_copy (test_base_dir, 0,
580  &test_directory, 0))
581  _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
582 
583  if (!_dbus_concat_dir_and_file (&test_directory, &filename))
584  _dbus_assert_not_reached ("couldn't allocate full path");
585 
586  _dbus_string_free (&filename);
587  if (!_dbus_string_init (&filename))
588  _dbus_assert_not_reached ("didn't allocate filename string\n");
589 
590  dir = _dbus_directory_open (&test_directory, &error);
591  if (dir == NULL)
592  {
593  _dbus_warn ("Could not open %s: %s\n",
594  _dbus_string_get_const_data (&test_directory),
595  error.message);
596  dbus_error_free (&error);
597  goto failed;
598  }
599 
600  printf ("Testing %s:\n", subdir);
601 
602  next:
603  while (_dbus_directory_get_next_file (dir, &filename, &error))
604  {
605  DBusString full_path;
606 
607  if (!_dbus_string_init (&full_path))
608  _dbus_assert_not_reached ("couldn't init string");
609 
610  if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
611  _dbus_assert_not_reached ("couldn't copy dir to full_path");
612 
613  if (!_dbus_concat_dir_and_file (&full_path, &filename))
614  _dbus_assert_not_reached ("couldn't concat file to dir");
615 
616  if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
617  ;
618  else
619  {
620  if (_dbus_string_ends_with_c_str (&filename, ".message"))
621  {
622  printf ("SKIP: Could not load %s, message builder language no longer supported\n",
623  _dbus_string_get_const_data (&filename));
624  }
625 
626  _dbus_verbose ("Skipping non-.message file %s\n",
627  _dbus_string_get_const_data (&filename));
628  _dbus_string_free (&full_path);
629  goto next;
630  }
631 
632  printf (" %s\n",
633  _dbus_string_get_const_data (&filename));
634 
635  if (! (*function) (&full_path,
636  expected_validity, user_data))
637  {
638  _dbus_string_free (&full_path);
639  goto failed;
640  }
641  else
642  _dbus_string_free (&full_path);
643  }
644 
645  if (dbus_error_is_set (&error))
646  {
647  _dbus_warn ("Could not get next file in %s: %s\n",
648  _dbus_string_get_const_data (&test_directory),
649  error.message);
650  dbus_error_free (&error);
651  goto failed;
652  }
653 
654  retval = TRUE;
655 
656  failed:
657 
658  if (dir)
659  _dbus_directory_close (dir);
660  _dbus_string_free (&test_directory);
661  _dbus_string_free (&filename);
662 
663  return retval;
664 }
665 
676 dbus_internal_do_not_use_foreach_message_file (const char *test_data_dir,
677  DBusForeachMessageFileFunc func,
678  void *user_data)
679 {
680  DBusString test_directory;
681  dbus_bool_t retval;
682 
683  retval = FALSE;
684 
685  _dbus_string_init_const (&test_directory, test_data_dir);
686 
687  if (!process_test_subdir (&test_directory, "valid-messages",
688  DBUS_VALID, func, user_data))
689  goto failed;
690 
691  check_memleaks ();
692 
693  if (!process_test_subdir (&test_directory, "invalid-messages",
694  DBUS_INVALID_FOR_UNKNOWN_REASON, func, user_data))
695  goto failed;
696 
697  check_memleaks ();
698 
699  if (!process_test_subdir (&test_directory, "incomplete-messages",
700  DBUS_VALID_BUT_INCOMPLETE, func, user_data))
701  goto failed;
702 
703  check_memleaks ();
704 
705  retval = TRUE;
706 
707  failed:
708 
709  _dbus_string_free (&test_directory);
710 
711  return retval;
712 }
713 
714 #if 0
715 #define GET_AND_CHECK(iter, typename, literal) \
716  do { \
717  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
718  _dbus_assert_not_reached ("got wrong argument type from message iter"); \
719  dbus_message_iter_get_basic (&iter, &v_##typename); \
720  if (v_##typename != literal) \
721  _dbus_assert_not_reached ("got wrong value from message iter"); \
722  } while (0)
723 
724 #define GET_AND_CHECK_STRCMP(iter, typename, literal) \
725  do { \
726  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
727  _dbus_assert_not_reached ("got wrong argument type from message iter"); \
728  dbus_message_iter_get_basic (&iter, &v_##typename); \
729  if (strcmp (v_##typename, literal) != 0) \
730  _dbus_assert_not_reached ("got wrong value from message iter"); \
731  } while (0)
732 
733 #define GET_AND_CHECK_AND_NEXT(iter, typename, literal) \
734  do { \
735  GET_AND_CHECK(iter, typename, literal); \
736  if (!dbus_message_iter_next (&iter)) \
737  _dbus_assert_not_reached ("failed to move iter to next"); \
738  } while (0)
739 
740 #define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal) \
741  do { \
742  GET_AND_CHECK_STRCMP(iter, typename, literal); \
743  if (!dbus_message_iter_next (&iter)) \
744  _dbus_assert_not_reached ("failed to move iter to next"); \
745  } while (0)
746 
747 static void
748 message_iter_test (DBusMessage *message)
749 {
750  DBusMessageIter iter, array, array2;
751  const char *v_STRING;
752  double v_DOUBLE;
753  dbus_int16_t v_INT16;
754  dbus_uint16_t v_UINT16;
755  dbus_int32_t v_INT32;
756  dbus_uint32_t v_UINT32;
757  dbus_int64_t v_INT64;
758  dbus_uint64_t v_UINT64;
759  unsigned char v_BYTE;
760  dbus_bool_t v_BOOLEAN;
761 
762  const dbus_int32_t *our_int_array;
763  int len;
764 
765  dbus_message_iter_init (message, &iter);
766 
767  GET_AND_CHECK_STRCMP_AND_NEXT (iter, STRING, "Test string");
768  GET_AND_CHECK_AND_NEXT (iter, INT32, -0x12345678);
769  GET_AND_CHECK_AND_NEXT (iter, UINT32, 0xedd1e);
770  GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
771 
773  _dbus_assert_not_reached ("Argument type not an array");
774 
776  _dbus_assert_not_reached ("Array type not double");
777 
778  dbus_message_iter_recurse (&iter, &array);
779 
780  GET_AND_CHECK_AND_NEXT (array, DOUBLE, 1.5);
781  GET_AND_CHECK (array, DOUBLE, 2.5);
782 
783  if (dbus_message_iter_next (&array))
784  _dbus_assert_not_reached ("Didn't reach end of array");
785 
786  if (!dbus_message_iter_next (&iter))
787  _dbus_assert_not_reached ("Reached end of arguments");
788 
789  GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
790 
792  _dbus_assert_not_reached ("no array");
793 
795  _dbus_assert_not_reached ("Array type not int32");
796 
797  /* Empty array */
798  dbus_message_iter_recurse (&iter, &array);
799 
800  if (dbus_message_iter_next (&array))
801  _dbus_assert_not_reached ("Didn't reach end of array");
802 
803  if (!dbus_message_iter_next (&iter))
804  _dbus_assert_not_reached ("Reached end of arguments");
805 
806  GET_AND_CHECK (iter, BYTE, 0xF0);
807 
808  if (dbus_message_iter_next (&iter))
809  _dbus_assert_not_reached ("Didn't reach end of arguments");
810 }
811 #endif
812 
813 static void
814 verify_test_message (DBusMessage *message)
815 {
816  DBusMessageIter iter;
817  DBusError error = DBUS_ERROR_INIT;
818  dbus_int16_t our_int16;
819  dbus_uint16_t our_uint16;
820  dbus_int32_t our_int;
821  dbus_uint32_t our_uint;
822  const char *our_str;
823  double our_double;
824  double v_DOUBLE;
825  dbus_bool_t our_bool;
826  unsigned char our_byte_1, our_byte_2;
827  const dbus_uint32_t *our_uint32_array = (void*)0xdeadbeef;
828  int our_uint32_array_len;
829  dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
830  int our_int32_array_len;
831  dbus_int64_t our_int64;
832  dbus_uint64_t our_uint64;
833  dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
834  int our_uint64_array_len;
835  const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
836  int our_int64_array_len;
837  const double *our_double_array = (void*)0xdeadbeef;
838  int our_double_array_len;
839  const unsigned char *our_byte_array = (void*)0xdeadbeef;
840  int our_byte_array_len;
841  const dbus_bool_t *our_boolean_array = (void*)0xdeadbeef;
842  int our_boolean_array_len;
843  char **our_string_array;
844  int our_string_array_len;
845 
846  dbus_message_iter_init (message, &iter);
847 
848  if (!dbus_message_iter_get_args (&iter, &error,
849  DBUS_TYPE_INT16, &our_int16,
850  DBUS_TYPE_UINT16, &our_uint16,
851  DBUS_TYPE_INT32, &our_int,
852  DBUS_TYPE_UINT32, &our_uint,
853  DBUS_TYPE_INT64, &our_int64,
854  DBUS_TYPE_UINT64, &our_uint64,
855  DBUS_TYPE_STRING, &our_str,
856  DBUS_TYPE_DOUBLE, &our_double,
857  DBUS_TYPE_BOOLEAN, &our_bool,
858  DBUS_TYPE_BYTE, &our_byte_1,
859  DBUS_TYPE_BYTE, &our_byte_2,
861  &our_uint32_array, &our_uint32_array_len,
863  &our_int32_array, &our_int32_array_len,
865  &our_uint64_array, &our_uint64_array_len,
867  &our_int64_array, &our_int64_array_len,
869  &our_double_array, &our_double_array_len,
871  &our_byte_array, &our_byte_array_len,
873  &our_boolean_array, &our_boolean_array_len,
875  &our_string_array, &our_string_array_len,
876  0))
877  {
878  _dbus_warn ("error: %s - %s\n", error.name,
879  (error.message != NULL) ? error.message : "no message");
880  _dbus_assert_not_reached ("Could not get arguments");
881  }
882 
883  if (our_int16 != -0x123)
884  _dbus_assert_not_reached ("16-bit integers differ!");
885 
886  if (our_uint16 != 0x123)
887  _dbus_assert_not_reached ("16-bit uints differ!");
888 
889  if (our_int != -0x12345678)
890  _dbus_assert_not_reached ("integers differ!");
891 
892  if (our_uint != 0x12300042)
893  _dbus_assert_not_reached ("uints differ!");
894 
895  if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
896  _dbus_assert_not_reached ("64-bit integers differ!");
897  if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
898  _dbus_assert_not_reached ("64-bit unsigned integers differ!");
899 
900  v_DOUBLE = 3.14159;
901  if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
902  _dbus_assert_not_reached ("doubles differ!");
903 
904  if (strcmp (our_str, "Test string") != 0)
905  _dbus_assert_not_reached ("strings differ!");
906 
907  if (!our_bool)
908  _dbus_assert_not_reached ("booleans differ");
909 
910  if (our_byte_1 != 42)
911  _dbus_assert_not_reached ("bytes differ!");
912 
913  if (our_byte_2 != 24)
914  _dbus_assert_not_reached ("bytes differ!");
915 
916  if (our_uint32_array_len != 4 ||
917  our_uint32_array[0] != 0x12345678 ||
918  our_uint32_array[1] != 0x23456781 ||
919  our_uint32_array[2] != 0x34567812 ||
920  our_uint32_array[3] != 0x45678123)
921  _dbus_assert_not_reached ("uint array differs");
922 
923  if (our_int32_array_len != 4 ||
924  our_int32_array[0] != 0x12345678 ||
925  our_int32_array[1] != -0x23456781 ||
926  our_int32_array[2] != 0x34567812 ||
927  our_int32_array[3] != -0x45678123)
928  _dbus_assert_not_reached ("int array differs");
929 
930  if (our_uint64_array_len != 4 ||
931  our_uint64_array[0] != 0x12345678 ||
932  our_uint64_array[1] != 0x23456781 ||
933  our_uint64_array[2] != 0x34567812 ||
934  our_uint64_array[3] != 0x45678123)
935  _dbus_assert_not_reached ("uint64 array differs");
936 
937  if (our_int64_array_len != 4 ||
938  our_int64_array[0] != 0x12345678 ||
939  our_int64_array[1] != -0x23456781 ||
940  our_int64_array[2] != 0x34567812 ||
941  our_int64_array[3] != -0x45678123)
942  _dbus_assert_not_reached ("int64 array differs");
943 
944  if (our_double_array_len != 3)
945  _dbus_assert_not_reached ("double array had wrong length");
946 
947  /* On all IEEE machines (i.e. everything sane) exact equality
948  * should be preserved over the wire
949  */
950  v_DOUBLE = 0.1234;
951  if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[0], v_DOUBLE))
952  _dbus_assert_not_reached ("double array had wrong values");
953  v_DOUBLE = 9876.54321;
954  if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[1], v_DOUBLE))
955  _dbus_assert_not_reached ("double array had wrong values");
956  v_DOUBLE = -300.0;
957  if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[2], v_DOUBLE))
958  _dbus_assert_not_reached ("double array had wrong values");
959 
960  if (our_byte_array_len != 4)
961  _dbus_assert_not_reached ("byte array had wrong length");
962 
963  if (our_byte_array[0] != 'a' ||
964  our_byte_array[1] != 'b' ||
965  our_byte_array[2] != 'c' ||
966  our_byte_array[3] != 234)
967  _dbus_assert_not_reached ("byte array had wrong values");
968 
969  if (our_boolean_array_len != 5)
970  _dbus_assert_not_reached ("bool array had wrong length");
971 
972  if (our_boolean_array[0] != TRUE ||
973  our_boolean_array[1] != FALSE ||
974  our_boolean_array[2] != TRUE ||
975  our_boolean_array[3] != TRUE ||
976  our_boolean_array[4] != FALSE)
977  _dbus_assert_not_reached ("bool array had wrong values");
978 
979  if (our_string_array_len != 4)
980  _dbus_assert_not_reached ("string array was wrong length");
981 
982  if (strcmp (our_string_array[0], "Foo") != 0 ||
983  strcmp (our_string_array[1], "bar") != 0 ||
984  strcmp (our_string_array[2], "") != 0 ||
985  strcmp (our_string_array[3], "woo woo woo woo") != 0)
986  _dbus_assert_not_reached ("string array had wrong values");
987 
988  dbus_free_string_array (our_string_array);
989 
990  if (dbus_message_iter_next (&iter))
991  _dbus_assert_not_reached ("Didn't reach end of arguments");
992 }
993 
994 static void
995 verify_test_message_args_ignored (DBusMessage *message)
996 {
997  DBusMessageIter iter;
998  DBusError error = DBUS_ERROR_INIT;
999  dbus_uint32_t our_uint;
1000  DBusInitialFDs *initial_fds;
1001 
1002  initial_fds = _dbus_check_fdleaks_enter ();
1003 
1004  /* parse with empty signature: "" */
1005  dbus_message_iter_init (message, &iter);
1006  if (!dbus_message_iter_get_args (&iter, &error,
1008  {
1009  _dbus_warn ("error: %s - %s\n", error.name,
1010  (error.message != NULL) ? error.message : "no message");
1011  }
1012  else
1013  {
1014  _dbus_assert (!dbus_error_is_set (&error));
1015  _dbus_verbose ("arguments ignored.\n");
1016  }
1017 
1018  /* parse with shorter signature: "u" */
1019  dbus_message_iter_init (message, &iter);
1020  if (!dbus_message_iter_get_args (&iter, &error,
1021  DBUS_TYPE_UINT32, &our_uint,
1023  {
1024  _dbus_warn ("error: %s - %s\n", error.name,
1025  (error.message != NULL) ? error.message : "no message");
1026  }
1027  else
1028  {
1029  _dbus_assert (!dbus_error_is_set (&error));
1030  _dbus_verbose ("arguments ignored.\n");
1031  }
1032 
1033  _dbus_check_fdleaks_leave (initial_fds);
1034 }
1035 
1036 static void
1037 verify_test_message_memleak (DBusMessage *message)
1038 {
1039  DBusMessageIter iter;
1040  DBusError error = DBUS_ERROR_INIT;
1041  dbus_uint32_t our_uint1;
1042  dbus_uint32_t our_uint2;
1043  dbus_uint32_t our_uint3;
1044  char **our_string_array1;
1045  int our_string_array_len1;
1046  char **our_string_array2;
1047  int our_string_array_len2;
1048  int our_unix_fd1;
1049  int our_unix_fd2;
1050  DBusInitialFDs *initial_fds;
1051 
1052  initial_fds = _dbus_check_fdleaks_enter ();
1053 
1054  /* parse with wrong signature: "uashuu" */
1055  dbus_error_free (&error);
1056  dbus_message_iter_init (message, &iter);
1057  if (!dbus_message_iter_get_args (&iter, &error,
1058  DBUS_TYPE_UINT32, &our_uint1,
1060  &our_string_array1, &our_string_array_len1,
1061 #ifdef HAVE_UNIX_FD_PASSING
1062  DBUS_TYPE_UNIX_FD, &our_unix_fd1,
1063 #endif
1064  DBUS_TYPE_UINT32, &our_uint2,
1065  DBUS_TYPE_UINT32, &our_uint3,
1067  {
1068  _dbus_verbose ("expected error: %s - %s\n", error.name,
1069  (error.message != NULL) ? error.message : "no message");
1070  /* ensure array of string and unix fd not leaked */
1071  _dbus_assert (our_string_array1 == NULL);
1072 #ifdef HAVE_UNIX_FD_PASSING
1073  _dbus_assert (our_unix_fd1 == -1);
1074 #endif
1075  }
1076  else
1077  {
1078  _dbus_warn ("error: parse with wrong signature: 'uashuu'.\n");
1079  }
1080 
1081  /* parse with wrong signature: "uashuashu" */
1082  dbus_message_iter_init (message, &iter);
1083  dbus_error_free (&error);
1084  if (!dbus_message_iter_get_args (&iter, &error,
1085  DBUS_TYPE_UINT32, &our_uint1,
1087  &our_string_array1, &our_string_array_len1,
1088 #ifdef HAVE_UNIX_FD_PASSING
1089  DBUS_TYPE_UNIX_FD, &our_unix_fd1,
1090 #endif
1091  DBUS_TYPE_UINT32, &our_uint2,
1093  &our_string_array2, &our_string_array_len2,
1094 #ifdef HAVE_UNIX_FD_PASSING
1095  DBUS_TYPE_UNIX_FD, &our_unix_fd2,
1096 #endif
1097  DBUS_TYPE_UINT32, &our_uint3,
1099  {
1100  _dbus_verbose ("expected error: %s - %s\n", error.name,
1101  (error.message != NULL) ? error.message : "no message");
1102  /* ensure array of string and unix fd not leaked */
1103  _dbus_assert (our_string_array1 == NULL);
1104  _dbus_assert (our_string_array2 == NULL);
1105 #ifdef HAVE_UNIX_FD_PASSING
1106  _dbus_assert (our_unix_fd1 == -1);
1107  _dbus_assert (our_unix_fd2 == -1);
1108 #endif
1109  }
1110  else
1111  {
1112  _dbus_warn ("error: parse with wrong signature: 'uashuashu'.\n");
1113  }
1114 
1115  /* parse with correct signature: "uashuash" */
1116  dbus_message_iter_init (message, &iter);
1117  dbus_error_free (&error);
1118  if (!dbus_message_iter_get_args (&iter, &error,
1119  DBUS_TYPE_UINT32, &our_uint1,
1121  &our_string_array1, &our_string_array_len1,
1122 #ifdef HAVE_UNIX_FD_PASSING
1123  DBUS_TYPE_UNIX_FD, &our_unix_fd1,
1124 #endif
1125  DBUS_TYPE_UINT32, &our_uint2,
1127  &our_string_array2, &our_string_array_len2,
1128 #ifdef HAVE_UNIX_FD_PASSING
1129  DBUS_TYPE_UNIX_FD, &our_unix_fd2,
1130 #endif
1132  {
1133  _dbus_warn ("error: %s - %s\n", error.name,
1134  (error.message != NULL) ? error.message : "no message");
1135  _dbus_assert_not_reached ("Could not get arguments");
1136  }
1137  else
1138  {
1139  dbus_free_string_array (our_string_array1);
1140  dbus_free_string_array (our_string_array2);
1141 #ifdef HAVE_UNIX_FD_PASSING
1142  _dbus_close (our_unix_fd1, &error);
1143  _dbus_close (our_unix_fd2, &error);
1144 #endif
1145  }
1146  _dbus_check_fdleaks_leave (initial_fds);
1147 }
1148 
1156 _dbus_message_test (const char *test_data_dir)
1157 {
1158  DBusMessage *message, *message_without_unix_fds;
1159  DBusMessageLoader *loader;
1160  int i;
1161  const char *data;
1162  DBusMessage *copy;
1163  const char *name1;
1164  const char *name2;
1165  const dbus_uint32_t our_uint32_array[] =
1166  { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
1167  const dbus_int32_t our_int32_array[] =
1168  { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
1169  const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
1170  const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
1171  const dbus_uint64_t our_uint64_array[] =
1172  { 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
1173  const dbus_int64_t our_int64_array[] =
1174  { 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
1175  const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
1176  const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
1177  const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
1178  const char *our_string_array1[] = { "foo", "Bar", "", "Woo woo Woo woo" };
1179  const char **v_ARRAY_STRING = our_string_array;
1180  const char **v1_ARRAY_STRING = our_string_array1;
1181  const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
1182  const double *v_ARRAY_DOUBLE = our_double_array;
1183  const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
1184  const unsigned char *v_ARRAY_BYTE = our_byte_array;
1185  const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
1186  const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
1187  char sig[64];
1188  const char *s;
1189  const char *v_STRING;
1190  double v_DOUBLE;
1191  dbus_int16_t v_INT16;
1192  dbus_uint16_t v_UINT16;
1193  dbus_int32_t v_INT32;
1194  dbus_uint32_t v_UINT32;
1195  dbus_uint32_t v1_UINT32;
1196  dbus_int64_t v_INT64;
1197  dbus_uint64_t v_UINT64;
1198  unsigned char v_BYTE;
1199  unsigned char v2_BYTE;
1200  dbus_bool_t v_BOOLEAN;
1201  DBusMessageIter iter, array_iter, struct_iter;
1202 #ifdef HAVE_UNIX_FD_PASSING
1203  int v_UNIX_FD;
1204  int v1_UNIX_FD;
1205 #endif
1206  char **decomposed;
1207  DBusInitialFDs *initial_fds;
1208 
1209  initial_fds = _dbus_check_fdleaks_enter ();
1210 
1211  message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
1212  "/org/freedesktop/TestPath",
1213  "Foo.TestInterface",
1214  "TestMethod");
1215  _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
1216  _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
1217  "TestMethod"));
1218  _dbus_assert (strcmp (dbus_message_get_path (message),
1219  "/org/freedesktop/TestPath") == 0);
1220  dbus_message_set_serial (message, 1234);
1221 
1222  /* string length including nul byte not a multiple of 4 */
1223  if (!dbus_message_set_sender (message, "org.foo.bar1"))
1224  _dbus_assert_not_reached ("out of memory");
1225 
1226  _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
1227  dbus_message_set_reply_serial (message, 5678);
1228 
1230  _dbus_string_get_length (&message->header.data));
1231  _dbus_verbose_bytes_of_string (&message->body, 0,
1232  _dbus_string_get_length (&message->body));
1233 
1234  if (!dbus_message_set_sender (message, NULL))
1235  _dbus_assert_not_reached ("out of memory");
1236 
1237 
1239  _dbus_string_get_length (&message->header.data));
1240  _dbus_verbose_bytes_of_string (&message->body, 0,
1241  _dbus_string_get_length (&message->body));
1242 
1243 
1244  _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
1245  _dbus_assert (dbus_message_get_serial (message) == 1234);
1246  _dbus_assert (dbus_message_get_reply_serial (message) == 5678);
1247  _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
1248 
1250  dbus_message_set_no_reply (message, TRUE);
1252  dbus_message_set_no_reply (message, FALSE);
1254 
1255  /* Set/get some header fields */
1256 
1257  if (!dbus_message_set_path (message, "/foo"))
1258  _dbus_assert_not_reached ("out of memory");
1259  _dbus_assert (strcmp (dbus_message_get_path (message),
1260  "/foo") == 0);
1261 
1262  if (!dbus_message_set_interface (message, "org.Foo"))
1263  _dbus_assert_not_reached ("out of memory");
1264  _dbus_assert (strcmp (dbus_message_get_interface (message),
1265  "org.Foo") == 0);
1266 
1267  if (!dbus_message_set_member (message, "Bar"))
1268  _dbus_assert_not_reached ("out of memory");
1269  _dbus_assert (strcmp (dbus_message_get_member (message),
1270  "Bar") == 0);
1271 
1272  /* Set/get them with longer values */
1273  if (!dbus_message_set_path (message, "/foo/bar"))
1274  _dbus_assert_not_reached ("out of memory");
1275  _dbus_assert (strcmp (dbus_message_get_path (message),
1276  "/foo/bar") == 0);
1277 
1278  if (!dbus_message_set_interface (message, "org.Foo.Bar"))
1279  _dbus_assert_not_reached ("out of memory");
1280  _dbus_assert (strcmp (dbus_message_get_interface (message),
1281  "org.Foo.Bar") == 0);
1282 
1283  if (!dbus_message_set_member (message, "BarFoo"))
1284  _dbus_assert_not_reached ("out of memory");
1285  _dbus_assert (strcmp (dbus_message_get_member (message),
1286  "BarFoo") == 0);
1287 
1288  /* Realloc shorter again */
1289 
1290  if (!dbus_message_set_path (message, "/foo"))
1291  _dbus_assert_not_reached ("out of memory");
1292  _dbus_assert (strcmp (dbus_message_get_path (message),
1293  "/foo") == 0);
1294 
1295  if (!dbus_message_set_interface (message, "org.Foo"))
1296  _dbus_assert_not_reached ("out of memory");
1297  _dbus_assert (strcmp (dbus_message_get_interface (message),
1298  "org.Foo") == 0);
1299 
1300  if (!dbus_message_set_member (message, "Bar"))
1301  _dbus_assert_not_reached ("out of memory");
1302  _dbus_assert (strcmp (dbus_message_get_member (message),
1303  "Bar") == 0);
1304 
1305  /* Path decomposing */
1306  dbus_message_set_path (message, NULL);
1307  dbus_message_get_path_decomposed (message, &decomposed);
1308  _dbus_assert (decomposed == NULL);
1309  dbus_free_string_array (decomposed);
1310 
1311  dbus_message_set_path (message, "/");
1312  dbus_message_get_path_decomposed (message, &decomposed);
1313  _dbus_assert (decomposed != NULL);
1314  _dbus_assert (decomposed[0] == NULL);
1315  dbus_free_string_array (decomposed);
1316 
1317  dbus_message_set_path (message, "/a/b");
1318  dbus_message_get_path_decomposed (message, &decomposed);
1319  _dbus_assert (decomposed != NULL);
1320  _dbus_assert (strcmp (decomposed[0], "a") == 0);
1321  _dbus_assert (strcmp (decomposed[1], "b") == 0);
1322  _dbus_assert (decomposed[2] == NULL);
1323  dbus_free_string_array (decomposed);
1324 
1325  dbus_message_set_path (message, "/spam/eggs");
1326  dbus_message_get_path_decomposed (message, &decomposed);
1327  _dbus_assert (decomposed != NULL);
1328  _dbus_assert (strcmp (decomposed[0], "spam") == 0);
1329  _dbus_assert (strcmp (decomposed[1], "eggs") == 0);
1330  _dbus_assert (decomposed[2] == NULL);
1331  dbus_free_string_array (decomposed);
1332 
1333  dbus_message_unref (message);
1334 
1335  /* Test the vararg functions */
1336  message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
1337  "/org/freedesktop/TestPath",
1338  "Foo.TestInterface",
1339  "TestMethod");
1340  dbus_message_set_serial (message, 1);
1341  dbus_message_set_reply_serial (message, 5678);
1342 
1343  v_INT16 = -0x123;
1344  v_UINT16 = 0x123;
1345  v_INT32 = -0x12345678;
1346  v_UINT32 = 0x12300042;
1347  v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
1348  v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
1349  v_STRING = "Test string";
1350  v_DOUBLE = 3.14159;
1351  v_BOOLEAN = TRUE;
1352  v_BYTE = 42;
1353  v2_BYTE = 24;
1354 #ifdef HAVE_UNIX_FD_PASSING
1355  v_UNIX_FD = 1;
1356  v1_UNIX_FD = 2;
1357 #endif
1358 
1359  dbus_message_append_args (message,
1360  DBUS_TYPE_INT16, &v_INT16,
1361  DBUS_TYPE_UINT16, &v_UINT16,
1362  DBUS_TYPE_INT32, &v_INT32,
1363  DBUS_TYPE_UINT32, &v_UINT32,
1364  DBUS_TYPE_INT64, &v_INT64,
1365  DBUS_TYPE_UINT64, &v_UINT64,
1366  DBUS_TYPE_STRING, &v_STRING,
1367  DBUS_TYPE_DOUBLE, &v_DOUBLE,
1368  DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
1369  DBUS_TYPE_BYTE, &v_BYTE,
1370  DBUS_TYPE_BYTE, &v2_BYTE,
1371  DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
1372  _DBUS_N_ELEMENTS (our_uint32_array),
1373  DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
1374  _DBUS_N_ELEMENTS (our_int32_array),
1375  DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
1376  _DBUS_N_ELEMENTS (our_uint64_array),
1377  DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
1378  _DBUS_N_ELEMENTS (our_int64_array),
1379  DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
1380  _DBUS_N_ELEMENTS (our_double_array),
1381  DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
1382  _DBUS_N_ELEMENTS (our_byte_array),
1383  DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
1384  _DBUS_N_ELEMENTS (our_boolean_array),
1385  DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
1386  _DBUS_N_ELEMENTS (our_string_array),
1387 
1389 
1390  i = 0;
1391  sig[i++] = DBUS_TYPE_INT16;
1392  sig[i++] = DBUS_TYPE_UINT16;
1393  sig[i++] = DBUS_TYPE_INT32;
1394  sig[i++] = DBUS_TYPE_UINT32;
1395  sig[i++] = DBUS_TYPE_INT64;
1396  sig[i++] = DBUS_TYPE_UINT64;
1397  sig[i++] = DBUS_TYPE_STRING;
1398  sig[i++] = DBUS_TYPE_DOUBLE;
1399  sig[i++] = DBUS_TYPE_BOOLEAN;
1400  sig[i++] = DBUS_TYPE_BYTE;
1401  sig[i++] = DBUS_TYPE_BYTE;
1402  sig[i++] = DBUS_TYPE_ARRAY;
1403  sig[i++] = DBUS_TYPE_UINT32;
1404  sig[i++] = DBUS_TYPE_ARRAY;
1405  sig[i++] = DBUS_TYPE_INT32;
1406  sig[i++] = DBUS_TYPE_ARRAY;
1407  sig[i++] = DBUS_TYPE_UINT64;
1408  sig[i++] = DBUS_TYPE_ARRAY;
1409  sig[i++] = DBUS_TYPE_INT64;
1410  sig[i++] = DBUS_TYPE_ARRAY;
1411  sig[i++] = DBUS_TYPE_DOUBLE;
1412  sig[i++] = DBUS_TYPE_ARRAY;
1413  sig[i++] = DBUS_TYPE_BYTE;
1414  sig[i++] = DBUS_TYPE_ARRAY;
1415  sig[i++] = DBUS_TYPE_BOOLEAN;
1416  sig[i++] = DBUS_TYPE_ARRAY;
1417  sig[i++] = DBUS_TYPE_STRING;
1418 
1419  message_without_unix_fds = dbus_message_copy(message);
1420  _dbus_assert(message_without_unix_fds);
1421 #ifdef HAVE_UNIX_FD_PASSING
1422  dbus_message_append_args (message,
1423  DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
1425  sig[i++] = DBUS_TYPE_UNIX_FD;
1426 #endif
1427  sig[i++] = DBUS_TYPE_INVALID;
1428 
1429  _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
1430 
1431  _dbus_verbose ("HEADER\n");
1433  _dbus_string_get_length (&message->header.data));
1434  _dbus_verbose ("BODY\n");
1435  _dbus_verbose_bytes_of_string (&message->body, 0,
1436  _dbus_string_get_length (&message->body));
1437 
1438  _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
1439  sig, dbus_message_get_signature (message));
1440 
1441  s = dbus_message_get_signature (message);
1442 
1443  _dbus_assert (dbus_message_has_signature (message, sig));
1444  _dbus_assert (strcmp (s, sig) == 0);
1445 
1446  verify_test_message (message);
1447 
1448  copy = dbus_message_copy (message);
1449 
1452  _dbus_assert (message->header.padding == copy->header.padding);
1453 
1454  _dbus_assert (_dbus_string_get_length (&message->header.data) ==
1455  _dbus_string_get_length (&copy->header.data));
1456 
1457  _dbus_assert (_dbus_string_get_length (&message->body) ==
1458  _dbus_string_get_length (&copy->body));
1459 
1460  verify_test_message (copy);
1461 
1462  name1 = dbus_message_get_interface (message);
1463  name2 = dbus_message_get_interface (copy);
1464 
1465  _dbus_assert (strcmp (name1, name2) == 0);
1466 
1467  name1 = dbus_message_get_member (message);
1468  name2 = dbus_message_get_member (copy);
1469 
1470  _dbus_assert (strcmp (name1, name2) == 0);
1471 
1472  dbus_message_unref (copy);
1473 
1474  /* Message loader test */
1475  dbus_message_lock (message);
1476  loader = _dbus_message_loader_new ();
1477 
1478  /* check ref/unref */
1479  _dbus_message_loader_ref (loader);
1480  _dbus_message_loader_unref (loader);
1481 
1482  /* Write the header data one byte at a time */
1483  data = _dbus_string_get_const_data (&message->header.data);
1484  for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
1485  {
1486  DBusString *buffer;
1487 
1488  _dbus_message_loader_get_buffer (loader, &buffer);
1489  _dbus_string_append_byte (buffer, data[i]);
1490  _dbus_message_loader_return_buffer (loader, buffer);
1491  }
1492 
1493  /* Write the body data one byte at a time */
1494  data = _dbus_string_get_const_data (&message->body);
1495  for (i = 0; i < _dbus_string_get_length (&message->body); i++)
1496  {
1497  DBusString *buffer;
1498 
1499  _dbus_message_loader_get_buffer (loader, &buffer);
1500  _dbus_string_append_byte (buffer, data[i]);
1501  _dbus_message_loader_return_buffer (loader, buffer);
1502  }
1503 
1504 #ifdef HAVE_UNIX_FD_PASSING
1505  {
1506  int *unix_fds;
1507  unsigned n_unix_fds;
1508  /* Write unix fd */
1509  _dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
1510  _dbus_assert(n_unix_fds > 0);
1511  _dbus_assert(message->n_unix_fds == 1);
1512  unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
1513  _dbus_assert(unix_fds[0] >= 0);
1514  _dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
1515  }
1516 #endif
1517 
1518  dbus_message_unref (message);
1519 
1520  /* Now pop back the message */
1522  _dbus_assert_not_reached ("no memory to queue messages");
1523 
1525  _dbus_assert_not_reached ("message loader corrupted");
1526 
1527  message = _dbus_message_loader_pop_message (loader);
1528  if (!message)
1529  _dbus_assert_not_reached ("received a NULL message");
1530 
1531  if (dbus_message_get_reply_serial (message) != 5678)
1532  _dbus_assert_not_reached ("reply serial fields differ");
1533 
1534  dbus_message_unref (message);
1535 
1536  /* ovveride the serial, since it was reset by dbus_message_copy() */
1537  dbus_message_set_serial(message_without_unix_fds, 8901);
1538 
1539  dbus_message_lock (message_without_unix_fds);
1540 
1541  verify_test_message (message_without_unix_fds);
1542 
1543  {
1544  /* Marshal and demarshal the message. */
1545 
1546  DBusMessage *message2;
1547  DBusError error = DBUS_ERROR_INIT;
1548  char *marshalled = NULL;
1549  int len = 0;
1550  char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
1551 
1552  if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
1553  _dbus_assert_not_reached ("failed to marshal message");
1554 
1555  _dbus_assert (len != 0);
1556  _dbus_assert (marshalled != NULL);
1557 
1558  _dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
1559  message2 = dbus_message_demarshal (marshalled, len, &error);
1560 
1561  _dbus_assert (message2 != NULL);
1562  _dbus_assert (!dbus_error_is_set (&error));
1563  verify_test_message (message2);
1564 
1565  dbus_message_unref (message2);
1566  dbus_free (marshalled);
1567 
1568  /* Demarshal invalid message. */
1569 
1570  message2 = dbus_message_demarshal ("invalid", 7, &error);
1571  _dbus_assert (message2 == NULL);
1572  _dbus_assert (dbus_error_is_set (&error));
1573  dbus_error_free (&error);
1574 
1575  /* Demarshal invalid (empty) message. */
1576 
1577  message2 = dbus_message_demarshal ("", 0, &error);
1578  _dbus_assert (message2 == NULL);
1579  _dbus_assert (dbus_error_is_set (&error));
1580  dbus_error_free (&error);
1581 
1582  /* Bytes needed to demarshal empty message: 0 (more) */
1583 
1585 
1586  /* Bytes needed to demarshal invalid message: -1 (error). */
1587 
1589  }
1590 
1591  dbus_message_unref (message_without_unix_fds);
1592  _dbus_message_loader_unref (loader);
1593 
1594  check_memleaks ();
1595  _dbus_check_fdleaks_leave (initial_fds);
1596  initial_fds = _dbus_check_fdleaks_enter ();
1597 
1598  /* Check that we can abandon a container */
1599  message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
1600  "/org/freedesktop/TestPath",
1601  "Foo.TestInterface",
1602  "Method");
1603 
1604  dbus_message_iter_init_append (message, &iter);
1605 
1611  &array_iter));
1613  NULL, &struct_iter));
1614 
1615  s = "peaches";
1617  &s));
1618 
1619  /* uh-oh, error, try and unwind */
1620 
1621  dbus_message_iter_abandon_container (&array_iter, &struct_iter);
1622  dbus_message_iter_abandon_container (&array_iter, &iter);
1623 
1624  dbus_message_unref (message);
1625 
1626  /* Check we should not leak array of string or unix fd, fd.o#21259 */
1627  message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
1628  "/org/freedesktop/TestPath",
1629  "Foo.TestInterface",
1630  "Method");
1631 
1632  /* signature "uashuash" */
1633  dbus_message_append_args (message,
1634  DBUS_TYPE_UINT32, &v_UINT32,
1635  DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
1636  _DBUS_N_ELEMENTS (our_string_array),
1637 #ifdef HAVE_UNIX_FD_PASSING
1638  DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
1639 #endif
1640  DBUS_TYPE_UINT32, &v1_UINT32,
1641  DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v1_ARRAY_STRING,
1642  _DBUS_N_ELEMENTS (our_string_array1),
1643 #ifdef HAVE_UNIX_FD_PASSING
1644  DBUS_TYPE_UNIX_FD, &v1_UNIX_FD,
1645 #endif
1646 
1648 
1649  i = 0;
1650  sig[i++] = DBUS_TYPE_UINT32;
1651  sig[i++] = DBUS_TYPE_ARRAY;
1652  sig[i++] = DBUS_TYPE_STRING;
1653 #ifdef HAVE_UNIX_FD_PASSING
1654  sig[i++] = DBUS_TYPE_UNIX_FD;
1655 #endif
1656  sig[i++] = DBUS_TYPE_UINT32;
1657  sig[i++] = DBUS_TYPE_ARRAY;
1658  sig[i++] = DBUS_TYPE_STRING;
1659 #ifdef HAVE_UNIX_FD_PASSING
1660  sig[i++] = DBUS_TYPE_UNIX_FD;
1661 #endif
1662  sig[i++] = DBUS_TYPE_INVALID;
1663 
1664  _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
1665 
1666  verify_test_message_args_ignored (message);
1667  verify_test_message_memleak (message);
1668 
1669  dbus_message_unref (message);
1670 
1671  /* Load all the sample messages from the message factory */
1672  {
1673  DBusMessageDataIter diter;
1674  DBusMessageData mdata;
1675  int count;
1676 
1677  reset_validities_seen ();
1678 
1679  count = 0;
1680  _dbus_message_data_iter_init (&diter);
1681 
1682  while (_dbus_message_data_iter_get_and_next (&diter,
1683  &mdata))
1684  {
1685  if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
1686  mdata.expected_validity))
1687  {
1688  _dbus_warn ("expected validity %d and did not get it\n",
1689  mdata.expected_validity);
1690  _dbus_assert_not_reached ("message data failed");
1691  }
1692 
1693  _dbus_message_data_free (&mdata);
1694 
1695  count += 1;
1696  }
1697 
1698  printf ("%d sample messages tested\n", count);
1699 
1700  print_validities_seen (FALSE);
1701  print_validities_seen (TRUE);
1702  }
1703 
1704  check_memleaks ();
1705  _dbus_check_fdleaks_leave (initial_fds);
1706 
1707  /* Now load every message in test_data_dir if we have one */
1708  if (test_data_dir == NULL)
1709  return TRUE;
1710 
1711  initial_fds = _dbus_check_fdleaks_enter ();
1712 
1713  if (!dbus_internal_do_not_use_foreach_message_file (test_data_dir,
1714  (DBusForeachMessageFileFunc)
1715  dbus_internal_do_not_use_try_message_file,
1716  NULL))
1717  _dbus_assert_not_reached ("foreach_message_file test failed");
1718 
1719  _dbus_check_fdleaks_leave (initial_fds);
1720 
1721  return TRUE;
1722 }
1723 
1724 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms.
#define DBUS_TYPE_UINT16
Type code marking a 16-bit unsigned integer.
Definition: dbus-protocol.h:78
void dbus_message_lock(DBusMessage *message)
Locks a message.
Definition: dbus-message.c:384
const char * message
public error message field
Definition: dbus-errors.h:51
#define NULL
A null pointer, defined appropriately for C or C++.
dbus_bool_t dbus_message_is_method_call(DBusMessage *message, const char *iface, const char *method)
Checks whether the message is a method call with the given interface and member fields.
long _dbus_message_loader_get_max_message_size(DBusMessageLoader *loader)
Gets the maximum allowed message size in bytes.
void dbus_message_set_no_reply(DBusMessage *message, dbus_bool_t no_reply)
Sets a flag indicating that the message does not want a reply; if this flag is set, the other end of the connection may (but is not required to) optimize by not sending method return or error replies.
int dbus_message_iter_get_arg_type(DBusMessageIter *iter)
Returns the argument type of the argument that the message iterator points to.
void _dbus_message_loader_return_buffer(DBusMessageLoader *loader, DBusString *buffer)
Returns a buffer obtained from _dbus_message_loader_get_buffer(), indicating to the loader how many b...
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:701
void _dbus_message_loader_return_unix_fds(DBusMessageLoader *loader, int *fds, unsigned n_fds)
Returns a buffer obtained from _dbus_message_loader_get_unix_fds().
dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
Returns the serial of a message or 0 if none has been specified.
#define DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_STRUCT_BEGIN_CHAR as a string literal instead of a int literal
void dbus_message_iter_recurse(DBusMessageIter *iter, DBusMessageIter *sub)
Recurses into a container value when reading values from a message, initializing a sub-iterator to us...
DBusMessage * _dbus_message_loader_pop_message(DBusMessageLoader *loader)
Pops a loaded message (passing ownership of the message to the caller).
dbus_bool_t dbus_message_set_interface(DBusMessage *message, const char *iface)
Sets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the interface...
#define DBUS_TYPE_STRUCT
STRUCT and DICT_ENTRY are sort of special since their codes can't appear in a type string...
void _dbus_directory_close(DBusDirIter *iter)
Closes a directory iteration.
dbus_uint32_t padding
bytes of alignment in header
dbus_bool_t _dbus_message_iter_get_args_valist(DBusMessageIter *iter, DBusError *error, int first_arg_type, va_list var_args)
Implementation of the varargs arg-getting functions.
Definition: dbus-message.c:796
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
DBusString body
Body network data.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_directory_get_next_file(DBusDirIter *iter, DBusString *filename, DBusError *error)
Get next file in the directory.
#define DBUS_ERROR_INIT
Expands to a suitable initializer for a DBusError on the stack.
Definition: dbus-errors.h:62
const char * dbus_message_get_signature(DBusMessage *message)
Gets the type signature of the message, i.e.
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
void dbus_error_free(DBusError *error)
Frees an error that's been set (or just initialized), then reinitializes the error as in dbus_error_i...
Definition: dbus-errors.c:211
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer.
Definition: dbus-protocol.h:66
void _dbus_message_loader_unref(DBusMessageLoader *loader)
Decrements the reference count of the loader and finalizes the loader when the count reaches zero...
DBusString data
Header network data, stored separately from body so we can independently realloc it.
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
const char * dbus_message_get_path(DBusMessage *message)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
DBusDirIter * _dbus_directory_open(const DBusString *filename, DBusError *error)
Open a directory to iterate over.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
Definition: dbus-string.c:1265
DBusValidity
This is primarily used in unit testing, so we can verify that each invalid message is invalid for the...
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:51
#define DBUS_TYPE_DOUBLE
Type code marking an 8-byte double in IEEE 754 format.
Definition: dbus-protocol.h:98
dbus_bool_t dbus_message_iter_init(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for reading the arguments of the message passed in. ...
dbus_bool_t _dbus_string_ends_with_c_str(const DBusString *a, const char *c_str)
Returns whether a string ends with the given suffix.
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
#define DBUS_TYPE_INT64
Type code marking a 64-bit signed integer.
Definition: dbus-protocol.h:90
Internals of directory iterator.
const char * dbus_message_get_member(DBusMessage *message)
Gets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
Internals of DBusMessage.
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
#define DBUS_MINIMUM_HEADER_SIZE
The smallest header size that can occur.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
DBusHeader header
Header network data and associated cache.
dbus_bool_t dbus_message_set_sender(DBusMessage *message, const char *sender)
Sets the message sender.
DBusString data
Buffered data.
_DBUS_GNUC_EXTENSION typedef unsigned long dbus_uint64_t
A 64-bit unsigned integer.
DBusMessageLoader * _dbus_message_loader_ref(DBusMessageLoader *loader)
Increments the reference count of the loader.
dbus_bool_t dbus_message_get_path_decomposed(DBusMessage *message, char ***path)
Gets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitt...
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
dbus_bool_t dbus_message_set_path(DBusMessage *message, const char *object_path)
Sets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the one a s...
#define DBUS_TYPE_INT32
Type code marking a 32-bit signed integer.
Definition: dbus-protocol.h:82
DBusMessageLoader * _dbus_message_loader_new(void)
Creates a new message loader.
Object representing an exception.
Definition: dbus-errors.h:48
_DBUS_GNUC_EXTENSION typedef long dbus_int64_t
A 64-bit signed integer.
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
#define DBUS_TYPE_UINT64
Type code marking a 64-bit unsigned integer.
Definition: dbus-protocol.h:94
dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
Returns the serial that the message is a reply to or 0 if none.
dbus_bool_t dbus_message_has_signature(DBusMessage *message, const char *signature)
Checks whether the message has the given signature; see dbus_message_get_signature() for more details...
dbus_bool_t _dbus_message_loader_get_is_corrupted(DBusMessageLoader *loader)
Checks whether the loader is confused due to bad data.
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
Definition: dbus-protocol.h:86
the data is valid
DBusMessage * dbus_message_new_method_call(const char *destination, const char *path, const char *iface, const char *method)
Constructs a new message to invoke a method on a remote object.
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
dbus_bool_t dbus_message_has_destination(DBusMessage *message, const char *name)
Checks whether the message was sent to the given name.
short dbus_int16_t
A 16-bit signed integer on all platforms.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
Definition: dbus-string.c:1139
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:242
#define TRUE
Expands to "1".
dbus_bool_t dbus_message_marshal(DBusMessage *msg, char **marshalled_data_p, int *len_p)
Turn a DBusMessage into the marshalled form as described in the D-Bus specification.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
DBusMessage * dbus_message_copy(const DBusMessage *message)
Creates a new message that is an exact replica of the message specified, except that its refcount is ...
int dbus_message_iter_get_element_type(DBusMessageIter *iter)
Returns the element type of the array that the message iterator points to.
const char * name
public error name field
Definition: dbus-errors.h:50
DBusMessage * dbus_message_demarshal(const char *str, int len, DBusError *error)
Demarshal a D-Bus message from the format described in the D-Bus specification.
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
const char * dbus_message_get_interface(DBusMessage *message)
Gets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or being emitted...
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
Definition: dbus-protocol.h:60
dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
Sets the reply serial of a message (the serial of the message this is a reply to).
dbus_bool_t dbus_message_has_sender(DBusMessage *message, const char *name)
Checks whether the message has the given unique name as its sender.
dbus_bool_t dbus_message_iter_next(DBusMessageIter *iter)
Moves the iterator to the next field, if any.
#define DBUS_INT64_CONSTANT(val)
Declare a 64-bit signed integer constant.
dbus_bool_t dbus_message_get_no_reply(DBusMessage *message)
Returns TRUE if the message does not expect a reply.
#define DBUS_TYPE_INT16
Type code marking a 16-bit signed integer.
Definition: dbus-protocol.h:74
dbus_bool_t _dbus_message_loader_get_unix_fds(DBusMessageLoader *loader, int **fds, unsigned *max_n_fds)
Gets the buffer to use for reading unix fds from the network.
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:749
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
Definition: dbus-protocol.h:70
void _dbus_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer)
Gets the buffer to use for reading data from the network.
#define DBUS_STRUCT_END_CHAR_AS_STRING
DBUS_STRUCT_END_CHAR a string literal instead of a int literal
dbus_bool_t dbus_message_iter_open_container(DBusMessageIter *iter, int type, const char *contained_signature, DBusMessageIter *sub)
Appends a container-typed value to the message; you are required to append the contents of the contai...
dbus_bool_t _dbus_file_get_contents(DBusString *str, const DBusString *filename, DBusError *error)
Appends the contents of the given file to the string, returning error code.
#define DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING as a string literal instead of a int literal
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
void dbus_shutdown(void)
Frees all memory allocated internally by libdbus and reverses the effects of dbus_threads_init().
Definition: dbus-memory.c:890
#define FALSE
Expands to "0".
int dbus_message_demarshal_bytes_needed(const char *buf, int len)
Returns the number of bytes required to be in the buffer to demarshal a D-Bus message.
void dbus_message_iter_abandon_container(DBusMessageIter *iter, DBusMessageIter *sub)
Abandons creation of a contained-typed value and frees resources created by dbus_message_iter_open_co...
void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
dbus_bool_t _dbus_message_loader_queue_messages(DBusMessageLoader *loader)
Converts buffered data into messages, if we have enough data.
int dbus_int32_t
A 32-bit signed integer on all platforms.
#define DBUS_UINT64_CONSTANT(val)
Declare a 64-bit unsigned integer constant.
DBusValidity corruption_reason
why we were corrupted
dbus_bool_t dbus_message_set_member(DBusMessage *message, const char *member)
Sets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
Implementation details of DBusMessageLoader.
dbus_bool_t dbus_error_is_set(const DBusError *error)
Checks whether an error occurred (the error is set).
Definition: dbus-errors.c:329
#define _DBUS_DOUBLES_BITWISE_EQUAL(a, b)
On x86 there is an 80-bit FPU, and if you do "a == b" it may have a or b in an 80-bit register...
Definition: dbus-sysdeps.h:488
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.
Definition: dbus-message.c:254
unsigned short dbus_uint16_t
A 16-bit unsigned integer on all platforms.