D-Bus  1.12.20
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 #ifdef HAVE_PDPLINUX
1258  message->message_skip_mandatory=FALSE;
1259 #endif
1260 
1261  message->locked = FALSE;
1262 #ifndef DBUS_DISABLE_CHECKS
1263  message->in_cache = FALSE;
1264 #endif
1265  message->counters = NULL;
1266  message->size_counter_delta = 0;
1267  message->changed_stamp = 0;
1268 
1269 #ifdef HAVE_UNIX_FD_PASSING
1270  message->n_unix_fds = 0;
1271  message->n_unix_fds_allocated = 0;
1272  message->unix_fd_counter_delta = 0;
1273 #endif
1274 
1275  if (!from_cache)
1277 
1278  if (from_cache)
1279  {
1280  _dbus_header_reinit (&message->header);
1281  _dbus_string_set_length (&message->body, 0);
1282  }
1283  else
1284  {
1285  if (!_dbus_header_init (&message->header))
1286  {
1287  dbus_free (message);
1288  return NULL;
1289  }
1290 
1291  if (!_dbus_string_init_preallocated (&message->body, 32))
1292  {
1293  _dbus_header_free (&message->header);
1294  dbus_free (message);
1295  return NULL;
1296  }
1297  }
1298 
1299  return message;
1300 }
1301 
1314 DBusMessage*
1315 dbus_message_new (int message_type)
1316 {
1317  DBusMessage *message;
1318 
1319  _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL);
1320 
1321  message = dbus_message_new_empty_header ();
1322  if (message == NULL)
1323  return NULL;
1324 
1325  if (!_dbus_header_create (&message->header,
1326  DBUS_COMPILER_BYTE_ORDER,
1327  message_type,
1328  NULL, NULL, NULL, NULL, NULL))
1329  {
1330  dbus_message_unref (message);
1331  return NULL;
1332  }
1333 
1334  return message;
1335 }
1336 
1358 DBusMessage*
1359 dbus_message_new_method_call (const char *destination,
1360  const char *path,
1361  const char *iface,
1362  const char *method)
1363 {
1364  DBusMessage *message;
1365 
1366  _dbus_return_val_if_fail (path != NULL, NULL);
1367  _dbus_return_val_if_fail (method != NULL, NULL);
1368  _dbus_return_val_if_fail (destination == NULL ||
1369  _dbus_check_is_valid_bus_name (destination), NULL);
1370  _dbus_return_val_if_fail (_dbus_check_is_valid_path (path), NULL);
1371  _dbus_return_val_if_fail (iface == NULL ||
1372  _dbus_check_is_valid_interface (iface), NULL);
1373  _dbus_return_val_if_fail (_dbus_check_is_valid_member (method), NULL);
1374 
1375  message = dbus_message_new_empty_header ();
1376  if (message == NULL)
1377  return NULL;
1378 
1379  if (!_dbus_header_create (&message->header,
1380  DBUS_COMPILER_BYTE_ORDER,
1382  destination, path, iface, method, NULL))
1383  {
1384  dbus_message_unref (message);
1385  return NULL;
1386  }
1387 
1388  return message;
1389 }
1390 
1398 DBusMessage*
1400 {
1401  DBusMessage *message;
1402  const char *sender;
1403 
1404  _dbus_return_val_if_fail (method_call != NULL, NULL);
1405 
1406  sender = dbus_message_get_sender (method_call);
1407 
1408  /* sender is allowed to be null here in peer-to-peer case */
1409 
1410  message = dbus_message_new_empty_header ();
1411  if (message == NULL)
1412  return NULL;
1413 
1414  if (!_dbus_header_create (&message->header,
1415  DBUS_COMPILER_BYTE_ORDER,
1417  sender, NULL, NULL, NULL, NULL))
1418  {
1419  dbus_message_unref (message);
1420  return NULL;
1421  }
1422 
1423  dbus_message_set_no_reply (message, TRUE);
1424 
1425  if (!dbus_message_set_reply_serial (message,
1426  dbus_message_get_serial (method_call)))
1427  {
1428  dbus_message_unref (message);
1429  return NULL;
1430  }
1431 
1432  return message;
1433 }
1434 
1449 DBusMessage*
1450 dbus_message_new_signal (const char *path,
1451  const char *iface,
1452  const char *name)
1453 {
1454  DBusMessage *message;
1455 
1456  _dbus_return_val_if_fail (path != NULL, NULL);
1457  _dbus_return_val_if_fail (iface != NULL, NULL);
1458  _dbus_return_val_if_fail (name != NULL, NULL);
1459  _dbus_return_val_if_fail (_dbus_check_is_valid_path (path), NULL);
1460  _dbus_return_val_if_fail (_dbus_check_is_valid_interface (iface), NULL);
1461  _dbus_return_val_if_fail (_dbus_check_is_valid_member (name), NULL);
1462 
1463  message = dbus_message_new_empty_header ();
1464  if (message == NULL)
1465  return NULL;
1466 
1467  if (!_dbus_header_create (&message->header,
1468  DBUS_COMPILER_BYTE_ORDER,
1470  NULL, path, iface, name, NULL))
1471  {
1472  dbus_message_unref (message);
1473  return NULL;
1474  }
1475 
1476  dbus_message_set_no_reply (message, TRUE);
1477 
1478  return message;
1479 }
1480 
1495 DBusMessage*
1497  const char *error_name,
1498  const char *error_message)
1499 {
1500  DBusMessage *message;
1501  const char *sender;
1502  DBusMessageIter iter;
1503 
1504  _dbus_return_val_if_fail (reply_to != NULL, NULL);
1505  _dbus_return_val_if_fail (error_name != NULL, NULL);
1506  _dbus_return_val_if_fail (_dbus_check_is_valid_error_name (error_name), NULL);
1507 
1508  sender = dbus_message_get_sender (reply_to);
1509 
1510  /* sender may be NULL for non-message-bus case or
1511  * when the message bus is dealing with an unregistered
1512  * connection.
1513  */
1514  message = dbus_message_new_empty_header ();
1515  if (message == NULL)
1516  return NULL;
1517 
1518  if (!_dbus_header_create (&message->header,
1519  DBUS_COMPILER_BYTE_ORDER,
1521  sender, NULL, NULL, NULL, error_name))
1522  {
1523  dbus_message_unref (message);
1524  return NULL;
1525  }
1526 
1527  dbus_message_set_no_reply (message, TRUE);
1528 
1529  if (!dbus_message_set_reply_serial (message,
1530  dbus_message_get_serial (reply_to)))
1531  {
1532  dbus_message_unref (message);
1533  return NULL;
1534  }
1535 
1536  if (error_message != NULL)
1537  {
1538  dbus_message_iter_init_append (message, &iter);
1539  if (!dbus_message_iter_append_basic (&iter,
1541  &error_message))
1542  {
1543  dbus_message_unref (message);
1544  return NULL;
1545  }
1546  }
1547 
1548  return message;
1549 }
1550 
1567 DBusMessage*
1569  const char *error_name,
1570  const char *error_format,
1571  ...)
1572 {
1573  va_list args;
1574  DBusString str;
1575  DBusMessage *message;
1576 
1577  _dbus_return_val_if_fail (reply_to != NULL, NULL);
1578  _dbus_return_val_if_fail (error_name != NULL, NULL);
1579  _dbus_return_val_if_fail (_dbus_check_is_valid_error_name (error_name), NULL);
1580 
1581  if (!_dbus_string_init (&str))
1582  return NULL;
1583 
1584  va_start (args, error_format);
1585 
1586  if (_dbus_string_append_printf_valist (&str, error_format, args))
1587  message = dbus_message_new_error (reply_to, error_name,
1588  _dbus_string_get_const_data (&str));
1589  else
1590  message = NULL;
1591 
1592  _dbus_string_free (&str);
1593 
1594  va_end (args);
1595 
1596  return message;
1597 }
1598 
1599 
1612 DBusMessage *
1614 {
1615  DBusMessage *retval;
1616 
1617  _dbus_return_val_if_fail (message != NULL, NULL);
1618 
1619  retval = dbus_new0 (DBusMessage, 1);
1620  if (retval == NULL)
1621  return NULL;
1622 
1623  _dbus_atomic_inc (&retval->refcount);
1624 
1625  retval->locked = FALSE;
1626 #ifndef DBUS_DISABLE_CHECKS
1627  retval->generation = message->generation;
1628 #endif
1629 
1630  if (!_dbus_header_copy (&message->header, &retval->header))
1631  {
1632  dbus_free (retval);
1633  return NULL;
1634  }
1635 
1636  if (!_dbus_string_init_preallocated (&retval->body,
1637  _dbus_string_get_length (&message->body)))
1638  {
1639  _dbus_header_free (&retval->header);
1640  dbus_free (retval);
1641  return NULL;
1642  }
1643 
1644  if (!_dbus_string_copy (&message->body, 0,
1645  &retval->body, 0))
1646  goto failed_copy;
1647 
1648 #ifdef HAVE_UNIX_FD_PASSING
1649  retval->unix_fds = dbus_new(int, message->n_unix_fds);
1650  if (retval->unix_fds == NULL && message->n_unix_fds > 0)
1651  goto failed_copy;
1652 
1653  retval->n_unix_fds_allocated = message->n_unix_fds;
1654 
1655  for (retval->n_unix_fds = 0;
1656  retval->n_unix_fds < message->n_unix_fds;
1657  retval->n_unix_fds++)
1658  {
1659  retval->unix_fds[retval->n_unix_fds] = _dbus_dup(message->unix_fds[retval->n_unix_fds], NULL);
1660 
1661  if (retval->unix_fds[retval->n_unix_fds] < 0)
1662  goto failed_copy;
1663  }
1664 
1665 #endif
1666 
1667  _dbus_message_trace_ref (retval, 0, 1, "copy");
1668  return retval;
1669 
1670  failed_copy:
1671  _dbus_header_free (&retval->header);
1672  _dbus_string_free (&retval->body);
1673 
1674 #ifdef HAVE_UNIX_FD_PASSING
1675  close_unix_fds(retval->unix_fds, &retval->n_unix_fds);
1676  dbus_free(retval->unix_fds);
1677 #endif
1678 
1679  dbus_free (retval);
1680 
1681  return NULL;
1682 }
1683 
1684 
1692 DBusMessage *
1694 {
1695  dbus_int32_t old_refcount;
1696 
1697  _dbus_return_val_if_fail (message != NULL, NULL);
1698  _dbus_return_val_if_fail (message->generation == _dbus_current_generation, NULL);
1699  _dbus_return_val_if_fail (!message->in_cache, NULL);
1700 
1701  old_refcount = _dbus_atomic_inc (&message->refcount);
1702  _dbus_assert (old_refcount >= 1);
1703  _dbus_message_trace_ref (message, old_refcount, old_refcount + 1, "ref");
1704 
1705  return message;
1706 }
1707 
1715 void
1717 {
1718  dbus_int32_t old_refcount;
1719 
1720  _dbus_return_if_fail (message != NULL);
1721  _dbus_return_if_fail (message->generation == _dbus_current_generation);
1722  _dbus_return_if_fail (!message->in_cache);
1723 
1724  old_refcount = _dbus_atomic_dec (&message->refcount);
1725 
1726  _dbus_assert (old_refcount >= 1);
1727 
1728  _dbus_message_trace_ref (message, old_refcount, old_refcount - 1, "unref");
1729 
1730  if (old_refcount == 1)
1731  {
1732  /* Calls application callbacks! */
1733  dbus_message_cache_or_finalize (message);
1734  }
1735 }
1736 
1747 int
1749 {
1750  _dbus_return_val_if_fail (message != NULL, DBUS_MESSAGE_TYPE_INVALID);
1751 
1752  return _dbus_header_get_message_type (&message->header);
1753 }
1754 
1825  int first_arg_type,
1826  ...)
1827 {
1828  dbus_bool_t retval;
1829  va_list var_args;
1830 
1831  _dbus_return_val_if_fail (message != NULL, FALSE);
1832 
1833  va_start (var_args, first_arg_type);
1834  retval = dbus_message_append_args_valist (message,
1835  first_arg_type,
1836  var_args);
1837  va_end (var_args);
1838 
1839  return retval;
1840 }
1841 
1857  int first_arg_type,
1858  va_list var_args)
1859 {
1860  int type;
1861  DBusMessageIter iter;
1862 
1863  _dbus_return_val_if_fail (message != NULL, FALSE);
1864 
1865  type = first_arg_type;
1866 
1867  dbus_message_iter_init_append (message, &iter);
1868 
1869  while (type != DBUS_TYPE_INVALID)
1870  {
1871  if (dbus_type_is_basic (type))
1872  {
1873  const DBusBasicValue *value;
1874  value = va_arg (var_args, const DBusBasicValue*);
1875 
1876  if (!dbus_message_iter_append_basic (&iter,
1877  type,
1878  value))
1879  goto failed;
1880  }
1881  else if (type == DBUS_TYPE_ARRAY)
1882  {
1883  int element_type;
1884  DBusMessageIter array;
1885  char buf[2];
1886 
1887  element_type = va_arg (var_args, int);
1888 
1889  buf[0] = element_type;
1890  buf[1] = '\0';
1893  buf,
1894  &array))
1895  goto failed;
1896 
1897  if (dbus_type_is_fixed (element_type) &&
1898  element_type != DBUS_TYPE_UNIX_FD)
1899  {
1900  const DBusBasicValue **value;
1901  int n_elements;
1902 
1903  value = va_arg (var_args, const DBusBasicValue**);
1904  n_elements = va_arg (var_args, int);
1905 
1907  element_type,
1908  value,
1909  n_elements)) {
1910  dbus_message_iter_abandon_container (&iter, &array);
1911  goto failed;
1912  }
1913  }
1914  else if (_DBUS_TYPE_IS_STRINGLIKE (element_type))
1915  {
1916  const char ***value_p;
1917  const char **value;
1918  int n_elements;
1919  int i;
1920 
1921  value_p = va_arg (var_args, const char***);
1922  n_elements = va_arg (var_args, int);
1923 
1924  value = *value_p;
1925 
1926  i = 0;
1927  while (i < n_elements)
1928  {
1929  if (!dbus_message_iter_append_basic (&array,
1930  element_type,
1931  &value[i])) {
1932  dbus_message_iter_abandon_container (&iter, &array);
1933  goto failed;
1934  }
1935  ++i;
1936  }
1937  }
1938  else
1939  {
1940  _dbus_warn ("arrays of %s can't be appended with %s for now",
1941  _dbus_type_to_string (element_type),
1942  _DBUS_FUNCTION_NAME);
1943  dbus_message_iter_abandon_container (&iter, &array);
1944  goto failed;
1945  }
1946 
1947  if (!dbus_message_iter_close_container (&iter, &array))
1948  goto failed;
1949  }
1950 #ifndef DBUS_DISABLE_CHECKS
1951  else
1952  {
1953  _dbus_warn ("type %s isn't supported yet in %s",
1954  _dbus_type_to_string (type), _DBUS_FUNCTION_NAME);
1955  goto failed;
1956  }
1957 #endif
1958 
1959  type = va_arg (var_args, int);
1960  }
1961 
1962  return TRUE;
1963 
1964  failed:
1965  return FALSE;
1966 }
1967 
2014  DBusError *error,
2015  int first_arg_type,
2016  ...)
2017 {
2018  dbus_bool_t retval;
2019  va_list var_args;
2020 
2021  _dbus_return_val_if_fail (message != NULL, FALSE);
2022  _dbus_return_val_if_error_is_set (error, FALSE);
2023 
2024  va_start (var_args, first_arg_type);
2025  retval = dbus_message_get_args_valist (message, error, first_arg_type, var_args);
2026  va_end (var_args);
2027 
2028  return retval;
2029 }
2030 
2043  DBusError *error,
2044  int first_arg_type,
2045  va_list var_args)
2046 {
2047  DBusMessageIter iter;
2048 
2049  _dbus_return_val_if_fail (message != NULL, FALSE);
2050  _dbus_return_val_if_error_is_set (error, FALSE);
2051 
2052  dbus_message_iter_init (message, &iter);
2053  return _dbus_message_iter_get_args_valist (&iter, error, first_arg_type, var_args);
2054 }
2055 
2056 static void
2057 _dbus_message_iter_init_common (DBusMessage *message,
2058  DBusMessageRealIter *real,
2059  int iter_type)
2060 {
2061  /* If these static assertions fail on your platform, report it as a bug. */
2062  _DBUS_STATIC_ASSERT (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter));
2063  _DBUS_STATIC_ASSERT (_DBUS_ALIGNOF (DBusMessageRealIter) <=
2064  _DBUS_ALIGNOF (DBusMessageIter));
2065  /* A failure of these two assertions would indicate that we've broken
2066  * ABI on this platform since 1.10.0. */
2067  _DBUS_STATIC_ASSERT (sizeof (DBusMessageIter_1_10_0) ==
2068  sizeof (DBusMessageIter));
2069  _DBUS_STATIC_ASSERT (_DBUS_ALIGNOF (DBusMessageIter_1_10_0) ==
2070  _DBUS_ALIGNOF (DBusMessageIter));
2071  /* If this static assertion fails, it means the DBusMessageIter struct
2072  * is not "packed", which might result in "iter = other_iter" not copying
2073  * every byte. */
2074  _DBUS_STATIC_ASSERT (sizeof (DBusMessageIter) ==
2075  4 * sizeof (void *) + sizeof (dbus_uint32_t) + 9 * sizeof (int));
2076 
2077  /* Since the iterator will read or write who-knows-what from the
2078  * message, we need to get in the right byte order
2079  */
2080  ensure_byte_order (message);
2081 
2082  real->message = message;
2083  real->changed_stamp = message->changed_stamp;
2084  real->iter_type = iter_type;
2085  real->sig_refcount = 0;
2086 }
2087 
2112  DBusMessageIter *iter)
2113 {
2114  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2115  const DBusString *type_str;
2116  int type_pos;
2117 
2118  _dbus_return_val_if_fail (message != NULL, FALSE);
2119  _dbus_return_val_if_fail (iter != NULL, FALSE);
2120 
2121  get_const_signature (&message->header, &type_str, &type_pos);
2122 
2123  _dbus_message_iter_init_common (message, real,
2124  DBUS_MESSAGE_ITER_TYPE_READER);
2125 
2127  _dbus_header_get_byte_order (&message->header),
2128  type_str, type_pos,
2129  &message->body,
2130  0);
2131 
2133 }
2134 
2143 {
2144  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2145 
2146  _dbus_return_val_if_fail (_dbus_message_iter_check (real), FALSE);
2147  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2148 
2149  return _dbus_type_reader_has_next (&real->u.reader);
2150 }
2151 
2162 {
2163  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2164 
2165  _dbus_return_val_if_fail (_dbus_message_iter_check (real), FALSE);
2166  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2167 
2168  return _dbus_type_reader_next (&real->u.reader);
2169 }
2170 
2185 int
2187 {
2188  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2189 
2190  _dbus_return_val_if_fail (_dbus_message_iter_check (real), DBUS_TYPE_INVALID);
2191  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, FALSE);
2192 
2194 }
2195 
2204 int
2206 {
2207  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2208 
2209  _dbus_return_val_if_fail (_dbus_message_iter_check (real), DBUS_TYPE_INVALID);
2210  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, DBUS_TYPE_INVALID);
2211  _dbus_return_val_if_fail (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
2212 
2214 }
2215 
2241 void
2243  DBusMessageIter *sub)
2244 {
2245  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2246  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
2247 
2248  _dbus_return_if_fail (_dbus_message_iter_check (real));
2249  _dbus_return_if_fail (sub != NULL);
2250 
2251  *real_sub = *real;
2252  _dbus_type_reader_recurse (&real->u.reader, &real_sub->u.reader);
2253 }
2254 
2266 char *
2268 {
2269  const DBusString *sig;
2270  DBusString retstr;
2271  char *ret;
2272  int start, len;
2273  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2274 
2275  _dbus_return_val_if_fail (_dbus_message_iter_check (real), NULL);
2276 
2277  if (!_dbus_string_init (&retstr))
2278  return NULL;
2279 
2281  &start, &len);
2282  if (!_dbus_string_append_len (&retstr,
2283  _dbus_string_get_const_data (sig) + start,
2284  len))
2285  return NULL;
2286  if (!_dbus_string_steal_data (&retstr, &ret))
2287  return NULL;
2288  _dbus_string_free (&retstr);
2289  return ret;
2290 }
2291 
2339 void
2341  void *value)
2342 {
2343  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2344 
2345  _dbus_return_if_fail (_dbus_message_iter_check (real));
2346  _dbus_return_if_fail (value != NULL);
2347 
2349  {
2350 #ifdef HAVE_UNIX_FD_PASSING
2351  DBusBasicValue idx;
2352 
2353  _dbus_type_reader_read_basic(&real->u.reader, &idx);
2354 
2355  if (idx.u32 >= real->message->n_unix_fds) {
2356  /* Hmm, we cannot really signal an error here, so let's make
2357  sure to return an invalid fd. */
2358  *((int*) value) = -1;
2359  return;
2360  }
2361 
2362  *((int*) value) = _dbus_dup(real->message->unix_fds[idx.u32], NULL);
2363 #else
2364  *((int*) value) = -1;
2365 #endif
2366  }
2367  else
2368  {
2370  value);
2371  }
2372 }
2373 
2384 int
2386 {
2387  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2388  DBusTypeReader array;
2389  int element_type;
2390  int n_elements = 0;
2391 
2392  _dbus_return_val_if_fail (_dbus_message_iter_check (real), 0);
2393  _dbus_return_val_if_fail (_dbus_type_reader_get_current_type (&real->u.reader)
2394  == DBUS_TYPE_ARRAY, 0);
2395 
2396  element_type = _dbus_type_reader_get_element_type (&real->u.reader);
2397  _dbus_type_reader_recurse (&real->u.reader, &array);
2398  if (dbus_type_is_fixed (element_type))
2399  {
2400  int alignment = _dbus_type_get_alignment (element_type);
2401  int total_len = _dbus_type_reader_get_array_length (&array);
2402  n_elements = total_len / alignment;
2403  }
2404  else
2405  {
2407  {
2408  ++n_elements;
2409  _dbus_type_reader_next (&array);
2410  }
2411  }
2412 
2413  return n_elements;
2414 }
2415 
2428 int
2430 {
2431  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2432 
2433  _dbus_return_val_if_fail (_dbus_message_iter_check (real), 0);
2434 
2436 }
2437 
2473 void
2475  void *value,
2476  int *n_elements)
2477 {
2478  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2479 #ifndef DBUS_DISABLE_CHECKS
2480  int subtype = _dbus_type_reader_get_current_type(&real->u.reader);
2481 
2482  _dbus_return_if_fail (_dbus_message_iter_check (real));
2483  _dbus_return_if_fail (value != NULL);
2484  _dbus_return_if_fail ((subtype == DBUS_TYPE_INVALID) ||
2485  (dbus_type_is_fixed (subtype) && subtype != DBUS_TYPE_UNIX_FD));
2486 #endif
2487 
2489  value, n_elements);
2490 }
2491 
2503 void
2505  DBusMessageIter *iter)
2506 {
2507  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2508 
2509  _dbus_return_if_fail (message != NULL);
2510  _dbus_return_if_fail (iter != NULL);
2511 
2512  _dbus_message_iter_init_common (message, real,
2513  DBUS_MESSAGE_ITER_TYPE_WRITER);
2514 
2515  /* We create the signature string and point iterators at it "on demand"
2516  * when a value is actually appended. That means that init() never fails
2517  * due to OOM.
2518  */
2520  _dbus_header_get_byte_order (&message->header),
2521  &message->body,
2522  _dbus_string_get_length (&message->body));
2523 }
2524 
2533 static dbus_bool_t
2534 _dbus_message_iter_open_signature (DBusMessageRealIter *real)
2535 {
2536  DBusString *str;
2537  const DBusString *current_sig;
2538  int current_sig_pos;
2539 
2540  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2541 
2542  if (real->u.writer.type_str != NULL)
2543  {
2544  _dbus_assert (real->sig_refcount > 0);
2545  real->sig_refcount += 1;
2546  return TRUE;
2547  }
2548 
2549  str = dbus_new (DBusString, 1);
2550  if (str == NULL)
2551  return FALSE;
2552 
2555  &current_sig, &current_sig_pos))
2556  current_sig = NULL;
2557 
2558  if (current_sig)
2559  {
2560  int current_len;
2561 
2562  current_len = _dbus_string_get_byte (current_sig, current_sig_pos);
2563  current_sig_pos += 1; /* move on to sig data */
2564 
2565  if (!_dbus_string_init_preallocated (str, current_len + 4))
2566  {
2567  dbus_free (str);
2568  return FALSE;
2569  }
2570 
2571  if (!_dbus_string_copy_len (current_sig, current_sig_pos, current_len,
2572  str, 0))
2573  {
2574  _dbus_string_free (str);
2575  dbus_free (str);
2576  return FALSE;
2577  }
2578  }
2579  else
2580  {
2581  if (!_dbus_string_init_preallocated (str, 4))
2582  {
2583  dbus_free (str);
2584  return FALSE;
2585  }
2586  }
2587 
2588  real->sig_refcount = 1;
2589 
2590  /* If this assertion failed, then str would be neither stored in u.writer
2591  * nor freed by this function, resulting in a memory leak. */
2592  _dbus_assert (real->u.writer.type_str == NULL);
2594  str, _dbus_string_get_length (str));
2595  return TRUE;
2596 }
2597 
2607 static dbus_bool_t
2608 _dbus_message_iter_close_signature (DBusMessageRealIter *real)
2609 {
2610  DBusString *str;
2611  const char *v_STRING;
2612  dbus_bool_t retval;
2613 
2614  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2615  _dbus_assert (real->u.writer.type_str != NULL);
2616  _dbus_assert (real->sig_refcount > 0);
2617 
2618  real->sig_refcount -= 1;
2619 
2620  if (real->sig_refcount > 0)
2621  return TRUE;
2622  _dbus_assert (real->sig_refcount == 0);
2623 
2624  retval = TRUE;
2625 
2626  str = real->u.writer.type_str;
2627 
2628  v_STRING = _dbus_string_get_const_data (str);
2632  &v_STRING))
2633  retval = FALSE;
2634 
2636  _dbus_string_free (str);
2637  dbus_free (str);
2638 
2639  return retval;
2640 }
2641 
2649 static void
2650 _dbus_message_iter_abandon_signature (DBusMessageRealIter *real)
2651 {
2652  DBusString *str;
2653 
2654  _dbus_assert (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
2655  _dbus_assert (real->u.writer.type_str != NULL);
2656  _dbus_assert (real->sig_refcount > 0);
2657 
2658  real->sig_refcount -= 1;
2659 
2660  if (real->sig_refcount > 0)
2661  return;
2662  _dbus_assert (real->sig_refcount == 0);
2663 
2664  str = real->u.writer.type_str;
2665 
2667  _dbus_string_free (str);
2668  dbus_free (str);
2669 }
2670 
2671 #ifndef DBUS_DISABLE_CHECKS
2672 static dbus_bool_t
2673 _dbus_message_iter_append_check (DBusMessageRealIter *iter)
2674 {
2675  if (!_dbus_message_iter_check (iter))
2676  return FALSE;
2677 
2678  if (iter->message->locked)
2679  {
2680  _dbus_warn_check_failed ("dbus append iterator can't be used: message is locked (has already been sent)");
2681  return FALSE;
2682  }
2683 
2684  return TRUE;
2685 }
2686 #endif /* DBUS_DISABLE_CHECKS */
2687 
2688 #ifdef HAVE_UNIX_FD_PASSING
2689 static int *
2690 expand_fd_array(DBusMessage *m,
2691  unsigned n)
2692 {
2693  _dbus_assert(m);
2694 
2695  /* This makes space for adding n new fds to the array and returns a
2696  pointer to the place were the first fd should be put. */
2697 
2698  if (m->n_unix_fds + n > m->n_unix_fds_allocated)
2699  {
2700  unsigned k;
2701  int *p;
2702 
2703  /* Make twice as much space as necessary */
2704  k = (m->n_unix_fds + n) * 2;
2705 
2706  /* Allocate at least four */
2707  if (k < 4)
2708  k = 4;
2709 
2710  p = dbus_realloc(m->unix_fds, k * sizeof(int));
2711  if (p == NULL)
2712  return NULL;
2713 
2714  m->unix_fds = p;
2715  m->n_unix_fds_allocated = k;
2716  }
2717 
2718  return m->unix_fds + m->n_unix_fds;
2719 }
2720 #endif
2721 
2743  int type,
2744  const void *value)
2745 {
2746  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2747  dbus_bool_t ret;
2748 
2749  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2750  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2751  _dbus_return_val_if_fail (dbus_type_is_basic (type), FALSE);
2752  _dbus_return_val_if_fail (value != NULL, FALSE);
2753 
2754 #ifndef DBUS_DISABLE_CHECKS
2755  switch (type)
2756  {
2757  DBusString str;
2758  DBusValidity signature_validity;
2759  const char * const *string_p;
2760  const dbus_bool_t *bool_p;
2761 
2762  case DBUS_TYPE_STRING:
2763  string_p = value;
2764  _dbus_return_val_if_fail (_dbus_check_is_valid_utf8 (*string_p), FALSE);
2765  break;
2766 
2767  case DBUS_TYPE_OBJECT_PATH:
2768  string_p = value;
2769  _dbus_return_val_if_fail (_dbus_check_is_valid_path (*string_p), FALSE);
2770  break;
2771 
2772  case DBUS_TYPE_SIGNATURE:
2773  string_p = value;
2774  _dbus_string_init_const (&str, *string_p);
2775  signature_validity = _dbus_validate_signature_with_reason (&str,
2776  0,
2777  _dbus_string_get_length (&str));
2778 
2779  if (signature_validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
2780  return FALSE;
2781 
2782  _dbus_return_val_if_fail (signature_validity == DBUS_VALID, FALSE);
2783  break;
2784 
2785  case DBUS_TYPE_BOOLEAN:
2786  bool_p = value;
2787  _dbus_return_val_if_fail (*bool_p == 0 || *bool_p == 1, FALSE);
2788  break;
2789 
2790  default:
2791  {
2792  /* nothing to check, all possible values are allowed */
2793  }
2794  }
2795 #endif
2796 
2797  if (!_dbus_message_iter_open_signature (real))
2798  return FALSE;
2799 
2800  if (type == DBUS_TYPE_UNIX_FD)
2801  {
2802 #ifdef HAVE_UNIX_FD_PASSING
2803  int *fds;
2804  dbus_uint32_t u;
2805 
2806  ret = FALSE;
2807 
2808  /* First step, include the fd in the fd list of this message */
2809  if (!(fds = expand_fd_array(real->message, 1)))
2810  goto out;
2811 
2812  *fds = _dbus_dup(*(int*) value, NULL);
2813  if (*fds < 0)
2814  goto out;
2815 
2816  u = real->message->n_unix_fds;
2817 
2818  /* Second step, write the index to the fd */
2819  if (!(ret = _dbus_type_writer_write_basic (&real->u.writer, DBUS_TYPE_UNIX_FD, &u))) {
2820  _dbus_close(*fds, NULL);
2821  goto out;
2822  }
2823 
2824  real->message->n_unix_fds += 1;
2825  u += 1;
2826 
2827  /* Final step, update the header accordingly */
2831  &u);
2832 
2833  /* If any of these operations fail the message is
2834  hosed. However, no memory or fds should be leaked since what
2835  has been added to message has been added to the message, and
2836  can hence be accounted for when the message is being
2837  freed. */
2838 #else
2839  ret = FALSE;
2840  /* This is redundant (we could just fall through), but it avoids
2841  * -Wunused-label in builds that don't HAVE_UNIX_FD_PASSING */
2842  goto out;
2843 #endif
2844  }
2845  else
2846  {
2847  ret = _dbus_type_writer_write_basic (&real->u.writer, type, value);
2848  }
2849 
2850 out:
2851  if (!_dbus_message_iter_close_signature (real))
2852  ret = FALSE;
2853 
2854  return ret;
2855 }
2856 
2894  int element_type,
2895  const void *value,
2896  int n_elements)
2897 {
2898  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2899  dbus_bool_t ret;
2900 
2901  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2902  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2903  _dbus_return_val_if_fail (dbus_type_is_fixed (element_type) && element_type != DBUS_TYPE_UNIX_FD, FALSE);
2904  _dbus_return_val_if_fail (real->u.writer.container_type == DBUS_TYPE_ARRAY, FALSE);
2905  _dbus_return_val_if_fail (value != NULL, FALSE);
2906  _dbus_return_val_if_fail (n_elements >= 0, FALSE);
2907  _dbus_return_val_if_fail (n_elements <=
2909  FALSE);
2910 
2911 #ifndef DBUS_DISABLE_CHECKS
2912  if (element_type == DBUS_TYPE_BOOLEAN)
2913  {
2914  const dbus_bool_t * const *bools = value;
2915  int i;
2916 
2917  for (i = 0; i < n_elements; i++)
2918  {
2919  _dbus_return_val_if_fail ((*bools)[i] == 0 || (*bools)[i] == 1, FALSE);
2920  }
2921  }
2922 #endif
2923 
2924  ret = _dbus_type_writer_write_fixed_multi (&real->u.writer, element_type, value, n_elements);
2925 
2926  return ret;
2927 }
2928 
2958  int type,
2959  const char *contained_signature,
2960  DBusMessageIter *sub)
2961 {
2962  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
2963  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
2964  DBusString contained_str;
2965  DBusValidity contained_signature_validity;
2966  dbus_bool_t ret;
2967 
2968  _dbus_return_val_if_fail (sub != NULL, FALSE);
2969  /* Do our best to make sure the sub-iterator doesn't contain something
2970  * valid-looking on failure */
2971  _dbus_message_real_iter_zero (real_sub);
2972 
2973  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
2974  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
2975  _dbus_return_val_if_fail (dbus_type_is_container (type), FALSE);
2976  _dbus_return_val_if_fail ((type == DBUS_TYPE_STRUCT &&
2977  contained_signature == NULL) ||
2978  (type == DBUS_TYPE_DICT_ENTRY &&
2979  contained_signature == NULL) ||
2980  (type == DBUS_TYPE_VARIANT &&
2981  contained_signature != NULL) ||
2982  (type == DBUS_TYPE_ARRAY &&
2983  contained_signature != NULL), FALSE);
2984 
2985  /* this would fail if the contained_signature is a dict entry, since
2986  * dict entries are invalid signatures standalone (they must be in
2987  * an array)
2988  */
2989  if (contained_signature != NULL)
2990  {
2991  _dbus_string_init_const (&contained_str, contained_signature);
2992  contained_signature_validity = _dbus_validate_signature_with_reason (&contained_str,
2993  0,
2994  _dbus_string_get_length (&contained_str));
2995 
2996  if (contained_signature_validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
2997  return FALSE;
2998  }
2999  else
3000  {
3001  /* just some placeholder value */
3002  contained_signature_validity = DBUS_VALID_BUT_INCOMPLETE;
3003  }
3004 
3005  _dbus_return_val_if_fail ((type == DBUS_TYPE_ARRAY && contained_signature && *contained_signature == DBUS_DICT_ENTRY_BEGIN_CHAR) ||
3006  contained_signature == NULL ||
3007  contained_signature_validity == DBUS_VALID,
3008  FALSE);
3009 
3010  if (!_dbus_message_iter_open_signature (real))
3011  return FALSE;
3012 
3013  ret = FALSE;
3014  *real_sub = *real;
3015 
3016  if (contained_signature != NULL)
3017  {
3018  _dbus_string_init_const (&contained_str, contained_signature);
3019 
3020  ret = _dbus_type_writer_recurse (&real->u.writer,
3021  type,
3022  &contained_str, 0,
3023  &real_sub->u.writer);
3024  }
3025  else
3026  {
3027  ret = _dbus_type_writer_recurse (&real->u.writer,
3028  type,
3029  NULL, 0,
3030  &real_sub->u.writer);
3031  }
3032 
3033  if (!ret)
3034  _dbus_message_iter_abandon_signature (real);
3035 
3036  return ret;
3037 }
3038 
3039 
3061  DBusMessageIter *sub)
3062 {
3063  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3064  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3065  dbus_bool_t ret;
3066 
3067  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
3068  _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
3069  _dbus_return_val_if_fail (_dbus_message_iter_append_check (real_sub), FALSE);
3070  _dbus_return_val_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
3071 
3072  ret = _dbus_type_writer_unrecurse (&real->u.writer,
3073  &real_sub->u.writer);
3074  _dbus_message_real_iter_zero (real_sub);
3075 
3076  if (!_dbus_message_iter_close_signature (real))
3077  ret = FALSE;
3078 
3079  return ret;
3080 }
3081 
3093 void
3095  DBusMessageIter *sub)
3096 {
3097  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3098  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3099 
3100 #ifndef DBUS_DISABLE_CHECKS
3101  _dbus_return_if_fail (_dbus_message_iter_append_check (real));
3102  _dbus_return_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3103  _dbus_return_if_fail (_dbus_message_iter_append_check (real_sub));
3104  _dbus_return_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3105 #endif
3106 
3107  _dbus_message_iter_abandon_signature (real);
3108  _dbus_message_real_iter_zero (real_sub);
3109 }
3110 
3152 void
3154  DBusMessageIter *sub)
3155 {
3156  DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
3157  DBusMessageRealIter *real_sub = (DBusMessageRealIter *)sub;
3158 
3159  /* If both the parent and the child are zeroed out, then either we didn't
3160  * even get as far as successfully recursing into the parent, or we already
3161  * closed both the child and the parent. For example, in the code sample
3162  * in the doc-comment above, this happens for
3163  * abandon_container_if_open (&outer, &inner) if the first open_container
3164  * call failed, or if we reached result = TRUE and fell through. */
3165  if (_dbus_message_real_iter_is_zeroed (real) &&
3166  _dbus_message_real_iter_is_zeroed (real_sub))
3167  return;
3168 
3169 #ifndef DBUS_DISABLE_CHECKS
3170  /* If the child is not zeroed out, but the parent is, then something has
3171  * gone horribly wrong (in practice that would probably mean both are
3172  * uninitialized or corrupt, and the parent happens to have ended up
3173  * all-bytes-zero). */
3174  _dbus_return_if_fail (_dbus_message_iter_append_check (real));
3175  _dbus_return_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3176 #endif
3177 
3178  /* If the parent is not zeroed out, but the child is, then either we did
3179  * not successfully open the child, or we already closed the child. This
3180  * means we do not own a reference to the parent's signature, so it would
3181  * be wrong to release it; so we must not call abandon_signature() here.
3182  * In the code sample in the doc-comment above, this happens for
3183  * abandon_container_if_open (&outer, &inner) if the second open_container
3184  * call failed, or if the second close_container call failed. */
3185  if (_dbus_message_real_iter_is_zeroed (real_sub))
3186  return;
3187 
3188 #ifndef DBUS_DISABLE_CHECKS
3189  _dbus_return_if_fail (_dbus_message_iter_append_check (real_sub));
3190  _dbus_return_if_fail (real_sub->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
3191 #endif
3192 
3193  /* If neither the parent nor the child is zeroed out, then we genuinely
3194  * have an open container; close it. In the code sample in the doc-comment,
3195  * this happens for abandon_container_if_open (&outer, &inner) if the
3196  * append_basic call failed. */
3197  _dbus_message_iter_abandon_signature (real);
3198  _dbus_message_real_iter_zero (real_sub);
3199 }
3200 
3217 void
3219  dbus_bool_t no_reply)
3220 {
3221  _dbus_return_if_fail (message != NULL);
3222  _dbus_return_if_fail (!message->locked);
3223 
3224  _dbus_header_toggle_flag (&message->header,
3226  no_reply);
3227 }
3228 
3238 {
3239  _dbus_return_val_if_fail (message != NULL, FALSE);
3240 
3241  return _dbus_header_get_flag (&message->header,
3243 }
3244 
3259 void
3261  dbus_bool_t auto_start)
3262 {
3263  _dbus_return_if_fail (message != NULL);
3264  _dbus_return_if_fail (!message->locked);
3265 
3266  _dbus_header_toggle_flag (&message->header,
3268  !auto_start);
3269 }
3270 
3280 {
3281  _dbus_return_val_if_fail (message != NULL, FALSE);
3282 
3283  return !_dbus_header_get_flag (&message->header,
3285 }
3286 
3287 
3302  const char *object_path)
3303 {
3304  _dbus_return_val_if_fail (message != NULL, FALSE);
3305  _dbus_return_val_if_fail (!message->locked, FALSE);
3306  _dbus_return_val_if_fail (object_path == NULL ||
3307  _dbus_check_is_valid_path (object_path),
3308  FALSE);
3309 
3310  return set_or_delete_string_field (message,
3313  object_path);
3314 }
3315 
3329 const char*
3331 {
3332  const char *v;
3333 
3334  _dbus_return_val_if_fail (message != NULL, NULL);
3335 
3336  v = NULL; /* in case field doesn't exist */
3340  (void *) &v);
3341  return v;
3342 }
3343 
3355  const char *path)
3356 {
3357  const char *msg_path;
3358  msg_path = dbus_message_get_path (message);
3359 
3360  if (msg_path == NULL)
3361  {
3362  if (path == NULL)
3363  return TRUE;
3364  else
3365  return FALSE;
3366  }
3367 
3368  if (path == NULL)
3369  return FALSE;
3370 
3371  if (strcmp (msg_path, path) == 0)
3372  return TRUE;
3373 
3374  return FALSE;
3375 }
3376 
3399  char ***path)
3400 {
3401  const char *v;
3402 
3403  _dbus_return_val_if_fail (message != NULL, FALSE);
3404  _dbus_return_val_if_fail (path != NULL, FALSE);
3405 
3406  *path = NULL;
3407 
3408  v = dbus_message_get_path (message);
3409  if (v != NULL)
3410  {
3411  if (!_dbus_decompose_path (v, strlen (v),
3412  path, NULL))
3413  return FALSE;
3414  }
3415  return TRUE;
3416 }
3417 
3433  const char *iface)
3434 {
3435  _dbus_return_val_if_fail (message != NULL, FALSE);
3436  _dbus_return_val_if_fail (!message->locked, FALSE);
3437  _dbus_return_val_if_fail (iface == NULL ||
3438  _dbus_check_is_valid_interface (iface),
3439  FALSE);
3440 
3441  return set_or_delete_string_field (message,
3444  iface);
3445 }
3446 
3460 const char*
3462 {
3463  const char *v;
3464 
3465  _dbus_return_val_if_fail (message != NULL, NULL);
3466 
3467  v = NULL; /* in case field doesn't exist */
3471  (void *) &v);
3472  return v;
3473 }
3474 
3484  const char *iface)
3485 {
3486  const char *msg_interface;
3487  msg_interface = dbus_message_get_interface (message);
3488 
3489  if (msg_interface == NULL)
3490  {
3491  if (iface == NULL)
3492  return TRUE;
3493  else
3494  return FALSE;
3495  }
3496 
3497  if (iface == NULL)
3498  return FALSE;
3499 
3500  if (strcmp (msg_interface, iface) == 0)
3501  return TRUE;
3502 
3503  return FALSE;
3504 
3505 }
3506 
3521  const char *member)
3522 {
3523  _dbus_return_val_if_fail (message != NULL, FALSE);
3524  _dbus_return_val_if_fail (!message->locked, FALSE);
3525  _dbus_return_val_if_fail (member == NULL ||
3526  _dbus_check_is_valid_member (member),
3527  FALSE);
3528 
3529  return set_or_delete_string_field (message,
3532  member);
3533 }
3534 
3546 const char*
3548 {
3549  const char *v;
3550 
3551  _dbus_return_val_if_fail (message != NULL, NULL);
3552 
3553  v = NULL; /* in case field doesn't exist */
3557  (void *) &v);
3558  return v;
3559 }
3560 
3570  const char *member)
3571 {
3572  const char *msg_member;
3573  msg_member = dbus_message_get_member (message);
3574 
3575  if (msg_member == NULL)
3576  {
3577  if (member == NULL)
3578  return TRUE;
3579  else
3580  return FALSE;
3581  }
3582 
3583  if (member == NULL)
3584  return FALSE;
3585 
3586  if (strcmp (msg_member, member) == 0)
3587  return TRUE;
3588 
3589  return FALSE;
3590 
3591 }
3592 
3606  const char *error_name)
3607 {
3608  _dbus_return_val_if_fail (message != NULL, FALSE);
3609  _dbus_return_val_if_fail (!message->locked, FALSE);
3610  _dbus_return_val_if_fail (error_name == NULL ||
3611  _dbus_check_is_valid_error_name (error_name),
3612  FALSE);
3613 
3614  return set_or_delete_string_field (message,
3617  error_name);
3618 }
3619 
3630 const char*
3632 {
3633  const char *v;
3634 
3635  _dbus_return_val_if_fail (message != NULL, NULL);
3636 
3637  v = NULL; /* in case field doesn't exist */
3641  (void *) &v);
3642  return v;
3643 }
3644 
3660  const char *destination)
3661 {
3662  _dbus_return_val_if_fail (message != NULL, FALSE);
3663  _dbus_return_val_if_fail (!message->locked, FALSE);
3664  _dbus_return_val_if_fail (destination == NULL ||
3665  _dbus_check_is_valid_bus_name (destination),
3666  FALSE);
3667 
3668  return set_or_delete_string_field (message,
3671  destination);
3672 }
3673 
3683 const char*
3685 {
3686  const char *v;
3687 
3688  _dbus_return_val_if_fail (message != NULL, NULL);
3689 
3690  v = NULL; /* in case field doesn't exist */
3694  (void *) &v);
3695  return v;
3696 }
3697 
3714  const char *sender)
3715 {
3716  _dbus_return_val_if_fail (message != NULL, FALSE);
3717  _dbus_return_val_if_fail (!message->locked, FALSE);
3718  _dbus_return_val_if_fail (sender == NULL ||
3719  _dbus_check_is_valid_bus_name (sender),
3720  FALSE);
3721 
3722  return set_or_delete_string_field (message,
3725  sender);
3726 }
3727 
3743 const char*
3745 {
3746  const char *v;
3747 
3748  _dbus_return_val_if_fail (message != NULL, NULL);
3749 
3750  v = NULL; /* in case field doesn't exist */
3754  (void *) &v);
3755  return v;
3756 }
3757 
3776 const char*
3778 {
3779  const DBusString *type_str;
3780  int type_pos;
3781 
3782  _dbus_return_val_if_fail (message != NULL, NULL);
3783 
3784  get_const_signature (&message->header, &type_str, &type_pos);
3785 
3786  return _dbus_string_get_const_data_len (type_str, type_pos, 0);
3787 }
3788 
3789 static dbus_bool_t
3790 _dbus_message_has_type_interface_member (DBusMessage *message,
3791  int type,
3792  const char *iface,
3793  const char *member)
3794 {
3795  const char *n;
3796 
3797  _dbus_assert (message != NULL);
3798  _dbus_assert (iface != NULL);
3799  _dbus_assert (member != NULL);
3800 
3801  if (dbus_message_get_type (message) != type)
3802  return FALSE;
3803 
3804  /* Optimize by checking the short member name first
3805  * instead of the longer interface name
3806  */
3807 
3808  n = dbus_message_get_member (message);
3809 
3810  if (n && strcmp (n, member) == 0)
3811  {
3812  n = dbus_message_get_interface (message);
3813 
3814  if (n == NULL || strcmp (n, iface) == 0)
3815  return TRUE;
3816  }
3817 
3818  return FALSE;
3819 }
3820 
3837  const char *iface,
3838  const char *method)
3839 {
3840  _dbus_return_val_if_fail (message != NULL, FALSE);
3841  _dbus_return_val_if_fail (iface != NULL, FALSE);
3842  _dbus_return_val_if_fail (method != NULL, FALSE);
3843  /* don't check that interface/method are valid since it would be
3844  * expensive, and not catch many common errors
3845  */
3846 
3847  return _dbus_message_has_type_interface_member (message,
3849  iface, method);
3850 }
3851 
3865  const char *iface,
3866  const char *signal_name)
3867 {
3868  _dbus_return_val_if_fail (message != NULL, FALSE);
3869  _dbus_return_val_if_fail (iface != NULL, FALSE);
3870  _dbus_return_val_if_fail (signal_name != NULL, FALSE);
3871  /* don't check that interface/name are valid since it would be
3872  * expensive, and not catch many common errors
3873  */
3874 
3875  return _dbus_message_has_type_interface_member (message,
3877  iface, signal_name);
3878 }
3879 
3892  const char *error_name)
3893 {
3894  const char *n;
3895 
3896  _dbus_return_val_if_fail (message != NULL, FALSE);
3897  _dbus_return_val_if_fail (error_name != NULL, FALSE);
3898  /* don't check that error_name is valid since it would be expensive,
3899  * and not catch many common errors
3900  */
3901 
3903  return FALSE;
3904 
3905  n = dbus_message_get_error_name (message);
3906 
3907  if (n && strcmp (n, error_name) == 0)
3908  return TRUE;
3909  else
3910  return FALSE;
3911 }
3912 
3925  const char *name)
3926 {
3927  const char *s;
3928 
3929  _dbus_return_val_if_fail (message != NULL, FALSE);
3930  _dbus_return_val_if_fail (name != NULL, FALSE);
3931  /* don't check that name is valid since it would be expensive, and
3932  * not catch many common errors
3933  */
3934 
3935  s = dbus_message_get_destination (message);
3936 
3937  if (s && strcmp (s, name) == 0)
3938  return TRUE;
3939  else
3940  return FALSE;
3941 }
3942 
3960  const char *name)
3961 {
3962  const char *s;
3963 
3964  _dbus_return_val_if_fail (message != NULL, FALSE);
3965  _dbus_return_val_if_fail (name != NULL, FALSE);
3966  /* don't check that name is valid since it would be expensive, and
3967  * not catch many common errors
3968  */
3969 
3970  s = dbus_message_get_sender (message);
3971 
3972  if (s && strcmp (s, name) == 0)
3973  return TRUE;
3974  else
3975  return FALSE;
3976 }
3977 
3989  const char *signature)
3990 {
3991  const char *s;
3992 
3993  _dbus_return_val_if_fail (message != NULL, FALSE);
3994  _dbus_return_val_if_fail (signature != NULL, FALSE);
3995  /* don't check that signature is valid since it would be expensive,
3996  * and not catch many common errors
3997  */
3998 
3999  s = dbus_message_get_signature (message);
4000 
4001  if (s && strcmp (s, signature) == 0)
4002  return TRUE;
4003  else
4004  return FALSE;
4005 }
4006 
4031  DBusMessage *message)
4032 {
4033  const char *str;
4034 
4035  _dbus_return_val_if_fail (message != NULL, FALSE);
4036  _dbus_return_val_if_error_is_set (error, FALSE);
4037 
4039  return FALSE;
4040 
4041  str = NULL;
4042  dbus_message_get_args (message, NULL,
4043  DBUS_TYPE_STRING, &str,
4045 
4046  dbus_set_error (error, dbus_message_get_error_name (message),
4047  str ? "%s" : NULL, str);
4048 
4049  return TRUE;
4050 }
4051 
4060 {
4061 #ifdef HAVE_UNIX_FD_PASSING
4062  _dbus_assert(message);
4063 
4064  return message->n_unix_fds > 0;
4065 #else
4066  return FALSE;
4067 #endif
4068 }
4069 
4088 #define INITIAL_LOADER_DATA_LEN 32
4089 
4098 {
4099  DBusMessageLoader *loader;
4100 
4101  loader = dbus_new0 (DBusMessageLoader, 1);
4102  if (loader == NULL)
4103  return NULL;
4104 
4105  loader->refcount = 1;
4106 
4107  loader->corrupted = FALSE;
4108  loader->corruption_reason = DBUS_VALID;
4109 
4110  /* this can be configured by the app, but defaults to the protocol max */
4112 
4113  /* We set a very relatively conservative default here since due to how
4114  SCM_RIGHTS works we need to preallocate an fd array of the maximum
4115  number of unix fds we want to receive in advance. A
4116  try-and-reallocate loop is not possible. */
4117  loader->max_message_unix_fds = DBUS_DEFAULT_MESSAGE_UNIX_FDS;
4118 
4119  if (!_dbus_string_init (&loader->data))
4120  {
4121  dbus_free (loader);
4122  return NULL;
4123  }
4124 
4125  /* preallocate the buffer for speed, ignore failure */
4127  _dbus_string_set_length (&loader->data, 0);
4128 
4129 #ifdef HAVE_UNIX_FD_PASSING
4130  loader->unix_fds = NULL;
4131  loader->n_unix_fds = loader->n_unix_fds_allocated = 0;
4132  loader->unix_fds_outstanding = FALSE;
4133 #endif
4134 
4135  return loader;
4136 }
4137 
4146 {
4147  loader->refcount += 1;
4148 
4149  return loader;
4150 }
4151 
4158 void
4160 {
4161  loader->refcount -= 1;
4162  if (loader->refcount == 0)
4163  {
4164 #ifdef HAVE_UNIX_FD_PASSING
4165  close_unix_fds(loader->unix_fds, &loader->n_unix_fds);
4166  dbus_free(loader->unix_fds);
4167 #endif
4168  _dbus_list_foreach (&loader->messages,
4170  NULL);
4171  _dbus_list_clear (&loader->messages);
4172  _dbus_string_free (&loader->data);
4173  dbus_free (loader);
4174  }
4175 }
4176 
4195 void
4197  DBusString **buffer,
4198  int *max_to_read,
4199  dbus_bool_t *may_read_fds)
4200 {
4201  _dbus_assert (!loader->buffer_outstanding);
4202 
4203  *buffer = &loader->data;
4204 
4205  loader->buffer_outstanding = TRUE;
4206 
4207  if (max_to_read != NULL)
4208  {
4209 #ifdef HAVE_UNIX_FD_PASSING
4210  int offset = 0;
4211  int remain;
4212  int byte_order;
4213  int fields_array_len;
4214  int header_len;
4215  int body_len;
4216 #endif
4217 
4218  *max_to_read = DBUS_MAXIMUM_MESSAGE_LENGTH;
4219  *may_read_fds = TRUE;
4220 
4221 #ifdef HAVE_UNIX_FD_PASSING
4222  /* If we aren't holding onto any fds, we can read as much as we want
4223  * (fast path). */
4224  if (loader->n_unix_fds == 0)
4225  return;
4226 
4227  /* Slow path: we have a message with some fds in it. We don't want
4228  * to start on the next message until this one is out of the way;
4229  * otherwise a legitimate sender can keep us processing messages
4230  * containing fds, until we disconnect it for having had fds pending
4231  * for too long, a limit that is in place to stop malicious senders
4232  * from setting up recursive fd-passing that takes up our quota and
4233  * will never go away. */
4234 
4235  remain = _dbus_string_get_length (&loader->data);
4236 
4237  while (remain > 0)
4238  {
4239  DBusValidity validity = DBUS_VALIDITY_UNKNOWN;
4240  int needed;
4241 
4242  /* If 0 < remain < DBUS_MINIMUM_HEADER_SIZE, then we've had at
4243  * least the first byte of a message, but we don't know how
4244  * much more to read. Only read the rest of the
4245  * DBUS_MINIMUM_HEADER_SIZE for now; then we'll know. */
4246  if (remain < DBUS_MINIMUM_HEADER_SIZE)
4247  {
4248  *max_to_read = DBUS_MINIMUM_HEADER_SIZE - remain;
4249  *may_read_fds = FALSE;
4250  return;
4251  }
4252 
4254  &validity,
4255  &byte_order,
4256  &fields_array_len,
4257  &header_len,
4258  &body_len,
4259  &loader->data,
4260  offset,
4261  remain))
4262  {
4263  /* If a message in the buffer is invalid, we're going to
4264  * disconnect the sender anyway, so reading an arbitrary amount
4265  * is fine. */
4266  if (validity != DBUS_VALID)
4267  return;
4268 
4269  /* We have a partial message, with the
4270  * DBUS_MINIMUM_HEADER_SIZE-byte fixed part of the header (which
4271  * lets us work out how much more we need), but no more. Read
4272  * the rest of the message. */
4273  needed = header_len + body_len;
4274  _dbus_assert (needed > remain);
4275  *max_to_read = needed - remain;
4276  *may_read_fds = FALSE;
4277  return;
4278  }
4279 
4280  /* Skip over entire messages until we have less than a message
4281  * remaining. */
4282  needed = header_len + body_len;
4284  _dbus_assert (remain >= needed);
4285  remain -= needed;
4286  offset += needed;
4287  }
4288 #endif
4289  }
4290 }
4291 
4301 void
4303  DBusString *buffer)
4304 {
4305  _dbus_assert (loader->buffer_outstanding);
4306  _dbus_assert (buffer == &loader->data);
4307 
4308  loader->buffer_outstanding = FALSE;
4309 }
4310 
4311 #ifdef HAVE_UNIX_FD_PASSING
4312 
4323 _dbus_message_loader_get_unix_fds(DBusMessageLoader *loader,
4324  int **fds,
4325  unsigned *max_n_fds)
4326 {
4327  _dbus_assert (!loader->unix_fds_outstanding);
4328 
4329  /* Allocate space where we can put the fds we read. We allocate
4330  space for max_message_unix_fds since this is an
4331  upper limit how many fds can be received within a single
4332  message. Since SCM_RIGHTS doesn't allow a reallocate+retry logic
4333  we are allocating the maximum possible array size right from the
4334  beginning. This sucks a bit, however unless SCM_RIGHTS is fixed
4335  there is no better way. */
4336 
4337  if (loader->n_unix_fds_allocated < loader->max_message_unix_fds)
4338  {
4339  int *a = dbus_realloc(loader->unix_fds,
4340  loader->max_message_unix_fds * sizeof(loader->unix_fds[0]));
4341 
4342  if (!a)
4343  return FALSE;
4344 
4345  loader->unix_fds = a;
4346  loader->n_unix_fds_allocated = loader->max_message_unix_fds;
4347  }
4348 
4349  *fds = loader->unix_fds + loader->n_unix_fds;
4350  *max_n_fds = loader->n_unix_fds_allocated - loader->n_unix_fds;
4351 
4352  loader->unix_fds_outstanding = TRUE;
4353  return TRUE;
4354 }
4355 
4366 void
4367 _dbus_message_loader_return_unix_fds(DBusMessageLoader *loader,
4368  int *fds,
4369  unsigned n_fds)
4370 {
4371  _dbus_assert(loader->unix_fds_outstanding);
4372  _dbus_assert(loader->unix_fds + loader->n_unix_fds == fds);
4373  _dbus_assert(loader->n_unix_fds + n_fds <= loader->n_unix_fds_allocated);
4374 
4375  loader->n_unix_fds += n_fds;
4376  loader->unix_fds_outstanding = FALSE;
4377 
4378  if (n_fds && loader->unix_fds_change)
4379  loader->unix_fds_change (loader->unix_fds_change_data);
4380 }
4381 #endif
4382 
4383 /*
4384  * FIXME when we move the header out of the buffer, that memmoves all
4385  * buffered messages. Kind of crappy.
4386  *
4387  * Also we copy the header and body, which is kind of crappy. To
4388  * avoid this, we have to allow header and body to be in a single
4389  * memory block, which is good for messages we read and bad for
4390  * messages we are creating. But we could move_len() the buffer into
4391  * this single memory block, and move_len() will just swap the buffers
4392  * if you're moving the entire buffer replacing the dest string.
4393  *
4394  * We could also have the message loader tell the transport how many
4395  * bytes to read; so it would first ask for some arbitrary number like
4396  * 256, then if the message was incomplete it would use the
4397  * header/body len to ask for exactly the size of the message (or
4398  * blocks the size of a typical kernel buffer for the socket). That
4399  * way we don't get trailing bytes in the buffer that have to be
4400  * memmoved. Though I suppose we also don't have a chance of reading a
4401  * bunch of small messages at once, so the optimization may be stupid.
4402  *
4403  * Another approach would be to keep a "start" index into
4404  * loader->data and only delete it occasionally, instead of after
4405  * each message is loaded.
4406  *
4407  * load_message() returns FALSE if not enough memory OR the loader was corrupted
4408  */
4409 static dbus_bool_t
4410 load_message (DBusMessageLoader *loader,
4411  DBusMessage *message,
4412  int byte_order,
4413  int fields_array_len,
4414  int header_len,
4415  int body_len)
4416 {
4417  dbus_bool_t oom;
4418  DBusValidity validity;
4419  const DBusString *type_str;
4420  int type_pos;
4421  DBusValidationMode mode;
4422  dbus_uint32_t n_unix_fds = 0;
4423 
4424  mode = DBUS_VALIDATION_MODE_DATA_IS_UNTRUSTED;
4425 
4426  oom = FALSE;
4427 
4428 #if 0
4429  _dbus_verbose_bytes_of_string (&loader->data, 0, header_len /* + body_len */);
4430 #endif
4431 
4432  /* 1. VALIDATE AND COPY OVER HEADER */
4433  _dbus_assert (_dbus_string_get_length (&message->header.data) == 0);
4434  _dbus_assert ((header_len + body_len) <= _dbus_string_get_length (&loader->data));
4435 
4436  if (!_dbus_header_load (&message->header,
4437  mode,
4438  &validity,
4439  byte_order,
4440  fields_array_len,
4441  header_len,
4442  body_len,
4443  &loader->data, 0,
4444  _dbus_string_get_length (&loader->data)))
4445  {
4446  _dbus_verbose ("Failed to load header for new message code %d\n", validity);
4447 
4448  /* assert here so we can catch any code that still uses DBUS_VALID to indicate
4449  oom errors. They should use DBUS_VALIDITY_UNKNOWN_OOM_ERROR instead */
4450  _dbus_assert (validity != DBUS_VALID);
4451 
4452  if (validity == DBUS_VALIDITY_UNKNOWN_OOM_ERROR)
4453  oom = TRUE;
4454  else
4455  {
4456  loader->corrupted = TRUE;
4457  loader->corruption_reason = validity;
4458  }
4459  goto failed;
4460  }
4461 
4462  _dbus_assert (validity == DBUS_VALID);
4463 
4464  /* 2. VALIDATE BODY */
4465  if (mode != DBUS_VALIDATION_MODE_WE_TRUST_THIS_DATA_ABSOLUTELY)
4466  {
4467  get_const_signature (&message->header, &type_str, &type_pos);
4468 
4469  /* Because the bytes_remaining arg is NULL, this validates that the
4470  * body is the right length
4471  */
4472  validity = _dbus_validate_body_with_reason (type_str,
4473  type_pos,
4474  byte_order,
4475  NULL,
4476  &loader->data,
4477  header_len,
4478  body_len);
4479  if (validity != DBUS_VALID)
4480  {
4481  _dbus_verbose ("Failed to validate message body code %d\n", validity);
4482 
4483  loader->corrupted = TRUE;
4484  loader->corruption_reason = validity;
4485 
4486  goto failed;
4487  }
4488  }
4489 
4490  /* 3. COPY OVER UNIX FDS */
4494  &n_unix_fds);
4495 
4496 #ifdef HAVE_UNIX_FD_PASSING
4497 
4498  if (n_unix_fds > loader->n_unix_fds)
4499  {
4500  _dbus_verbose("Message contains references to more unix fds than were sent %u != %u\n",
4501  n_unix_fds, loader->n_unix_fds);
4502 
4503  loader->corrupted = TRUE;
4504  loader->corruption_reason = DBUS_INVALID_MISSING_UNIX_FDS;
4505  goto failed;
4506  }
4507 
4508  /* If this was a recycled message there might still be
4509  some memory allocated for the fds */
4510  dbus_free(message->unix_fds);
4511 
4512  if (n_unix_fds > 0)
4513  {
4514  message->unix_fds = _dbus_memdup(loader->unix_fds, n_unix_fds * sizeof(message->unix_fds[0]));
4515  if (message->unix_fds == NULL)
4516  {
4517  _dbus_verbose ("Failed to allocate file descriptor array\n");
4518  oom = TRUE;
4519  goto failed;
4520  }
4521 
4522  message->n_unix_fds_allocated = message->n_unix_fds = n_unix_fds;
4523  loader->n_unix_fds -= n_unix_fds;
4524  memmove (loader->unix_fds, loader->unix_fds + n_unix_fds, loader->n_unix_fds * sizeof (loader->unix_fds[0]));
4525 
4526  if (loader->unix_fds_change)
4527  loader->unix_fds_change (loader->unix_fds_change_data);
4528  }
4529  else
4530  message->unix_fds = NULL;
4531 
4532 #else
4533 
4534  if (n_unix_fds > 0)
4535  {
4536  _dbus_verbose ("Hmm, message claims to come with file descriptors "
4537  "but that's not supported on our platform, disconnecting.\n");
4538 
4539  loader->corrupted = TRUE;
4540  loader->corruption_reason = DBUS_INVALID_MISSING_UNIX_FDS;
4541  goto failed;
4542  }
4543 
4544 #endif
4545 
4546  /* 3. COPY OVER BODY AND QUEUE MESSAGE */
4547 
4548  if (!_dbus_list_append (&loader->messages, message))
4549  {
4550  _dbus_verbose ("Failed to append new message to loader queue\n");
4551  oom = TRUE;
4552  goto failed;
4553  }
4554 
4555  _dbus_assert (_dbus_string_get_length (&message->body) == 0);
4556  _dbus_assert (_dbus_string_get_length (&loader->data) >=
4557  (header_len + body_len));
4558 
4559  if (!_dbus_string_copy_len (&loader->data, header_len, body_len, &message->body, 0))
4560  {
4561  _dbus_verbose ("Failed to move body into new message\n");
4562  oom = TRUE;
4563  goto failed;
4564  }
4565 
4566  _dbus_string_delete (&loader->data, 0, header_len + body_len);
4567 
4568  /* don't waste more than 2k of memory */
4569  _dbus_string_compact (&loader->data, 2048);
4570 
4571  _dbus_assert (_dbus_string_get_length (&message->header.data) == header_len);
4572  _dbus_assert (_dbus_string_get_length (&message->body) == body_len);
4573 
4574  _dbus_verbose ("Loaded message %p\n", message);
4575 
4576  _dbus_assert (!oom);
4577  _dbus_assert (!loader->corrupted);
4578  _dbus_assert (loader->messages != NULL);
4579  _dbus_assert (_dbus_list_find_last (&loader->messages, message) != NULL);
4580 
4581  return TRUE;
4582 
4583  failed:
4584 
4585  /* Clean up */
4586 
4587  /* does nothing if the message isn't in the list */
4588  _dbus_list_remove_last (&loader->messages, message);
4589 
4590  if (oom)
4591  _dbus_assert (!loader->corrupted);
4592  else
4593  _dbus_assert (loader->corrupted);
4594 
4595  _dbus_verbose_bytes_of_string (&loader->data, 0, _dbus_string_get_length (&loader->data));
4596 
4597  return FALSE;
4598 }
4599 
4616 {
4617  while (!loader->corrupted &&
4618  _dbus_string_get_length (&loader->data) >= DBUS_MINIMUM_HEADER_SIZE)
4619  {
4620  DBusValidity validity;
4621  int byte_order, fields_array_len, header_len, body_len;
4622 
4624  &validity,
4625  &byte_order,
4626  &fields_array_len,
4627  &header_len,
4628  &body_len,
4629  &loader->data, 0,
4630  _dbus_string_get_length (&loader->data)))
4631  {
4632  DBusMessage *message;
4633 
4634  _dbus_assert (validity == DBUS_VALID);
4635 
4636  message = dbus_message_new_empty_header ();
4637  if (message == NULL)
4638  return FALSE;
4639 
4640  if (!load_message (loader, message,
4641  byte_order, fields_array_len,
4642  header_len, body_len))
4643  {
4644  dbus_message_unref (message);
4645  /* load_message() returns false if corrupted or OOM; if
4646  * corrupted then return TRUE for not OOM
4647  */
4648  return loader->corrupted;
4649  }
4650 
4651  _dbus_assert (loader->messages != NULL);
4652  _dbus_assert (_dbus_list_find_last (&loader->messages, message) != NULL);
4653  }
4654  else
4655  {
4656  _dbus_verbose ("Initial peek at header says we don't have a whole message yet, or data broken with invalid code %d\n",
4657  validity);
4658  if (validity != DBUS_VALID)
4659  {
4660  loader->corrupted = TRUE;
4661  loader->corruption_reason = validity;
4662  }
4663  return TRUE;
4664  }
4665  }
4666 
4667  return TRUE;
4668 }
4669 
4677 DBusMessage*
4679 {
4680  if (loader->messages)
4681  return loader->messages->data;
4682  else
4683  return NULL;
4684 }
4685 
4694 DBusMessage*
4696 {
4697  return _dbus_list_pop_first (&loader->messages);
4698 }
4699 
4708 DBusList*
4710 {
4711  return _dbus_list_pop_first_link (&loader->messages);
4712 }
4713 
4720 void
4722  DBusList *link)
4723 {
4724  _dbus_list_prepend_link (&loader->messages, link);
4725 }
4726 
4738 {
4739  _dbus_assert ((loader->corrupted && loader->corruption_reason != DBUS_VALID) ||
4740  (!loader->corrupted && loader->corruption_reason == DBUS_VALID));
4741  return loader->corrupted;
4742 }
4743 
4752 {
4753  _dbus_assert ((loader->corrupted && loader->corruption_reason != DBUS_VALID) ||
4754  (!loader->corrupted && loader->corruption_reason == DBUS_VALID));
4755 
4756  return loader->corruption_reason;
4757 }
4758 
4765 void
4767  long size)
4768 {
4769  if (size > DBUS_MAXIMUM_MESSAGE_LENGTH)
4770  {
4771  _dbus_verbose ("clamping requested max message size %ld to %d\n",
4774  }
4775  loader->max_message_size = size;
4776 }
4777 
4784 long
4786 {
4787  return loader->max_message_size;
4788 }
4789 
4796 void
4798  long n)
4799 {
4801  {
4802  _dbus_verbose ("clamping requested max message unix_fds %ld to %d\n",
4805  }
4806  loader->max_message_unix_fds = n;
4807 }
4808 
4815 long
4817 {
4818  return loader->max_message_unix_fds;
4819 }
4820 
4826 int
4828 {
4829 #ifdef HAVE_UNIX_FD_PASSING
4830  return loader->n_unix_fds;
4831 #else
4832  return 0;
4833 #endif
4834 }
4835 
4844 void
4846  void (* callback) (void *),
4847  void *data)
4848 {
4849 #ifdef HAVE_UNIX_FD_PASSING
4850  loader->unix_fds_change = callback;
4851  loader->unix_fds_change_data = data;
4852 #endif
4853 }
4854 
4855 static DBusDataSlotAllocator slot_allocator =
4856  _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (message_slots));
4857 
4873 dbus_message_allocate_data_slot (dbus_int32_t *slot_p)
4874 {
4875  return _dbus_data_slot_allocator_alloc (&slot_allocator,
4876  slot_p);
4877 }
4878 
4890 void
4891 dbus_message_free_data_slot (dbus_int32_t *slot_p)
4892 {
4893  _dbus_return_if_fail (*slot_p >= 0);
4894 
4895  _dbus_data_slot_allocator_free (&slot_allocator, slot_p);
4896 }
4897 
4913  dbus_int32_t slot,
4914  void *data,
4915  DBusFreeFunction free_data_func)
4916 {
4917  DBusFreeFunction old_free_func;
4918  void *old_data;
4919  dbus_bool_t retval;
4920 
4921  _dbus_return_val_if_fail (message != NULL, FALSE);
4922  _dbus_return_val_if_fail (slot >= 0, FALSE);
4923 
4924  retval = _dbus_data_slot_list_set (&slot_allocator,
4925  &message->slot_list,
4926  slot, data, free_data_func,
4927  &old_free_func, &old_data);
4928 
4929  if (retval)
4930  {
4931  /* Do the actual free outside the message lock */
4932  if (old_free_func)
4933  (* old_free_func) (old_data);
4934  }
4935 
4936  return retval;
4937 }
4938 
4947 void*
4949  dbus_int32_t slot)
4950 {
4951  void *res;
4952 
4953  _dbus_return_val_if_fail (message != NULL, NULL);
4954 
4955  res = _dbus_data_slot_list_get (&slot_allocator,
4956  &message->slot_list,
4957  slot);
4958 
4959  return res;
4960 }
4961 
4975 int
4976 dbus_message_type_from_string (const char *type_str)
4977 {
4978  if (strcmp (type_str, "method_call") == 0)
4980  if (strcmp (type_str, "method_return") == 0)
4982  else if (strcmp (type_str, "signal") == 0)
4983  return DBUS_MESSAGE_TYPE_SIGNAL;
4984  else if (strcmp (type_str, "error") == 0)
4985  return DBUS_MESSAGE_TYPE_ERROR;
4986  else
4988 }
4989 
5003 const char *
5005 {
5006  switch (type)
5007  {
5009  return "method_call";
5011  return "method_return";
5013  return "signal";
5015  return "error";
5016  default:
5017  return "invalid";
5018  }
5019 }
5020 
5035  char **marshalled_data_p,
5036  int *len_p)
5037 {
5038  DBusString tmp;
5039  dbus_bool_t was_locked;
5040 
5041  _dbus_return_val_if_fail (msg != NULL, FALSE);
5042  _dbus_return_val_if_fail (marshalled_data_p != NULL, FALSE);
5043  _dbus_return_val_if_fail (len_p != NULL, FALSE);
5044 
5045  if (!_dbus_string_init (&tmp))
5046  return FALSE;
5047 
5048  /* Ensure the message is locked, to ensure the length header is filled in. */
5049  was_locked = msg->locked;
5050 
5051  if (!was_locked)
5052  dbus_message_lock (msg);
5053 
5054  if (!_dbus_string_copy (&(msg->header.data), 0, &tmp, 0))
5055  goto fail;
5056 
5057  *len_p = _dbus_string_get_length (&tmp);
5058 
5059  if (!_dbus_string_copy (&(msg->body), 0, &tmp, *len_p))
5060  goto fail;
5061 
5062  *len_p = _dbus_string_get_length (&tmp);
5063 
5064  if (!_dbus_string_steal_data (&tmp, marshalled_data_p))
5065  goto fail;
5066 
5067  _dbus_string_free (&tmp);
5068 
5069  if (!was_locked)
5070  msg->locked = FALSE;
5071 
5072  return TRUE;
5073 
5074  fail:
5075  _dbus_string_free (&tmp);
5076 
5077  if (!was_locked)
5078  msg->locked = FALSE;
5079 
5080  return FALSE;
5081 }
5082 
5095 DBusMessage *
5096 dbus_message_demarshal (const char *str,
5097  int len,
5098  DBusError *error)
5099 {
5100  DBusMessageLoader *loader;
5101  DBusString *buffer;
5102  DBusMessage *msg;
5103 
5104  _dbus_return_val_if_fail (str != NULL, NULL);
5105 
5106  loader = _dbus_message_loader_new ();
5107 
5108  if (loader == NULL)
5109  return NULL;
5110 
5111  _dbus_message_loader_get_buffer (loader, &buffer, NULL, NULL);
5112 
5113  if (!_dbus_string_append_len (buffer, str, len))
5114  goto fail_oom;
5115 
5116  _dbus_message_loader_return_buffer (loader, buffer);
5117 
5119  goto fail_oom;
5120 
5122  goto fail_corrupt;
5123 
5124  msg = _dbus_message_loader_pop_message (loader);
5125 
5126  if (!msg)
5127  goto fail_oom;
5128 
5129  _dbus_message_loader_unref (loader);
5130  return msg;
5131 
5132  fail_corrupt:
5133  dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, "Message is corrupted (%s)",
5134  _dbus_validity_to_error_message (loader->corruption_reason));
5135  _dbus_message_loader_unref (loader);
5136  return NULL;
5137 
5138  fail_oom:
5139  _DBUS_SET_OOM (error);
5140  _dbus_message_loader_unref (loader);
5141  return NULL;
5142 }
5143 
5156 int
5158  int len)
5159 {
5160  DBusString str;
5161  int byte_order, fields_array_len, header_len, body_len;
5162  DBusValidity validity = DBUS_VALID;
5163  int have_message;
5164 
5165  if (!buf || len < DBUS_MINIMUM_HEADER_SIZE)
5166  return 0;
5167 
5168  if (len > DBUS_MAXIMUM_MESSAGE_LENGTH)
5170  _dbus_string_init_const_len (&str, buf, len);
5171 
5172  validity = DBUS_VALID;
5173  have_message
5175  &validity, &byte_order,
5176  &fields_array_len,
5177  &header_len,
5178  &body_len,
5179  &str, 0,
5180  len);
5181  _dbus_string_free (&str);
5182 
5183  if (validity == DBUS_VALID)
5184  {
5185  _dbus_assert (have_message || (header_len + body_len) > len);
5186  (void) have_message; /* unused unless asserting */
5187  return header_len + body_len;
5188  }
5189  else
5190  {
5191  return -1; /* broken! */
5192  }
5193 }
5194 
5216 void
5218  dbus_bool_t allow)
5219 {
5220  _dbus_return_if_fail (message != NULL);
5221  _dbus_return_if_fail (!message->locked);
5222 
5223  _dbus_header_toggle_flag (&message->header,
5225  allow);
5226 }
5227 
5236 {
5237  _dbus_return_val_if_fail (message != NULL, FALSE);
5238 
5239  return _dbus_header_get_flag (&message->header,
5241 }
5242 
5250 {
5251  DBusString data;
5252 };
5253 
5265 DBusVariant *
5267 {
5268  DBusVariant *self = NULL;
5269  /* Points to the single item we will read from the reader */
5270  DBusMessageRealIter *real_reader = (DBusMessageRealIter *) reader;
5271  /* The position in self at which we will write a single variant
5272  * (it is position 0) */
5273  DBusTypeWriter items_writer;
5274  /* The position in self at which we will write a copy of reader
5275  * (it is inside the variant) */
5276  DBusTypeWriter variant_writer;
5277  /* 'v' */
5278  DBusString variant_signature;
5279  /* Whatever is the signature of the item we will copy from the reader */
5280  DBusString contained_signature;
5281  /* TRUE if self->data needs to be freed */
5282  dbus_bool_t data_inited = FALSE;
5283  /* The type of the item we will read from the reader */
5284  int type;
5285  /* The string, start position within that string, and length of the signature
5286  * of the single complete type of the item reader points to */
5287  const DBusString *sig;
5288  int start, len;
5289 
5290  _dbus_assert (_dbus_message_iter_check (real_reader));
5291  _dbus_assert (real_reader->iter_type == DBUS_MESSAGE_ITER_TYPE_READER);
5293  type = dbus_message_iter_get_arg_type (reader);
5294  _dbus_type_reader_get_signature (&real_reader->u.reader, &sig, &start, &len);
5295 
5296  if (!_dbus_string_init (&contained_signature))
5297  return NULL;
5298 
5299  if (!_dbus_string_copy_len (sig, start, len, &contained_signature, 0))
5300  goto oom;
5301 
5302  self = dbus_new0 (DBusVariant, 1);
5303 
5304  if (self == NULL)
5305  goto oom;
5306 
5307  if (!_dbus_string_init (&self->data))
5308  goto oom;
5309 
5310  data_inited = TRUE;
5311 
5312  _dbus_type_writer_init_values_only (&items_writer, DBUS_COMPILER_BYTE_ORDER,
5313  &variant_signature, 0, &self->data, 0);
5314 
5315  if (!_dbus_type_writer_recurse (&items_writer, DBUS_TYPE_VARIANT,
5316  &contained_signature, 0, &variant_writer))
5317  goto oom;
5318 
5319  if (type == DBUS_TYPE_ARRAY)
5320  {
5321  /* Points to each item in turn inside the array we are copying */
5322  DBusMessageIter array_reader;
5323  /* Same as array_reader */
5324  DBusMessageRealIter *real_array_reader = (DBusMessageRealIter *) &array_reader;
5325  /* The position inside the copied array at which we will write
5326  * the copy of array_reader */
5327  DBusTypeWriter array_writer;
5328 
5329  dbus_message_iter_recurse (reader, &array_reader);
5330 
5331  if (!_dbus_type_writer_recurse (&variant_writer, type,
5332  &contained_signature, 1, &array_writer))
5333  goto oom;
5334 
5335  if (!_dbus_type_writer_write_reader (&array_writer,
5336  &real_array_reader->u.reader))
5337  goto oom;
5338 
5339  if (!_dbus_type_writer_unrecurse (&variant_writer, &array_writer))
5340  goto oom;
5341  }
5342  else if (type == DBUS_TYPE_DICT_ENTRY || type == DBUS_TYPE_VARIANT ||
5343  type == DBUS_TYPE_STRUCT)
5344  {
5345  /* Points to each item in turn inside the container we are copying */
5346  DBusMessageIter inner_reader;
5347  /* Same as inner_reader */
5348  DBusMessageRealIter *real_inner_reader = (DBusMessageRealIter *) &inner_reader;
5349  /* The position inside the copied container at which we will write the
5350  * copy of inner_reader */
5351  DBusTypeWriter inner_writer;
5352 
5353  dbus_message_iter_recurse (reader, &inner_reader);
5354 
5355  if (!_dbus_type_writer_recurse (&variant_writer, type, NULL, 0,
5356  &inner_writer))
5357  goto oom;
5358 
5359  if (!_dbus_type_writer_write_reader (&inner_writer,
5360  &real_inner_reader->u.reader))
5361  goto oom;
5362 
5363  if (!_dbus_type_writer_unrecurse (&variant_writer, &inner_writer))
5364  goto oom;
5365  }
5366  else
5367  {
5368  DBusBasicValue value;
5369 
5370  /* We eliminated all the container types above */
5372 
5373  dbus_message_iter_get_basic (reader, &value);
5374 
5375  if (!_dbus_type_writer_write_basic (&variant_writer, type, &value))
5376  goto oom;
5377  }
5378 
5379  _dbus_string_free (&contained_signature);
5380  return self;
5381 
5382 oom:
5383  if (self != NULL)
5384  {
5385  if (data_inited)
5386  _dbus_string_free (&self->data);
5387 
5388  dbus_free (self);
5389  }
5390 
5391  _dbus_string_free (&contained_signature);
5392  return NULL;
5393 }
5394 
5401 const char *
5403 {
5404  unsigned char len;
5405  const char *ret;
5406 
5407  _dbus_assert (self != NULL);
5408 
5409  /* Here we make use of the fact that the serialization of a variant starts
5410  * with the 1-byte length, then that many bytes of signature, then \0. */
5411  len = _dbus_string_get_byte (&self->data, 0);
5412  ret = _dbus_string_get_const_data_len (&self->data, 1, len);
5413  _dbus_assert (strlen (ret) == len);
5414  return ret;
5415 }
5416 
5430  DBusMessageIter *writer)
5431 {
5432  /* 'v' */
5433  DBusString variant_signature;
5434  /* Points to the single item in self */
5435  DBusTypeReader variant_reader;
5436  /* Points to the single item (of whatever type) inside the variant */
5437  DBusTypeReader reader;
5438  /* The position at which we will copy reader */
5439  DBusMessageRealIter *real_writer = (DBusMessageRealIter *) writer;
5440  dbus_bool_t ret;
5441 
5442  _dbus_assert (self != NULL);
5443  _dbus_assert (_dbus_message_iter_append_check (real_writer));
5444  _dbus_assert (real_writer->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER);
5445 
5447  _dbus_type_reader_init (&reader, DBUS_COMPILER_BYTE_ORDER,
5448  &variant_signature, 0, &self->data, 0);
5449  _dbus_type_reader_recurse (&reader, &variant_reader);
5450 
5451  if (!_dbus_message_iter_open_signature (real_writer))
5452  return FALSE;
5453 
5454  ret = _dbus_type_writer_write_reader (&real_writer->u.writer,
5455  &variant_reader);
5456 
5457  if (!_dbus_message_iter_close_signature (real_writer))
5458  return FALSE;
5459 
5460  return ret;
5461 }
5462 
5463 int
5464 _dbus_variant_get_length (DBusVariant *self)
5465 {
5466  _dbus_assert (self != NULL);
5467  return _dbus_string_get_length (&self->data);
5468 }
5469 
5470 const DBusString *
5471 _dbus_variant_peek (DBusVariant *self)
5472 {
5473  _dbus_assert (self != NULL);
5474  return &self->data;
5475 }
5476 
5477 void
5478 _dbus_variant_free (DBusVariant *self)
5479 {
5480  _dbus_assert (self != NULL);
5481  _dbus_string_free (&self->data);
5482  dbus_free (self);
5483 }
5484 
5485 // ********************************PDP********************************
5486 #ifdef HAVE_PDPLINUX
5487 
5488 #ifdef PDP_EXEC_INTERNAL_CHECK_SENDER
5489 #else
5490 //-----------------------------------------------------------------------------------------------
5491 const char*
5492 dbus_pdplinux_message_get_exec_src (DBusMessage *message)
5493 {
5494  const char *v;
5495  _dbus_return_val_if_fail (message != NULL, NULL);
5496  v = NULL;
5497 
5499  DBUS_HEADER_FIELD_EXEC_SRC,
5501  (void *) &v);
5502 
5503  return v;
5504 }
5505 
5506 //-----------------------------------------------------------------------------------------------
5508 dbus_pdplinux_message_set_exec_src ( DBusMessage *message,char* sProcName)
5509 {
5510  dbus_bool_t res=FALSE;
5511 
5512  _dbus_return_val_if_fail (message != NULL, FALSE);
5513  _dbus_return_val_if_fail (!message->locked, FALSE);
5514 
5515  res=set_or_delete_string_field (message,
5516  DBUS_HEADER_FIELD_EXEC_SRC,
5518  sProcName);
5519 
5520  return res;
5521 }
5522 #endif //PDP_EXEC_INTERNAL_CHECK_SENDER
5523 
5524 #ifdef PDP_EXEC_INTERNAL_CHECK_RECIEVER
5525 #else
5526 //-----------------------------------------------------------------------------------------------
5527 const char*
5528 dbus_pdplinux_message_get_exec_dst (DBusMessage *message)
5529 {
5530  const char *v;
5531  _dbus_return_val_if_fail (message != NULL, NULL);
5532  v = NULL;
5533 
5535  DBUS_HEADER_FIELD_EXEC_DST,
5537  (void *) &v);
5538 
5539  return v;
5540 }
5541 
5542 //-----------------------------------------------------------------------------------------------
5543 #error ("Function dbus_pdplinux_message_set_exec_dst never used yet, so can't use it to determine dst proc")
5544 
5546 dbus_pdplinux_message_set_exec_dst ( DBusMessage *message,char* sProcName)
5547 {
5548  dbus_bool_t res=FALSE;
5549 
5550  _dbus_return_val_if_fail (message != NULL, FALSE);
5551  _dbus_return_val_if_fail (!message->locked, FALSE);
5552 
5553  res=set_or_delete_string_field (message,
5554  DBUS_HEADER_FIELD_EXEC_DST,
5556  sProcName);
5557 
5558  return res;
5559 }
5560 #endif // PDP_EXEC_INTERNAL_CHECK_RECIEVER
5561 
5562 //-----------------------------------------------------------------------------------------------
5564 dbus_pdplinux_message_set_skip_mandatory( DBusMessage *message, dbus_bool_t is_skip_mandatory){
5565  dbus_bool_t res=TRUE;
5566  _dbus_verbose("Setting message %p skip_mandatory to %s\n",message,is_skip_mandatory ? "TRUE" : "FALSE");
5567  message->message_skip_mandatory=is_skip_mandatory;
5568  return res;
5569 }
5570 
5571 //-----------------------------------------------------------------------------------------------
5573 dbus_pdplinux_message_get_skip_mandatory( DBusMessage *message){
5574  return message->message_skip_mandatory;
5575 }
5576 
5577 #endif //HAVE_PDPLINUX
5578 
5581 /* 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:3044
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:3218
_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:3432
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:5235
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:37
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:3060
_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:4751
_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:1209
_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:1693
_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:4797
_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_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:3744
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:3836
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:5217
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:2893
_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_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:4615
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:2957
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:4827
_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:5157
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:1716
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:1399
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)
The type of a function which frees a block of 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:5004
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:2042
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:4059
_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:408
_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:4721
_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:1429
dbus_message_new
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type.
Definition: dbus-message.c:1315
_dbus_header_get_serial
dbus_uint32_t _dbus_header_get_serial(DBusHeader *header)
See dbus_message_get_serial()
Definition: dbus-marshal-header.c:431
_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:2111
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:3483
DBusHeader
Message header data and some cached details of it.
Definition: dbus-marshal-header.h:48
_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:4766
_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:4145
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:4845
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:3605
_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:983
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:178
_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:3068
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:4785
_dbus_header_get_message_type
int _dbus_header_get_message_type(DBusHeader *header)
Gets the type of the message.
Definition: dbus-marshal-header.c:390
_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)
Locks a global lock, initializing it first if necessary.
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:5429
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:4873
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:2142
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:3509
TRUE
#define TRUE
Expands to "1".
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:2205
_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_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:3330
_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:4737
DBUS_MINIMUM_HEADER_SIZE
#define DBUS_MINIMUM_HEADER_SIZE
The smallest header size that can occur.
Definition: dbus-protocol.h:359
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:3094
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:3631
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:3891
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:2013
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:3684
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:3354
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:3959
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:2340
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:2742
DBusTypeReader
The type reader is an iterator for reading values from a block of values.
Definition: dbus-marshal-recursive.h:40
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:2186
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:1470
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:4088
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_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:3547
_DBUS_LOCK_NAME
#define _DBUS_LOCK_NAME(name)
Expands to name of a global lock variable.
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:3659
_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:466
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:43
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:3713
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:4948
_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:4159
_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:4816
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:3777
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:2504
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:1492
_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:3301
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:3988
_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:5250
FALSE
#define FALSE
Expands to "0".
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:494
_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_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:3924
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:100
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:3153
_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_getenv
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:187
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:1568
_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:4196
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)
Aborts with an error message if called.
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:677
_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:1405
_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:4678
_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:3569
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_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:3461
_dbus_header_free
void _dbus_header_free(DBusHeader *header)
Frees a header.
Definition: dbus-marshal-header.c:480
_dbus_message_loader_new
DBusMessageLoader * _dbus_message_loader_new(void)
Creates a new message loader.
Definition: dbus-message.c:4097
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:404
_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:55
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:3279
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:1364
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)
Safe macro for using dbus_malloc().
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:4912
_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)
Aborts with an error message if the condition is false.
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:3481
_dbus_warn
void _dbus_warn(const char *format,...)
Prints a warning message to stderr.
Definition: dbus-internals.c:263
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:2474
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:644
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:3864
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:49
DBusMessageIter
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:62
_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:1509
DBusDataSlotAllocator
An allocator that tracks a set of slot IDs.
Definition: dbus-dataslot.h:56
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:1824
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:2161
DBusBasicValue
A simple value union that lets you access bytes as if they were various types; useful when dealing wi...
Definition: dbus-types.h:138
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:5034
_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
A node in a linked list.
Definition: dbus-list.h:35
_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:2242
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:4302
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:2267
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)
Used to iterate over each item in a collection, such as a DBusList.
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:1613
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:3237
_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:5266
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:3260
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:4976
_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:2385
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:3021
_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:4709
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:4891
_DBUS_UNLOCK
#define _DBUS_UNLOCK(name)
Unlocks a global lock.
Definition: dbus-internals.h:373
DBusMessageLoader
Implementation details of DBusMessageLoader.
Definition: dbus-message-private.h:61
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:1748
DBusError::message
const char * message
public error message field
Definition: dbus-errors.h:51
_DBUS_ZERO
#define _DBUS_ZERO(object)
Sets all bits in an object to zero.
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:5402
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:1450
_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)
Safe macro for using dbus_malloc0().
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:127
_dbus_memdup
void * _dbus_memdup(const void *mem, size_t n_bytes)
Duplicates a block of memory.
Definition: dbus-internals.c:672
DBusMessageIter_1_10_0
Layout of a DBusMessageIter on the stack in dbus 1.10.0.
Definition: dbus-message.c:145
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:1496
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:5096
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:447
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:1359
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:382
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:532
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:65
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:1856
_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:4695
_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:1286
_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:464
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:4030
_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:295
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:2429
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
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:3398
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:3520
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:50
NULL
#define NULL
A null pointer, defined appropriately for C or C++.