1 /* GDBus - GLib D-Bus Library
3 * Copyright (C) 2008-2010 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 * Author: David Zeuthen <davidz@redhat.com>
21 /* Uncomment to debug serializer code */
22 /* #define DEBUG_SERIALIZER */
28 #include <sys/types.h>
32 #include <sys/mkdev.h>
33 #elif MAJOR_IN_SYSMACROS
34 #include <sys/sysmacros.h>
37 #include "gdbusutils.h"
38 #include "gdbusmessage.h"
39 #include "gdbuserror.h"
40 #include "gioenumtypes.h"
41 #include "ginputstream.h"
42 #include "gdatainputstream.h"
43 #include "gmemoryinputstream.h"
44 #include "goutputstream.h"
45 #include "gdataoutputstream.h"
46 #include "gmemoryoutputstream.h"
47 #include "gseekable.h"
49 #include "gdbusprivate.h"
52 #include "gunixfdlist.h"
57 typedef struct _GMemoryBuffer GMemoryBuffer;
64 GDataStreamByteOrder byte_order;
68 g_memory_buffer_read_byte (GMemoryBuffer *mbuf)
70 if (mbuf->pos >= mbuf->valid_len)
72 return mbuf->data [mbuf->pos++];
76 g_memory_buffer_read_int16 (GMemoryBuffer *mbuf)
80 if (mbuf->pos > mbuf->valid_len - 2)
82 mbuf->pos = mbuf->valid_len;
86 memcpy (&v, mbuf->data + mbuf->pos, 2);
88 switch (mbuf->byte_order)
90 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
91 v = GINT16_FROM_BE (v);
93 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
94 v = GINT16_FROM_LE (v);
96 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
104 g_memory_buffer_read_uint16 (GMemoryBuffer *mbuf)
108 if (mbuf->pos > mbuf->valid_len - 2)
110 mbuf->pos = mbuf->valid_len;
114 memcpy (&v, mbuf->data + mbuf->pos, 2);
116 switch (mbuf->byte_order)
118 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
119 v = GINT16_FROM_BE (v);
121 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
122 v = GINT16_FROM_LE (v);
124 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
132 g_memory_buffer_read_int32 (GMemoryBuffer *mbuf)
136 if (mbuf->pos > mbuf->valid_len - 4)
138 mbuf->pos = mbuf->valid_len;
142 memcpy (&v, mbuf->data + mbuf->pos, 4);
144 switch (mbuf->byte_order)
146 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
147 v = GINT32_FROM_BE (v);
149 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
150 v = GINT32_FROM_LE (v);
152 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
160 g_memory_buffer_read_uint32 (GMemoryBuffer *mbuf)
164 if (mbuf->pos > mbuf->valid_len - 4)
166 mbuf->pos = mbuf->valid_len;
170 memcpy (&v, mbuf->data + mbuf->pos, 4);
172 switch (mbuf->byte_order)
174 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
175 v = GUINT32_FROM_BE (v);
177 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
178 v = GUINT32_FROM_LE (v);
180 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
188 g_memory_buffer_read_int64 (GMemoryBuffer *mbuf)
192 if (mbuf->pos > mbuf->valid_len - 8)
194 mbuf->pos = mbuf->valid_len;
198 memcpy (&v, mbuf->data + mbuf->pos, 8);
200 switch (mbuf->byte_order)
202 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
203 v = GINT64_FROM_BE (v);
205 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
206 v = GINT64_FROM_LE (v);
208 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
216 g_memory_buffer_read_uint64 (GMemoryBuffer *mbuf)
220 if (mbuf->pos > mbuf->valid_len - 8)
222 mbuf->pos = mbuf->valid_len;
226 memcpy (&v, mbuf->data + mbuf->pos, 8);
228 switch (mbuf->byte_order)
230 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
231 v = GUINT64_FROM_BE (v);
233 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
234 v = GUINT64_FROM_LE (v);
236 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
243 #define MIN_ARRAY_SIZE 128
246 g_nearest_pow (gint num)
257 array_resize (GMemoryBuffer *mbuf,
263 if (mbuf->len == size)
267 data = g_realloc (mbuf->data, size);
270 memset ((guint8 *)data + len, 0, size - len);
275 if (mbuf->len < mbuf->valid_len)
276 mbuf->valid_len = mbuf->len;
280 g_memory_buffer_write (GMemoryBuffer *mbuf,
290 /* Check for address space overflow, but only if the buffer is resizable.
291 Otherwise we just do a short write and don't worry. */
292 if (mbuf->pos + count < mbuf->pos)
295 if (mbuf->pos + count > mbuf->len)
297 /* At least enought to fit the write, rounded up
298 for greater than linear growth.
299 TODO: This wastes a lot of memory at large buffer sizes.
300 Figure out a more rational allocation strategy. */
301 new_size = g_nearest_pow (mbuf->pos + count);
302 /* Check for overflow again. We have only checked if
303 pos + count > G_MAXSIZE, but it only catches the case of writing
304 more than 4GiB total on a 32-bit system. There's still the problem
305 of g_nearest_pow overflowing above 0x7fffffff, so we're
306 effectively limited to 2GiB. */
307 if (new_size < mbuf->len)
310 new_size = MAX (new_size, MIN_ARRAY_SIZE);
311 array_resize (mbuf, new_size);
314 dest = (guint8 *)mbuf->data + mbuf->pos;
315 memcpy (dest, buffer, count);
318 if (mbuf->pos > mbuf->valid_len)
319 mbuf->valid_len = mbuf->pos;
325 g_memory_buffer_put_byte (GMemoryBuffer *mbuf,
328 return g_memory_buffer_write (mbuf, &data, 1);
332 g_memory_buffer_put_int16 (GMemoryBuffer *mbuf,
335 switch (mbuf->byte_order)
337 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
338 data = GINT16_TO_BE (data);
340 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
341 data = GINT16_TO_LE (data);
343 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
348 return g_memory_buffer_write (mbuf, &data, 2);
352 g_memory_buffer_put_uint16 (GMemoryBuffer *mbuf,
355 switch (mbuf->byte_order)
357 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
358 data = GUINT16_TO_BE (data);
360 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
361 data = GUINT16_TO_LE (data);
363 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
368 return g_memory_buffer_write (mbuf, &data, 2);
372 g_memory_buffer_put_int32 (GMemoryBuffer *mbuf,
375 switch (mbuf->byte_order)
377 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
378 data = GINT32_TO_BE (data);
380 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
381 data = GINT32_TO_LE (data);
383 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
388 return g_memory_buffer_write (mbuf, &data, 4);
392 g_memory_buffer_put_uint32 (GMemoryBuffer *mbuf,
395 switch (mbuf->byte_order)
397 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
398 data = GUINT32_TO_BE (data);
400 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
401 data = GUINT32_TO_LE (data);
403 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
408 return g_memory_buffer_write (mbuf, &data, 4);
412 g_memory_buffer_put_int64 (GMemoryBuffer *mbuf,
415 switch (mbuf->byte_order)
417 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
418 data = GINT64_TO_BE (data);
420 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
421 data = GINT64_TO_LE (data);
423 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
428 return g_memory_buffer_write (mbuf, &data, 8);
432 g_memory_buffer_put_uint64 (GMemoryBuffer *mbuf,
435 switch (mbuf->byte_order)
437 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
438 data = GUINT64_TO_BE (data);
440 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
441 data = GUINT64_TO_LE (data);
443 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
448 return g_memory_buffer_write (mbuf, &data, 8);
452 g_memory_buffer_put_string (GMemoryBuffer *mbuf,
455 g_return_val_if_fail (str != NULL, FALSE);
457 return g_memory_buffer_write (mbuf, str, strlen (str));
462 * SECTION:gdbusmessage
463 * @short_description: D-Bus Message
464 * @include: gio/gio.h
466 * A type for representing D-Bus messages that can be sent or received
467 * on a #GDBusConnection.
470 typedef struct _GDBusMessageClass GDBusMessageClass;
475 * Class structure for #GDBusMessage.
479 struct _GDBusMessageClass
482 GObjectClass parent_class;
488 * The #GDBusMessage structure contains only private data and should
489 * only be accessed using the provided API.
496 GObject parent_instance;
498 GDBusMessageType type;
499 GDBusMessageFlags flags;
501 GDBusMessageByteOrder byte_order;
502 guchar major_protocol_version;
507 GUnixFDList *fd_list;
517 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
520 g_dbus_message_finalize (GObject *object)
522 GDBusMessage *message = G_DBUS_MESSAGE (object);
524 if (message->headers != NULL)
525 g_hash_table_unref (message->headers);
526 if (message->body != NULL)
527 g_variant_unref (message->body);
529 if (message->fd_list != NULL)
530 g_object_unref (message->fd_list);
533 if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
534 G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
538 g_dbus_message_get_property (GObject *object,
543 GDBusMessage *message = G_DBUS_MESSAGE (object);
548 g_value_set_boolean (value, g_dbus_message_get_locked (message));
552 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
558 g_dbus_message_class_init (GDBusMessageClass *klass)
560 GObjectClass *gobject_class;
562 gobject_class = G_OBJECT_CLASS (klass);
563 gobject_class->finalize = g_dbus_message_finalize;
564 gobject_class->get_property = g_dbus_message_get_property;
567 * GDBusConnection:locked:
569 * A boolean specifying whether the message is locked.
573 g_object_class_install_property (gobject_class,
575 g_param_spec_boolean ("locked",
577 P_("Whether the message is locked"),
580 G_PARAM_STATIC_NAME |
581 G_PARAM_STATIC_BLURB |
582 G_PARAM_STATIC_NICK));
586 g_dbus_message_init (GDBusMessage *message)
588 /* Any D-Bus implementation is supposed to handle both Big and
589 * Little Endian encodings and the Endianness is part of the D-Bus
590 * message - we prefer to use Big Endian (since it's Network Byte
591 * Order and just easier to read for humans) but if the machine is
592 * Little Endian we use that for performance reasons.
594 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
595 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
597 /* this could also be G_PDP_ENDIAN */
598 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
600 message->headers = g_hash_table_new_full (g_direct_hash,
603 (GDestroyNotify) g_variant_unref);
607 * g_dbus_message_new:
609 * Creates a new empty #GDBusMessage.
611 * Returns: A #GDBusMessage. Free with g_object_unref().
616 g_dbus_message_new (void)
618 return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
622 * g_dbus_message_new_method_call:
623 * @name: (allow-none): A valid D-Bus name or %NULL.
624 * @path: A valid object path.
625 * @interface_: (allow-none): A valid D-Bus interface name or %NULL.
626 * @method: A valid method name.
628 * Creates a new #GDBusMessage for a method call.
630 * Returns: A #GDBusMessage. Free with g_object_unref().
635 g_dbus_message_new_method_call (const gchar *name,
637 const gchar *interface_,
640 GDBusMessage *message;
642 g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
643 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
644 g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
645 g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
647 message = g_dbus_message_new ();
648 message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
651 g_dbus_message_set_destination (message, name);
652 g_dbus_message_set_path (message, path);
653 g_dbus_message_set_member (message, method);
654 if (interface_ != NULL)
655 g_dbus_message_set_interface (message, interface_);
661 * g_dbus_message_new_signal:
662 * @path: A valid object path.
663 * @interface_: A valid D-Bus interface name.
664 * @signal: A valid signal name.
666 * Creates a new #GDBusMessage for a signal emission.
668 * Returns: A #GDBusMessage. Free with g_object_unref().
673 g_dbus_message_new_signal (const gchar *path,
674 const gchar *interface_,
677 GDBusMessage *message;
679 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
680 g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
681 g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
683 message = g_dbus_message_new ();
684 message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
685 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
687 g_dbus_message_set_path (message, path);
688 g_dbus_message_set_member (message, signal);
689 g_dbus_message_set_interface (message, interface_);
696 * g_dbus_message_new_method_reply:
697 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
698 * create a reply message to.
700 * Creates a new #GDBusMessage that is a reply to @method_call_message.
702 * Returns: (transfer full): #GDBusMessage. Free with g_object_unref().
707 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
709 GDBusMessage *message;
712 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
713 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
714 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
716 message = g_dbus_message_new ();
717 message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
718 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
719 /* reply with same endianness */
720 message->byte_order = method_call_message->byte_order;
722 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
723 sender = g_dbus_message_get_sender (method_call_message);
725 g_dbus_message_set_destination (message, sender);
731 * g_dbus_message_new_method_error:
732 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
733 * create a reply message to.
734 * @error_name: A valid D-Bus error name.
735 * @error_message_format: The D-Bus error message in a printf() format.
736 * @...: Arguments for @error_message_format.
738 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
740 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
745 g_dbus_message_new_method_error (GDBusMessage *method_call_message,
746 const gchar *error_name,
747 const gchar *error_message_format,
753 va_start (var_args, error_message_format);
754 ret = g_dbus_message_new_method_error_valist (method_call_message,
756 error_message_format,
764 * g_dbus_message_new_method_error_literal:
765 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
766 * create a reply message to.
767 * @error_name: A valid D-Bus error name.
768 * @error_message: The D-Bus error message.
770 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
772 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
777 g_dbus_message_new_method_error_literal (GDBusMessage *method_call_message,
778 const gchar *error_name,
779 const gchar *error_message)
781 GDBusMessage *message;
784 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
785 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
786 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
787 g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
788 g_return_val_if_fail (error_message != NULL, NULL);
790 message = g_dbus_message_new ();
791 message->type = G_DBUS_MESSAGE_TYPE_ERROR;
792 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
793 /* reply with same endianness */
794 message->byte_order = method_call_message->byte_order;
796 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
797 g_dbus_message_set_error_name (message, error_name);
798 g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
800 sender = g_dbus_message_get_sender (method_call_message);
802 g_dbus_message_set_destination (message, sender);
808 * g_dbus_message_new_method_error_valist:
809 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
810 * create a reply message to.
811 * @error_name: A valid D-Bus error name.
812 * @error_message_format: The D-Bus error message in a printf() format.
813 * @var_args: Arguments for @error_message_format.
815 * Like g_dbus_message_new_method_error() but intended for language bindings.
817 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
823 g_dbus_message_new_method_error_valist (GDBusMessage *method_call_message,
824 const gchar *error_name,
825 const gchar *error_message_format,
829 gchar *error_message;
830 error_message = g_strdup_vprintf (error_message_format, var_args);
831 ret = g_dbus_message_new_method_error_literal (method_call_message,
834 g_free (error_message);
838 /* ---------------------------------------------------------------------------------------------------- */
841 * g_dbus_message_get_byte_order:
842 * @message: A #GDBusMessage.
844 * Gets the byte order of @message.
846 * Returns: The byte order.
848 GDBusMessageByteOrder
849 g_dbus_message_get_byte_order (GDBusMessage *message)
851 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
852 return message->byte_order;
856 * g_dbus_message_set_byte_order:
857 * @message: A #GDBusMessage.
858 * @byte_order: The byte order.
860 * Sets the byte order of @message.
863 g_dbus_message_set_byte_order (GDBusMessage *message,
864 GDBusMessageByteOrder byte_order)
866 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
870 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
874 message->byte_order = byte_order;
877 /* ---------------------------------------------------------------------------------------------------- */
879 /* TODO: need GI annotations to specify that any guchar value goes for the type */
882 * g_dbus_message_get_message_type:
883 * @message: A #GDBusMessage.
885 * Gets the type of @message.
887 * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
892 g_dbus_message_get_message_type (GDBusMessage *message)
894 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
895 return message->type;
899 * g_dbus_message_set_message_type:
900 * @message: A #GDBusMessage.
901 * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
903 * Sets @message to be of @type.
908 g_dbus_message_set_message_type (GDBusMessage *message,
909 GDBusMessageType type)
911 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
912 g_return_if_fail (type >=0 && type < 256);
916 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
920 message->type = type;
923 /* ---------------------------------------------------------------------------------------------------- */
925 /* TODO: need GI annotations to specify that any guchar value goes for flags */
928 * g_dbus_message_get_flags:
929 * @message: A #GDBusMessage.
931 * Gets the flags for @message.
933 * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
938 g_dbus_message_get_flags (GDBusMessage *message)
940 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
941 return message->flags;
945 * g_dbus_message_set_flags:
946 * @message: A #GDBusMessage.
947 * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
948 * enumeration bitwise ORed together).
950 * Sets the flags to set on @message.
955 g_dbus_message_set_flags (GDBusMessage *message,
956 GDBusMessageFlags flags)
958 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
959 g_return_if_fail (flags >=0 && flags < 256);
963 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
967 message->flags = flags;
970 /* ---------------------------------------------------------------------------------------------------- */
973 * g_dbus_message_get_serial:
974 * @message: A #GDBusMessage.
976 * Gets the serial for @message.
978 * Returns: A #guint32.
983 g_dbus_message_get_serial (GDBusMessage *message)
985 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
986 return message->serial;
990 * g_dbus_message_set_serial:
991 * @message: A #GDBusMessage.
992 * @serial: A #guint32.
994 * Sets the serial for @message.
999 g_dbus_message_set_serial (GDBusMessage *message,
1002 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1004 if (message->locked)
1006 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1010 message->serial = serial;
1013 /* ---------------------------------------------------------------------------------------------------- */
1015 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
1018 * g_dbus_message_get_header:
1019 * @message: A #GDBusMessage.
1020 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1022 * Gets a header field on @message.
1024 * Returns: A #GVariant with the value if the header was found, %NULL
1025 * otherwise. Do not free, it is owned by @message.
1030 g_dbus_message_get_header (GDBusMessage *message,
1031 GDBusMessageHeaderField header_field)
1033 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1034 g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
1035 return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
1039 * g_dbus_message_set_header:
1040 * @message: A #GDBusMessage.
1041 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1042 * @value: (allow-none): A #GVariant to set the header field or %NULL to clear the header field.
1044 * Sets a header field on @message.
1046 * If @value is floating, @message assumes ownership of @value.
1051 g_dbus_message_set_header (GDBusMessage *message,
1052 GDBusMessageHeaderField header_field,
1055 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1056 g_return_if_fail (header_field >=0 && header_field < 256);
1058 if (message->locked)
1060 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1066 g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
1070 g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
1075 * g_dbus_message_get_header_fields:
1076 * @message: A #GDBusMessage.
1078 * Gets an array of all header fields on @message that are set.
1080 * Returns: (array zero-terminated=1): An array of header fields
1081 * terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element
1082 * is a #guchar. Free with g_free().
1087 g_dbus_message_get_header_fields (GDBusMessage *message)
1095 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1097 keys = g_hash_table_get_keys (message->headers);
1098 num_keys = g_list_length (keys);
1099 ret = g_new (guchar, num_keys + 1);
1100 for (l = keys, n = 0; l != NULL; l = l->next, n++)
1101 ret[n] = GPOINTER_TO_UINT (l->data);
1102 g_assert (n == num_keys);
1103 ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
1109 /* ---------------------------------------------------------------------------------------------------- */
1112 * g_dbus_message_get_body:
1113 * @message: A #GDBusMessage.
1115 * Gets the body of a message.
1117 * Returns: (transfer none): A #GVariant or %NULL if the body is
1118 * empty. Do not free, it is owned by @message.
1123 g_dbus_message_get_body (GDBusMessage *message)
1125 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1126 return message->body;
1130 * g_dbus_message_set_body:
1131 * @message: A #GDBusMessage.
1132 * @body: Either %NULL or a #GVariant that is a tuple.
1134 * Sets the body @message. As a side-effect the
1135 * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
1136 * type string of @body (or cleared if @body is %NULL).
1138 * If @body is floating, @message assumes ownership of @body.
1143 g_dbus_message_set_body (GDBusMessage *message,
1146 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1147 g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
1149 if (message->locked)
1151 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1155 if (message->body != NULL)
1156 g_variant_unref (message->body);
1159 message->body = NULL;
1160 g_dbus_message_set_signature (message, NULL);
1164 const gchar *type_string;
1165 gsize type_string_len;
1168 message->body = g_variant_ref_sink (body);
1170 type_string = g_variant_get_type_string (body);
1171 type_string_len = strlen (type_string);
1172 g_assert (type_string_len >= 2);
1173 signature = g_strndup (type_string + 1, type_string_len - 2);
1174 g_dbus_message_set_signature (message, signature);
1179 /* ---------------------------------------------------------------------------------------------------- */
1183 * g_dbus_message_get_unix_fd_list:
1184 * @message: A #GDBusMessage.
1186 * Gets the UNIX file descriptors associated with @message, if any.
1188 * This method is only available on UNIX.
1190 * Returns: (transfer none):A #GUnixFDList or %NULL if no file descriptors are
1191 * associated. Do not free, this object is owned by @message.
1196 g_dbus_message_get_unix_fd_list (GDBusMessage *message)
1198 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1199 return message->fd_list;
1203 * g_dbus_message_set_unix_fd_list:
1204 * @message: A #GDBusMessage.
1205 * @fd_list: (allow-none): A #GUnixFDList or %NULL.
1207 * Sets the UNIX file descriptors associated with @message. As a
1208 * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
1209 * field is set to the number of fds in @fd_list (or cleared if
1210 * @fd_list is %NULL).
1212 * This method is only available on UNIX.
1217 g_dbus_message_set_unix_fd_list (GDBusMessage *message,
1218 GUnixFDList *fd_list)
1220 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1221 g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
1223 if (message->locked)
1225 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1229 if (message->fd_list != NULL)
1230 g_object_unref (message->fd_list);
1231 if (fd_list != NULL)
1233 message->fd_list = g_object_ref (fd_list);
1234 g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
1238 message->fd_list = NULL;
1239 g_dbus_message_set_num_unix_fds (message, 0);
1244 /* ---------------------------------------------------------------------------------------------------- */
1247 validate_headers (GDBusMessage *message,
1252 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
1253 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1257 switch (message->type)
1259 case G_DBUS_MESSAGE_TYPE_INVALID:
1260 g_set_error_literal (error,
1262 G_IO_ERROR_INVALID_ARGUMENT,
1263 _("type is INVALID"));
1267 case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
1268 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1269 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1271 g_set_error_literal (error,
1273 G_IO_ERROR_INVALID_ARGUMENT,
1274 _("METHOD_CALL message: PATH or MEMBER header field is missing"));
1279 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
1280 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1282 g_set_error_literal (error,
1284 G_IO_ERROR_INVALID_ARGUMENT,
1285 _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
1290 case G_DBUS_MESSAGE_TYPE_ERROR:
1291 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
1292 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1294 g_set_error_literal (error,
1296 G_IO_ERROR_INVALID_ARGUMENT,
1297 _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
1302 case G_DBUS_MESSAGE_TYPE_SIGNAL:
1303 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1304 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
1305 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1307 g_set_error_literal (error,
1309 G_IO_ERROR_INVALID_ARGUMENT,
1310 _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
1313 if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
1315 g_set_error_literal (error,
1317 G_IO_ERROR_INVALID_ARGUMENT,
1318 _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
1321 if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
1323 g_set_error_literal (error,
1325 G_IO_ERROR_INVALID_ARGUMENT,
1326 _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
1332 /* hitherto unknown type - nothing to check */
1339 g_assert (ret || (error == NULL || *error != NULL));
1343 /* ---------------------------------------------------------------------------------------------------- */
1346 ensure_input_padding (GMemoryBuffer *buf,
1350 gsize wanted_offset;
1353 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1354 buf->pos = wanted_offset;
1358 static const gchar *
1359 read_string (GMemoryBuffer *mbuf,
1364 const gchar *end_valid;
1366 if (mbuf->pos + len >= mbuf->valid_len || mbuf->pos + len < mbuf->pos)
1368 mbuf->pos = mbuf->valid_len;
1369 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
1372 G_IO_ERROR_INVALID_ARGUMENT,
1373 g_dngettext (GETTEXT_PACKAGE,
1374 "Wanted to read %lu byte but only got %lu",
1375 "Wanted to read %lu bytes but only got %lu",
1378 (gulong)(mbuf->valid_len - mbuf->pos));
1382 if (mbuf->data[mbuf->pos + len] != '\0')
1384 str = g_strndup (mbuf->data + mbuf->pos, len);
1387 G_IO_ERROR_INVALID_ARGUMENT,
1388 _("Expected NUL byte after the string '%s' but found byte %d"),
1389 str, mbuf->data[mbuf->pos + len]);
1391 mbuf->pos += len + 1;
1395 str = mbuf->data + mbuf->pos;
1396 mbuf->pos += len + 1;
1398 if (!g_utf8_validate (str, -1, &end_valid))
1402 offset = (gint) (end_valid - str);
1403 valid_str = g_strndup (str, offset);
1406 G_IO_ERROR_INVALID_ARGUMENT,
1407 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1408 "The valid UTF-8 string up until that point was '%s'"),
1419 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1421 /* returns a non-floating GVariant! */
1423 parse_value_from_blob (GMemoryBuffer *buf,
1424 const GVariantType *type,
1425 gboolean just_align,
1430 GError *local_error;
1432 const gchar *type_string;
1434 type_string = g_variant_type_peek_string (type);
1436 #ifdef DEBUG_SERIALIZER
1439 s = g_variant_type_dup_string (type);
1440 g_print ("%*s%s type %s from offset 0x%04x",
1442 just_align ? "Aligning" : "Reading",
1444 (gint) g_seekable_tell (G_SEEKABLE (buf)));
1447 #endif /* DEBUG_SERIALIZER */
1453 switch (type_string[0])
1455 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1456 ensure_input_padding (buf, 4);
1460 v = g_memory_buffer_read_uint32 (buf);
1461 ret = g_variant_new_boolean (v);
1465 case 'y': /* G_VARIANT_TYPE_BYTE */
1469 v = g_memory_buffer_read_byte (buf);
1470 ret = g_variant_new_byte (v);
1474 case 'n': /* G_VARIANT_TYPE_INT16 */
1475 ensure_input_padding (buf, 2);
1479 v = g_memory_buffer_read_int16 (buf);
1480 ret = g_variant_new_int16 (v);
1484 case 'q': /* G_VARIANT_TYPE_UINT16 */
1485 ensure_input_padding (buf, 2);
1489 v = g_memory_buffer_read_uint16 (buf);
1490 ret = g_variant_new_uint16 (v);
1494 case 'i': /* G_VARIANT_TYPE_INT32 */
1495 ensure_input_padding (buf, 4);
1499 v = g_memory_buffer_read_int32 (buf);
1500 ret = g_variant_new_int32 (v);
1504 case 'u': /* G_VARIANT_TYPE_UINT32 */
1505 ensure_input_padding (buf, 4);
1509 v = g_memory_buffer_read_uint32 (buf);
1510 ret = g_variant_new_uint32 (v);
1514 case 'x': /* G_VARIANT_TYPE_INT64 */
1515 ensure_input_padding (buf, 8);
1519 v = g_memory_buffer_read_int64 (buf);
1520 ret = g_variant_new_int64 (v);
1524 case 't': /* G_VARIANT_TYPE_UINT64 */
1525 ensure_input_padding (buf, 8);
1529 v = g_memory_buffer_read_uint64 (buf);
1530 ret = g_variant_new_uint64 (v);
1534 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1535 ensure_input_padding (buf, 8);
1542 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1543 u.v_uint64 = g_memory_buffer_read_uint64 (buf);
1544 ret = g_variant_new_double (u.v_double);
1548 case 's': /* G_VARIANT_TYPE_STRING */
1549 ensure_input_padding (buf, 4);
1554 len = g_memory_buffer_read_uint32 (buf);
1555 v = read_string (buf, (gsize) len, &local_error);
1558 ret = g_variant_new_string (v);
1562 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1563 ensure_input_padding (buf, 4);
1568 len = g_memory_buffer_read_uint32 (buf);
1569 v = read_string (buf, (gsize) len, &local_error);
1572 if (!g_variant_is_object_path (v))
1574 g_set_error (&local_error,
1576 G_IO_ERROR_INVALID_ARGUMENT,
1577 _("Parsed value '%s' is not a valid D-Bus object path"),
1581 ret = g_variant_new_object_path (v);
1585 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
1590 len = g_memory_buffer_read_byte (buf);
1591 v = read_string (buf, (gsize) len, &local_error);
1594 if (!g_variant_is_signature (v))
1596 g_set_error (&local_error,
1598 G_IO_ERROR_INVALID_ARGUMENT,
1599 _("Parsed value '%s' is not a valid D-Bus signature"),
1603 ret = g_variant_new_signature (v);
1607 case 'h': /* G_VARIANT_TYPE_HANDLE */
1608 ensure_input_padding (buf, 4);
1612 v = g_memory_buffer_read_int32 (buf);
1613 ret = g_variant_new_handle (v);
1617 case 'a': /* G_VARIANT_TYPE_ARRAY */
1618 ensure_input_padding (buf, 4);
1620 /* If we are only aligning for this array type, it is the child type of
1621 * another array, which is empty. So, we do not need to add padding for
1622 * this nonexistent array's elements: we only need to align for this
1623 * array itself (4 bytes). See
1624 * <https://bugzilla.gnome.org/show_bug.cgi?id=673612>.
1631 const GVariantType *element_type;
1632 GVariantBuilder builder;
1634 array_len = g_memory_buffer_read_uint32 (buf);
1637 #ifdef DEBUG_SERIALIZER
1638 g_print (": array spans 0x%04x bytes\n", array_len);
1639 #endif /* DEBUG_SERIALIZER */
1641 if (array_len > (2<<26))
1643 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1644 g_set_error (&local_error,
1646 G_IO_ERROR_INVALID_ARGUMENT,
1647 g_dngettext (GETTEXT_PACKAGE,
1648 "Encountered array of length %u byte. Maximum length is 2<<26 bytes (64 MiB).",
1649 "Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB).",
1655 g_variant_builder_init (&builder, type);
1656 element_type = g_variant_type_element (type);
1661 item = parse_value_from_blob (buf,
1666 g_assert (item == NULL);
1670 /* TODO: optimize array of primitive types */
1672 target = offset + array_len;
1673 while (offset < target)
1676 item = parse_value_from_blob (buf,
1683 g_variant_builder_clear (&builder);
1686 g_variant_builder_add_value (&builder, item);
1687 g_variant_unref (item);
1692 ret = g_variant_builder_end (&builder);
1697 if (g_variant_type_is_dict_entry (type))
1699 const GVariantType *key_type;
1700 const GVariantType *value_type;
1704 ensure_input_padding (buf, 8);
1707 #ifdef DEBUG_SERIALIZER
1709 #endif /* DEBUG_SERIALIZER */
1713 key_type = g_variant_type_key (type);
1714 key = parse_value_from_blob (buf,
1721 value_type = g_variant_type_value (type);
1722 value = parse_value_from_blob (buf,
1729 g_variant_unref (key);
1732 ret = g_variant_new_dict_entry (key, value);
1733 g_variant_unref (key);
1734 g_variant_unref (value);
1737 else if (g_variant_type_is_tuple (type))
1739 ensure_input_padding (buf, 8);
1742 #ifdef DEBUG_SERIALIZER
1744 #endif /* DEBUG_SERIALIZER */
1748 const GVariantType *element_type;
1749 GVariantBuilder builder;
1751 g_variant_builder_init (&builder, type);
1752 element_type = g_variant_type_first (type);
1753 while (element_type != NULL)
1756 item = parse_value_from_blob (buf,
1763 g_variant_builder_clear (&builder);
1766 g_variant_builder_add_value (&builder, item);
1767 g_variant_unref (item);
1769 element_type = g_variant_type_next (element_type);
1771 ret = g_variant_builder_end (&builder);
1774 else if (g_variant_type_is_variant (type))
1777 #ifdef DEBUG_SERIALIZER
1779 #endif /* DEBUG_SERIALIZER */
1785 GVariantType *variant_type;
1788 siglen = g_memory_buffer_read_byte (buf);
1789 sig = read_string (buf, (gsize) siglen, &local_error);
1792 if (!g_variant_is_signature (sig))
1794 g_set_error (&local_error,
1796 G_IO_ERROR_INVALID_ARGUMENT,
1797 _("Parsed value '%s' for variant is not a valid D-Bus signature"),
1801 variant_type = g_variant_type_new (sig);
1802 value = parse_value_from_blob (buf,
1807 g_variant_type_free (variant_type);
1810 ret = g_variant_new_variant (value);
1811 g_variant_unref (value);
1817 s = g_variant_type_dup_string (type);
1818 g_set_error (&local_error,
1820 G_IO_ERROR_INVALID_ARGUMENT,
1821 _("Error deserializing GVariant with type string '%s' from the D-Bus wire format"),
1829 g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1831 #ifdef DEBUG_SERIALIZER
1837 if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1839 s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1843 s = g_variant_print (ret, FALSE);
1845 g_print (": %s\n", s);
1850 is_leaf = is_leaf; /* To avoid -Wunused-but-set-variable */
1851 #endif /* DEBUG_SERIALIZER */
1853 /* sink the reference */
1856 g_assert (g_variant_is_floating (ret));
1857 g_variant_ref_sink (ret);
1862 #ifdef DEBUG_SERIALIZER
1864 "%*sFAILURE: %s (%s, %d)\n",
1866 local_error->message,
1867 g_quark_to_string (local_error->domain),
1869 #endif /* DEBUG_SERIALIZER */
1870 g_propagate_error (error, local_error);
1874 /* ---------------------------------------------------------------------------------------------------- */
1876 /* message_header must be at least 16 bytes */
1879 * g_dbus_message_bytes_needed:
1880 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1881 * @blob_len: The length of @blob (must be at least 16).
1882 * @error: Return location for error or %NULL.
1884 * Utility function to calculate how many bytes are needed to
1885 * completely deserialize the D-Bus message stored at @blob.
1887 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1888 * @blob contains invalid data or not enough data is available to
1889 * determine the size).
1894 g_dbus_message_bytes_needed (guchar *blob,
1902 g_return_val_if_fail (blob != NULL, -1);
1903 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1904 g_return_val_if_fail (blob_len >= 16, -1);
1908 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1909 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1910 /* round up so it's a multiple of 8 */
1911 ret = 8 * ((ret + 7)/8);
1912 /* finally add the body size */
1913 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1915 else if (blob[0] == 'B')
1917 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1918 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1919 /* round up so it's a multiple of 8 */
1920 ret = 8 * ((ret + 7)/8);
1921 /* finally add the body size */
1922 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1928 G_IO_ERROR_INVALID_ARGUMENT,
1929 "Unable to determine message blob length - given blob is malformed");
1936 G_IO_ERROR_INVALID_ARGUMENT,
1937 "Blob indicates that message exceeds maximum message length (128MiB)");
1944 /* ---------------------------------------------------------------------------------------------------- */
1947 * g_dbus_message_new_from_blob:
1948 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1949 * @blob_len: The length of @blob.
1950 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
1951 * @error: Return location for error or %NULL.
1953 * Creates a new #GDBusMessage from the data stored at @blob. The byte
1954 * order that the message was in can be retrieved using
1955 * g_dbus_message_get_byte_order().
1957 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
1963 g_dbus_message_new_from_blob (guchar *blob,
1965 GDBusCapabilityFlags capabilities,
1970 GDBusMessage *message;
1972 guchar major_protocol_version;
1973 guint32 message_body_len;
1977 GVariant *signature;
1979 /* TODO: check against @capabilities */
1983 g_return_val_if_fail (blob != NULL, NULL);
1984 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1985 g_return_val_if_fail (blob_len >= 12, NULL);
1987 message = g_dbus_message_new ();
1989 memset (&mbuf, 0, sizeof (mbuf));
1990 mbuf.data = (gchar *)blob;
1991 mbuf.len = mbuf.valid_len = blob_len;
1993 endianness = g_memory_buffer_read_byte (&mbuf);
1997 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
1998 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
2001 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2002 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
2007 G_IO_ERROR_INVALID_ARGUMENT,
2008 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
2013 message->type = g_memory_buffer_read_byte (&mbuf);
2014 message->flags = g_memory_buffer_read_byte (&mbuf);
2015 major_protocol_version = g_memory_buffer_read_byte (&mbuf);
2016 if (major_protocol_version != 1)
2020 G_IO_ERROR_INVALID_ARGUMENT,
2021 _("Invalid major protocol version. Expected 1 but found %d"),
2022 major_protocol_version);
2025 message_body_len = g_memory_buffer_read_uint32 (&mbuf);
2026 message->serial = g_memory_buffer_read_uint32 (&mbuf);
2028 #ifdef DEBUG_SERIALIZER
2029 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2032 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
2033 g_print ("%s\n", s);
2036 #endif /* DEBUG_SERIALIZER */
2038 #ifdef DEBUG_SERIALIZER
2039 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2040 #endif /* DEBUG_SERIALIZER */
2041 headers = parse_value_from_blob (&mbuf,
2042 G_VARIANT_TYPE ("a{yv}"),
2046 if (headers == NULL)
2048 g_variant_iter_init (&iter, headers);
2049 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2051 guchar header_field;
2053 g_variant_get (item,
2057 g_dbus_message_set_header (message, header_field, value);
2058 g_variant_unref (value);
2059 g_variant_unref (item);
2061 g_variant_unref (headers);
2063 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2064 if (signature != NULL)
2066 const gchar *signature_str;
2067 gsize signature_str_len;
2069 signature_str = g_variant_get_string (signature, &signature_str_len);
2071 /* signature but no body */
2072 if (message_body_len == 0 && signature_str_len > 0)
2076 G_IO_ERROR_INVALID_ARGUMENT,
2077 _("Signature header with signature '%s' found but message body is empty"),
2081 else if (signature_str_len > 0)
2083 GVariantType *variant_type;
2084 gchar *tupled_signature_str;
2086 if (!g_variant_is_signature (signature_str))
2090 G_IO_ERROR_INVALID_ARGUMENT,
2091 _("Parsed value '%s' is not a valid D-Bus signature (for body)"),
2095 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2096 variant_type = g_variant_type_new (tupled_signature_str);
2097 g_free (tupled_signature_str);
2098 #ifdef DEBUG_SERIALIZER
2099 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2100 #endif /* DEBUG_SERIALIZER */
2101 message->body = parse_value_from_blob (&mbuf,
2106 g_variant_type_free (variant_type);
2107 if (message->body == NULL)
2113 /* no signature, this is only OK if the body is empty */
2114 if (message_body_len != 0)
2116 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
2119 G_IO_ERROR_INVALID_ARGUMENT,
2120 g_dngettext (GETTEXT_PACKAGE,
2121 "No signature header in message but the message body is %u byte",
2122 "No signature header in message but the message body is %u bytes",
2129 if (!validate_headers (message, error))
2131 g_prefix_error (error, _("Cannot deserialize message: "));
2144 if (message != NULL)
2145 g_object_unref (message);
2150 /* ---------------------------------------------------------------------------------------------------- */
2153 ensure_output_padding (GMemoryBuffer *mbuf,
2157 gsize wanted_offset;
2158 gsize padding_needed;
2162 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
2163 padding_needed = wanted_offset - offset;
2165 for (n = 0; n < padding_needed; n++)
2166 g_memory_buffer_put_byte (mbuf, '\0');
2168 return padding_needed;
2171 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
2173 append_value_to_blob (GVariant *value,
2174 const GVariantType *type,
2175 GMemoryBuffer *mbuf,
2176 gsize *out_padding_added,
2179 gsize padding_added;
2180 const gchar *type_string;
2182 type_string = g_variant_type_peek_string (type);
2186 switch (type_string[0])
2188 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
2189 padding_added = ensure_output_padding (mbuf, 4);
2192 gboolean v = g_variant_get_boolean (value);
2193 g_memory_buffer_put_uint32 (mbuf, v);
2197 case 'y': /* G_VARIANT_TYPE_BYTE */
2200 guint8 v = g_variant_get_byte (value);
2201 g_memory_buffer_put_byte (mbuf, v);
2205 case 'n': /* G_VARIANT_TYPE_INT16 */
2206 padding_added = ensure_output_padding (mbuf, 2);
2209 gint16 v = g_variant_get_int16 (value);
2210 g_memory_buffer_put_int16 (mbuf, v);
2214 case 'q': /* G_VARIANT_TYPE_UINT16 */
2215 padding_added = ensure_output_padding (mbuf, 2);
2218 guint16 v = g_variant_get_uint16 (value);
2219 g_memory_buffer_put_uint16 (mbuf, v);
2223 case 'i': /* G_VARIANT_TYPE_INT32 */
2224 padding_added = ensure_output_padding (mbuf, 4);
2227 gint32 v = g_variant_get_int32 (value);
2228 g_memory_buffer_put_int32 (mbuf, v);
2232 case 'u': /* G_VARIANT_TYPE_UINT32 */
2233 padding_added = ensure_output_padding (mbuf, 4);
2236 guint32 v = g_variant_get_uint32 (value);
2237 g_memory_buffer_put_uint32 (mbuf, v);
2241 case 'x': /* G_VARIANT_TYPE_INT64 */
2242 padding_added = ensure_output_padding (mbuf, 8);
2245 gint64 v = g_variant_get_int64 (value);
2246 g_memory_buffer_put_int64 (mbuf, v);
2250 case 't': /* G_VARIANT_TYPE_UINT64 */
2251 padding_added = ensure_output_padding (mbuf, 8);
2254 guint64 v = g_variant_get_uint64 (value);
2255 g_memory_buffer_put_uint64 (mbuf, v);
2259 case 'd': /* G_VARIANT_TYPE_DOUBLE */
2260 padding_added = ensure_output_padding (mbuf, 8);
2267 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
2268 u.v_double = g_variant_get_double (value);
2269 g_memory_buffer_put_uint64 (mbuf, u.v_uint64);
2273 case 's': /* G_VARIANT_TYPE_STRING */
2274 padding_added = ensure_output_padding (mbuf, 4);
2280 v = g_variant_get_string (value, &len);
2281 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
2282 g_memory_buffer_put_uint32 (mbuf, len);
2283 g_memory_buffer_put_string (mbuf, v);
2284 g_memory_buffer_put_byte (mbuf, '\0');
2288 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
2289 padding_added = ensure_output_padding (mbuf, 4);
2293 const gchar *v = g_variant_get_string (value, &len);
2294 g_assert (g_variant_is_object_path (v));
2295 g_memory_buffer_put_uint32 (mbuf, len);
2296 g_memory_buffer_put_string (mbuf, v);
2297 g_memory_buffer_put_byte (mbuf, '\0');
2301 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
2305 const gchar *v = g_variant_get_string (value, &len);
2306 g_assert (g_variant_is_signature (v));
2307 g_memory_buffer_put_byte (mbuf, len);
2308 g_memory_buffer_put_string (mbuf, v);
2309 g_memory_buffer_put_byte (mbuf, '\0');
2313 case 'h': /* G_VARIANT_TYPE_HANDLE */
2314 padding_added = ensure_output_padding (mbuf, 4);
2317 gint32 v = g_variant_get_handle (value);
2318 g_memory_buffer_put_int32 (mbuf, v);
2322 case 'a': /* G_VARIANT_TYPE_ARRAY */
2326 goffset array_len_offset;
2327 goffset array_payload_begin_offset;
2331 padding_added = ensure_output_padding (mbuf, 4);
2334 /* array length - will be filled in later */
2335 array_len_offset = mbuf->valid_len;
2336 g_memory_buffer_put_uint32 (mbuf, 0xF00DFACE);
2338 /* From the D-Bus spec:
2340 * "A UINT32 giving the length of the array data in bytes,
2341 * followed by alignment padding to the alignment boundary of
2342 * the array element type, followed by each array element. The
2343 * array length is from the end of the alignment padding to
2344 * the end of the last element, i.e. it does not include the
2345 * padding after the length, or any padding after the last
2348 * Thus, we need to count how much padding the first element
2349 * contributes and subtract that from the array length.
2351 array_payload_begin_offset = mbuf->valid_len;
2353 if (g_variant_n_children (value) == 0)
2355 gsize padding_added_for_item;
2356 if (!append_value_to_blob (NULL,
2357 g_variant_type_element (type),
2359 &padding_added_for_item,
2362 array_payload_begin_offset += padding_added_for_item;
2368 g_variant_iter_init (&iter, value);
2369 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2371 gsize padding_added_for_item;
2372 if (!append_value_to_blob (item,
2373 g_variant_get_type (item),
2375 &padding_added_for_item,
2378 g_variant_unref (item);
2381 g_variant_unref (item);
2384 array_payload_begin_offset += padding_added_for_item;
2390 cur_offset = mbuf->valid_len;
2391 array_len = cur_offset - array_payload_begin_offset;
2392 mbuf->pos = array_len_offset;
2394 g_memory_buffer_put_uint32 (mbuf, array_len);
2395 mbuf->pos = cur_offset;
2401 if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2403 padding_added = ensure_output_padding (mbuf, 8);
2408 g_variant_iter_init (&iter, value);
2409 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2411 if (!append_value_to_blob (item,
2412 g_variant_get_type (item),
2417 g_variant_unref (item);
2420 g_variant_unref (item);
2424 else if (g_variant_type_is_variant (type))
2429 const gchar *signature;
2430 child = g_variant_get_child_value (value, 0);
2431 signature = g_variant_get_type_string (child);
2432 g_memory_buffer_put_byte (mbuf, strlen (signature));
2433 g_memory_buffer_put_string (mbuf, signature);
2434 g_memory_buffer_put_byte (mbuf, '\0');
2435 if (!append_value_to_blob (child,
2436 g_variant_get_type (child),
2441 g_variant_unref (child);
2444 g_variant_unref (child);
2451 G_IO_ERROR_INVALID_ARGUMENT,
2452 _("Error serializing GVariant with type string '%s' to the D-Bus wire format"),
2453 g_variant_get_type_string (value));
2459 if (out_padding_added != NULL)
2460 *out_padding_added = padding_added;
2469 append_body_to_blob (GVariant *value,
2470 GMemoryBuffer *mbuf,
2476 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2480 G_IO_ERROR_INVALID_ARGUMENT,
2481 "Expected a tuple for the body of the GDBusMessage.");
2485 g_variant_iter_init (&iter, value);
2486 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2488 if (!append_value_to_blob (item,
2489 g_variant_get_type (item),
2494 g_variant_unref (item);
2497 g_variant_unref (item);
2505 /* ---------------------------------------------------------------------------------------------------- */
2508 * g_dbus_message_to_blob:
2509 * @message: A #GDBusMessage.
2510 * @out_size: Return location for size of generated blob.
2511 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2512 * @error: Return location for error.
2514 * Serializes @message to a blob. The byte order returned by
2515 * g_dbus_message_get_byte_order() will be used.
2517 * Returns: (array length=out_size) (transfer full): A pointer to a
2518 * valid binary D-Bus message of @out_size bytes generated by @message
2519 * or %NULL if @error is set. Free with g_free().
2524 g_dbus_message_to_blob (GDBusMessage *message,
2526 GDBusCapabilityFlags capabilities,
2532 goffset body_len_offset;
2533 goffset body_start_offset;
2535 GVariant *header_fields;
2536 GVariantBuilder builder;
2537 GHashTableIter hash_iter;
2539 GVariant *header_value;
2540 GVariant *signature;
2541 const gchar *signature_str;
2542 gint num_fds_in_message;
2543 gint num_fds_according_to_header;
2545 /* TODO: check against @capabilities */
2549 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2550 g_return_val_if_fail (out_size != NULL, NULL);
2551 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2553 memset (&mbuf, 0, sizeof (mbuf));
2554 mbuf.len = MIN_ARRAY_SIZE;
2555 mbuf.data = g_malloc (mbuf.len);
2557 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2558 switch (message->byte_order)
2560 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2561 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2563 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2564 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2569 g_memory_buffer_put_byte (&mbuf, (guchar) message->byte_order);
2570 g_memory_buffer_put_byte (&mbuf, message->type);
2571 g_memory_buffer_put_byte (&mbuf, message->flags);
2572 g_memory_buffer_put_byte (&mbuf, 1); /* major protocol version */
2573 body_len_offset = mbuf.valid_len;
2574 /* body length - will be filled in later */
2575 g_memory_buffer_put_uint32 (&mbuf, 0xF00DFACE);
2576 g_memory_buffer_put_uint32 (&mbuf, message->serial);
2578 num_fds_in_message = 0;
2580 if (message->fd_list != NULL)
2581 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2583 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2584 if (num_fds_in_message != num_fds_according_to_header)
2588 G_IO_ERROR_INVALID_ARGUMENT,
2589 _("Message has %d file descriptors but the header field indicates %d file descriptors"),
2591 num_fds_according_to_header);
2595 if (!validate_headers (message, error))
2597 g_prefix_error (error, _("Cannot serialize message: "));
2601 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2602 g_hash_table_iter_init (&hash_iter, message->headers);
2603 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2605 g_variant_builder_add (&builder,
2607 (guchar) GPOINTER_TO_UINT (key),
2610 header_fields = g_variant_builder_end (&builder);
2612 if (!append_value_to_blob (header_fields,
2613 g_variant_get_type (header_fields),
2618 g_variant_unref (header_fields);
2621 g_variant_unref (header_fields);
2623 /* header size must be a multiple of 8 */
2624 ensure_output_padding (&mbuf, 8);
2626 body_start_offset = mbuf.valid_len;
2628 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2629 signature_str = NULL;
2630 if (signature != NULL)
2631 signature_str = g_variant_get_string (signature, NULL);
2632 if (message->body != NULL)
2634 gchar *tupled_signature_str;
2635 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2636 if (signature == NULL)
2640 G_IO_ERROR_INVALID_ARGUMENT,
2641 _("Message body has signature '%s' but there is no signature header"),
2643 g_free (tupled_signature_str);
2646 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2650 G_IO_ERROR_INVALID_ARGUMENT,
2651 _("Message body has type signature '%s' but signature in the header field is '%s'"),
2652 tupled_signature_str, g_variant_get_type_string (message->body));
2653 g_free (tupled_signature_str);
2656 g_free (tupled_signature_str);
2657 if (!append_body_to_blob (message->body, &mbuf, error))
2662 if (signature != NULL && strlen (signature_str) > 0)
2666 G_IO_ERROR_INVALID_ARGUMENT,
2667 _("Message body is empty but signature in the header field is '(%s)'"),
2673 /* OK, we're done writing the message - set the body length */
2674 size = mbuf.valid_len;
2675 body_size = size - body_start_offset;
2677 mbuf.pos = body_len_offset;
2679 g_memory_buffer_put_uint32 (&mbuf, body_size);
2682 ret = (guchar *)mbuf.data;
2688 /* ---------------------------------------------------------------------------------------------------- */
2691 get_uint32_header (GDBusMessage *message,
2692 GDBusMessageHeaderField header_field)
2698 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2699 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2700 ret = g_variant_get_uint32 (value);
2705 static const gchar *
2706 get_string_header (GDBusMessage *message,
2707 GDBusMessageHeaderField header_field)
2713 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2714 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2715 ret = g_variant_get_string (value, NULL);
2720 static const gchar *
2721 get_object_path_header (GDBusMessage *message,
2722 GDBusMessageHeaderField header_field)
2728 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2729 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2730 ret = g_variant_get_string (value, NULL);
2735 static const gchar *
2736 get_signature_header (GDBusMessage *message,
2737 GDBusMessageHeaderField header_field)
2743 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2744 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2745 ret = g_variant_get_string (value, NULL);
2750 /* ---------------------------------------------------------------------------------------------------- */
2753 set_uint32_header (GDBusMessage *message,
2754 GDBusMessageHeaderField header_field,
2757 g_dbus_message_set_header (message,
2759 g_variant_new_uint32 (value));
2763 set_string_header (GDBusMessage *message,
2764 GDBusMessageHeaderField header_field,
2767 g_dbus_message_set_header (message,
2769 value == NULL ? NULL : g_variant_new_string (value));
2773 set_object_path_header (GDBusMessage *message,
2774 GDBusMessageHeaderField header_field,
2777 g_dbus_message_set_header (message,
2779 value == NULL ? NULL : g_variant_new_object_path (value));
2783 set_signature_header (GDBusMessage *message,
2784 GDBusMessageHeaderField header_field,
2787 g_dbus_message_set_header (message,
2789 value == NULL ? NULL : g_variant_new_signature (value));
2792 /* ---------------------------------------------------------------------------------------------------- */
2795 * g_dbus_message_get_reply_serial:
2796 * @message: A #GDBusMessage.
2798 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2800 * Returns: The value.
2805 g_dbus_message_get_reply_serial (GDBusMessage *message)
2807 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2808 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2812 * g_dbus_message_set_reply_serial:
2813 * @message: A #GDBusMessage.
2814 * @value: The value to set.
2816 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2821 g_dbus_message_set_reply_serial (GDBusMessage *message,
2824 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2825 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2828 /* ---------------------------------------------------------------------------------------------------- */
2831 * g_dbus_message_get_interface:
2832 * @message: A #GDBusMessage.
2834 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2836 * Returns: The value.
2841 g_dbus_message_get_interface (GDBusMessage *message)
2843 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2844 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2848 * g_dbus_message_set_interface:
2849 * @message: A #GDBusMessage.
2850 * @value: The value to set.
2852 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2857 g_dbus_message_set_interface (GDBusMessage *message,
2860 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2861 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2862 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2865 /* ---------------------------------------------------------------------------------------------------- */
2868 * g_dbus_message_get_member:
2869 * @message: A #GDBusMessage.
2871 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2873 * Returns: The value.
2878 g_dbus_message_get_member (GDBusMessage *message)
2880 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2881 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2885 * g_dbus_message_set_member:
2886 * @message: A #GDBusMessage.
2887 * @value: The value to set.
2889 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2894 g_dbus_message_set_member (GDBusMessage *message,
2897 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2898 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2899 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2902 /* ---------------------------------------------------------------------------------------------------- */
2905 * g_dbus_message_get_path:
2906 * @message: A #GDBusMessage.
2908 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2910 * Returns: The value.
2915 g_dbus_message_get_path (GDBusMessage *message)
2917 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2918 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2922 * g_dbus_message_set_path:
2923 * @message: A #GDBusMessage.
2924 * @value: The value to set.
2926 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2931 g_dbus_message_set_path (GDBusMessage *message,
2934 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2935 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2936 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2939 /* ---------------------------------------------------------------------------------------------------- */
2942 * g_dbus_message_get_sender:
2943 * @message: A #GDBusMessage.
2945 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2947 * Returns: The value.
2952 g_dbus_message_get_sender (GDBusMessage *message)
2954 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2955 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
2959 * g_dbus_message_set_sender:
2960 * @message: A #GDBusMessage.
2961 * @value: The value to set.
2963 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2968 g_dbus_message_set_sender (GDBusMessage *message,
2971 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2972 g_return_if_fail (value == NULL || g_dbus_is_name (value));
2973 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
2976 /* ---------------------------------------------------------------------------------------------------- */
2979 * g_dbus_message_get_destination:
2980 * @message: A #GDBusMessage.
2982 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2984 * Returns: The value.
2989 g_dbus_message_get_destination (GDBusMessage *message)
2991 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2992 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
2996 * g_dbus_message_set_destination:
2997 * @message: A #GDBusMessage.
2998 * @value: The value to set.
3000 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3005 g_dbus_message_set_destination (GDBusMessage *message,
3008 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3009 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3010 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
3013 /* ---------------------------------------------------------------------------------------------------- */
3016 * g_dbus_message_get_error_name:
3017 * @message: A #GDBusMessage.
3019 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3021 * Returns: The value.
3026 g_dbus_message_get_error_name (GDBusMessage *message)
3028 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3029 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
3033 * g_dbus_message_set_error_name:
3034 * @message: A #GDBusMessage.
3035 * @value: The value to set.
3037 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3042 g_dbus_message_set_error_name (GDBusMessage *message,
3045 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3046 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
3047 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
3050 /* ---------------------------------------------------------------------------------------------------- */
3053 * g_dbus_message_get_signature:
3054 * @message: A #GDBusMessage.
3056 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3058 * Returns: The value.
3063 g_dbus_message_get_signature (GDBusMessage *message)
3066 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3067 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
3074 * g_dbus_message_set_signature:
3075 * @message: A #GDBusMessage.
3076 * @value: The value to set.
3078 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3083 g_dbus_message_set_signature (GDBusMessage *message,
3086 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3087 g_return_if_fail (value == NULL || g_variant_is_signature (value));
3088 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
3091 /* ---------------------------------------------------------------------------------------------------- */
3094 * g_dbus_message_get_arg0:
3095 * @message: A #GDBusMessage.
3097 * Convenience to get the first item in the body of @message.
3099 * Returns: The string item or %NULL if the first item in the body of
3100 * @message is not a string.
3105 g_dbus_message_get_arg0 (GDBusMessage *message)
3109 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3113 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
3116 item = g_variant_get_child_value (message->body, 0);
3117 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
3118 ret = g_variant_get_string (item, NULL);
3119 g_variant_unref (item);
3125 /* ---------------------------------------------------------------------------------------------------- */
3128 * g_dbus_message_get_num_unix_fds:
3129 * @message: A #GDBusMessage.
3131 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3133 * Returns: The value.
3138 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
3140 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
3141 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
3145 * g_dbus_message_set_num_unix_fds:
3146 * @message: A #GDBusMessage.
3147 * @value: The value to set.
3149 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3154 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
3157 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3158 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
3161 /* ---------------------------------------------------------------------------------------------------- */
3164 * g_dbus_message_to_gerror:
3165 * @message: A #GDBusMessage.
3166 * @error: The #GError to set.
3168 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
3169 * nothing and returns %FALSE.
3171 * Otherwise this method encodes the error in @message as a #GError
3172 * using g_dbus_error_set_dbus_error() using the information in the
3173 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
3174 * well as the first string item in @message's body.
3176 * Returns: %TRUE if @error was set, %FALSE otherwise.
3181 g_dbus_message_to_gerror (GDBusMessage *message,
3185 const gchar *error_name;
3187 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3190 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
3193 error_name = g_dbus_message_get_error_name (message);
3194 if (error_name != NULL)
3198 body = g_dbus_message_get_body (message);
3200 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
3202 const gchar *error_message;
3203 g_variant_get (body, "(&s)", &error_message);
3204 g_dbus_error_set_dbus_error (error,
3211 /* these two situations are valid, yet pretty rare */
3214 g_dbus_error_set_dbus_error (error,
3217 _("Error return with body of type '%s'"),
3218 g_variant_get_type_string (body));
3222 g_dbus_error_set_dbus_error (error,
3225 _("Error return with empty body"));
3231 /* TOOD: this shouldn't happen - should check this at message serialization
3232 * time and disconnect the peer.
3237 "Error return without error-name header!");
3246 /* ---------------------------------------------------------------------------------------------------- */
3249 flags_to_string (GType flags_type, guint value)
3255 klass = g_type_class_ref (flags_type);
3256 s = g_string_new (NULL);
3257 for (n = 0; n < 32; n++)
3259 if ((value & (1<<n)) != 0)
3261 GFlagsValue *flags_value;
3262 flags_value = g_flags_get_first_value (klass, (1<<n));
3264 g_string_append_c (s, ',');
3265 if (flags_value != NULL)
3266 g_string_append (s, flags_value->value_nick);
3268 g_string_append_printf (s, "unknown (bit %d)", n);
3272 g_string_append (s, "none");
3273 g_type_class_unref (klass);
3274 return g_string_free (s, FALSE);
3278 _sort_keys_func (gconstpointer a,
3284 ia = GPOINTER_TO_INT (a);
3285 ib = GPOINTER_TO_INT (b);
3291 * g_dbus_message_print:
3292 * @message: A #GDBusMessage.
3293 * @indent: Indentation level.
3295 * Produces a human-readable multi-line description of @message.
3297 * The contents of the description has no ABI guarantees, the contents
3298 * and formatting is subject to change at any time. Typical output
3299 * looks something like this:
3306 * path -> objectpath '/org/gtk/GDBus/TestObject'
3307 * interface -> 'org.gtk.GDBus.TestInterface'
3308 * member -> 'GimmeStdout'
3309 * destination -> ':1.146'
3311 * UNIX File Descriptors:
3316 * Type: method-return
3317 * Flags: no-reply-expected
3321 * reply-serial -> uint32 4
3322 * destination -> ':1.159'
3323 * sender -> ':1.146'
3324 * num-unix-fds -> uint32 1
3326 * UNIX File Descriptors:
3327 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3330 * Returns: A string that should be freed with g_free().
3335 g_dbus_message_print (GDBusMessage *message,
3343 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3345 str = g_string_new (NULL);
3347 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3348 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3350 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3351 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3353 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3354 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3356 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3357 keys = g_hash_table_get_keys (message->headers);
3358 keys = g_list_sort (keys, _sort_keys_func);
3361 for (l = keys; l != NULL; l = l->next)
3363 gint key = GPOINTER_TO_INT (l->data);
3367 value = g_hash_table_lookup (message->headers, l->data);
3368 g_assert (value != NULL);
3370 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3371 value_str = g_variant_print (value, TRUE);
3372 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3379 g_string_append_printf (str, "%*s (none)\n", indent, "");
3381 g_string_append_printf (str, "%*sBody: ", indent, "");
3382 if (message->body != NULL)
3384 g_variant_print_string (message->body,
3390 g_string_append (str, "()");
3392 g_string_append (str, "\n");
3394 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3395 if (message->fd_list != NULL)
3401 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3404 for (n = 0; n < num_fds; n++)
3407 struct stat statbuf;
3408 fs = g_string_new (NULL);
3409 if (fstat (fds[n], &statbuf) == 0)
3411 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3412 major (statbuf.st_dev), minor (statbuf.st_dev));
3413 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3415 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3416 (guint64) statbuf.st_ino);
3417 g_string_append_printf (fs, "%s" "uid=%u", fs->len > 0 ? "," : "",
3418 (guint) statbuf.st_uid);
3419 g_string_append_printf (fs, "%s" "gid=%u", fs->len > 0 ? "," : "",
3420 (guint) statbuf.st_gid);
3421 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3422 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3423 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3424 (guint64) statbuf.st_size);
3425 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3426 (guint64) statbuf.st_atime);
3427 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3428 (guint64) statbuf.st_mtime);
3429 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3430 (guint64) statbuf.st_ctime);
3434 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3436 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3437 g_string_free (fs, TRUE);
3442 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3447 g_string_append_printf (str, "%*s (none)\n", indent, "");
3451 return g_string_free (str, FALSE);
3455 * g_dbus_message_get_locked:
3456 * @message: A #GDBusMessage.
3458 * Checks whether @message is locked. To monitor changes to this
3459 * value, conncet to the #GObject::notify signal to listen for changes
3460 * on the #GDBusMessage:locked property.
3462 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3467 g_dbus_message_get_locked (GDBusMessage *message)
3469 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3470 return message->locked;
3474 * g_dbus_message_lock:
3475 * @message: A #GDBusMessage.
3477 * If @message is locked, does nothing. Otherwise locks the message.
3482 g_dbus_message_lock (GDBusMessage *message)
3484 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3486 if (message->locked)
3489 message->locked = TRUE;
3490 g_object_notify (G_OBJECT (message), "locked");
3497 * g_dbus_message_copy:
3498 * @message: A #GDBusMessage.
3499 * @error: Return location for error or %NULL.
3501 * Copies @message. The copy is a deep copy and the returned
3502 * #GDBusMessage is completely identical except that it is guaranteed
3505 * This operation can fail if e.g. @message contains file descriptors
3506 * and the per-process or system-wide open files limit is reached.
3508 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3509 * Free with g_object_unref().
3514 g_dbus_message_copy (GDBusMessage *message,
3518 GHashTableIter iter;
3519 gpointer header_key;
3520 GVariant *header_value;
3522 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3523 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3525 ret = g_dbus_message_new ();
3526 ret->type = message->type;
3527 ret->flags = message->flags;
3528 ret->byte_order = message->byte_order;
3529 ret->major_protocol_version = message->major_protocol_version;
3530 ret->serial = message->serial;
3533 if (message->fd_list != NULL)
3539 ret->fd_list = g_unix_fd_list_new ();
3540 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3541 for (n = 0; n < num_fds; n++)
3543 if (g_unix_fd_list_append (ret->fd_list,
3547 g_object_unref (ret);
3555 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3556 * to just ref (as opposed to deep-copying) the GVariant instances
3558 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3559 g_hash_table_iter_init (&iter, message->headers);
3560 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3561 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));