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>
37 #include <sys/mkdev.h>
38 #elif MAJOR_IN_SYSMACROS
39 #include <sys/sysmacros.h>
42 #include "gdbusutils.h"
43 #include "gdbusmessage.h"
44 #include "gdbuserror.h"
45 #include "gioenumtypes.h"
46 #include "ginputstream.h"
47 #include "gdatainputstream.h"
48 #include "gmemoryinputstream.h"
49 #include "goutputstream.h"
50 #include "gdataoutputstream.h"
51 #include "gmemoryoutputstream.h"
52 #include "gseekable.h"
54 #include "gdbusprivate.h"
57 #include "gunixfdlist.h"
62 typedef struct _GMemoryBuffer GMemoryBuffer;
69 GDataStreamByteOrder byte_order;
73 g_memory_buffer_read_byte (GMemoryBuffer *mbuf,
76 if (mbuf->pos >= mbuf->valid_len)
78 return mbuf->data [mbuf->pos++];
82 g_memory_buffer_read_int16 (GMemoryBuffer *mbuf,
87 if (mbuf->pos > mbuf->valid_len - 2)
89 mbuf->pos = mbuf->valid_len;
93 memcpy (&v, mbuf->data + mbuf->pos, 2);
95 switch (mbuf->byte_order)
97 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
98 v = GINT16_FROM_BE (v);
100 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
101 v = GINT16_FROM_LE (v);
103 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
111 g_memory_buffer_read_uint16 (GMemoryBuffer *mbuf,
116 if (mbuf->pos > mbuf->valid_len - 2)
118 mbuf->pos = mbuf->valid_len;
122 memcpy (&v, mbuf->data + mbuf->pos, 2);
124 switch (mbuf->byte_order)
126 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
127 v = GINT16_FROM_BE (v);
129 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
130 v = GINT16_FROM_LE (v);
132 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
140 g_memory_buffer_read_int32 (GMemoryBuffer *mbuf,
145 if (mbuf->pos > mbuf->valid_len - 4)
147 mbuf->pos = mbuf->valid_len;
151 memcpy (&v, mbuf->data + mbuf->pos, 4);
153 switch (mbuf->byte_order)
155 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
156 v = GINT32_FROM_BE (v);
158 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
159 v = GINT32_FROM_LE (v);
161 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
169 g_memory_buffer_read_uint32 (GMemoryBuffer *mbuf,
174 if (mbuf->pos > mbuf->valid_len - 4)
176 mbuf->pos = mbuf->valid_len;
180 memcpy (&v, mbuf->data + mbuf->pos, 4);
182 switch (mbuf->byte_order)
184 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
185 v = GUINT32_FROM_BE (v);
187 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
188 v = GUINT32_FROM_LE (v);
190 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
198 g_memory_buffer_read_int64 (GMemoryBuffer *mbuf,
203 if (mbuf->pos > mbuf->valid_len - 8)
205 mbuf->pos = mbuf->valid_len;
209 memcpy (&v, mbuf->data + mbuf->pos, 8);
211 switch (mbuf->byte_order)
213 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
214 v = GINT64_FROM_BE (v);
216 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
217 v = GINT64_FROM_LE (v);
219 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
227 g_memory_buffer_read_uint64 (GMemoryBuffer *mbuf,
232 if (mbuf->pos > mbuf->valid_len - 8)
234 mbuf->pos = mbuf->valid_len;
238 memcpy (&v, mbuf->data + mbuf->pos, 8);
240 switch (mbuf->byte_order)
242 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
243 v = GUINT64_FROM_BE (v);
245 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
246 v = GUINT64_FROM_LE (v);
248 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
255 #define MIN_ARRAY_SIZE 128
258 g_nearest_pow (gint num)
269 array_resize (GMemoryBuffer *mbuf,
275 if (mbuf->len == size)
279 data = g_realloc (mbuf->data, size);
282 memset ((guint8 *)data + len, 0, size - len);
287 if (mbuf->len < mbuf->valid_len)
288 mbuf->valid_len = mbuf->len;
292 g_memory_buffer_write (GMemoryBuffer *mbuf,
302 /* Check for address space overflow, but only if the buffer is resizable.
303 Otherwise we just do a short write and don't worry. */
304 if (mbuf->pos + count < mbuf->pos)
307 if (mbuf->pos + count > mbuf->len)
309 /* At least enought to fit the write, rounded up
310 for greater than linear growth.
311 TODO: This wastes a lot of memory at large buffer sizes.
312 Figure out a more rational allocation strategy. */
313 new_size = g_nearest_pow (mbuf->pos + count);
314 /* Check for overflow again. We have only checked if
315 pos + count > G_MAXSIZE, but it only catches the case of writing
316 more than 4GiB total on a 32-bit system. There's still the problem
317 of g_nearest_pow overflowing above 0x7fffffff, so we're
318 effectively limited to 2GiB. */
319 if (new_size < mbuf->len)
322 new_size = MAX (new_size, MIN_ARRAY_SIZE);
323 array_resize (mbuf, new_size);
326 dest = (guint8 *)mbuf->data + mbuf->pos;
327 memcpy (dest, buffer, count);
330 if (mbuf->pos > mbuf->valid_len)
331 mbuf->valid_len = mbuf->pos;
337 g_memory_buffer_put_byte (GMemoryBuffer *mbuf,
340 return g_memory_buffer_write (mbuf, &data, 1);
344 g_memory_buffer_put_int16 (GMemoryBuffer *mbuf,
347 switch (mbuf->byte_order)
349 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
350 data = GINT16_TO_BE (data);
352 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
353 data = GINT16_TO_LE (data);
355 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
360 return g_memory_buffer_write (mbuf, &data, 2);
364 g_memory_buffer_put_uint16 (GMemoryBuffer *mbuf,
367 switch (mbuf->byte_order)
369 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
370 data = GUINT16_TO_BE (data);
372 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
373 data = GUINT16_TO_LE (data);
375 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
380 return g_memory_buffer_write (mbuf, &data, 2);
384 g_memory_buffer_put_int32 (GMemoryBuffer *mbuf,
387 switch (mbuf->byte_order)
389 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
390 data = GINT32_TO_BE (data);
392 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
393 data = GINT32_TO_LE (data);
395 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
400 return g_memory_buffer_write (mbuf, &data, 4);
404 g_memory_buffer_put_uint32 (GMemoryBuffer *mbuf,
407 switch (mbuf->byte_order)
409 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
410 data = GUINT32_TO_BE (data);
412 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
413 data = GUINT32_TO_LE (data);
415 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
420 return g_memory_buffer_write (mbuf, &data, 4);
424 g_memory_buffer_put_int64 (GMemoryBuffer *mbuf,
427 switch (mbuf->byte_order)
429 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
430 data = GINT64_TO_BE (data);
432 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
433 data = GINT64_TO_LE (data);
435 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
440 return g_memory_buffer_write (mbuf, &data, 8);
444 g_memory_buffer_put_uint64 (GMemoryBuffer *mbuf,
447 switch (mbuf->byte_order)
449 case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN:
450 data = GUINT64_TO_BE (data);
452 case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN:
453 data = GUINT64_TO_LE (data);
455 case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN:
460 return g_memory_buffer_write (mbuf, &data, 8);
464 g_memory_buffer_put_string (GMemoryBuffer *mbuf,
467 g_return_val_if_fail (str != NULL, FALSE);
469 return g_memory_buffer_write (mbuf, str, strlen (str));
474 * SECTION:gdbusmessage
475 * @short_description: D-Bus Message
476 * @include: gio/gio.h
478 * A type for representing D-Bus messages that can be sent or received
479 * on a #GDBusConnection.
482 typedef struct _GDBusMessageClass GDBusMessageClass;
487 * Class structure for #GDBusMessage.
491 struct _GDBusMessageClass
494 GObjectClass parent_class;
500 * The #GDBusMessage structure contains only private data and should
501 * only be accessed using the provided API.
508 GObject parent_instance;
510 GDBusMessageType type;
511 GDBusMessageFlags flags;
513 GDBusMessageByteOrder byte_order;
514 guchar major_protocol_version;
519 GUnixFDList *fd_list;
529 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
532 g_dbus_message_finalize (GObject *object)
534 GDBusMessage *message = G_DBUS_MESSAGE (object);
536 if (message->headers != NULL)
537 g_hash_table_unref (message->headers);
538 if (message->body != NULL)
539 g_variant_unref (message->body);
541 if (message->fd_list != NULL)
542 g_object_unref (message->fd_list);
545 if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
546 G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
550 g_dbus_message_get_property (GObject *object,
555 GDBusMessage *message = G_DBUS_MESSAGE (object);
560 g_value_set_boolean (value, g_dbus_message_get_locked (message));
564 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
570 g_dbus_message_class_init (GDBusMessageClass *klass)
572 GObjectClass *gobject_class;
574 gobject_class = G_OBJECT_CLASS (klass);
575 gobject_class->finalize = g_dbus_message_finalize;
576 gobject_class->get_property = g_dbus_message_get_property;
579 * GDBusConnection:locked:
581 * A boolean specifying whether the message is locked.
585 g_object_class_install_property (gobject_class,
587 g_param_spec_boolean ("locked",
589 P_("Whether the message is locked"),
592 G_PARAM_STATIC_NAME |
593 G_PARAM_STATIC_BLURB |
594 G_PARAM_STATIC_NICK));
598 g_dbus_message_init (GDBusMessage *message)
600 /* Any D-Bus implementation is supposed to handle both Big and
601 * Little Endian encodings and the Endianness is part of the D-Bus
602 * message - we prefer to use Big Endian (since it's Network Byte
603 * Order and just easier to read for humans) but if the machine is
604 * Little Endian we use that for performance reasons.
606 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
607 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
609 /* this could also be G_PDP_ENDIAN */
610 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
612 message->headers = g_hash_table_new_full (g_direct_hash,
615 (GDestroyNotify) g_variant_unref);
619 * g_dbus_message_new:
621 * Creates a new empty #GDBusMessage.
623 * Returns: A #GDBusMessage. Free with g_object_unref().
628 g_dbus_message_new (void)
630 return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
634 * g_dbus_message_new_method_call:
635 * @name: (allow-none): A valid D-Bus name or %NULL.
636 * @path: A valid object path.
637 * @interface_: (allow-none): A valid D-Bus interface name or %NULL.
638 * @method: A valid method name.
640 * Creates a new #GDBusMessage for a method call.
642 * Returns: A #GDBusMessage. Free with g_object_unref().
647 g_dbus_message_new_method_call (const gchar *name,
649 const gchar *interface_,
652 GDBusMessage *message;
654 g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
655 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
656 g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
657 g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
659 message = g_dbus_message_new ();
660 message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
663 g_dbus_message_set_destination (message, name);
664 g_dbus_message_set_path (message, path);
665 g_dbus_message_set_member (message, method);
666 if (interface_ != NULL)
667 g_dbus_message_set_interface (message, interface_);
673 * g_dbus_message_new_signal:
674 * @path: A valid object path.
675 * @interface_: A valid D-Bus interface name.
676 * @signal: A valid signal name.
678 * Creates a new #GDBusMessage for a signal emission.
680 * Returns: A #GDBusMessage. Free with g_object_unref().
685 g_dbus_message_new_signal (const gchar *path,
686 const gchar *interface_,
689 GDBusMessage *message;
691 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
692 g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
693 g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
695 message = g_dbus_message_new ();
696 message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
697 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
699 g_dbus_message_set_path (message, path);
700 g_dbus_message_set_member (message, signal);
701 g_dbus_message_set_interface (message, interface_);
708 * g_dbus_message_new_method_reply:
709 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
710 * create a reply message to.
712 * Creates a new #GDBusMessage that is a reply to @method_call_message.
714 * Returns: (transfer full): #GDBusMessage. Free with g_object_unref().
719 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
721 GDBusMessage *message;
724 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
725 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
726 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
728 message = g_dbus_message_new ();
729 message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
730 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
731 /* reply with same endianness */
732 message->byte_order = method_call_message->byte_order;
734 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
735 sender = g_dbus_message_get_sender (method_call_message);
737 g_dbus_message_set_destination (message, sender);
743 * g_dbus_message_new_method_error:
744 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
745 * create a reply message to.
746 * @error_name: A valid D-Bus error name.
747 * @error_message_format: The D-Bus error message in a printf() format.
748 * @...: Arguments for @error_message_format.
750 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
752 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
757 g_dbus_message_new_method_error (GDBusMessage *method_call_message,
758 const gchar *error_name,
759 const gchar *error_message_format,
765 va_start (var_args, error_message_format);
766 ret = g_dbus_message_new_method_error_valist (method_call_message,
768 error_message_format,
776 * g_dbus_message_new_method_error_literal:
777 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
778 * create a reply message to.
779 * @error_name: A valid D-Bus error name.
780 * @error_message: The D-Bus error message.
782 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
784 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
789 g_dbus_message_new_method_error_literal (GDBusMessage *method_call_message,
790 const gchar *error_name,
791 const gchar *error_message)
793 GDBusMessage *message;
796 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
797 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
798 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
799 g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
800 g_return_val_if_fail (error_message != NULL, NULL);
802 message = g_dbus_message_new ();
803 message->type = G_DBUS_MESSAGE_TYPE_ERROR;
804 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
805 /* reply with same endianness */
806 message->byte_order = method_call_message->byte_order;
808 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
809 g_dbus_message_set_error_name (message, error_name);
810 g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
812 sender = g_dbus_message_get_sender (method_call_message);
814 g_dbus_message_set_destination (message, sender);
820 * g_dbus_message_new_method_error_valist:
821 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
822 * create a reply message to.
823 * @error_name: A valid D-Bus error name.
824 * @error_message_format: The D-Bus error message in a printf() format.
825 * @var_args: Arguments for @error_message_format.
827 * Like g_dbus_message_new_method_error() but intended for language bindings.
829 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
835 g_dbus_message_new_method_error_valist (GDBusMessage *method_call_message,
836 const gchar *error_name,
837 const gchar *error_message_format,
841 gchar *error_message;
842 error_message = g_strdup_vprintf (error_message_format, var_args);
843 ret = g_dbus_message_new_method_error_literal (method_call_message,
846 g_free (error_message);
850 /* ---------------------------------------------------------------------------------------------------- */
853 * g_dbus_message_get_byte_order:
854 * @message: A #GDBusMessage.
856 * Gets the byte order of @message.
858 * Returns: The byte order.
860 GDBusMessageByteOrder
861 g_dbus_message_get_byte_order (GDBusMessage *message)
863 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
864 return message->byte_order;
868 * g_dbus_message_set_byte_order:
869 * @message: A #GDBusMessage.
870 * @byte_order: The byte order.
872 * Sets the byte order of @message.
875 g_dbus_message_set_byte_order (GDBusMessage *message,
876 GDBusMessageByteOrder byte_order)
878 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
882 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
886 message->byte_order = byte_order;
889 /* ---------------------------------------------------------------------------------------------------- */
891 /* TODO: need GI annotations to specify that any guchar value goes for the type */
894 * g_dbus_message_get_message_type:
895 * @message: A #GDBusMessage.
897 * Gets the type of @message.
899 * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
904 g_dbus_message_get_message_type (GDBusMessage *message)
906 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
907 return message->type;
911 * g_dbus_message_set_message_type:
912 * @message: A #GDBusMessage.
913 * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
915 * Sets @message to be of @type.
920 g_dbus_message_set_message_type (GDBusMessage *message,
921 GDBusMessageType type)
923 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
924 g_return_if_fail (type >=0 && type < 256);
928 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
932 message->type = type;
935 /* ---------------------------------------------------------------------------------------------------- */
937 /* TODO: need GI annotations to specify that any guchar value goes for flags */
940 * g_dbus_message_get_flags:
941 * @message: A #GDBusMessage.
943 * Gets the flags for @message.
945 * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
950 g_dbus_message_get_flags (GDBusMessage *message)
952 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
953 return message->flags;
957 * g_dbus_message_set_flags:
958 * @message: A #GDBusMessage.
959 * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
960 * enumeration bitwise ORed together).
962 * Sets the flags to set on @message.
967 g_dbus_message_set_flags (GDBusMessage *message,
968 GDBusMessageFlags flags)
970 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
971 g_return_if_fail (flags >=0 && flags < 256);
975 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
979 message->flags = flags;
982 /* ---------------------------------------------------------------------------------------------------- */
985 * g_dbus_message_get_serial:
986 * @message: A #GDBusMessage.
988 * Gets the serial for @message.
990 * Returns: A #guint32.
995 g_dbus_message_get_serial (GDBusMessage *message)
997 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
998 return message->serial;
1002 * g_dbus_message_set_serial:
1003 * @message: A #GDBusMessage.
1004 * @serial: A #guint32.
1006 * Sets the serial for @message.
1011 g_dbus_message_set_serial (GDBusMessage *message,
1014 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1016 if (message->locked)
1018 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1022 message->serial = serial;
1025 /* ---------------------------------------------------------------------------------------------------- */
1027 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
1030 * g_dbus_message_get_header:
1031 * @message: A #GDBusMessage.
1032 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1034 * Gets a header field on @message.
1036 * Returns: A #GVariant with the value if the header was found, %NULL
1037 * otherwise. Do not free, it is owned by @message.
1042 g_dbus_message_get_header (GDBusMessage *message,
1043 GDBusMessageHeaderField header_field)
1045 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1046 g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
1047 return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
1051 * g_dbus_message_set_header:
1052 * @message: A #GDBusMessage.
1053 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
1054 * @value: (allow-none): A #GVariant to set the header field or %NULL to clear the header field.
1056 * Sets a header field on @message.
1058 * If @value is floating, @message assumes ownership of @value.
1063 g_dbus_message_set_header (GDBusMessage *message,
1064 GDBusMessageHeaderField header_field,
1067 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1068 g_return_if_fail (header_field >=0 && header_field < 256);
1070 if (message->locked)
1072 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1078 g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
1082 g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
1087 * g_dbus_message_get_header_fields:
1088 * @message: A #GDBusMessage.
1090 * Gets an array of all header fields on @message that are set.
1092 * Returns: (array zero-terminated=1): An array of header fields
1093 * terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element
1094 * is a #guchar. Free with g_free().
1099 g_dbus_message_get_header_fields (GDBusMessage *message)
1107 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1109 keys = g_hash_table_get_keys (message->headers);
1110 num_keys = g_list_length (keys);
1111 ret = g_new (guchar, num_keys + 1);
1112 for (l = keys, n = 0; l != NULL; l = l->next, n++)
1113 ret[n] = GPOINTER_TO_UINT (l->data);
1114 g_assert (n == num_keys);
1115 ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
1121 /* ---------------------------------------------------------------------------------------------------- */
1124 * g_dbus_message_get_body:
1125 * @message: A #GDBusMessage.
1127 * Gets the body of a message.
1129 * Returns: A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
1134 g_dbus_message_get_body (GDBusMessage *message)
1136 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1137 return message->body;
1141 * g_dbus_message_set_body:
1142 * @message: A #GDBusMessage.
1143 * @body: Either %NULL or a #GVariant that is a tuple.
1145 * Sets the body @message. As a side-effect the
1146 * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
1147 * type string of @body (or cleared if @body is %NULL).
1149 * If @body is floating, @message assumes ownership of @body.
1154 g_dbus_message_set_body (GDBusMessage *message,
1157 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1158 g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
1160 if (message->locked)
1162 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1166 if (message->body != NULL)
1167 g_variant_unref (message->body);
1170 message->body = NULL;
1171 g_dbus_message_set_signature (message, NULL);
1175 const gchar *type_string;
1176 gsize type_string_len;
1179 message->body = g_variant_ref_sink (body);
1181 type_string = g_variant_get_type_string (body);
1182 type_string_len = strlen (type_string);
1183 g_assert (type_string_len >= 2);
1184 signature = g_strndup (type_string + 1, type_string_len - 2);
1185 g_dbus_message_set_signature (message, signature);
1190 /* ---------------------------------------------------------------------------------------------------- */
1194 * g_dbus_message_get_unix_fd_list:
1195 * @message: A #GDBusMessage.
1197 * Gets the UNIX file descriptors associated with @message, if any.
1199 * This method is only available on UNIX.
1201 * Returns: (transfer none):A #GUnixFDList or %NULL if no file descriptors are
1202 * associated. Do not free, this object is owned by @message.
1207 g_dbus_message_get_unix_fd_list (GDBusMessage *message)
1209 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
1210 return message->fd_list;
1214 * g_dbus_message_set_unix_fd_list:
1215 * @message: A #GDBusMessage.
1216 * @fd_list: (allow-none): A #GUnixFDList or %NULL.
1218 * Sets the UNIX file descriptors associated with @message. As a
1219 * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
1220 * field is set to the number of fds in @fd_list (or cleared if
1221 * @fd_list is %NULL).
1223 * This method is only available on UNIX.
1228 g_dbus_message_set_unix_fd_list (GDBusMessage *message,
1229 GUnixFDList *fd_list)
1231 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
1232 g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
1234 if (message->locked)
1236 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
1240 if (message->fd_list != NULL)
1241 g_object_unref (message->fd_list);
1242 if (fd_list != NULL)
1244 message->fd_list = g_object_ref (fd_list);
1245 g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
1249 message->fd_list = NULL;
1250 g_dbus_message_set_num_unix_fds (message, 0);
1255 /* ---------------------------------------------------------------------------------------------------- */
1258 validate_headers (GDBusMessage *message,
1263 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
1264 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1268 switch (message->type)
1270 case G_DBUS_MESSAGE_TYPE_INVALID:
1271 g_set_error_literal (error,
1273 G_IO_ERROR_INVALID_ARGUMENT,
1274 _("type is INVALID"));
1278 case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
1279 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1280 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1282 g_set_error_literal (error,
1284 G_IO_ERROR_INVALID_ARGUMENT,
1285 _("METHOD_CALL message: PATH or MEMBER header field is missing"));
1290 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
1291 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1293 g_set_error_literal (error,
1295 G_IO_ERROR_INVALID_ARGUMENT,
1296 _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
1301 case G_DBUS_MESSAGE_TYPE_ERROR:
1302 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
1303 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
1305 g_set_error_literal (error,
1307 G_IO_ERROR_INVALID_ARGUMENT,
1308 _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
1313 case G_DBUS_MESSAGE_TYPE_SIGNAL:
1314 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
1315 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
1316 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
1318 g_set_error_literal (error,
1320 G_IO_ERROR_INVALID_ARGUMENT,
1321 _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
1324 if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
1326 g_set_error_literal (error,
1328 G_IO_ERROR_INVALID_ARGUMENT,
1329 _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
1332 if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
1334 g_set_error_literal (error,
1336 G_IO_ERROR_INVALID_ARGUMENT,
1337 _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
1343 /* hitherto unknown type - nothing to check */
1350 g_assert (ret || (error == NULL || *error != NULL));
1354 /* ---------------------------------------------------------------------------------------------------- */
1357 ensure_input_padding (GMemoryBuffer *buf,
1362 gsize wanted_offset;
1365 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1366 buf->pos = wanted_offset;
1370 static const gchar *
1371 read_string (GMemoryBuffer *mbuf,
1376 const gchar *end_valid;
1378 if (mbuf->pos + len >= mbuf->valid_len || mbuf->pos + len < mbuf->pos)
1380 mbuf->pos = mbuf->valid_len;
1381 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
1384 G_IO_ERROR_INVALID_ARGUMENT,
1385 g_dngettext (GETTEXT_PACKAGE,
1386 "Wanted to read %lu byte but only got %lu",
1387 "Wanted to read %lu bytes but only got %lu",
1390 (gulong)(mbuf->valid_len - mbuf->pos));
1391 mbuf->pos = mbuf->valid_len;
1395 if (mbuf->data[mbuf->pos + len] != '\0')
1397 str = g_strndup (mbuf->data + mbuf->pos, len);
1400 G_IO_ERROR_INVALID_ARGUMENT,
1401 _("Expected NUL byte after the string '%s' but found byte %d"),
1402 str, mbuf->data[mbuf->pos + len]);
1404 mbuf->pos += len + 1;
1408 str = mbuf->data + mbuf->pos;
1409 mbuf->pos += len + 1;
1411 if (!g_utf8_validate (str, -1, &end_valid))
1415 offset = (gint) (end_valid - str);
1416 valid_str = g_strndup (str, offset);
1419 G_IO_ERROR_INVALID_ARGUMENT,
1420 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1421 "The valid UTF-8 string up until that point was '%s'"),
1432 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1434 /* returns a non-floating GVariant! */
1436 parse_value_from_blob (GMemoryBuffer *buf,
1437 const GVariantType *type,
1438 gboolean just_align,
1443 GError *local_error;
1445 const gchar *type_string;
1447 type_string = g_variant_type_peek_string (type);
1449 #ifdef DEBUG_SERIALIZER
1452 s = g_variant_type_dup_string (type);
1453 g_print ("%*s%s type %s from offset 0x%04x",
1455 just_align ? "Aligning" : "Reading",
1457 (gint) g_seekable_tell (G_SEEKABLE (buf)));
1460 #endif /* DEBUG_SERIALIZER */
1466 switch (type_string[0])
1468 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1469 if (!ensure_input_padding (buf, 4, &local_error))
1474 v = g_memory_buffer_read_uint32 (buf, &local_error);
1475 if (local_error != NULL)
1477 ret = g_variant_new_boolean (v);
1481 case 'y': /* G_VARIANT_TYPE_BYTE */
1485 v = g_memory_buffer_read_byte (buf, &local_error);
1486 if (local_error != NULL)
1488 ret = g_variant_new_byte (v);
1492 case 'n': /* G_VARIANT_TYPE_INT16 */
1493 if (!ensure_input_padding (buf, 2, &local_error))
1498 v = g_memory_buffer_read_int16 (buf, &local_error);
1499 if (local_error != NULL)
1501 ret = g_variant_new_int16 (v);
1505 case 'q': /* G_VARIANT_TYPE_UINT16 */
1506 if (!ensure_input_padding (buf, 2, &local_error))
1511 v = g_memory_buffer_read_uint16 (buf, &local_error);
1512 if (local_error != NULL)
1514 ret = g_variant_new_uint16 (v);
1518 case 'i': /* G_VARIANT_TYPE_INT32 */
1519 if (!ensure_input_padding (buf, 4, &local_error))
1524 v = g_memory_buffer_read_int32 (buf, &local_error);
1525 if (local_error != NULL)
1527 ret = g_variant_new_int32 (v);
1531 case 'u': /* G_VARIANT_TYPE_UINT32 */
1532 if (!ensure_input_padding (buf, 4, &local_error))
1537 v = g_memory_buffer_read_uint32 (buf, &local_error);
1538 if (local_error != NULL)
1540 ret = g_variant_new_uint32 (v);
1544 case 'x': /* G_VARIANT_TYPE_INT64 */
1545 if (!ensure_input_padding (buf, 8, &local_error))
1550 v = g_memory_buffer_read_int64 (buf, &local_error);
1551 if (local_error != NULL)
1553 ret = g_variant_new_int64 (v);
1557 case 't': /* G_VARIANT_TYPE_UINT64 */
1558 if (!ensure_input_padding (buf, 8, &local_error))
1563 v = g_memory_buffer_read_uint64 (buf, &local_error);
1564 if (local_error != NULL)
1566 ret = g_variant_new_uint64 (v);
1570 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1571 if (!ensure_input_padding (buf, 8, &local_error))
1579 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1580 u.v_uint64 = g_memory_buffer_read_uint64 (buf, &local_error);
1581 if (local_error != NULL)
1583 ret = g_variant_new_double (u.v_double);
1587 case 's': /* G_VARIANT_TYPE_STRING */
1588 if (!ensure_input_padding (buf, 4, &local_error))
1594 len = g_memory_buffer_read_uint32 (buf, &local_error);
1595 if (local_error != NULL)
1597 v = read_string (buf, (gsize) len, &local_error);
1600 ret = g_variant_new_string (v);
1604 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1605 if (!ensure_input_padding (buf, 4, &local_error))
1611 len = g_memory_buffer_read_uint32 (buf, &local_error);
1612 if (local_error != NULL)
1614 v = read_string (buf, (gsize) len, &local_error);
1617 if (!g_variant_is_object_path (v))
1619 g_set_error (&local_error,
1621 G_IO_ERROR_INVALID_ARGUMENT,
1622 _("Parsed value '%s' is not a valid D-Bus object path"),
1626 ret = g_variant_new_object_path (v);
1630 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
1635 len = g_memory_buffer_read_byte (buf, &local_error);
1636 if (local_error != NULL)
1638 v = read_string (buf, (gsize) len, &local_error);
1641 if (!g_variant_is_signature (v))
1643 g_set_error (&local_error,
1645 G_IO_ERROR_INVALID_ARGUMENT,
1646 _("Parsed value '%s' is not a valid D-Bus signature"),
1650 ret = g_variant_new_signature (v);
1654 case 'h': /* G_VARIANT_TYPE_HANDLE */
1655 if (!ensure_input_padding (buf, 4, &local_error))
1660 v = g_memory_buffer_read_int32 (buf, &local_error);
1661 if (local_error != NULL)
1663 ret = g_variant_new_handle (v);
1667 case 'a': /* G_VARIANT_TYPE_ARRAY */
1668 if (!ensure_input_padding (buf, 4, &local_error))
1671 /* If we are only aligning for this array type, it is the child type of
1672 * another array, which is empty. So, we do not need to add padding for
1673 * this nonexistent array's elements: we only need to align for this
1674 * array itself (4 bytes). See
1675 * <https://bugzilla.gnome.org/show_bug.cgi?id=673612>.
1682 const GVariantType *element_type;
1683 GVariantBuilder builder;
1685 array_len = g_memory_buffer_read_uint32 (buf, &local_error);
1686 if (local_error != NULL)
1690 #ifdef DEBUG_SERIALIZER
1691 g_print (": array spans 0x%04x bytes\n", array_len);
1692 #endif /* DEBUG_SERIALIZER */
1694 if (array_len > (2<<26))
1696 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1697 g_set_error (&local_error,
1699 G_IO_ERROR_INVALID_ARGUMENT,
1700 g_dngettext (GETTEXT_PACKAGE,
1701 "Encountered array of length %u byte. Maximum length is 2<<26 bytes (64 MiB).",
1702 "Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB).",
1708 g_variant_builder_init (&builder, type);
1709 element_type = g_variant_type_element (type);
1714 item = parse_value_from_blob (buf,
1719 g_assert (item == NULL);
1723 /* TODO: optimize array of primitive types */
1725 target = offset + array_len;
1726 while (offset < target)
1729 item = parse_value_from_blob (buf,
1736 g_variant_builder_clear (&builder);
1739 g_variant_builder_add_value (&builder, item);
1740 g_variant_unref (item);
1745 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 if (!ensure_input_padding (buf, 8, &local_error))
1761 #ifdef DEBUG_SERIALIZER
1763 #endif /* DEBUG_SERIALIZER */
1767 key_type = g_variant_type_key (type);
1768 key = parse_value_from_blob (buf,
1775 value_type = g_variant_type_value (type);
1776 value = parse_value_from_blob (buf,
1783 g_variant_unref (key);
1786 ret = g_variant_new_dict_entry (key, value);
1787 g_variant_unref (key);
1788 g_variant_unref (value);
1791 else if (g_variant_type_is_tuple (type))
1793 if (!ensure_input_padding (buf, 8, &local_error))
1797 #ifdef DEBUG_SERIALIZER
1799 #endif /* DEBUG_SERIALIZER */
1803 const GVariantType *element_type;
1804 GVariantBuilder builder;
1806 g_variant_builder_init (&builder, type);
1807 element_type = g_variant_type_first (type);
1808 while (element_type != NULL)
1811 item = parse_value_from_blob (buf,
1818 g_variant_builder_clear (&builder);
1821 g_variant_builder_add_value (&builder, item);
1822 g_variant_unref (item);
1824 element_type = g_variant_type_next (element_type);
1826 ret = g_variant_builder_end (&builder);
1829 else if (g_variant_type_is_variant (type))
1832 #ifdef DEBUG_SERIALIZER
1834 #endif /* DEBUG_SERIALIZER */
1840 GVariantType *variant_type;
1843 siglen = g_memory_buffer_read_byte (buf, &local_error);
1844 if (local_error != NULL)
1846 sig = read_string (buf, (gsize) siglen, &local_error);
1849 if (!g_variant_is_signature (sig))
1851 g_set_error (&local_error,
1853 G_IO_ERROR_INVALID_ARGUMENT,
1854 _("Parsed value '%s' for variant is not a valid D-Bus signature"),
1858 variant_type = g_variant_type_new (sig);
1859 value = parse_value_from_blob (buf,
1864 g_variant_type_free (variant_type);
1867 ret = g_variant_new_variant (value);
1868 g_variant_unref (value);
1874 s = g_variant_type_dup_string (type);
1875 g_set_error (&local_error,
1877 G_IO_ERROR_INVALID_ARGUMENT,
1878 _("Error deserializing GVariant with type string '%s' from the D-Bus wire format"),
1886 g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1888 #ifdef DEBUG_SERIALIZER
1894 if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1896 s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1900 s = g_variant_print (ret, FALSE);
1902 g_print (": %s\n", s);
1907 is_leaf = is_leaf; /* To avoid -Wunused-but-set-variable */
1908 #endif /* DEBUG_SERIALIZER */
1910 /* sink the reference */
1913 g_assert (g_variant_is_floating (ret));
1914 g_variant_ref_sink (ret);
1919 #ifdef DEBUG_SERIALIZER
1921 "%*sFAILURE: %s (%s, %d)\n",
1923 local_error->message,
1924 g_quark_to_string (local_error->domain),
1926 #endif /* DEBUG_SERIALIZER */
1927 g_propagate_error (error, local_error);
1931 /* ---------------------------------------------------------------------------------------------------- */
1933 /* message_header must be at least 16 bytes */
1936 * g_dbus_message_bytes_needed:
1937 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
1938 * @blob_len: The length of @blob (must be at least 16).
1939 * @error: Return location for error or %NULL.
1941 * Utility function to calculate how many bytes are needed to
1942 * completely deserialize the D-Bus message stored at @blob.
1944 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1945 * @blob contains invalid data or not enough data is available to
1946 * determine the size).
1951 g_dbus_message_bytes_needed (guchar *blob,
1959 g_return_val_if_fail (blob != NULL, -1);
1960 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1961 g_return_val_if_fail (blob_len >= 16, -1);
1965 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1966 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1967 /* round up so it's a multiple of 8 */
1968 ret = 8 * ((ret + 7)/8);
1969 /* finally add the body size */
1970 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1972 else if (blob[0] == 'B')
1974 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1975 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1976 /* round up so it's a multiple of 8 */
1977 ret = 8 * ((ret + 7)/8);
1978 /* finally add the body size */
1979 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1985 G_IO_ERROR_INVALID_ARGUMENT,
1986 "Unable to determine message blob length - given blob is malformed");
1993 G_IO_ERROR_INVALID_ARGUMENT,
1994 "Blob indicates that message exceeds maximum message length (128MiB)");
2001 /* ---------------------------------------------------------------------------------------------------- */
2004 * g_dbus_message_new_from_blob:
2005 * @blob: (array length=blob_len) (element-type guint8): A blob represent a binary D-Bus message.
2006 * @blob_len: The length of @blob.
2007 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2008 * @error: Return location for error or %NULL.
2010 * Creates a new #GDBusMessage from the data stored at @blob. The byte
2011 * order that the message was in can be retrieved using
2012 * g_dbus_message_get_byte_order().
2014 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
2020 g_dbus_message_new_from_blob (guchar *blob,
2022 GDBusCapabilityFlags capabilities,
2027 GDBusMessage *message;
2029 guchar major_protocol_version;
2030 guint32 message_body_len;
2034 GVariant *signature;
2036 /* TODO: check against @capabilities */
2040 g_return_val_if_fail (blob != NULL, NULL);
2041 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2042 g_return_val_if_fail (blob_len >= 12, NULL);
2044 message = g_dbus_message_new ();
2046 memset (&mbuf, 0, sizeof (mbuf));
2047 mbuf.data = (gchar *)blob;
2048 mbuf.len = mbuf.valid_len = blob_len;
2050 endianness = g_memory_buffer_read_byte (&mbuf, NULL);
2054 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2055 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
2058 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2059 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
2064 G_IO_ERROR_INVALID_ARGUMENT,
2065 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
2070 message->type = g_memory_buffer_read_byte (&mbuf, NULL);
2071 message->flags = g_memory_buffer_read_byte (&mbuf, NULL);
2072 major_protocol_version = g_memory_buffer_read_byte (&mbuf, NULL);
2073 if (major_protocol_version != 1)
2077 G_IO_ERROR_INVALID_ARGUMENT,
2078 _("Invalid major protocol version. Expected 1 but found %d"),
2079 major_protocol_version);
2082 message_body_len = g_memory_buffer_read_uint32 (&mbuf, NULL);
2083 message->serial = g_memory_buffer_read_uint32 (&mbuf, NULL);
2085 #ifdef DEBUG_SERIALIZER
2086 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2089 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
2090 g_print ("%s\n", s);
2093 #endif /* DEBUG_SERIALIZER */
2095 #ifdef DEBUG_SERIALIZER
2096 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2097 #endif /* DEBUG_SERIALIZER */
2098 headers = parse_value_from_blob (&mbuf,
2099 G_VARIANT_TYPE ("a{yv}"),
2103 if (headers == NULL)
2105 g_variant_iter_init (&iter, headers);
2106 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2108 guchar header_field;
2110 g_variant_get (item,
2114 g_dbus_message_set_header (message, header_field, value);
2115 g_variant_unref (value);
2116 g_variant_unref (item);
2118 g_variant_unref (headers);
2120 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2121 if (signature != NULL)
2123 const gchar *signature_str;
2124 gsize signature_str_len;
2126 signature_str = g_variant_get_string (signature, &signature_str_len);
2128 /* signature but no body */
2129 if (message_body_len == 0 && signature_str_len > 0)
2133 G_IO_ERROR_INVALID_ARGUMENT,
2134 _("Signature header with signature '%s' found but message body is empty"),
2138 else if (signature_str_len > 0)
2140 GVariantType *variant_type;
2141 gchar *tupled_signature_str;
2143 if (!g_variant_is_signature (signature_str))
2147 G_IO_ERROR_INVALID_ARGUMENT,
2148 _("Parsed value '%s' is not a valid D-Bus signature (for body)"),
2152 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2153 variant_type = g_variant_type_new (tupled_signature_str);
2154 g_free (tupled_signature_str);
2155 #ifdef DEBUG_SERIALIZER
2156 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
2157 #endif /* DEBUG_SERIALIZER */
2158 message->body = parse_value_from_blob (&mbuf,
2163 g_variant_type_free (variant_type);
2164 if (message->body == NULL)
2170 /* no signature, this is only OK if the body is empty */
2171 if (message_body_len != 0)
2173 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
2176 G_IO_ERROR_INVALID_ARGUMENT,
2177 g_dngettext (GETTEXT_PACKAGE,
2178 "No signature header in message but the message body is %u byte",
2179 "No signature header in message but the message body is %u bytes",
2186 if (!validate_headers (message, error))
2188 g_prefix_error (error, _("Cannot deserialize message: "));
2201 if (message != NULL)
2202 g_object_unref (message);
2207 /* ---------------------------------------------------------------------------------------------------- */
2210 ensure_output_padding (GMemoryBuffer *mbuf,
2214 gsize wanted_offset;
2215 gsize padding_needed;
2219 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
2220 padding_needed = wanted_offset - offset;
2222 for (n = 0; n < padding_needed; n++)
2223 g_memory_buffer_put_byte (mbuf, '\0');
2225 return padding_needed;
2228 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
2230 append_value_to_blob (GVariant *value,
2231 const GVariantType *type,
2232 GMemoryBuffer *mbuf,
2233 gsize *out_padding_added,
2236 gsize padding_added;
2237 const gchar *type_string;
2239 type_string = g_variant_type_peek_string (type);
2243 switch (type_string[0])
2245 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
2246 padding_added = ensure_output_padding (mbuf, 4);
2249 gboolean v = g_variant_get_boolean (value);
2250 g_memory_buffer_put_uint32 (mbuf, v);
2254 case 'y': /* G_VARIANT_TYPE_BYTE */
2257 guint8 v = g_variant_get_byte (value);
2258 g_memory_buffer_put_byte (mbuf, v);
2262 case 'n': /* G_VARIANT_TYPE_INT16 */
2263 padding_added = ensure_output_padding (mbuf, 2);
2266 gint16 v = g_variant_get_int16 (value);
2267 g_memory_buffer_put_int16 (mbuf, v);
2271 case 'q': /* G_VARIANT_TYPE_UINT16 */
2272 padding_added = ensure_output_padding (mbuf, 2);
2275 guint16 v = g_variant_get_uint16 (value);
2276 g_memory_buffer_put_uint16 (mbuf, v);
2280 case 'i': /* G_VARIANT_TYPE_INT32 */
2281 padding_added = ensure_output_padding (mbuf, 4);
2284 gint32 v = g_variant_get_int32 (value);
2285 g_memory_buffer_put_int32 (mbuf, v);
2289 case 'u': /* G_VARIANT_TYPE_UINT32 */
2290 padding_added = ensure_output_padding (mbuf, 4);
2293 guint32 v = g_variant_get_uint32 (value);
2294 g_memory_buffer_put_uint32 (mbuf, v);
2298 case 'x': /* G_VARIANT_TYPE_INT64 */
2299 padding_added = ensure_output_padding (mbuf, 8);
2302 gint64 v = g_variant_get_int64 (value);
2303 g_memory_buffer_put_int64 (mbuf, v);
2307 case 't': /* G_VARIANT_TYPE_UINT64 */
2308 padding_added = ensure_output_padding (mbuf, 8);
2311 guint64 v = g_variant_get_uint64 (value);
2312 g_memory_buffer_put_uint64 (mbuf, v);
2316 case 'd': /* G_VARIANT_TYPE_DOUBLE */
2317 padding_added = ensure_output_padding (mbuf, 8);
2324 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
2325 u.v_double = g_variant_get_double (value);
2326 g_memory_buffer_put_uint64 (mbuf, u.v_uint64);
2330 case 's': /* G_VARIANT_TYPE_STRING */
2331 padding_added = ensure_output_padding (mbuf, 4);
2337 v = g_variant_get_string (value, &len);
2338 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
2339 g_memory_buffer_put_uint32 (mbuf, len);
2340 g_memory_buffer_put_string (mbuf, v);
2341 g_memory_buffer_put_byte (mbuf, '\0');
2345 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
2346 padding_added = ensure_output_padding (mbuf, 4);
2350 const gchar *v = g_variant_get_string (value, &len);
2351 g_assert (g_variant_is_object_path (v));
2352 g_memory_buffer_put_uint32 (mbuf, len);
2353 g_memory_buffer_put_string (mbuf, v);
2354 g_memory_buffer_put_byte (mbuf, '\0');
2358 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
2362 const gchar *v = g_variant_get_string (value, &len);
2363 g_assert (g_variant_is_signature (v));
2364 g_memory_buffer_put_byte (mbuf, len);
2365 g_memory_buffer_put_string (mbuf, v);
2366 g_memory_buffer_put_byte (mbuf, '\0');
2370 case 'h': /* G_VARIANT_TYPE_HANDLE */
2371 padding_added = ensure_output_padding (mbuf, 4);
2374 gint32 v = g_variant_get_handle (value);
2375 g_memory_buffer_put_int32 (mbuf, v);
2379 case 'a': /* G_VARIANT_TYPE_ARRAY */
2383 goffset array_len_offset;
2384 goffset array_payload_begin_offset;
2388 padding_added = ensure_output_padding (mbuf, 4);
2391 /* array length - will be filled in later */
2392 array_len_offset = mbuf->valid_len;
2393 g_memory_buffer_put_uint32 (mbuf, 0xF00DFACE);
2395 /* From the D-Bus spec:
2397 * "A UINT32 giving the length of the array data in bytes,
2398 * followed by alignment padding to the alignment boundary of
2399 * the array element type, followed by each array element. The
2400 * array length is from the end of the alignment padding to
2401 * the end of the last element, i.e. it does not include the
2402 * padding after the length, or any padding after the last
2405 * Thus, we need to count how much padding the first element
2406 * contributes and subtract that from the array length.
2408 array_payload_begin_offset = mbuf->valid_len;
2410 if (g_variant_n_children (value) == 0)
2412 gsize padding_added_for_item;
2413 if (!append_value_to_blob (NULL,
2414 g_variant_type_element (type),
2416 &padding_added_for_item,
2419 array_payload_begin_offset += padding_added_for_item;
2425 g_variant_iter_init (&iter, value);
2426 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2428 gsize padding_added_for_item;
2429 if (!append_value_to_blob (item,
2430 g_variant_get_type (item),
2432 &padding_added_for_item,
2435 g_variant_unref (item);
2438 g_variant_unref (item);
2441 array_payload_begin_offset += padding_added_for_item;
2447 cur_offset = mbuf->valid_len;
2448 array_len = cur_offset - array_payload_begin_offset;
2449 mbuf->pos = array_len_offset;
2451 g_memory_buffer_put_uint32 (mbuf, array_len);
2452 mbuf->pos = cur_offset;
2458 if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2460 padding_added = ensure_output_padding (mbuf, 8);
2465 g_variant_iter_init (&iter, value);
2466 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2468 if (!append_value_to_blob (item,
2469 g_variant_get_type (item),
2474 g_variant_unref (item);
2477 g_variant_unref (item);
2481 else if (g_variant_type_is_variant (type))
2486 const gchar *signature;
2487 child = g_variant_get_child_value (value, 0);
2488 signature = g_variant_get_type_string (child);
2489 g_memory_buffer_put_byte (mbuf, strlen (signature));
2490 g_memory_buffer_put_string (mbuf, signature);
2491 g_memory_buffer_put_byte (mbuf, '\0');
2492 if (!append_value_to_blob (child,
2493 g_variant_get_type (child),
2498 g_variant_unref (child);
2501 g_variant_unref (child);
2508 G_IO_ERROR_INVALID_ARGUMENT,
2509 _("Error serializing GVariant with type string '%s' to the D-Bus wire format"),
2510 g_variant_get_type_string (value));
2516 if (out_padding_added != NULL)
2517 *out_padding_added = padding_added;
2526 append_body_to_blob (GVariant *value,
2527 GMemoryBuffer *mbuf,
2533 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2537 G_IO_ERROR_INVALID_ARGUMENT,
2538 "Expected a tuple for the body of the GDBusMessage.");
2542 g_variant_iter_init (&iter, value);
2543 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2545 if (!append_value_to_blob (item,
2546 g_variant_get_type (item),
2551 g_variant_unref (item);
2554 g_variant_unref (item);
2562 /* ---------------------------------------------------------------------------------------------------- */
2565 * g_dbus_message_to_blob:
2566 * @message: A #GDBusMessage.
2567 * @out_size: Return location for size of generated blob.
2568 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2569 * @error: Return location for error.
2571 * Serializes @message to a blob. The byte order returned by
2572 * g_dbus_message_get_byte_order() will be used.
2574 * Returns: (array length=out_size) (transfer full): A pointer to a
2575 * valid binary D-Bus message of @out_size bytes generated by @message
2576 * or %NULL if @error is set. Free with g_free().
2581 g_dbus_message_to_blob (GDBusMessage *message,
2583 GDBusCapabilityFlags capabilities,
2589 goffset body_len_offset;
2590 goffset body_start_offset;
2592 GVariant *header_fields;
2593 GVariantBuilder builder;
2594 GHashTableIter hash_iter;
2596 GVariant *header_value;
2597 GVariant *signature;
2598 const gchar *signature_str;
2599 gint num_fds_in_message;
2600 gint num_fds_according_to_header;
2602 /* TODO: check against @capabilities */
2606 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2607 g_return_val_if_fail (out_size != NULL, NULL);
2608 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2610 memset (&mbuf, 0, sizeof (mbuf));
2611 mbuf.len = MIN_ARRAY_SIZE;
2612 mbuf.data = g_malloc (mbuf.len);
2614 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2615 switch (message->byte_order)
2617 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2618 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2620 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2621 mbuf.byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2626 g_memory_buffer_put_byte (&mbuf, (guchar) message->byte_order);
2627 g_memory_buffer_put_byte (&mbuf, message->type);
2628 g_memory_buffer_put_byte (&mbuf, message->flags);
2629 g_memory_buffer_put_byte (&mbuf, 1); /* major protocol version */
2630 body_len_offset = mbuf.valid_len;
2631 /* body length - will be filled in later */
2632 g_memory_buffer_put_uint32 (&mbuf, 0xF00DFACE);
2633 g_memory_buffer_put_uint32 (&mbuf, message->serial);
2635 num_fds_in_message = 0;
2637 if (message->fd_list != NULL)
2638 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2640 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2641 if (num_fds_in_message != num_fds_according_to_header)
2645 G_IO_ERROR_INVALID_ARGUMENT,
2646 _("Message has %d file descriptors but the header field indicates %d file descriptors"),
2648 num_fds_according_to_header);
2652 if (!validate_headers (message, error))
2654 g_prefix_error (error, _("Cannot serialize message: "));
2658 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2659 g_hash_table_iter_init (&hash_iter, message->headers);
2660 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2662 g_variant_builder_add (&builder,
2664 (guchar) GPOINTER_TO_UINT (key),
2667 header_fields = g_variant_builder_end (&builder);
2669 if (!append_value_to_blob (header_fields,
2670 g_variant_get_type (header_fields),
2675 g_variant_unref (header_fields);
2678 g_variant_unref (header_fields);
2680 /* header size must be a multiple of 8 */
2681 ensure_output_padding (&mbuf, 8);
2683 body_start_offset = mbuf.valid_len;
2685 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2686 signature_str = NULL;
2687 if (signature != NULL)
2688 signature_str = g_variant_get_string (signature, NULL);
2689 if (message->body != NULL)
2691 gchar *tupled_signature_str;
2692 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2693 if (signature == NULL)
2697 G_IO_ERROR_INVALID_ARGUMENT,
2698 _("Message body has signature '%s' but there is no signature header"),
2700 g_free (tupled_signature_str);
2703 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2707 G_IO_ERROR_INVALID_ARGUMENT,
2708 _("Message body has type signature '%s' but signature in the header field is '%s'"),
2709 tupled_signature_str, g_variant_get_type_string (message->body));
2710 g_free (tupled_signature_str);
2713 g_free (tupled_signature_str);
2714 if (!append_body_to_blob (message->body, &mbuf, error))
2719 if (signature != NULL && strlen (signature_str) > 0)
2723 G_IO_ERROR_INVALID_ARGUMENT,
2724 _("Message body is empty but signature in the header field is '(%s)'"),
2730 /* OK, we're done writing the message - set the body length */
2731 size = mbuf.valid_len;
2732 body_size = size - body_start_offset;
2734 mbuf.pos = body_len_offset;
2736 g_memory_buffer_put_uint32 (&mbuf, body_size);
2739 ret = (guchar *)mbuf.data;
2745 /* ---------------------------------------------------------------------------------------------------- */
2748 get_uint32_header (GDBusMessage *message,
2749 GDBusMessageHeaderField header_field)
2755 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2756 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2757 ret = g_variant_get_uint32 (value);
2762 static const gchar *
2763 get_string_header (GDBusMessage *message,
2764 GDBusMessageHeaderField header_field)
2770 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2771 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2772 ret = g_variant_get_string (value, NULL);
2777 static const gchar *
2778 get_object_path_header (GDBusMessage *message,
2779 GDBusMessageHeaderField header_field)
2785 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2786 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2787 ret = g_variant_get_string (value, NULL);
2792 static const gchar *
2793 get_signature_header (GDBusMessage *message,
2794 GDBusMessageHeaderField header_field)
2800 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2801 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2802 ret = g_variant_get_string (value, NULL);
2807 /* ---------------------------------------------------------------------------------------------------- */
2810 set_uint32_header (GDBusMessage *message,
2811 GDBusMessageHeaderField header_field,
2814 g_dbus_message_set_header (message,
2816 g_variant_new_uint32 (value));
2820 set_string_header (GDBusMessage *message,
2821 GDBusMessageHeaderField header_field,
2824 g_dbus_message_set_header (message,
2826 value == NULL ? NULL : g_variant_new_string (value));
2830 set_object_path_header (GDBusMessage *message,
2831 GDBusMessageHeaderField header_field,
2834 g_dbus_message_set_header (message,
2836 value == NULL ? NULL : g_variant_new_object_path (value));
2840 set_signature_header (GDBusMessage *message,
2841 GDBusMessageHeaderField header_field,
2844 g_dbus_message_set_header (message,
2846 value == NULL ? NULL : g_variant_new_signature (value));
2849 /* ---------------------------------------------------------------------------------------------------- */
2852 * g_dbus_message_get_reply_serial:
2853 * @message: A #GDBusMessage.
2855 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2857 * Returns: The value.
2862 g_dbus_message_get_reply_serial (GDBusMessage *message)
2864 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2865 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2869 * g_dbus_message_set_reply_serial:
2870 * @message: A #GDBusMessage.
2871 * @value: The value to set.
2873 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2878 g_dbus_message_set_reply_serial (GDBusMessage *message,
2881 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2882 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2885 /* ---------------------------------------------------------------------------------------------------- */
2888 * g_dbus_message_get_interface:
2889 * @message: A #GDBusMessage.
2891 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2893 * Returns: The value.
2898 g_dbus_message_get_interface (GDBusMessage *message)
2900 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2901 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2905 * g_dbus_message_set_interface:
2906 * @message: A #GDBusMessage.
2907 * @value: The value to set.
2909 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2914 g_dbus_message_set_interface (GDBusMessage *message,
2917 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2918 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2919 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2922 /* ---------------------------------------------------------------------------------------------------- */
2925 * g_dbus_message_get_member:
2926 * @message: A #GDBusMessage.
2928 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2930 * Returns: The value.
2935 g_dbus_message_get_member (GDBusMessage *message)
2937 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2938 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2942 * g_dbus_message_set_member:
2943 * @message: A #GDBusMessage.
2944 * @value: The value to set.
2946 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2951 g_dbus_message_set_member (GDBusMessage *message,
2954 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2955 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2956 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2959 /* ---------------------------------------------------------------------------------------------------- */
2962 * g_dbus_message_get_path:
2963 * @message: A #GDBusMessage.
2965 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2967 * Returns: The value.
2972 g_dbus_message_get_path (GDBusMessage *message)
2974 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2975 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2979 * g_dbus_message_set_path:
2980 * @message: A #GDBusMessage.
2981 * @value: The value to set.
2983 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2988 g_dbus_message_set_path (GDBusMessage *message,
2991 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2992 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2993 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2996 /* ---------------------------------------------------------------------------------------------------- */
2999 * g_dbus_message_get_sender:
3000 * @message: A #GDBusMessage.
3002 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3004 * Returns: The value.
3009 g_dbus_message_get_sender (GDBusMessage *message)
3011 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3012 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
3016 * g_dbus_message_set_sender:
3017 * @message: A #GDBusMessage.
3018 * @value: The value to set.
3020 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
3025 g_dbus_message_set_sender (GDBusMessage *message,
3028 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3029 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3030 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
3033 /* ---------------------------------------------------------------------------------------------------- */
3036 * g_dbus_message_get_destination:
3037 * @message: A #GDBusMessage.
3039 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3041 * Returns: The value.
3046 g_dbus_message_get_destination (GDBusMessage *message)
3048 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3049 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
3053 * g_dbus_message_set_destination:
3054 * @message: A #GDBusMessage.
3055 * @value: The value to set.
3057 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
3062 g_dbus_message_set_destination (GDBusMessage *message,
3065 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3066 g_return_if_fail (value == NULL || g_dbus_is_name (value));
3067 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
3070 /* ---------------------------------------------------------------------------------------------------- */
3073 * g_dbus_message_get_error_name:
3074 * @message: A #GDBusMessage.
3076 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3078 * Returns: The value.
3083 g_dbus_message_get_error_name (GDBusMessage *message)
3085 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3086 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
3090 * g_dbus_message_set_error_name:
3091 * @message: A #GDBusMessage.
3092 * @value: The value to set.
3094 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
3099 g_dbus_message_set_error_name (GDBusMessage *message,
3102 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3103 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
3104 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
3107 /* ---------------------------------------------------------------------------------------------------- */
3110 * g_dbus_message_get_signature:
3111 * @message: A #GDBusMessage.
3113 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3115 * Returns: The value.
3120 g_dbus_message_get_signature (GDBusMessage *message)
3123 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3124 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
3131 * g_dbus_message_set_signature:
3132 * @message: A #GDBusMessage.
3133 * @value: The value to set.
3135 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
3140 g_dbus_message_set_signature (GDBusMessage *message,
3143 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3144 g_return_if_fail (value == NULL || g_variant_is_signature (value));
3145 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
3148 /* ---------------------------------------------------------------------------------------------------- */
3151 * g_dbus_message_get_arg0:
3152 * @message: A #GDBusMessage.
3154 * Convenience to get the first item in the body of @message.
3156 * Returns: The string item or %NULL if the first item in the body of
3157 * @message is not a string.
3162 g_dbus_message_get_arg0 (GDBusMessage *message)
3166 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3170 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
3173 item = g_variant_get_child_value (message->body, 0);
3174 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
3175 ret = g_variant_get_string (item, NULL);
3176 g_variant_unref (item);
3182 /* ---------------------------------------------------------------------------------------------------- */
3185 * g_dbus_message_get_num_unix_fds:
3186 * @message: A #GDBusMessage.
3188 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3190 * Returns: The value.
3195 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
3197 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
3198 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
3202 * g_dbus_message_set_num_unix_fds:
3203 * @message: A #GDBusMessage.
3204 * @value: The value to set.
3206 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
3211 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
3214 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3215 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
3218 /* ---------------------------------------------------------------------------------------------------- */
3221 * g_dbus_message_to_gerror:
3222 * @message: A #GDBusMessage.
3223 * @error: The #GError to set.
3225 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
3226 * nothing and returns %FALSE.
3228 * Otherwise this method encodes the error in @message as a #GError
3229 * using g_dbus_error_set_dbus_error() using the information in the
3230 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
3231 * well as the first string item in @message's body.
3233 * Returns: %TRUE if @error was set, %FALSE otherwise.
3238 g_dbus_message_to_gerror (GDBusMessage *message,
3242 const gchar *error_name;
3244 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3247 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
3250 error_name = g_dbus_message_get_error_name (message);
3251 if (error_name != NULL)
3255 body = g_dbus_message_get_body (message);
3257 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
3259 const gchar *error_message;
3260 g_variant_get (body, "(&s)", &error_message);
3261 g_dbus_error_set_dbus_error (error,
3268 /* these two situations are valid, yet pretty rare */
3271 g_dbus_error_set_dbus_error (error,
3274 _("Error return with body of type '%s'"),
3275 g_variant_get_type_string (body));
3279 g_dbus_error_set_dbus_error (error,
3282 _("Error return with empty body"));
3288 /* TOOD: this shouldn't happen - should check this at message serialization
3289 * time and disconnect the peer.
3294 "Error return without error-name header!");
3303 /* ---------------------------------------------------------------------------------------------------- */
3306 flags_to_string (GType flags_type, guint value)
3312 klass = g_type_class_ref (flags_type);
3313 s = g_string_new (NULL);
3314 for (n = 0; n < 32; n++)
3316 if ((value & (1<<n)) != 0)
3318 GFlagsValue *flags_value;
3319 flags_value = g_flags_get_first_value (klass, (1<<n));
3321 g_string_append_c (s, ',');
3322 if (flags_value != NULL)
3323 g_string_append (s, flags_value->value_nick);
3325 g_string_append_printf (s, "unknown (bit %d)", n);
3329 g_string_append (s, "none");
3330 g_type_class_unref (klass);
3331 return g_string_free (s, FALSE);
3335 _sort_keys_func (gconstpointer a,
3341 ia = GPOINTER_TO_INT (a);
3342 ib = GPOINTER_TO_INT (b);
3348 * g_dbus_message_print:
3349 * @message: A #GDBusMessage.
3350 * @indent: Indentation level.
3352 * Produces a human-readable multi-line description of @message.
3354 * The contents of the description has no ABI guarantees, the contents
3355 * and formatting is subject to change at any time. Typical output
3356 * looks something like this:
3358 * Type: method-call
3363 * path -> objectpath '/org/gtk/GDBus/TestObject'
3364 * interface -> 'org.gtk.GDBus.TestInterface'
3365 * member -> 'GimmeStdout'
3366 * destination -> ':1.146'
3368 * UNIX File Descriptors:
3373 * Type: method-return
3374 * Flags: no-reply-expected
3378 * reply-serial -> uint32 4
3379 * destination -> ':1.159'
3380 * sender -> ':1.146'
3381 * num-unix-fds -> uint32 1
3383 * UNIX File Descriptors:
3384 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3387 * Returns: A string that should be freed with g_free().
3392 g_dbus_message_print (GDBusMessage *message,
3400 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3402 str = g_string_new (NULL);
3404 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3405 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3407 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3408 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3410 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3411 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3413 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3414 keys = g_hash_table_get_keys (message->headers);
3415 keys = g_list_sort (keys, _sort_keys_func);
3418 for (l = keys; l != NULL; l = l->next)
3420 gint key = GPOINTER_TO_INT (l->data);
3424 value = g_hash_table_lookup (message->headers, l->data);
3425 g_assert (value != NULL);
3427 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3428 value_str = g_variant_print (value, TRUE);
3429 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3436 g_string_append_printf (str, "%*s (none)\n", indent, "");
3438 g_string_append_printf (str, "%*sBody: ", indent, "");
3439 if (message->body != NULL)
3441 g_variant_print_string (message->body,
3447 g_string_append (str, "()");
3449 g_string_append (str, "\n");
3451 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3452 if (message->fd_list != NULL)
3458 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3461 for (n = 0; n < num_fds; n++)
3464 struct stat statbuf;
3465 fs = g_string_new (NULL);
3466 if (fstat (fds[n], &statbuf) == 0)
3468 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3469 major (statbuf.st_dev), minor (statbuf.st_dev));
3470 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3472 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3473 (guint64) statbuf.st_ino);
3474 g_string_append_printf (fs, "%s" "uid=%u", fs->len > 0 ? "," : "",
3475 (guint) statbuf.st_uid);
3476 g_string_append_printf (fs, "%s" "gid=%u", fs->len > 0 ? "," : "",
3477 (guint) statbuf.st_gid);
3478 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3479 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3480 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3481 (guint64) statbuf.st_size);
3482 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3483 (guint64) statbuf.st_atime);
3484 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3485 (guint64) statbuf.st_mtime);
3486 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3487 (guint64) statbuf.st_ctime);
3491 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3493 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3494 g_string_free (fs, TRUE);
3499 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3504 g_string_append_printf (str, "%*s (none)\n", indent, "");
3508 return g_string_free (str, FALSE);
3512 * g_dbus_message_get_locked:
3513 * @message: A #GDBusMessage.
3515 * Checks whether @message is locked. To monitor changes to this
3516 * value, conncet to the #GObject::notify signal to listen for changes
3517 * on the #GDBusMessage:locked property.
3519 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3524 g_dbus_message_get_locked (GDBusMessage *message)
3526 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3527 return message->locked;
3531 * g_dbus_message_lock:
3532 * @message: A #GDBusMessage.
3534 * If @message is locked, does nothing. Otherwise locks the message.
3539 g_dbus_message_lock (GDBusMessage *message)
3541 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3543 if (message->locked)
3546 message->locked = TRUE;
3547 g_object_notify (G_OBJECT (message), "locked");
3554 * g_dbus_message_copy:
3555 * @message: A #GDBusMessage.
3556 * @error: Return location for error or %NULL.
3558 * Copies @message. The copy is a deep copy and the returned
3559 * #GDBusMessage is completely identical except that it is guaranteed
3562 * This operation can fail if e.g. @message contains file descriptors
3563 * and the per-process or system-wide open files limit is reached.
3565 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3566 * Free with g_object_unref().
3571 g_dbus_message_copy (GDBusMessage *message,
3575 GHashTableIter iter;
3576 gpointer header_key;
3577 GVariant *header_value;
3579 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3580 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3582 ret = g_dbus_message_new ();
3583 ret->type = message->type;
3584 ret->flags = message->flags;
3585 ret->byte_order = message->byte_order;
3586 ret->major_protocol_version = message->major_protocol_version;
3587 ret->serial = message->serial;
3590 if (message->fd_list != NULL)
3596 ret->fd_list = g_unix_fd_list_new ();
3597 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3598 for (n = 0; n < num_fds; n++)
3600 if (g_unix_fd_list_append (ret->fd_list,
3604 g_object_unref (ret);
3612 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3613 * to just ref (as opposed to deep-copying) the GVariant instances
3615 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3616 g_hash_table_iter_init (&iter, message->headers);
3617 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3618 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));