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"
60 * SECTION:gdbusmessage
61 * @short_description: D-Bus Message
64 * A type for representing D-Bus messages that can be sent or received
65 * on a #GDBusConnection.
68 typedef struct _GDBusMessageClass GDBusMessageClass;
73 * Class structure for #GDBusMessage.
77 struct _GDBusMessageClass
80 GObjectClass parent_class;
86 * The #GDBusMessage structure contains only private data and should
87 * only be accessed using the provided API.
94 GObject parent_instance;
96 GDBusMessageType type;
97 GDBusMessageFlags flags;
99 GDBusMessageByteOrder byte_order;
100 guchar major_protocol_version;
105 GUnixFDList *fd_list;
115 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
118 g_dbus_message_finalize (GObject *object)
120 GDBusMessage *message = G_DBUS_MESSAGE (object);
122 if (message->headers != NULL)
123 g_hash_table_unref (message->headers);
124 if (message->body != NULL)
125 g_variant_unref (message->body);
127 if (message->fd_list != NULL)
128 g_object_unref (message->fd_list);
131 if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
132 G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
136 g_dbus_message_get_property (GObject *object,
141 GDBusMessage *message = G_DBUS_MESSAGE (object);
146 g_value_set_boolean (value, g_dbus_message_get_locked (message));
150 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
156 g_dbus_message_class_init (GDBusMessageClass *klass)
158 GObjectClass *gobject_class;
160 gobject_class = G_OBJECT_CLASS (klass);
161 gobject_class->finalize = g_dbus_message_finalize;
162 gobject_class->get_property = g_dbus_message_get_property;
165 * GDBusConnection:locked:
167 * A boolean specifying whether the message is locked.
171 g_object_class_install_property (gobject_class,
173 g_param_spec_boolean ("locked",
175 P_("Whether the message is locked"),
178 G_PARAM_STATIC_NAME |
179 G_PARAM_STATIC_BLURB |
180 G_PARAM_STATIC_NICK));
184 g_dbus_message_init (GDBusMessage *message)
186 /* Any D-Bus implementation is supposed to handle both Big and
187 * Little Endian encodings and the Endianness is part of the D-Bus
188 * message - we prefer to use Big Endian (since it's Network Byte
189 * Order and just easier to read for humans) but if the machine is
190 * Little Endian we use that for performance reasons.
192 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
193 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
195 /* this could also be G_PDP_ENDIAN */
196 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
198 message->headers = g_hash_table_new_full (g_direct_hash,
201 (GDestroyNotify) g_variant_unref);
205 * g_dbus_message_new:
207 * Creates a new empty #GDBusMessage.
209 * Returns: A #GDBusMessage. Free with g_object_unref().
214 g_dbus_message_new (void)
216 return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
220 * g_dbus_message_new_method_call:
221 * @name: A valid D-Bus name or %NULL.
222 * @path: A valid object path.
223 * @interface_: A valid D-Bus interface name or %NULL.
224 * @method: A valid method name.
226 * Creates a new #GDBusMessage for a method call.
228 * Returns: A #GDBusMessage. Free with g_object_unref().
233 g_dbus_message_new_method_call (const gchar *name,
235 const gchar *interface_,
238 GDBusMessage *message;
240 g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
241 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
242 g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
243 g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
245 message = g_dbus_message_new ();
246 message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
249 g_dbus_message_set_destination (message, name);
250 g_dbus_message_set_path (message, path);
251 g_dbus_message_set_member (message, method);
252 if (interface_ != NULL)
253 g_dbus_message_set_interface (message, interface_);
259 * g_dbus_message_new_signal:
260 * @path: A valid object path.
261 * @interface_: A valid D-Bus interface name.
262 * @signal: A valid signal name.
264 * Creates a new #GDBusMessage for a signal emission.
266 * Returns: A #GDBusMessage. Free with g_object_unref().
271 g_dbus_message_new_signal (const gchar *path,
272 const gchar *interface_,
275 GDBusMessage *message;
277 g_return_val_if_fail (g_variant_is_object_path (path), NULL);
278 g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
279 g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
281 message = g_dbus_message_new ();
282 message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
283 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
285 g_dbus_message_set_path (message, path);
286 g_dbus_message_set_member (message, signal);
287 g_dbus_message_set_interface (message, interface_);
294 * g_dbus_message_new_method_reply:
295 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
296 * create a reply message to.
298 * Creates a new #GDBusMessage that is a reply to @method_call_message.
300 * Returns: (transfer full): #GDBusMessage. Free with g_object_unref().
305 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
307 GDBusMessage *message;
310 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
311 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
312 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
314 message = g_dbus_message_new ();
315 message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
316 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
317 /* reply with same endianness */
318 message->byte_order = method_call_message->byte_order;
320 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
321 sender = g_dbus_message_get_sender (method_call_message);
323 g_dbus_message_set_destination (message, sender);
329 * g_dbus_message_new_method_error:
330 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
331 * create a reply message to.
332 * @error_name: A valid D-Bus error name.
333 * @error_message_format: The D-Bus error message in a printf() format.
334 * @...: Arguments for @error_message_format.
336 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
338 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
343 g_dbus_message_new_method_error (GDBusMessage *method_call_message,
344 const gchar *error_name,
345 const gchar *error_message_format,
351 va_start (var_args, error_message_format);
352 ret = g_dbus_message_new_method_error_valist (method_call_message,
354 error_message_format,
362 * g_dbus_message_new_method_error_literal:
363 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
364 * create a reply message to.
365 * @error_name: A valid D-Bus error name.
366 * @error_message: The D-Bus error message.
368 * Creates a new #GDBusMessage that is an error reply to @method_call_message.
370 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
375 g_dbus_message_new_method_error_literal (GDBusMessage *method_call_message,
376 const gchar *error_name,
377 const gchar *error_message)
379 GDBusMessage *message;
382 g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
383 g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
384 g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
385 g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
386 g_return_val_if_fail (error_message != NULL, NULL);
388 message = g_dbus_message_new ();
389 message->type = G_DBUS_MESSAGE_TYPE_ERROR;
390 message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
391 /* reply with same endianness */
392 message->byte_order = method_call_message->byte_order;
394 g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
395 g_dbus_message_set_error_name (message, error_name);
396 g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
398 sender = g_dbus_message_get_sender (method_call_message);
400 g_dbus_message_set_destination (message, sender);
406 * g_dbus_message_new_method_error_valist:
407 * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
408 * create a reply message to.
409 * @error_name: A valid D-Bus error name.
410 * @error_message_format: The D-Bus error message in a printf() format.
411 * @var_args: Arguments for @error_message_format.
413 * Like g_dbus_message_new_method_error() but intended for language bindings.
415 * Returns: (transfer full): A #GDBusMessage. Free with g_object_unref().
420 g_dbus_message_new_method_error_valist (GDBusMessage *method_call_message,
421 const gchar *error_name,
422 const gchar *error_message_format,
426 gchar *error_message;
427 error_message = g_strdup_vprintf (error_message_format, var_args);
428 ret = g_dbus_message_new_method_error_literal (method_call_message,
431 g_free (error_message);
435 /* ---------------------------------------------------------------------------------------------------- */
438 * g_dbus_message_get_byte_order:
439 * @message: A #GDBusMessage.
441 * Gets the byte order of @message.
443 * Returns: The byte order.
445 GDBusMessageByteOrder
446 g_dbus_message_get_byte_order (GDBusMessage *message)
448 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
449 return message->byte_order;
453 * g_dbus_message_set_byte_order:
454 * @message: A #GDBusMessage.
455 * @byte_order: The byte order.
457 * Sets the byte order of @message.
460 g_dbus_message_set_byte_order (GDBusMessage *message,
461 GDBusMessageByteOrder byte_order)
463 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
467 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
471 message->byte_order = byte_order;
474 /* ---------------------------------------------------------------------------------------------------- */
476 /* TODO: need GI annotations to specify that any guchar value goes for the type */
479 * g_dbus_message_get_message_type:
480 * @message: A #GDBusMessage.
482 * Gets the type of @message.
484 * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
489 g_dbus_message_get_message_type (GDBusMessage *message)
491 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
492 return message->type;
496 * g_dbus_message_set_message_type:
497 * @message: A #GDBusMessage.
498 * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
500 * Sets @message to be of @type.
505 g_dbus_message_set_message_type (GDBusMessage *message,
506 GDBusMessageType type)
508 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
509 g_return_if_fail (type >=0 && type < 256);
513 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
517 message->type = type;
520 /* ---------------------------------------------------------------------------------------------------- */
522 /* TODO: need GI annotations to specify that any guchar value goes for flags */
525 * g_dbus_message_get_flags:
526 * @message: A #GDBusMessage.
528 * Gets the flags for @message.
530 * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
535 g_dbus_message_get_flags (GDBusMessage *message)
537 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
538 return message->flags;
542 * g_dbus_message_set_flags:
543 * @message: A #GDBusMessage.
544 * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
545 * enumeration bitwise ORed together).
547 * Sets the flags to set on @message.
552 g_dbus_message_set_flags (GDBusMessage *message,
553 GDBusMessageFlags flags)
555 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
556 g_return_if_fail (flags >=0 && flags < 256);
560 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
564 message->flags = flags;
567 /* ---------------------------------------------------------------------------------------------------- */
570 * g_dbus_message_get_serial:
571 * @message: A #GDBusMessage.
573 * Gets the serial for @message.
575 * Returns: A #guint32.
580 g_dbus_message_get_serial (GDBusMessage *message)
582 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
583 return message->serial;
587 * g_dbus_message_set_serial:
588 * @message: A #GDBusMessage.
589 * @serial: A #guint32.
591 * Sets the serial for @message.
596 g_dbus_message_set_serial (GDBusMessage *message,
599 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
603 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
607 message->serial = serial;
610 /* ---------------------------------------------------------------------------------------------------- */
612 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
615 * g_dbus_message_get_header:
616 * @message: A #GDBusMessage.
617 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
619 * Gets a header field on @message.
621 * Returns: A #GVariant with the value if the header was found, %NULL
622 * otherwise. Do not free, it is owned by @message.
627 g_dbus_message_get_header (GDBusMessage *message,
628 GDBusMessageHeaderField header_field)
630 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
631 g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
632 return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
636 * g_dbus_message_set_header:
637 * @message: A #GDBusMessage.
638 * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
639 * @value: A #GVariant to set the header field or %NULL to clear the header field.
641 * Sets a header field on @message.
643 * If @value is floating, @message assumes ownership of @value.
648 g_dbus_message_set_header (GDBusMessage *message,
649 GDBusMessageHeaderField header_field,
652 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
653 g_return_if_fail (header_field >=0 && header_field < 256);
657 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
663 g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
667 g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
672 * g_dbus_message_get_header_fields:
673 * @message: A #GDBusMessage.
675 * Gets an array of all header fields on @message that are set.
677 * Returns: An array of header fields terminated by
678 * %G_DBUS_MESSAGE_HEADER_FIELD_INVALID. Each element is a
679 * #guchar. Free with g_free().
684 g_dbus_message_get_header_fields (GDBusMessage *message)
692 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
694 keys = g_hash_table_get_keys (message->headers);
695 num_keys = g_list_length (keys);
696 ret = g_new (guchar, num_keys + 1);
697 for (l = keys, n = 0; l != NULL; l = l->next, n++)
698 ret[n] = GPOINTER_TO_UINT (l->data);
699 g_assert (n == num_keys);
700 ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
706 /* ---------------------------------------------------------------------------------------------------- */
709 * g_dbus_message_get_body:
710 * @message: A #GDBusMessage.
712 * Gets the body of a message.
714 * Returns: A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
719 g_dbus_message_get_body (GDBusMessage *message)
721 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
722 return message->body;
726 * g_dbus_message_set_body:
727 * @message: A #GDBusMessage.
728 * @body: Either %NULL or a #GVariant that is a tuple.
730 * Sets the body @message. As a side-effect the
731 * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
732 * type string of @body (or cleared if @body is %NULL).
734 * If @body is floating, @message assumes ownership of @body.
739 g_dbus_message_set_body (GDBusMessage *message,
742 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
743 g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
747 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
751 if (message->body != NULL)
752 g_variant_unref (message->body);
755 message->body = NULL;
756 g_dbus_message_set_signature (message, NULL);
760 const gchar *type_string;
761 gsize type_string_len;
764 message->body = g_variant_ref_sink (body);
766 type_string = g_variant_get_type_string (body);
767 type_string_len = strlen (type_string);
768 g_assert (type_string_len >= 2);
769 signature = g_strndup (type_string + 1, type_string_len - 2);
770 g_dbus_message_set_signature (message, signature);
775 /* ---------------------------------------------------------------------------------------------------- */
779 * g_dbus_message_get_unix_fd_list:
780 * @message: A #GDBusMessage.
782 * Gets the UNIX file descriptors associated with @message, if any.
784 * This method is only available on UNIX.
786 * Returns: (transfer none):A #GUnixFDList or %NULL if no file descriptors are
787 * associated. Do not free, this object is owned by @message.
792 g_dbus_message_get_unix_fd_list (GDBusMessage *message)
794 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
795 return message->fd_list;
799 * g_dbus_message_set_unix_fd_list:
800 * @message: A #GDBusMessage.
801 * @fd_list: (allow-none): A #GUnixFDList or %NULL.
803 * Sets the UNIX file descriptors associated with @message. As a
804 * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
805 * field is set to the number of fds in @fd_list (or cleared if
806 * @fd_list is %NULL).
808 * This method is only available on UNIX.
813 g_dbus_message_set_unix_fd_list (GDBusMessage *message,
814 GUnixFDList *fd_list)
816 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
817 g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
821 g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
825 if (message->fd_list != NULL)
826 g_object_unref (message->fd_list);
829 message->fd_list = g_object_ref (fd_list);
830 g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
834 message->fd_list = NULL;
835 g_dbus_message_set_num_unix_fds (message, 0);
840 /* ---------------------------------------------------------------------------------------------------- */
843 validate_headers (GDBusMessage *message,
848 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
849 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
853 switch (message->type)
855 case G_DBUS_MESSAGE_TYPE_INVALID:
856 g_set_error_literal (error,
858 G_IO_ERROR_INVALID_ARGUMENT,
859 _("type is INVALID"));
863 case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
864 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
865 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
867 g_set_error_literal (error,
869 G_IO_ERROR_INVALID_ARGUMENT,
870 _("METHOD_CALL message: PATH or MEMBER header field is missing"));
875 case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
876 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
878 g_set_error_literal (error,
880 G_IO_ERROR_INVALID_ARGUMENT,
881 _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
886 case G_DBUS_MESSAGE_TYPE_ERROR:
887 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
888 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
890 g_set_error_literal (error,
892 G_IO_ERROR_INVALID_ARGUMENT,
893 _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
898 case G_DBUS_MESSAGE_TYPE_SIGNAL:
899 if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
900 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
901 g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
903 g_set_error_literal (error,
905 G_IO_ERROR_INVALID_ARGUMENT,
906 _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
909 if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
911 g_set_error_literal (error,
913 G_IO_ERROR_INVALID_ARGUMENT,
914 _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
917 if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
919 g_set_error_literal (error,
921 G_IO_ERROR_INVALID_ARGUMENT,
922 _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
928 /* hitherto unknown type - nothing to check */
935 g_assert (ret || (error == NULL || *error != NULL));
939 /* ---------------------------------------------------------------------------------------------------- */
942 ensure_input_padding (GMemoryInputStream *mis,
949 offset = g_seekable_tell (G_SEEKABLE (mis));
950 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
952 if (offset != wanted_offset)
954 return g_seekable_seek (G_SEEKABLE (mis), wanted_offset, G_SEEK_SET, NULL, error);
963 read_string (GMemoryInputStream *mis,
964 GDataInputStream *dis,
973 const gchar *end_valid;
975 s = g_string_new (NULL);
978 while (remaining > 0)
983 to_read = MIN (remaining, sizeof (buf));
984 num_read = g_input_stream_read (G_INPUT_STREAM (mis),
993 /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
996 G_IO_ERROR_INVALID_ARGUMENT,
997 _("Wanted to read %lu bytes but got EOF"),
1002 remaining -= num_read;
1003 g_string_append_len (s, buf, num_read);
1007 nul = g_data_input_stream_read_byte (dis, NULL, &local_error);
1008 if (local_error != NULL)
1010 g_propagate_error (error, local_error);
1013 if (!g_utf8_validate (s->str, -1, &end_valid))
1017 offset = (gint) (end_valid - s->str);
1018 valid_str = g_strndup (s->str, offset);
1021 G_IO_ERROR_INVALID_ARGUMENT,
1022 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1023 "The valid UTF-8 string up until that point was `%s'"),
1034 G_IO_ERROR_INVALID_ARGUMENT,
1035 _("Expected NUL byte after the string `%s' but found byte %d"),
1040 return g_string_free (s, FALSE);
1043 g_string_free (s, TRUE);
1047 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1049 /* returns a non-floating GVariant! */
1051 parse_value_from_blob (GMemoryInputStream *mis,
1052 GDataInputStream *dis,
1053 const GVariantType *type,
1054 gboolean just_align,
1059 GError *local_error;
1062 #ifdef DEBUG_SERIALIZER
1066 s = g_variant_type_dup_string (type);
1067 g_print ("%*sReading type %s from offset 0x%04x",
1070 (gint) g_seekable_tell (G_SEEKABLE (mis)));
1073 #endif /* DEBUG_SERIALIZER */
1079 if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
1081 if (!ensure_input_padding (mis, 4, &local_error))
1086 v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1087 if (local_error != NULL)
1089 ret = g_variant_new_boolean (v);
1092 else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1097 v = g_data_input_stream_read_byte (dis, NULL, &local_error);
1098 if (local_error != NULL)
1100 ret = g_variant_new_byte (v);
1103 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
1105 if (!ensure_input_padding (mis, 2, &local_error))
1110 v = g_data_input_stream_read_int16 (dis, NULL, &local_error);
1111 if (local_error != NULL)
1113 ret = g_variant_new_int16 (v);
1116 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
1118 if (!ensure_input_padding (mis, 2, &local_error))
1123 v = g_data_input_stream_read_uint16 (dis, NULL, &local_error);
1124 if (local_error != NULL)
1126 ret = g_variant_new_uint16 (v);
1129 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
1131 if (!ensure_input_padding (mis, 4, &local_error))
1136 v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1137 if (local_error != NULL)
1139 ret = g_variant_new_int32 (v);
1142 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
1144 if (!ensure_input_padding (mis, 4, &local_error))
1149 v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1150 if (local_error != NULL)
1152 ret = g_variant_new_uint32 (v);
1155 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
1157 if (!ensure_input_padding (mis, 8, &local_error))
1162 v = g_data_input_stream_read_int64 (dis, NULL, &local_error);
1163 if (local_error != NULL)
1165 ret = g_variant_new_int64 (v);
1168 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
1170 if (!ensure_input_padding (mis, 8, &local_error))
1175 v = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1176 if (local_error != NULL)
1178 ret = g_variant_new_uint64 (v);
1181 else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
1183 if (!ensure_input_padding (mis, 8, &local_error))
1191 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1192 u.v_uint64 = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1193 if (local_error != NULL)
1195 ret = g_variant_new_double (u.v_double);
1198 else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
1200 if (!ensure_input_padding (mis, 4, &local_error))
1206 len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1207 if (local_error != NULL)
1209 v = read_string (mis, dis, (gsize) len, &local_error);
1212 ret = g_variant_new_string (v);
1216 else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
1218 if (!ensure_input_padding (mis, 4, &local_error))
1224 len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1225 if (local_error != NULL)
1227 v = read_string (mis, dis, (gsize) len, &local_error);
1230 if (!g_variant_is_object_path (v))
1232 g_set_error (&local_error,
1234 G_IO_ERROR_INVALID_ARGUMENT,
1235 _("Parsed value `%s' is not a valid D-Bus object path"),
1240 ret = g_variant_new_object_path (v);
1244 else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
1250 len = g_data_input_stream_read_byte (dis, NULL, &local_error);
1251 if (local_error != NULL)
1253 v = read_string (mis, dis, (gsize) len, &local_error);
1256 if (!g_variant_is_signature (v))
1258 g_set_error (&local_error,
1260 G_IO_ERROR_INVALID_ARGUMENT,
1261 _("Parsed value `%s' is not a valid D-Bus signature"),
1266 ret = g_variant_new_signature (v);
1270 else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
1272 if (!ensure_input_padding (mis, 4, &local_error))
1277 v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1278 if (local_error != NULL)
1280 ret = g_variant_new_handle (v);
1283 else if (g_variant_type_is_array (type))
1288 const GVariantType *element_type;
1289 GVariantBuilder builder;
1291 if (!ensure_input_padding (mis, 4, &local_error))
1300 array_len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1301 if (local_error != NULL)
1305 #ifdef DEBUG_SERIALIZER
1306 g_print (": array spans 0x%04x bytes\n", array_len);
1307 #endif /* DEBUG_SERIALIZER */
1309 if (array_len > (2<<26))
1311 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1312 g_set_error (&local_error,
1314 G_IO_ERROR_INVALID_ARGUMENT,
1315 _("Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB)."),
1321 g_variant_builder_init (&builder, type);
1322 element_type = g_variant_type_element (type);
1327 item = parse_value_from_blob (mis,
1333 g_assert (item == NULL);
1337 /* TODO: optimize array of primitive types */
1338 offset = g_seekable_tell (G_SEEKABLE (mis));
1339 target = offset + array_len;
1340 while (offset < target)
1343 item = parse_value_from_blob (mis,
1351 g_variant_builder_clear (&builder);
1354 g_variant_builder_add_value (&builder, item);
1355 g_variant_unref (item);
1356 offset = g_seekable_tell (G_SEEKABLE (mis));
1362 ret = g_variant_builder_end (&builder);
1366 g_variant_builder_clear (&builder);
1369 else if (g_variant_type_is_dict_entry (type))
1371 const GVariantType *key_type;
1372 const GVariantType *value_type;
1376 if (!ensure_input_padding (mis, 8, &local_error))
1380 #ifdef DEBUG_SERIALIZER
1382 #endif /* DEBUG_SERIALIZER */
1386 key_type = g_variant_type_key (type);
1387 key = parse_value_from_blob (mis,
1395 value_type = g_variant_type_value (type);
1396 value = parse_value_from_blob (mis,
1404 g_variant_unref (key);
1407 ret = g_variant_new_dict_entry (key, value);
1408 g_variant_unref (key);
1409 g_variant_unref (value);
1412 else if (g_variant_type_is_tuple (type))
1414 if (!ensure_input_padding (mis, 8, &local_error))
1418 #ifdef DEBUG_SERIALIZER
1420 #endif /* DEBUG_SERIALIZER */
1424 const GVariantType *element_type;
1425 GVariantBuilder builder;
1427 g_variant_builder_init (&builder, type);
1428 element_type = g_variant_type_first (type);
1429 while (element_type != NULL)
1432 item = parse_value_from_blob (mis,
1440 g_variant_builder_clear (&builder);
1443 g_variant_builder_add_value (&builder, item);
1444 g_variant_unref (item);
1446 element_type = g_variant_type_next (element_type);
1448 ret = g_variant_builder_end (&builder);
1451 else if (g_variant_type_is_variant (type))
1454 #ifdef DEBUG_SERIALIZER
1456 #endif /* DEBUG_SERIALIZER */
1462 GVariantType *variant_type;
1465 siglen = g_data_input_stream_read_byte (dis, NULL, &local_error);
1466 if (local_error != NULL)
1468 sig = read_string (mis, dis, (gsize) siglen, &local_error);
1471 if (!g_variant_is_signature (sig))
1473 g_set_error (&local_error,
1475 G_IO_ERROR_INVALID_ARGUMENT,
1476 _("Parsed value `%s' for variant is not a valid D-Bus signature"),
1481 variant_type = g_variant_type_new (sig);
1483 value = parse_value_from_blob (mis,
1489 g_variant_type_free (variant_type);
1492 ret = g_variant_new_variant (value);
1493 g_variant_unref (value);
1499 s = g_variant_type_dup_string (type);
1500 g_set_error (&local_error,
1502 G_IO_ERROR_INVALID_ARGUMENT,
1503 _("Error deserializing GVariant with type string `%s' from the D-Bus wire format"),
1509 g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1511 #ifdef DEBUG_SERIALIZER
1517 if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1519 s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1523 s = g_variant_print (ret, FALSE);
1525 g_print (": %s\n", s);
1530 is_leaf = is_leaf; /* To avoid -Wunused-but-set-variable */
1531 #endif /* DEBUG_SERIALIZER */
1533 /* sink the reference */
1536 g_assert (g_variant_is_floating (ret));
1537 g_variant_ref_sink (ret);
1542 #ifdef DEBUG_SERIALIZER
1544 "%*sFAILURE: %s (%s, %d)\n",
1546 local_error->message,
1547 g_quark_to_string (local_error->domain),
1549 #endif /* DEBUG_SERIALIZER */
1550 g_propagate_error (error, local_error);
1554 /* ---------------------------------------------------------------------------------------------------- */
1556 /* message_header must be at least 16 bytes */
1559 * g_dbus_message_bytes_needed:
1560 * @blob: A blob represent a binary D-Bus message.
1561 * @blob_len: The length of @blob (must be at least 16).
1562 * @error: Return location for error or %NULL.
1564 * Utility function to calculate how many bytes are needed to
1565 * completely deserialize the D-Bus message stored at @blob.
1567 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1568 * @blob contains invalid data or not enough data is available to
1569 * determine the size).
1574 g_dbus_message_bytes_needed (guchar *blob,
1582 g_return_val_if_fail (blob != NULL, -1);
1583 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1584 g_return_val_if_fail (blob_len >= 16, -1);
1588 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1589 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1590 /* round up so it's a multiple of 8 */
1591 ret = 8 * ((ret + 7)/8);
1592 /* finally add the body size */
1593 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1595 else if (blob[0] == 'B')
1597 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1598 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1599 /* round up so it's a multiple of 8 */
1600 ret = 8 * ((ret + 7)/8);
1601 /* finally add the body size */
1602 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1608 G_IO_ERROR_INVALID_ARGUMENT,
1609 "Unable to determine message blob length - given blob is malformed");
1616 G_IO_ERROR_INVALID_ARGUMENT,
1617 "Blob indicates that message exceeds maximum message length (128MiB)");
1624 /* ---------------------------------------------------------------------------------------------------- */
1627 * g_dbus_message_new_from_blob:
1628 * @blob: A blob represent a binary D-Bus message.
1629 * @blob_len: The length of @blob.
1630 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
1631 * @error: Return location for error or %NULL.
1633 * Creates a new #GDBusMessage from the data stored at @blob. The byte
1634 * order that the message was in can be retrieved using
1635 * g_dbus_message_get_byte_order().
1637 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
1643 g_dbus_message_new_from_blob (guchar *blob,
1645 GDBusCapabilityFlags capabilities,
1649 GMemoryInputStream *mis;
1650 GDataInputStream *dis;
1651 GDBusMessage *message;
1653 guchar major_protocol_version;
1654 GDataStreamByteOrder byte_order;
1655 guint32 message_body_len;
1659 GVariant *signature;
1661 /* TODO: check against @capabilities */
1665 g_return_val_if_fail (blob != NULL, NULL);
1666 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1667 g_return_val_if_fail (blob_len >= 12, NULL);
1669 message = g_dbus_message_new ();
1671 mis = G_MEMORY_INPUT_STREAM (g_memory_input_stream_new_from_data (blob, blob_len, NULL));
1672 dis = g_data_input_stream_new (G_INPUT_STREAM (mis));
1674 endianness = g_data_input_stream_read_byte (dis, NULL, NULL);
1678 byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
1679 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
1682 byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
1683 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
1688 G_IO_ERROR_INVALID_ARGUMENT,
1689 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
1693 g_data_input_stream_set_byte_order (dis, byte_order);
1695 message->type = g_data_input_stream_read_byte (dis, NULL, NULL);
1696 message->flags = g_data_input_stream_read_byte (dis, NULL, NULL);
1697 major_protocol_version = g_data_input_stream_read_byte (dis, NULL, NULL);
1698 if (major_protocol_version != 1)
1702 G_IO_ERROR_INVALID_ARGUMENT,
1703 _("Invalid major protocol version. Expected 1 but found %d"),
1704 major_protocol_version);
1707 message_body_len = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1708 message->serial = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1710 #ifdef DEBUG_SERIALIZER
1711 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1714 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
1715 g_print ("%s\n", s);
1718 #endif /* DEBUG_SERIALIZER */
1720 #ifdef DEBUG_SERIALIZER
1721 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1722 #endif /* DEBUG_SERIALIZER */
1723 headers = parse_value_from_blob (mis,
1725 G_VARIANT_TYPE ("a{yv}"),
1729 if (headers == NULL)
1731 g_variant_iter_init (&iter, headers);
1732 while ((item = g_variant_iter_next_value (&iter)) != NULL)
1734 guchar header_field;
1736 g_variant_get (item,
1740 g_dbus_message_set_header (message, header_field, value);
1741 g_variant_unref (value);
1742 g_variant_unref (item);
1744 g_variant_unref (headers);
1746 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
1747 if (signature != NULL)
1749 const gchar *signature_str;
1750 gsize signature_str_len;
1752 signature_str = g_variant_get_string (signature, &signature_str_len);
1754 /* signature but no body */
1755 if (message_body_len == 0 && signature_str_len > 0)
1759 G_IO_ERROR_INVALID_ARGUMENT,
1760 _("Signature header with signature `%s' found but message body is empty"),
1764 else if (signature_str_len > 0)
1766 GVariantType *variant_type;
1767 gchar *tupled_signature_str;
1769 if (!g_variant_is_signature (signature_str))
1773 G_IO_ERROR_INVALID_ARGUMENT,
1774 _("Parsed value `%s' is not a valid D-Bus signature (for body)"),
1778 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
1779 variant_type = g_variant_type_new (tupled_signature_str);
1780 g_free (tupled_signature_str);
1781 #ifdef DEBUG_SERIALIZER
1782 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1783 #endif /* DEBUG_SERIALIZER */
1784 message->body = parse_value_from_blob (mis,
1790 g_variant_type_free (variant_type);
1791 if (message->body == NULL)
1797 /* no signature, this is only OK if the body is empty */
1798 if (message_body_len != 0)
1800 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
1803 G_IO_ERROR_INVALID_ARGUMENT,
1804 _("No signature header in message but the message body is %u bytes"),
1810 if (!validate_headers (message, error))
1812 g_prefix_error (error, _("Cannot deserialize message: "));
1819 g_object_unref (dis);
1820 g_object_unref (mis);
1828 if (message != NULL)
1829 g_object_unref (message);
1834 /* ---------------------------------------------------------------------------------------------------- */
1837 ensure_output_padding (GMemoryOutputStream *mos,
1838 GDataOutputStream *dos,
1842 gsize wanted_offset;
1843 gsize padding_needed;
1846 offset = g_memory_output_stream_get_data_size (mos);
1847 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1848 padding_needed = wanted_offset - offset;
1850 for (n = 0; n < padding_needed; n++)
1851 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1853 return padding_needed;
1856 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
1858 append_value_to_blob (GVariant *value,
1859 const GVariantType *type,
1860 GMemoryOutputStream *mos,
1861 GDataOutputStream *dos,
1862 gsize *out_padding_added,
1865 gsize padding_added;
1869 if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
1871 padding_added = ensure_output_padding (mos, dos, 4);
1874 gboolean v = g_variant_get_boolean (value);
1875 g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1878 else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1882 guint8 v = g_variant_get_byte (value);
1883 g_data_output_stream_put_byte (dos, v, NULL, NULL);
1886 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
1888 padding_added = ensure_output_padding (mos, dos, 2);
1891 gint16 v = g_variant_get_int16 (value);
1892 g_data_output_stream_put_int16 (dos, v, NULL, NULL);
1895 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
1897 padding_added = ensure_output_padding (mos, dos, 2);
1900 guint16 v = g_variant_get_uint16 (value);
1901 g_data_output_stream_put_uint16 (dos, v, NULL, NULL);
1904 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
1906 padding_added = ensure_output_padding (mos, dos, 4);
1909 gint32 v = g_variant_get_int32 (value);
1910 g_data_output_stream_put_int32 (dos, v, NULL, NULL);
1913 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
1915 padding_added = ensure_output_padding (mos, dos, 4);
1918 guint32 v = g_variant_get_uint32 (value);
1919 g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1922 else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
1924 padding_added = ensure_output_padding (mos, dos, 8);
1927 gint64 v = g_variant_get_int64 (value);
1928 g_data_output_stream_put_int64 (dos, v, NULL, NULL);
1931 else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
1933 padding_added = ensure_output_padding (mos, dos, 8);
1936 guint64 v = g_variant_get_uint64 (value);
1937 g_data_output_stream_put_uint64 (dos, v, NULL, NULL);
1940 else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
1942 padding_added = ensure_output_padding (mos, dos, 8);
1949 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1950 u.v_double = g_variant_get_double (value);
1951 g_data_output_stream_put_uint64 (dos, u.v_uint64, NULL, NULL);
1954 else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
1956 padding_added = ensure_output_padding (mos, dos, 4);
1962 v = g_variant_get_string (value, &len);
1963 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
1964 g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
1965 g_data_output_stream_put_string (dos, v, NULL, NULL);
1966 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1969 else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
1971 padding_added = ensure_output_padding (mos, dos, 4);
1975 const gchar *v = g_variant_get_string (value, &len);
1976 g_assert (g_variant_is_object_path (v));
1977 g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
1978 g_data_output_stream_put_string (dos, v, NULL, NULL);
1979 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1982 else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
1987 const gchar *v = g_variant_get_string (value, &len);
1988 g_assert (g_variant_is_signature (v));
1989 g_data_output_stream_put_byte (dos, len, NULL, NULL);
1990 g_data_output_stream_put_string (dos, v, NULL, NULL);
1991 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1994 else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
1996 padding_added = ensure_output_padding (mos, dos, 4);
1999 gint32 v = g_variant_get_handle (value);
2000 g_data_output_stream_put_int32 (dos, v, NULL, NULL);
2003 else if (g_variant_type_is_array (type))
2007 goffset array_len_offset;
2008 goffset array_payload_begin_offset;
2012 padding_added = ensure_output_padding (mos, dos, 4);
2015 /* array length - will be filled in later */
2016 array_len_offset = g_memory_output_stream_get_data_size (mos);
2017 g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2019 /* From the D-Bus spec:
2021 * "A UINT32 giving the length of the array data in bytes,
2022 * followed by alignment padding to the alignment boundary of
2023 * the array element type, followed by each array element. The
2024 * array length is from the end of the alignment padding to
2025 * the end of the last element, i.e. it does not include the
2026 * padding after the length, or any padding after the last
2029 * Thus, we need to count how much padding the first element
2030 * contributes and subtract that from the array length.
2032 array_payload_begin_offset = g_memory_output_stream_get_data_size (mos);
2034 if (g_variant_n_children (value) == 0)
2036 gsize padding_added_for_item;
2037 if (!append_value_to_blob (NULL,
2038 g_variant_type_element (type),
2041 &padding_added_for_item,
2044 array_payload_begin_offset += padding_added_for_item;
2050 g_variant_iter_init (&iter, value);
2051 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2053 gsize padding_added_for_item;
2054 if (!append_value_to_blob (item,
2055 g_variant_get_type (item),
2058 &padding_added_for_item,
2061 g_variant_unref (item);
2064 g_variant_unref (item);
2067 array_payload_begin_offset += padding_added_for_item;
2073 cur_offset = g_memory_output_stream_get_data_size (mos);
2075 array_len = cur_offset - array_payload_begin_offset;
2077 if (!g_seekable_seek (G_SEEKABLE (mos), array_len_offset, G_SEEK_SET, NULL, error))
2080 g_data_output_stream_put_uint32 (dos, array_len, NULL, NULL);
2082 if (!g_seekable_seek (G_SEEKABLE (mos), cur_offset, G_SEEK_SET, NULL, error))
2086 else if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2088 padding_added = ensure_output_padding (mos, dos, 8);
2093 g_variant_iter_init (&iter, value);
2094 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2096 if (!append_value_to_blob (item,
2097 g_variant_get_type (item),
2103 g_variant_unref (item);
2106 g_variant_unref (item);
2110 else if (g_variant_type_is_variant (type))
2115 const gchar *signature;
2116 child = g_variant_get_child_value (value, 0);
2117 signature = g_variant_get_type_string (child);
2118 g_data_output_stream_put_byte (dos, strlen (signature), NULL, NULL);
2119 g_data_output_stream_put_string (dos, signature, NULL, NULL);
2120 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
2121 if (!append_value_to_blob (child,
2122 g_variant_get_type (child),
2128 g_variant_unref (child);
2131 g_variant_unref (child);
2138 G_IO_ERROR_INVALID_ARGUMENT,
2139 _("Error serializing GVariant with type string `%s' to the D-Bus wire format"),
2140 g_variant_get_type_string (value));
2144 if (out_padding_added != NULL)
2145 *out_padding_added = padding_added;
2154 append_body_to_blob (GVariant *value,
2155 GMemoryOutputStream *mos,
2156 GDataOutputStream *dos,
2162 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2166 G_IO_ERROR_INVALID_ARGUMENT,
2167 "Expected a tuple for the body of the GDBusMessage.");
2171 g_variant_iter_init (&iter, value);
2172 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2174 if (!append_value_to_blob (item,
2175 g_variant_get_type (item),
2181 g_variant_unref (item);
2184 g_variant_unref (item);
2192 /* ---------------------------------------------------------------------------------------------------- */
2195 * g_dbus_message_to_blob:
2196 * @message: A #GDBusMessage.
2197 * @out_size: Return location for size of generated blob.
2198 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2199 * @error: Return location for error.
2201 * Serializes @message to a blob. The byte order returned by
2202 * g_dbus_message_get_byte_order() will be used.
2204 * Returns: A pointer to a valid binary D-Bus message of @out_size bytes
2205 * generated by @message or %NULL if @error is set. Free with g_free().
2210 g_dbus_message_to_blob (GDBusMessage *message,
2212 GDBusCapabilityFlags capabilities,
2215 GMemoryOutputStream *mos;
2216 GDataOutputStream *dos;
2219 GDataStreamByteOrder byte_order;
2220 goffset body_len_offset;
2221 goffset body_start_offset;
2223 GVariant *header_fields;
2224 GVariantBuilder builder;
2225 GHashTableIter hash_iter;
2227 GVariant *header_value;
2228 GVariant *signature;
2229 const gchar *signature_str;
2230 gint num_fds_in_message;
2231 gint num_fds_according_to_header;
2233 /* TODO: check against @capabilities */
2237 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2238 g_return_val_if_fail (out_size != NULL, NULL);
2239 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2241 mos = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (NULL, 0, g_realloc, g_free));
2242 dos = g_data_output_stream_new (G_OUTPUT_STREAM (mos));
2244 byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2245 switch (message->byte_order)
2247 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2248 byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2250 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2251 byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2254 g_data_output_stream_set_byte_order (dos, byte_order);
2257 g_data_output_stream_put_byte (dos, (guchar) message->byte_order, NULL, NULL);
2258 g_data_output_stream_put_byte (dos, message->type, NULL, NULL);
2259 g_data_output_stream_put_byte (dos, message->flags, NULL, NULL);
2260 g_data_output_stream_put_byte (dos, 1, NULL, NULL); /* major protocol version */
2261 body_len_offset = g_memory_output_stream_get_data_size (mos);
2262 /* body length - will be filled in later */
2263 g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2264 g_data_output_stream_put_uint32 (dos, message->serial, NULL, NULL);
2266 num_fds_in_message = 0;
2268 if (message->fd_list != NULL)
2269 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2271 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2272 if (num_fds_in_message != num_fds_according_to_header)
2276 G_IO_ERROR_INVALID_ARGUMENT,
2277 _("Message has %d fds but the header field indicates %d fds"),
2279 num_fds_according_to_header);
2283 if (!validate_headers (message, error))
2285 g_prefix_error (error, _("Cannot serialize message: "));
2289 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2290 g_hash_table_iter_init (&hash_iter, message->headers);
2291 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2293 g_variant_builder_add (&builder,
2295 (guchar) GPOINTER_TO_UINT (key),
2298 header_fields = g_variant_builder_end (&builder);
2300 if (!append_value_to_blob (header_fields,
2301 g_variant_get_type (header_fields),
2306 g_variant_unref (header_fields);
2309 g_variant_unref (header_fields);
2311 /* header size must be a multiple of 8 */
2312 ensure_output_padding (mos, dos, 8);
2314 body_start_offset = g_memory_output_stream_get_data_size (mos);
2316 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2317 signature_str = NULL;
2318 if (signature != NULL)
2319 signature_str = g_variant_get_string (signature, NULL);
2320 if (message->body != NULL)
2322 gchar *tupled_signature_str;
2323 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2324 if (signature == NULL)
2328 G_IO_ERROR_INVALID_ARGUMENT,
2329 _("Message body has signature `%s' but there is no signature header"),
2331 g_free (tupled_signature_str);
2334 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2338 G_IO_ERROR_INVALID_ARGUMENT,
2339 _("Message body has type signature `%s' but signature in the header field is `%s'"),
2340 tupled_signature_str, g_variant_get_type_string (message->body));
2341 g_free (tupled_signature_str);
2344 g_free (tupled_signature_str);
2345 if (!append_body_to_blob (message->body, mos, dos, error))
2350 if (signature != NULL && strlen (signature_str) > 0)
2354 G_IO_ERROR_INVALID_ARGUMENT,
2355 _("Message body is empty but signature in the header field is `(%s)'"),
2361 /* OK, we're done writing the message - set the body length */
2362 size = g_memory_output_stream_get_data_size (mos);
2363 body_size = size - body_start_offset;
2365 if (!g_seekable_seek (G_SEEKABLE (mos), body_len_offset, G_SEEK_SET, NULL, error))
2368 g_data_output_stream_put_uint32 (dos, body_size, NULL, NULL);
2370 if (!g_output_stream_close (G_OUTPUT_STREAM (dos), NULL, error))
2374 ret = g_memory_output_stream_steal_data (mos);
2377 g_object_unref (dos);
2378 g_object_unref (mos);
2383 /* ---------------------------------------------------------------------------------------------------- */
2386 get_uint32_header (GDBusMessage *message,
2387 GDBusMessageHeaderField header_field)
2393 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2394 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2395 ret = g_variant_get_uint32 (value);
2400 static const gchar *
2401 get_string_header (GDBusMessage *message,
2402 GDBusMessageHeaderField header_field)
2408 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2409 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2410 ret = g_variant_get_string (value, NULL);
2415 static const gchar *
2416 get_object_path_header (GDBusMessage *message,
2417 GDBusMessageHeaderField header_field)
2423 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2424 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2425 ret = g_variant_get_string (value, NULL);
2430 static const gchar *
2431 get_signature_header (GDBusMessage *message,
2432 GDBusMessageHeaderField header_field)
2438 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2439 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2440 ret = g_variant_get_string (value, NULL);
2445 /* ---------------------------------------------------------------------------------------------------- */
2448 set_uint32_header (GDBusMessage *message,
2449 GDBusMessageHeaderField header_field,
2452 g_dbus_message_set_header (message,
2454 g_variant_new_uint32 (value));
2458 set_string_header (GDBusMessage *message,
2459 GDBusMessageHeaderField header_field,
2462 g_dbus_message_set_header (message,
2464 value == NULL ? NULL : g_variant_new_string (value));
2468 set_object_path_header (GDBusMessage *message,
2469 GDBusMessageHeaderField header_field,
2472 g_dbus_message_set_header (message,
2474 value == NULL ? NULL : g_variant_new_object_path (value));
2478 set_signature_header (GDBusMessage *message,
2479 GDBusMessageHeaderField header_field,
2482 g_dbus_message_set_header (message,
2484 value == NULL ? NULL : g_variant_new_signature (value));
2487 /* ---------------------------------------------------------------------------------------------------- */
2490 * g_dbus_message_get_reply_serial:
2491 * @message: A #GDBusMessage.
2493 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2495 * Returns: The value.
2500 g_dbus_message_get_reply_serial (GDBusMessage *message)
2502 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2503 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2507 * g_dbus_message_set_reply_serial:
2508 * @message: A #GDBusMessage.
2509 * @value: The value to set.
2511 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2516 g_dbus_message_set_reply_serial (GDBusMessage *message,
2519 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2520 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2523 /* ---------------------------------------------------------------------------------------------------- */
2526 * g_dbus_message_get_interface:
2527 * @message: A #GDBusMessage.
2529 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2531 * Returns: The value.
2536 g_dbus_message_get_interface (GDBusMessage *message)
2538 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2539 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2543 * g_dbus_message_set_interface:
2544 * @message: A #GDBusMessage.
2545 * @value: The value to set.
2547 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2552 g_dbus_message_set_interface (GDBusMessage *message,
2555 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2556 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2557 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2560 /* ---------------------------------------------------------------------------------------------------- */
2563 * g_dbus_message_get_member:
2564 * @message: A #GDBusMessage.
2566 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2568 * Returns: The value.
2573 g_dbus_message_get_member (GDBusMessage *message)
2575 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2576 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2580 * g_dbus_message_set_member:
2581 * @message: A #GDBusMessage.
2582 * @value: The value to set.
2584 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2589 g_dbus_message_set_member (GDBusMessage *message,
2592 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2593 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2594 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2597 /* ---------------------------------------------------------------------------------------------------- */
2600 * g_dbus_message_get_path:
2601 * @message: A #GDBusMessage.
2603 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2605 * Returns: The value.
2610 g_dbus_message_get_path (GDBusMessage *message)
2612 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2613 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2617 * g_dbus_message_set_path:
2618 * @message: A #GDBusMessage.
2619 * @value: The value to set.
2621 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2626 g_dbus_message_set_path (GDBusMessage *message,
2629 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2630 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2631 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2634 /* ---------------------------------------------------------------------------------------------------- */
2637 * g_dbus_message_get_sender:
2638 * @message: A #GDBusMessage.
2640 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2642 * Returns: The value.
2647 g_dbus_message_get_sender (GDBusMessage *message)
2649 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2650 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
2654 * g_dbus_message_set_sender:
2655 * @message: A #GDBusMessage.
2656 * @value: The value to set.
2658 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2663 g_dbus_message_set_sender (GDBusMessage *message,
2666 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2667 g_return_if_fail (value == NULL || g_dbus_is_name (value));
2668 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
2671 /* ---------------------------------------------------------------------------------------------------- */
2674 * g_dbus_message_get_destination:
2675 * @message: A #GDBusMessage.
2677 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2679 * Returns: The value.
2684 g_dbus_message_get_destination (GDBusMessage *message)
2686 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2687 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
2691 * g_dbus_message_set_destination:
2692 * @message: A #GDBusMessage.
2693 * @value: The value to set.
2695 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2700 g_dbus_message_set_destination (GDBusMessage *message,
2703 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2704 g_return_if_fail (value == NULL || g_dbus_is_name (value));
2705 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
2708 /* ---------------------------------------------------------------------------------------------------- */
2711 * g_dbus_message_get_error_name:
2712 * @message: A #GDBusMessage.
2714 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2716 * Returns: The value.
2721 g_dbus_message_get_error_name (GDBusMessage *message)
2723 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2724 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
2728 * g_dbus_message_set_error_name:
2729 * @message: A #GDBusMessage.
2730 * @value: The value to set.
2732 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2737 g_dbus_message_set_error_name (GDBusMessage *message,
2740 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2741 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2742 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
2745 /* ---------------------------------------------------------------------------------------------------- */
2748 * g_dbus_message_get_signature:
2749 * @message: A #GDBusMessage.
2751 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2753 * Returns: The value.
2758 g_dbus_message_get_signature (GDBusMessage *message)
2761 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2762 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2769 * g_dbus_message_set_signature:
2770 * @message: A #GDBusMessage.
2771 * @value: The value to set.
2773 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2778 g_dbus_message_set_signature (GDBusMessage *message,
2781 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2782 g_return_if_fail (value == NULL || g_variant_is_signature (value));
2783 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
2786 /* ---------------------------------------------------------------------------------------------------- */
2789 * g_dbus_message_get_arg0:
2790 * @message: A #GDBusMessage.
2792 * Convenience to get the first item in the body of @message.
2794 * Returns: The string item or %NULL if the first item in the body of
2795 * @message is not a string.
2800 g_dbus_message_get_arg0 (GDBusMessage *message)
2804 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2808 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
2811 item = g_variant_get_child_value (message->body, 0);
2812 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
2813 ret = g_variant_get_string (item, NULL);
2814 g_variant_unref (item);
2820 /* ---------------------------------------------------------------------------------------------------- */
2823 * g_dbus_message_get_num_unix_fds:
2824 * @message: A #GDBusMessage.
2826 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2828 * Returns: The value.
2833 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
2835 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2836 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
2840 * g_dbus_message_set_num_unix_fds:
2841 * @message: A #GDBusMessage.
2842 * @value: The value to set.
2844 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2849 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
2852 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2853 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
2856 /* ---------------------------------------------------------------------------------------------------- */
2859 * g_dbus_message_to_gerror:
2860 * @message: A #GDBusMessage.
2861 * @error: The #GError to set.
2863 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
2864 * nothing and returns %FALSE.
2866 * Otherwise this method encodes the error in @message as a #GError
2867 * using g_dbus_error_set_dbus_error() using the information in the
2868 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
2869 * well as the first string item in @message's body.
2871 * Returns: %TRUE if @error was set, %FALSE otherwise.
2876 g_dbus_message_to_gerror (GDBusMessage *message,
2880 const gchar *error_name;
2882 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
2885 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
2888 error_name = g_dbus_message_get_error_name (message);
2889 if (error_name != NULL)
2893 body = g_dbus_message_get_body (message);
2895 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
2897 const gchar *error_message;
2898 g_variant_get (body, "(&s)", &error_message);
2899 g_dbus_error_set_dbus_error (error,
2906 /* these two situations are valid, yet pretty rare */
2909 g_dbus_error_set_dbus_error (error,
2912 _("Error return with body of type `%s'"),
2913 g_variant_get_type_string (body));
2917 g_dbus_error_set_dbus_error (error,
2920 _("Error return with empty body"));
2926 /* TOOD: this shouldn't happen - should check this at message serialization
2927 * time and disconnect the peer.
2932 "Error return without error-name header!");
2941 /* ---------------------------------------------------------------------------------------------------- */
2944 flags_to_string (GType flags_type, guint value)
2950 klass = g_type_class_ref (flags_type);
2951 s = g_string_new (NULL);
2952 for (n = 0; n < 32; n++)
2954 if ((value & (1<<n)) != 0)
2956 GFlagsValue *flags_value;
2957 flags_value = g_flags_get_first_value (klass, (1<<n));
2959 g_string_append_c (s, ',');
2960 if (flags_value != NULL)
2961 g_string_append (s, flags_value->value_nick);
2963 g_string_append_printf (s, "unknown (bit %d)", n);
2967 g_string_append (s, "none");
2968 g_type_class_unref (klass);
2969 return g_string_free (s, FALSE);
2973 _sort_keys_func (gconstpointer a,
2979 ia = GPOINTER_TO_INT (a);
2980 ib = GPOINTER_TO_INT (b);
2986 * g_dbus_message_print:
2987 * @message: A #GDBusMessage.
2988 * @indent: Indentation level.
2990 * Produces a human-readable multi-line description of @message.
2992 * The contents of the description has no ABI guarantees, the contents
2993 * and formatting is subject to change at any time. Typical output
2994 * looks something like this:
3001 * path -> objectpath '/org/gtk/GDBus/TestObject'
3002 * interface -> 'org.gtk.GDBus.TestInterface'
3003 * member -> 'GimmeStdout'
3004 * destination -> ':1.146'
3006 * UNIX File Descriptors:
3011 * Type: method-return
3012 * Flags: no-reply-expected
3016 * reply-serial -> uint32 4
3017 * destination -> ':1.159'
3018 * sender -> ':1.146'
3019 * num-unix-fds -> uint32 1
3021 * UNIX File Descriptors:
3022 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3025 * Returns: A string that should be freed with g_free().
3030 g_dbus_message_print (GDBusMessage *message,
3038 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3040 str = g_string_new (NULL);
3042 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3043 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3045 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3046 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3048 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3049 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3051 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3052 keys = g_hash_table_get_keys (message->headers);
3053 keys = g_list_sort (keys, _sort_keys_func);
3056 for (l = keys; l != NULL; l = l->next)
3058 gint key = GPOINTER_TO_INT (l->data);
3062 value = g_hash_table_lookup (message->headers, l->data);
3063 g_assert (value != NULL);
3065 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3066 value_str = g_variant_print (value, TRUE);
3067 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3074 g_string_append_printf (str, "%*s (none)\n", indent, "");
3076 g_string_append_printf (str, "%*sBody: ", indent, "");
3077 if (message->body != NULL)
3079 g_variant_print_string (message->body,
3085 g_string_append (str, "()");
3087 g_string_append (str, "\n");
3089 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3090 if (message->fd_list != NULL)
3096 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3099 for (n = 0; n < num_fds; n++)
3102 struct stat statbuf;
3103 fs = g_string_new (NULL);
3104 if (fstat (fds[n], &statbuf) == 0)
3106 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3107 major (statbuf.st_dev), minor (statbuf.st_dev));
3108 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3110 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3111 (guint64) statbuf.st_ino);
3112 g_string_append_printf (fs, "%s" "uid=%d", fs->len > 0 ? "," : "",
3114 g_string_append_printf (fs, "%s" "gid=%d", fs->len > 0 ? "," : "",
3116 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3117 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3118 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3119 (guint64) statbuf.st_size);
3120 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3121 (guint64) statbuf.st_atime);
3122 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3123 (guint64) statbuf.st_mtime);
3124 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3125 (guint64) statbuf.st_ctime);
3129 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3131 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3132 g_string_free (fs, TRUE);
3137 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3142 g_string_append_printf (str, "%*s (none)\n", indent, "");
3146 return g_string_free (str, FALSE);
3150 * g_dbus_message_get_locked:
3151 * @message: A #GDBusMessage.
3153 * Checks whether @message is locked. To monitor changes to this
3154 * value, conncet to the #GObject::notify signal to listen for changes
3155 * on the #GDBusMessage:locked property.
3157 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3162 g_dbus_message_get_locked (GDBusMessage *message)
3164 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3165 return message->locked;
3169 * g_dbus_message_lock:
3170 * @message: A #GDBusMessage.
3172 * If @message is locked, does nothing. Otherwise locks the message.
3177 g_dbus_message_lock (GDBusMessage *message)
3179 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3181 if (message->locked)
3184 message->locked = TRUE;
3185 g_object_notify (G_OBJECT (message), "locked");
3192 * g_dbus_message_copy:
3193 * @message: A #GDBusMessage.
3194 * @error: Return location for error or %NULL.
3196 * Copies @message. The copy is a deep copy and the returned
3197 * #GDBusMessage is completely identical except that it is guaranteed
3200 * This operation can fail if e.g. @message contains file descriptors
3201 * and the per-process or system-wide open files limit is reached.
3203 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3204 * Free with g_object_unref().
3209 g_dbus_message_copy (GDBusMessage *message,
3213 GHashTableIter iter;
3214 gpointer header_key;
3215 GVariant *header_value;
3217 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3218 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3220 ret = g_dbus_message_new ();
3221 ret->type = message->type;
3222 ret->flags = message->flags;
3223 ret->byte_order = message->byte_order;
3224 ret->major_protocol_version = message->major_protocol_version;
3225 ret->serial = message->serial;
3228 if (message->fd_list != NULL)
3234 ret->fd_list = g_unix_fd_list_new ();
3235 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3236 for (n = 0; n < num_fds; n++)
3238 if (g_unix_fd_list_append (ret->fd_list,
3242 g_object_unref (ret);
3250 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3251 * to just ref (as opposed to deep-copying) the GVariant instances
3253 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3254 g_hash_table_iter_init (&iter, message->headers);
3255 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3256 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));