D-Bus  1.12.18
dbus-message.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-message.c DBusMessage object
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-marshal-recursive.h"
28 #include "dbus-marshal-validate.h"
29 #include "dbus-marshal-byteswap.h"
30 #include "dbus-marshal-header.h"
31 #include "dbus-signature.h"
32 #include "dbus-message-private.h"
33 #include "dbus-object-tree.h"
34 #include "dbus-memory.h"
35 #include "dbus-list.h"
36 #include "dbus-threads-internal.h"
37 #ifdef HAVE_UNIX_FD_PASSING
38 #include "dbus-sysdeps.h"
39 #include "dbus-sysdeps-unix.h"
40 #endif
41 
42 #include <string.h>
43 
44 #define _DBUS_TYPE_IS_STRINGLIKE(type) \
45  (type == DBUS_TYPE_STRING || type == DBUS_TYPE_SIGNATURE || \
46  type == DBUS_TYPE_OBJECT_PATH)
47 
48 static void dbus_message_finalize (DBusMessage *message);
49 
60 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
61 static dbus_bool_t
62 _dbus_enable_message_cache (void)
63 {
64  static int enabled = -1;
65 
66  if (enabled < 0)
67  {
68  const char *s = _dbus_getenv ("DBUS_MESSAGE_CACHE");
69 
70  enabled = TRUE;
71 
72  if (s && *s)
73  {
74  if (*s == '0')
75  enabled = FALSE;
76  else if (*s == '1')
77  enabled = TRUE;
78  else
79  _dbus_warn ("DBUS_MESSAGE_CACHE should be 0 or 1 if set, not '%s'",
80  s);
81  }
82  }
83 
84  return enabled;
85 }
86 #else
87  /* constant expression, should be optimized away */
88 # define _dbus_enable_message_cache() (TRUE)
89 #endif
90 
91 #ifndef _dbus_message_trace_ref
92 void
93 _dbus_message_trace_ref (DBusMessage *message,
94  int old_refcount,
95  int new_refcount,
96  const char *why)
97 {
98  static int enabled = -1;
99 
100  _dbus_trace_ref ("DBusMessage", message, old_refcount, new_refcount, why,
101  "DBUS_MESSAGE_TRACE", &enabled);
102 }
103 #endif
104 
105 /* Not thread locked, but strictly const/read-only so should be OK
106  */
108 _DBUS_STRING_DEFINE_STATIC(_dbus_empty_signature_str, "");
109 
110 /* these have wacky values to help trap uninitialized iterators;
111  * but has to fit in 3 bits
112  */
113 enum {
114  DBUS_MESSAGE_ITER_TYPE_READER = 3,
115  DBUS_MESSAGE_ITER_TYPE_WRITER = 7
116 };
117 
120 
127 {
130  dbus_uint32_t iter_type : 3;
131  dbus_uint32_t sig_refcount : 8;
132  union
133  {
136  } u;
137 };
138 
144 typedef struct
145 {
146  void *dummy1;
147  void *dummy2;
148  dbus_uint32_t dummy3;
149  int dummy4;
150  int dummy5;
151  int dummy6;
152  int dummy7;
153  int dummy8;
154  int dummy9;
155  int dummy10;
156  int dummy11;
157  int pad1;
158  int pad2;
159  void *pad3;
161 
162 static void
163 get_const_signature (DBusHeader *header,
164  const DBusString **type_str_p,
165  int *type_pos_p)
166 {
167  if (_dbus_header_get_field_raw (header,
169  type_str_p,
170  type_pos_p))
171  {
172  *type_pos_p += 1; /* skip the signature length which is 1 byte */
173  }
174  else
175  {
176  *type_str_p = &_dbus_empty_signature_str;
177  *type_pos_p = 0;
178  }
179 }
180 
186 static void
187 _dbus_message_byteswap (DBusMessage *message)
188 {
189  const DBusString *type_str;
190  int type_pos;
191  char byte_order;
192 
193  byte_order = _dbus_header_get_byte_order (&message->header);
194 
195  if (byte_order == DBUS_COMPILER_BYTE_ORDER)
196  return;
197 
198  _dbus_verbose ("Swapping message into compiler byte order\n");
199 
200  get_const_signature (&message->header, &type_str, &type_pos);
201 
202  _dbus_marshal_byteswap (type_str, type_pos,
203  byte_order,
204  DBUS_COMPILER_BYTE_ORDER,
205  &message->body, 0);
206 
207  _dbus_header_byteswap (&message->header, DBUS_COMPILER_BYTE_ORDER);
209  DBUS_COMPILER_BYTE_ORDER);
210 }
211 
218 #define ensure_byte_order(message) _dbus_message_byteswap (message)
219 
230 void
232  const DBusString **header,
233  const DBusString **body)
234 {
235  _dbus_assert (message->locked);
236 
237  *header = &message->header.data;
238  *body = &message->body;
239 }
240 
251  const int **fds,
252  unsigned *n_fds)
253 {
254  _dbus_assert (message->locked);
255 
256 #ifdef HAVE_UNIX_FD_PASSING
257  *fds = message->unix_fds;
258  *n_fds = message->n_unix_fds;
259 #else
260  *fds = NULL;
261  *n_fds = 0;
262 #endif
263 }
264 
276 void
278  dbus_uint32_t serial)
279 {
280  _dbus_return_if_fail (message != NULL);
281  _dbus_return_if_fail (!message->locked);
282 
283  _dbus_header_set_serial (&message->header, serial);
284 }
285 
302 void
304  DBusList *link)
305 {
306  /* right now we don't recompute the delta when message
307  * size changes, and that's OK for current purposes
308  * I think, but could be important to change later.
309  * Do recompute it whenever there are no outstanding counters,
310  * since it's basically free.
311  */
312  if (message->counters == NULL)
313  {
314  message->size_counter_delta =
315  _dbus_string_get_length (&message->header.data) +
316  _dbus_string_get_length (&message->body);
317 
318 #ifdef HAVE_UNIX_FD_PASSING
319  message->unix_fd_counter_delta = message->n_unix_fds;
320 #endif
321 
322 #if 0
323  _dbus_verbose ("message has size %ld\n",
324  message->size_counter_delta);
325 #endif
326  }
327 
328  _dbus_list_append_link (&message->counters, link);
329 
331 
332 #ifdef HAVE_UNIX_FD_PASSING
333  _dbus_counter_adjust_unix_fd (link->data, message->unix_fd_counter_delta);
334 #endif
335 }
336 
353  DBusCounter *counter)
354 {
355  DBusList *link;
356 
357  link = _dbus_list_alloc_link (counter);
358  if (link == NULL)
359  return FALSE;
360 
361  _dbus_counter_ref (counter);
362  _dbus_message_add_counter_link (message, link);
363 
364  return TRUE;
365 }
366 
374 void
376  DBusCounter *counter)
377 {
378  DBusList *link;
379 
380  link = _dbus_list_find_last (&message->counters,
381  counter);
382  _dbus_assert (link != NULL);
383 
384  _dbus_list_remove_link (&message->counters, link);
385 
386  _dbus_counter_adjust_size (counter, - message->size_counter_delta);
387 
388 #ifdef HAVE_UNIX_FD_PASSING
389  _dbus_counter_adjust_unix_fd (counter, - message->unix_fd_counter_delta);
390 #endif
391 
392  _dbus_counter_notify (counter);
393  _dbus_counter_unref (counter);
394 }
395 
406 void
408 {
409  if (!message->locked)
410  {
412  _dbus_string_get_length (&message->body));
413 
414  /* must have a signature if you have a body */
415  _dbus_assert (_dbus_string_get_length (&message->body) == 0 ||
416  dbus_message_get_signature (message) != NULL);
417 
418  message->locked = TRUE;
419  }
420 }
421 
422 static dbus_bool_t
423 set_or_delete_string_field (DBusMessage *message,
424  int field,
425  int typecode,
426  const char *value)
427 {
428  if (value == NULL)
429  return _dbus_header_delete_field (&message->header, field);
430  else
431  return _dbus_header_set_field_basic (&message->header,
432  field,
433  typecode,
434  &value);
435 }
436 
437 /* Message Cache
438  *
439  * We cache some DBusMessage to reduce the overhead of allocating
440  * them. In my profiling this consistently made about an 8%
441  * difference. It avoids the malloc for the message, the malloc for
442  * the slot list, the malloc for the header string and body string,
443  * and the associated free() calls. It does introduce another global
444  * lock which could be a performance issue in certain cases.
445  *
446  * For the echo client/server the round trip time goes from around
447  * .000077 to .000069 with the message cache on my laptop. The sysprof
448  * change is as follows (numbers are cumulative percentage):
449  *
450  * with message cache implemented as array as it is now (0.000069 per):
451  * new_empty_header 1.46
452  * mutex_lock 0.56 # i.e. _DBUS_LOCK(message_cache)
453  * mutex_unlock 0.25
454  * self 0.41
455  * unref 2.24
456  * self 0.68
457  * list_clear 0.43
458  * mutex_lock 0.33 # i.e. _DBUS_LOCK(message_cache)
459  * mutex_unlock 0.25
460  *
461  * with message cache implemented as list (0.000070 per roundtrip):
462  * new_empty_header 2.72
463  * list_pop_first 1.88
464  * unref 3.3
465  * list_prepend 1.63
466  *
467  * without cache (0.000077 per roundtrip):
468  * new_empty_header 6.7
469  * string_init_preallocated 3.43
470  * dbus_malloc 2.43
471  * dbus_malloc0 2.59
472  *
473  * unref 4.02
474  * string_free 1.82
475  * dbus_free 1.63
476  * dbus_free 0.71
477  *
478  * If you implement the message_cache with a list, the primary reason
479  * it's slower is that you add another thread lock (on the DBusList
480  * mempool).
481  */
482 
484 #define MAX_MESSAGE_SIZE_TO_CACHE 10 * _DBUS_ONE_KILOBYTE
485 
487 #define MAX_MESSAGE_CACHE_SIZE 5
488 
489 /* Protected by _DBUS_LOCK (message_cache) */
490 static DBusMessage *message_cache[MAX_MESSAGE_CACHE_SIZE];
491 static int message_cache_count = 0;
492 static dbus_bool_t message_cache_shutdown_registered = FALSE;
493 
494 static void
495 dbus_message_cache_shutdown (void *data)
496 {
497  int i;
498 
499  if (!_DBUS_LOCK (message_cache))
500  _dbus_assert_not_reached ("we would have initialized global locks "
501  "before registering a shutdown function");
502 
503  i = 0;
504  while (i < MAX_MESSAGE_CACHE_SIZE)
505  {
506  if (message_cache[i])
507  dbus_message_finalize (message_cache[i]);
508 
509  ++i;
510  }
511 
512  message_cache_count = 0;
513  message_cache_shutdown_registered = FALSE;
514 
515  _DBUS_UNLOCK (message_cache);
516 }
517 
525 static DBusMessage*
526 dbus_message_get_cached (void)
527 {
528  DBusMessage *message;
529  int i;
530 
531  message = NULL;
532 
533  if (!_DBUS_LOCK (message_cache))
534  {
535  /* we'd have initialized global locks before caching anything,
536  * so there can't be anything in the cache */
537  return NULL;
538  }
539 
540  _dbus_assert (message_cache_count >= 0);
541 
542  if (message_cache_count == 0)
543  {
544  _DBUS_UNLOCK (message_cache);
545  return NULL;
546  }
547 
548  /* This is not necessarily true unless count > 0, and
549  * message_cache is uninitialized until the shutdown is
550  * registered
551  */
552  _dbus_assert (message_cache_shutdown_registered);
553 
554  i = 0;
555  while (i < MAX_MESSAGE_CACHE_SIZE)
556  {
557  if (message_cache[i])
558  {
559  message = message_cache[i];
560  message_cache[i] = NULL;
561  message_cache_count -= 1;
562  break;
563  }
564  ++i;
565  }
566  _dbus_assert (message_cache_count >= 0);
568  _dbus_assert (message != NULL);
569 
570  _dbus_assert (_dbus_atomic_get (&message->refcount) == 0);
571 
572  _dbus_assert (message->counters == NULL);
573 
574  _DBUS_UNLOCK (message_cache);
575 
576  return message;
577 }
578 
579 #ifdef HAVE_UNIX_FD_PASSING
580 static void
581 close_unix_fds(int *fds, unsigned *n_fds)
582 {
583  DBusError e;
584  unsigned int i;
585 
586  if (*n_fds <= 0)
587  return;
588 
589  dbus_error_init(&e);
590 
591  for (i = 0; i < *n_fds; i++)
592  {
593  if (!_dbus_close(fds[i], &e))
594  {
595  _dbus_warn("Failed to close file descriptor: %s", e.message);
596  dbus_error_free(&e);
597  }
598  }
599 
600  *n_fds = 0;
601 
602  /* We don't free the array here, in case we can recycle it later */
603 }
604 #endif
605 
606 static void
607 free_counter (void *element,
608  void *data)
609 {
610  DBusCounter *counter = element;
611  DBusMessage *message = data;
612 
613  _dbus_counter_adjust_size (counter, - message->size_counter_delta);
614 #ifdef HAVE_UNIX_FD_PASSING
615  _dbus_counter_adjust_unix_fd (counter, - message->unix_fd_counter_delta);
616 #endif
617 
618  _dbus_counter_notify (counter);
619  _dbus_counter_unref (counter);
620 }
621 
627 static void
628 dbus_message_cache_or_finalize (DBusMessage *message)
629 {
630  dbus_bool_t was_cached;
631  int i;
632 
633  _dbus_assert (_dbus_atomic_get (&message->refcount) == 0);
634 
635  /* This calls application code and has to be done first thing
636  * without holding the lock
637  */
639 
640  _dbus_list_foreach (&message->counters,
641  free_counter, message);
642  _dbus_list_clear (&message->counters);
643 
644 #ifdef HAVE_UNIX_FD_PASSING
645  close_unix_fds(message->unix_fds, &message->n_unix_fds);
646 #endif
647 
648  was_cached = FALSE;
649 
650  if (!_DBUS_LOCK (message_cache))
651  {
652  /* The only way to get a non-null message goes through
653  * dbus_message_get_cached() which takes the lock. */
654  _dbus_assert_not_reached ("we would have initialized global locks "
655  "the first time we constructed a message");
656  }
657 
658  if (!message_cache_shutdown_registered)
659  {
660  _dbus_assert (message_cache_count == 0);
661 
662  if (!_dbus_register_shutdown_func (dbus_message_cache_shutdown, NULL))
663  goto out;
664 
665  i = 0;
666  while (i < MAX_MESSAGE_CACHE_SIZE)
667  {
668  message_cache[i] = NULL;
669  ++i;
670  }
671 
672  message_cache_shutdown_registered = TRUE;
673  }
674 
675  _dbus_assert (message_cache_count >= 0);
676 
677  if (!_dbus_enable_message_cache ())
678  goto out;
679 
680  if ((_dbus_string_get_length (&message->header.data) +
681  _dbus_string_get_length (&message->body)) >
683  goto out;
684 
685  if (message_cache_count >= MAX_MESSAGE_CACHE_SIZE)
686  goto out;
687 
688  /* Find empty slot */
689  i = 0;
690  while (message_cache[i] != NULL)
691  ++i;
692 
694 
695  _dbus_assert (message_cache[i] == NULL);
696  message_cache[i] = message;
697  message_cache_count += 1;
698  was_cached = TRUE;
699 #ifndef DBUS_DISABLE_CHECKS
700  message->in_cache = TRUE;
701 #endif
702 
703  out:
704  _dbus_assert (_dbus_atomic_get (&message->refcount) == 0);
705 
706  _DBUS_UNLOCK (message_cache);
707 
708  if (!was_cached)
709  dbus_message_finalize (message);
710 }
711 
712 /*
713  * Arrange for iter to be something that _dbus_message_iter_check() would
714  * reject as not a valid iterator.
715  */
716 static void
717 _dbus_message_real_iter_zero (DBusMessageRealIter *iter)
718 {
719  _dbus_assert (iter != NULL);
720  _DBUS_ZERO (*iter);
721  /* NULL is not, strictly speaking, guaranteed to be all-bits-zero */
722  iter->message = NULL;
723 }
724 
730 void
732 {
733  _dbus_return_if_fail (iter != NULL);
734  _dbus_message_real_iter_zero ((DBusMessageRealIter *) iter);
735 }
736 
737 static dbus_bool_t
738 _dbus_message_real_iter_is_zeroed (DBusMessageRealIter *iter)
739 {
740  return (iter != NULL && iter->message == NULL && iter->changed_stamp == 0 &&
741  iter->iter_type == 0 && iter->sig_refcount == 0);
742 }
743 
744 #if defined(DBUS_ENABLE_CHECKS) || defined(DBUS_ENABLE_ASSERT)
745 static dbus_bool_t
746 _dbus_message_iter_check (DBusMessageRealIter *iter)
747 {
748  char byte_order;
749 
750  if (iter == NULL)
751  {
752  _dbus_warn_check_failed ("dbus message iterator is NULL");
753  return FALSE;
754  }
755 
756  if (iter->message == NULL || iter->iter_type == 0)
757  {
758  _dbus_warn_check_failed ("dbus message iterator has already been "
759  "closed, or is uninitialized or corrupt");
760  return FALSE;
761  }
762 
763  byte_order = _dbus_header_get_byte_order (&iter->message->header);
764 
765  if (iter->iter_type == DBUS_MESSAGE_ITER_TYPE_READER)
766  {
767  if (iter->u.reader.byte_order != byte_order)
768  {
769  _dbus_warn_check_failed ("dbus message changed byte order since iterator was created");
770  return FALSE;
771  }
772  /* because we swap the message into compiler order when you init an iter */
773  _dbus_assert (iter->u.reader.byte_order == DBUS_COMPILER_BYTE_ORDER);
774  }
775  else if (iter->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER)
776  {
777  if (iter->u.writer.byte_order != byte_order)
778  {
779  _dbus_warn_check_failed ("dbus message changed byte order since append iterator was created");
780  return FALSE;
781  }
782  /* because we swap the message into compiler order when you init an iter */
783  _dbus_assert (iter->u.writer.byte_order == DBUS_COMPILER_BYTE_ORDER);
784  }
785  else
786  {
787  _dbus_warn_check_failed ("dbus message iterator looks uninitialized or corrupted");
788  return FALSE;
789  }
790 
791  if (iter->changed_stamp != iter->message->changed_stamp)
792  {
793  _dbus_warn_check_failed ("dbus message iterator invalid because the message has been modified (or perhaps the iterator is just uninitialized)");
794  return FALSE;
795  }
796 
797  return TRUE;
798 }
799 #endif /* DBUS_ENABLE_CHECKS || DBUS_ENABLE_ASSERT */
800 
815  DBusError *error,
816  int first_arg_type,
817  va_list var_args)
818 {
820  int spec_type, msg_type, i, j;
821  dbus_bool_t retval;
822  va_list copy_args;
823 
824  _dbus_assert (_dbus_message_iter_check (real));
825 
826  retval = FALSE;
827 
828  spec_type = first_arg_type;
829  i = 0;
830 
831  /* copy var_args first, then we can do another iteration over it to
832  * free memory and close unix fds if parse failed at some point.
833  */
834  DBUS_VA_COPY (copy_args, var_args);
835 
836  while (spec_type != DBUS_TYPE_INVALID)
837  {
838  msg_type = dbus_message_iter_get_arg_type (iter);
839 
840  if (msg_type != spec_type)
841  {
843  "Argument %d is specified to be of type \"%s\", but "
844  "is actually of type \"%s\"\n", i,
845  _dbus_type_to_string (spec_type),
846  _dbus_type_to_string (msg_type));
847 
848  goto out;
849  }
850 
851  if (spec_type == DBUS_TYPE_UNIX_FD)
852  {
853 #ifdef HAVE_UNIX_FD_PASSING
854  DBusBasicValue idx;
855  int *pfd, nfd;
856 
857  pfd = va_arg (var_args, int*);
858  _dbus_assert(pfd);
859 
860  _dbus_type_reader_read_basic(&real->u.reader, &idx);
861 
862  if (idx.u32 >= real->message->n_unix_fds)
863  {
865  "Message refers to file descriptor at index %i,"
866  "but has only %i descriptors attached.\n",
867  idx.u32,
868  real->message->n_unix_fds);
869  goto out;
870  }
871 
872  if ((nfd = _dbus_dup(real->message->unix_fds[idx.u32], error)) < 0)
873  goto out;
874 
875  *pfd = nfd;
876 #else
878  "Platform does not support file desciptor passing.\n");
879  goto out;
880 #endif
881  }
882  else if (dbus_type_is_basic (spec_type))
883  {
884  DBusBasicValue *ptr;
885 
886  ptr = va_arg (var_args, DBusBasicValue*);
887 
888  _dbus_assert (ptr != NULL);
889 
891  ptr);
892  }
893  else if (spec_type == DBUS_TYPE_ARRAY)
894  {
895  int element_type;
896  int spec_element_type;
897  const DBusBasicValue **ptr;
898  int *n_elements_p;
899  DBusTypeReader array;
900 
901  spec_element_type = va_arg (var_args, int);
902  element_type = _dbus_type_reader_get_element_type (&real->u.reader);
903 
904  if (spec_element_type != element_type)
905  {
907  "Argument %d is specified to be an array of \"%s\", but "
908  "is actually an array of \"%s\"\n",
909  i,
910  _dbus_type_to_string (spec_element_type),
911  _dbus_type_to_string (element_type));
912 
913  goto out;
914  }
915 
916  if (dbus_type_is_fixed (spec_element_type) &&
917  element_type != DBUS_TYPE_UNIX_FD)
918  {
919  ptr = va_arg (var_args, const DBusBasicValue**);
920  n_elements_p = va_arg (var_args, int*);
921 
922  _dbus_assert (ptr != NULL);
923  _dbus_assert (n_elements_p != NULL);
924 
925  _dbus_type_reader_recurse (&real->u.reader, &array);
926 
928  (void *) ptr, n_elements_p);
929  }
930  else if (_DBUS_TYPE_IS_STRINGLIKE (spec_element_type))
931  {
932  char ***str_array_p;
933  int n_elements;
934  char **str_array;
935 
936  str_array_p = va_arg (var_args, char***);
937  n_elements_p = va_arg (var_args, int*);
938 
939  _dbus_assert (str_array_p != NULL);
940  _dbus_assert (n_elements_p != NULL);
941 
942  /* Count elements in the array */
943  _dbus_type_reader_recurse (&real->u.reader, &array);
944 
945  n_elements = 0;
947  {
948  ++n_elements;
949  _dbus_type_reader_next (&array);
950  }
951 
952  str_array = dbus_new0 (char*, n_elements + 1);
953  if (str_array == NULL)
954  {
955  _DBUS_SET_OOM (error);
956  goto out;
957  }
958 
959  /* Now go through and dup each string */
960  _dbus_type_reader_recurse (&real->u.reader, &array);
961 
962  j = 0;
963  while (j < n_elements)
964  {
965  const char *s;
967  (void *) &s);
968 
969  str_array[j] = _dbus_strdup (s);
970  if (str_array[j] == NULL)
971  {
972  dbus_free_string_array (str_array);
973  _DBUS_SET_OOM (error);
974  goto out;
975  }
976 
977  ++j;
978 
979  if (!_dbus_type_reader_next (&array))
980  _dbus_assert (j == n_elements);
981  }
982 
984  _dbus_assert (j == n_elements);
985  _dbus_assert (str_array[j] == NULL);
986 
987  *str_array_p = str_array;
988  *n_elements_p = n_elements;
989  }
990 #ifndef DBUS_DISABLE_CHECKS
991  else
992  {
993  _dbus_warn ("you can't read arrays of container types (struct, variant, array) with %s for now",
994  _DBUS_FUNCTION_NAME);
995  goto out;
996  }
997 #endif
998  }
999 #ifndef DBUS_DISABLE_CHECKS
1000  else
1001  {
1002  _dbus_warn ("you can only read arrays and basic types with %s for now",
1003  _DBUS_FUNCTION_NAME);
1004  goto out;
1005  }
1006 #endif
1007 
1008  /* how many arguments already handled */
1009  i++;
1010 
1011  spec_type = va_arg (var_args, int);
1012  if (!_dbus_type_reader_next (&real->u.reader) && spec_type != DBUS_TYPE_INVALID)
1013  {
1015  "Message has only %d arguments, but more were expected", i);
1016  goto out;
1017  }
1018  }
1019 
1020  retval = TRUE;
1021 
1022  out:
1023  /* there may memory or unix fd leak in the above iteration if parse failed.
1024  * so we have another iteration over copy_args to free memory and close
1025  * unix fds.
1026  */
1027  if (!retval)
1028  {
1029  spec_type = first_arg_type;
1030  j = 0;
1031 
1032  while (j < i)
1033  {
1034  if (spec_type == DBUS_TYPE_UNIX_FD)
1035  {
1036 #ifdef HAVE_UNIX_FD_PASSING
1037  int *pfd;
1038 
1039  pfd = va_arg (copy_args, int *);
1040  _dbus_assert(pfd);
1041  if (*pfd >= 0)
1042  {
1043  _dbus_close (*pfd, NULL);
1044  *pfd = -1;
1045  }
1046 #endif
1047  }
1048  else if (dbus_type_is_basic (spec_type))
1049  {
1050  /* move the index forward */
1051  va_arg (copy_args, DBusBasicValue *);
1052  }
1053  else if (spec_type == DBUS_TYPE_ARRAY)
1054  {
1055  int spec_element_type;
1056 
1057  spec_element_type = va_arg (copy_args, int);
1058  if (dbus_type_is_fixed (spec_element_type))
1059  {
1060  /* move the index forward */
1061  va_arg (copy_args, const DBusBasicValue **);
1062  va_arg (copy_args, int *);
1063  }
1064  else if (_DBUS_TYPE_IS_STRINGLIKE (spec_element_type))
1065  {
1066  char ***str_array_p;
1067 
1068  str_array_p = va_arg (copy_args, char ***);
1069  /* move the index forward */
1070  va_arg (copy_args, int *);
1071  _dbus_assert (str_array_p != NULL);
1072  dbus_free_string_array (*str_array_p);
1073  *str_array_p = NULL;
1074  }
1075  }
1076 
1077  spec_type = va_arg (copy_args, int);
1078  j++;
1079  }
1080  }
1081 
1082  va_end (copy_args);
1083  return retval;
1084 }
1085 
1144 dbus_uint32_t
1146 {
1147  _dbus_return_val_if_fail (message != NULL, 0);
1148 
1149  return _dbus_header_get_serial (&message->header);
1150 }
1151 
1162  dbus_uint32_t reply_serial)
1163 {
1164  DBusBasicValue value;
1165 
1166  _dbus_return_val_if_fail (message != NULL, FALSE);
1167  _dbus_return_val_if_fail (!message->locked, FALSE);
1168  _dbus_return_val_if_fail (reply_serial != 0, FALSE); /* 0 is invalid */
1169 
1170  value.u32 = reply_serial;
1171 
1172  return _dbus_header_set_field_basic (&message->header,
1175  &value);
1176 }
1177 
1184 dbus_uint32_t
1186 {
1187  dbus_uint32_t v_UINT32;
1188 
1189  _dbus_return_val_if_fail (message != NULL, 0);
1190 
1191  if (_dbus_header_get_field_basic (&message->header,
1194  &v_UINT32))
1195  return v_UINT32;
1196  else
1197  return 0;
1198 }
1199 
1200 static void
1201 dbus_message_finalize (DBusMessage *message)
1202 {
1203  _dbus_assert (_dbus_atomic_get (&message->refcount) == 0);
1204 
1205  /* This calls application callbacks! */
1207 
1208  _dbus_list_foreach (&message->counters,
1209  free_counter, message);
1210  _dbus_list_clear (&message->counters);
1211 
1212  _dbus_header_free (&message->header);
1213  _dbus_string_free (&message->body);
1214 
1215 #ifdef HAVE_UNIX_FD_PASSING
1216  close_unix_fds(message->unix_fds, &message->n_unix_fds);
1217  dbus_free(message->unix_fds);
1218 #endif
1219 
1220  _dbus_assert (_dbus_atomic_get (&message->refcount) == 0);
1221 
1222  dbus_free (message);
1223 }
1224 
1225 static DBusMessage*
1226 dbus_message_new_empty_header (void)
1227 {
1228  DBusMessage *message;
1229  dbus_bool_t from_cache;
1230 
1231  message = dbus_message_get_cached ();
1232 
1233  if (message != NULL)
1234  {
1235  from_cache = TRUE;
1236  }
1237  else
1238  {
1239  from_cache = FALSE;
1240  message = dbus_new0 (DBusMessage, 1);
1241  if (message == NULL)
1242  return NULL;
1243 #ifndef DBUS_DISABLE_CHECKS
1245 #endif
1246 
1247 #ifdef HAVE_UNIX_FD_PASSING
1248  message->unix_fds = NULL;
1249  message->n_unix_fds_allocated = 0;
1250 #endif
1251  }
1252 
1253  _dbus_atomic_inc (&message->refcount);
1254 
1255  _dbus_message_trace_ref (message, 0, 1, "new_empty_header");
1256 
1257  message->locked = FALSE;
1258 #ifndef DBUS_DISABLE_CHECKS
1259  message->in_cache = FALSE;
1260 #endif
1261  message->counters = NULL;
1262  message->size_counter_delta = 0;
1263  message->changed_stamp = 0;
1264 
1265 #ifdef HAVE_UNIX_FD_PASSING
1266  message->n_unix_fds = 0;
1267  message->n_unix_fds_allocated = 0;
1268  message->unix_fd_counter_delta = 0;
1269 #endif
1270 
1271  if (!from_cache)
1273 
1274  if (from_cache)
1275  {
1276  _dbus_header_reinit (&message->header);
1277  _dbus_string_set_length (&message->body, 0);
1278  }
1279  else
1280  {
1281  if (!_dbus_header_init (&message->header))
1282  {
1283  dbus_free (message);
1284  return NULL;
1285  }
1286 
1287  if (!_dbus_string_init_preallocated (&message->body, 32))
1288  {
1289  _dbus_header_free (&message->header);
1290  dbus_free (message);
1291  return NULL;
1292  }
1293  }
1294 
1295  return message;
1296 }
1297 
1310 DBusMessage*
1311 dbus_message_new (int message_type)
1312 {
1313  DBusMessage *message;
1314 
1315  _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL);
1316 
1317  message = dbus_message_new_empty_header ();
1318  if (message == NULL)
1319  return NULL;
1320 
1321  if (!_dbus_header_create (&message->header,
1322  DBUS_COMPILER_BYTE_ORDER,
1323  message_type,
1324  NULL, NULL, NULL, NULL, NULL))
1325  {
1326  dbus_message_unref (message);
1327  return NULL;
1328  }
1329 
1330  return message;
1331 }
1332 
1354 DBusMessage*
1355 dbus_message_new_method_call (const char *destination,
1356  const char *path,
1357  const char *iface,
1358  const char *method)
1359 {
1360  DBusMessage *message;
1361 
1362  _dbus_return_val_if_fail (path != NULL, NULL);
1363  _dbus_return_val_if_fail (method != NULL, NULL);
1364  _dbus_return_val_if_fail (destination == NULL ||
1365  _dbus_check_is_valid_bus_name (destination), NULL);
1366  _dbus_return_val_if_fail (_dbus_check_is_valid_path (path), NULL);
1367  _dbus_return_val_if_fail (iface == NULL ||
1368  _dbus_check_is_valid_interface (iface), NULL);
1369  _dbus_return_val_if_fail (_dbus_check_is_valid_member (method), NULL);
1370 
1371  message = dbus_message_new_empty_header ();
1372  if (message == NULL)
1373  return NULL;
1374 
1375  if (!_dbus_header_create (&message->header,
1376  DBUS_COMPILER_BYTE_ORDER,
1378  destination, path, iface, method, NULL))
1379  {
1380  dbus_message_unref (message);
1381  return NULL;
1382  }
1383 
1384  return message;
1385 }
1386 
1394 DBusMessage*
1396 {
1397  DBusMessage *message;
1398  const char *sender;
1399 
1400  _dbus_return_val_if_fail (method_call != NULL, NULL);
1401 
1402  sender = dbus_message_get_sender (method_call);
1403 
1404  /* sender is allowed to be null here in peer-to-peer case */
1405 
1406  message = dbus_message_new_empty_header ();
1407  if (message == NULL)
1408  return NULL;
1409 
1410  if (!_dbus_header_create (&message->header,
1411  DBUS_COMPILER_BYTE_ORDER,
1413  sender, NULL, NULL, NULL, NULL))
1414  {
1415  dbus_message_unref (message);
1416  return NULL;
1417  }
1418 
1419  dbus_message_set_no_reply (message, TRUE);
1420 
1421  if (!dbus_message_set_reply_serial (message,
1422  dbus_message_get_serial (method_call)))
1423  {
1424  dbus_message_unref (message);
1425  return NULL;
1426  }
1427 
1428  return message;
1429 }
1430 
1445 DBusMessage*
1446 dbus_message_new_signal (const char *path,
1447  const char *iface,
1448  const char *name)
1449 {
1450  DBusMessage *message;
1451 
1452  _dbus_return_val_if_fail (path != NULL, NULL);
1453  _dbus_return_val_if_fail (iface != NULL, NULL);
1454  _dbus_return_val_if_fail (name != NULL, NULL);
1455  _dbus_return_val_if_fail (_dbus_check_is_valid_path (path), NULL);
1456  _dbus_return_val_if_fail (_dbus_check_is_valid_interface (iface), NULL);
1457  _dbus_return_val_if_fail (_dbus_check_is_valid_member (name), NULL);
1458 
1459  message = dbus_message_new_empty_header ();
1460  if (message == NULL)
1461  return NULL;
1462 
1463  if (!_dbus_header_create (&message->header,
1464  DBUS_COMPILER_BYTE_ORDER,
1466  NULL, path, iface, name, NULL))
1467  {
1468  dbus_message_unref (message);
1469  return NULL;
1470  }
1471 
1472  dbus_message_set_no_reply (message, TRUE);
1473 
1474  return message;
1475 }
1476 
1491 DBusMessage*
1493  const char *error_name,
1494  const char *error_message)
1495 {
1496  DBusMessage *message;
1497  const char *sender;
1498  DBusMessageIter iter;
1499 
1500  _dbus_return_val_if_fail (reply_to != NULL, NULL);
1501  _dbus_return_val_if_fail (error_name != NULL, NULL);
1502  _dbus_return_val_if_fail (_dbus_check_is_valid_error_name (error_name), NULL);
1503 
1504  sender = dbus_message_get_sender (reply_to);
1505 
1506  /* sender may be NULL for non-message-bus case or
1507  * when the message bus is dealing with an unregistered
1508  * connection.
1509  */
1510  message = dbus_message_new_empty_header ();
1511  if (message == NULL)
1512  return NULL;
1513 
1514  if (!_dbus_header_create (&message->header,
1515  DBUS_COMPILER_BYTE_ORDER,
1517  sender, NULL, NULL, NULL, error_name))
1518  {
1519  dbus_message_unref (message);
1520  return NULL;
1521  }
1522 
1523  dbus_message_set_no_reply (message, TRUE);
1524 
1525  if (!dbus_message_set_reply_serial (message,
1526  dbus_message_get_serial (reply_to)))
1527  {
1528  dbus_message_unref (message);
1529  return NULL;
1530  }
1531 
1532  if (error_message != NULL)
1533  {
1534  dbus_message_iter_init_append (message, &iter);
1535  if (!dbus_message_iter_append_basic (&iter,
1537  &error_message))
1538  {
1539  dbus_message_unref (message);
1540  return NULL;
1541  }
1542  }
1543 
1544  return message;
1545 }
1546 
1563 DBusMessage*
1565  const char *error_name,
1566  const char *error_format,
1567  ...)
1568 {
1569  va_list args;
1570  DBusString str;
1571  DBusMessage *message;
1572 
1573  _dbus_return_val_if_fail (reply_to != NULL, NULL);
1574  _dbus_return_val_if_fail (error_name != NULL, NULL);
1575  _dbus_return_val_if_fail (_dbus_check_is_valid_error_name (error_name), NULL);
1576 
1577  if (!_dbus_string_init (&str))
1578  return NULL;
1579 
1580  va_start (args, error_format);
1581 
1582  if (_dbus_string_append_printf_valist (&str, error_format, args))
1583  message = dbus_message_new_error (reply_to, error_name,
1584  _dbus_string_get_const_data (&str));
1585  else
1586  message = NULL;
1587 
1588  _dbus_string_free (&str);
1589 
1590  va_end (args);
1591 
1592  return message;
1593 }
1594 
1595 
1608 DBusMessage *
1610 {
1611  DBusMessage *retval;
1612 
1613  _dbus_return_val_if_fail (message != NULL, NULL);
1614 
1615  retval = dbus_new0 (DBusMessage, 1);
1616  if (retval == NULL)
1617  return NULL;
1618 
1619  _dbus_atomic_inc (&retval->refcount);
1620 
1621  retval->locked = FALSE;
1622 #ifndef DBUS_DISABLE_CHECKS
1623  retval->generation = message->generation;
1624 #endif
1625 
1626  if (!_dbus_header_copy (&message->header, &retval->header))
1627  {
1628  dbus_free (retval);
1629  return NULL;
1630  }
1631 
1632  if (!_dbus_string_init_preallocated (&retval->body,
1633  _dbus_string_get_length (&message->body)))
1634  {
1635  _dbus_header_free (&retval->header);
1636  dbus_free (retval);
1637  return NULL;
1638  }
1639 
1640  if (!_dbus_string_copy (&message->body, 0,
1641  &retval->body, 0))
1642  goto failed_copy;
1643 
1644 #ifdef HAVE_UNIX_FD_PASSING
1645  retval->unix_fds = dbus_new(int, message->n_unix_fds);
1646  if (retval->unix_fds == NULL && message->n_unix_fds > 0)
1647  goto failed_copy;
1648 
1649  retval->n_unix_fds_allocated = message->n_unix_fds;
1650 
1651  for (retval->n_unix_fds = 0;
1652  retval->n_unix_fds < message->n_unix_fds;
1653  retval->n_unix_fds++)
1654  {
1655  retval->unix_fds[retval->n_unix_fds] = _dbus_dup(message->unix_fds[retval->n_unix_fds], NULL);
1656 
1657  if (retval->unix_fds[retval->n_unix_fds] < 0)
1658  goto failed_copy;
1659  }
1660 
1661 #endif
1662 
1663  _dbus_message_trace_ref (retval, 0, 1, "copy");
1664  return retval;
1665 
1666  failed_copy:
1667  _dbus_header_free (&retval->header);
1668  _dbus_string_free (&retval->body);
1669 
1670 #ifdef HAVE_UNIX_FD_PASSING
1671  close_unix_fds(retval->unix_fds, &retval->n_unix_fds);
1672  dbus_free(retval->unix_fds);
1673 #endif
1674 
1675  dbus_free (retval);
1676 
1677  return NULL;
1678 }
1679 
1680 
1688 DBusMessage *
1690 {
1691  dbus_int32_t old_refcount;
1692 
1693  _dbus_return_val_if_fail (message != NULL, NULL);
1694  _dbus_return_val_if_fail (message->generation == _dbus_current_generation, NULL);
1695  _dbus_return_val_if_fail (!message->in_cache, NULL);
1696 
1697  old_refcount = _dbus_atomic_inc (&message->refcount);
1698  _dbus_assert (old_refcount >= 1);
1699  _dbus_message_trace_ref (message, old_refcount, old_refcount + 1, "ref");
1700 
1701  return message;
1702 }
1703 
1711 void
1713 {
1714  dbus_int32_t old_refcount;
1715 
1716  _dbus_return_if_fail (message != NULL);
1717  _dbus_return_if_fail (message->generation == _dbus_current_generation);
1718  _dbus_return_if_fail (!message->in_cache);
1719 
1720  old_refcount = _dbus_atomic_dec (&message->refcount);
1721 
1722  _dbus_assert (old_refcount >= 1);
1723 
1724  _dbus_message_trace_ref (message, old_refcount, old_refcount - 1, "unref");
1725 
1726  if (old_refcount == 1)
1727  {
1728  /* Calls application callbacks! */
1729  dbus_message_cache_or_finalize (message);
1730  }
1731 }
1732 
1743 int
1745 {
1746  _dbus_return_val_if_fail (message != NULL, DBUS_MESSAGE_TYPE_INVALID);
1747 
1748  return _dbus_header_get_message_type (&message->header);
1749 }
1750 
1821  int first_arg_type,
1822  ...)
1823 {
1824  dbus_bool_t retval;
1825  va_list var_args;
1826 
1827  _dbus_return_val_if_fail (message != NULL, FALSE);
1828 
1829  va_start (var_args, first_arg_type);
1830  retval = dbus_message_append_args_valist (message,
1831  first_arg_type,
1832  var_args);
1833  va_end (var_args);
1834 
1835  return retval;
1836 }
1837 
1853  int first_arg_type,
1854  va_list var_args)
1855 {
1856  int type;
1857  DBusMessageIter iter;
1858 
1859  _dbus_return_val_if_fail (message != NULL, FALSE);
1860 
1861  type = first_arg_type;
1862 
1863  dbus_message_iter_init_append (message, &iter);
1864 
1865  while (type != DBUS_TYPE_INVALID)
1866  {
1867  if (dbus_type_is_basic (type))
1868  {
1869  const DBusBasicValue *value;
1870  value = va_arg (var_args, const DBusBasicValue*);
1871 
1872  if (!dbus_message_iter_append_basic (&iter,
1873  type,
1874  value))
1875  goto failed;
1876  }
1877  else if (type == DBUS_TYPE_ARRAY)
1878  {
1879  int element_type;
1880  DBusMessageIter array;
1881  char buf[2];
1882 
1883  element_type = va_arg (var_args, int);
1884 
1885  buf[0] = element_type;
1886  buf[1] = '\0';
1889  buf,
1890  &array))
1891  goto failed;
1892 
1893  if (dbus_type_is_fixed (element_type) &&
1894  element_type != DBUS_TYPE_UNIX_FD)
1895  {
1896  const DBusBasicValue **value;
1897  int n_elements;
1898 
1899  value = va_arg (var_args, const DBusBasicValue**);
1900  n_elements = va_arg (var_args, int);
1901 
1903  element_type,
1904  value,
1905  n_elements)) {
1906  dbus_message_iter_abandon_container (&iter, &array);
1907  goto failed;
1908  }
1909  }
1910  else if (_DBUS_TYPE_IS_STRINGLIKE (element_type))
1911  {
1912  const char ***value_p;
1913  const char **value;
1914  int n_elements;
1915  int i;
1916 
1917  value_p = va_arg (var_args, const char***);
1918  n_elements = va_arg (var_args, int);
1919 
1920  value = *value_p;
1921 
1922  i = 0;
1923  while (i < n_elements)
1924  {
1925  if (!dbus_message_iter_append_basic (&array,
1926  element_type,
1927  &value[i])) {
1928  dbus_message_iter_abandon_container (&iter, &array);
1929  goto failed;
1930  }
1931  ++i;
1932  }
1933  }
1934  else
1935  {
1936  _dbus_warn ("arrays of %s can't be appended with %s for now",
1937  _dbus_type_to_string (element_type),
1938  _DBUS_FUNCTION_NAME);
1939  dbus_message_iter_abandon_container (&iter, &array);
1940  goto failed;
1941  }
1942 
1943  if (!dbus_message_iter_close_container (&iter, &array))
1944  goto failed;
1945  }
1946 #ifndef DBUS_DISABLE_CHECKS
1947  else
1948  {
1949  _dbus_warn ("type %s isn't supported yet in %s",
1950  _dbus_type_to_string (type), _DBUS_FUNCTION_NAME);
1951  goto failed;
1952  }
1953 #endif
1954 
1955  type = va_arg (var_args, int);
1956  }
1957 
1958  return TRUE;
1959 
1960  failed:
1961  return FALSE;
1962 }
1963 
2010  DBusError *error,
2011  int first_arg_type,
2012  ...)
2013 {
2014  dbus_bool_t retval;
2015  va_list var_args;
2016 
2017  _dbus_return_val_if_fail (message != NULL, FALSE);
2018  _dbus_return_val_if_error_is_set (error, FALSE);
2019 
2020  va_start (var_args, first_arg_type);
2021  retval = dbus_message_get_args_valist (message, error, first_arg_type, var_args);
2022  va_end (var_args);
2023 
2024  return retval;
2025 }
2026 
2039  DBusError *error,
2040  int first_arg_type,
2041  va_list var_args)
2042 {
2043  DBusMessageIter iter;
2044 
2045  _dbus_return_val_if_fail (message != NULL, FALSE);
2046  _dbus_return_val_if_error_is_set (error, FALSE);
2047 
2048  dbus_message_iter_init (message, &iter);
2049  return _dbus_message_iter_get_args_valist (&iter, error, first_arg_type, var_args);
2050 }
2051 
2052 static void
2053 _dbus_message_iter_init_common (DBusMessage *message,
2054  DBusMessageRealIter *real,
2055  int iter_type)
2056 {
2057  /* If these static assertions fail on your platform, report it as a bug. */
2058  _DBUS_STATIC_ASSERT (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter));
2059  _DBUS_STATIC_ASSERT (_DBUS_ALIGNOF (DBusMessageRealIter) <=
2060  _DBUS_ALIGNOF (DBusMessageIter));
2061  /* A failure of these two assertions would indicate that we've broken
2062  * ABI on this platform since 1.10.0. */
2063  _DBUS_STATIC_ASSERT (sizeof (DBusMessageIter_1_10_0) ==
2064  sizeof (DBusMessageIter));
2065  _DBUS_STATIC_ASSERT (_DBUS_ALIGNOF (DBusMessageIter_1_10_0) ==
2066  _DBUS_ALIGNOF (DBusMessageIter));
2067  /* If this static assertion fails, it means the DBusMessageIter struct
2068  * is not "packed", which might result in "iter = other_iter" not copying
2069  * every byte. */
2070  _DBUS_STATIC_ASSERT (sizeof (DBusMessageIter) ==
2071  4 * sizeof (void *) + sizeof (dbus_uint32_t) + 9 * sizeof (int));
2072 
2073  /* Since the iterator will read or write who-knows-what from the
2074  * message, we need to get in the right byte order
2075  */
2076  ensure_byte_order (message);
2077 
2078  real->message = message;
2079  real->changed_stamp = message->changed_stamp;
2080  real->iter_type = iter_type;
2081  real->sig_refcount = 0;
2082 }
2083 
2108  DBusMessageIter *iter)
2109 {
2110  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2111  const DBusString *type_str;
2112  int type_pos;
2113 
2114  _dbus_return_val_if_fail (message != NULL, FALSE);
2115  _dbus_return_val_if_fail (iter != NULL, FALSE);
2116 
2117  get_const_signature (&message->header, &type_str, &type_pos);
2118 
2119  _dbus_message_iter_init_common (message, real,
2120  DBUS_MESSAGE_ITER_TYPE_READER);
2121 
2123  _dbus_header_get_byte_order (&message->header),
2124  type_str, type_pos,
2125  &message->body,
2126  0);
2127 
2129 }
2130 
2139 {
2140  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2141 
2142  _dbus_return_val_if_fail (_dbus_message_iter_check (real), FALSE);
2143  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2144 
2145  return _dbus_type_reader_has_next (&real->u.reader);
2146 }
2147 
2158 {
2159  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2160 
2161  _dbus_return_val_if_fail (_dbus_message_iter_check (real), FALSE);
2162  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2163 
2164  return _dbus_type_reader_next (&real->u.reader);
2165 }
2166 
2181 int
2183 {
2184  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2185 
2186  _dbus_return_val_if_fail (_dbus_message_iter_check (real), DBUS_TYPE_INVALID);
2187  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2188 
2190 }
2191 
2200 int
2202 {
2203  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2204 
2205  _dbus_return_val_if_fail (_dbus_message_iter_check (real), DBUS_TYPE_INVALID);
2206  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, DBUS_TYPE_INVALID);
2207  _dbus_return_val_if_fail (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
2208 
2210 }
2211 
2237 void
2239  DBusMessageIter *sub)
2240 {
2241  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2242  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
2243 
2244  _dbus_return_if_fail (_dbus_message_iter_check (real));
2245  _dbus_return_if_fail (sub != NULL);
2246 
2247  *real_sub = *real;
2248  _dbus_type_reader_recurse (&real->u.reader, &real_sub->u.reader);
2249 }
2250 
2262 char *
2264 {
2265  const DBusString *sig;
2266  DBusString retstr;
2267  char *ret;
2268  int start, len;
2269  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2270 
2271  _dbus_return_val_if_fail (_dbus_message_iter_check (real), NULL);
2272 
2273  if (!_dbus_string_init (&retstr))
2274  return NULL;
2275 
2277  &start, &len);
2278  if (!_dbus_string_append_len (&retstr,
2279  _dbus_string_get_const_data (sig) + start,
2280  len))
2281  return NULL;
2282  if (!_dbus_string_steal_data (&retstr, &ret))
2283  return NULL;
2284  _dbus_string_free (&retstr);
2285  return ret;
2286 }
2287 
2335 void
2337  void *value)
2338 {
2339  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2340 
2341  _dbus_return_if_fail (_dbus_message_iter_check (real));
2342  _dbus_return_if_fail (value != NULL);
2343 
2345  {
2346 #ifdef HAVE_UNIX_FD_PASSING
2347  DBusBasicValue idx;
2348 
2349  _dbus_type_reader_read_basic(&real->u.reader, &idx);
2350 
2351  if (idx.u32 >= real->message->n_unix_fds) {
2352  /* Hmm, we cannot really signal an error here, so let's make
2353  sure to return an invalid fd. */
2354  *((int*) value) = -1;
2355  return;
2356  }
2357 
2358  *((int*) value) = _dbus_dup(real->message->unix_fds[idx.u32], NULL);
2359 #else
2360  *((int*) value) = -1;
2361 #endif
2362  }
2363  else
2364  {
2366  value);
2367  }
2368 }
2369 
2380 int
2382 {
2383  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2384  DBusTypeReader array;
2385  int element_type;
2386  int n_elements = 0;
2387 
2388  _dbus_return_val_if_fail (_dbus_message_iter_check (real), 0);
2389  _dbus_return_val_if_fail (_dbus_type_reader_get_current_type (&real->u.reader)
2390  == DBUS_TYPE_ARRAY, 0);
2391 
2392  element_type = _dbus_type_reader_get_element_type (&real->u.reader);
2393  _dbus_type_reader_recurse (&real->u.reader, &array);
2394  if (dbus_type_is_fixed (element_type))
2395  {
2396  int alignment = _dbus_type_get_alignment (element_type);
2397  int total_len = _dbus_type_reader_get_array_length (&array);
2398  n_elements = total_len / alignment;
2399  }
2400  else
2401  {
2403  {
2404  ++n_elements;
2405  _dbus_type_reader_next (&array);
2406  }
2407  }
2408 
2409  return n_elements;
2410 }
2411 
2424 int
2426 {
2427  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2428 
2429  _dbus_return_val_if_fail (_dbus_message_iter_check (real), 0);
2430 
2432 }
2433 
2469 void
2471  void *value,
2472  int *n_elements)
2473 {
2474  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2475 #ifndef DBUS_DISABLE_CHECKS
2476  int subtype = _dbus_type_reader_get_current_type(&real->u.reader);
2477 
2478  _dbus_return_if_fail (_dbus_message_iter_check (real));
2479  _dbus_return_if_fail (value != NULL);
2480  _dbus_return_if_fail ((subtype == DBUS_TYPE_INVALID) ||
2481  (dbus_type_is_fixed (subtype) && subtype != DBUS_TYPE_UNIX_FD));
2482 #endif
2483 
2485  value, n_elements);
2486 }
2487 
2499 void
2501  DBusMessageIter *iter)
2502 {
2503  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2504 
2505  _dbus_return_if_fail (message != NULL);
2506  _dbus_return_if_fail (iter != NULL);
2507 
2508  _dbus_message_iter_init_common (message, real,
2509  DBUS_MESSAGE_ITER_TYPE_WRITER);
2510 
2511  /* We create the signature string and point iterators at it "on demand"
2512  * when a value is actually appended. That means that init() never fails
2513  * due to OOM.
2514  */
2516  _dbus_header_get_byte_order (&message->header),
2517  &message->body,
2518  _dbus_string_get_length (&message->body));
2519 }
2520 
2529 static dbus_bool_t
2530 _dbus_message_iter_open_signature (DBusMessageRealIter *real)
2531 {
2532  DBusString *str;
2533  const DBusString *current_sig;
2534  int current_sig_pos;
2535 
2536  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2537 
2538  if (real->u.writer.type_str != NULL)
2539  {
2540  _dbus_assert (real->sig_refcount > 0);
2541  real->sig_refcount += 1;
2542  return TRUE;
2543  }
2544 
2545  str = dbus_new (DBusString, 1);
2546  if (str == NULL)
2547  return FALSE;
2548 
2551  &current_sig, &current_sig_pos))
2552  current_sig = NULL;
2553 
2554  if (current_sig)
2555  {
2556  int current_len;
2557 
2558  current_len = _dbus_string_get_byte (current_sig, current_sig_pos);
2559  current_sig_pos += 1; /* move on to sig data */
2560 
2561  if (!_dbus_string_init_preallocated (str, current_len + 4))
2562  {
2563  dbus_free (str);
2564  return FALSE;
2565  }
2566 
2567  if (!_dbus_string_copy_len (current_sig, current_sig_pos, current_len,
2568  str, 0))
2569  {
2570  _dbus_string_free (str);
2571  dbus_free (str);
2572  return FALSE;
2573  }
2574  }
2575  else
2576  {
2577  if (!_dbus_string_init_preallocated (str, 4))
2578  {
2579  dbus_free (str);
2580  return FALSE;
2581  }
2582  }
2583 
2584  real->sig_refcount = 1;
2585 
2586  /* If this assertion failed, then str would be neither stored in u.writer
2587  * nor freed by this function, resulting in a memory leak. */
2588  _dbus_assert (real->u.writer.type_str == NULL);
2590  str, _dbus_string_get_length (str));
2591  return TRUE;
2592 }
2593 
2603 static dbus_bool_t
2604 _dbus_message_iter_close_signature (DBusMessageRealIter *real)
2605 {
2606  DBusString *str;
2607  const char *v_STRING;
2608  dbus_bool_t retval;
2609 
2610  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2611  _dbus_assert (real->u.writer.type_str != NULL);
2612  _dbus_assert (real->sig_refcount > 0);
2613 
2614  real->sig_refcount -= 1;
2615 
2616  if (real->sig_refcount > 0)
2617  return TRUE;
2618  _dbus_assert (real->sig_refcount == 0);
2619 
2620  retval = TRUE;
2621 
2622  str = real->u.writer.type_str;
2623 
2624  v_STRING = _dbus_string_get_const_data (str);
2628  &v_STRING))
2629  retval = FALSE;
2630 
2632  _dbus_string_free (str);
2633  dbus_free (str);
2634 
2635  return retval;
2636 }
2637 
2645 static void
2646 _dbus_message_iter_abandon_signature (DBusMessageRealIter *real)
2647 {
2648  DBusString *str;
2649 
2650  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2651  _dbus_assert (real->u.writer.type_str != NULL);
2652  _dbus_assert (real->sig_refcount > 0);
2653 
2654  real->sig_refcount -= 1;
2655 
2656  if (real->sig_refcount > 0)
2657  return;
2658  _dbus_assert (real->sig_refcount == 0);
2659 
2660  str = real->u.writer.type_str;
2661 
2663  _dbus_string_free (str);
2664  dbus_free (str);
2665 }
2666 
2667 #ifndef DBUS_DISABLE_CHECKS
2668 static dbus_bool_t
2669 _dbus_message_iter_append_check (DBusMessageRealIter *iter)
2670 {
2671  if (!_dbus_message_iter_check (iter))
2672  return FALSE;
2673 
2674  if (iter->message->locked)
2675  {
2676  _dbus_warn_check_failed ("dbus append iterator can't be used: message is locked (has already been sent)");
2677  return FALSE;
2678  }
2679 
2680  return TRUE;
2681 }
2682 #endif /* DBUS_DISABLE_CHECKS */
2683 
2684 #ifdef HAVE_UNIX_FD_PASSING
2685 static int *
2686 expand_fd_array(DBusMessage *m,
2687  unsigned n)
2688 {
2689  _dbus_assert(m);
2690 
2691  /* This makes space for adding n new fds to the array and returns a
2692  pointer to the place were the first fd should be put. */
2693 
2694  if (m->n_unix_fds + n > m->n_unix_fds_allocated)
2695  {
2696  unsigned k;
2697  int *p;
2698 
2699  /* Make twice as much space as necessary */
2700  k = (m->n_unix_fds + n) * 2;
2701 
2702  /* Allocate at least four */
2703  if (k < 4)
2704  k = 4;
2705 
2706  p = dbus_realloc(m->unix_fds, k * sizeof(int));
2707  if (p == NULL)
2708  return NULL;
2709 
2710  m->unix_fds = p;
2711  m->n_unix_fds_allocated = k;
2712  }
2713 
2714  return m->unix_fds + m->n_unix_fds;
2715 }
2716 #endif
2717 
2739  int type,
2740  const void *value)
2741 {
2742  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2743  dbus_bool_t ret;
2744 
2745  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2746  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2747  _dbus_return_val_if_fail (dbus_type_is_basic (type), FALSE);
2748  _dbus_return_val_if_fail (value != NULL, FALSE);
2749 
2750 #ifndef DBUS_DISABLE_CHECKS
2751  switch (type)
2752  {
2753  DBusString str;
2754  DBusValidity signature_validity;
2755  const char * const *string_p;
2756  const dbus_bool_t *bool_p;
2757 
2758  case DBUS_TYPE_STRING:
2759  string_p = value;
2760  _dbus_return_val_if_fail (_dbus_check_is_valid_utf8 (*string_p), FALSE);
2761  break;
2762 
2763  case DBUS_TYPE_OBJECT_PATH:
2764  string_p = value;
2765  _dbus_return_val_if_fail (_dbus_check_is_valid_path (*string_p), FALSE);
2766  break;
2767 
2768  case DBUS_TYPE_SIGNATURE:
2769  string_p = value;
2770  _dbus_string_init_const (&str, *string_p);
2771  signature_validity = _dbus_validate_signature_with_reason (&str,
2772  0,
2773  _dbus_string_get_length (&str));
2774 
2775  if (signature_validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
2776  return FALSE;
2777 
2778  _dbus_return_val_if_fail (signature_validity == DBUS_VALID, FALSE);
2779  break;
2780 
2781  case DBUS_TYPE_BOOLEAN:
2782  bool_p = value;
2783  _dbus_return_val_if_fail (*bool_p == 0 || *bool_p == 1, FALSE);
2784  break;
2785 
2786  default:
2787  {
2788  /* nothing to check, all possible values are allowed */
2789  }
2790  }
2791 #endif
2792 
2793  if (!_dbus_message_iter_open_signature (real))
2794  return FALSE;
2795 
2796  if (type == DBUS_TYPE_UNIX_FD)
2797  {
2798 #ifdef HAVE_UNIX_FD_PASSING
2799  int *fds;
2800  dbus_uint32_t u;
2801 
2802  ret = FALSE;
2803 
2804  /* First step, include the fd in the fd list of this message */
2805  if (!(fds = expand_fd_array(real->message, 1)))
2806  goto out;
2807 
2808  *fds = _dbus_dup(*(int*) value, NULL);
2809  if (*fds < 0)
2810  goto out;
2811 
2812  u = real->message->n_unix_fds;
2813 
2814  /* Second step, write the index to the fd */
2815  if (!(ret = _dbus_type_writer_write_basic (&real->u.writer, DBUS_TYPE_UNIX_FD, &u))) {
2816  _dbus_close(*fds, NULL);
2817  goto out;
2818  }
2819 
2820  real->message->n_unix_fds += 1;
2821  u += 1;
2822 
2823  /* Final step, update the header accordingly */
2827  &u);
2828 
2829  /* If any of these operations fail the message is
2830  hosed. However, no memory or fds should be leaked since what
2831  has been added to message has been added to the message, and
2832  can hence be accounted for when the message is being
2833  freed. */
2834 #else
2835  ret = FALSE;
2836  /* This is redundant (we could just fall through), but it avoids
2837  * -Wunused-label in builds that don't HAVE_UNIX_FD_PASSING */
2838  goto out;
2839 #endif
2840  }
2841  else
2842  {
2843  ret = _dbus_type_writer_write_basic (&real->u.writer, type, value);
2844  }
2845 
2846 out:
2847  if (!_dbus_message_iter_close_signature (real))
2848  ret = FALSE;
2849 
2850  return ret;
2851 }
2852 
2890  int element_type,
2891  const void *value,
2892  int n_elements)
2893 {
2894  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2895  dbus_bool_t ret;
2896 
2897  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2898  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2899  _dbus_return_val_if_fail (dbus_type_is_fixed (element_type) && element_type != DBUS_TYPE_UNIX_FD, FALSE);
2900  _dbus_return_val_if_fail (real->u.writer.container_type == DBUS_TYPE_ARRAY, FALSE);
2901  _dbus_return_val_if_fail (value != NULL, FALSE);
2902  _dbus_return_val_if_fail (n_elements >= 0, FALSE);
2903  _dbus_return_val_if_fail (n_elements <=
2905  FALSE);
2906 
2907 #ifndef DBUS_DISABLE_CHECKS
2908  if (element_type == DBUS_TYPE_BOOLEAN)
2909  {
2910  const dbus_bool_t * const *bools = value;
2911  int i;
2912 
2913  for (i = 0; i < n_elements; i++)
2914  {
2915  _dbus_return_val_if_fail ((*bools)[i] == 0 || (*bools)[i] == 1, FALSE);
2916  }
2917  }
2918 #endif
2919 
2920  ret = _dbus_type_writer_write_fixed_multi (&real->u.writer, element_type, value, n_elements);
2921 
2922  return ret;
2923 }
2924 
2954  int type,
2955  const char *contained_signature,
2956  DBusMessageIter *sub)
2957 {
2958  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2959  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
2960  DBusString contained_str;
2961  DBusValidity contained_signature_validity;
2962  dbus_bool_t ret;
2963 
2964  _dbus_return_val_if_fail (sub != NULL, FALSE);
2965  /* Do our best to make sure the sub-iterator doesn't contain something
2966  * valid-looking on failure */
2967  _dbus_message_real_iter_zero (real_sub);
2968 
2969  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2970  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2971  _dbus_return_val_if_fail (dbus_type_is_container (type), FALSE);
2972  _dbus_return_val_if_fail ((type == DBUS_TYPE_STRUCT &&
2973  contained_signature == NULL) ||
2974  (type == DBUS_TYPE_DICT_ENTRY &&
2975  contained_signature == NULL) ||
2976  (type == DBUS_TYPE_VARIANT &&
2977  contained_signature != NULL) ||
2978  (type == DBUS_TYPE_ARRAY &&
2979  contained_signature != NULL), FALSE);
2980 
2981  /* this would fail if the contained_signature is a dict entry, since
2982  * dict entries are invalid signatures standalone (they must be in
2983  * an array)
2984  */
2985  if (contained_signature != NULL)
2986  {
2987  _dbus_string_init_const (&contained_str, contained_signature);
2988  contained_signature_validity = _dbus_validate_signature_with_reason (&contained_str,
2989  0,
2990  _dbus_string_get_length (&contained_str));
2991 
2992  if (contained_signature_validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
2993  return FALSE;
2994  }
2995  else
2996  {
2997  /* just some placeholder value */
2998  contained_signature_validity = DBUS_VALID_BUT_INCOMPLETE;
2999  }
3000 
3001  _dbus_return_val_if_fail ((type == DBUS_TYPE_ARRAY && contained_signature && *contained_signature == DBUS_DICT_ENTRY_BEGIN_CHAR) ||
3002  contained_signature == NULL ||
3003  contained_signature_validity == DBUS_VALID,
3004  FALSE);
3005 
3006  if (!_dbus_message_iter_open_signature (real))
3007  return FALSE;
3008 
3009  ret = FALSE;
3010  *real_sub = *real;
3011 
3012  if (contained_signature != NULL)
3013  {
3014  _dbus_string_init_const (&contained_str, contained_signature);
3015 
3016  ret = _dbus_type_writer_recurse (&real->u.writer,
3017  type,
3018  &contained_str, 0,
3019  &real_sub->u.writer);
3020  }
3021  else
3022  {
3023  ret = _dbus_type_writer_recurse (&real->u.writer,
3024  type,
3025  NULL, 0,
3026  &real_sub->u.writer);
3027  }
3028 
3029  if (!ret)
3030  _dbus_message_iter_abandon_signature (real);
3031 
3032  return ret;
3033 }
3034 
3035 
3057  DBusMessageIter *sub)
3058 {
3059  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3060  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3061  dbus_bool_t ret;
3062 
3063  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
3064  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
3065  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real_sub), FALSE);
3066  _dbus_return_val_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
3067 
3068  ret = _dbus_type_writer_unrecurse (&real->u.writer,
3069  &real_sub->u.writer);
3070  _dbus_message_real_iter_zero (real_sub);
3071 
3072  if (!_dbus_message_iter_close_signature (real))
3073  ret = FALSE;
3074 
3075  return ret;
3076 }
3077 
3089 void
3091  DBusMessageIter *sub)
3092 {
3093  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3094  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3095 
3096 #ifndef DBUS_DISABLE_CHECKS
3097  _dbus_return_if_fail (_dbus_message_iter_append_check (real));
3098  _dbus_return_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3099  _dbus_return_if_fail (_dbus_message_iter_append_check (real_sub));
3100  _dbus_return_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3101 #endif
3102 
3103  _dbus_message_iter_abandon_signature (real);
3104  _dbus_message_real_iter_zero (real_sub);
3105 }
3106 
3148 void
3150  DBusMessageIter *sub)
3151 {
3152  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3153  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3154 
3155  /* If both the parent and the child are zeroed out, then either we didn't
3156  * even get as far as successfully recursing into the parent, or we already
3157  * closed both the child and the parent. For example, in the code sample
3158  * in the doc-comment above, this happens for
3159  * abandon_container_if_open (&outer, &inner) if the first open_container
3160  * call failed, or if we reached result = TRUE and fell through. */
3161  if (_dbus_message_real_iter_is_zeroed (real) &&
3162  _dbus_message_real_iter_is_zeroed (real_sub))
3163  return;
3164 
3165 #ifndef DBUS_DISABLE_CHECKS
3166  /* If the child is not zeroed out, but the parent is, then something has
3167  * gone horribly wrong (in practice that would probably mean both are
3168  * uninitialized or corrupt, and the parent happens to have ended up
3169  * all-bytes-zero). */
3170  _dbus_return_if_fail (_dbus_message_iter_append_check (real));
3171  _dbus_return_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3172 #endif
3173 
3174  /* If the parent is not zeroed out, but the child is, then either we did
3175  * not successfully open the child, or we already closed the child. This
3176  * means we do not own a reference to the parent's signature, so it would
3177  * be wrong to release it; so we must not call abandon_signature() here.
3178  * In the code sample in the doc-comment above, this happens for
3179  * abandon_container_if_open (&outer, &inner) if the second open_container
3180  * call failed, or if the second close_container call failed. */
3181  if (_dbus_message_real_iter_is_zeroed (real_sub))
3182  return;
3183 
3184 #ifndef DBUS_DISABLE_CHECKS
3185  _dbus_return_if_fail (_dbus_message_iter_append_check (real_sub));
3186  _dbus_return_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3187 #endif
3188 
3189  /* If neither the parent nor the child is zeroed out, then we genuinely
3190  * have an open container; close it. In the code sample in the doc-comment,
3191  * this happens for abandon_container_if_open (&outer, &inner) if the
3192  * append_basic call failed. */
3193  _dbus_message_iter_abandon_signature (real);
3194  _dbus_message_real_iter_zero (real_sub);
3195 }
3196 
3213 void
3215  dbus_bool_t no_reply)
3216 {
3217  _dbus_return_if_fail (message != NULL);
3218  _dbus_return_if_fail (!message->locked);
3219 
3220  _dbus_header_toggle_flag (&message->header,
3222  no_reply);
3223 }
3224 
3234 {
3235  _dbus_return_val_if_fail (message != NULL, FALSE);
3236 
3237  return _dbus_header_get_flag (&message->header,
3239 }
3240 
3255 void
3257  dbus_bool_t auto_start)
3258 {
3259  _dbus_return_if_fail (message != NULL);
3260  _dbus_return_if_fail (!message->locked);
3261 
3262  _dbus_header_toggle_flag (&message->header,
3264  !auto_start);
3265 }
3266 
3276 {
3277  _dbus_return_val_if_fail (message != NULL, FALSE);
3278 
3279  return !_dbus_header_get_flag (&message->header,
3281 }
3282 
3283 
3298  const char *object_path)
3299 {
3300  _dbus_return_val_if_fail (message != NULL, FALSE);
3301  _dbus_return_val_if_fail (!message->locked, FALSE);
3302  _dbus_return_val_if_fail (object_path == NULL ||
3303  _dbus_check_is_valid_path (object_path),
3304  FALSE);
3305 
3306  return set_or_delete_string_field (message,
3309  object_path);
3310 }
3311 
3325 const char*
3327 {
3328  const char *v;
3329 
3330  _dbus_return_val_if_fail (message != NULL, NULL);
3331 
3332  v = NULL; /* in case field doesn't exist */
3336  (void *) &v);
3337  return v;
3338 }
3339 
3351  const char *path)
3352 {
3353  const char *msg_path;
3354  msg_path = dbus_message_get_path (message);
3355 
3356  if (msg_path == NULL)
3357  {
3358  if (path == NULL)
3359  return TRUE;
3360  else
3361  return FALSE;
3362  }
3363 
3364  if (path == NULL)
3365  return FALSE;
3366 
3367  if (strcmp (msg_path, path) == 0)
3368  return TRUE;
3369 
3370  return FALSE;
3371 }
3372 
3395  char ***path)
3396 {
3397  const char *v;
3398 
3399  _dbus_return_val_if_fail (message != NULL, FALSE);
3400  _dbus_return_val_if_fail (path != NULL, FALSE);
3401 
3402  *path = NULL;
3403 
3404  v = dbus_message_get_path (message);
3405  if (v != NULL)
3406  {
3407  if (!_dbus_decompose_path (v, strlen (v),
3408  path, NULL))
3409  return FALSE;
3410  }
3411  return TRUE;
3412 }
3413 
3429  const char *iface)
3430 {
3431  _dbus_return_val_if_fail (message != NULL, FALSE);
3432  _dbus_return_val_if_fail (!message->locked, FALSE);
3433  _dbus_return_val_if_fail (iface == NULL ||
3434  _dbus_check_is_valid_interface (iface),
3435  FALSE);
3436 
3437  return set_or_delete_string_field (message,
3440  iface);
3441 }
3442 
3456 const char*
3458 {
3459  const char *v;
3460 
3461  _dbus_return_val_if_fail (message != NULL, NULL);
3462 
3463  v = NULL; /* in case field doesn't exist */
3467  (void *) &v);
3468  return v;
3469 }
3470 
3480  const char *iface)
3481 {
3482  const char *msg_interface;
3483  msg_interface = dbus_message_get_interface (message);
3484 
3485  if (msg_interface == NULL)
3486  {
3487  if (iface == NULL)
3488  return TRUE;
3489  else
3490  return FALSE;
3491  }
3492 
3493  if (iface == NULL)
3494  return FALSE;
3495 
3496  if (strcmp (msg_interface, iface) == 0)
3497  return TRUE;
3498 
3499  return FALSE;
3500 
3501 }
3502 
3517  const char *member)
3518 {
3519  _dbus_return_val_if_fail (message != NULL, FALSE);
3520  _dbus_return_val_if_fail (!message->locked, FALSE);
3521  _dbus_return_val_if_fail (member == NULL ||
3522  _dbus_check_is_valid_member (member),
3523  FALSE);
3524 
3525  return set_or_delete_string_field (message,
3528  member);
3529 }
3530 
3542 const char*
3544 {
3545  const char *v;
3546 
3547  _dbus_return_val_if_fail (message != NULL, NULL);
3548 
3549  v = NULL; /* in case field doesn't exist */
3553  (void *) &v);
3554  return v;
3555 }
3556 
3566  const char *member)
3567 {
3568  const char *msg_member;
3569  msg_member = dbus_message_get_member (message);
3570 
3571  if (msg_member == NULL)
3572  {
3573  if (member == NULL)
3574  return TRUE;
3575  else
3576  return FALSE;
3577  }
3578 
3579  if (member == NULL)
3580  return FALSE;
3581 
3582  if (strcmp (msg_member, member) == 0)
3583  return TRUE;
3584 
3585  return FALSE;
3586 
3587 }
3588 
3602  const char *error_name)
3603 {
3604  _dbus_return_val_if_fail (message != NULL, FALSE);
3605  _dbus_return_val_if_fail (!message->locked, FALSE);
3606  _dbus_return_val_if_fail (error_name == NULL ||
3607  _dbus_check_is_valid_error_name (error_name),
3608  FALSE);
3609 
3610  return set_or_delete_string_field (message,
3613  error_name);
3614 }
3615 
3626 const char*
3628 {
3629  const char *v;
3630 
3631  _dbus_return_val_if_fail (message != NULL, NULL);
3632 
3633  v = NULL; /* in case field doesn't exist */
3637  (void *) &v);
3638  return v;
3639 }
3640 
3656  const char *destination)
3657 {
3658  _dbus_return_val_if_fail (message != NULL, FALSE);
3659  _dbus_return_val_if_fail (!message->locked, FALSE);
3660  _dbus_return_val_if_fail (destination == NULL ||
3661  _dbus_check_is_valid_bus_name (destination),
3662  FALSE);
3663 
3664  return set_or_delete_string_field (message,
3667  destination);
3668 }
3669 
3679 const char*
3681 {
3682  const char *v;
3683 
3684  _dbus_return_val_if_fail (message != NULL, NULL);
3685 
3686  v = NULL; /* in case field doesn't exist */
3690  (void *) &v);
3691  return v;
3692 }
3693 
3710  const char *sender)
3711 {
3712  _dbus_return_val_if_fail (message != NULL, FALSE);
3713  _dbus_return_val_if_fail (!message->locked, FALSE);
3714  _dbus_return_val_if_fail (sender == NULL ||
3715  _dbus_check_is_valid_bus_name (sender),
3716  FALSE);
3717 
3718  return set_or_delete_string_field (message,
3721  sender);
3722 }
3723 
3739 const char*
3741 {
3742  const char *v;
3743 
3744  _dbus_return_val_if_fail (message != NULL, NULL);
3745 
3746  v = NULL; /* in case field doesn't exist */
3750  (void *) &v);
3751  return v;
3752 }
3753 
3772 const char*
3774 {
3775  const DBusString *type_str;
3776  int type_pos;
3777 
3778  _dbus_return_val_if_fail (message != NULL, NULL);
3779 
3780  get_const_signature (&message->header, &type_str, &type_pos);
3781 
3782  return _dbus_string_get_const_data_len (type_str, type_pos, 0);
3783 }
3784 
3785 static dbus_bool_t
3786 _dbus_message_has_type_interface_member (DBusMessage *message,
3787  int type,
3788  const char *iface,
3789  const char *member)
3790 {
3791  const char *n;
3792 
3793  _dbus_assert (message != NULL);
3794  _dbus_assert (iface != NULL);
3795  _dbus_assert (member != NULL);
3796 
3797  if (dbus_message_get_type (message) != type)
3798  return FALSE;
3799 
3800  /* Optimize by checking the short member name first
3801  * instead of the longer interface name
3802  */
3803 
3804  n = dbus_message_get_member (message);
3805 
3806  if (n && strcmp (n, member) == 0)
3807  {
3808  n = dbus_message_get_interface (message);
3809 
3810  if (n == NULL || strcmp (n, iface) == 0)
3811  return TRUE;
3812  }
3813 
3814  return FALSE;
3815 }
3816 
3833  const char *iface,
3834  const char *method)
3835 {
3836  _dbus_return_val_if_fail (message != NULL, FALSE);
3837  _dbus_return_val_if_fail (iface != NULL, FALSE);
3838  _dbus_return_val_if_fail (method != NULL, FALSE);
3839  /* don't check that interface/method are valid since it would be
3840  * expensive, and not catch many common errors
3841  */
3842 
3843  return _dbus_message_has_type_interface_member (message,
3845  iface, method);
3846 }
3847 
3861  const char *iface,
3862  const char *signal_name)
3863 {
3864  _dbus_return_val_if_fail (message != NULL, FALSE);
3865  _dbus_return_val_if_fail (iface != NULL, FALSE);
3866  _dbus_return_val_if_fail (signal_name != NULL, FALSE);
3867  /* don't check that interface/name are valid since it would be
3868  * expensive, and not catch many common errors
3869  */
3870 
3871  return _dbus_message_has_type_interface_member (message,
3873  iface, signal_name);
3874 }
3875 
3888  const char *error_name)
3889 {
3890  const char *n;
3891 
3892  _dbus_return_val_if_fail (message != NULL, FALSE);
3893  _dbus_return_val_if_fail (error_name != NULL, FALSE);
3894  /* don't check that error_name is valid since it would be expensive,
3895  * and not catch many common errors
3896  */
3897 
3899  return FALSE;
3900 
3901  n = dbus_message_get_error_name (message);
3902 
3903  if (n && strcmp (n, error_name) == 0)
3904  return TRUE;
3905  else
3906  return FALSE;
3907 }
3908 
3921  const char *name)
3922 {
3923  const char *s;
3924 
3925  _dbus_return_val_if_fail (message != NULL, FALSE);
3926  _dbus_return_val_if_fail (name != NULL, FALSE);
3927  /* don't check that name is valid since it would be expensive, and
3928  * not catch many common errors
3929  */
3930 
3931  s = dbus_message_get_destination (message);
3932 
3933  if (s && strcmp (s, name) == 0)
3934  return TRUE;
3935  else
3936  return FALSE;
3937 }
3938 
3956  const char *name)
3957 {
3958  const char *s;
3959 
3960  _dbus_return_val_if_fail (message != NULL, FALSE);
3961  _dbus_return_val_if_fail (name != NULL, FALSE);
3962  /* don't check that name is valid since it would be expensive, and
3963  * not catch many common errors
3964  */
3965 
3966  s = dbus_message_get_sender (message);
3967 
3968  if (s && strcmp (s, name) == 0)
3969  return TRUE;
3970  else
3971  return FALSE;
3972 }
3973 
3985  const char *signature)
3986 {
3987  const char *s;
3988 
3989  _dbus_return_val_if_fail (message != NULL, FALSE);
3990  _dbus_return_val_if_fail (signature != NULL, FALSE);
3991  /* don't check that signature is valid since it would be expensive,
3992  * and not catch many common errors
3993  */
3994 
3995  s = dbus_message_get_signature (message);
3996 
3997  if (s && strcmp (s, signature) == 0)
3998  return TRUE;
3999  else
4000  return FALSE;
4001 }
4002 
4027  DBusMessage *message)
4028 {
4029  const char *str;
4030 
4031  _dbus_return_val_if_fail (message != NULL, FALSE);
4032  _dbus_return_val_if_error_is_set (error, FALSE);
4033 
4035  return FALSE;
4036 
4037  str = NULL;
4038  dbus_message_get_args (message, NULL,
4039  DBUS_TYPE_STRING, &str,
4041 
4042  dbus_set_error (error, dbus_message_get_error_name (message),
4043  str ? "%s" : NULL, str);
4044 
4045  return TRUE;
4046 }
4047 
4056 {
4057 #ifdef HAVE_UNIX_FD_PASSING
4058  _dbus_assert(message);
4059 
4060  return message->n_unix_fds > 0;
4061 #else
4062  return FALSE;
4063 #endif
4064 }
4065 
4084 #define INITIAL_LOADER_DATA_LEN 32
4085 
4094 {
4095  DBusMessageLoader *loader;
4096 
4097  loader = dbus_new0 (DBusMessageLoader, 1);
4098  if (loader == NULL)
4099  return NULL;
4100 
4101  loader->refcount = 1;
4102 
4103  loader->corrupted = FALSE;
4104  loader->corruption_reason = DBUS_VALID;
4105 
4106  /* this can be configured by the app, but defaults to the protocol max */
4108 
4109  /* We set a very relatively conservative default here since due to how
4110  SCM_RIGHTS works we need to preallocate an fd array of the maximum
4111  number of unix fds we want to receive in advance. A
4112  try-and-reallocate loop is not possible. */
4113  loader->max_message_unix_fds = DBUS_DEFAULT_MESSAGE_UNIX_FDS;
4114 
4115  if (!_dbus_string_init (&loader->data))
4116  {
4117  dbus_free (loader);
4118  return NULL;
4119  }
4120 
4121  /* preallocate the buffer for speed, ignore failure */
4123  _dbus_string_set_length (&loader->data, 0);
4124 
4125 #ifdef HAVE_UNIX_FD_PASSING
4126  loader->unix_fds = NULL;
4127  loader->n_unix_fds = loader->n_unix_fds_allocated = 0;
4128  loader->unix_fds_outstanding = FALSE;
4129 #endif
4130 
4131  return loader;
4132 }
4133 
4142 {
4143  loader->refcount += 1;
4144 
4145  return loader;
4146 }
4147 
4154 void
4156 {
4157  loader->refcount -= 1;
4158  if (loader->refcount == 0)
4159  {
4160 #ifdef HAVE_UNIX_FD_PASSING
4161  close_unix_fds(loader->unix_fds, &loader->n_unix_fds);
4162  dbus_free(loader->unix_fds);
4163 #endif
4164  _dbus_list_foreach (&loader->messages,
4166  NULL);
4167  _dbus_list_clear (&loader->messages);
4168  _dbus_string_free (&loader->data);
4169  dbus_free (loader);
4170  }
4171 }
4172 
4191 void
4193  DBusString **buffer,
4194  int *max_to_read,
4195  dbus_bool_t *may_read_fds)
4196 {
4197  _dbus_assert (!loader->buffer_outstanding);
4198 
4199  *buffer = &loader->data;
4200 
4201  loader->buffer_outstanding = TRUE;
4202 
4203  if (max_to_read != NULL)
4204  {
4205 #ifdef HAVE_UNIX_FD_PASSING
4206  int offset = 0;
4207  int remain;
4208  int byte_order;
4209  int fields_array_len;
4210  int header_len;
4211  int body_len;
4212 #endif
4213 
4214  *max_to_read = DBUS_MAXIMUM_MESSAGE_LENGTH;
4215  *may_read_fds = TRUE;
4216 
4217 #ifdef HAVE_UNIX_FD_PASSING
4218  /* If we aren't holding onto any fds, we can read as much as we want
4219  * (fast path). */
4220  if (loader->n_unix_fds == 0)
4221  return;
4222 
4223  /* Slow path: we have a message with some fds in it. We don't want
4224  * to start on the next message until this one is out of the way;
4225  * otherwise a legitimate sender can keep us processing messages
4226  * containing fds, until we disconnect it for having had fds pending
4227  * for too long, a limit that is in place to stop malicious senders
4228  * from setting up recursive fd-passing that takes up our quota and
4229  * will never go away. */
4230 
4231  remain = _dbus_string_get_length (&loader->data);
4232 
4233  while (remain > 0)
4234  {
4235  DBusValidity validity = DBUS_VALIDITY_UNKNOWN;
4236  int needed;
4237 
4238  /* If 0 < remain < DBUS_MINIMUM_HEADER_SIZE, then we've had at
4239  * least the first byte of a message, but we don't know how
4240  * much more to read. Only read the rest of the
4241  * DBUS_MINIMUM_HEADER_SIZE for now; then we'll know. */
4242  if (remain < DBUS_MINIMUM_HEADER_SIZE)
4243  {
4244  *max_to_read = DBUS_MINIMUM_HEADER_SIZE - remain;
4245  *may_read_fds = FALSE;
4246  return;
4247  }
4248 
4250  &validity,
4251  &byte_order,
4252  &fields_array_len,
4253  &header_len,
4254  &body_len,
4255  &loader->data,
4256  offset,
4257  remain))
4258  {
4259  /* If a message in the buffer is invalid, we're going to
4260  * disconnect the sender anyway, so reading an arbitrary amount
4261  * is fine. */
4262  if (validity != DBUS_VALID)
4263  return;
4264 
4265  /* We have a partial message, with the
4266  * DBUS_MINIMUM_HEADER_SIZE-byte fixed part of the header (which
4267  * lets us work out how much more we need), but no more. Read
4268  * the rest of the message. */
4269  needed = header_len + body_len;
4270  _dbus_assert (needed > remain);
4271  *max_to_read = needed - remain;
4272  *may_read_fds = FALSE;
4273  return;
4274  }
4275 
4276  /* Skip over entire messages until we have less than a message
4277  * remaining. */
4278  needed = header_len + body_len;
4280  _dbus_assert (remain >= needed);
4281  remain -= needed;
4282  offset += needed;
4283  }
4284 #endif
4285  }
4286 }
4287 
4297 void
4299  DBusString *buffer)
4300 {
4301  _dbus_assert (loader->buffer_outstanding);
4302  _dbus_assert (buffer == &loader->data);
4303 
4304  loader->buffer_outstanding = FALSE;
4305 }
4306 
4307 #ifdef HAVE_UNIX_FD_PASSING
4308 
4319 _dbus_message_loader_get_unix_fds(DBusMessageLoader *loader,
4320  int **fds,
4321  unsigned *max_n_fds)
4322 {
4323  _dbus_assert (!loader->unix_fds_outstanding);
4324 
4325  /* Allocate space where we can put the fds we read. We allocate
4326  space for max_message_unix_fds since this is an
4327  upper limit how many fds can be received within a single
4328  message. Since SCM_RIGHTS doesn't allow a reallocate+retry logic
4329  we are allocating the maximum possible array size right from the
4330  beginning. This sucks a bit, however unless SCM_RIGHTS is fixed
4331  there is no better way. */
4332 
4333  if (loader->n_unix_fds_allocated < loader->max_message_unix_fds)
4334  {
4335  int *a = dbus_realloc(loader->unix_fds,
4336  loader->max_message_unix_fds * sizeof(loader->unix_fds[0]));
4337 
4338  if (!a)
4339  return FALSE;
4340 
4341  loader->unix_fds = a;
4342  loader->n_unix_fds_allocated = loader->max_message_unix_fds;
4343  }
4344 
4345  *fds = loader->unix_fds + loader->n_unix_fds;
4346  *max_n_fds = loader->n_unix_fds_allocated - loader->n_unix_fds;
4347 
4348  loader->unix_fds_outstanding = TRUE;
4349  return TRUE;
4350 }
4351 
4362 void
4363 _dbus_message_loader_return_unix_fds(DBusMessageLoader *loader,
4364  int *fds,
4365  unsigned n_fds)
4366 {
4367  _dbus_assert(loader->unix_fds_outstanding);
4368  _dbus_assert(loader->unix_fds + loader->n_unix_fds == fds);
4369  _dbus_assert(loader->n_unix_fds + n_fds <= loader->n_unix_fds_allocated);
4370 
4371  loader->n_unix_fds += n_fds;
4372  loader->unix_fds_outstanding = FALSE;
4373 
4374  if (n_fds && loader->unix_fds_change)
4375  loader->unix_fds_change (loader->unix_fds_change_data);
4376 }
4377 #endif
4378 
4379 /*
4380  * FIXME when we move the header out of the buffer, that memmoves all
4381  * buffered messages. Kind of crappy.
4382  *
4383  * Also we copy the header and body, which is kind of crappy. To
4384  * avoid this, we have to allow header and body to be in a single
4385  * memory block, which is good for messages we read and bad for
4386  * messages we are creating. But we could move_len() the buffer into
4387  * this single memory block, and move_len() will just swap the buffers
4388  * if you're moving the entire buffer replacing the dest string.
4389  *
4390  * We could also have the message loader tell the transport how many
4391  * bytes to read; so it would first ask for some arbitrary number like
4392  * 256, then if the message was incomplete it would use the
4393  * header/body len to ask for exactly the size of the message (or
4394  * blocks the size of a typical kernel buffer for the socket). That
4395  * way we don't get trailing bytes in the buffer that have to be
4396  * memmoved. Though I suppose we also don't have a chance of reading a
4397  * bunch of small messages at once, so the optimization may be stupid.
4398  *
4399  * Another approach would be to keep a "start" index into
4400  * loader->data and only delete it occasionally, instead of after
4401  * each message is loaded.
4402  *
4403  * load_message() returns FALSE if not enough memory OR the loader was corrupted
4404  */
4405 static dbus_bool_t
4406 load_message (DBusMessageLoader *loader,
4407  DBusMessage *message,
4408  int byte_order,
4409  int fields_array_len,
4410  int header_len,
4411  int body_len)
4412 {
4413  dbus_bool_t oom;
4414  DBusValidity validity;
4415  const DBusString *type_str;
4416  int type_pos;
4417  DBusValidationMode mode;
4418  dbus_uint32_t n_unix_fds = 0;
4419 
4420  mode = DBUS_VALIDATION_MODE_DATA_IS_UNTRUSTED;
4421 
4422  oom = FALSE;
4423 
4424 #if 0
4425  _dbus_verbose_bytes_of_string (&loader->data, 0, header_len /* + body_len */);
4426 #endif
4427 
4428  /* 1. VALIDATE AND COPY OVER HEADER */
4429  _dbus_assert (_dbus_string_get_length (&message->header.data) == 0);
4430  _dbus_assert ((header_len + body_len) <= _dbus_string_get_length (&loader->data));
4431 
4432  if (!_dbus_header_load (&message->header,
4433  mode,
4434  &validity,
4435  byte_order,
4436  fields_array_len,
4437  header_len,
4438  body_len,
4439  &loader->data, 0,
4440  _dbus_string_get_length (&loader->data)))
4441  {
4442  _dbus_verbose ("Failed to load header for new message code %d\n", validity);
4443 
4444  /* assert here so we can catch any code that still uses DBUS_VALID to indicate
4445  oom errors. They should use DBUS_VALIDITY_UNKNOWN_OOM_ERROR instead */
4446  _dbus_assert (validity != DBUS_VALID);
4447 
4448  if (validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
4449  oom = TRUE;
4450  else
4451  {
4452  loader->corrupted = TRUE;
4453  loader->corruption_reason = validity;
4454  }
4455  goto failed;
4456  }
4457 
4458  _dbus_assert (validity == DBUS_VALID);
4459 
4460  /* 2. VALIDATE BODY */
4461  if (mode != DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY)
4462  {
4463  get_const_signature (&message->header, &type_str, &type_pos);
4464 
4465  /* Because the bytes_remaining arg is NULL, this validates that the
4466  * body is the right length
4467  */
4468  validity = _dbus_validate_body_with_reason (type_str,
4469  type_pos,
4470  byte_order,
4471  NULL,
4472  &loader->data,
4473  header_len,
4474  body_len);
4475  if (validity != DBUS_VALID)
4476  {
4477  _dbus_verbose ("Failed to validate message body code %d\n", validity);
4478 
4479  loader->corrupted = TRUE;
4480  loader->corruption_reason = validity;
4481 
4482  goto failed;
4483  }
4484  }
4485 
4486  /* 3. COPY OVER UNIX FDS */
4490  &n_unix_fds);
4491 
4492 #ifdef HAVE_UNIX_FD_PASSING
4493 
4494  if (n_unix_fds > loader->n_unix_fds)
4495  {
4496  _dbus_verbose("Message contains references to more unix fds than were sent %u != %u\n",
4497  n_unix_fds, loader->n_unix_fds);
4498 
4499  loader->corrupted = TRUE;
4500  loader->corruption_reason = DBUS_INVALID_MISSING_UNIX_FDS;
4501  goto failed;
4502  }
4503 
4504  /* If this was a recycled message there might still be
4505  some memory allocated for the fds */
4506  dbus_free(message->unix_fds);
4507 
4508  if (n_unix_fds > 0)
4509  {
4510  message->unix_fds = _dbus_memdup(loader->unix_fds, n_unix_fds * sizeof(message->unix_fds[0]));
4511  if (message->unix_fds == NULL)
4512  {
4513  _dbus_verbose ("Failed to allocate file descriptor array\n");
4514  oom = TRUE;
4515  goto failed;
4516  }
4517 
4518  message->n_unix_fds_allocated = message->n_unix_fds = n_unix_fds;
4519  loader->n_unix_fds -= n_unix_fds;
4520  memmove (loader->unix_fds, loader->unix_fds + n_unix_fds, loader->n_unix_fds * sizeof (loader->unix_fds[0]));
4521 
4522  if (loader->unix_fds_change)
4523  loader->unix_fds_change (loader->unix_fds_change_data);
4524  }
4525  else
4526  message->unix_fds = NULL;
4527 
4528 #else
4529 
4530  if (n_unix_fds > 0)
4531  {
4532  _dbus_verbose ("Hmm, message claims to come with file descriptors "
4533  "but that's not supported on our platform, disconnecting.\n");
4534 
4535  loader->corrupted = TRUE;
4536  loader->corruption_reason = DBUS_INVALID_MISSING_UNIX_FDS;
4537  goto failed;
4538  }
4539 
4540 #endif
4541 
4542  /* 3. COPY OVER BODY AND QUEUE MESSAGE */
4543 
4544  if (!_dbus_list_append (&loader->messages, message))
4545  {
4546  _dbus_verbose ("Failed to append new message to loader queue\n");
4547  oom = TRUE;
4548  goto failed;
4549  }
4550 
4551  _dbus_assert (_dbus_string_get_length (&message->body) == 0);
4552  _dbus_assert (_dbus_string_get_length (&loader->data) >=
4553  (header_len + body_len));
4554 
4555  if (!_dbus_string_copy_len (&loader->data, header_len, body_len, &message->body, 0))
4556  {
4557  _dbus_verbose ("Failed to move body into new message\n");
4558  oom = TRUE;
4559  goto failed;
4560  }
4561 
4562  _dbus_string_delete (&loader->data, 0, header_len + body_len);
4563 
4564  /* don't waste more than 2k of memory */
4565  _dbus_string_compact (&loader->data, 2048);
4566 
4567  _dbus_assert (_dbus_string_get_length (&message->header.data) == header_len);
4568  _dbus_assert (_dbus_string_get_length (&message->body) == body_len);
4569 
4570  _dbus_verbose ("Loaded message %p\n", message);
4571 
4572  _dbus_assert (!oom);
4573  _dbus_assert (!loader->corrupted);
4574  _dbus_assert (loader->messages != NULL);
4575  _dbus_assert (_dbus_list_find_last (&loader->messages, message) != NULL);
4576 
4577  return TRUE;
4578 
4579  failed:
4580 
4581  /* Clean up */
4582 
4583  /* does nothing if the message isn't in the list */
4584  _dbus_list_remove_last (&loader->messages, message);
4585 
4586  if (oom)
4587  _dbus_assert (!loader->corrupted);
4588  else
4589  _dbus_assert (loader->corrupted);
4590 
4591  _dbus_verbose_bytes_of_string (&loader->data, 0, _dbus_string_get_length (&loader->data));
4592 
4593  return FALSE;
4594 }
4595 
4612 {
4613  while (!loader->corrupted &&
4614  _dbus_string_get_length (&loader->data) >= DBUS_MINIMUM_HEADER_SIZE)
4615  {
4616  DBusValidity validity;
4617  int byte_order, fields_array_len, header_len, body_len;
4618 
4620  &validity,
4621  &byte_order,
4622  &fields_array_len,
4623  &header_len,
4624  &body_len,
4625  &loader->data, 0,
4626  _dbus_string_get_length (&loader->data)))
4627  {
4628  DBusMessage *message;
4629 
4630  _dbus_assert (validity == DBUS_VALID);
4631 
4632  message = dbus_message_new_empty_header ();
4633  if (message == NULL)
4634  return FALSE;
4635 
4636  if (!load_message (loader, message,
4637  byte_order, fields_array_len,
4638  header_len, body_len))
4639  {
4640  dbus_message_unref (message);
4641  /* load_message() returns false if corrupted or OOM; if
4642  * corrupted then return TRUE for not OOM
4643  */
4644  return loader->corrupted;
4645  }
4646 
4647  _dbus_assert (loader->messages != NULL);
4648  _dbus_assert (_dbus_list_find_last (&loader->messages, message) != NULL);
4649  }
4650  else
4651  {
4652  _dbus_verbose ("Initial peek at header says we don't have a whole message yet, or data broken with invalid code %d\n",
4653  validity);
4654  if (validity != DBUS_VALID)
4655  {
4656  loader->corrupted = TRUE;
4657  loader->corruption_reason = validity;
4658  }
4659  return TRUE;
4660  }
4661  }
4662 
4663  return TRUE;
4664 }
4665 
4673 DBusMessage*
4675 {
4676  if (loader->messages)
4677  return loader->messages->data;
4678  else
4679  return NULL;
4680 }
4681 
4690 DBusMessage*
4692 {
4693  return _dbus_list_pop_first (&loader->messages);
4694 }
4695 
4704 DBusList*
4706 {
4707  return _dbus_list_pop_first_link (&loader->messages);
4708 }
4709 
4716 void
4718  DBusList *link)
4719 {
4720  _dbus_list_prepend_link (&loader->messages, link);
4721 }
4722 
4734 {
4735  _dbus_assert ((loader->corrupted && loader->corruption_reason != DBUS_VALID) ||
4736  (!loader->corrupted && loader->corruption_reason == DBUS_VALID));
4737  return loader->corrupted;
4738 }
4739 
4748 {
4749  _dbus_assert ((loader->corrupted && loader->corruption_reason != DBUS_VALID) ||
4750  (!loader->corrupted && loader->corruption_reason == DBUS_VALID));
4751 
4752  return loader->corruption_reason;
4753 }
4754 
4761 void
4763  long size)
4764 {
4765  if (size > DBUS_MAXIMUM_MESSAGE_LENGTH)
4766  {
4767  _dbus_verbose ("clamping requested max message size %ld to %d\n",
4770  }
4771  loader->max_message_size = size;
4772 }
4773 
4780 long
4782 {
4783  return loader->max_message_size;
4784 }
4785 
4792 void
4794  long n)
4795 {
4797  {
4798  _dbus_verbose ("clamping requested max message unix_fds %ld to %d\n",
4801  }
4802  loader->max_message_unix_fds = n;
4803 }
4804 
4811 long
4813 {
4814  return loader->max_message_unix_fds;
4815 }
4816 
4822 int
4824 {
4825 #ifdef HAVE_UNIX_FD_PASSING
4826  return loader->n_unix_fds;
4827 #else
4828  return 0;
4829 #endif
4830 }
4831 
4840 void
4842  void (* callback) (void *),
4843  void *data)
4844 {
4845 #ifdef HAVE_UNIX_FD_PASSING
4846  loader->unix_fds_change = callback;
4847  loader->unix_fds_change_data = data;
4848 #endif
4849 }
4850 
4851 static DBusDataSlotAllocator slot_allocator =
4852  _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (message_slots));
4853 
4869 dbus_message_allocate_data_slot (dbus_int32_t *slot_p)
4870 {
4871  return _dbus_data_slot_allocator_alloc (&slot_allocator,
4872  slot_p);
4873 }
4874 
4886 void
4887 dbus_message_free_data_slot (dbus_int32_t *slot_p)
4888 {
4889  _dbus_return_if_fail (*slot_p >= 0);
4890 
4891  _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
4892 }
4893 
4909  dbus_int32_t slot,
4910  void *data,
4911  DBusFreeFunction free_data_func)
4912 {
4913  DBusFreeFunction old_free_func;
4914  void *old_data;
4915  dbus_bool_t retval;
4916 
4917  _dbus_return_val_if_fail (message != NULL, FALSE);
4918  _dbus_return_val_if_fail (slot >= 0, FALSE);
4919 
4920  retval = _dbus_data_slot_list_set (&slot_allocator,
4921  &message->slot_list,
4922  slot, data, free_data_func,
4923  &old_free_func, &old_data);
4924 
4925  if (retval)
4926  {
4927  /* Do the actual free outside the message lock */
4928  if (old_free_func)
4929  (* old_free_func) (old_data);
4930  }
4931 
4932  return retval;
4933 }
4934 
4943 void*
4945  dbus_int32_t slot)
4946 {
4947  void *res;
4948 
4949  _dbus_return_val_if_fail (message != NULL, NULL);
4950 
4951  res = _dbus_data_slot_list_get (&slot_allocator,
4952  &message->slot_list,
4953  slot);
4954 
4955  return res;
4956 }
4957 
4971 int
4972 dbus_message_type_from_string (const char *type_str)
4973 {
4974  if (strcmp (type_str, "method_call") == 0)
4976  if (strcmp (type_str, "method_return") == 0)
4978  else if (strcmp (type_str, "signal") == 0)
4979  return DBUS_MESSAGE_TYPE_SIGNAL;
4980  else if (strcmp (type_str, "error") == 0)
4981  return DBUS_MESSAGE_TYPE_ERROR;
4982  else
4984 }
4985 
4999 const char *
5001 {
5002  switch (type)
5003  {
5005  return "method_call";
5007  return "method_return";
5009  return "signal";
5011  return "error";
5012  default:
5013  return "invalid";
5014  }
5015 }
5016 
5031  char **marshalled_data_p,
5032  int *len_p)
5033 {
5034  DBusString tmp;
5035  dbus_bool_t was_locked;
5036 
5037  _dbus_return_val_if_fail (msg != NULL, FALSE);
5038  _dbus_return_val_if_fail (marshalled_data_p != NULL, FALSE);
5039  _dbus_return_val_if_fail (len_p != NULL, FALSE);
5040 
5041  if (!_dbus_string_init (&tmp))
5042  return FALSE;
5043 
5044  /* Ensure the message is locked, to ensure the length header is filled in. */
5045  was_locked = msg->locked;
5046 
5047  if (!was_locked)
5048  dbus_message_lock (msg);
5049 
5050  if (!_dbus_string_copy (&(msg->header.data), 0, &tmp, 0))
5051  goto fail;
5052 
5053  *len_p = _dbus_string_get_length (&tmp);
5054 
5055  if (!_dbus_string_copy (&(msg->body), 0, &tmp, *len_p))
5056  goto fail;
5057 
5058  *len_p = _dbus_string_get_length (&tmp);
5059 
5060  if (!_dbus_string_steal_data (&tmp, marshalled_data_p))
5061  goto fail;
5062 
5063  _dbus_string_free (&tmp);
5064 
5065  if (!was_locked)
5066  msg->locked = FALSE;
5067 
5068  return TRUE;
5069 
5070  fail:
5071  _dbus_string_free (&tmp);
5072 
5073  if (!was_locked)
5074  msg->locked = FALSE;
5075 
5076  return FALSE;
5077 }
5078 
5091 DBusMessage *
5092 dbus_message_demarshal (const char *str,
5093  int len,
5094  DBusError *error)
5095 {
5096  DBusMessageLoader *loader;
5097  DBusString *buffer;
5098  DBusMessage *msg;
5099 
5100  _dbus_return_val_if_fail (str != NULL, NULL);
5101 
5102  loader = _dbus_message_loader_new ();
5103 
5104  if (loader == NULL)
5105  return NULL;
5106 
5107  _dbus_message_loader_get_buffer (loader, &buffer, NULL, NULL);
5108 
5109  if (!_dbus_string_append_len (buffer, str, len))
5110  goto fail_oom;
5111 
5112  _dbus_message_loader_return_buffer (loader, buffer);
5113 
5115  goto fail_oom;
5116 
5118  goto fail_corrupt;
5119 
5120  msg = _dbus_message_loader_pop_message (loader);
5121 
5122  if (!msg)
5123  goto fail_oom;
5124 
5125  _dbus_message_loader_unref (loader);
5126  return msg;
5127 
5128  fail_corrupt:
5129  dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, "Message is corrupted (%s)",
5130  _dbus_validity_to_error_message (loader->corruption_reason));
5131  _dbus_message_loader_unref (loader);
5132  return NULL;
5133 
5134  fail_oom:
5135  _DBUS_SET_OOM (error);
5136  _dbus_message_loader_unref (loader);
5137  return NULL;
5138 }
5139 
5152 int
5154  int len)
5155 {
5156  DBusString str;
5157  int byte_order, fields_array_len, header_len, body_len;
5158  DBusValidity validity = DBUS_VALID;
5159  int have_message;
5160 
5161  if (!buf || len < DBUS_MINIMUM_HEADER_SIZE)
5162  return 0;
5163 
5164  if (len > DBUS_MAXIMUM_MESSAGE_LENGTH)
5166  _dbus_string_init_const_len (&str, buf, len);
5167 
5168  validity = DBUS_VALID;
5169  have_message
5171  &validity, &byte_order,
5172  &fields_array_len,
5173  &header_len,
5174  &body_len,
5175  &str, 0,
5176  len);
5177  _dbus_string_free (&str);
5178 
5179  if (validity == DBUS_VALID)
5180  {
5181  _dbus_assert (have_message || (header_len + body_len) > len);
5182  (void) have_message; /* unused unless asserting */
5183  return header_len + body_len;
5184  }
5185  else
5186  {
5187  return -1; /* broken! */
5188  }
5189 }
5190 
5212 void
5214  dbus_bool_t allow)
5215 {
5216  _dbus_return_if_fail (message != NULL);
5217  _dbus_return_if_fail (!message->locked);
5218 
5219  _dbus_header_toggle_flag (&message->header,
5221  allow);
5222 }
5223 
5232 {
5233  _dbus_return_val_if_fail (message != NULL, FALSE);
5234 
5235  return _dbus_header_get_flag (&message->header,
5237 }
5238 
5246 {
5247  DBusString data;
5248 };
5249 
5261 DBusVariant *
5263 {
5264  DBusVariant *self = NULL;
5265  /* Points to the single item we will read from the reader */
5266  DBusMessageRealIter *real_reader = (DBusMessageRealIter *) reader;
5267  /* The position in self at which we will write a single variant
5268  * (it is position 0) */
5269  DBusTypeWriter items_writer;
5270  /* The position in self at which we will write a copy of reader
5271  * (it is inside the variant) */
5272  DBusTypeWriter variant_writer;
5273  /* 'v' */
5274  DBusString variant_signature;
5275  /* Whatever is the signature of the item we will copy from the reader */
5276  DBusString contained_signature;
5277  /* TRUE if self->data needs to be freed */
5278  dbus_bool_t data_inited = FALSE;
5279  /* The type of the item we will read from the reader */
5280  int type;
5281  /* The string, start position within that string, and length of the signature
5282  * of the single complete type of the item reader points to */
5283  const DBusString *sig;
5284  int start, len;
5285 
5286  _dbus_assert (_dbus_message_iter_check (real_reader));
5287  _dbus_assert (real_reader->iter_type == DBUS_MESSAGE_ITER_TYPE_READER);
5289  type = dbus_message_iter_get_arg_type (reader);
5290  _dbus_type_reader_get_signature (&real_reader->u.reader, &sig, &start, &len);
5291 
5292  if (!_dbus_string_init (&contained_signature))
5293  return NULL;
5294 
5295  if (!_dbus_string_copy_len (sig, start, len, &contained_signature, 0))
5296  goto oom;
5297 
5298  self = dbus_new0 (DBusVariant, 1);
5299 
5300  if (self == NULL)
5301  goto oom;
5302 
5303  if (!_dbus_string_init (&self->data))
5304  goto oom;
5305 
5306  data_inited = TRUE;
5307 
5308  _dbus_type_writer_init_values_only (&items_writer, DBUS_COMPILER_BYTE_ORDER,
5309  &variant_signature, 0, &self->data, 0);
5310 
5311  if (!_dbus_type_writer_recurse (&items_writer, DBUS_TYPE_VARIANT,
5312  &contained_signature, 0, &variant_writer))
5313  goto oom;
5314 
5315  if (type == DBUS_TYPE_ARRAY)
5316  {
5317  /* Points to each item in turn inside the array we are copying */
5318  DBusMessageIter array_reader;
5319  /* Same as array_reader */
5320  DBusMessageRealIter *real_array_reader = (DBusMessageRealIter *) &array_reader;
5321  /* The position inside the copied array at which we will write
5322  * the copy of array_reader */
5323  DBusTypeWriter array_writer;
5324 
5325  dbus_message_iter_recurse (reader, &array_reader);
5326 
5327  if (!_dbus_type_writer_recurse (&variant_writer, type,
5328  &contained_signature, 1, &array_writer))
5329  goto oom;
5330 
5331  if (!_dbus_type_writer_write_reader (&array_writer,
5332  &real_array_reader->u.reader))
5333  goto oom;
5334 
5335  if (!_dbus_type_writer_unrecurse (&variant_writer, &array_writer))
5336  goto oom;
5337  }
5338  else if (type == DBUS_TYPE_DICT_ENTRY || type == DBUS_TYPE_VARIANT ||
5339  type == DBUS_TYPE_STRUCT)
5340  {
5341  /* Points to each item in turn inside the container we are copying */
5342  DBusMessageIter inner_reader;
5343  /* Same as inner_reader */
5344  DBusMessageRealIter *real_inner_reader = (DBusMessageRealIter *) &inner_reader;
5345  /* The position inside the copied container at which we will write the
5346  * copy of inner_reader */
5347  DBusTypeWriter inner_writer;
5348 
5349  dbus_message_iter_recurse (reader, &inner_reader);
5350 
5351  if (!_dbus_type_writer_recurse (&variant_writer, type, NULL, 0,
5352  &inner_writer))
5353  goto oom;
5354 
5355  if (!_dbus_type_writer_write_reader (&inner_writer,
5356  &real_inner_reader->u.reader))
5357  goto oom;
5358 
5359  if (!_dbus_type_writer_unrecurse (&variant_writer, &inner_writer))
5360  goto oom;
5361  }
5362  else
5363  {
5364  DBusBasicValue value;
5365 
5366  /* We eliminated all the container types above */
5368 
5369  dbus_message_iter_get_basic (reader, &value);
5370 
5371  if (!_dbus_type_writer_write_basic (&variant_writer, type, &value))
5372  goto oom;
5373  }
5374 
5375  _dbus_string_free (&contained_signature);
5376  return self;
5377 
5378 oom:
5379  if (self != NULL)
5380  {
5381  if (data_inited)
5382  _dbus_string_free (&self->data);
5383 
5384  dbus_free (self);
5385  }
5386 
5387  _dbus_string_free (&contained_signature);
5388  return NULL;
5389 }
5390 
5397 const char *
5399 {
5400  unsigned char len;
5401  const char *ret;
5402 
5403  _dbus_assert (self != NULL);
5404 
5405  /* Here we make use of the fact that the serialization of a variant starts
5406  * with the 1-byte length, then that many bytes of signature, then \0. */
5407  len = _dbus_string_get_byte (&self->data, 0);
5408  ret = _dbus_string_get_const_data_len (&self->data, 1, len);
5409  _dbus_assert (strlen (ret) == len);
5410  return ret;
5411 }
5412 
5426  DBusMessageIter *writer)
5427 {
5428  /* 'v' */
5429  DBusString variant_signature;
5430  /* Points to the single item in self */
5431  DBusTypeReader variant_reader;
5432  /* Points to the single item (of whatever type) inside the variant */
5433  DBusTypeReader reader;
5434  /* The position at which we will copy reader */
5435  DBusMessageRealIter *real_writer = (DBusMessageRealIter *) writer;
5436  dbus_bool_t ret;
5437 
5438  _dbus_assert (self != NULL);
5439  _dbus_assert (_dbus_message_iter_append_check (real_writer));
5440  _dbus_assert (real_writer->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
5441 
5443  _dbus_type_reader_init (&reader, DBUS_COMPILER_BYTE_ORDER,
5444  &variant_signature, 0, &self->data, 0);
5445  _dbus_type_reader_recurse (&reader, &variant_reader);
5446 
5447  if (!_dbus_message_iter_open_signature (real_writer))
5448  return FALSE;
5449 
5450  ret = _dbus_type_writer_write_reader (&real_writer->u.writer,
5451  &variant_reader);
5452 
5453  if (!_dbus_message_iter_close_signature (real_writer))
5454  return FALSE;
5455 
5456  return ret;
5457 }
5458 
5459 int
5460 _dbus_variant_get_length (DBusVariant *self)
5461 {
5462  _dbus_assert (self != NULL);
5463  return _dbus_string_get_length (&self->data);
5464 }
5465 
5466 const DBusString *
5467 _dbus_variant_peek (DBusVariant *self)
5468 {
5469  _dbus_assert (self != NULL);
5470  return &self->data;
5471 }
5472 
5473 void
5474 _dbus_variant_free (DBusVariant *self)
5475 {
5476  _dbus_assert (self != NULL);
5477  _dbus_string_free (&self->data);
5478  dbus_free (self);
5479 }
5480 
5483 /* tests in dbus-message-util.c */
DBUS_TYPE_ARRAY
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
Definition: dbus-protocol.h:120
_dbus_data_slot_list_clear
void _dbus_data_slot_list_clear(DBusDataSlotList *list)
Frees all data slots contained in the list, calling application-provided free functions if they exist...
Definition: dbus-dataslot.c:317
_dbus_atomic_dec
dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
Definition: dbus-sysdeps-unix.c:2847
DBUS_TYPE_STRING
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
Definition: dbus-protocol.h:102
dbus_message_set_no_reply
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,...
Definition: dbus-message.c:3214
_dbus_data_slot_list_get
void * _dbus_data_slot_list_get(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot)
Retrieves data previously set with _dbus_data_slot_list_set_data().
Definition: dbus-dataslot.c:285
dbus_message_set_interface
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...
Definition: dbus-message.c:3428
dbus_message_get_allow_interactive_authorization
dbus_bool_t dbus_message_get_allow_interactive_authorization(DBusMessage *message)
Returns whether the flag controlled by dbus_message_set_allow_interactive_authorization() has been se...
Definition: dbus-message.c:5231
DBusMessageLoader::messages
DBusList * messages
Complete messages.
Definition: dbus-message-private.h:66
_dbus_type_reader_next
dbus_bool_t _dbus_type_reader_next(DBusTypeReader *reader)
Skip to the next value on this "level".
Definition: dbus-marshal-recursive.c:1055
DBusHeader::data
DBusString data
Header network data, stored separately from body so we can independently realloc it.
Definition: dbus-marshal-header.h:49
MAX_MESSAGE_SIZE_TO_CACHE
#define MAX_MESSAGE_SIZE_TO_CACHE
Avoid caching huge messages.
Definition: dbus-message.c:484
DBusValidationMode
DBusValidationMode
This is used rather than a bool for high visibility.
Definition: dbus-marshal-validate.h:36
DBUS_TYPE_INVALID
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
Definition: dbus-protocol.h:60
DBUS_VALID
@ DBUS_VALID
the data is valid
Definition: dbus-marshal-validate.h:56
dbus_realloc
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:602
dbus_message_iter_close_container
dbus_bool_t dbus_message_iter_close_container(DBusMessageIter *iter, DBusMessageIter *sub)
Closes a container-typed value appended to the message; may write out more information to the message...
Definition: dbus-message.c:3056
_dbus_list_find_last
DBusList * _dbus_list_find_last(DBusList **list, void *data)
Finds a value in the list.
Definition: dbus-list.c:472
_dbus_message_loader_get_corruption_reason
DBusValidity _dbus_message_loader_get_corruption_reason(DBusMessageLoader *loader)
Checks what kind of bad data confused the loader.
Definition: dbus-message.c:4747
_dbus_header_update_lengths
void _dbus_header_update_lengths(DBusHeader *header, int body_len)
Fills in the correct body length.
Definition: dbus-marshal-header.c:1196
_dbus_verbose_bytes_of_string
DBUS_PRIVATE_EXPORT void _dbus_verbose_bytes_of_string(const DBusString *str, int start, int len)
Dump the given part of the string to verbose log.
Definition: dbus-marshal-basic.c:1362
dbus_message_ref
DBusMessage * dbus_message_ref(DBusMessage *message)
Increments the reference count of a DBusMessage.
Definition: dbus-message.c:1689
_dbus_list_remove_link
void _dbus_list_remove_link(DBusList **list, DBusList *link)
Removes a link from the list.
Definition: dbus-list.c:527
_dbus_message_loader_set_max_message_unix_fds
void _dbus_message_loader_set_max_message_unix_fds(DBusMessageLoader *loader, long n)
Sets the maximum unix fds per message we allow.
Definition: dbus-message.c:4793
_dbus_type_writer_init_values_only
void _dbus_type_writer_init_values_only(DBusTypeWriter *writer, int byte_order, const DBusString *type_str, int type_pos, DBusString *value_str, int value_pos)
Like _dbus_type_writer_init(), except the type string passed in should correspond to an existing sign...
Definition: dbus-marshal-recursive.c:1585
dbus_message_is_method_call
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.
Definition: dbus-message.c:3832
dbus_message_set_allow_interactive_authorization
void dbus_message_set_allow_interactive_authorization(DBusMessage *message, dbus_bool_t allow)
Sets a flag indicating that the caller of the method is prepared to wait for interactive authorizatio...
Definition: dbus-message.c:5213
DBusMessageRealIter::sig_refcount
dbus_uint32_t sig_refcount
depth of open_signature()
Definition: dbus-message.c:131
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
_dbus_current_generation
int _dbus_current_generation
_dbus_current_generation is used to track each time that dbus_shutdown() is called,...
Definition: dbus-memory.c:782
dbus_message_iter_append_fixed_array
dbus_bool_t dbus_message_iter_append_fixed_array(DBusMessageIter *iter, int element_type, const void *value, int n_elements)
Appends a block of fixed-length values to an array.
Definition: dbus-message.c:2889
_dbus_list_append_link
void _dbus_list_append_link(DBusList **list, DBusList *link)
Appends a link to the list.
Definition: dbus-list.c:315
dbus_message_get_path
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...
Definition: dbus-message.c:3326
_dbus_message_loader_queue_messages
dbus_bool_t _dbus_message_loader_queue_messages(DBusMessageLoader *loader)
Converts buffered data into messages, if we have enough data.
Definition: dbus-message.c:4611
dbus_message_iter_open_container
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.
Definition: dbus-message.c:2953
DBusMessageRealIter::u
union DBusMessageRealIter::@6 u
the type writer or reader that does all the work
_dbus_message_loader_get_pending_fds_count
int _dbus_message_loader_get_pending_fds_count(DBusMessageLoader *loader)
Return how many file descriptors are pending in the loader.
Definition: dbus-message.c:4823
_dbus_message_get_unix_fds
void _dbus_message_get_unix_fds(DBusMessage *message, const int **fds, unsigned *n_fds)
Gets the unix fds to be sent over the network for this message.
Definition: dbus-message.c:250
_dbus_list_clear
void _dbus_list_clear(DBusList **list)
Frees all links in the list and sets the list head to NULL.
Definition: dbus-list.c:542
dbus_message_demarshal_bytes_needed
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.
Definition: dbus-message.c:5153
dbus_message_unref
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0.
Definition: dbus-message.c:1712
dbus_message_new_method_return
DBusMessage * dbus_message_new_method_return(DBusMessage *method_call)
Constructs a message that is a reply to a method call.
Definition: dbus-message.c:1395
DBUS_HEADER_FIELD_SENDER
#define DBUS_HEADER_FIELD_SENDER
Header field code for the sender of a message; usually initialized by the message bus.
Definition: dbus-protocol.h:293
DBUS_TYPE_UNIX_FD
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
Definition: dbus-protocol.h:114
_dbus_string_compact
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
Definition: dbus-string.c:389
_dbus_type_writer_recurse
dbus_bool_t _dbus_type_writer_recurse(DBusTypeWriter *writer, int container_type, const DBusString *contained_type, int contained_type_start, DBusTypeWriter *sub)
Opens a new container and writes out the initial information for that container.
Definition: dbus-marshal-recursive.c:2110
_dbus_type_reader_has_next
dbus_bool_t _dbus_type_reader_has_next(const DBusTypeReader *reader)
Check whether there's another value on this "level".
Definition: dbus-marshal-recursive.c:1095
_dbus_message_add_counter
dbus_bool_t _dbus_message_add_counter(DBusMessage *message, DBusCounter *counter)
Adds a counter to be incremented immediately with the size/unix fds of this message,...
Definition: dbus-message.c:352
DBusMessageLoader::buffer_outstanding
unsigned int buffer_outstanding
Someone is using the buffer to read.
Definition: dbus-message-private.h:75
DBusMessageLoader::max_message_size
long max_message_size
Maximum size of a message.
Definition: dbus-message-private.h:68
_dbus_type_reader_get_element_type
int _dbus_type_reader_get_element_type(const DBusTypeReader *reader)
Gets the type of an element of the array the reader is currently pointing to.
Definition: dbus-marshal-recursive.c:821
DBUS_TYPE_VARIANT_AS_STRING
#define DBUS_TYPE_VARIANT_AS_STRING
DBUS_TYPE_VARIANT as a string literal instead of a int literal
Definition: dbus-protocol.h:126
DBusFreeFunction
void(* DBusFreeFunction)(void *memory)
Definition: dbus-memory.h:63
DBUS_HEADER_FIELD_PATH
#define DBUS_HEADER_FIELD_PATH
Header field code for the path - the path is the object emitting a signal or the object receiving a m...
Definition: dbus-protocol.h:270
dbus_message_type_to_string
const char * dbus_message_type_to_string(int type)
Utility function to convert a D-Bus message type into a machine-readable string (not translated).
Definition: dbus-message.c:5000
dbus_message_get_args_valist
dbus_bool_t dbus_message_get_args_valist(DBusMessage *message, DBusError *error, int first_arg_type, va_list var_args)
Like dbus_message_get_args but takes a va_list for use by language bindings.
Definition: dbus-message.c:2038
dbus_message_contains_unix_fds
dbus_bool_t dbus_message_contains_unix_fds(DBusMessage *message)
Checks whether a message contains unix fds.
Definition: dbus-message.c:4055
_dbus_list_alloc_link
DBusList * _dbus_list_alloc_link(void *data)
Allocates a linked list node.
Definition: dbus-list.c:242
_dbus_counter_unref
void _dbus_counter_unref(DBusCounter *counter)
Decrements refcount of the counter and possibly finalizes the counter.
Definition: dbus-resources.c:136
_dbus_type_writer_init_types_delayed
void _dbus_type_writer_init_types_delayed(DBusTypeWriter *writer, int byte_order, DBusString *value_str, int value_pos)
Initialize a write iterator, with the signature to be provided later.
Definition: dbus-marshal-recursive.c:1529
_dbus_header_set_serial
void _dbus_header_set_serial(DBusHeader *header, dbus_uint32_t serial)
Sets the serial number of a header.
Definition: dbus-marshal-header.c:404
_dbus_string_copy
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:1283
DBusTypeWriter::type_str
DBusString * type_str
where to write typecodes (or read type expectations)
Definition: dbus-marshal-recursive.h:74
DBusMessageLoader::corruption_reason
DBusValidity corruption_reason
why we were corrupted
Definition: dbus-message-private.h:71
DBusTypeReader::byte_order
dbus_uint32_t byte_order
byte order of the block
Definition: dbus-marshal-recursive.h:41
_dbus_message_loader_putback_message_link
void _dbus_message_loader_putback_message_link(DBusMessageLoader *loader, DBusList *link)
Returns a popped message link, used to undo a pop.
Definition: dbus-message.c:4717
_dbus_type_reader_read_basic
void _dbus_type_reader_read_basic(const DBusTypeReader *reader, void *value)
Reads a basic-typed value, as with _dbus_marshal_read_basic().
Definition: dbus-marshal-recursive.c:870
_dbus_counter_adjust_unix_fd
void _dbus_counter_adjust_unix_fd(DBusCounter *counter, long delta)
Adjusts the value of the unix fd counter by the given delta which may be positive or negative.
Definition: dbus-resources.c:236
_dbus_message_remove_counter
void _dbus_message_remove_counter(DBusMessage *message, DBusCounter *counter)
Removes a counter tracking the size/unix fds of this message, and decrements the counter by the size/...
Definition: dbus-message.c:375
DBusMessageLoader::corrupted
unsigned int corrupted
We got broken data, and are no longer working.
Definition: dbus-message-private.h:73
_dbus_header_delete_field
dbus_bool_t _dbus_header_delete_field(DBusHeader *header, int field)
Deletes a field, if it exists.
Definition: dbus-marshal-header.c:1416
dbus_message_new
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type.
Definition: dbus-message.c:1311
_dbus_header_get_serial
dbus_uint32_t _dbus_header_get_serial(DBusHeader *header)
See dbus_message_get_serial()
Definition: dbus-marshal-header.c:427
_dbus_type_get_alignment
int _dbus_type_get_alignment(int typecode)
Gets the alignment requirement for the given type; will be 1, 4, or 8.
Definition: dbus-marshal-basic.c:1177
_dbus_validate_body_with_reason
DBusValidity _dbus_validate_body_with_reason(const DBusString *expected_signature, int expected_signature_start, int byte_order, int *bytes_remaining, const DBusString *value_str, int value_pos, int len)
Verifies that the range of value_str from value_pos to value_end is a legitimate value of type expect...
Definition: dbus-marshal-validate.c:708
dbus_message_iter_init
dbus_bool_t dbus_message_iter_init(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for reading the arguments of the message passed in.
Definition: dbus-message.c:2107
DBUS_MESSAGE_TYPE_METHOD_CALL
#define DBUS_MESSAGE_TYPE_METHOD_CALL
Message type of a method call message, see dbus_message_get_type()
Definition: dbus-protocol.h:234
dbus_error_init
void dbus_error_init(DBusError *error)
Initializes a DBusError structure.
Definition: dbus-errors.c:188
dbus_message_has_interface
dbus_bool_t dbus_message_has_interface(DBusMessage *message, const char *iface)
Checks if the message has an interface.
Definition: dbus-message.c:3479
DBusHeader
Message header data and some cached details of it.
Definition: dbus-marshal-header.h:47
_dbus_message_loader_set_max_message_size
void _dbus_message_loader_set_max_message_size(DBusMessageLoader *loader, long size)
Sets the maximum size message we allow.
Definition: dbus-message.c:4762
_dbus_string_append_len
dbus_bool_t _dbus_string_append_len(DBusString *str, const char *buffer, int len)
Appends block of bytes with the given length to a DBusString.
Definition: dbus-string.c:1137
_dbus_message_loader_ref
DBusMessageLoader * _dbus_message_loader_ref(DBusMessageLoader *loader)
Increments the reference count of the loader.
Definition: dbus-message.c:4141
DBusMessage::locked
unsigned int locked
Message being sent, no modifications allowed.
Definition: dbus-message-private.h:107
_dbus_message_loader_set_pending_fds_function
void _dbus_message_loader_set_pending_fds_function(DBusMessageLoader *loader, void(*callback)(void *), void *data)
Register a function to be called whenever the number of pending file descriptors in the loader change...
Definition: dbus-message.c:4841
dbus_message_set_error_name
dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *error_name)
Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR).
Definition: dbus-message.c:3601
_dbus_header_load
dbus_bool_t _dbus_header_load(DBusHeader *header, DBusValidationMode mode, DBusValidity *validity, int byte_order, int fields_array_len, int header_len, int body_len, const DBusString *str, int start, int len)
Creates a message header from potentially-untrusted data.
Definition: dbus-marshal-header.c:970
DBUS_HEADER_FIELD_SIGNATURE
#define DBUS_HEADER_FIELD_SIGNATURE
Header field code for the type signature of a message.
Definition: dbus-protocol.h:297
_dbus_message_iter_get_args_valist
DBUS_PRIVATE_EXPORT 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:814
_dbus_header_get_byte_order
char _dbus_header_get_byte_order(const DBusHeader *header)
Returns the header's byte order.
Definition: dbus-marshal-header.c:174
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
dbus_message_iter_init_closed
void dbus_message_iter_init_closed(DBusMessageIter *iter)
Initialize iter as if with DBUS_MESSAGE_ITER_INIT_CLOSED.
Definition: dbus-message.c:731
_dbus_string_append_printf_valist
dbus_bool_t _dbus_string_append_printf_valist(DBusString *str, const char *format, va_list args)
Appends a printf-style formatted string to the DBusString.
Definition: dbus-string.c:1072
_dbus_atomic_get
dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
Definition: dbus-sysdeps-unix.c:2871
DBUS_MAXIMUM_MESSAGE_LENGTH
#define DBUS_MAXIMUM_MESSAGE_LENGTH
The maximum total message size including header and body; similar rationale to max array size.
Definition: dbus-protocol.h:210
_dbus_message_loader_get_max_message_size
long _dbus_message_loader_get_max_message_size(DBusMessageLoader *loader)
Gets the maximum allowed message size in bytes.
Definition: dbus-message.c:4781
_dbus_header_get_message_type
int _dbus_header_get_message_type(DBusHeader *header)
Gets the type of the message.
Definition: dbus-marshal-header.c:386
_dbus_type_writer_add_types
void _dbus_type_writer_add_types(DBusTypeWriter *writer, DBusString *type_str, int type_pos)
Adds type string to the writer, if it had none.
Definition: dbus-marshal-recursive.c:1547
_DBUS_LOCK
#define _DBUS_LOCK(name)
Definition: dbus-internals.h:372
_dbus_variant_write
dbus_bool_t _dbus_variant_write(DBusVariant *self, DBusMessageIter *writer)
Copy the single D-Bus message item from self into writer.
Definition: dbus-message.c:5425
dbus_message_allocate_data_slot
dbus_bool_t dbus_message_allocate_data_slot(dbus_int32_t *slot_p)
Allocates an integer ID to be used for storing application-specific data on any DBusMessage.
Definition: dbus-message.c:4869
dbus_message_iter_has_next
dbus_bool_t dbus_message_iter_has_next(DBusMessageIter *iter)
Checks if an iterator has any more fields.
Definition: dbus-message.c:2138
DBusMessageLoader::refcount
int refcount
Reference count.
Definition: dbus-message-private.h:62
_dbus_dup
int _dbus_dup(int fd, DBusError *error)
Duplicates a file descriptor.
Definition: dbus-sysdeps-unix.c:3312
dbus_message_get_error_name
const char * dbus_message_get_error_name(DBusMessage *message)
Gets the error name (DBUS_MESSAGE_TYPE_ERROR only) or NULL if none.
Definition: dbus-message.c:3627
TRUE
#define TRUE
dbus_message_iter_get_element_type
int dbus_message_iter_get_element_type(DBusMessageIter *iter)
Returns the element type of the array that the message iterator points to.
Definition: dbus-message.c:2201
_dbus_list_pop_first_link
DBusList * _dbus_list_pop_first_link(DBusList **list)
Removes the first link in the list and returns it.
Definition: dbus-list.c:628
_dbus_list_append
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
Definition: dbus-list.c:270
_dbus_message_loader_get_is_corrupted
dbus_bool_t _dbus_message_loader_get_is_corrupted(DBusMessageLoader *loader)
Checks whether the loader is confused due to bad data.
Definition: dbus-message.c:4733
DBUS_MINIMUM_HEADER_SIZE
#define DBUS_MINIMUM_HEADER_SIZE
The smallest header size that can occur.
Definition: dbus-protocol.h:346
dbus_message_iter_abandon_container
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...
Definition: dbus-message.c:3090
dbus_message_set_reply_serial
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).
Definition: dbus-message.c:1161
dbus_message_is_error
dbus_bool_t dbus_message_is_error(DBusMessage *message, const char *error_name)
Checks whether the message is an error reply with the given error name.
Definition: dbus-message.c:3887
dbus_message_get_args
dbus_bool_t dbus_message_get_args(DBusMessage *message, DBusError *error, int first_arg_type,...)
Gets arguments from a message given a variable argument list.
Definition: dbus-message.c:2009
dbus_message_has_path
dbus_bool_t dbus_message_has_path(DBusMessage *message, const char *path)
Checks if the message has a particular object path.
Definition: dbus-message.c:3350
dbus_message_has_sender
dbus_bool_t dbus_message_has_sender(DBusMessage *message, const char *name)
Checks whether the message has the given unique name as its sender.
Definition: dbus-message.c:3955
DBusMessage::slot_list
DBusDataSlotList slot_list
Data stored by allocated integer ID.
Definition: dbus-message-private.h:118
_dbus_data_slot_list_set
dbus_bool_t _dbus_data_slot_list_set(DBusDataSlotAllocator *allocator, DBusDataSlotList *list, int slot, void *data, DBusFreeFunction free_data_func, DBusFreeFunction *old_free_func, void **old_data)
Stores a pointer in the data slot list, along with an optional function to be used for freeing the da...
Definition: dbus-dataslot.c:221
dbus_message_iter_get_basic
void dbus_message_iter_get_basic(DBusMessageIter *iter, void *value)
Reads a basic-typed value from the message iterator.
Definition: dbus-message.c:2336
DBusMessage::size_counter_delta
long size_counter_delta
Size we incremented the size counters by.
Definition: dbus-message-private.h:114
_dbus_counter_adjust_size
void _dbus_counter_adjust_size(DBusCounter *counter, long delta)
Adjusts the value of the size counter by the given delta which may be positive or negative.
Definition: dbus-resources.c:167
dbus_message_iter_append_basic
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
Definition: dbus-message.c:2738
DBusTypeReader
The type reader is an iterator for reading values from a block of values.
Definition: dbus-marshal-recursive.h:39
dbus_message_iter_get_arg_type
int dbus_message_iter_get_arg_type(DBusMessageIter *iter)
Returns the argument type of the argument that the message iterator points to.
Definition: dbus-message.c:2182
DBUS_TYPE_SIGNATURE
#define DBUS_TYPE_SIGNATURE
Type code marking a D-Bus type signature.
Definition: dbus-protocol.h:110
_dbus_header_toggle_flag
void _dbus_header_toggle_flag(DBusHeader *header, dbus_uint32_t flag, dbus_bool_t value)
Toggles a message flag bit, turning on the bit if value = TRUE and flipping it off if value = FALSE.
Definition: dbus-marshal-header.c:1457
dbus_message_get_signature
const char * dbus_message_get_signature(DBusMessage *message)
Gets the type signature of the message, i.e.
Definition: dbus-message.c:3773
dbus_free
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:702
DBUS_HEADER_FLAG_NO_AUTO_START
#define DBUS_HEADER_FLAG_NO_AUTO_START
If set, this flag means that even if the message bus knows how to start an owner for the destination ...
Definition: dbus-protocol.h:256
INITIAL_LOADER_DATA_LEN
#define INITIAL_LOADER_DATA_LEN
The initial buffer size of the message loader.
Definition: dbus-message.c:4084
DBusTypeWriter::container_type
dbus_uint32_t container_type
what are we inside? (e.g.
Definition: dbus-marshal-recursive.h:68
_dbus_decompose_path
dbus_bool_t _dbus_decompose_path(const char *data, int len, char ***path, int *path_len)
Decompose an object path.
Definition: dbus-object-tree.c:1244
_DBUS_LOCK_NAME
#define _DBUS_LOCK_NAME(name)
Definition: dbus-internals.h:371
dbus_message_set_destination
dbus_bool_t dbus_message_set_destination(DBusMessage *message, const char *destination)
Sets the message's destination.
Definition: dbus-message.c:3655
_dbus_string_init_preallocated
dbus_bool_t _dbus_string_init_preallocated(DBusString *str, int allocate_size)
Initializes a string that can be up to the given allocation size before it has to realloc.
Definition: dbus-string.c:132
DBUS_ERROR_INCONSISTENT_MESSAGE
#define DBUS_ERROR_INCONSISTENT_MESSAGE
The message meta data does not match the payload.
Definition: dbus-protocol.h:453
MAX_MESSAGE_CACHE_SIZE
#define MAX_MESSAGE_CACHE_SIZE
Avoid caching too many messages.
Definition: dbus-message.c:487
_dbus_register_shutdown_func
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_register_shutdown_func(DBusShutdownFunction function, void *data)
Register a cleanup function to be called exactly once the next time dbus_shutdown() is called.
Definition: dbus-memory.c:811
DBusString
Definition: dbus-string.h:42
DBUS_HEADER_FIELD_INTERFACE
#define DBUS_HEADER_FIELD_INTERFACE
Header field code for the interface containing a member (method or signal).
Definition: dbus-protocol.h:274
_dbus_counter_notify
void _dbus_counter_notify(DBusCounter *counter)
Calls the notify function from _dbus_counter_set_notify(), if that function has been specified and th...
Definition: dbus-resources.c:207
_dbus_message_add_counter_link
void _dbus_message_add_counter_link(DBusMessage *message, DBusList *link)
Adds a counter to be incremented immediately with the size/unix fds of this message,...
Definition: dbus-message.c:303
dbus_message_set_sender
dbus_bool_t dbus_message_set_sender(DBusMessage *message, const char *sender)
Sets the message sender.
Definition: dbus-message.c:3709
dbus_message_get_data
void * dbus_message_get_data(DBusMessage *message, dbus_int32_t slot)
Retrieves data previously set with dbus_message_set_data().
Definition: dbus-message.c:4944
_dbus_message_loader_unref
void _dbus_message_loader_unref(DBusMessageLoader *loader)
Decrements the reference count of the loader and finalizes the loader when the count reaches zero.
Definition: dbus-message.c:4155
_dbus_type_reader_init
void _dbus_type_reader_init(DBusTypeReader *reader, int byte_order, const DBusString *type_str, int type_pos, const DBusString *value_str, int value_pos)
Initializes a type reader.
Definition: dbus-marshal-recursive.c:733
DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION
#define DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION
If set on a method call, this flag means that the caller is prepared to wait for interactive authoriz...
Definition: dbus-protocol.h:261
_dbus_message_loader_get_max_message_unix_fds
long _dbus_message_loader_get_max_message_unix_fds(DBusMessageLoader *loader)
Gets the maximum allowed number of unix fds per message.
Definition: dbus-message.c:4812
DBusMessage::generation
int generation
_dbus_current_generation when message was created
Definition: dbus-message-private.h:121
_dbus_type_writer_write_reader
dbus_bool_t _dbus_type_writer_write_reader(DBusTypeWriter *writer, DBusTypeReader *reader)
Iterate through all values in the given reader, writing a copy of each value to the writer.
Definition: dbus-marshal-recursive.c:2732
DBUS_MESSAGE_TYPE_SIGNAL
#define DBUS_MESSAGE_TYPE_SIGNAL
Message type of a signal message, see dbus_message_get_type()
Definition: dbus-protocol.h:240
_dbus_list_pop_first
void * _dbus_list_pop_first(DBusList **list)
Removes the first value in the list and returns it.
Definition: dbus-list.c:649
dbus_message_iter_init_append
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
Definition: dbus-message.c:2500
DBUS_TYPE_STRUCT
#define DBUS_TYPE_STRUCT
STRUCT and DICT_ENTRY are sort of special since their codes can't appear in a type string,...
Definition: dbus-protocol.h:136
DBUS_TYPE_DICT_ENTRY
#define DBUS_TYPE_DICT_ENTRY
Type code used to represent a dict entry; however, this type code does not appear in type signatures,...
Definition: dbus-protocol.h:143
DBusBasicValue::u32
dbus_uint32_t u32
as int32
Definition: dbus-types.h:143
_dbus_header_get_flag
dbus_bool_t _dbus_header_get_flag(DBusHeader *header, dbus_uint32_t flag)
Gets a message flag bit, returning TRUE if the bit is set.
Definition: dbus-marshal-header.c:1479
_dbus_data_slot_list_init
void _dbus_data_slot_list_init(DBusDataSlotList *list)
Initializes a slot list.
Definition: dbus-dataslot.c:197
DBUS_MAXIMUM_MESSAGE_UNIX_FDS
#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS
The maximum total number of unix fds in a message.
Definition: dbus-protocol.h:218
_dbus_type_reader_get_current_type
int _dbus_type_reader_get_current_type(const DBusTypeReader *reader)
Gets the type of the value the reader is currently pointing to; or for a types-only reader gets the t...
Definition: dbus-marshal-recursive.c:786
_DBUS_STRING_DEFINE_STATIC
_DBUS_STRING_DEFINE_STATIC(_dbus_empty_signature_str, "")
An static string representing an empty signature.
_dbus_list_remove_last
dbus_bool_t _dbus_list_remove_last(DBusList **list, void *data)
Removes a value from the list.
Definition: dbus-list.c:446
dbus_message_set_path
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...
Definition: dbus-message.c:3297
dbus_message_has_signature
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...
Definition: dbus-message.c:3984
_dbus_data_slot_allocator_alloc
dbus_bool_t _dbus_data_slot_allocator_alloc(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Allocates an integer ID to be used for storing data in a DBusDataSlotList.
Definition: dbus-dataslot.c:69
DBusVariant
An opaque data structure containing the serialized form of any single D-Bus message item,...
Definition: dbus-message.c:5245
FALSE
#define FALSE
DBusMessage::refcount
DBusAtomic refcount
Reference count.
Definition: dbus-message-private.h:101
_dbus_data_slot_list_free
void _dbus_data_slot_list_free(DBusDataSlotList *list)
Frees the data slot list and all data slots contained in it, calling application-provided free functi...
Definition: dbus-dataslot.c:340
_dbus_header_copy
dbus_bool_t _dbus_header_copy(const DBusHeader *header, DBusHeader *dest)
Initializes dest with a copy of the given header.
Definition: dbus-marshal-header.c:490
_dbus_type_reader_read_fixed_multi
void _dbus_type_reader_read_fixed_multi(const DBusTypeReader *reader, void *value, int *n_elements)
Reads a block of fixed-length basic values, from the current point in an array to the end of the arra...
Definition: dbus-marshal-recursive.c:924
dbus_message_get_interface
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...
Definition: dbus-message.c:3457
dbus_message_has_destination
dbus_bool_t dbus_message_has_destination(DBusMessage *message, const char *name)
Checks whether the message was sent to the given name.
Definition: dbus-message.c:3920
dbus_message_get_destination
const char * dbus_message_get_destination(DBusMessage *message)
Gets the destination of a message or NULL if there is none set.
Definition: dbus-message.c:3680
DBusMessage::in_cache
unsigned int in_cache
Has been "freed" since it's in the cache (this is a debug feature)
Definition: dbus-message-private.h:110
DBusMessage
Internals of DBusMessage.
Definition: dbus-message-private.h:99
DBusList::data
void * data
Data stored at this element.
Definition: dbus-list.h:38
dbus_message_iter_abandon_container_if_open
void dbus_message_iter_abandon_container_if_open(DBusMessageIter *iter, DBusMessageIter *sub)
Abandons creation of a contained-typed value and frees resources created by dbus_message_iter_open_co...
Definition: dbus-message.c:3149
_dbus_string_delete
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
Definition: dbus-string.c:1193
dbus_message_get_sender
const char * dbus_message_get_sender(DBusMessage *message)
Gets the unique name of the connection which originated this message, or NULL if unknown or inapplica...
Definition: dbus-message.c:3740
DBUS_MESSAGE_TYPE_ERROR
#define DBUS_MESSAGE_TYPE_ERROR
Message type of an error reply message, see dbus_message_get_type()
Definition: dbus-protocol.h:238
dbus_message_new_error_printf
DBusMessage * dbus_message_new_error_printf(DBusMessage *reply_to, const char *error_name, const char *error_format,...)
Creates a new message that is an error reply to another message, allowing you to use printf formattin...
Definition: dbus-message.c:1564
_dbus_message_loader_get_buffer
void _dbus_message_loader_get_buffer(DBusMessageLoader *loader, DBusString **buffer, int *max_to_read, dbus_bool_t *may_read_fds)
Gets the buffer to use for reading data from the network.
Definition: dbus-message.c:4192
dbus_type_is_container
dbus_bool_t dbus_type_is_container(int typecode)
A "container type" can contain basic types, or nested container types.
Definition: dbus-signature.c:295
ensure_byte_order
#define ensure_byte_order(message)
byte-swap the message if it doesn't match our byte order.
Definition: dbus-message.c:218
DBUS_MESSAGE_TYPE_METHOD_RETURN
#define DBUS_MESSAGE_TYPE_METHOD_RETURN
Message type of a method return message, see dbus_message_get_type()
Definition: dbus-protocol.h:236
_dbus_assert_not_reached
#define _dbus_assert_not_reached(explanation)
Definition: dbus-internals.h:163
_dbus_header_have_message_untrusted
dbus_bool_t _dbus_header_have_message_untrusted(int max_message_length, DBusValidity *validity, int *byte_order, int *fields_array_len, int *header_len, int *body_len, const DBusString *str, int start, int len)
Given data long enough to contain the length of the message body and the fields array,...
Definition: dbus-marshal-header.c:673
_dbus_string_set_length
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:802
_dbus_header_get_field_raw
dbus_bool_t _dbus_header_get_field_raw(DBusHeader *header, int field, const DBusString **str, int *pos)
Gets the raw marshaled data for a field.
Definition: dbus-marshal-header.c:1392
_dbus_message_loader_peek_message
DBusMessage * _dbus_message_loader_peek_message(DBusMessageLoader *loader)
Peeks at first loaded message, returns NULL if no messages have been queued.
Definition: dbus-message.c:4674
_dbus_marshal_byteswap
void _dbus_marshal_byteswap(const DBusString *signature, int signature_start, int old_byte_order, int new_byte_order, DBusString *value_str, int value_pos)
Byteswaps the marshaled data in the given value_str.
Definition: dbus-marshal-byteswap.c:222
dbus_message_has_member
dbus_bool_t dbus_message_has_member(DBusMessage *message, const char *member)
Checks if the message has an interface member.
Definition: dbus-message.c:3565
DBUS_DICT_ENTRY_BEGIN_CHAR
#define DBUS_DICT_ENTRY_BEGIN_CHAR
Code marking the start of a dict entry type in a type signature.
Definition: dbus-protocol.h:164
dbus_type_is_fixed
dbus_bool_t dbus_type_is_fixed(int typecode)
Tells you whether values of this type can change length if you set them to some other value.
Definition: dbus-signature.c:350
dbus_message_get_reply_serial
dbus_uint32_t dbus_message_get_reply_serial(DBusMessage *message)
Returns the serial that the message is a reply to or 0 if none.
Definition: dbus-message.c:1185
dbus_message_get_serial
dbus_uint32_t dbus_message_get_serial(DBusMessage *message)
Returns the serial of a message or 0 if none has been specified.
Definition: dbus-message.c:1145
dbus_message_get_member
const char * dbus_message_get_member(DBusMessage *message)
Gets the interface member being invoked (DBUS_MESSAGE_TYPE_METHOD_CALL) or emitted (DBUS_MESSAGE_TYPE...
Definition: dbus-message.c:3543
_dbus_header_free
void _dbus_header_free(DBusHeader *header)
Frees a header.
Definition: dbus-marshal-header.c:476
_dbus_message_loader_new
DBusMessageLoader * _dbus_message_loader_new(void)
Creates a new message loader.
Definition: dbus-message.c:4093
DBusMessageRealIter::writer
DBusTypeWriter writer
writer
Definition: dbus-message.c:134
DBusMessage::counters
DBusList * counters
0-N DBusCounter used to track message size/unix fds.
Definition: dbus-message-private.h:113
DBUS_ERROR_INVALID_ARGS
#define DBUS_ERROR_INVALID_ARGS
Invalid arguments passed to a method call.
Definition: dbus-protocol.h:391
_dbus_list_foreach
void _dbus_list_foreach(DBusList **list, DBusForeachFunction function, void *data)
Calls the given function for each element in the list.
Definition: dbus-list.c:759
_dbus_type_writer_write_basic
dbus_bool_t _dbus_type_writer_write_basic(DBusTypeWriter *writer, int type, const void *value)
Writes out a basic type.
Definition: dbus-marshal-recursive.c:2312
DBusCounter
Internals of DBusCounter.
Definition: dbus-resources.c:54
DBUS_HEADER_FIELD_ERROR_NAME
#define DBUS_HEADER_FIELD_ERROR_NAME
Header field code for an error name (found in DBUS_MESSAGE_TYPE_ERROR messages).
Definition: dbus-protocol.h:280
dbus_message_get_auto_start
dbus_bool_t dbus_message_get_auto_start(DBusMessage *message)
Returns TRUE if the message will cause an owner for destination name to be auto-started.
Definition: dbus-message.c:3275
DBusMessageLoader::data
DBusString data
Buffered data.
Definition: dbus-message-private.h:64
_dbus_header_get_field_basic
dbus_bool_t _dbus_header_get_field_basic(DBusHeader *header, int field, int type, void *value)
Gets the value of a field with basic type.
Definition: dbus-marshal-header.c:1351
DBUS_MESSAGE_TYPE_INVALID
#define DBUS_MESSAGE_TYPE_INVALID
This value is never a valid message type, see dbus_message_get_type()
Definition: dbus-protocol.h:232
DBUS_VALIDITY_UNKNOWN_OOM_ERROR
@ DBUS_VALIDITY_UNKNOWN_OOM_ERROR
can't determine validity due to OOM
Definition: dbus-marshal-validate.h:52
dbus_new
#define dbus_new(type, count)
Definition: dbus-memory.h:57
DBUS_TYPE_BOOLEAN
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
Definition: dbus-protocol.h:70
_dbus_list_prepend_link
void _dbus_list_prepend_link(DBusList **list, DBusList *link)
Prepends a link to the list.
Definition: dbus-list.c:333
dbus_message_set_data
dbus_bool_t dbus_message_set_data(DBusMessage *message, dbus_int32_t slot, void *data, DBusFreeFunction free_data_func)
Stores a pointer on a DBusMessage, along with an optional function to be used for freeing the data wh...
Definition: dbus-message.c:4908
_dbus_type_reader_get_array_length
int _dbus_type_reader_get_array_length(const DBusTypeReader *reader)
Returns the number of bytes in the array.
Definition: dbus-marshal-recursive.c:900
_dbus_assert
#define _dbus_assert(condition)
Definition: dbus-internals.h:152
dbus_error_free
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
_dbus_close
dbus_bool_t _dbus_close(int fd, DBusError *error)
Closes a file descriptor.
Definition: dbus-sysdeps-unix.c:3284
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition: dbus-internals.c:230
dbus_message_iter_get_fixed_array
void dbus_message_iter_get_fixed_array(DBusMessageIter *iter, void *value, int *n_elements)
Reads a block of fixed-length values from the message iterator.
Definition: dbus-message.c:2470
DBUS_TYPE_OBJECT_PATH
#define DBUS_TYPE_OBJECT_PATH
Type code marking a D-Bus object path.
Definition: dbus-protocol.h:106
_dbus_strdup
char * _dbus_strdup(const char *str)
Duplicates a string.
Definition: dbus-internals.c:536
DBusMessage::header
DBusHeader header
Header network data and associated cache.
Definition: dbus-message-private.h:103
dbus_message_is_signal
dbus_bool_t dbus_message_is_signal(DBusMessage *message, const char *iface, const char *signal_name)
Checks whether the message is a signal with the given interface and member fields.
Definition: dbus-message.c:3860
_dbus_getenv
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:187
DBUS_TYPE_VARIANT
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type.
Definition: dbus-protocol.h:124
DBusError
Object representing an exception.
Definition: dbus-errors.h:48
DBusMessageIter
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:61
_dbus_header_byteswap
void _dbus_header_byteswap(DBusHeader *header, int new_order)
Swaps the header into the given order if required.
Definition: dbus-marshal-header.c:1496
DBusDataSlotAllocator
An allocator that tracks a set of slot IDs.
Definition: dbus-dataslot.h:55
dbus_message_append_args
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
Definition: dbus-message.c:1820
DBUS_HEADER_FIELD_MEMBER
#define DBUS_HEADER_FIELD_MEMBER
Header field code for a member (method or signal).
Definition: dbus-protocol.h:276
dbus_message_iter_next
dbus_bool_t dbus_message_iter_next(DBusMessageIter *iter)
Moves the iterator to the next field, if any.
Definition: dbus-message.c:2157
DBusBasicValue
A simple value union that lets you access bytes as if they were various types; useful when dealing wi...
Definition: dbus-types.h:137
dbus_message_marshal
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.
Definition: dbus-message.c:5030
_dbus_message_get_network_data
void _dbus_message_get_network_data(DBusMessage *message, const DBusString **header, const DBusString **body)
Gets the data to be sent over the network for this message.
Definition: dbus-message.c:231
_dbus_type_writer_unrecurse
dbus_bool_t _dbus_type_writer_unrecurse(DBusTypeWriter *writer, DBusTypeWriter *sub)
Closes a container created by _dbus_type_writer_recurse() and writes any additional information to th...
Definition: dbus-marshal-recursive.c:2180
DBusList
Definition: dbus-list.h:34
_dbus_data_slot_allocator_free
void _dbus_data_slot_allocator_free(DBusDataSlotAllocator *allocator, dbus_int32_t *slot_id_p)
Deallocates an ID previously allocated with _dbus_data_slot_allocator_alloc().
Definition: dbus-dataslot.c:154
dbus_message_iter_recurse
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...
Definition: dbus-message.c:2238
CHANGED_STAMP_BITS
#define CHANGED_STAMP_BITS
How many bits are in the changed_stamp used to validate iterators.
Definition: dbus-message-private.h:90
DBusMessageRealIter::message
DBusMessage * message
Message used.
Definition: dbus-message.c:128
dbus_message_set_serial
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.
Definition: dbus-message.c:277
_dbus_validate_signature_with_reason
DBusValidity _dbus_validate_signature_with_reason(const DBusString *type_str, int type_pos, int len)
Verifies that the range of type_str from type_pos to type_end is a valid signature.
Definition: dbus-marshal-validate.c:51
_dbus_message_loader_return_buffer
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...
Definition: dbus-message.c:4298
dbus_message_iter_get_signature
char * dbus_message_iter_get_signature(DBusMessageIter *iter)
Returns the current signature of a message iterator.
Definition: dbus-message.c:2263
dbus_set_error
void dbus_set_error(DBusError *error, const char *name, const char *format,...)
Assigns an error name and message to a DBusError.
Definition: dbus-errors.c:354
DBusForeachFunction
void(* DBusForeachFunction)(void *element, void *data)
Definition: dbus-internals.h:284
dbus_type_is_basic
dbus_bool_t dbus_type_is_basic(int typecode)
A "basic type" is a somewhat arbitrary concept, but the intent is to include those types that are ful...
Definition: dbus-signature.c:319
dbus_message_copy
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 ...
Definition: dbus-message.c:1609
dbus_free_string_array
void dbus_free_string_array(char **str_array)
Frees a NULL-terminated array of strings.
Definition: dbus-memory.c:750
_dbus_string_steal_data
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
Definition: dbus-string.c:641
dbus_message_get_no_reply
dbus_bool_t dbus_message_get_no_reply(DBusMessage *message)
Returns TRUE if the message does not expect a reply.
Definition: dbus-message.c:3233
_dbus_type_to_string
const char * _dbus_type_to_string(int typecode)
Returns a string describing the given type.
Definition: dbus-marshal-basic.c:1223
_dbus_variant_read
DBusVariant * _dbus_variant_read(DBusMessageIter *reader)
Copy a single D-Bus message item from reader into a newly-allocated DBusVariant.
Definition: dbus-message.c:5262
dbus_message_set_auto_start
void dbus_message_set_auto_start(DBusMessage *message, dbus_bool_t auto_start)
Sets a flag indicating that an owner for the destination name will be automatically started before th...
Definition: dbus-message.c:3256
DBusMessage::body
DBusString body
Body network data.
Definition: dbus-message-private.h:105
dbus_message_type_from_string
int dbus_message_type_from_string(const char *type_str)
Utility function to convert a machine-readable (not translated) string into a D-Bus message type.
Definition: dbus-message.c:4972
_dbus_counter_ref
DBusCounter * _dbus_counter_ref(DBusCounter *counter)
Increments refcount of the counter.
Definition: dbus-resources.c:116
dbus_message_iter_get_element_count
int dbus_message_iter_get_element_count(DBusMessageIter *iter)
Returns the number of elements in the array-typed value pointed to by the iterator.
Definition: dbus-message.c:2381
DBusMessageLoader::max_message_unix_fds
long max_message_unix_fds
Maximum unix fds in a message.
Definition: dbus-message-private.h:69
_dbus_type_writer_remove_types
void _dbus_type_writer_remove_types(DBusTypeWriter *writer)
Removes type string from the writer.
Definition: dbus-marshal-recursive.c:1564
DBusMessageRealIter::changed_stamp
dbus_uint32_t changed_stamp
stamp to detect invalid iters
Definition: dbus-message.c:129
_dbus_atomic_inc
dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
Definition: dbus-sysdeps-unix.c:2824
_dbus_message_loader_pop_message_link
DBusList * _dbus_message_loader_pop_message_link(DBusMessageLoader *loader)
Pops a loaded message inside a list link (passing ownership of the message and link to the caller).
Definition: dbus-message.c:4705
dbus_message_lock
void dbus_message_lock(DBusMessage *message)
Locks a message.
Definition: dbus-message.c:407
_dbus_type_reader_recurse
void _dbus_type_reader_recurse(DBusTypeReader *reader, DBusTypeReader *sub)
Initialize a new reader pointing to the first type and corresponding value that's a child of the curr...
Definition: dbus-marshal-recursive.c:989
dbus_message_free_data_slot
void dbus_message_free_data_slot(dbus_int32_t *slot_p)
Deallocates a global ID for message data slots.
Definition: dbus-message.c:4887
_DBUS_UNLOCK
#define _DBUS_UNLOCK(name)
Definition: dbus-internals.h:373
DBusMessageLoader
Implementation details of DBusMessageLoader.
Definition: dbus-message-private.h:60
DBUS_HEADER_FIELD_UNIX_FDS
#define DBUS_HEADER_FIELD_UNIX_FDS
Header field code for the number of unix file descriptors associated with this message.
Definition: dbus-protocol.h:302
dbus_message_get_type
int dbus_message_get_type(DBusMessage *message)
Gets the type of a message.
Definition: dbus-message.c:1744
DBusError::message
const char * message
public error message field
Definition: dbus-errors.h:51
_DBUS_ZERO
#define _DBUS_ZERO(object)
Definition: dbus-internals.h:193
_dbus_variant_get_signature
const char * _dbus_variant_get_signature(DBusVariant *self)
Return the signature of the item stored in self.
Definition: dbus-message.c:5398
dbus_message_new_signal
DBusMessage * dbus_message_new_signal(const char *path, const char *iface, const char *name)
Constructs a new message representing a signal emission.
Definition: dbus-message.c:1446
_dbus_string_init_const
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
DBUS_HEADER_FIELD_REPLY_SERIAL
#define DBUS_HEADER_FIELD_REPLY_SERIAL
Header field code for a reply serial, used to match a DBUS_MESSAGE_TYPE_METHOD_RETURN message with th...
Definition: dbus-protocol.h:284
_dbus_string_copy_len
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
Definition: dbus-string.c:1375
dbus_new0
#define dbus_new0(type, count)
Definition: dbus-memory.h:58
_dbus_type_reader_get_signature
void _dbus_type_reader_get_signature(const DBusTypeReader *reader, const DBusString **str_p, int *start_p, int *len_p)
Gets the string and range of said string containing the signature of the current value.
Definition: dbus-marshal-recursive.c:1126
DBusMessageRealIter
Internals of DBusMessageIter.
Definition: dbus-message.c:126
_dbus_memdup
void * _dbus_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
Definition: dbus-internals.c:564
DBusMessageIter_1_10_0
Layout of a DBusMessageIter on the stack in dbus 1.10.0.
Definition: dbus-message.c:144
dbus_message_new_error
DBusMessage * dbus_message_new_error(DBusMessage *reply_to, const char *error_name, const char *error_message)
Creates a new message that is an error reply to another message.
Definition: dbus-message.c:1492
dbus_message_demarshal
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.
Definition: dbus-message.c:5092
DBusMessageRealIter::iter_type
dbus_uint32_t iter_type
whether this is a reader or writer iter
Definition: dbus-message.c:130
_dbus_header_reinit
void _dbus_header_reinit(DBusHeader *header)
Re-initializes a header that was previously initialized and never freed.
Definition: dbus-marshal-header.c:443
dbus_message_new_method_call
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.
Definition: dbus-message.c:1355
DBusMessage::changed_stamp
dbus_uint32_t changed_stamp
Incremented when iterators are invalidated.
Definition: dbus-message-private.h:116
DBUS_ERROR_NOT_SUPPORTED
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn't supported (like ENOSYS on UNIX).
Definition: dbus-protocol.h:369
DBUS_TYPE_UINT32
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
Definition: dbus-protocol.h:86
_dbus_type_writer_write_fixed_multi
dbus_bool_t _dbus_type_writer_write_fixed_multi(DBusTypeWriter *writer, int element_type, const void *value, int n_elements)
Writes a block of fixed-length basic values, i.e.
Definition: dbus-marshal-recursive.c:2360
_dbus_header_create
dbus_bool_t _dbus_header_create(DBusHeader *header, int byte_order, int message_type, const char *destination, const char *path, const char *interface, const char *member, const char *error_name)
Fills in the primary fields of the header, so the header is ready for use.
Definition: dbus-marshal-header.c:528
DBUS_HEADER_FIELD_DESTINATION
#define DBUS_HEADER_FIELD_DESTINATION
Header field code for the destination bus name of a message.
Definition: dbus-protocol.h:288
DBusTypeWriter
The type writer is an iterator for writing to a block of values.
Definition: dbus-marshal-recursive.h:64
DBusMessageRealIter::reader
DBusTypeReader reader
reader
Definition: dbus-message.c:135
DBusTypeWriter::byte_order
dbus_uint32_t byte_order
byte order to write values with
Definition: dbus-marshal-recursive.h:66
dbus_message_append_args_valist
dbus_bool_t dbus_message_append_args_valist(DBusMessage *message, int first_arg_type, va_list var_args)
Like dbus_message_append_args() but takes a va_list for use by language bindings.
Definition: dbus-message.c:1852
_dbus_message_loader_pop_message
DBusMessage * _dbus_message_loader_pop_message(DBusMessageLoader *loader)
Pops a loaded message (passing ownership of the message to the caller).
Definition: dbus-message.c:4691
_dbus_header_set_field_basic
dbus_bool_t _dbus_header_set_field_basic(DBusHeader *header, int field, int type, const void *value)
Sets the value of a field with basic type.
Definition: dbus-marshal-header.c:1273
_dbus_header_init
dbus_bool_t _dbus_header_init(DBusHeader *header)
Initializes a header, but doesn't prepare it for use; to make the header valid, you have to call _dbu...
Definition: dbus-marshal-header.c:460
dbus_set_error_from_message
dbus_bool_t dbus_set_error_from_message(DBusError *error, DBusMessage *message)
Sets a DBusError based on the contents of the given message.
Definition: dbus-message.c:4026
_dbus_string_init_const_len
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
Definition: dbus-string.c:210
DBUS_HEADER_FLAG_NO_REPLY_EXPECTED
#define DBUS_HEADER_FLAG_NO_REPLY_EXPECTED
If set, this flag means that the sender of a message does not care about getting a reply,...
Definition: dbus-protocol.h:249
_dbus_warn_check_failed
void _dbus_warn_check_failed(const char *format,...)
Prints a "critical" warning to stderr when an assertion fails; differs from _dbus_warn primarily in t...
Definition: dbus-internals.c:262
DBUS_MAXIMUM_ARRAY_LENGTH
#define DBUS_MAXIMUM_ARRAY_LENGTH
Max length of a marshaled array in bytes (64M, 2^26) We use signed int for lengths so must be INT_MAX...
Definition: dbus-protocol.h:203
dbus_message_iter_get_array_len
int dbus_message_iter_get_array_len(DBusMessageIter *iter)
Returns the number of bytes in the array as marshaled in the wire protocol.
Definition: dbus-message.c:2425
dbus_bool_t
dbus_uint32_t dbus_bool_t
Definition: dbus-types.h:35
dbus_message_get_path_decomposed
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...
Definition: dbus-message.c:3394
dbus_message_set_member
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...
Definition: dbus-message.c:3516
DBusValidity
DBusValidity
This is primarily used in unit testing, so we can verify that each invalid message is invalid for the...
Definition: dbus-marshal-validate.h:49
NULL
#define NULL