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, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: David Zeuthen <davidz@redhat.com>
23 /* Uncomment to debug serializer code */
24 /* #define DEBUG_SERIALIZER */
30 #include <sys/types.h>
32 #ifdef HAVE_SYS_MKDEV_H
33 #include <sys/mkdev.h>
39 #include "gdbusutils.h"
40 #include "gdbusmessage.h"
41 #include "gdbuserror.h"
42 #include "gioenumtypes.h"
43 #include "ginputstream.h"
44 #include "gdatainputstream.h"
45 #include "gmemoryinputstream.h"
46 #include "goutputstream.h"
47 #include "gdataoutputstream.h"
48 #include "gmemoryoutputstream.h"
49 #include "gseekable.h"
51 #include "gdbusprivate.h"
54 #include "gunixfdlist.h"
59 typedef struct _GMemoryBuffer GMemoryBuffer;
66 GDataStreamByteOrder byte_order;
70 g_memory_buffer_read_byte (GMemoryBuffer *mbuf,
73 if (mbuf->pos >= mbuf->valid_len)
75 return mbuf->data [mbuf->pos++];
79 g_memory_buffer_read_int16 (GMemoryBuffer *mbuf,
84 if (mbuf->pos > mbuf->valid_len - 2)
86 mbuf->pos = mbuf->valid_len;
90 memcpy (&v, mbuf->data + mbuf->pos, 2);
92 switch (mbuf->byte_order)
94 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
95 v = GINT16_FROM_BE (v);
97 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
98 v = GINT16_FROM_LE (v);
100 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
108 g_memory_buffer_read_uint16 (GMemoryBuffer *mbuf,
113 if (mbuf->pos > mbuf->valid_len - 2)
115 mbuf->pos = mbuf->valid_len;
119 memcpy (&v, mbuf->data + mbuf->pos, 2);
121 switch (mbuf->byte_order)
123 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
124 v = GINT16_FROM_BE (v);
126 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
127 v = GINT16_FROM_LE (v);
129 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
137 g_memory_buffer_read_int32 (GMemoryBuffer *mbuf,
142 if (mbuf->pos > mbuf->valid_len - 4)
144 mbuf->pos = mbuf->valid_len;
148 memcpy (&v, mbuf->data + mbuf->pos, 4);
150 switch (mbuf->byte_order)
152 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
153 v = GINT32_FROM_BE (v);
155 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
156 v = GINT32_FROM_LE (v);
158 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
166 g_memory_buffer_read_uint32 (GMemoryBuffer *mbuf,
171 if (mbuf->pos > mbuf->valid_len - 4)
173 mbuf->pos = mbuf->valid_len;
177 memcpy (&v, mbuf->data + mbuf->pos, 4);
179 switch (mbuf->byte_order)
181 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
182 v = GUINT32_FROM_BE (v);
184 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
185 v = GUINT32_FROM_LE (v);
187 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
195 g_memory_buffer_read_int64 (GMemoryBuffer *mbuf,
200 if (mbuf->pos > mbuf->valid_len - 8)
202 mbuf->pos = mbuf->valid_len;
206 memcpy (&v, mbuf->data + mbuf->pos, 8);
208 switch (mbuf->byte_order)
210 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
211 v = GINT64_FROM_BE (v);
213 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
214 v = GINT64_FROM_LE (v);
216 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
224 g_memory_buffer_read_uint64 (GMemoryBuffer *mbuf,
229 if (mbuf->pos > mbuf->valid_len - 8)
231 mbuf->pos = mbuf->valid_len;
235 memcpy (&v, mbuf->data + mbuf->pos, 8);
237 switch (mbuf->byte_order)
239 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
240 v = GUINT64_FROM_BE (v);
242 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
243 v = GUINT64_FROM_LE (v);
245 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
252 #define MIN_ARRAY_SIZE 128
255 g_nearest_pow (gint num)
266 array_resize (GMemoryBuffer *mbuf,
272 if (mbuf->len == size)
276 data = g_realloc (mbuf->data, size);
279 memset ((guint8 *)data + len, 0, size - len);
284 if (mbuf->len < mbuf->valid_len)
285 mbuf->valid_len = mbuf->len;
289 g_memory_buffer_write (GMemoryBuffer *mbuf,
299 /* Check for address space overflow, but only if the buffer is resizable.
300 Otherwise we just do a short write and don't worry. */
301 if (mbuf->pos + count < mbuf->pos)
304 if (mbuf->pos + count > mbuf->len)
306 /* At least enought to fit the write, rounded up
307 for greater than linear growth.
308 TODO: This wastes a lot of memory at large buffer sizes.
309 Figure out a more rational allocation strategy. */
310 new_size = g_nearest_pow (mbuf->pos + count);
311 /* Check for overflow again. We have only checked if
312 pos + count > G_MAXSIZE, but it only catches the case of writing
313 more than 4GiB total on a 32-bit system. There's still the problem
314 of g_nearest_pow overflowing above 0x7fffffff, so we're
315 effectively limited to 2GiB. */
316 if (new_size < mbuf->len)
319 new_size = MAX (new_size, MIN_ARRAY_SIZE);
320 array_resize (mbuf, new_size);
323 dest = (guint8 *)mbuf->data + mbuf->pos;
324 memcpy (dest, buffer, count);
327 if (mbuf->pos > mbuf->valid_len)
328 mbuf->valid_len = mbuf->pos;
334 g_memory_buffer_put_byte (GMemoryBuffer *mbuf,
337 return g_memory_buffer_write (mbuf, &data, 1);
341 g_memory_buffer_put_int16 (GMemoryBuffer *mbuf,
344 switch (mbuf->byte_order)
346 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
347 data = GINT16_TO_BE (data);
349 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
350 data = GINT16_TO_LE (data);
352 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
357 return g_memory_buffer_write (mbuf, &data, 2);
361 g_memory_buffer_put_uint16 (GMemoryBuffer *mbuf,
364 switch (mbuf->byte_order)
366 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
367 data = GUINT16_TO_BE (data);
369 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
370 data = GUINT16_TO_LE (data);
372 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
377 return g_memory_buffer_write (mbuf, &data, 2);
381 g_memory_buffer_put_int32 (GMemoryBuffer *mbuf,
384 switch (mbuf->byte_order)
386 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
387 data = GINT32_TO_BE (data);
389 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
390 data = GINT32_TO_LE (data);
392 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
397 return g_memory_buffer_write (mbuf, &data, 4);
401 g_memory_buffer_put_uint32 (GMemoryBuffer *mbuf,
404 switch (mbuf->byte_order)
406 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
407 data = GUINT32_TO_BE (data);
409 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
410 data = GUINT32_TO_LE (data);
412 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
417 return g_memory_buffer_write (mbuf, &data, 4);
421 g_memory_buffer_put_int64 (GMemoryBuffer *mbuf,
424 switch (mbuf->byte_order)
426 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
427 data = GINT64_TO_BE (data);
429 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
430 data = GINT64_TO_LE (data);
432 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
437 return g_memory_buffer_write (mbuf, &data, 8);
441 g_memory_buffer_put_uint64 (GMemoryBuffer *mbuf,
444 switch (mbuf->byte_order)
446 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
447 data = GUINT64_TO_BE (data);
449 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
450 data = GUINT64_TO_LE (data);
452 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
457 return g_memory_buffer_write (mbuf, &data, 8);
461 g_memory_buffer_put_string (GMemoryBuffer *mbuf,
464 g_return_val_if_fail (str != NULL, FALSE);
466 return g_memory_buffer_write (mbuf, str, strlen (str));
471 * SECTION:gdbusmessage
472 * @short_description: D-Bus Message
473 * @include: gio/gio.h
475 * A type for representing D-Bus messages that can be sent or received
476 * on a #GDBusConnection.
479 typedef struct _GDBusMessageClass GDBusMessageClass;
484 * Class structure for #GDBusMessage.
488 struct _GDBusMessageClass
491 GObjectClass parent_class;
497 * The #GDBusMessage structure contains only private data and should
498 * only be accessed using the provided API.
505 GObject parent_instance;
507 GDBusMessageType type;
508 GDBusMessageFlags flags;
510 GDBusMessageByteOrder byte_order;
511 guchar major_protocol_version;
516 GUnixFDList *fd_list;
526 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
529 g_dbus_message_finalize (GObject *object)
531 GDBusMessage *message = G_DBUS_MESSAGE (object);
533 if (message->headers != NULL)
534 g_hash_table_unref (message->headers);
535 if (message->body != NULL)
536 g_variant_unref (message->body);
538 if (message->fd_list != NULL)
539 g_object_unref (message->fd_list);
542 if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
543 G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
547 g_dbus_message_get_property (GObject *object,
552 GDBusMessage *message = G_DBUS_MESSAGE (object);
557 g_value_set_boolean (value, g_dbus_message_get_locked (message));
561 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
567 g_dbus_message_class_init (GDBusMessageClass *klass)
569 GObjectClass *gobject_class;
571 gobject_class = G_OBJECT_CLASS (klass);
572 gobject_class->finalize = g_dbus_message_finalize;
573 gobject_class->get_property = g_dbus_message_get_property;
576 * GDBusConnection:locked:
578 * A boolean specifying whether the message is locked.
582 g_object_class_install_property (gobject_class,
584 g_param_spec_boolean ("locked",
586 P_("Whether the message is locked"),
589 G_PARAM_STATIC_NAME |
590 G_PARAM_STATIC_BLURB |
591 G_PARAM_STATIC_NICK));
595 g_dbus_message_init (GDBusMessage *message)
597 /* Any D-Bus implementation is supposed to handle both Big and
598 * Little Endian encodings and the Endianness is part of the D-Bus
599 * message - we prefer to use Big Endian (since it's Network Byte
600 * Order and just easier to read for humans) but if the machine is
601 * Little Endian we use that for performance reasons.
603 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
604 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
606 /* this could also be G_PDP_ENDIAN */
607 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
609 message->headers = g_hash_table_new_full (g_direct_hash,
612 (GDestroyNotify) g_variant_unref);
616 * g_dbus_message_new:
618 * Creates a new empty #GDBusMessage.
620 * Returns: A #GDBusMessage. Free with g_object_unref().
625 g_dbus_message_new (void)
627 return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
631 * g_dbus_message_new_method_call:
632 * @name: (allow-none): A valid D-Bus name or %NULL.
633 * @path: A valid object path.
634 * @interface_: (allow-none): A valid D-Bus interface name or %NULL.
635 * @method: A valid method name.
637 * Creates a new #GDBusMessage for a method call.
639 * Returns: A #GDBusMessage. Free with g_object_unref().
644 g_dbus_message_new_method_call (const gchar *name,
646 const gchar *interface_,
649 GDBusMessage *message;
651 g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
652 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
653 g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
654 g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
656 message = g_dbus_message_new ();
657 message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
660 g_dbus_message_set_destination (message, name);
661 g_dbus_message_set_path (message, path);
662 g_dbus_message_set_member (message, method);
663 if (interface_ != NULL)
664 g_dbus_message_set_interface (message, interface_);
670 * g_dbus_message_new_signal:
671 * @path: A valid object path.
672 * @interface_: A valid D-Bus interface name.
673 * @signal: A valid signal name.
675 * Creates a new #GDBusMessage for a signal emission.
677 * Returns: A #GDBusMessage. Free with g_object_unref().
682 g_dbus_message_new_signal (const gchar *path,
683 const gchar *interface_,
686 GDBusMessage *message;
688 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
689 g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
690 g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
692 message = g_dbus_message_new ();
693 message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
694 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
696 g_dbus_message_set_path (message, path);
697 g_dbus_message_set_member (message, signal);
698 g_dbus_message_set_interface (message, interface_);
705 * g_dbus_message_new_method_reply:
706 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
707 * create a reply message to.
709 * Creates a new #GDBusMessage that is a reply to @method_call_message.
711 * Returns: (transfer full): #GDBusMessage. Free with g_object_unref().
716 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
718 GDBusMessage *message;
721 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
722 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
723 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
725 message = g_dbus_message_new ();
726 message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
727 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
728 /* reply with same endianness */
729 message->byte_order = method_call_message->byte_order;
731 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
732 sender = g_dbus_message_get_sender (method_call_message);
734 g_dbus_message_set_destination (message, sender);
740 * g_dbus_message_new_method_error:
741 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
742 * create a reply message to.
743 * @error_name: A valid D-Bus error name.
744 * @error_message_format: The D-Bus error message in a printf() format.
745 * @...: Arguments for @error_message_format.
747 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
749 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
754 g_dbus_message_new_method_error (GDBusMessage *method_call_message,
755 const gchar *error_name,
756 const gchar *error_message_format,
762 va_start (var_args, error_message_format);
763 ret = g_dbus_message_new_method_error_valist (method_call_message,
765 error_message_format,
773 * g_dbus_message_new_method_error_literal:
774 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
775 * create a reply message to.
776 * @error_name: A valid D-Bus error name.
777 * @error_message: The D-Bus error message.
779 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
781 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
786 g_dbus_message_new_method_error_literal (GDBusMessage *method_call_message,
787 const gchar *error_name,
788 const gchar *error_message)
790 GDBusMessage *message;
793 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
794 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
795 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
796 g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
797 g_return_val_if_fail (error_message != NULL, NULL);
799 message = g_dbus_message_new ();
800 message->type = G_DBUS_MESSAGE_TYPE_ERROR;
801 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
802 /* reply with same endianness */
803 message->byte_order = method_call_message->byte_order;
805 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
806 g_dbus_message_set_error_name (message, error_name);
807 g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
809 sender = g_dbus_message_get_sender (method_call_message);
811 g_dbus_message_set_destination (message, sender);
817 * g_dbus_message_new_method_error_valist:
818 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
819 * create a reply message to.
820 * @error_name: A valid D-Bus error name.
821 * @error_message_format: The D-Bus error message in a printf() format.
822 * @var_args: Arguments for @error_message_format.
824 * Like g_dbus_message_new_method_error() but intended for language bindings.
826 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
831 g_dbus_message_new_method_error_valist (GDBusMessage *method_call_message,
832 const gchar *error_name,
833 const gchar *error_message_format,
837 gchar *error_message;
838 error_message = g_strdup_vprintf (error_message_format, var_args);
839 ret = g_dbus_message_new_method_error_literal (method_call_message,
842 g_free (error_message);
846 /* ---------------------------------------------------------------------------------------------------- */
849 * g_dbus_message_get_byte_order:
850 * @message: A #GDBusMessage.
852 * Gets the byte order of @message.
854 * Returns: The byte order.
856 GDBusMessageByteOrder
857 g_dbus_message_get_byte_order (GDBusMessage *message)
859 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
860 return message->byte_order;
864 * g_dbus_message_set_byte_order:
865 * @message: A #GDBusMessage.
866 * @byte_order: The byte order.
868 * Sets the byte order of @message.
871 g_dbus_message_set_byte_order (GDBusMessage *message,
872 GDBusMessageByteOrder byte_order)
874 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
878 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
882 message->byte_order = byte_order;
885 /* ---------------------------------------------------------------------------------------------------- */
887 /* TODO: need GI annotations to specify that any guchar value goes for the type */
890 * g_dbus_message_get_message_type:
891 * @message: A #GDBusMessage.
893 * Gets the type of @message.
895 * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
900 g_dbus_message_get_message_type (GDBusMessage *message)
902 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
903 return message->type;
907 * g_dbus_message_set_message_type:
908 * @message: A #GDBusMessage.
909 * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
911 * Sets @message to be of @type.
916 g_dbus_message_set_message_type (GDBusMessage *message,
917 GDBusMessageType type)
919 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
920 g_return_if_fail (type >=0 && type < 256);
924 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
928 message->type = type;
931 /* ---------------------------------------------------------------------------------------------------- */
933 /* TODO: need GI annotations to specify that any guchar value goes for flags */
936 * g_dbus_message_get_flags:
937 * @message: A #GDBusMessage.
939 * Gets the flags for @message.
941 * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
946 g_dbus_message_get_flags (GDBusMessage *message)
948 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
949 return message->flags;
953 * g_dbus_message_set_flags:
954 * @message: A #GDBusMessage.
955 * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
956 * enumeration bitwise ORed together).
958 * Sets the flags to set on @message.
963 g_dbus_message_set_flags (GDBusMessage *message,
964 GDBusMessageFlags flags)
966 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
967 g_return_if_fail (flags >=0 && flags < 256);
971 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
975 message->flags = flags;
978 /* ---------------------------------------------------------------------------------------------------- */
981 * g_dbus_message_get_serial:
982 * @message: A #GDBusMessage.
984 * Gets the serial for @message.
986 * Returns: A #guint32.
991 g_dbus_message_get_serial (GDBusMessage *message)
993 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
994 return message->serial;
998 * g_dbus_message_set_serial:
999 * @message: A #GDBusMessage.
1000 * @serial: A #guint32.
1002 * Sets the serial for @message.
1007 g_dbus_message_set_serial (GDBusMessage *message,
1010 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1012 if (message->locked)
1014 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1018 message->serial = serial;
1021 /* ---------------------------------------------------------------------------------------------------- */
1023 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
1026 * g_dbus_message_get_header:
1027 * @message: A #GDBusMessage.
1028 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1030 * Gets a header field on @message.
1032 * Returns: A #GVariant with the value if the header was found, %NULL
1033 * otherwise. Do not free, it is owned by @message.
1038 g_dbus_message_get_header (GDBusMessage *message,
1039 GDBusMessageHeaderField header_field)
1041 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1042 g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
1043 return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
1047 * g_dbus_message_set_header:
1048 * @message: A #GDBusMessage.
1049 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1050 * @value: (allow-none): A #GVariant to set the header field or %NULL to clear the header field.
1052 * Sets a header field on @message.
1054 * If @value is floating, @message assumes ownership of @value.
1059 g_dbus_message_set_header (GDBusMessage *message,
1060 GDBusMessageHeaderField header_field,
1063 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1064 g_return_if_fail (header_field >=0 && header_field < 256);
1066 if (message->locked)
1068 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1074 g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
1078 g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
1083 * g_dbus_message_get_header_fields:
1084 * @message: A #GDBusMessage.
1086 * Gets an array of all header fields on @message that are set.
1088 * Returns: (array zero-terminated=1): An array of header fields
1089 * terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element
1090 * is a #guchar. Free with g_free().
1095 g_dbus_message_get_header_fields (GDBusMessage *message)
1103 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1105 keys = g_hash_table_get_keys (message->headers);
1106 num_keys = g_list_length (keys);
1107 ret = g_new (guchar, num_keys + 1);
1108 for (l = keys, n = 0; l != NULL; l = l->next, n++)
1109 ret[n] = GPOINTER_TO_UINT (l->data);
1110 g_assert (n == num_keys);
1111 ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
1117 /* ---------------------------------------------------------------------------------------------------- */
1120 * g_dbus_message_get_body:
1121 * @message: A #GDBusMessage.
1123 * Gets the body of a message.
1125 * Returns: A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
1130 g_dbus_message_get_body (GDBusMessage *message)
1132 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1133 return message->body;
1137 * g_dbus_message_set_body:
1138 * @message: A #GDBusMessage.
1139 * @body: Either %NULL or a #GVariant that is a tuple.
1141 * Sets the body @message. As a side-effect the
1142 * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
1143 * type string of @body (or cleared if @body is %NULL).
1145 * If @body is floating, @message assumes ownership of @body.
1150 g_dbus_message_set_body (GDBusMessage *message,
1153 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1154 g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
1156 if (message->locked)
1158 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1162 if (message->body != NULL)
1163 g_variant_unref (message->body);
1166 message->body = NULL;
1167 g_dbus_message_set_signature (message, NULL);
1171 const gchar *type_string;
1172 gsize type_string_len;
1175 message->body = g_variant_ref_sink (body);
1177 type_string = g_variant_get_type_string (body);
1178 type_string_len = strlen (type_string);
1179 g_assert (type_string_len >= 2);
1180 signature = g_strndup (type_string + 1, type_string_len - 2);
1181 g_dbus_message_set_signature (message, signature);
1186 /* ---------------------------------------------------------------------------------------------------- */
1190 * g_dbus_message_get_unix_fd_list:
1191 * @message: A #GDBusMessage.
1193 * Gets the UNIX file descriptors associated with @message, if any.
1195 * This method is only available on UNIX.
1197 * Returns: (transfer none):A #GUnixFDList or %NULL if no file descriptors are
1198 * associated. Do not free, this object is owned by @message.
1203 g_dbus_message_get_unix_fd_list (GDBusMessage *message)
1205 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1206 return message->fd_list;
1210 * g_dbus_message_set_unix_fd_list:
1211 * @message: A #GDBusMessage.
1212 * @fd_list: (allow-none): A #GUnixFDList or %NULL.
1214 * Sets the UNIX file descriptors associated with @message. As a
1215 * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
1216 * field is set to the number of fds in @fd_list (or cleared if
1217 * @fd_list is %NULL).
1219 * This method is only available on UNIX.
1224 g_dbus_message_set_unix_fd_list (GDBusMessage *message,
1225 GUnixFDList *fd_list)
1227 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1228 g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
1230 if (message->locked)
1232 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1236 if (message->fd_list != NULL)
1237 g_object_unref (message->fd_list);
1238 if (fd_list != NULL)
1240 message->fd_list = g_object_ref (fd_list);
1241 g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
1245 message->fd_list = NULL;
1246 g_dbus_message_set_num_unix_fds (message, 0);
1251 /* ---------------------------------------------------------------------------------------------------- */
1254 validate_headers (GDBusMessage *message,
1259 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
1260 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1264 switch (message->type)
1266 case G_DBUS_MESSAGE_TYPE_INVALID:
1267 g_set_error_literal (error,
1269 G_IO_ERROR_INVALID_ARGUMENT,
1270 _("type is INVALID"));
1274 case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
1275 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1276 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1278 g_set_error_literal (error,
1280 G_IO_ERROR_INVALID_ARGUMENT,
1281 _("METHOD_CALL message: PATH or MEMBER header field is missing"));
1286 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
1287 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1289 g_set_error_literal (error,
1291 G_IO_ERROR_INVALID_ARGUMENT,
1292 _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
1297 case G_DBUS_MESSAGE_TYPE_ERROR:
1298 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
1299 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1301 g_set_error_literal (error,
1303 G_IO_ERROR_INVALID_ARGUMENT,
1304 _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
1309 case G_DBUS_MESSAGE_TYPE_SIGNAL:
1310 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1311 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
1312 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1314 g_set_error_literal (error,
1316 G_IO_ERROR_INVALID_ARGUMENT,
1317 _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
1320 if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
1322 g_set_error_literal (error,
1324 G_IO_ERROR_INVALID_ARGUMENT,
1325 _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
1328 if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
1330 g_set_error_literal (error,
1332 G_IO_ERROR_INVALID_ARGUMENT,
1333 _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
1339 /* hitherto unknown type - nothing to check */
1346 g_assert (ret || (error == NULL || *error != NULL));
1350 /* ---------------------------------------------------------------------------------------------------- */
1353 ensure_input_padding (GMemoryBuffer *buf,
1358 gsize wanted_offset;
1361 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1362 buf->pos = wanted_offset;
1366 static const gchar *
1367 read_string (GMemoryBuffer *mbuf,
1372 const gchar *end_valid;
1374 if (mbuf->pos + len >= mbuf->valid_len || mbuf->pos + len < mbuf->pos)
1376 mbuf->pos = mbuf->valid_len;
1377 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
1380 G_IO_ERROR_INVALID_ARGUMENT,
1381 g_dngettext (GETTEXT_PACKAGE,
1382 "Wanted to read %lu bytes but only got %lu",
1383 "Wanted to read %lu byte but only got %lu",
1386 (gulong)mbuf->valid_len - mbuf->pos);
1387 mbuf->pos = mbuf->valid_len;
1391 if (mbuf->data[mbuf->pos + len] != '\0')
1393 str = g_strndup (mbuf->data + mbuf->pos, len);
1396 G_IO_ERROR_INVALID_ARGUMENT,
1397 _("Expected NUL byte after the string `%s' but found byte %d"),
1398 str, mbuf->data[mbuf->pos + len]);
1400 mbuf->pos += len + 1;
1404 str = mbuf->data + mbuf->pos;
1405 mbuf->pos += len + 1;
1407 if (!g_utf8_validate (str, -1, &end_valid))
1411 offset = (gint) (end_valid - str);
1412 valid_str = g_strndup (str, offset);
1415 G_IO_ERROR_INVALID_ARGUMENT,
1416 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1417 "The valid UTF-8 string up until that point was `%s'"),
1428 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1430 /* returns a non-floating GVariant! */
1432 parse_value_from_blob (GMemoryBuffer *buf,
1433 const GVariantType *type,
1434 gboolean just_align,
1439 GError *local_error;
1441 const gchar *type_string;
1443 type_string = g_variant_type_peek_string (type);
1445 #ifdef DEBUG_SERIALIZER
1448 s = g_variant_type_dup_string (type);
1449 g_print ("%*s%s type %s from offset 0x%04x",
1451 just_align ? "Aligning" : "Reading",
1453 (gint) g_seekable_tell (G_SEEKABLE (buf)));
1456 #endif /* DEBUG_SERIALIZER */
1462 switch (type_string[0])
1464 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1465 if (!ensure_input_padding (buf, 4, &local_error))
1470 v = g_memory_buffer_read_uint32 (buf, &local_error);
1471 if (local_error != NULL)
1473 ret = g_variant_new_boolean (v);
1477 case 'y': /* G_VARIANT_TYPE_BYTE */
1481 v = g_memory_buffer_read_byte (buf, &local_error);
1482 if (local_error != NULL)
1484 ret = g_variant_new_byte (v);
1488 case 'n': /* G_VARIANT_TYPE_INT16 */
1489 if (!ensure_input_padding (buf, 2, &local_error))
1494 v = g_memory_buffer_read_int16 (buf, &local_error);
1495 if (local_error != NULL)
1497 ret = g_variant_new_int16 (v);
1501 case 'q': /* G_VARIANT_TYPE_UINT16 */
1502 if (!ensure_input_padding (buf, 2, &local_error))
1507 v = g_memory_buffer_read_uint16 (buf, &local_error);
1508 if (local_error != NULL)
1510 ret = g_variant_new_uint16 (v);
1514 case 'i': /* G_VARIANT_TYPE_INT32 */
1515 if (!ensure_input_padding (buf, 4, &local_error))
1520 v = g_memory_buffer_read_int32 (buf, &local_error);
1521 if (local_error != NULL)
1523 ret = g_variant_new_int32 (v);
1527 case 'u': /* G_VARIANT_TYPE_UINT32 */
1528 if (!ensure_input_padding (buf, 4, &local_error))
1533 v = g_memory_buffer_read_uint32 (buf, &local_error);
1534 if (local_error != NULL)
1536 ret = g_variant_new_uint32 (v);
1540 case 'x': /* G_VARIANT_TYPE_INT64 */
1541 if (!ensure_input_padding (buf, 8, &local_error))
1546 v = g_memory_buffer_read_int64 (buf, &local_error);
1547 if (local_error != NULL)
1549 ret = g_variant_new_int64 (v);
1553 case 't': /* G_VARIANT_TYPE_UINT64 */
1554 if (!ensure_input_padding (buf, 8, &local_error))
1559 v = g_memory_buffer_read_uint64 (buf, &local_error);
1560 if (local_error != NULL)
1562 ret = g_variant_new_uint64 (v);
1566 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1567 if (!ensure_input_padding (buf, 8, &local_error))
1575 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1576 u.v_uint64 = g_memory_buffer_read_uint64 (buf, &local_error);
1577 if (local_error != NULL)
1579 ret = g_variant_new_double (u.v_double);
1583 case 's': /* G_VARIANT_TYPE_STRING */
1584 if (!ensure_input_padding (buf, 4, &local_error))
1590 len = g_memory_buffer_read_uint32 (buf, &local_error);
1591 if (local_error != NULL)
1593 v = read_string (buf, (gsize) len, &local_error);
1596 ret = g_variant_new_string (v);
1600 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1601 if (!ensure_input_padding (buf, 4, &local_error))
1607 len = g_memory_buffer_read_uint32 (buf, &local_error);
1608 if (local_error != NULL)
1610 v = read_string (buf, (gsize) len, &local_error);
1613 if (!g_variant_is_object_path (v))
1615 g_set_error (&local_error,
1617 G_IO_ERROR_INVALID_ARGUMENT,
1618 _("Parsed value `%s' is not a valid D-Bus object path"),
1622 ret = g_variant_new_object_path (v);
1626 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
1631 len = g_memory_buffer_read_byte (buf, &local_error);
1632 if (local_error != NULL)
1634 v = read_string (buf, (gsize) len, &local_error);
1637 if (!g_variant_is_signature (v))
1639 g_set_error (&local_error,
1641 G_IO_ERROR_INVALID_ARGUMENT,
1642 _("Parsed value `%s' is not a valid D-Bus signature"),
1646 ret = g_variant_new_signature (v);
1650 case 'h': /* G_VARIANT_TYPE_HANDLE */
1651 if (!ensure_input_padding (buf, 4, &local_error))
1656 v = g_memory_buffer_read_int32 (buf, &local_error);
1657 if (local_error != NULL)
1659 ret = g_variant_new_handle (v);
1663 case 'a': /* G_VARIANT_TYPE_ARRAY */
1664 if (!ensure_input_padding (buf, 4, &local_error))
1667 /* If we are only aligning for this array type, it is the child type of
1668 * another array, which is empty. So, we do not need to add padding for
1669 * this nonexistent array's elements: we only need to align for this
1670 * array itself (4 bytes). See
1671 * <https://bugzilla.gnome.org/show_bug.cgi?id=673612>.
1678 const GVariantType *element_type;
1679 GVariantBuilder builder;
1681 array_len = g_memory_buffer_read_uint32 (buf, &local_error);
1682 if (local_error != NULL)
1686 #ifdef DEBUG_SERIALIZER
1687 g_print (": array spans 0x%04x bytes\n", array_len);
1688 #endif /* DEBUG_SERIALIZER */
1690 if (array_len > (2<<26))
1692 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1693 g_set_error (&local_error,
1695 G_IO_ERROR_INVALID_ARGUMENT,
1696 g_dngettext (GETTEXT_PACKAGE,
1697 "Encountered array of length %u byte. Maximum length is 2<<26 bytes (64 MiB).",
1698 "Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB).",
1704 g_variant_builder_init (&builder, type);
1705 element_type = g_variant_type_element (type);
1710 item = parse_value_from_blob (buf,
1715 g_assert (item == NULL);
1719 /* TODO: optimize array of primitive types */
1721 target = offset + array_len;
1722 while (offset < target)
1725 item = parse_value_from_blob (buf,
1732 g_variant_builder_clear (&builder);
1735 g_variant_builder_add_value (&builder, item);
1736 g_variant_unref (item);
1741 ret = g_variant_builder_end (&builder);
1746 if (g_variant_type_is_dict_entry (type))
1748 const GVariantType *key_type;
1749 const GVariantType *value_type;
1753 if (!ensure_input_padding (buf, 8, &local_error))
1757 #ifdef DEBUG_SERIALIZER
1759 #endif /* DEBUG_SERIALIZER */
1763 key_type = g_variant_type_key (type);
1764 key = parse_value_from_blob (buf,
1771 value_type = g_variant_type_value (type);
1772 value = parse_value_from_blob (buf,
1779 g_variant_unref (key);
1782 ret = g_variant_new_dict_entry (key, value);
1783 g_variant_unref (key);
1784 g_variant_unref (value);
1787 else if (g_variant_type_is_tuple (type))
1789 if (!ensure_input_padding (buf, 8, &local_error))
1793 #ifdef DEBUG_SERIALIZER
1795 #endif /* DEBUG_SERIALIZER */
1799 const GVariantType *element_type;
1800 GVariantBuilder builder;
1802 g_variant_builder_init (&builder, type);
1803 element_type = g_variant_type_first (type);
1804 while (element_type != NULL)
1807 item = parse_value_from_blob (buf,
1814 g_variant_builder_clear (&builder);
1817 g_variant_builder_add_value (&builder, item);
1818 g_variant_unref (item);
1820 element_type = g_variant_type_next (element_type);
1822 ret = g_variant_builder_end (&builder);
1825 else if (g_variant_type_is_variant (type))
1828 #ifdef DEBUG_SERIALIZER
1830 #endif /* DEBUG_SERIALIZER */
1836 GVariantType *variant_type;
1839 siglen = g_memory_buffer_read_byte (buf, &local_error);
1840 if (local_error != NULL)
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 */
1909 g_assert (g_variant_is_floating (ret));
1910 g_variant_ref_sink (ret);
1915 #ifdef DEBUG_SERIALIZER
1917 "%*sFAILURE: %s (%s, %d)\n",
1919 local_error->message,
1920 g_quark_to_string (local_error->domain),
1922 #endif /* DEBUG_SERIALIZER */
1923 g_propagate_error (error, local_error);
1927 /* ---------------------------------------------------------------------------------------------------- */
1929 /* message_header must be at least 16 bytes */
1932 * g_dbus_message_bytes_needed:
1933 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1934 * @blob_len: The length of @blob (must be at least 16).
1935 * @error: Return location for error or %NULL.
1937 * Utility function to calculate how many bytes are needed to
1938 * completely deserialize the D-Bus message stored at @blob.
1940 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1941 * @blob contains invalid data or not enough data is available to
1942 * determine the size).
1947 g_dbus_message_bytes_needed (guchar *blob,
1955 g_return_val_if_fail (blob != NULL, -1);
1956 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1957 g_return_val_if_fail (blob_len >= 16, -1);
1961 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1962 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1963 /* round up so it's a multiple of 8 */
1964 ret = 8 * ((ret + 7)/8);
1965 /* finally add the body size */
1966 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1968 else if (blob[0] == 'B')
1970 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1971 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1972 /* round up so it's a multiple of 8 */
1973 ret = 8 * ((ret + 7)/8);
1974 /* finally add the body size */
1975 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1981 G_IO_ERROR_INVALID_ARGUMENT,
1982 "Unable to determine message blob length - given blob is malformed");
1989 G_IO_ERROR_INVALID_ARGUMENT,
1990 "Blob indicates that message exceeds maximum message length (128MiB)");
1997 /* ---------------------------------------------------------------------------------------------------- */
2000 * g_dbus_message_new_from_blob:
2001 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
2002 * @blob_len: The length of @blob.
2003 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2004 * @error: Return location for error or %NULL.
2006 * Creates a new #GDBusMessage from the data stored at @blob. The byte
2007 * order that the message was in can be retrieved using
2008 * g_dbus_message_get_byte_order().
2010 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
2016 g_dbus_message_new_from_blob (guchar *blob,
2018 GDBusCapabilityFlags capabilities,
2023 GDBusMessage *message;
2025 guchar major_protocol_version;
2026 guint32 message_body_len;
2030 GVariant *signature;
2032 /* TODO: check against @capabilities */
2036 g_return_val_if_fail (blob != NULL, NULL);
2037 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2038 g_return_val_if_fail (blob_len >= 12, NULL);
2040 message = g_dbus_message_new ();
2042 memset (&mbuf, 0, sizeof (mbuf));
2043 mbuf.data = (gchar *)blob;
2044 mbuf.len = mbuf.valid_len = blob_len;
2046 endianness = g_memory_buffer_read_byte (&mbuf, NULL);
2050 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2051 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
2054 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2055 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
2060 G_IO_ERROR_INVALID_ARGUMENT,
2061 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
2066 message->type = g_memory_buffer_read_byte (&mbuf, NULL);
2067 message->flags = g_memory_buffer_read_byte (&mbuf, NULL);
2068 major_protocol_version = g_memory_buffer_read_byte (&mbuf, NULL);
2069 if (major_protocol_version != 1)
2073 G_IO_ERROR_INVALID_ARGUMENT,
2074 _("Invalid major protocol version. Expected 1 but found %d"),
2075 major_protocol_version);
2078 message_body_len = g_memory_buffer_read_uint32 (&mbuf, NULL);
2079 message->serial = g_memory_buffer_read_uint32 (&mbuf, NULL);
2081 #ifdef DEBUG_SERIALIZER
2082 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2085 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
2086 g_print ("%s\n", s);
2089 #endif /* DEBUG_SERIALIZER */
2091 #ifdef DEBUG_SERIALIZER
2092 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2093 #endif /* DEBUG_SERIALIZER */
2094 headers = parse_value_from_blob (&mbuf,
2095 G_VARIANT_TYPE ("a{yv}"),
2099 if (headers == NULL)
2101 g_variant_iter_init (&iter, headers);
2102 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2104 guchar header_field;
2106 g_variant_get (item,
2110 g_dbus_message_set_header (message, header_field, value);
2111 g_variant_unref (value);
2112 g_variant_unref (item);
2114 g_variant_unref (headers);
2116 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2117 if (signature != NULL)
2119 const gchar *signature_str;
2120 gsize signature_str_len;
2122 signature_str = g_variant_get_string (signature, &signature_str_len);
2124 /* signature but no body */
2125 if (message_body_len == 0 && signature_str_len > 0)
2129 G_IO_ERROR_INVALID_ARGUMENT,
2130 _("Signature header with signature `%s' found but message body is empty"),
2134 else if (signature_str_len > 0)
2136 GVariantType *variant_type;
2137 gchar *tupled_signature_str;
2139 if (!g_variant_is_signature (signature_str))
2143 G_IO_ERROR_INVALID_ARGUMENT,
2144 _("Parsed value `%s' is not a valid D-Bus signature (for body)"),
2148 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2149 variant_type = g_variant_type_new (tupled_signature_str);
2150 g_free (tupled_signature_str);
2151 #ifdef DEBUG_SERIALIZER
2152 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2153 #endif /* DEBUG_SERIALIZER */
2154 message->body = parse_value_from_blob (&mbuf,
2159 g_variant_type_free (variant_type);
2160 if (message->body == NULL)
2166 /* no signature, this is only OK if the body is empty */
2167 if (message_body_len != 0)
2169 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
2172 G_IO_ERROR_INVALID_ARGUMENT,
2173 g_dngettext (GETTEXT_PACKAGE,
2174 "No signature header in message but the message body is %u byte",
2175 "No signature header in message but the message body is %u bytes",
2182 if (!validate_headers (message, error))
2184 g_prefix_error (error, _("Cannot deserialize message: "));
2197 if (message != NULL)
2198 g_object_unref (message);
2203 /* ---------------------------------------------------------------------------------------------------- */
2206 ensure_output_padding (GMemoryBuffer *mbuf,
2210 gsize wanted_offset;
2211 gsize padding_needed;
2215 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
2216 padding_needed = wanted_offset - offset;
2218 for (n = 0; n < padding_needed; n++)
2219 g_memory_buffer_put_byte (mbuf, '\0');
2221 return padding_needed;
2224 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
2226 append_value_to_blob (GVariant *value,
2227 const GVariantType *type,
2228 GMemoryBuffer *mbuf,
2229 gsize *out_padding_added,
2232 gsize padding_added;
2233 const gchar *type_string;
2235 type_string = g_variant_type_peek_string (type);
2239 switch (type_string[0])
2241 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
2242 padding_added = ensure_output_padding (mbuf, 4);
2245 gboolean v = g_variant_get_boolean (value);
2246 g_memory_buffer_put_uint32 (mbuf, v);
2250 case 'y': /* G_VARIANT_TYPE_BYTE */
2253 guint8 v = g_variant_get_byte (value);
2254 g_memory_buffer_put_byte (mbuf, v);
2258 case 'n': /* G_VARIANT_TYPE_INT16 */
2259 padding_added = ensure_output_padding (mbuf, 2);
2262 gint16 v = g_variant_get_int16 (value);
2263 g_memory_buffer_put_int16 (mbuf, v);
2267 case 'q': /* G_VARIANT_TYPE_UINT16 */
2268 padding_added = ensure_output_padding (mbuf, 2);
2271 guint16 v = g_variant_get_uint16 (value);
2272 g_memory_buffer_put_uint16 (mbuf, v);
2276 case 'i': /* G_VARIANT_TYPE_INT32 */
2277 padding_added = ensure_output_padding (mbuf, 4);
2280 gint32 v = g_variant_get_int32 (value);
2281 g_memory_buffer_put_int32 (mbuf, v);
2285 case 'u': /* G_VARIANT_TYPE_UINT32 */
2286 padding_added = ensure_output_padding (mbuf, 4);
2289 guint32 v = g_variant_get_uint32 (value);
2290 g_memory_buffer_put_uint32 (mbuf, v);
2294 case 'x': /* G_VARIANT_TYPE_INT64 */
2295 padding_added = ensure_output_padding (mbuf, 8);
2298 gint64 v = g_variant_get_int64 (value);
2299 g_memory_buffer_put_int64 (mbuf, v);
2303 case 't': /* G_VARIANT_TYPE_UINT64 */
2304 padding_added = ensure_output_padding (mbuf, 8);
2307 guint64 v = g_variant_get_uint64 (value);
2308 g_memory_buffer_put_uint64 (mbuf, v);
2312 case 'd': /* G_VARIANT_TYPE_DOUBLE */
2313 padding_added = ensure_output_padding (mbuf, 8);
2320 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
2321 u.v_double = g_variant_get_double (value);
2322 g_memory_buffer_put_uint64 (mbuf, u.v_uint64);
2326 case 's': /* G_VARIANT_TYPE_STRING */
2327 padding_added = ensure_output_padding (mbuf, 4);
2333 v = g_variant_get_string (value, &len);
2334 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
2335 g_memory_buffer_put_uint32 (mbuf, len);
2336 g_memory_buffer_put_string (mbuf, v);
2337 g_memory_buffer_put_byte (mbuf, '\0');
2341 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
2342 padding_added = ensure_output_padding (mbuf, 4);
2346 const gchar *v = g_variant_get_string (value, &len);
2347 g_assert (g_variant_is_object_path (v));
2348 g_memory_buffer_put_uint32 (mbuf, len);
2349 g_memory_buffer_put_string (mbuf, v);
2350 g_memory_buffer_put_byte (mbuf, '\0');
2354 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
2358 const gchar *v = g_variant_get_string (value, &len);
2359 g_assert (g_variant_is_signature (v));
2360 g_memory_buffer_put_byte (mbuf, len);
2361 g_memory_buffer_put_string (mbuf, v);
2362 g_memory_buffer_put_byte (mbuf, '\0');
2366 case 'h': /* G_VARIANT_TYPE_HANDLE */
2367 padding_added = ensure_output_padding (mbuf, 4);
2370 gint32 v = g_variant_get_handle (value);
2371 g_memory_buffer_put_int32 (mbuf, v);
2375 case 'a': /* G_VARIANT_TYPE_ARRAY */
2379 goffset array_len_offset;
2380 goffset array_payload_begin_offset;
2384 padding_added = ensure_output_padding (mbuf, 4);
2387 /* array length - will be filled in later */
2388 array_len_offset = mbuf->valid_len;
2389 g_memory_buffer_put_uint32 (mbuf, 0xF00DFACE);
2391 /* From the D-Bus spec:
2393 * "A UINT32 giving the length of the array data in bytes,
2394 * followed by alignment padding to the alignment boundary of
2395 * the array element type, followed by each array element. The
2396 * array length is from the end of the alignment padding to
2397 * the end of the last element, i.e. it does not include the
2398 * padding after the length, or any padding after the last
2401 * Thus, we need to count how much padding the first element
2402 * contributes and subtract that from the array length.
2404 array_payload_begin_offset = mbuf->valid_len;
2406 if (g_variant_n_children (value) == 0)
2408 gsize padding_added_for_item;
2409 if (!append_value_to_blob (NULL,
2410 g_variant_type_element (type),
2412 &padding_added_for_item,
2415 array_payload_begin_offset += padding_added_for_item;
2421 g_variant_iter_init (&iter, value);
2422 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2424 gsize padding_added_for_item;
2425 if (!append_value_to_blob (item,
2426 g_variant_get_type (item),
2428 &padding_added_for_item,
2431 g_variant_unref (item);
2434 g_variant_unref (item);
2437 array_payload_begin_offset += padding_added_for_item;
2443 cur_offset = mbuf->valid_len;
2444 array_len = cur_offset - array_payload_begin_offset;
2445 mbuf->pos = array_len_offset;
2447 g_memory_buffer_put_uint32 (mbuf, array_len);
2448 mbuf->pos = cur_offset;
2454 if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2456 padding_added = ensure_output_padding (mbuf, 8);
2461 g_variant_iter_init (&iter, value);
2462 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2464 if (!append_value_to_blob (item,
2465 g_variant_get_type (item),
2470 g_variant_unref (item);
2473 g_variant_unref (item);
2477 else if (g_variant_type_is_variant (type))
2482 const gchar *signature;
2483 child = g_variant_get_child_value (value, 0);
2484 signature = g_variant_get_type_string (child);
2485 g_memory_buffer_put_byte (mbuf, strlen (signature));
2486 g_memory_buffer_put_string (mbuf, signature);
2487 g_memory_buffer_put_byte (mbuf, '\0');
2488 if (!append_value_to_blob (child,
2489 g_variant_get_type (child),
2494 g_variant_unref (child);
2497 g_variant_unref (child);
2504 G_IO_ERROR_INVALID_ARGUMENT,
2505 _("Error serializing GVariant with type string `%s' to the D-Bus wire format"),
2506 g_variant_get_type_string (value));
2512 if (out_padding_added != NULL)
2513 *out_padding_added = padding_added;
2522 append_body_to_blob (GVariant *value,
2523 GMemoryBuffer *mbuf,
2529 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2533 G_IO_ERROR_INVALID_ARGUMENT,
2534 "Expected a tuple for the body of the GDBusMessage.");
2538 g_variant_iter_init (&iter, value);
2539 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2541 if (!append_value_to_blob (item,
2542 g_variant_get_type (item),
2547 g_variant_unref (item);
2550 g_variant_unref (item);
2558 /* ---------------------------------------------------------------------------------------------------- */
2561 * g_dbus_message_to_blob:
2562 * @message: A #GDBusMessage.
2563 * @out_size: Return location for size of generated blob.
2564 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2565 * @error: Return location for error.
2567 * Serializes @message to a blob. The byte order returned by
2568 * g_dbus_message_get_byte_order() will be used.
2570 * Returns: (array length=out_size) (transfer full): A pointer to a
2571 * valid binary D-Bus message of @out_size bytes generated by @message
2572 * or %NULL if @error is set. Free with g_free().
2577 g_dbus_message_to_blob (GDBusMessage *message,
2579 GDBusCapabilityFlags capabilities,
2585 goffset body_len_offset;
2586 goffset body_start_offset;
2588 GVariant *header_fields;
2589 GVariantBuilder builder;
2590 GHashTableIter hash_iter;
2592 GVariant *header_value;
2593 GVariant *signature;
2594 const gchar *signature_str;
2595 gint num_fds_in_message;
2596 gint num_fds_according_to_header;
2598 /* TODO: check against @capabilities */
2602 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2603 g_return_val_if_fail (out_size != NULL, NULL);
2604 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2606 memset (&mbuf, 0, sizeof (mbuf));
2607 mbuf.len = MIN_ARRAY_SIZE;
2608 mbuf.data = g_malloc (mbuf.len);
2610 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2611 switch (message->byte_order)
2613 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2614 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2616 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2617 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2622 g_memory_buffer_put_byte (&mbuf, (guchar) message->byte_order);
2623 g_memory_buffer_put_byte (&mbuf, message->type);
2624 g_memory_buffer_put_byte (&mbuf, message->flags);
2625 g_memory_buffer_put_byte (&mbuf, 1); /* major protocol version */
2626 body_len_offset = mbuf.valid_len;
2627 /* body length - will be filled in later */
2628 g_memory_buffer_put_uint32 (&mbuf, 0xF00DFACE);
2629 g_memory_buffer_put_uint32 (&mbuf, message->serial);
2631 num_fds_in_message = 0;
2633 if (message->fd_list != NULL)
2634 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2636 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2637 if (num_fds_in_message != num_fds_according_to_header)
2641 G_IO_ERROR_INVALID_ARGUMENT,
2642 _("Message has %d file descriptors but the header field indicates %d file descriptors"),
2644 num_fds_according_to_header);
2648 if (!validate_headers (message, error))
2650 g_prefix_error (error, _("Cannot serialize message: "));
2654 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2655 g_hash_table_iter_init (&hash_iter, message->headers);
2656 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2658 g_variant_builder_add (&builder,
2660 (guchar) GPOINTER_TO_UINT (key),
2663 header_fields = g_variant_builder_end (&builder);
2665 if (!append_value_to_blob (header_fields,
2666 g_variant_get_type (header_fields),
2671 g_variant_unref (header_fields);
2674 g_variant_unref (header_fields);
2676 /* header size must be a multiple of 8 */
2677 ensure_output_padding (&mbuf, 8);
2679 body_start_offset = mbuf.valid_len;
2681 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2682 signature_str = NULL;
2683 if (signature != NULL)
2684 signature_str = g_variant_get_string (signature, NULL);
2685 if (message->body != NULL)
2687 gchar *tupled_signature_str;
2688 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2689 if (signature == NULL)
2693 G_IO_ERROR_INVALID_ARGUMENT,
2694 _("Message body has signature `%s' but there is no signature header"),
2696 g_free (tupled_signature_str);
2699 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2703 G_IO_ERROR_INVALID_ARGUMENT,
2704 _("Message body has type signature `%s' but signature in the header field is `%s'"),
2705 tupled_signature_str, g_variant_get_type_string (message->body));
2706 g_free (tupled_signature_str);
2709 g_free (tupled_signature_str);
2710 if (!append_body_to_blob (message->body, &mbuf, error))
2715 if (signature != NULL && strlen (signature_str) > 0)
2719 G_IO_ERROR_INVALID_ARGUMENT,
2720 _("Message body is empty but signature in the header field is `(%s)'"),
2726 /* OK, we're done writing the message - set the body length */
2727 size = mbuf.valid_len;
2728 body_size = size - body_start_offset;
2730 mbuf.pos = body_len_offset;
2732 g_memory_buffer_put_uint32 (&mbuf, body_size);
2735 ret = (guchar *)mbuf.data;
2741 /* ---------------------------------------------------------------------------------------------------- */
2744 get_uint32_header (GDBusMessage *message,
2745 GDBusMessageHeaderField header_field)
2751 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2752 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2753 ret = g_variant_get_uint32 (value);
2758 static const gchar *
2759 get_string_header (GDBusMessage *message,
2760 GDBusMessageHeaderField header_field)
2766 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2767 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2768 ret = g_variant_get_string (value, NULL);
2773 static const gchar *
2774 get_object_path_header (GDBusMessage *message,
2775 GDBusMessageHeaderField header_field)
2781 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2782 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2783 ret = g_variant_get_string (value, NULL);
2788 static const gchar *
2789 get_signature_header (GDBusMessage *message,
2790 GDBusMessageHeaderField header_field)
2796 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2797 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2798 ret = g_variant_get_string (value, NULL);
2803 /* ---------------------------------------------------------------------------------------------------- */
2806 set_uint32_header (GDBusMessage *message,
2807 GDBusMessageHeaderField header_field,
2810 g_dbus_message_set_header (message,
2812 g_variant_new_uint32 (value));
2816 set_string_header (GDBusMessage *message,
2817 GDBusMessageHeaderField header_field,
2820 g_dbus_message_set_header (message,
2822 value == NULL ? NULL : g_variant_new_string (value));
2826 set_object_path_header (GDBusMessage *message,
2827 GDBusMessageHeaderField header_field,
2830 g_dbus_message_set_header (message,
2832 value == NULL ? NULL : g_variant_new_object_path (value));
2836 set_signature_header (GDBusMessage *message,
2837 GDBusMessageHeaderField header_field,
2840 g_dbus_message_set_header (message,
2842 value == NULL ? NULL : g_variant_new_signature (value));
2845 /* ---------------------------------------------------------------------------------------------------- */
2848 * g_dbus_message_get_reply_serial:
2849 * @message: A #GDBusMessage.
2851 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2853 * Returns: The value.
2858 g_dbus_message_get_reply_serial (GDBusMessage *message)
2860 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2861 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2865 * g_dbus_message_set_reply_serial:
2866 * @message: A #GDBusMessage.
2867 * @value: The value to set.
2869 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2874 g_dbus_message_set_reply_serial (GDBusMessage *message,
2877 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2878 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2881 /* ---------------------------------------------------------------------------------------------------- */
2884 * g_dbus_message_get_interface:
2885 * @message: A #GDBusMessage.
2887 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2889 * Returns: The value.
2894 g_dbus_message_get_interface (GDBusMessage *message)
2896 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2897 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2901 * g_dbus_message_set_interface:
2902 * @message: A #GDBusMessage.
2903 * @value: The value to set.
2905 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2910 g_dbus_message_set_interface (GDBusMessage *message,
2913 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2914 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2915 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2918 /* ---------------------------------------------------------------------------------------------------- */
2921 * g_dbus_message_get_member:
2922 * @message: A #GDBusMessage.
2924 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2926 * Returns: The value.
2931 g_dbus_message_get_member (GDBusMessage *message)
2933 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2934 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2938 * g_dbus_message_set_member:
2939 * @message: A #GDBusMessage.
2940 * @value: The value to set.
2942 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2947 g_dbus_message_set_member (GDBusMessage *message,
2950 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2951 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2952 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2955 /* ---------------------------------------------------------------------------------------------------- */
2958 * g_dbus_message_get_path:
2959 * @message: A #GDBusMessage.
2961 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2963 * Returns: The value.
2968 g_dbus_message_get_path (GDBusMessage *message)
2970 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2971 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2975 * g_dbus_message_set_path:
2976 * @message: A #GDBusMessage.
2977 * @value: The value to set.
2979 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2984 g_dbus_message_set_path (GDBusMessage *message,
2987 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2988 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2989 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2992 /* ---------------------------------------------------------------------------------------------------- */
2995 * g_dbus_message_get_sender:
2996 * @message: A #GDBusMessage.
2998 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3000 * Returns: The value.
3005 g_dbus_message_get_sender (GDBusMessage *message)
3007 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3008 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
3012 * g_dbus_message_set_sender:
3013 * @message: A #GDBusMessage.
3014 * @value: The value to set.
3016 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3021 g_dbus_message_set_sender (GDBusMessage *message,
3024 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3025 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3026 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
3029 /* ---------------------------------------------------------------------------------------------------- */
3032 * g_dbus_message_get_destination:
3033 * @message: A #GDBusMessage.
3035 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3037 * Returns: The value.
3042 g_dbus_message_get_destination (GDBusMessage *message)
3044 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3045 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
3049 * g_dbus_message_set_destination:
3050 * @message: A #GDBusMessage.
3051 * @value: The value to set.
3053 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3058 g_dbus_message_set_destination (GDBusMessage *message,
3061 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3062 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3063 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
3066 /* ---------------------------------------------------------------------------------------------------- */
3069 * g_dbus_message_get_error_name:
3070 * @message: A #GDBusMessage.
3072 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3074 * Returns: The value.
3079 g_dbus_message_get_error_name (GDBusMessage *message)
3081 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3082 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
3086 * g_dbus_message_set_error_name:
3087 * @message: A #GDBusMessage.
3088 * @value: The value to set.
3090 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3095 g_dbus_message_set_error_name (GDBusMessage *message,
3098 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3099 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
3100 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
3103 /* ---------------------------------------------------------------------------------------------------- */
3106 * g_dbus_message_get_signature:
3107 * @message: A #GDBusMessage.
3109 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3111 * Returns: The value.
3116 g_dbus_message_get_signature (GDBusMessage *message)
3119 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3120 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
3127 * g_dbus_message_set_signature:
3128 * @message: A #GDBusMessage.
3129 * @value: The value to set.
3131 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3136 g_dbus_message_set_signature (GDBusMessage *message,
3139 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3140 g_return_if_fail (value == NULL || g_variant_is_signature (value));
3141 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
3144 /* ---------------------------------------------------------------------------------------------------- */
3147 * g_dbus_message_get_arg0:
3148 * @message: A #GDBusMessage.
3150 * Convenience to get the first item in the body of @message.
3152 * Returns: The string item or %NULL if the first item in the body of
3153 * @message is not a string.
3158 g_dbus_message_get_arg0 (GDBusMessage *message)
3162 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3166 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
3169 item = g_variant_get_child_value (message->body, 0);
3170 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
3171 ret = g_variant_get_string (item, NULL);
3172 g_variant_unref (item);
3178 /* ---------------------------------------------------------------------------------------------------- */
3181 * g_dbus_message_get_num_unix_fds:
3182 * @message: A #GDBusMessage.
3184 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3186 * Returns: The value.
3191 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
3193 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
3194 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
3198 * g_dbus_message_set_num_unix_fds:
3199 * @message: A #GDBusMessage.
3200 * @value: The value to set.
3202 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3207 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
3210 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3211 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
3214 /* ---------------------------------------------------------------------------------------------------- */
3217 * g_dbus_message_to_gerror:
3218 * @message: A #GDBusMessage.
3219 * @error: The #GError to set.
3221 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
3222 * nothing and returns %FALSE.
3224 * Otherwise this method encodes the error in @message as a #GError
3225 * using g_dbus_error_set_dbus_error() using the information in the
3226 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
3227 * well as the first string item in @message's body.
3229 * Returns: %TRUE if @error was set, %FALSE otherwise.
3234 g_dbus_message_to_gerror (GDBusMessage *message,
3238 const gchar *error_name;
3240 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3243 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
3246 error_name = g_dbus_message_get_error_name (message);
3247 if (error_name != NULL)
3251 body = g_dbus_message_get_body (message);
3253 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
3255 const gchar *error_message;
3256 g_variant_get (body, "(&s)", &error_message);
3257 g_dbus_error_set_dbus_error (error,
3264 /* these two situations are valid, yet pretty rare */
3267 g_dbus_error_set_dbus_error (error,
3270 _("Error return with body of type `%s'"),
3271 g_variant_get_type_string (body));
3275 g_dbus_error_set_dbus_error (error,
3278 _("Error return with empty body"));
3284 /* TOOD: this shouldn't happen - should check this at message serialization
3285 * time and disconnect the peer.
3290 "Error return without error-name header!");
3299 /* ---------------------------------------------------------------------------------------------------- */
3302 flags_to_string (GType flags_type, guint value)
3308 klass = g_type_class_ref (flags_type);
3309 s = g_string_new (NULL);
3310 for (n = 0; n < 32; n++)
3312 if ((value & (1<<n)) != 0)
3314 GFlagsValue *flags_value;
3315 flags_value = g_flags_get_first_value (klass, (1<<n));
3317 g_string_append_c (s, ',');
3318 if (flags_value != NULL)
3319 g_string_append (s, flags_value->value_nick);
3321 g_string_append_printf (s, "unknown (bit %d)", n);
3325 g_string_append (s, "none");
3326 g_type_class_unref (klass);
3327 return g_string_free (s, FALSE);
3331 _sort_keys_func (gconstpointer a,
3337 ia = GPOINTER_TO_INT (a);
3338 ib = GPOINTER_TO_INT (b);
3344 * g_dbus_message_print:
3345 * @message: A #GDBusMessage.
3346 * @indent: Indentation level.
3348 * Produces a human-readable multi-line description of @message.
3350 * The contents of the description has no ABI guarantees, the contents
3351 * and formatting is subject to change at any time. Typical output
3352 * looks something like this:
3354 * Type: method-call
3359 * path -> objectpath '/org/gtk/GDBus/TestObject'
3360 * interface -> 'org.gtk.GDBus.TestInterface'
3361 * member -> 'GimmeStdout'
3362 * destination -> ':1.146'
3364 * UNIX File Descriptors:
3369 * Type: method-return
3370 * Flags: no-reply-expected
3374 * reply-serial -> uint32 4
3375 * destination -> ':1.159'
3376 * sender -> ':1.146'
3377 * num-unix-fds -> uint32 1
3379 * UNIX File Descriptors:
3380 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3383 * Returns: A string that should be freed with g_free().
3388 g_dbus_message_print (GDBusMessage *message,
3396 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3398 str = g_string_new (NULL);
3400 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3401 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3403 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3404 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3406 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3407 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3409 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3410 keys = g_hash_table_get_keys (message->headers);
3411 keys = g_list_sort (keys, _sort_keys_func);
3414 for (l = keys; l != NULL; l = l->next)
3416 gint key = GPOINTER_TO_INT (l->data);
3420 value = g_hash_table_lookup (message->headers, l->data);
3421 g_assert (value != NULL);
3423 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3424 value_str = g_variant_print (value, TRUE);
3425 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3432 g_string_append_printf (str, "%*s (none)\n", indent, "");
3434 g_string_append_printf (str, "%*sBody: ", indent, "");
3435 if (message->body != NULL)
3437 g_variant_print_string (message->body,
3443 g_string_append (str, "()");
3445 g_string_append (str, "\n");
3447 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3448 if (message->fd_list != NULL)
3454 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3457 for (n = 0; n < num_fds; n++)
3460 struct stat statbuf;
3461 fs = g_string_new (NULL);
3462 if (fstat (fds[n], &statbuf) == 0)
3464 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3465 major (statbuf.st_dev), minor (statbuf.st_dev));
3466 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3468 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3469 (guint64) statbuf.st_ino);
3470 g_string_append_printf (fs, "%s" "uid=%d", fs->len > 0 ? "," : "",
3472 g_string_append_printf (fs, "%s" "gid=%d", fs->len > 0 ? "," : "",
3474 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3475 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3476 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3477 (guint64) statbuf.st_size);
3478 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3479 (guint64) statbuf.st_atime);
3480 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3481 (guint64) statbuf.st_mtime);
3482 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3483 (guint64) statbuf.st_ctime);
3487 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3489 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3490 g_string_free (fs, TRUE);
3495 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3500 g_string_append_printf (str, "%*s (none)\n", indent, "");
3504 return g_string_free (str, FALSE);
3508 * g_dbus_message_get_locked:
3509 * @message: A #GDBusMessage.
3511 * Checks whether @message is locked. To monitor changes to this
3512 * value, conncet to the #GObject::notify signal to listen for changes
3513 * on the #GDBusMessage:locked property.
3515 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3520 g_dbus_message_get_locked (GDBusMessage *message)
3522 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3523 return message->locked;
3527 * g_dbus_message_lock:
3528 * @message: A #GDBusMessage.
3530 * If @message is locked, does nothing. Otherwise locks the message.
3535 g_dbus_message_lock (GDBusMessage *message)
3537 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3539 if (message->locked)
3542 message->locked = TRUE;
3543 g_object_notify (G_OBJECT (message), "locked");
3550 * g_dbus_message_copy:
3551 * @message: A #GDBusMessage.
3552 * @error: Return location for error or %NULL.
3554 * Copies @message. The copy is a deep copy and the returned
3555 * #GDBusMessage is completely identical except that it is guaranteed
3558 * This operation can fail if e.g. @message contains file descriptors
3559 * and the per-process or system-wide open files limit is reached.
3561 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3562 * Free with g_object_unref().
3567 g_dbus_message_copy (GDBusMessage *message,
3571 GHashTableIter iter;
3572 gpointer header_key;
3573 GVariant *header_value;
3575 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3576 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3578 ret = g_dbus_message_new ();
3579 ret->type = message->type;
3580 ret->flags = message->flags;
3581 ret->byte_order = message->byte_order;
3582 ret->major_protocol_version = message->major_protocol_version;
3583 ret->serial = message->serial;
3586 if (message->fd_list != NULL)
3592 ret->fd_list = g_unix_fd_list_new ();
3593 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3594 for (n = 0; n < num_fds; n++)
3596 if (g_unix_fd_list_append (ret->fd_list,
3600 g_object_unref (ret);
3608 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3609 * to just ref (as opposed to deep-copying) the GVariant instances
3611 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3612 g_hash_table_iter_init (&iter, message->headers);
3613 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3614 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));