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_is_byteswapped (GMemoryBuffer *mbuf)
70 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
71 return mbuf->byte_order == G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
73 return mbuf->byte_order == G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
78 g_memory_buffer_read_byte (GMemoryBuffer *mbuf)
80 if (mbuf->pos >= mbuf->valid_len)
82 return mbuf->data [mbuf->pos++];
86 g_memory_buffer_read_int16 (GMemoryBuffer *mbuf)
90 if (mbuf->pos > mbuf->valid_len - 2)
92 mbuf->pos = mbuf->valid_len;
96 memcpy (&v, mbuf->data + mbuf->pos, 2);
99 if (g_memory_buffer_is_byteswapped (mbuf))
100 v = GUINT16_SWAP_LE_BE (v);
106 g_memory_buffer_read_uint16 (GMemoryBuffer *mbuf)
110 if (mbuf->pos > mbuf->valid_len - 2)
112 mbuf->pos = mbuf->valid_len;
116 memcpy (&v, mbuf->data + mbuf->pos, 2);
119 if (g_memory_buffer_is_byteswapped (mbuf))
120 v = GUINT16_SWAP_LE_BE (v);
126 g_memory_buffer_read_int32 (GMemoryBuffer *mbuf)
130 if (mbuf->pos > mbuf->valid_len - 4)
132 mbuf->pos = mbuf->valid_len;
136 memcpy (&v, mbuf->data + mbuf->pos, 4);
139 if (g_memory_buffer_is_byteswapped (mbuf))
140 v = GUINT32_SWAP_LE_BE (v);
146 g_memory_buffer_read_uint32 (GMemoryBuffer *mbuf)
150 if (mbuf->pos > mbuf->valid_len - 4)
152 mbuf->pos = mbuf->valid_len;
156 memcpy (&v, mbuf->data + mbuf->pos, 4);
159 if (g_memory_buffer_is_byteswapped (mbuf))
160 v = GUINT32_SWAP_LE_BE (v);
166 g_memory_buffer_read_int64 (GMemoryBuffer *mbuf)
170 if (mbuf->pos > mbuf->valid_len - 8)
172 mbuf->pos = mbuf->valid_len;
176 memcpy (&v, mbuf->data + mbuf->pos, 8);
179 if (g_memory_buffer_is_byteswapped (mbuf))
180 v = GUINT64_SWAP_LE_BE (v);
186 g_memory_buffer_read_uint64 (GMemoryBuffer *mbuf)
190 if (mbuf->pos > mbuf->valid_len - 8)
192 mbuf->pos = mbuf->valid_len;
196 memcpy (&v, mbuf->data + mbuf->pos, 8);
199 if (g_memory_buffer_is_byteswapped (mbuf))
200 v = GUINT64_SWAP_LE_BE (v);
205 #define MIN_ARRAY_SIZE 128
208 g_nearest_pow (gint num)
219 array_resize (GMemoryBuffer *mbuf,
225 if (mbuf->len == size)
229 data = g_realloc (mbuf->data, size);
232 memset ((guint8 *)data + len, 0, size - len);
237 if (mbuf->len < mbuf->valid_len)
238 mbuf->valid_len = mbuf->len;
242 g_memory_buffer_write (GMemoryBuffer *mbuf,
252 /* Check for address space overflow, but only if the buffer is resizable.
253 Otherwise we just do a short write and don't worry. */
254 if (mbuf->pos + count < mbuf->pos)
257 if (mbuf->pos + count > mbuf->len)
259 /* At least enought to fit the write, rounded up
260 for greater than linear growth.
261 TODO: This wastes a lot of memory at large buffer sizes.
262 Figure out a more rational allocation strategy. */
263 new_size = g_nearest_pow (mbuf->pos + count);
264 /* Check for overflow again. We have only checked if
265 pos + count > G_MAXSIZE, but it only catches the case of writing
266 more than 4GiB total on a 32-bit system. There's still the problem
267 of g_nearest_pow overflowing above 0x7fffffff, so we're
268 effectively limited to 2GiB. */
269 if (new_size < mbuf->len)
272 new_size = MAX (new_size, MIN_ARRAY_SIZE);
273 array_resize (mbuf, new_size);
276 dest = (guint8 *)mbuf->data + mbuf->pos;
277 memcpy (dest, buffer, count);
280 if (mbuf->pos > mbuf->valid_len)
281 mbuf->valid_len = mbuf->pos;
287 g_memory_buffer_put_byte (GMemoryBuffer *mbuf,
290 return g_memory_buffer_write (mbuf, &data, 1);
294 g_memory_buffer_put_int16 (GMemoryBuffer *mbuf,
297 switch (mbuf->byte_order)
299 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
300 data = GINT16_TO_BE (data);
302 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
303 data = GINT16_TO_LE (data);
305 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
310 return g_memory_buffer_write (mbuf, &data, 2);
314 g_memory_buffer_put_uint16 (GMemoryBuffer *mbuf,
317 switch (mbuf->byte_order)
319 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
320 data = GUINT16_TO_BE (data);
322 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
323 data = GUINT16_TO_LE (data);
325 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
330 return g_memory_buffer_write (mbuf, &data, 2);
334 g_memory_buffer_put_int32 (GMemoryBuffer *mbuf,
337 switch (mbuf->byte_order)
339 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
340 data = GINT32_TO_BE (data);
342 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
343 data = GINT32_TO_LE (data);
345 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
350 return g_memory_buffer_write (mbuf, &data, 4);
354 g_memory_buffer_put_uint32 (GMemoryBuffer *mbuf,
357 switch (mbuf->byte_order)
359 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
360 data = GUINT32_TO_BE (data);
362 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
363 data = GUINT32_TO_LE (data);
365 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
370 return g_memory_buffer_write (mbuf, &data, 4);
374 g_memory_buffer_put_int64 (GMemoryBuffer *mbuf,
377 switch (mbuf->byte_order)
379 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
380 data = GINT64_TO_BE (data);
382 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
383 data = GINT64_TO_LE (data);
385 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
390 return g_memory_buffer_write (mbuf, &data, 8);
394 g_memory_buffer_put_uint64 (GMemoryBuffer *mbuf,
397 switch (mbuf->byte_order)
399 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
400 data = GUINT64_TO_BE (data);
402 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
403 data = GUINT64_TO_LE (data);
405 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
410 return g_memory_buffer_write (mbuf, &data, 8);
414 g_memory_buffer_put_string (GMemoryBuffer *mbuf,
417 g_return_val_if_fail (str != NULL, FALSE);
419 return g_memory_buffer_write (mbuf, str, strlen (str));
424 * SECTION:gdbusmessage
425 * @short_description: D-Bus Message
426 * @include: gio/gio.h
428 * A type for representing D-Bus messages that can be sent or received
429 * on a #GDBusConnection.
432 typedef struct _GDBusMessageClass GDBusMessageClass;
437 * Class structure for #GDBusMessage.
441 struct _GDBusMessageClass
444 GObjectClass parent_class;
450 * The #GDBusMessage structure contains only private data and should
451 * only be accessed using the provided API.
458 GObject parent_instance;
460 GDBusMessageType type;
461 GDBusMessageFlags flags;
463 GDBusMessageByteOrder byte_order;
464 guchar major_protocol_version;
469 GUnixFDList *fd_list;
479 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
482 g_dbus_message_finalize (GObject *object)
484 GDBusMessage *message = G_DBUS_MESSAGE (object);
486 if (message->headers != NULL)
487 g_hash_table_unref (message->headers);
488 if (message->body != NULL)
489 g_variant_unref (message->body);
491 if (message->fd_list != NULL)
492 g_object_unref (message->fd_list);
495 if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
496 G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
500 g_dbus_message_get_property (GObject *object,
505 GDBusMessage *message = G_DBUS_MESSAGE (object);
510 g_value_set_boolean (value, g_dbus_message_get_locked (message));
514 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
520 g_dbus_message_class_init (GDBusMessageClass *klass)
522 GObjectClass *gobject_class;
524 gobject_class = G_OBJECT_CLASS (klass);
525 gobject_class->finalize = g_dbus_message_finalize;
526 gobject_class->get_property = g_dbus_message_get_property;
529 * GDBusConnection:locked:
531 * A boolean specifying whether the message is locked.
535 g_object_class_install_property (gobject_class,
537 g_param_spec_boolean ("locked",
539 P_("Whether the message is locked"),
542 G_PARAM_STATIC_NAME |
543 G_PARAM_STATIC_BLURB |
544 G_PARAM_STATIC_NICK));
548 g_dbus_message_init (GDBusMessage *message)
550 /* Any D-Bus implementation is supposed to handle both Big and
551 * Little Endian encodings and the Endianness is part of the D-Bus
552 * message - we prefer to use Big Endian (since it's Network Byte
553 * Order and just easier to read for humans) but if the machine is
554 * Little Endian we use that for performance reasons.
556 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
557 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
559 /* this could also be G_PDP_ENDIAN */
560 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
562 message->headers = g_hash_table_new_full (g_direct_hash,
565 (GDestroyNotify) g_variant_unref);
569 * g_dbus_message_new:
571 * Creates a new empty #GDBusMessage.
573 * Returns: A #GDBusMessage. Free with g_object_unref().
578 g_dbus_message_new (void)
580 return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
584 * g_dbus_message_new_method_call:
585 * @name: (allow-none): A valid D-Bus name or %NULL.
586 * @path: A valid object path.
587 * @interface_: (allow-none): A valid D-Bus interface name or %NULL.
588 * @method: A valid method name.
590 * Creates a new #GDBusMessage for a method call.
592 * Returns: A #GDBusMessage. Free with g_object_unref().
597 g_dbus_message_new_method_call (const gchar *name,
599 const gchar *interface_,
602 GDBusMessage *message;
604 g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
605 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
606 g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
607 g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
609 message = g_dbus_message_new ();
610 message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
613 g_dbus_message_set_destination (message, name);
614 g_dbus_message_set_path (message, path);
615 g_dbus_message_set_member (message, method);
616 if (interface_ != NULL)
617 g_dbus_message_set_interface (message, interface_);
623 * g_dbus_message_new_signal:
624 * @path: A valid object path.
625 * @interface_: A valid D-Bus interface name.
626 * @signal: A valid signal name.
628 * Creates a new #GDBusMessage for a signal emission.
630 * Returns: A #GDBusMessage. Free with g_object_unref().
635 g_dbus_message_new_signal (const gchar *path,
636 const gchar *interface_,
639 GDBusMessage *message;
641 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
642 g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
643 g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
645 message = g_dbus_message_new ();
646 message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
647 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
649 g_dbus_message_set_path (message, path);
650 g_dbus_message_set_member (message, signal);
651 g_dbus_message_set_interface (message, interface_);
658 * g_dbus_message_new_method_reply:
659 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
660 * create a reply message to.
662 * Creates a new #GDBusMessage that is a reply to @method_call_message.
664 * Returns: (transfer full): #GDBusMessage. Free with g_object_unref().
669 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
671 GDBusMessage *message;
674 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
675 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
676 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
678 message = g_dbus_message_new ();
679 message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
680 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
681 /* reply with same endianness */
682 message->byte_order = method_call_message->byte_order;
684 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
685 sender = g_dbus_message_get_sender (method_call_message);
687 g_dbus_message_set_destination (message, sender);
693 * g_dbus_message_new_method_error:
694 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
695 * create a reply message to.
696 * @error_name: A valid D-Bus error name.
697 * @error_message_format: The D-Bus error message in a printf() format.
698 * @...: Arguments for @error_message_format.
700 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
702 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
707 g_dbus_message_new_method_error (GDBusMessage *method_call_message,
708 const gchar *error_name,
709 const gchar *error_message_format,
715 va_start (var_args, error_message_format);
716 ret = g_dbus_message_new_method_error_valist (method_call_message,
718 error_message_format,
726 * g_dbus_message_new_method_error_literal:
727 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
728 * create a reply message to.
729 * @error_name: A valid D-Bus error name.
730 * @error_message: The D-Bus error message.
732 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
734 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
739 g_dbus_message_new_method_error_literal (GDBusMessage *method_call_message,
740 const gchar *error_name,
741 const gchar *error_message)
743 GDBusMessage *message;
746 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
747 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
748 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
749 g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
750 g_return_val_if_fail (error_message != NULL, NULL);
752 message = g_dbus_message_new ();
753 message->type = G_DBUS_MESSAGE_TYPE_ERROR;
754 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
755 /* reply with same endianness */
756 message->byte_order = method_call_message->byte_order;
758 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
759 g_dbus_message_set_error_name (message, error_name);
760 g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
762 sender = g_dbus_message_get_sender (method_call_message);
764 g_dbus_message_set_destination (message, sender);
770 * g_dbus_message_new_method_error_valist:
771 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
772 * create a reply message to.
773 * @error_name: A valid D-Bus error name.
774 * @error_message_format: The D-Bus error message in a printf() format.
775 * @var_args: Arguments for @error_message_format.
777 * Like g_dbus_message_new_method_error() but intended for language bindings.
779 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
785 g_dbus_message_new_method_error_valist (GDBusMessage *method_call_message,
786 const gchar *error_name,
787 const gchar *error_message_format,
791 gchar *error_message;
792 error_message = g_strdup_vprintf (error_message_format, var_args);
793 ret = g_dbus_message_new_method_error_literal (method_call_message,
796 g_free (error_message);
800 /* ---------------------------------------------------------------------------------------------------- */
803 * g_dbus_message_get_byte_order:
804 * @message: A #GDBusMessage.
806 * Gets the byte order of @message.
808 * Returns: The byte order.
810 GDBusMessageByteOrder
811 g_dbus_message_get_byte_order (GDBusMessage *message)
813 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
814 return message->byte_order;
818 * g_dbus_message_set_byte_order:
819 * @message: A #GDBusMessage.
820 * @byte_order: The byte order.
822 * Sets the byte order of @message.
825 g_dbus_message_set_byte_order (GDBusMessage *message,
826 GDBusMessageByteOrder byte_order)
828 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
832 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
836 message->byte_order = byte_order;
839 /* ---------------------------------------------------------------------------------------------------- */
841 /* TODO: need GI annotations to specify that any guchar value goes for the type */
844 * g_dbus_message_get_message_type:
845 * @message: A #GDBusMessage.
847 * Gets the type of @message.
849 * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
854 g_dbus_message_get_message_type (GDBusMessage *message)
856 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
857 return message->type;
861 * g_dbus_message_set_message_type:
862 * @message: A #GDBusMessage.
863 * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
865 * Sets @message to be of @type.
870 g_dbus_message_set_message_type (GDBusMessage *message,
871 GDBusMessageType type)
873 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
874 g_return_if_fail (type >=0 && type < 256);
878 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
882 message->type = type;
885 /* ---------------------------------------------------------------------------------------------------- */
887 /* TODO: need GI annotations to specify that any guchar value goes for flags */
890 * g_dbus_message_get_flags:
891 * @message: A #GDBusMessage.
893 * Gets the flags for @message.
895 * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
900 g_dbus_message_get_flags (GDBusMessage *message)
902 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
903 return message->flags;
907 * g_dbus_message_set_flags:
908 * @message: A #GDBusMessage.
909 * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
910 * enumeration bitwise ORed together).
912 * Sets the flags to set on @message.
917 g_dbus_message_set_flags (GDBusMessage *message,
918 GDBusMessageFlags flags)
920 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
921 g_return_if_fail (flags >=0 && flags < 256);
925 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
929 message->flags = flags;
932 /* ---------------------------------------------------------------------------------------------------- */
935 * g_dbus_message_get_serial:
936 * @message: A #GDBusMessage.
938 * Gets the serial for @message.
940 * Returns: A #guint32.
945 g_dbus_message_get_serial (GDBusMessage *message)
947 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
948 return message->serial;
952 * g_dbus_message_set_serial:
953 * @message: A #GDBusMessage.
954 * @serial: A #guint32.
956 * Sets the serial for @message.
961 g_dbus_message_set_serial (GDBusMessage *message,
964 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
968 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
972 message->serial = serial;
975 /* ---------------------------------------------------------------------------------------------------- */
977 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
980 * g_dbus_message_get_header:
981 * @message: A #GDBusMessage.
982 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
984 * Gets a header field on @message.
986 * Returns: A #GVariant with the value if the header was found, %NULL
987 * otherwise. Do not free, it is owned by @message.
992 g_dbus_message_get_header (GDBusMessage *message,
993 GDBusMessageHeaderField header_field)
995 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
996 g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
997 return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
1001 * g_dbus_message_set_header:
1002 * @message: A #GDBusMessage.
1003 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1004 * @value: (allow-none): A #GVariant to set the header field or %NULL to clear the header field.
1006 * Sets a header field on @message.
1008 * If @value is floating, @message assumes ownership of @value.
1013 g_dbus_message_set_header (GDBusMessage *message,
1014 GDBusMessageHeaderField header_field,
1017 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1018 g_return_if_fail (header_field >=0 && header_field < 256);
1020 if (message->locked)
1022 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1028 g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
1032 g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
1037 * g_dbus_message_get_header_fields:
1038 * @message: A #GDBusMessage.
1040 * Gets an array of all header fields on @message that are set.
1042 * Returns: (array zero-terminated=1): An array of header fields
1043 * terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element
1044 * is a #guchar. Free with g_free().
1049 g_dbus_message_get_header_fields (GDBusMessage *message)
1057 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1059 keys = g_hash_table_get_keys (message->headers);
1060 num_keys = g_list_length (keys);
1061 ret = g_new (guchar, num_keys + 1);
1062 for (l = keys, n = 0; l != NULL; l = l->next, n++)
1063 ret[n] = GPOINTER_TO_UINT (l->data);
1064 g_assert (n == num_keys);
1065 ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
1071 /* ---------------------------------------------------------------------------------------------------- */
1074 * g_dbus_message_get_body:
1075 * @message: A #GDBusMessage.
1077 * Gets the body of a message.
1079 * Returns: (transfer none): A #GVariant or %NULL if the body is
1080 * empty. Do not free, it is owned by @message.
1085 g_dbus_message_get_body (GDBusMessage *message)
1087 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1088 return message->body;
1092 * g_dbus_message_set_body:
1093 * @message: A #GDBusMessage.
1094 * @body: Either %NULL or a #GVariant that is a tuple.
1096 * Sets the body @message. As a side-effect the
1097 * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
1098 * type string of @body (or cleared if @body is %NULL).
1100 * If @body is floating, @message assumes ownership of @body.
1105 g_dbus_message_set_body (GDBusMessage *message,
1108 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1109 g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
1111 if (message->locked)
1113 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1117 if (message->body != NULL)
1118 g_variant_unref (message->body);
1121 message->body = NULL;
1122 g_dbus_message_set_signature (message, NULL);
1126 const gchar *type_string;
1127 gsize type_string_len;
1130 message->body = g_variant_ref_sink (body);
1132 type_string = g_variant_get_type_string (body);
1133 type_string_len = strlen (type_string);
1134 g_assert (type_string_len >= 2);
1135 signature = g_strndup (type_string + 1, type_string_len - 2);
1136 g_dbus_message_set_signature (message, signature);
1141 /* ---------------------------------------------------------------------------------------------------- */
1145 * g_dbus_message_get_unix_fd_list:
1146 * @message: A #GDBusMessage.
1148 * Gets the UNIX file descriptors associated with @message, if any.
1150 * This method is only available on UNIX.
1152 * Returns: (transfer none):A #GUnixFDList or %NULL if no file descriptors are
1153 * associated. Do not free, this object is owned by @message.
1158 g_dbus_message_get_unix_fd_list (GDBusMessage *message)
1160 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1161 return message->fd_list;
1165 * g_dbus_message_set_unix_fd_list:
1166 * @message: A #GDBusMessage.
1167 * @fd_list: (allow-none): A #GUnixFDList or %NULL.
1169 * Sets the UNIX file descriptors associated with @message. As a
1170 * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
1171 * field is set to the number of fds in @fd_list (or cleared if
1172 * @fd_list is %NULL).
1174 * This method is only available on UNIX.
1179 g_dbus_message_set_unix_fd_list (GDBusMessage *message,
1180 GUnixFDList *fd_list)
1182 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1183 g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
1185 if (message->locked)
1187 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1191 if (message->fd_list != NULL)
1192 g_object_unref (message->fd_list);
1193 if (fd_list != NULL)
1195 message->fd_list = g_object_ref (fd_list);
1196 g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
1200 message->fd_list = NULL;
1201 g_dbus_message_set_num_unix_fds (message, 0);
1206 /* ---------------------------------------------------------------------------------------------------- */
1209 get_type_fixed_size (const GVariantType *type)
1211 /* NB: we do not treat 'b' as fixed-size here because GVariant and
1212 * D-Bus disagree about the size.
1214 * In addition 'd' is encoded differently by GVariant and DBus, so
1215 * we force (en|de)coding rather than direct use of fixed data.
1217 * https://bugzilla.gnome.org/show_bug.cgi?id=732754
1219 switch (*g_variant_type_peek_string (type))
1225 case 'i': case 'u': case 'h':
1235 validate_headers (GDBusMessage *message,
1240 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
1241 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1245 switch (message->type)
1247 case G_DBUS_MESSAGE_TYPE_INVALID:
1248 g_set_error_literal (error,
1250 G_IO_ERROR_INVALID_ARGUMENT,
1251 _("type is INVALID"));
1255 case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
1256 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1257 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1259 g_set_error_literal (error,
1261 G_IO_ERROR_INVALID_ARGUMENT,
1262 _("METHOD_CALL message: PATH or MEMBER header field is missing"));
1267 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
1268 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1270 g_set_error_literal (error,
1272 G_IO_ERROR_INVALID_ARGUMENT,
1273 _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
1278 case G_DBUS_MESSAGE_TYPE_ERROR:
1279 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
1280 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 _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
1290 case G_DBUS_MESSAGE_TYPE_SIGNAL:
1291 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1292 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
1293 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1295 g_set_error_literal (error,
1297 G_IO_ERROR_INVALID_ARGUMENT,
1298 _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
1301 if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
1303 g_set_error_literal (error,
1305 G_IO_ERROR_INVALID_ARGUMENT,
1306 _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
1309 if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
1311 g_set_error_literal (error,
1313 G_IO_ERROR_INVALID_ARGUMENT,
1314 _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
1320 /* hitherto unknown type - nothing to check */
1327 g_assert (ret || (error == NULL || *error != NULL));
1331 /* ---------------------------------------------------------------------------------------------------- */
1334 ensure_input_padding (GMemoryBuffer *buf,
1338 gsize wanted_offset;
1341 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1342 buf->pos = wanted_offset;
1346 static const gchar *
1347 read_string (GMemoryBuffer *mbuf,
1352 const gchar *end_valid;
1354 if G_UNLIKELY (mbuf->pos + len >= mbuf->valid_len || mbuf->pos + len < mbuf->pos)
1356 mbuf->pos = mbuf->valid_len;
1357 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
1360 G_IO_ERROR_INVALID_ARGUMENT,
1361 g_dngettext (GETTEXT_PACKAGE,
1362 "Wanted to read %lu byte but only got %lu",
1363 "Wanted to read %lu bytes but only got %lu",
1366 (gulong)(mbuf->valid_len - mbuf->pos));
1370 if G_UNLIKELY (mbuf->data[mbuf->pos + len] != '\0')
1372 str = g_strndup (mbuf->data + mbuf->pos, len);
1375 G_IO_ERROR_INVALID_ARGUMENT,
1376 _("Expected NUL byte after the string '%s' but found byte %d"),
1377 str, mbuf->data[mbuf->pos + len]);
1379 mbuf->pos += len + 1;
1383 str = mbuf->data + mbuf->pos;
1384 mbuf->pos += len + 1;
1386 if G_UNLIKELY (!g_utf8_validate (str, -1, &end_valid))
1390 offset = (gint) (end_valid - str);
1391 valid_str = g_strndup (str, offset);
1394 G_IO_ERROR_INVALID_ARGUMENT,
1395 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1396 "The valid UTF-8 string up until that point was '%s'"),
1407 static gconstpointer
1408 read_bytes (GMemoryBuffer *mbuf,
1412 gconstpointer result;
1414 if G_UNLIKELY (mbuf->pos + len > mbuf->valid_len || mbuf->pos + len < mbuf->pos)
1416 mbuf->pos = mbuf->valid_len;
1417 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
1420 G_IO_ERROR_INVALID_ARGUMENT,
1421 g_dngettext (GETTEXT_PACKAGE,
1422 "Wanted to read %lu byte but only got %lu",
1423 "Wanted to read %lu bytes but only got %lu",
1426 (gulong)(mbuf->valid_len - mbuf->pos));
1430 result = mbuf->data + mbuf->pos;
1436 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1438 /* returns a non-floating GVariant! */
1440 parse_value_from_blob (GMemoryBuffer *buf,
1441 const GVariantType *type,
1442 gboolean just_align,
1447 GError *local_error;
1449 const gchar *type_string;
1451 type_string = g_variant_type_peek_string (type);
1453 #ifdef DEBUG_SERIALIZER
1456 s = g_variant_type_dup_string (type);
1457 g_print ("%*s%s type %s from offset 0x%04x",
1459 just_align ? "Aligning" : "Reading",
1461 (gint) g_seekable_tell (G_SEEKABLE (buf)));
1464 #endif /* DEBUG_SERIALIZER */
1470 switch (type_string[0])
1472 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1473 ensure_input_padding (buf, 4);
1477 v = g_memory_buffer_read_uint32 (buf);
1478 ret = g_variant_new_boolean (v);
1482 case 'y': /* G_VARIANT_TYPE_BYTE */
1486 v = g_memory_buffer_read_byte (buf);
1487 ret = g_variant_new_byte (v);
1491 case 'n': /* G_VARIANT_TYPE_INT16 */
1492 ensure_input_padding (buf, 2);
1496 v = g_memory_buffer_read_int16 (buf);
1497 ret = g_variant_new_int16 (v);
1501 case 'q': /* G_VARIANT_TYPE_UINT16 */
1502 ensure_input_padding (buf, 2);
1506 v = g_memory_buffer_read_uint16 (buf);
1507 ret = g_variant_new_uint16 (v);
1511 case 'i': /* G_VARIANT_TYPE_INT32 */
1512 ensure_input_padding (buf, 4);
1516 v = g_memory_buffer_read_int32 (buf);
1517 ret = g_variant_new_int32 (v);
1521 case 'u': /* G_VARIANT_TYPE_UINT32 */
1522 ensure_input_padding (buf, 4);
1526 v = g_memory_buffer_read_uint32 (buf);
1527 ret = g_variant_new_uint32 (v);
1531 case 'x': /* G_VARIANT_TYPE_INT64 */
1532 ensure_input_padding (buf, 8);
1536 v = g_memory_buffer_read_int64 (buf);
1537 ret = g_variant_new_int64 (v);
1541 case 't': /* G_VARIANT_TYPE_UINT64 */
1542 ensure_input_padding (buf, 8);
1546 v = g_memory_buffer_read_uint64 (buf);
1547 ret = g_variant_new_uint64 (v);
1551 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1552 ensure_input_padding (buf, 8);
1559 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1560 u.v_uint64 = g_memory_buffer_read_uint64 (buf);
1561 ret = g_variant_new_double (u.v_double);
1565 case 's': /* G_VARIANT_TYPE_STRING */
1566 ensure_input_padding (buf, 4);
1571 len = g_memory_buffer_read_uint32 (buf);
1572 v = read_string (buf, (gsize) len, &local_error);
1575 ret = g_variant_new_string (v);
1579 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1580 ensure_input_padding (buf, 4);
1585 len = g_memory_buffer_read_uint32 (buf);
1586 v = read_string (buf, (gsize) len, &local_error);
1589 if (!g_variant_is_object_path (v))
1591 g_set_error (&local_error,
1593 G_IO_ERROR_INVALID_ARGUMENT,
1594 _("Parsed value '%s' is not a valid D-Bus object path"),
1598 ret = g_variant_new_object_path (v);
1602 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
1607 len = g_memory_buffer_read_byte (buf);
1608 v = read_string (buf, (gsize) len, &local_error);
1611 if (!g_variant_is_signature (v))
1613 g_set_error (&local_error,
1615 G_IO_ERROR_INVALID_ARGUMENT,
1616 _("Parsed value '%s' is not a valid D-Bus signature"),
1620 ret = g_variant_new_signature (v);
1624 case 'h': /* G_VARIANT_TYPE_HANDLE */
1625 ensure_input_padding (buf, 4);
1629 v = g_memory_buffer_read_int32 (buf);
1630 ret = g_variant_new_handle (v);
1634 case 'a': /* G_VARIANT_TYPE_ARRAY */
1635 ensure_input_padding (buf, 4);
1637 /* If we are only aligning for this array type, it is the child type of
1638 * another array, which is empty. So, we do not need to add padding for
1639 * this nonexistent array's elements: we only need to align for this
1640 * array itself (4 bytes). See
1641 * <https://bugzilla.gnome.org/show_bug.cgi?id=673612>.
1646 const GVariantType *element_type;
1649 array_len = g_memory_buffer_read_uint32 (buf);
1652 #ifdef DEBUG_SERIALIZER
1653 g_print (": array spans 0x%04x bytes\n", array_len);
1654 #endif /* DEBUG_SERIALIZER */
1656 if (array_len > (2<<26))
1658 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1659 g_set_error (&local_error,
1661 G_IO_ERROR_INVALID_ARGUMENT,
1662 g_dngettext (GETTEXT_PACKAGE,
1663 "Encountered array of length %u byte. Maximum length is 2<<26 bytes (64 MiB).",
1664 "Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB).",
1670 element_type = g_variant_type_element (type);
1671 fixed_size = get_type_fixed_size (element_type);
1673 /* Fast-path the cases like 'ay', etc. */
1674 if (fixed_size != 0)
1676 gconstpointer array_data;
1678 if (array_len % fixed_size != 0)
1680 g_set_error (&local_error,
1682 G_IO_ERROR_INVALID_ARGUMENT,
1683 _("Encountered array of type 'a%c', expected to have a length a multiple "
1684 "of %u bytes, but found to be %u bytes in length"),
1685 g_variant_type_peek_string (element_type)[0], fixed_size, array_len);
1689 ensure_input_padding (buf, fixed_size);
1690 array_data = read_bytes (buf, array_len, &local_error);
1691 if (array_data == NULL)
1694 ret = g_variant_new_fixed_array (element_type, array_data, array_len / fixed_size, fixed_size);
1696 if (g_memory_buffer_is_byteswapped (buf))
1698 GVariant *tmp = g_variant_ref_sink (ret);
1699 ret = g_variant_byteswap (tmp);
1700 g_variant_unref (tmp);
1705 GVariantBuilder builder;
1709 g_variant_builder_init (&builder, type);
1714 item = parse_value_from_blob (buf,
1719 g_assert (item == NULL);
1724 target = offset + array_len;
1725 while (offset < target)
1728 item = parse_value_from_blob (buf,
1735 g_variant_builder_clear (&builder);
1738 g_variant_builder_add_value (&builder, item);
1739 g_variant_unref (item);
1744 ret = g_variant_builder_end (&builder);
1750 if (g_variant_type_is_dict_entry (type))
1752 const GVariantType *key_type;
1753 const GVariantType *value_type;
1757 ensure_input_padding (buf, 8);
1760 #ifdef DEBUG_SERIALIZER
1762 #endif /* DEBUG_SERIALIZER */
1766 key_type = g_variant_type_key (type);
1767 key = parse_value_from_blob (buf,
1774 value_type = g_variant_type_value (type);
1775 value = parse_value_from_blob (buf,
1782 g_variant_unref (key);
1785 ret = g_variant_new_dict_entry (key, value);
1786 g_variant_unref (key);
1787 g_variant_unref (value);
1790 else if (g_variant_type_is_tuple (type))
1792 ensure_input_padding (buf, 8);
1795 #ifdef DEBUG_SERIALIZER
1797 #endif /* DEBUG_SERIALIZER */
1801 const GVariantType *element_type;
1802 GVariantBuilder builder;
1804 g_variant_builder_init (&builder, type);
1805 element_type = g_variant_type_first (type);
1806 while (element_type != NULL)
1809 item = parse_value_from_blob (buf,
1816 g_variant_builder_clear (&builder);
1819 g_variant_builder_add_value (&builder, item);
1820 g_variant_unref (item);
1822 element_type = g_variant_type_next (element_type);
1824 ret = g_variant_builder_end (&builder);
1827 else if (g_variant_type_is_variant (type))
1830 #ifdef DEBUG_SERIALIZER
1832 #endif /* DEBUG_SERIALIZER */
1838 GVariantType *variant_type;
1841 siglen = g_memory_buffer_read_byte (buf);
1842 sig = read_string (buf, (gsize) siglen, &local_error);
1845 if (!g_variant_is_signature (sig))
1847 g_set_error (&local_error,
1849 G_IO_ERROR_INVALID_ARGUMENT,
1850 _("Parsed value '%s' for variant is not a valid D-Bus signature"),
1854 variant_type = g_variant_type_new (sig);
1855 value = parse_value_from_blob (buf,
1860 g_variant_type_free (variant_type);
1863 ret = g_variant_new_variant (value);
1864 g_variant_unref (value);
1870 s = g_variant_type_dup_string (type);
1871 g_set_error (&local_error,
1873 G_IO_ERROR_INVALID_ARGUMENT,
1874 _("Error deserializing GVariant with type string '%s' from the D-Bus wire format"),
1882 g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1884 #ifdef DEBUG_SERIALIZER
1890 if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1892 s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1896 s = g_variant_print (ret, FALSE);
1898 g_print (": %s\n", s);
1903 is_leaf = is_leaf; /* To avoid -Wunused-but-set-variable */
1904 #endif /* DEBUG_SERIALIZER */
1906 /* sink the reference, if floating */
1908 g_variant_take_ref (ret);
1912 #ifdef DEBUG_SERIALIZER
1914 "%*sFAILURE: %s (%s, %d)\n",
1916 local_error->message,
1917 g_quark_to_string (local_error->domain),
1919 #endif /* DEBUG_SERIALIZER */
1920 g_propagate_error (error, local_error);
1924 /* ---------------------------------------------------------------------------------------------------- */
1926 /* message_header must be at least 16 bytes */
1929 * g_dbus_message_bytes_needed:
1930 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1931 * @blob_len: The length of @blob (must be at least 16).
1932 * @error: Return location for error or %NULL.
1934 * Utility function to calculate how many bytes are needed to
1935 * completely deserialize the D-Bus message stored at @blob.
1937 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1938 * @blob contains invalid data or not enough data is available to
1939 * determine the size).
1944 g_dbus_message_bytes_needed (guchar *blob,
1952 g_return_val_if_fail (blob != NULL, -1);
1953 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1954 g_return_val_if_fail (blob_len >= 16, -1);
1958 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1959 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1960 /* round up so it's a multiple of 8 */
1961 ret = 8 * ((ret + 7)/8);
1962 /* finally add the body size */
1963 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1965 else if (blob[0] == 'B')
1967 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1968 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1969 /* round up so it's a multiple of 8 */
1970 ret = 8 * ((ret + 7)/8);
1971 /* finally add the body size */
1972 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1978 G_IO_ERROR_INVALID_ARGUMENT,
1979 "Unable to determine message blob length - given blob is malformed");
1986 G_IO_ERROR_INVALID_ARGUMENT,
1987 "Blob indicates that message exceeds maximum message length (128MiB)");
1994 /* ---------------------------------------------------------------------------------------------------- */
1997 * g_dbus_message_new_from_blob:
1998 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1999 * @blob_len: The length of @blob.
2000 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2001 * @error: Return location for error or %NULL.
2003 * Creates a new #GDBusMessage from the data stored at @blob. The byte
2004 * order that the message was in can be retrieved using
2005 * g_dbus_message_get_byte_order().
2007 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
2013 g_dbus_message_new_from_blob (guchar *blob,
2015 GDBusCapabilityFlags capabilities,
2020 GDBusMessage *message;
2022 guchar major_protocol_version;
2023 guint32 message_body_len;
2027 GVariant *signature;
2029 /* TODO: check against @capabilities */
2033 g_return_val_if_fail (blob != NULL, NULL);
2034 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2035 g_return_val_if_fail (blob_len >= 12, NULL);
2037 message = g_dbus_message_new ();
2039 memset (&mbuf, 0, sizeof (mbuf));
2040 mbuf.data = (gchar *)blob;
2041 mbuf.len = mbuf.valid_len = blob_len;
2043 endianness = g_memory_buffer_read_byte (&mbuf);
2047 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2048 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
2051 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2052 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
2057 G_IO_ERROR_INVALID_ARGUMENT,
2058 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
2063 message->type = g_memory_buffer_read_byte (&mbuf);
2064 message->flags = g_memory_buffer_read_byte (&mbuf);
2065 major_protocol_version = g_memory_buffer_read_byte (&mbuf);
2066 if (major_protocol_version != 1)
2070 G_IO_ERROR_INVALID_ARGUMENT,
2071 _("Invalid major protocol version. Expected 1 but found %d"),
2072 major_protocol_version);
2075 message_body_len = g_memory_buffer_read_uint32 (&mbuf);
2076 message->serial = g_memory_buffer_read_uint32 (&mbuf);
2078 #ifdef DEBUG_SERIALIZER
2079 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2082 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
2083 g_print ("%s\n", s);
2086 #endif /* DEBUG_SERIALIZER */
2088 #ifdef DEBUG_SERIALIZER
2089 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2090 #endif /* DEBUG_SERIALIZER */
2091 headers = parse_value_from_blob (&mbuf,
2092 G_VARIANT_TYPE ("a{yv}"),
2096 if (headers == NULL)
2098 g_variant_iter_init (&iter, headers);
2099 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2101 guchar header_field;
2103 g_variant_get (item,
2107 g_dbus_message_set_header (message, header_field, value);
2108 g_variant_unref (value);
2109 g_variant_unref (item);
2111 g_variant_unref (headers);
2113 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2114 if (signature != NULL)
2116 const gchar *signature_str;
2117 gsize signature_str_len;
2119 signature_str = g_variant_get_string (signature, &signature_str_len);
2121 /* signature but no body */
2122 if (message_body_len == 0 && signature_str_len > 0)
2126 G_IO_ERROR_INVALID_ARGUMENT,
2127 _("Signature header with signature '%s' found but message body is empty"),
2131 else if (signature_str_len > 0)
2133 GVariantType *variant_type;
2134 gchar *tupled_signature_str;
2136 if (!g_variant_is_signature (signature_str))
2140 G_IO_ERROR_INVALID_ARGUMENT,
2141 _("Parsed value '%s' is not a valid D-Bus signature (for body)"),
2145 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2146 variant_type = g_variant_type_new (tupled_signature_str);
2147 g_free (tupled_signature_str);
2148 #ifdef DEBUG_SERIALIZER
2149 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2150 #endif /* DEBUG_SERIALIZER */
2151 message->body = parse_value_from_blob (&mbuf,
2156 g_variant_type_free (variant_type);
2157 if (message->body == NULL)
2163 /* no signature, this is only OK if the body is empty */
2164 if (message_body_len != 0)
2166 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
2169 G_IO_ERROR_INVALID_ARGUMENT,
2170 g_dngettext (GETTEXT_PACKAGE,
2171 "No signature header in message but the message body is %u byte",
2172 "No signature header in message but the message body is %u bytes",
2179 if (!validate_headers (message, error))
2181 g_prefix_error (error, _("Cannot deserialize message: "));
2194 if (message != NULL)
2195 g_object_unref (message);
2200 /* ---------------------------------------------------------------------------------------------------- */
2203 ensure_output_padding (GMemoryBuffer *mbuf,
2207 gsize wanted_offset;
2208 gsize padding_needed;
2212 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
2213 padding_needed = wanted_offset - offset;
2215 for (n = 0; n < padding_needed; n++)
2216 g_memory_buffer_put_byte (mbuf, '\0');
2218 return padding_needed;
2221 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
2223 append_value_to_blob (GVariant *value,
2224 const GVariantType *type,
2225 GMemoryBuffer *mbuf,
2226 gsize *out_padding_added,
2229 gsize padding_added;
2230 const gchar *type_string;
2232 type_string = g_variant_type_peek_string (type);
2236 switch (type_string[0])
2238 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
2239 padding_added = ensure_output_padding (mbuf, 4);
2242 gboolean v = g_variant_get_boolean (value);
2243 g_memory_buffer_put_uint32 (mbuf, v);
2247 case 'y': /* G_VARIANT_TYPE_BYTE */
2250 guint8 v = g_variant_get_byte (value);
2251 g_memory_buffer_put_byte (mbuf, v);
2255 case 'n': /* G_VARIANT_TYPE_INT16 */
2256 padding_added = ensure_output_padding (mbuf, 2);
2259 gint16 v = g_variant_get_int16 (value);
2260 g_memory_buffer_put_int16 (mbuf, v);
2264 case 'q': /* G_VARIANT_TYPE_UINT16 */
2265 padding_added = ensure_output_padding (mbuf, 2);
2268 guint16 v = g_variant_get_uint16 (value);
2269 g_memory_buffer_put_uint16 (mbuf, v);
2273 case 'i': /* G_VARIANT_TYPE_INT32 */
2274 padding_added = ensure_output_padding (mbuf, 4);
2277 gint32 v = g_variant_get_int32 (value);
2278 g_memory_buffer_put_int32 (mbuf, v);
2282 case 'u': /* G_VARIANT_TYPE_UINT32 */
2283 padding_added = ensure_output_padding (mbuf, 4);
2286 guint32 v = g_variant_get_uint32 (value);
2287 g_memory_buffer_put_uint32 (mbuf, v);
2291 case 'x': /* G_VARIANT_TYPE_INT64 */
2292 padding_added = ensure_output_padding (mbuf, 8);
2295 gint64 v = g_variant_get_int64 (value);
2296 g_memory_buffer_put_int64 (mbuf, v);
2300 case 't': /* G_VARIANT_TYPE_UINT64 */
2301 padding_added = ensure_output_padding (mbuf, 8);
2304 guint64 v = g_variant_get_uint64 (value);
2305 g_memory_buffer_put_uint64 (mbuf, v);
2309 case 'd': /* G_VARIANT_TYPE_DOUBLE */
2310 padding_added = ensure_output_padding (mbuf, 8);
2317 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
2318 u.v_double = g_variant_get_double (value);
2319 g_memory_buffer_put_uint64 (mbuf, u.v_uint64);
2323 case 's': /* G_VARIANT_TYPE_STRING */
2324 padding_added = ensure_output_padding (mbuf, 4);
2330 v = g_variant_get_string (value, &len);
2331 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
2332 g_memory_buffer_put_uint32 (mbuf, len);
2333 g_memory_buffer_put_string (mbuf, v);
2334 g_memory_buffer_put_byte (mbuf, '\0');
2338 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
2339 padding_added = ensure_output_padding (mbuf, 4);
2343 const gchar *v = g_variant_get_string (value, &len);
2344 g_assert (g_variant_is_object_path (v));
2345 g_memory_buffer_put_uint32 (mbuf, len);
2346 g_memory_buffer_put_string (mbuf, v);
2347 g_memory_buffer_put_byte (mbuf, '\0');
2351 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
2355 const gchar *v = g_variant_get_string (value, &len);
2356 g_assert (g_variant_is_signature (v));
2357 g_memory_buffer_put_byte (mbuf, len);
2358 g_memory_buffer_put_string (mbuf, v);
2359 g_memory_buffer_put_byte (mbuf, '\0');
2363 case 'h': /* G_VARIANT_TYPE_HANDLE */
2364 padding_added = ensure_output_padding (mbuf, 4);
2367 gint32 v = g_variant_get_handle (value);
2368 g_memory_buffer_put_int32 (mbuf, v);
2372 case 'a': /* G_VARIANT_TYPE_ARRAY */
2374 const GVariantType *element_type;
2377 goffset array_len_offset;
2378 goffset array_payload_begin_offset;
2383 padding_added = ensure_output_padding (mbuf, 4);
2386 /* array length - will be filled in later */
2387 array_len_offset = mbuf->valid_len;
2388 g_memory_buffer_put_uint32 (mbuf, 0xF00DFACE);
2390 /* From the D-Bus spec:
2392 * "A UINT32 giving the length of the array data in bytes,
2393 * followed by alignment padding to the alignment boundary of
2394 * the array element type, followed by each array element. The
2395 * array length is from the end of the alignment padding to
2396 * the end of the last element, i.e. it does not include the
2397 * padding after the length, or any padding after the last
2400 * Thus, we need to count how much padding the first element
2401 * contributes and subtract that from the array length.
2403 array_payload_begin_offset = mbuf->valid_len;
2405 element_type = g_variant_type_element (type);
2406 fixed_size = get_type_fixed_size (element_type);
2408 if (g_variant_n_children (value) == 0)
2410 gsize padding_added_for_item;
2411 if (!append_value_to_blob (NULL,
2414 &padding_added_for_item,
2417 array_payload_begin_offset += padding_added_for_item;
2419 else if (fixed_size != 0)
2421 GVariant *use_value;
2423 if (g_memory_buffer_is_byteswapped (mbuf))
2424 use_value = g_variant_byteswap (value);
2426 use_value = g_variant_ref (value);
2428 ensure_output_padding (mbuf, fixed_size);
2429 array_len = g_variant_get_size (use_value);
2430 g_memory_buffer_write (mbuf, g_variant_get_data (use_value), array_len);
2431 g_variant_unref (use_value);
2437 g_variant_iter_init (&iter, value);
2438 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2440 gsize padding_added_for_item;
2441 if (!append_value_to_blob (item,
2442 g_variant_get_type (item),
2444 &padding_added_for_item,
2447 g_variant_unref (item);
2450 g_variant_unref (item);
2453 array_payload_begin_offset += padding_added_for_item;
2459 cur_offset = mbuf->valid_len;
2460 array_len = cur_offset - array_payload_begin_offset;
2461 mbuf->pos = array_len_offset;
2463 g_memory_buffer_put_uint32 (mbuf, array_len);
2464 mbuf->pos = cur_offset;
2470 if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2472 padding_added = ensure_output_padding (mbuf, 8);
2477 g_variant_iter_init (&iter, value);
2478 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2480 if (!append_value_to_blob (item,
2481 g_variant_get_type (item),
2486 g_variant_unref (item);
2489 g_variant_unref (item);
2493 else if (g_variant_type_is_variant (type))
2498 const gchar *signature;
2499 child = g_variant_get_child_value (value, 0);
2500 signature = g_variant_get_type_string (child);
2501 g_memory_buffer_put_byte (mbuf, strlen (signature));
2502 g_memory_buffer_put_string (mbuf, signature);
2503 g_memory_buffer_put_byte (mbuf, '\0');
2504 if (!append_value_to_blob (child,
2505 g_variant_get_type (child),
2510 g_variant_unref (child);
2513 g_variant_unref (child);
2520 G_IO_ERROR_INVALID_ARGUMENT,
2521 _("Error serializing GVariant with type string '%s' to the D-Bus wire format"),
2522 g_variant_get_type_string (value));
2528 if (out_padding_added != NULL)
2529 *out_padding_added = padding_added;
2538 append_body_to_blob (GVariant *value,
2539 GMemoryBuffer *mbuf,
2545 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2549 G_IO_ERROR_INVALID_ARGUMENT,
2550 "Expected a tuple for the body of the GDBusMessage.");
2554 g_variant_iter_init (&iter, value);
2555 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2557 if (!append_value_to_blob (item,
2558 g_variant_get_type (item),
2563 g_variant_unref (item);
2566 g_variant_unref (item);
2574 /* ---------------------------------------------------------------------------------------------------- */
2577 * g_dbus_message_to_blob:
2578 * @message: A #GDBusMessage.
2579 * @out_size: Return location for size of generated blob.
2580 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2581 * @error: Return location for error.
2583 * Serializes @message to a blob. The byte order returned by
2584 * g_dbus_message_get_byte_order() will be used.
2586 * Returns: (array length=out_size) (transfer full): A pointer to a
2587 * valid binary D-Bus message of @out_size bytes generated by @message
2588 * or %NULL if @error is set. Free with g_free().
2593 g_dbus_message_to_blob (GDBusMessage *message,
2595 GDBusCapabilityFlags capabilities,
2601 goffset body_len_offset;
2602 goffset body_start_offset;
2604 GVariant *header_fields;
2605 GVariantBuilder builder;
2606 GHashTableIter hash_iter;
2608 GVariant *header_value;
2609 GVariant *signature;
2610 const gchar *signature_str;
2611 gint num_fds_in_message;
2612 gint num_fds_according_to_header;
2614 /* TODO: check against @capabilities */
2618 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2619 g_return_val_if_fail (out_size != NULL, NULL);
2620 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2622 memset (&mbuf, 0, sizeof (mbuf));
2623 mbuf.len = MIN_ARRAY_SIZE;
2624 mbuf.data = g_malloc (mbuf.len);
2626 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2627 switch (message->byte_order)
2629 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2630 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2632 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2633 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2638 g_memory_buffer_put_byte (&mbuf, (guchar) message->byte_order);
2639 g_memory_buffer_put_byte (&mbuf, message->type);
2640 g_memory_buffer_put_byte (&mbuf, message->flags);
2641 g_memory_buffer_put_byte (&mbuf, 1); /* major protocol version */
2642 body_len_offset = mbuf.valid_len;
2643 /* body length - will be filled in later */
2644 g_memory_buffer_put_uint32 (&mbuf, 0xF00DFACE);
2645 g_memory_buffer_put_uint32 (&mbuf, message->serial);
2647 num_fds_in_message = 0;
2649 if (message->fd_list != NULL)
2650 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2652 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2653 if (num_fds_in_message != num_fds_according_to_header)
2657 G_IO_ERROR_INVALID_ARGUMENT,
2658 _("Message has %d file descriptors but the header field indicates %d file descriptors"),
2660 num_fds_according_to_header);
2664 if (!validate_headers (message, error))
2666 g_prefix_error (error, _("Cannot serialize message: "));
2670 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2671 g_hash_table_iter_init (&hash_iter, message->headers);
2672 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2674 g_variant_builder_add (&builder,
2676 (guchar) GPOINTER_TO_UINT (key),
2679 header_fields = g_variant_builder_end (&builder);
2681 if (!append_value_to_blob (header_fields,
2682 g_variant_get_type (header_fields),
2687 g_variant_unref (header_fields);
2690 g_variant_unref (header_fields);
2692 /* header size must be a multiple of 8 */
2693 ensure_output_padding (&mbuf, 8);
2695 body_start_offset = mbuf.valid_len;
2697 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2698 signature_str = NULL;
2699 if (signature != NULL)
2700 signature_str = g_variant_get_string (signature, NULL);
2701 if (message->body != NULL)
2703 gchar *tupled_signature_str;
2704 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2705 if (signature == NULL)
2709 G_IO_ERROR_INVALID_ARGUMENT,
2710 _("Message body has signature '%s' but there is no signature header"),
2712 g_free (tupled_signature_str);
2715 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2719 G_IO_ERROR_INVALID_ARGUMENT,
2720 _("Message body has type signature '%s' but signature in the header field is '%s'"),
2721 tupled_signature_str, g_variant_get_type_string (message->body));
2722 g_free (tupled_signature_str);
2725 g_free (tupled_signature_str);
2726 if (!append_body_to_blob (message->body, &mbuf, error))
2731 if (signature != NULL && strlen (signature_str) > 0)
2735 G_IO_ERROR_INVALID_ARGUMENT,
2736 _("Message body is empty but signature in the header field is '(%s)'"),
2742 /* OK, we're done writing the message - set the body length */
2743 size = mbuf.valid_len;
2744 body_size = size - body_start_offset;
2746 mbuf.pos = body_len_offset;
2748 g_memory_buffer_put_uint32 (&mbuf, body_size);
2751 ret = (guchar *)mbuf.data;
2757 /* ---------------------------------------------------------------------------------------------------- */
2760 get_uint32_header (GDBusMessage *message,
2761 GDBusMessageHeaderField header_field)
2767 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2768 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2769 ret = g_variant_get_uint32 (value);
2774 static const gchar *
2775 get_string_header (GDBusMessage *message,
2776 GDBusMessageHeaderField header_field)
2782 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2783 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2784 ret = g_variant_get_string (value, NULL);
2789 static const gchar *
2790 get_object_path_header (GDBusMessage *message,
2791 GDBusMessageHeaderField header_field)
2797 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2798 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2799 ret = g_variant_get_string (value, NULL);
2804 static const gchar *
2805 get_signature_header (GDBusMessage *message,
2806 GDBusMessageHeaderField header_field)
2812 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2813 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2814 ret = g_variant_get_string (value, NULL);
2819 /* ---------------------------------------------------------------------------------------------------- */
2822 set_uint32_header (GDBusMessage *message,
2823 GDBusMessageHeaderField header_field,
2826 g_dbus_message_set_header (message,
2828 g_variant_new_uint32 (value));
2832 set_string_header (GDBusMessage *message,
2833 GDBusMessageHeaderField header_field,
2836 g_dbus_message_set_header (message,
2838 value == NULL ? NULL : g_variant_new_string (value));
2842 set_object_path_header (GDBusMessage *message,
2843 GDBusMessageHeaderField header_field,
2846 g_dbus_message_set_header (message,
2848 value == NULL ? NULL : g_variant_new_object_path (value));
2852 set_signature_header (GDBusMessage *message,
2853 GDBusMessageHeaderField header_field,
2856 g_dbus_message_set_header (message,
2858 value == NULL ? NULL : g_variant_new_signature (value));
2861 /* ---------------------------------------------------------------------------------------------------- */
2864 * g_dbus_message_get_reply_serial:
2865 * @message: A #GDBusMessage.
2867 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2869 * Returns: The value.
2874 g_dbus_message_get_reply_serial (GDBusMessage *message)
2876 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2877 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2881 * g_dbus_message_set_reply_serial:
2882 * @message: A #GDBusMessage.
2883 * @value: The value to set.
2885 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2890 g_dbus_message_set_reply_serial (GDBusMessage *message,
2893 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2894 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2897 /* ---------------------------------------------------------------------------------------------------- */
2900 * g_dbus_message_get_interface:
2901 * @message: A #GDBusMessage.
2903 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2905 * Returns: The value.
2910 g_dbus_message_get_interface (GDBusMessage *message)
2912 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2913 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2917 * g_dbus_message_set_interface:
2918 * @message: A #GDBusMessage.
2919 * @value: The value to set.
2921 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2926 g_dbus_message_set_interface (GDBusMessage *message,
2929 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2930 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2931 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2934 /* ---------------------------------------------------------------------------------------------------- */
2937 * g_dbus_message_get_member:
2938 * @message: A #GDBusMessage.
2940 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2942 * Returns: The value.
2947 g_dbus_message_get_member (GDBusMessage *message)
2949 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2950 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2954 * g_dbus_message_set_member:
2955 * @message: A #GDBusMessage.
2956 * @value: The value to set.
2958 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2963 g_dbus_message_set_member (GDBusMessage *message,
2966 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2967 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2968 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2971 /* ---------------------------------------------------------------------------------------------------- */
2974 * g_dbus_message_get_path:
2975 * @message: A #GDBusMessage.
2977 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2979 * Returns: The value.
2984 g_dbus_message_get_path (GDBusMessage *message)
2986 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2987 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2991 * g_dbus_message_set_path:
2992 * @message: A #GDBusMessage.
2993 * @value: The value to set.
2995 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
3000 g_dbus_message_set_path (GDBusMessage *message,
3003 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3004 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
3005 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
3008 /* ---------------------------------------------------------------------------------------------------- */
3011 * g_dbus_message_get_sender:
3012 * @message: A #GDBusMessage.
3014 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3016 * Returns: The value.
3021 g_dbus_message_get_sender (GDBusMessage *message)
3023 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3024 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
3028 * g_dbus_message_set_sender:
3029 * @message: A #GDBusMessage.
3030 * @value: The value to set.
3032 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3037 g_dbus_message_set_sender (GDBusMessage *message,
3040 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3041 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3042 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
3045 /* ---------------------------------------------------------------------------------------------------- */
3048 * g_dbus_message_get_destination:
3049 * @message: A #GDBusMessage.
3051 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3053 * Returns: The value.
3058 g_dbus_message_get_destination (GDBusMessage *message)
3060 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3061 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
3065 * g_dbus_message_set_destination:
3066 * @message: A #GDBusMessage.
3067 * @value: The value to set.
3069 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3074 g_dbus_message_set_destination (GDBusMessage *message,
3077 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3078 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3079 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
3082 /* ---------------------------------------------------------------------------------------------------- */
3085 * g_dbus_message_get_error_name:
3086 * @message: A #GDBusMessage.
3088 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3090 * Returns: The value.
3095 g_dbus_message_get_error_name (GDBusMessage *message)
3097 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3098 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
3102 * g_dbus_message_set_error_name:
3103 * @message: A #GDBusMessage.
3104 * @value: The value to set.
3106 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3111 g_dbus_message_set_error_name (GDBusMessage *message,
3114 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3115 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
3116 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
3119 /* ---------------------------------------------------------------------------------------------------- */
3122 * g_dbus_message_get_signature:
3123 * @message: A #GDBusMessage.
3125 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3127 * Returns: The value.
3132 g_dbus_message_get_signature (GDBusMessage *message)
3135 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3136 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
3143 * g_dbus_message_set_signature:
3144 * @message: A #GDBusMessage.
3145 * @value: The value to set.
3147 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3152 g_dbus_message_set_signature (GDBusMessage *message,
3155 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3156 g_return_if_fail (value == NULL || g_variant_is_signature (value));
3157 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
3160 /* ---------------------------------------------------------------------------------------------------- */
3163 * g_dbus_message_get_arg0:
3164 * @message: A #GDBusMessage.
3166 * Convenience to get the first item in the body of @message.
3168 * Returns: The string item or %NULL if the first item in the body of
3169 * @message is not a string.
3174 g_dbus_message_get_arg0 (GDBusMessage *message)
3178 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3182 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
3185 item = g_variant_get_child_value (message->body, 0);
3186 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
3187 ret = g_variant_get_string (item, NULL);
3188 g_variant_unref (item);
3194 /* ---------------------------------------------------------------------------------------------------- */
3197 * g_dbus_message_get_num_unix_fds:
3198 * @message: A #GDBusMessage.
3200 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3202 * Returns: The value.
3207 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
3209 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
3210 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
3214 * g_dbus_message_set_num_unix_fds:
3215 * @message: A #GDBusMessage.
3216 * @value: The value to set.
3218 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3223 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
3226 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3227 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
3230 /* ---------------------------------------------------------------------------------------------------- */
3233 * g_dbus_message_to_gerror:
3234 * @message: A #GDBusMessage.
3235 * @error: The #GError to set.
3237 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
3238 * nothing and returns %FALSE.
3240 * Otherwise this method encodes the error in @message as a #GError
3241 * using g_dbus_error_set_dbus_error() using the information in the
3242 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
3243 * well as the first string item in @message's body.
3245 * Returns: %TRUE if @error was set, %FALSE otherwise.
3250 g_dbus_message_to_gerror (GDBusMessage *message,
3254 const gchar *error_name;
3256 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3259 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
3262 error_name = g_dbus_message_get_error_name (message);
3263 if (error_name != NULL)
3267 body = g_dbus_message_get_body (message);
3269 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
3271 const gchar *error_message;
3272 g_variant_get (body, "(&s)", &error_message);
3273 g_dbus_error_set_dbus_error (error,
3280 /* these two situations are valid, yet pretty rare */
3283 g_dbus_error_set_dbus_error (error,
3286 _("Error return with body of type '%s'"),
3287 g_variant_get_type_string (body));
3291 g_dbus_error_set_dbus_error (error,
3294 _("Error return with empty body"));
3300 /* TOOD: this shouldn't happen - should check this at message serialization
3301 * time and disconnect the peer.
3306 "Error return without error-name header!");
3315 /* ---------------------------------------------------------------------------------------------------- */
3318 flags_to_string (GType flags_type, guint value)
3324 klass = g_type_class_ref (flags_type);
3325 s = g_string_new (NULL);
3326 for (n = 0; n < 32; n++)
3328 if ((value & (1<<n)) != 0)
3330 GFlagsValue *flags_value;
3331 flags_value = g_flags_get_first_value (klass, (1<<n));
3333 g_string_append_c (s, ',');
3334 if (flags_value != NULL)
3335 g_string_append (s, flags_value->value_nick);
3337 g_string_append_printf (s, "unknown (bit %d)", n);
3341 g_string_append (s, "none");
3342 g_type_class_unref (klass);
3343 return g_string_free (s, FALSE);
3347 _sort_keys_func (gconstpointer a,
3353 ia = GPOINTER_TO_INT (a);
3354 ib = GPOINTER_TO_INT (b);
3360 * g_dbus_message_print:
3361 * @message: A #GDBusMessage.
3362 * @indent: Indentation level.
3364 * Produces a human-readable multi-line description of @message.
3366 * The contents of the description has no ABI guarantees, the contents
3367 * and formatting is subject to change at any time. Typical output
3368 * looks something like this:
3375 * path -> objectpath '/org/gtk/GDBus/TestObject'
3376 * interface -> 'org.gtk.GDBus.TestInterface'
3377 * member -> 'GimmeStdout'
3378 * destination -> ':1.146'
3380 * UNIX File Descriptors:
3385 * Type: method-return
3386 * Flags: no-reply-expected
3390 * reply-serial -> uint32 4
3391 * destination -> ':1.159'
3392 * sender -> ':1.146'
3393 * num-unix-fds -> uint32 1
3395 * UNIX File Descriptors:
3396 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3399 * Returns: A string that should be freed with g_free().
3404 g_dbus_message_print (GDBusMessage *message,
3412 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3414 str = g_string_new (NULL);
3416 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3417 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3419 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3420 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3422 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3423 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3425 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3426 keys = g_hash_table_get_keys (message->headers);
3427 keys = g_list_sort (keys, _sort_keys_func);
3430 for (l = keys; l != NULL; l = l->next)
3432 gint key = GPOINTER_TO_INT (l->data);
3436 value = g_hash_table_lookup (message->headers, l->data);
3437 g_assert (value != NULL);
3439 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3440 value_str = g_variant_print (value, TRUE);
3441 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3448 g_string_append_printf (str, "%*s (none)\n", indent, "");
3450 g_string_append_printf (str, "%*sBody: ", indent, "");
3451 if (message->body != NULL)
3453 g_variant_print_string (message->body,
3459 g_string_append (str, "()");
3461 g_string_append (str, "\n");
3463 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3464 if (message->fd_list != NULL)
3470 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3473 for (n = 0; n < num_fds; n++)
3476 struct stat statbuf;
3477 fs = g_string_new (NULL);
3478 if (fstat (fds[n], &statbuf) == 0)
3480 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3481 major (statbuf.st_dev), minor (statbuf.st_dev));
3482 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3484 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3485 (guint64) statbuf.st_ino);
3486 g_string_append_printf (fs, "%s" "uid=%u", fs->len > 0 ? "," : "",
3487 (guint) statbuf.st_uid);
3488 g_string_append_printf (fs, "%s" "gid=%u", fs->len > 0 ? "," : "",
3489 (guint) statbuf.st_gid);
3490 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3491 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3492 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3493 (guint64) statbuf.st_size);
3494 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3495 (guint64) statbuf.st_atime);
3496 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3497 (guint64) statbuf.st_mtime);
3498 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3499 (guint64) statbuf.st_ctime);
3503 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3505 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3506 g_string_free (fs, TRUE);
3511 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3516 g_string_append_printf (str, "%*s (none)\n", indent, "");
3520 return g_string_free (str, FALSE);
3524 * g_dbus_message_get_locked:
3525 * @message: A #GDBusMessage.
3527 * Checks whether @message is locked. To monitor changes to this
3528 * value, conncet to the #GObject::notify signal to listen for changes
3529 * on the #GDBusMessage:locked property.
3531 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3536 g_dbus_message_get_locked (GDBusMessage *message)
3538 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3539 return message->locked;
3543 * g_dbus_message_lock:
3544 * @message: A #GDBusMessage.
3546 * If @message is locked, does nothing. Otherwise locks the message.
3551 g_dbus_message_lock (GDBusMessage *message)
3553 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3555 if (message->locked)
3558 message->locked = TRUE;
3559 g_object_notify (G_OBJECT (message), "locked");
3566 * g_dbus_message_copy:
3567 * @message: A #GDBusMessage.
3568 * @error: Return location for error or %NULL.
3570 * Copies @message. The copy is a deep copy and the returned
3571 * #GDBusMessage is completely identical except that it is guaranteed
3574 * This operation can fail if e.g. @message contains file descriptors
3575 * and the per-process or system-wide open files limit is reached.
3577 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3578 * Free with g_object_unref().
3583 g_dbus_message_copy (GDBusMessage *message,
3587 GHashTableIter iter;
3588 gpointer header_key;
3589 GVariant *header_value;
3591 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3592 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3594 ret = g_dbus_message_new ();
3595 ret->type = message->type;
3596 ret->flags = message->flags;
3597 ret->byte_order = message->byte_order;
3598 ret->major_protocol_version = message->major_protocol_version;
3599 ret->serial = message->serial;
3602 if (message->fd_list != NULL)
3608 ret->fd_list = g_unix_fd_list_new ();
3609 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3610 for (n = 0; n < num_fds; n++)
3612 if (g_unix_fd_list_append (ret->fd_list,
3616 g_object_unref (ret);
3624 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3625 * to just ref (as opposed to deep-copying) the GVariant instances
3627 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3628 g_hash_table_iter_init (&iter, message->headers);
3629 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3630 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));