gio/gdbusmessage.c

   1 /* GDBus - GLib D-Bus Library
   2  *
   3  * Copyright (C) 2008-2010 Red Hat, Inc.
   4  *
   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.
   9  *
  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.
  14  *
  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.
  19  *
  20  * Author: David Zeuthen <davidz@redhat.com>
  21  */
  22
  23 /* Uncomment to debug serializer code */
  24 /* #define DEBUG_SERIALIZER */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35
  36 #include "gdbusutils.h"
  37 #include "gdbusmessage.h"
  38 #include "gdbuserror.h"
  39 #include "gioenumtypes.h"
  40 #include "ginputstream.h"
  41 #include "gdatainputstream.h"
  42 #include "gmemoryinputstream.h"
  43 #include "goutputstream.h"
  44 #include "gdataoutputstream.h"
  45 #include "gmemoryoutputstream.h"
  46 #include "gseekable.h"
  47 #include "gioerror.h"
  48 #include "gdbusprivate.h"
  49
  50 #ifdef G_OS_UNIX
  51 #include "gunixfdlist.h"
  52 #endif
  53
  54 #include "glibintl.h"
  55
  56 /**
  57  * SECTION:gdbusmessage
  58  * @short_description: D-Bus Message
  59  * @include: gio/gio.h
  60  *
  61  * A type for representing D-Bus messages that can be sent or received
  62  * on a #GDBusConnection.
  63  */
  64
  65 typedef struct _GDBusMessageClass GDBusMessageClass;
  66
  67 /**
  68  * GDBusMessageClass:
  69  *
  70  * Class structure for #GDBusMessage.
  71  *
  72  * Since: 2.26
  73  */
  74 struct _GDBusMessageClass
  75 {
  76   /*< private >*/
  77   GObjectClass parent_class;
  78 };
  79
  80 /**
  81  * GDBusMessage:
  82  *
  83  * The #GDBusMessage structure contains only private data and should
  84  * only be accessed using the provided API.
  85  *
  86  * Since: 2.26
  87  */
  88 struct _GDBusMessage
  89 {
  90   /*< private >*/
  91   GObject parent_instance;
  92
  93   GDBusMessageType type;
  94   GDBusMessageFlags flags;
  95   gboolean locked;
  96   GDBusMessageByteOrder byte_order;
  97   guchar major_protocol_version;
  98   guint32 serial;
  99   GHashTable *headers;
 100   GVariant *body;
 101 #ifdef G_OS_UNIX
 102   GUnixFDList *fd_list;
 103 #endif
 104 };
 105
 106 enum
 107 {
 108   PROP_0,
 109   PROP_LOCKED
 110 };
 111
 112 G_DEFINE_TYPE (GDBusMessage, g_dbus_message, G_TYPE_OBJECT);
 113
 114 static void
 115 g_dbus_message_finalize (GObject *object)
 116 {
 117   GDBusMessage *message = G_DBUS_MESSAGE (object);
 118
 119   if (message->headers != NULL)
 120     g_hash_table_unref (message->headers);
 121   if (message->body != NULL)
 122     g_variant_unref (message->body);
 123 #ifdef G_OS_UNIX
 124   if (message->fd_list != NULL)
 125     g_object_unref (message->fd_list);
 126 #endif
 127
 128   if (G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize != NULL)
 129     G_OBJECT_CLASS (g_dbus_message_parent_class)->finalize (object);
 130 }
 131
 132 static void
 133 g_dbus_message_get_property (GObject    *object,
 134                              guint       prop_id,
 135                              GValue     *value,
 136                              GParamSpec *pspec)
 137 {
 138   GDBusMessage *message = G_DBUS_MESSAGE (object);
 139
 140   switch (prop_id)
 141     {
 142     case PROP_LOCKED:
 143       g_value_set_boolean (value, g_dbus_message_get_locked (message));
 144       break;
 145
 146     default:
 147       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 148       break;
 149     }
 150 }
 151
 152 static void
 153 g_dbus_message_class_init (GDBusMessageClass *klass)
 154 {
 155   GObjectClass *gobject_class;
 156
 157   gobject_class = G_OBJECT_CLASS (klass);
 158   gobject_class->finalize     = g_dbus_message_finalize;
 159   gobject_class->get_property = g_dbus_message_get_property;
 160
 161   /**
 162    * GDBusConnection:locked:
 163    *
 164    * A boolean specifying whether the message is locked.
 165    *
 166    * Since: 2.26
 167    */
 168   g_object_class_install_property (gobject_class,
 169                                    PROP_LOCKED,
 170                                    g_param_spec_boolean ("locked",
 171                                                          P_("Locked"),
 172                                                          P_("Whether the message is locked"),
 173                                                          FALSE,
 174                                                          G_PARAM_READABLE |
 175                                                          G_PARAM_STATIC_NAME |
 176                                                          G_PARAM_STATIC_BLURB |
 177                                                          G_PARAM_STATIC_NICK));
 178 }
 179
 180 static void
 181 g_dbus_message_init (GDBusMessage *message)
 182 {
 183   /* Any D-Bus implementation is supposed to handle both Big and
 184    * Little Endian encodings and the Endianness is part of the D-Bus
 185    * message - we prefer to use Big Endian (since it's Network Byte
 186    * Order and just easier to read for humans) but if the machine is
 187    * Little Endian we use that for performance reasons.
 188    */
 189 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
 190   message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
 191 #else
 192   /* this could also be G_PDP_ENDIAN */
 193   message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
 194 #endif
 195   message->headers = g_hash_table_new_full (g_direct_hash,
 196                                             g_direct_equal,
 197                                             NULL,
 198                                             (GDestroyNotify) g_variant_unref);
 199 }
 200
 201 /**
 202  * g_dbus_message_new:
 203  *
 204  * Creates a new empty #GDBusMessage.
 205  *
 206  * Returns: A #GDBusMessage. Free with g_object_unref().
 207  *
 208  * Since: 2.26
 209  */
 210 GDBusMessage *
 211 g_dbus_message_new (void)
 212 {
 213   return g_object_new (G_TYPE_DBUS_MESSAGE, NULL);
 214 }
 215
 216 /**
 217  * g_dbus_message_new_method_call:
 218  * @name: A valid D-Bus name or %NULL.
 219  * @path: A valid object path.
 220  * @interface_: A valid D-Bus interface name or %NULL.
 221  * @method: A valid method name.
 222  *
 223  * Creates a new #GDBusMessage for a method call.
 224  *
 225  * Returns: A #GDBusMessage. Free with g_object_unref().
 226  *
 227  * Since: 2.26
 228  */
 229 GDBusMessage *
 230 g_dbus_message_new_method_call (const gchar *name,
 231                                 const gchar *path,
 232                                 const gchar *interface_,
 233                                 const gchar *method)
 234 {
 235   GDBusMessage *message;
 236
 237   g_return_val_if_fail (name == NULL || g_dbus_is_name (name), NULL);
 238   g_return_val_if_fail (g_variant_is_object_path (path), NULL);
 239   g_return_val_if_fail (g_dbus_is_member_name (method), NULL);
 240   g_return_val_if_fail (interface_ == NULL || g_dbus_is_interface_name (interface_), NULL);
 241
 242   message = g_dbus_message_new ();
 243   message->type = G_DBUS_MESSAGE_TYPE_METHOD_CALL;
 244
 245   if (name != NULL)
 246     g_dbus_message_set_destination (message, name);
 247   g_dbus_message_set_path (message, path);
 248   g_dbus_message_set_member (message, method);
 249   if (interface_ != NULL)
 250     g_dbus_message_set_interface (message, interface_);
 251
 252   return message;
 253 }
 254
 255 /**
 256  * g_dbus_message_new_signal:
 257  * @path: A valid object path.
 258  * @interface_: A valid D-Bus interface name.
 259  * @signal: A valid signal name.
 260  *
 261  * Creates a new #GDBusMessage for a signal emission.
 262  *
 263  * Returns: A #GDBusMessage. Free with g_object_unref().
 264  *
 265  * Since: 2.26
 266  */
 267 GDBusMessage *
 268 g_dbus_message_new_signal (const gchar  *path,
 269                            const gchar  *interface_,
 270                            const gchar  *signal)
 271 {
 272   GDBusMessage *message;
 273
 274   g_return_val_if_fail (g_variant_is_object_path (path), NULL);
 275   g_return_val_if_fail (g_dbus_is_member_name (signal), NULL);
 276   g_return_val_if_fail (g_dbus_is_interface_name (interface_), NULL);
 277
 278   message = g_dbus_message_new ();
 279   message->type = G_DBUS_MESSAGE_TYPE_SIGNAL;
 280   message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
 281
 282   g_dbus_message_set_path (message, path);
 283   g_dbus_message_set_member (message, signal);
 284   g_dbus_message_set_interface (message, interface_);
 285
 286   return message;
 287 }
 288
 289
 290 /**
 291  * g_dbus_message_new_method_reply:
 292  * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
 293  * create a reply message to.
 294  *
 295  * Creates a new #GDBusMessage that is a reply to @method_call_message.
 296  *
 297  * Returns: A #GDBusMessage. Free with g_object_unref().
 298  *
 299  * Since: 2.26
 300  */
 301 GDBusMessage *
 302 g_dbus_message_new_method_reply (GDBusMessage *method_call_message)
 303 {
 304   GDBusMessage *message;
 305   const gchar *sender;
 306
 307   g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
 308   g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
 309   g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
 310
 311   message = g_dbus_message_new ();
 312   message->type = G_DBUS_MESSAGE_TYPE_METHOD_RETURN;
 313   message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
 314   /* reply with same endianness */
 315   message->byte_order = method_call_message->byte_order;
 316
 317   g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
 318   sender = g_dbus_message_get_sender (method_call_message);
 319   if (sender != NULL)
 320     g_dbus_message_set_destination (message, sender);
 321
 322   return message;
 323 }
 324
 325 /**
 326  * g_dbus_message_new_method_error:
 327  * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
 328  * create a reply message to.
 329  * @error_name: A valid D-Bus error name.
 330  * @error_message_format: The D-Bus error message in a printf() format.
 331  * @...: Arguments for @error_message_format.
 332  *
 333  * Creates a new #GDBusMessage that is an error reply to @method_call_message.
 334  *
 335  * Returns: A #GDBusMessage. Free with g_object_unref().
 336  *
 337  * Since: 2.26
 338  */
 339 GDBusMessage *
 340 g_dbus_message_new_method_error (GDBusMessage             *method_call_message,
 341                                  const gchar              *error_name,
 342                                  const gchar              *error_message_format,
 343                                  ...)
 344 {
 345   GDBusMessage *ret;
 346   va_list var_args;
 347
 348   va_start (var_args, error_message_format);
 349   ret = g_dbus_message_new_method_error_valist (method_call_message,
 350                                                 error_name,
 351                                                 error_message_format,
 352                                                 var_args);
 353   va_end (var_args);
 354
 355   return ret;
 356 }
 357
 358 /**
 359  * g_dbus_message_new_method_error_literal:
 360  * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
 361  * create a reply message to.
 362  * @error_name: A valid D-Bus error name.
 363  * @error_message: The D-Bus error message.
 364  *
 365  * Creates a new #GDBusMessage that is an error reply to @method_call_message.
 366  *
 367  * Returns: A #GDBusMessage. Free with g_object_unref().
 368  *
 369  * Since: 2.26
 370  */
 371 GDBusMessage *
 372 g_dbus_message_new_method_error_literal (GDBusMessage  *method_call_message,
 373                                          const gchar   *error_name,
 374                                          const gchar   *error_message)
 375 {
 376   GDBusMessage *message;
 377   const gchar *sender;
 378
 379   g_return_val_if_fail (G_IS_DBUS_MESSAGE (method_call_message), NULL);
 380   g_return_val_if_fail (g_dbus_message_get_message_type (method_call_message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL, NULL);
 381   g_return_val_if_fail (g_dbus_message_get_serial (method_call_message) != 0, NULL);
 382   g_return_val_if_fail (g_dbus_is_name (error_name), NULL);
 383   g_return_val_if_fail (error_message != NULL, NULL);
 384
 385   message = g_dbus_message_new ();
 386   message->type = G_DBUS_MESSAGE_TYPE_ERROR;
 387   message->flags = G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED;
 388   /* reply with same endianness */
 389   message->byte_order = method_call_message->byte_order;
 390
 391   g_dbus_message_set_reply_serial (message, g_dbus_message_get_serial (method_call_message));
 392   g_dbus_message_set_error_name (message, error_name);
 393   g_dbus_message_set_body (message, g_variant_new ("(s)", error_message));
 394
 395   sender = g_dbus_message_get_sender (method_call_message);
 396   if (sender != NULL)
 397     g_dbus_message_set_destination (message, sender);
 398
 399   return message;
 400 }
 401
 402 /**
 403  * g_dbus_message_new_method_error_valist:
 404  * @method_call_message: A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to
 405  * create a reply message to.
 406  * @error_name: A valid D-Bus error name.
 407  * @error_message_format: The D-Bus error message in a printf() format.
 408  * @var_args: Arguments for @error_message_format.
 409  *
 410  * Like g_dbus_message_new_method_error() but intended for language bindings.
 411  *
 412  * Returns: A #GDBusMessage. Free with g_object_unref().
 413  *
 414  * Since: 2.26
 415  */
 416 GDBusMessage *
 417 g_dbus_message_new_method_error_valist (GDBusMessage             *method_call_message,
 418                                         const gchar              *error_name,
 419                                         const gchar              *error_message_format,
 420                                         va_list                   var_args)
 421 {
 422   GDBusMessage *ret;
 423   gchar *error_message;
 424   error_message = g_strdup_vprintf (error_message_format, var_args);
 425   ret = g_dbus_message_new_method_error_literal (method_call_message,
 426                                                  error_name,
 427                                                  error_message);
 428   g_free (error_message);
 429   return ret;
 430 }
 431
 432 /* ---------------------------------------------------------------------------------------------------- */
 433
 434 /**
 435  * g_dbus_message_get_byte_order:
 436  * @message: A #GDBusMessage.
 437  *
 438  * Gets the byte order of @message.
 439  *
 440  * Returns: The byte order.
 441  */
 442 GDBusMessageByteOrder
 443 g_dbus_message_get_byte_order (GDBusMessage *message)
 444 {
 445   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), (GDBusMessageByteOrder) 0);
 446   return message->byte_order;
 447 }
 448
 449 /**
 450  * g_dbus_message_set_byte_order:
 451  * @message: A #GDBusMessage.
 452  * @byte_order: The byte order.
 453  *
 454  * Sets the byte order of @message.
 455  */
 456 void
 457 g_dbus_message_set_byte_order (GDBusMessage          *message,
 458                                GDBusMessageByteOrder  byte_order)
 459 {
 460   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 461
 462   if (message->locked)
 463     {
 464       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 465       return;
 466     }
 467
 468   message->byte_order = byte_order;
 469 }
 470
 471 /* ---------------------------------------------------------------------------------------------------- */
 472
 473 /* TODO: need GI annotations to specify that any guchar value goes for the type */
 474
 475 /**
 476  * g_dbus_message_get_message_type:
 477  * @message: A #GDBusMessage.
 478  *
 479  * Gets the type of @message.
 480  *
 481  * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
 482  *
 483  * Since: 2.26
 484  */
 485 GDBusMessageType
 486 g_dbus_message_get_message_type (GDBusMessage  *message)
 487 {
 488   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_TYPE_INVALID);
 489   return message->type;
 490 }
 491
 492 /**
 493  * g_dbus_message_set_message_type:
 494  * @message: A #GDBusMessage.
 495  * @type: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
 496  *
 497  * Sets @message to be of @type.
 498  *
 499  * Since: 2.26
 500  */
 501 void
 502 g_dbus_message_set_message_type (GDBusMessage      *message,
 503                                  GDBusMessageType   type)
 504 {
 505   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 506   g_return_if_fail (type >=0 && type < 256);
 507
 508   if (message->locked)
 509     {
 510       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 511       return;
 512     }
 513
 514   message->type = type;
 515 }
 516
 517 /* ---------------------------------------------------------------------------------------------------- */
 518
 519 /* TODO: need GI annotations to specify that any guchar value goes for flags */
 520
 521 /**
 522  * g_dbus_message_get_flags:
 523  * @message: A #GDBusMessage.
 524  *
 525  * Gets the flags for @message.
 526  *
 527  * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
 528  *
 529  * Since: 2.26
 530  */
 531 GDBusMessageFlags
 532 g_dbus_message_get_flags (GDBusMessage  *message)
 533 {
 534   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), G_DBUS_MESSAGE_FLAGS_NONE);
 535   return message->flags;
 536 }
 537
 538 /**
 539  * g_dbus_message_set_flags:
 540  * @message: A #GDBusMessage.
 541  * @flags: Flags for @message that are set (typically values from the #GDBusMessageFlags
 542  * enumeration bitwise ORed together).
 543  *
 544  * Sets the flags to set on @message.
 545  *
 546  * Since: 2.26
 547  */
 548 void
 549 g_dbus_message_set_flags (GDBusMessage       *message,
 550                           GDBusMessageFlags   flags)
 551 {
 552   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 553   g_return_if_fail (flags >=0 && flags < 256);
 554
 555   if (message->locked)
 556     {
 557       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 558       return;
 559     }
 560
 561   message->flags = flags;
 562 }
 563
 564 /* ---------------------------------------------------------------------------------------------------- */
 565
 566 /**
 567  * g_dbus_message_get_serial:
 568  * @message: A #GDBusMessage.
 569  *
 570  * Gets the serial for @message.
 571  *
 572  * Returns: A #guint32.
 573  *
 574  * Since: 2.26
 575  */
 576 guint32
 577 g_dbus_message_get_serial (GDBusMessage *message)
 578 {
 579   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
 580   return message->serial;
 581 }
 582
 583 /**
 584  * g_dbus_message_set_serial:
 585  * @message: A #GDBusMessage.
 586  * @serial: A #guint32.
 587  *
 588  * Sets the serial for @message.
 589  *
 590  * Since: 2.26
 591  */
 592 void
 593 g_dbus_message_set_serial (GDBusMessage  *message,
 594                            guint32        serial)
 595 {
 596   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 597
 598   if (message->locked)
 599     {
 600       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 601       return;
 602     }
 603
 604   message->serial = serial;
 605 }
 606
 607 /* ---------------------------------------------------------------------------------------------------- */
 608
 609 /* TODO: need GI annotations to specify that any guchar value goes for header_field */
 610
 611 /**
 612  * g_dbus_message_get_header:
 613  * @message: A #GDBusMessage.
 614  * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
 615  *
 616  * Gets a header field on @message.
 617  *
 618  * Returns: A #GVariant with the value if the header was found, %NULL
 619  * otherwise. Do not free, it is owned by @message.
 620  *
 621  * Since: 2.26
 622  */
 623 GVariant *
 624 g_dbus_message_get_header (GDBusMessage             *message,
 625                            GDBusMessageHeaderField   header_field)
 626 {
 627   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
 628   g_return_val_if_fail (header_field >=0 && header_field < 256, NULL);
 629   return g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
 630 }
 631
 632 /**
 633  * g_dbus_message_set_header:
 634  * @message: A #GDBusMessage.
 635  * @header_field: A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
 636  * @value: A #GVariant to set the header field or %NULL to clear the header field.
 637  *
 638  * Sets a header field on @message.
 639  *
 640  * If @value is floating, @message assumes ownership of @value.
 641  *
 642  * Since: 2.26
 643  */
 644 void
 645 g_dbus_message_set_header (GDBusMessage             *message,
 646                            GDBusMessageHeaderField   header_field,
 647                            GVariant                 *value)
 648 {
 649   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 650   g_return_if_fail (header_field >=0 && header_field < 256);
 651
 652   if (message->locked)
 653     {
 654       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 655       return;
 656     }
 657
 658   if (value == NULL)
 659     {
 660       g_hash_table_remove (message->headers, GUINT_TO_POINTER (header_field));
 661     }
 662   else
 663     {
 664       g_hash_table_insert (message->headers, GUINT_TO_POINTER (header_field), g_variant_ref_sink (value));
 665     }
 666 }
 667
 668 /**
 669  * g_dbus_message_get_header_fields:
 670  * @message: A #GDBusMessage.
 671  *
 672  * Gets an array of all header fields on @message that are set.
 673  *
 674  * Returns: An array of header fields terminated by
 675  * %G_DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element is a
 676  * #guchar. Free with g_free().
 677  *
 678  * Since: 2.26
 679  */
 680 guchar *
 681 g_dbus_message_get_header_fields (GDBusMessage  *message)
 682 {
 683   GList *keys;
 684   guchar *ret;
 685   guint num_keys;
 686   GList *l;
 687   guint n;
 688
 689   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
 690
 691   keys = g_hash_table_get_keys (message->headers);
 692   num_keys = g_list_length (keys);
 693   ret = g_new (guchar, num_keys + 1);
 694   for (l = keys, n = 0; l != NULL; l = l->next, n++)
 695     ret[n] = GPOINTER_TO_UINT (l->data);
 696   g_assert (n == num_keys);
 697   ret[n] = G_DBUS_MESSAGE_HEADER_FIELD_INVALID;
 698   g_list_free (keys);
 699
 700   return ret;
 701 }
 702
 703 /* ---------------------------------------------------------------------------------------------------- */
 704
 705 /**
 706  * g_dbus_message_get_body:
 707  * @message: A #GDBusMessage.
 708  *
 709  * Gets the body of a message.
 710  *
 711  * Returns: A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
 712  *
 713  * Since: 2.26
 714  */
 715 GVariant *
 716 g_dbus_message_get_body (GDBusMessage  *message)
 717 {
 718   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
 719   return message->body;
 720 }
 721
 722 /**
 723  * g_dbus_message_set_body:
 724  * @message: A #GDBusMessage.
 725  * @body: Either %NULL or a #GVariant that is a tuple.
 726  *
 727  * Sets the body @message. As a side-effect the
 728  * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
 729  * type string of @body (or cleared if @body is %NULL).
 730  *
 731  * If @body is floating, @message assumes ownership of @body.
 732  *
 733  * Since: 2.26
 734  */
 735 void
 736 g_dbus_message_set_body (GDBusMessage  *message,
 737                          GVariant      *body)
 738 {
 739   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 740   g_return_if_fail ((body == NULL) || g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE));
 741
 742   if (message->locked)
 743     {
 744       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 745       return;
 746     }
 747
 748   if (message->body != NULL)
 749     g_variant_unref (message->body);
 750   if (body == NULL)
 751     {
 752       message->body = NULL;
 753       g_dbus_message_set_signature (message, NULL);
 754     }
 755   else
 756     {
 757       const gchar *type_string;
 758       gsize type_string_len;
 759       gchar *signature;
 760
 761       message->body = g_variant_ref_sink (body);
 762
 763       type_string = g_variant_get_type_string (body);
 764       type_string_len = strlen (type_string);
 765       g_assert (type_string_len >= 2);
 766       signature = g_strndup (type_string + 1, type_string_len - 2);
 767       g_dbus_message_set_signature (message, signature);
 768       g_free (signature);
 769     }
 770 }
 771
 772 /* ---------------------------------------------------------------------------------------------------- */
 773
 774 #ifdef G_OS_UNIX
 775 /**
 776  * g_dbus_message_get_unix_fd_list:
 777  * @message: A #GDBusMessage.
 778  *
 779  * Gets the UNIX file descriptors associated with @message, if any.
 780  *
 781  * This method is only available on UNIX.
 782  *
 783  * Returns: A #GUnixFDList or %NULL if no file descriptors are
 784  * associated. Do not free, this object is owned by @message.
 785  *
 786  * Since: 2.26
 787  */
 788 GUnixFDList *
 789 g_dbus_message_get_unix_fd_list (GDBusMessage  *message)
 790 {
 791   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
 792   return message->fd_list;
 793 }
 794
 795 /**
 796  * g_dbus_message_set_unix_fd_list:
 797  * @message: A #GDBusMessage.
 798  * @fd_list: (allow-none): A #GUnixFDList or %NULL.
 799  *
 800  * Sets the UNIX file descriptors associated with @message. As a
 801  * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
 802  * field is set to the number of fds in @fd_list (or cleared if
 803  * @fd_list is %NULL).
 804  *
 805  * This method is only available on UNIX.
 806  *
 807  * Since: 2.26
 808  */
 809 void
 810 g_dbus_message_set_unix_fd_list (GDBusMessage  *message,
 811                                  GUnixFDList   *fd_list)
 812 {
 813   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
 814   g_return_if_fail (fd_list == NULL || G_IS_UNIX_FD_LIST (fd_list));
 815
 816   if (message->locked)
 817     {
 818       g_warning ("%s: Attempted to modify a locked message", G_STRFUNC);
 819       return;
 820     }
 821
 822   if (message->fd_list != NULL)
 823     g_object_unref (message->fd_list);
 824   if (fd_list != NULL)
 825     {
 826       message->fd_list = g_object_ref (fd_list);
 827       g_dbus_message_set_num_unix_fds (message, g_unix_fd_list_get_length (fd_list));
 828     }
 829   else
 830     {
 831       message->fd_list = NULL;
 832       g_dbus_message_set_num_unix_fds (message, 0);
 833     }
 834 }
 835 #endif
 836
 837 /* ---------------------------------------------------------------------------------------------------- */
 838
 839 static gboolean
 840 validate_headers (GDBusMessage  *message,
 841                   GError       **error)
 842 {
 843   gboolean ret;
 844
 845   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
 846   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 847
 848   ret = FALSE;
 849
 850   switch (message->type)
 851     {
 852     case G_DBUS_MESSAGE_TYPE_INVALID:
 853       g_set_error_literal (error,
 854                            G_IO_ERROR,
 855                            G_IO_ERROR_INVALID_ARGUMENT,
 856                            _("type is INVALID"));
 857       goto out;
 858       break;
 859
 860     case G_DBUS_MESSAGE_TYPE_METHOD_CALL:
 861       if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
 862           g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
 863         {
 864           g_set_error_literal (error,
 865                                G_IO_ERROR,
 866                                G_IO_ERROR_INVALID_ARGUMENT,
 867                                _("METHOD_CALL message: PATH or MEMBER header field is missing"));
 868           goto out;
 869         }
 870       break;
 871
 872     case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
 873       if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
 874         {
 875           g_set_error_literal (error,
 876                                G_IO_ERROR,
 877                                G_IO_ERROR_INVALID_ARGUMENT,
 878                                _("METHOD_RETURN message: REPLY_SERIAL header field is missing"));
 879           goto out;
 880         }
 881       break;
 882
 883     case G_DBUS_MESSAGE_TYPE_ERROR:
 884       if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME) == NULL ||
 885           g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL) == NULL)
 886         {
 887           g_set_error_literal (error,
 888                                G_IO_ERROR,
 889                                G_IO_ERROR_INVALID_ARGUMENT,
 890                                _("ERROR message: REPLY_SERIAL or ERROR_NAME header field is missing"));
 891           goto out;
 892         }
 893       break;
 894
 895     case G_DBUS_MESSAGE_TYPE_SIGNAL:
 896       if (g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH) == NULL ||
 897           g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE) == NULL ||
 898           g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER) == NULL)
 899         {
 900           g_set_error_literal (error,
 901                                G_IO_ERROR,
 902                                G_IO_ERROR_INVALID_ARGUMENT,
 903                                _("SIGNAL message: PATH, INTERFACE or MEMBER header field is missing"));
 904           goto out;
 905         }
 906       if (g_strcmp0 (g_dbus_message_get_path (message), "/org/freedesktop/DBus/Local") == 0)
 907         {
 908           g_set_error_literal (error,
 909                                G_IO_ERROR,
 910                                G_IO_ERROR_INVALID_ARGUMENT,
 911                                _("SIGNAL message: The PATH header field is using the reserved value /org/freedesktop/DBus/Local"));
 912           goto out;
 913         }
 914       if (g_strcmp0 (g_dbus_message_get_interface (message), "org.freedesktop.DBus.Local") == 0)
 915         {
 916           g_set_error_literal (error,
 917                                G_IO_ERROR,
 918                                G_IO_ERROR_INVALID_ARGUMENT,
 919                                _("SIGNAL message: The INTERFACE header field is using the reserved value org.freedesktop.DBus.Local"));
 920           goto out;
 921         }
 922       break;
 923
 924     default:
 925       /* hitherto unknown type - nothing to check */
 926       break;
 927     }
 928
 929   ret = TRUE;
 930
 931  out:
 932   g_assert (ret || (error == NULL || *error != NULL));
 933   return ret;
 934 }
 935
 936 /* ---------------------------------------------------------------------------------------------------- */
 937
 938 static gboolean
 939 ensure_input_padding (GMemoryInputStream   *mis,
 940                       gsize                 padding_size,
 941                       GError              **error)
 942 {
 943   gsize offset;
 944   gsize wanted_offset;
 945
 946   offset = g_seekable_tell (G_SEEKABLE (mis));
 947   wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
 948
 949   if (offset != wanted_offset)
 950     {
 951       return g_seekable_seek (G_SEEKABLE (mis), wanted_offset, G_SEEK_SET, NULL, error);
 952     }
 953   else
 954     {
 955       return TRUE;
 956     }
 957 }
 958
 959 static gchar *
 960 read_string (GMemoryInputStream    *mis,
 961              GDataInputStream      *dis,
 962              gsize                  len,
 963              GError               **error)
 964 {
 965   GString *s;
 966   gchar buf[256];
 967   gsize remaining;
 968   guchar nul;
 969   GError *local_error;
 970   const gchar *end_valid;
 971
 972   s = g_string_new (NULL);
 973
 974   remaining = len;
 975   while (remaining > 0)
 976     {
 977       gsize to_read;
 978       gssize num_read;
 979
 980       to_read = MIN (remaining, sizeof (buf));
 981       num_read = g_input_stream_read (G_INPUT_STREAM (mis),
 982                                       buf,
 983                                       to_read,
 984                                       NULL,
 985                                       error);
 986       if (num_read < 0)
 987         goto fail;
 988       if (num_read == 0)
 989         {
 990           /* G_GSIZE_FORMAT doesn't work with gettext, so we use %lu */
 991           g_set_error (error,
 992                        G_IO_ERROR,
 993                        G_IO_ERROR_INVALID_ARGUMENT,
 994                        _("Wanted to read %lu bytes but got EOF"),
 995                        (gulong)to_read);
 996           goto fail;
 997         }
 998
 999       remaining -= num_read;
1000       g_string_append_len (s, buf, num_read);
1001     }
1002
1003   local_error = NULL;
1004   nul = g_data_input_stream_read_byte (dis, NULL, &local_error);
1005   if (local_error != NULL)
1006     {
1007       g_propagate_error (error, local_error);
1008       goto fail;
1009     }
1010   if (!g_utf8_validate (s->str, -1, &end_valid))
1011     {
1012       gint offset;
1013       gchar *valid_str;
1014       offset = (gint) (end_valid - s->str);
1015       valid_str = g_strndup (s->str, offset);
1016       g_set_error (error,
1017                    G_IO_ERROR,
1018                    G_IO_ERROR_INVALID_ARGUMENT,
1019                    _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1020                      "The valid UTF-8 string up until that point was `%s'"),
1021                    offset,
1022                    (gint) s->len,
1023                    valid_str);
1024       g_free (valid_str);
1025       goto fail;
1026     }
1027   if (nul != '\0')
1028     {
1029       g_set_error (error,
1030                    G_IO_ERROR,
1031                    G_IO_ERROR_INVALID_ARGUMENT,
1032                    _("Expected NUL byte after the string `%s' but found byte %d"),
1033                    s->str, nul);
1034       goto fail;
1035     }
1036
1037   return g_string_free (s, FALSE);
1038
1039  fail:
1040   g_string_free (s, TRUE);
1041   return NULL;
1042 }
1043
1044 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1045
1046 /* returns a non-floating GVariant! */
1047 static GVariant *
1048 parse_value_from_blob (GMemoryInputStream    *mis,
1049                        GDataInputStream      *dis,
1050                        const GVariantType    *type,
1051                        gboolean               just_align,
1052                        guint                  indent,
1053                        GError               **error)
1054 {
1055   GVariant *ret;
1056   GError *local_error;
1057   gboolean is_leaf;
1058
1059 #ifdef DEBUG_SERIALIZER
1060   if (!just_align)
1061     {
1062       gchar *s;
1063       s = g_variant_type_dup_string (type);
1064       g_print ("%*sReading type %s from offset 0x%04x",
1065                indent, "",
1066                s,
1067                (gint) g_seekable_tell (G_SEEKABLE (mis)));
1068       g_free (s);
1069     }
1070 #endif /* DEBUG_SERIALIZER */
1071
1072   ret = NULL;
1073
1074   is_leaf = TRUE;
1075   local_error = NULL;
1076   if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
1077     {
1078       if (!ensure_input_padding (mis, 4, &local_error))
1079         goto fail;
1080       if (!just_align)
1081         {
1082           gboolean v;
1083           v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1084           if (local_error != NULL)
1085             goto fail;
1086           ret = g_variant_new_boolean (v);
1087         }
1088     }
1089   else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1090     {
1091       if (!just_align)
1092         {
1093           guchar v;
1094           v = g_data_input_stream_read_byte (dis, NULL, &local_error);
1095           if (local_error != NULL)
1096             goto fail;
1097           ret = g_variant_new_byte (v);
1098         }
1099     }
1100   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
1101     {
1102       if (!ensure_input_padding (mis, 2, &local_error))
1103         goto fail;
1104       if (!just_align)
1105         {
1106           gint16 v;
1107           v = g_data_input_stream_read_int16 (dis, NULL, &local_error);
1108           if (local_error != NULL)
1109             goto fail;
1110           ret = g_variant_new_int16 (v);
1111         }
1112     }
1113   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
1114     {
1115       if (!ensure_input_padding (mis, 2, &local_error))
1116         goto fail;
1117       if (!just_align)
1118         {
1119           guint16 v;
1120           v = g_data_input_stream_read_uint16 (dis, NULL, &local_error);
1121           if (local_error != NULL)
1122             goto fail;
1123           ret = g_variant_new_uint16 (v);
1124         }
1125     }
1126   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
1127     {
1128       if (!ensure_input_padding (mis, 4, &local_error))
1129         goto fail;
1130       if (!just_align)
1131         {
1132           gint32 v;
1133           v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1134           if (local_error != NULL)
1135             goto fail;
1136           ret = g_variant_new_int32 (v);
1137         }
1138     }
1139   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
1140     {
1141       if (!ensure_input_padding (mis, 4, &local_error))
1142         goto fail;
1143       if (!just_align)
1144         {
1145           guint32 v;
1146           v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1147           if (local_error != NULL)
1148             goto fail;
1149           ret = g_variant_new_uint32 (v);
1150         }
1151     }
1152   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
1153     {
1154       if (!ensure_input_padding (mis, 8, &local_error))
1155         goto fail;
1156       if (!just_align)
1157         {
1158           gint64 v;
1159           v = g_data_input_stream_read_int64 (dis, NULL, &local_error);
1160           if (local_error != NULL)
1161             goto fail;
1162           ret = g_variant_new_int64 (v);
1163         }
1164     }
1165   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
1166     {
1167       if (!ensure_input_padding (mis, 8, &local_error))
1168         goto fail;
1169       if (!just_align)
1170         {
1171           guint64 v;
1172           v = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1173           if (local_error != NULL)
1174             goto fail;
1175           ret = g_variant_new_uint64 (v);
1176         }
1177     }
1178   else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
1179     {
1180       if (!ensure_input_padding (mis, 8, &local_error))
1181         goto fail;
1182       if (!just_align)
1183         {
1184           guint64 v;
1185           gdouble *encoded;
1186           v = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1187           if (local_error != NULL)
1188             goto fail;
1189           G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1190           encoded = (gdouble *) &v;
1191           ret = g_variant_new_double (*encoded);
1192         }
1193     }
1194   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
1195     {
1196       if (!ensure_input_padding (mis, 4, &local_error))
1197         goto fail;
1198       if (!just_align)
1199         {
1200           guint32 len;
1201           gchar *v;
1202           len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1203           if (local_error != NULL)
1204             goto fail;
1205           v = read_string (mis, dis, (gsize) len, &local_error);
1206           if (v == NULL)
1207             goto fail;
1208           ret = g_variant_new_string (v);
1209           g_free (v);
1210         }
1211     }
1212   else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
1213     {
1214       if (!ensure_input_padding (mis, 4, &local_error))
1215         goto fail;
1216       if (!just_align)
1217         {
1218           guint32 len;
1219           gchar *v;
1220           len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1221           if (local_error != NULL)
1222             goto fail;
1223           v = read_string (mis, dis, (gsize) len, &local_error);
1224           if (v == NULL)
1225             goto fail;
1226           if (!g_variant_is_object_path (v))
1227             {
1228               g_set_error (&local_error,
1229                            G_IO_ERROR,
1230                            G_IO_ERROR_INVALID_ARGUMENT,
1231                            _("Parsed value `%s' is not a valid D-Bus object path"),
1232                            v);
1233               g_free (v);
1234               goto fail;
1235             }
1236           ret = g_variant_new_object_path (v);
1237           g_free (v);
1238         }
1239     }
1240   else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
1241     {
1242       if (!just_align)
1243         {
1244           guchar len;
1245           gchar *v;
1246           len = g_data_input_stream_read_byte (dis, NULL, &local_error);
1247           if (local_error != NULL)
1248             goto fail;
1249           v = read_string (mis, dis, (gsize) len, &local_error);
1250           if (v == NULL)
1251             goto fail;
1252           if (!g_variant_is_signature (v))
1253             {
1254               g_set_error (&local_error,
1255                            G_IO_ERROR,
1256                            G_IO_ERROR_INVALID_ARGUMENT,
1257                            _("Parsed value `%s' is not a valid D-Bus signature"),
1258                        v);
1259               g_free (v);
1260               goto fail;
1261             }
1262           ret = g_variant_new_signature (v);
1263           g_free (v);
1264         }
1265     }
1266   else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
1267     {
1268       if (!ensure_input_padding (mis, 4, &local_error))
1269         goto fail;
1270       if (!just_align)
1271         {
1272           gint32 v;
1273           v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1274           if (local_error != NULL)
1275             goto fail;
1276           ret = g_variant_new_handle (v);
1277         }
1278     }
1279   else if (g_variant_type_is_array (type))
1280     {
1281       guint32 array_len;
1282       goffset offset;
1283       goffset target;
1284       const GVariantType *element_type;
1285       GVariantBuilder builder;
1286
1287       if (!ensure_input_padding (mis, 4, &local_error))
1288         goto fail;
1289
1290       if (just_align)
1291         {
1292           array_len = 0;
1293         }
1294       else
1295         {
1296           array_len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1297           if (local_error != NULL)
1298             goto fail;
1299
1300           is_leaf = FALSE;
1301 #ifdef DEBUG_SERIALIZER
1302           g_print (": array spans 0x%04x bytes\n", array_len);
1303 #endif /* DEBUG_SERIALIZER */
1304
1305           if (array_len > (2<<26))
1306             {
1307               /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1308               g_set_error (&local_error,
1309                            G_IO_ERROR,
1310                            G_IO_ERROR_INVALID_ARGUMENT,
1311                            _("Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB)."),
1312                            array_len);
1313               goto fail;
1314             }
1315         }
1316
1317       g_variant_builder_init (&builder, type);
1318       element_type = g_variant_type_element (type);
1319
1320       if (array_len == 0)
1321         {
1322           GVariant *item;
1323           item = parse_value_from_blob (mis,
1324                                         dis,
1325                                         element_type,
1326                                         TRUE,
1327                                         indent + 2,
1328                                         &local_error);
1329           g_assert (item == NULL);
1330         }
1331       else
1332         {
1333           /* TODO: optimize array of primitive types */
1334           offset = g_seekable_tell (G_SEEKABLE (mis));
1335           target = offset + array_len;
1336           while (offset < target)
1337             {
1338               GVariant *item;
1339               item = parse_value_from_blob (mis,
1340                                             dis,
1341                                             element_type,
1342                                             FALSE,
1343                                             indent + 2,
1344                                             &local_error);
1345               if (item == NULL)
1346                 {
1347                   g_variant_builder_clear (&builder);
1348                   goto fail;
1349                 }
1350               g_variant_builder_add_value (&builder, item);
1351               g_variant_unref (item);
1352               offset = g_seekable_tell (G_SEEKABLE (mis));
1353             }
1354         }
1355
1356       if (!just_align)
1357         {
1358           ret = g_variant_builder_end (&builder);
1359         }
1360       else
1361         {
1362           g_variant_builder_clear (&builder);
1363         }
1364     }
1365   else if (g_variant_type_is_dict_entry (type))
1366     {
1367       const GVariantType *key_type;
1368       const GVariantType *value_type;
1369       GVariant *key;
1370       GVariant *value;
1371
1372       if (!ensure_input_padding (mis, 8, &local_error))
1373         goto fail;
1374
1375       is_leaf = FALSE;
1376 #ifdef DEBUG_SERIALIZER
1377       g_print ("\n");
1378 #endif /* DEBUG_SERIALIZER */
1379
1380       if (!just_align)
1381         {
1382           key_type = g_variant_type_key (type);
1383           key = parse_value_from_blob (mis,
1384                                        dis,
1385                                        key_type,
1386                                        FALSE,
1387                                        indent + 2,
1388                                        &local_error);
1389           if (key == NULL)
1390             goto fail;
1391           value_type = g_variant_type_value (type);
1392           value = parse_value_from_blob (mis,
1393                                          dis,
1394                                          value_type,
1395                                          FALSE,
1396                                          indent + 2,
1397                                          &local_error);
1398           if (value == NULL)
1399             {
1400               g_variant_unref (key);
1401               goto fail;
1402             }
1403           ret = g_variant_new_dict_entry (key, value);
1404           g_variant_unref (key);
1405           g_variant_unref (value);
1406         }
1407     }
1408   else if (g_variant_type_is_tuple (type))
1409     {
1410       if (!ensure_input_padding (mis, 8, &local_error))
1411         goto fail;
1412
1413       is_leaf = FALSE;
1414 #ifdef DEBUG_SERIALIZER
1415       g_print ("\n");
1416 #endif /* DEBUG_SERIALIZER */
1417
1418       if (!just_align)
1419         {
1420           const GVariantType *element_type;
1421           GVariantBuilder builder;
1422
1423           g_variant_builder_init (&builder, type);
1424           element_type = g_variant_type_first (type);
1425           while (element_type != NULL)
1426             {
1427               GVariant *item;
1428               item = parse_value_from_blob (mis,
1429                                             dis,
1430                                             element_type,
1431                                             FALSE,
1432                                             indent + 2,
1433                                             &local_error);
1434               if (item == NULL)
1435                 {
1436                   g_variant_builder_clear (&builder);
1437                   goto fail;
1438                 }
1439               g_variant_builder_add_value (&builder, item);
1440               g_variant_unref (item);
1441
1442               element_type = g_variant_type_next (element_type);
1443             }
1444           ret = g_variant_builder_end (&builder);
1445         }
1446     }
1447   else if (g_variant_type_is_variant (type))
1448     {
1449       is_leaf = FALSE;
1450 #ifdef DEBUG_SERIALIZER
1451       g_print ("\n");
1452 #endif /* DEBUG_SERIALIZER */
1453
1454       if (!just_align)
1455         {
1456           guchar siglen;
1457           gchar *sig;
1458           GVariantType *variant_type;
1459           GVariant *value;
1460
1461           siglen = g_data_input_stream_read_byte (dis, NULL, &local_error);
1462           if (local_error != NULL)
1463             goto fail;
1464           sig = read_string (mis, dis, (gsize) siglen, &local_error);
1465           if (sig == NULL)
1466             goto fail;
1467           if (!g_variant_is_signature (sig))
1468             {
1469               g_set_error (&local_error,
1470                            G_IO_ERROR,
1471                            G_IO_ERROR_INVALID_ARGUMENT,
1472                            _("Parsed value `%s' for variant is not a valid D-Bus signature"),
1473                            sig);
1474               g_free (sig);
1475               goto fail;
1476             }
1477           variant_type = g_variant_type_new (sig);
1478           g_free (sig);
1479           value = parse_value_from_blob (mis,
1480                                          dis,
1481                                          variant_type,
1482                                          FALSE,
1483                                          indent + 2,
1484                                          &local_error);
1485           g_variant_type_free (variant_type);
1486           if (value == NULL)
1487             goto fail;
1488           ret = g_variant_new_variant (value);
1489           g_variant_unref (value);
1490         }
1491     }
1492   else
1493     {
1494       gchar *s;
1495       s = g_variant_type_dup_string (type);
1496       g_set_error (&local_error,
1497                    G_IO_ERROR,
1498                    G_IO_ERROR_INVALID_ARGUMENT,
1499                    _("Error deserializing GVariant with type string `%s' from the D-Bus wire format"),
1500                    s);
1501       g_free (s);
1502       goto fail;
1503     }
1504
1505   g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1506
1507 #ifdef DEBUG_SERIALIZER
1508   if (ret != NULL)
1509     {
1510       if (is_leaf)
1511         {
1512           gchar *s;
1513           if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1514             {
1515               s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1516             }
1517           else
1518             {
1519               s = g_variant_print (ret, FALSE);
1520             }
1521           g_print (": %s\n", s);
1522           g_free (s);
1523         }
1524     }
1525 #endif /* DEBUG_SERIALIZER */
1526
1527   /* sink the reference */
1528   if (ret != NULL)
1529     {
1530       g_assert (g_variant_is_floating (ret));
1531       g_variant_ref_sink (ret);
1532     }
1533   return ret;
1534
1535  fail:
1536 #ifdef DEBUG_SERIALIZER
1537   g_print ("\n"
1538            "%*sFAILURE: %s (%s, %d)\n",
1539            indent, "",
1540            local_error->message,
1541            g_quark_to_string (local_error->domain),
1542            local_error->code);
1543 #endif /* DEBUG_SERIALIZER */
1544   g_propagate_error (error, local_error);
1545   return NULL;
1546 }
1547
1548 /* ---------------------------------------------------------------------------------------------------- */
1549
1550 /* message_header must be at least 16 bytes */
1551
1552 /**
1553  * g_dbus_message_bytes_needed:
1554  * @blob: A blob represent a binary D-Bus message.
1555  * @blob_len: The length of @blob (must be at least 16).
1556  * @error: Return location for error or %NULL.
1557  *
1558  * Utility function to calculate how many bytes are needed to
1559  * completely deserialize the D-Bus message stored at @blob.
1560  *
1561  * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1562  * @blob contains invalid data or not enough data is available to
1563  * determine the size).
1564  *
1565  * Since: 2.26
1566  */
1567 gssize
1568 g_dbus_message_bytes_needed (guchar                *blob,
1569                              gsize                  blob_len,
1570                              GError               **error)
1571 {
1572   gssize ret;
1573
1574   ret = -1;
1575
1576   g_return_val_if_fail (blob != NULL, -1);
1577   g_return_val_if_fail (error == NULL || *error == NULL, -1);
1578   g_return_val_if_fail (blob_len >= 16, -1);
1579
1580   if (blob[0] == 'l')
1581     {
1582       /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1583       ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1584       /* round up so it's a multiple of 8 */
1585       ret = 8 * ((ret + 7)/8);
1586       /* finally add the body size */
1587       ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1588     }
1589   else if (blob[0] == 'B')
1590     {
1591       /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1592       ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1593       /* round up so it's a multiple of 8 */
1594       ret = 8 * ((ret + 7)/8);
1595       /* finally add the body size */
1596       ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1597     }
1598   else
1599     {
1600       g_set_error (error,
1601                    G_IO_ERROR,
1602                    G_IO_ERROR_INVALID_ARGUMENT,
1603                    "Unable to determine message blob length - given blob is malformed");
1604     }
1605
1606   if (ret > (2<<27))
1607     {
1608       g_set_error (error,
1609                    G_IO_ERROR,
1610                    G_IO_ERROR_INVALID_ARGUMENT,
1611                    "Blob indicates that message exceeds maximum message length (128MiB)");
1612       ret = -1;
1613     }
1614
1615   return ret;
1616 }
1617
1618 /* ---------------------------------------------------------------------------------------------------- */
1619
1620 /**
1621  * g_dbus_message_new_from_blob:
1622  * @blob: A blob represent a binary D-Bus message.
1623  * @blob_len: The length of @blob.
1624  * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
1625  * @error: Return location for error or %NULL.
1626  *
1627  * Creates a new #GDBusMessage from the data stored at @blob. The byte
1628  * order that the message was in can be retrieved using
1629  * g_dbus_message_get_byte_order().
1630  *
1631  * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
1632  * g_object_unref().
1633  *
1634  * Since: 2.26
1635  */
1636 GDBusMessage *
1637 g_dbus_message_new_from_blob (guchar                *blob,
1638                               gsize                  blob_len,
1639                               GDBusCapabilityFlags   capabilities,
1640                               GError               **error)
1641 {
1642   gboolean ret;
1643   GMemoryInputStream *mis;
1644   GDataInputStream *dis;
1645   GDBusMessage *message;
1646   guchar endianness;
1647   guchar major_protocol_version;
1648   GDataStreamByteOrder byte_order;
1649   guint32 message_body_len;
1650   GVariant *headers;
1651   GVariant *item;
1652   GVariantIter iter;
1653   GVariant *signature;
1654
1655   /* TODO: check against @capabilities */
1656
1657   ret = FALSE;
1658
1659   g_return_val_if_fail (blob != NULL, NULL);
1660   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1661   g_return_val_if_fail (blob_len >= 12, NULL);
1662
1663   message = g_dbus_message_new ();
1664
1665   mis = G_MEMORY_INPUT_STREAM (g_memory_input_stream_new_from_data (blob, blob_len, NULL));
1666   dis = g_data_input_stream_new (G_INPUT_STREAM (mis));
1667
1668   endianness = g_data_input_stream_read_byte (dis, NULL, NULL);
1669   switch (endianness)
1670     {
1671     case 'l':
1672       byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
1673       message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
1674       break;
1675     case 'B':
1676       byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
1677       message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
1678       break;
1679     default:
1680       g_set_error (error,
1681                    G_IO_ERROR,
1682                    G_IO_ERROR_INVALID_ARGUMENT,
1683                    _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
1684                    endianness);
1685       goto out;
1686     }
1687   g_data_input_stream_set_byte_order (dis, byte_order);
1688
1689   message->type = g_data_input_stream_read_byte (dis, NULL, NULL);
1690   message->flags = g_data_input_stream_read_byte (dis, NULL, NULL);
1691   major_protocol_version = g_data_input_stream_read_byte (dis, NULL, NULL);
1692   if (major_protocol_version != 1)
1693     {
1694       g_set_error (error,
1695                    G_IO_ERROR,
1696                    G_IO_ERROR_INVALID_ARGUMENT,
1697                    _("Invalid major protocol version. Expected 1 but found %d"),
1698                    major_protocol_version);
1699       goto out;
1700     }
1701   message_body_len = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1702   message->serial = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1703
1704 #ifdef DEBUG_SERIALIZER
1705   g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1706   {
1707     gchar *s;
1708     s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
1709     g_print ("%s\n", s);
1710     g_free (s);
1711   }
1712 #endif /* DEBUG_SERIALIZER */
1713
1714 #ifdef DEBUG_SERIALIZER
1715   g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1716 #endif /* DEBUG_SERIALIZER */
1717   headers = parse_value_from_blob (mis,
1718                                    dis,
1719                                    G_VARIANT_TYPE ("a{yv}"),
1720                                    FALSE,
1721                                    2,
1722                                    error);
1723   if (headers == NULL)
1724     goto out;
1725   g_variant_iter_init (&iter, headers);
1726   while ((item = g_variant_iter_next_value (&iter)) != NULL)
1727     {
1728       guchar header_field;
1729       GVariant *value;
1730       g_variant_get (item,
1731                      "{yv}",
1732                      &header_field,
1733                      &value);
1734       g_dbus_message_set_header (message, header_field, value);
1735       g_variant_unref (value);
1736       g_variant_unref (item);
1737     }
1738   g_variant_unref (headers);
1739
1740   signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
1741   if (signature != NULL)
1742     {
1743       const gchar *signature_str;
1744       gsize signature_str_len;
1745
1746       signature_str = g_variant_get_string (signature, &signature_str_len);
1747
1748       /* signature but no body */
1749       if (message_body_len == 0 && signature_str_len > 0)
1750         {
1751           g_set_error (error,
1752                        G_IO_ERROR,
1753                        G_IO_ERROR_INVALID_ARGUMENT,
1754                        _("Signature header with signature `%s' found but message body is empty"),
1755                        signature_str);
1756           goto out;
1757         }
1758       else if (signature_str_len > 0)
1759         {
1760           GVariantType *variant_type;
1761           gchar *tupled_signature_str;
1762
1763           if (!g_variant_is_signature (signature_str))
1764             {
1765               g_set_error (error,
1766                            G_IO_ERROR,
1767                            G_IO_ERROR_INVALID_ARGUMENT,
1768                            _("Parsed value `%s' is not a valid D-Bus signature (for body)"),
1769                            signature_str);
1770               goto out;
1771             }
1772           tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
1773           variant_type = g_variant_type_new (tupled_signature_str);
1774           g_free (tupled_signature_str);
1775 #ifdef DEBUG_SERIALIZER
1776           g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1777 #endif /* DEBUG_SERIALIZER */
1778           message->body = parse_value_from_blob (mis,
1779                                                  dis,
1780                                                  variant_type,
1781                                                  FALSE,
1782                                                  2,
1783                                                  error);
1784           g_variant_type_free (variant_type);
1785           if (message->body == NULL)
1786             goto out;
1787         }
1788     }
1789   else
1790     {
1791       /* no signature, this is only OK if the body is empty */
1792       if (message_body_len != 0)
1793         {
1794           /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
1795           g_set_error (error,
1796                        G_IO_ERROR,
1797                        G_IO_ERROR_INVALID_ARGUMENT,
1798                        _("No signature header in message but the message body is %u bytes"),
1799                        message_body_len);
1800           goto out;
1801         }
1802     }
1803
1804   if (!validate_headers (message, error))
1805     {
1806       g_prefix_error (error, _("Cannot deserialize message: "));
1807       goto out;
1808     }
1809
1810   ret = TRUE;
1811
1812  out:
1813   g_object_unref (dis);
1814   g_object_unref (mis);
1815
1816   if (ret)
1817     {
1818       return message;
1819     }
1820   else
1821     {
1822       if (message != NULL)
1823         g_object_unref (message);
1824       return NULL;
1825     }
1826 }
1827
1828 /* ---------------------------------------------------------------------------------------------------- */
1829
1830 static gsize
1831 ensure_output_padding (GMemoryOutputStream  *mos,
1832                        GDataOutputStream    *dos,
1833                        gsize                 padding_size)
1834 {
1835   gsize offset;
1836   gsize wanted_offset;
1837   gsize padding_needed;
1838   guint n;
1839
1840   offset = g_memory_output_stream_get_data_size (mos);
1841   wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1842   padding_needed = wanted_offset - offset;
1843
1844   for (n = 0; n < padding_needed; n++)
1845     g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1846
1847   return padding_needed;
1848 }
1849
1850 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
1851 static gboolean
1852 append_value_to_blob (GVariant             *value,
1853                       const GVariantType   *type,
1854                       GMemoryOutputStream  *mos,
1855                       GDataOutputStream    *dos,
1856                       gsize                *out_padding_added,
1857                       GError              **error)
1858 {
1859   gsize padding_added;
1860
1861   padding_added = 0;
1862
1863   if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
1864     {
1865       padding_added = ensure_output_padding (mos, dos, 4);
1866       if (value != NULL)
1867         {
1868           gboolean v = g_variant_get_boolean (value);
1869           g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1870         }
1871     }
1872   else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1873     {
1874       if (value != NULL)
1875         {
1876           guint8 v = g_variant_get_byte (value);
1877           g_data_output_stream_put_byte (dos, v, NULL, NULL);
1878         }
1879     }
1880   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
1881     {
1882       padding_added = ensure_output_padding (mos, dos, 2);
1883       if (value != NULL)
1884         {
1885           gint16 v = g_variant_get_int16 (value);
1886           g_data_output_stream_put_int16 (dos, v, NULL, NULL);
1887         }
1888     }
1889   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
1890     {
1891       padding_added = ensure_output_padding (mos, dos, 2);
1892       if (value != NULL)
1893         {
1894           guint16 v = g_variant_get_uint16 (value);
1895           g_data_output_stream_put_uint16 (dos, v, NULL, NULL);
1896         }
1897     }
1898   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
1899     {
1900       padding_added = ensure_output_padding (mos, dos, 4);
1901       if (value != NULL)
1902         {
1903           gint32 v = g_variant_get_int32 (value);
1904           g_data_output_stream_put_int32 (dos, v, NULL, NULL);
1905         }
1906     }
1907   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
1908     {
1909       padding_added = ensure_output_padding (mos, dos, 4);
1910       if (value != NULL)
1911         {
1912           guint32 v = g_variant_get_uint32 (value);
1913           g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1914         }
1915     }
1916   else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
1917     {
1918       padding_added = ensure_output_padding (mos, dos, 8);
1919       if (value != NULL)
1920         {
1921           gint64 v = g_variant_get_int64 (value);
1922           g_data_output_stream_put_int64 (dos, v, NULL, NULL);
1923         }
1924     }
1925   else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
1926     {
1927       padding_added = ensure_output_padding (mos, dos, 8);
1928       if (value != NULL)
1929         {
1930           guint64 v = g_variant_get_uint64 (value);
1931           g_data_output_stream_put_uint64 (dos, v, NULL, NULL);
1932         }
1933     }
1934   else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
1935     {
1936       padding_added = ensure_output_padding (mos, dos, 8);
1937       if (value != NULL)
1938         {
1939           guint64 *encoded;
1940           gdouble v = g_variant_get_double (value);
1941           G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1942           encoded = (guint64 *) &v;
1943           g_data_output_stream_put_uint64 (dos, *encoded, NULL, NULL);
1944         }
1945     }
1946   else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
1947     {
1948       padding_added = ensure_output_padding (mos, dos, 4);
1949       if (value != NULL)
1950         {
1951           gsize len;
1952           const gchar *v;
1953           const gchar *end;
1954           v = g_variant_get_string (value, &len);
1955           g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
1956           g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
1957           g_data_output_stream_put_string (dos, v, NULL, NULL);
1958           g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1959         }
1960     }
1961   else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
1962     {
1963       padding_added = ensure_output_padding (mos, dos, 4);
1964       if (value != NULL)
1965         {
1966           gsize len;
1967           const gchar *v = g_variant_get_string (value, &len);
1968           g_assert (g_variant_is_object_path (v));
1969           g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
1970           g_data_output_stream_put_string (dos, v, NULL, NULL);
1971           g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1972         }
1973     }
1974   else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
1975     {
1976       if (value != NULL)
1977         {
1978           gsize len;
1979           const gchar *v = g_variant_get_string (value, &len);
1980           g_assert (g_variant_is_signature (v));
1981           g_data_output_stream_put_byte (dos, len, NULL, NULL);
1982           g_data_output_stream_put_string (dos, v, NULL, NULL);
1983           g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1984         }
1985     }
1986   else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
1987     {
1988       padding_added = ensure_output_padding (mos, dos, 4);
1989       if (value != NULL)
1990         {
1991           gint32 v = g_variant_get_handle (value);
1992           g_data_output_stream_put_int32 (dos, v, NULL, NULL);
1993         }
1994     }
1995   else if (g_variant_type_is_array (type))
1996     {
1997       GVariant *item;
1998       GVariantIter iter;
1999       goffset array_len_offset;
2000       goffset array_payload_begin_offset;
2001       goffset cur_offset;
2002       gsize array_len;
2003
2004       padding_added = ensure_output_padding (mos, dos, 4);
2005       if (value != NULL)
2006         {
2007           /* array length - will be filled in later */
2008           array_len_offset = g_memory_output_stream_get_data_size (mos);
2009           g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2010
2011           /* From the D-Bus spec:
2012            *
2013            *   "A UINT32 giving the length of the array data in bytes,
2014            *    followed by alignment padding to the alignment boundary of
2015            *    the array element type, followed by each array element. The
2016            *    array length is from the end of the alignment padding to
2017            *    the end of the last element, i.e. it does not include the
2018            *    padding after the length, or any padding after the last
2019            *    element."
2020            *
2021            * Thus, we need to count how much padding the first element
2022            * contributes and subtract that from the array length.
2023            */
2024           array_payload_begin_offset = g_memory_output_stream_get_data_size (mos);
2025
2026           if (g_variant_n_children (value) == 0)
2027             {
2028               gsize padding_added_for_item;
2029               if (!append_value_to_blob (NULL,
2030                                          g_variant_type_element (type),
2031                                          mos,
2032                                          dos,
2033                                          &padding_added_for_item,
2034                                          error))
2035                 goto fail;
2036               array_payload_begin_offset += padding_added_for_item;
2037             }
2038           else
2039             {
2040               guint n;
2041               n = 0;
2042               g_variant_iter_init (&iter, value);
2043               while ((item = g_variant_iter_next_value (&iter)) != NULL)
2044                 {
2045                   gsize padding_added_for_item;
2046                   if (!append_value_to_blob (item,
2047                                              g_variant_get_type (item),
2048                                              mos,
2049                                              dos,
2050                                              &padding_added_for_item,
2051                                              error))
2052                     {
2053                       g_variant_unref (item);
2054                       goto fail;
2055                     }
2056                   g_variant_unref (item);
2057                   if (n == 0)
2058                     {
2059                       array_payload_begin_offset += padding_added_for_item;
2060                     }
2061                   n++;
2062                 }
2063             }
2064
2065           cur_offset = g_memory_output_stream_get_data_size (mos);
2066
2067           array_len = cur_offset - array_payload_begin_offset;
2068
2069           if (!g_seekable_seek (G_SEEKABLE (mos), array_len_offset, G_SEEK_SET, NULL, error))
2070             goto fail;
2071
2072           g_data_output_stream_put_uint32 (dos, array_len, NULL, NULL);
2073
2074           if (!g_seekable_seek (G_SEEKABLE (mos), cur_offset, G_SEEK_SET, NULL, error))
2075             goto fail;
2076         }
2077     }
2078   else if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2079     {
2080       padding_added = ensure_output_padding (mos, dos, 8);
2081       if (value != NULL)
2082         {
2083           GVariant *item;
2084           GVariantIter iter;
2085           g_variant_iter_init (&iter, value);
2086           while ((item = g_variant_iter_next_value (&iter)) != NULL)
2087             {
2088               if (!append_value_to_blob (item,
2089                                          g_variant_get_type (item),
2090                                          mos,
2091                                          dos,
2092                                          NULL,
2093                                          error))
2094                 {
2095                   g_variant_unref (item);
2096                   goto fail;
2097                 }
2098               g_variant_unref (item);
2099             }
2100         }
2101     }
2102   else if (g_variant_type_is_variant (type))
2103     {
2104       if (value != NULL)
2105         {
2106           GVariant *child;
2107           const gchar *signature;
2108           child = g_variant_get_child_value (value, 0);
2109           signature = g_variant_get_type_string (child);
2110           g_data_output_stream_put_byte (dos, strlen (signature), NULL, NULL);
2111           g_data_output_stream_put_string (dos, signature, NULL, NULL);
2112           g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
2113           if (!append_value_to_blob (child,
2114                                      g_variant_get_type (child),
2115                                      mos,
2116                                      dos,
2117                                      NULL,
2118                                      error))
2119             {
2120               g_variant_unref (child);
2121               goto fail;
2122             }
2123           g_variant_unref (child);
2124         }
2125     }
2126   else
2127     {
2128       g_set_error (error,
2129                    G_IO_ERROR,
2130                    G_IO_ERROR_INVALID_ARGUMENT,
2131                    _("Error serializing GVariant with type string `%s' to the D-Bus wire format"),
2132                    g_variant_get_type_string (value));
2133       goto fail;
2134     }
2135
2136   if (out_padding_added != NULL)
2137     *out_padding_added = padding_added;
2138
2139   return TRUE;
2140
2141  fail:
2142   return FALSE;
2143 }
2144
2145 static gboolean
2146 append_body_to_blob (GVariant             *value,
2147                      GMemoryOutputStream  *mos,
2148                      GDataOutputStream    *dos,
2149                      GError              **error)
2150 {
2151   gboolean ret;
2152   GVariant *item;
2153   GVariantIter iter;
2154
2155   ret = FALSE;
2156
2157   if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2158     {
2159       g_set_error (error,
2160                    G_IO_ERROR,
2161                    G_IO_ERROR_INVALID_ARGUMENT,
2162                    "Expected a tuple for the body of the GDBusMessage.");
2163       goto fail;
2164     }
2165
2166   g_variant_iter_init (&iter, value);
2167   while ((item = g_variant_iter_next_value (&iter)) != NULL)
2168     {
2169       if (!append_value_to_blob (item,
2170                                  g_variant_get_type (item),
2171                                  mos,
2172                                  dos,
2173                                  NULL,
2174                                  error))
2175         {
2176           g_variant_unref (item);
2177           goto fail;
2178         }
2179       g_variant_unref (item);
2180     }
2181   return TRUE;
2182
2183  fail:
2184   return FALSE;
2185 }
2186
2187 /* ---------------------------------------------------------------------------------------------------- */
2188
2189 /**
2190  * g_dbus_message_to_blob:
2191  * @message: A #GDBusMessage.
2192  * @out_size: Return location for size of generated blob.
2193  * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2194  * @error: Return location for error.
2195  *
2196  * Serializes @message to a blob. The byte order returned by
2197  * g_dbus_message_get_byte_order() will be used.
2198  *
2199  * Returns: A pointer to a valid binary D-Bus message of @out_size bytes
2200  * generated by @message or %NULL if @error is set. Free with g_free().
2201  *
2202  * Since: 2.26
2203  */
2204 guchar *
2205 g_dbus_message_to_blob (GDBusMessage          *message,
2206                         gsize                 *out_size,
2207                         GDBusCapabilityFlags   capabilities,
2208                         GError               **error)
2209 {
2210   GMemoryOutputStream *mos;
2211   GDataOutputStream *dos;
2212   guchar *ret;
2213   gsize size;
2214   GDataStreamByteOrder byte_order;
2215   goffset body_len_offset;
2216   goffset body_start_offset;
2217   gsize body_size;
2218   GVariant *header_fields;
2219   GVariantBuilder builder;
2220   GHashTableIter hash_iter;
2221   gpointer key;
2222   GVariant *header_value;
2223   GVariant *signature;
2224   const gchar *signature_str;
2225   gint num_fds_in_message;
2226   gint num_fds_according_to_header;
2227
2228   /* TODO: check against @capabilities */
2229
2230   ret = NULL;
2231
2232   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2233   g_return_val_if_fail (out_size != NULL, NULL);
2234   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2235
2236   mos = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (NULL, 0, g_realloc, g_free));
2237   dos = g_data_output_stream_new (G_OUTPUT_STREAM (mos));
2238
2239   byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2240   switch (message->byte_order)
2241     {
2242     case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2243       byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2244       break;
2245     case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2246       byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2247       break;
2248     }
2249   g_data_output_stream_set_byte_order (dos, byte_order);
2250
2251   /* Core header */
2252   g_data_output_stream_put_byte (dos, (guchar) message->byte_order, NULL, NULL);
2253   g_data_output_stream_put_byte (dos, message->type, NULL, NULL);
2254   g_data_output_stream_put_byte (dos, message->flags, NULL, NULL);
2255   g_data_output_stream_put_byte (dos, 1, NULL, NULL); /* major protocol version */
2256   body_len_offset = g_memory_output_stream_get_data_size (mos);
2257   /* body length - will be filled in later */
2258   g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2259   g_data_output_stream_put_uint32 (dos, message->serial, NULL, NULL);
2260
2261   num_fds_in_message = 0;
2262 #ifdef G_OS_UNIX
2263   if (message->fd_list != NULL)
2264     num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2265 #endif
2266   num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2267   if (num_fds_in_message != num_fds_according_to_header)
2268     {
2269       g_set_error (error,
2270                    G_IO_ERROR,
2271                    G_IO_ERROR_INVALID_ARGUMENT,
2272                    _("Message has %d fds but the header field indicates %d fds"),
2273                    num_fds_in_message,
2274                    num_fds_according_to_header);
2275       goto out;
2276     }
2277
2278   if (!validate_headers (message, error))
2279     {
2280       g_prefix_error (error, _("Cannot serialize message: "));
2281       goto out;
2282     }
2283
2284   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2285   g_hash_table_iter_init (&hash_iter, message->headers);
2286   while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2287     {
2288       g_variant_builder_add (&builder,
2289                              "{yv}",
2290                              (guchar) GPOINTER_TO_UINT (key),
2291                              header_value);
2292     }
2293   header_fields = g_variant_builder_end (&builder);
2294
2295   if (!append_value_to_blob (header_fields,
2296                              g_variant_get_type (header_fields),
2297                              mos, dos,
2298                              NULL,
2299                              error))
2300     {
2301       g_variant_unref (header_fields);
2302       goto out;
2303     }
2304   g_variant_unref (header_fields);
2305
2306   /* header size must be a multiple of 8 */
2307   ensure_output_padding (mos, dos, 8);
2308
2309   body_start_offset = g_memory_output_stream_get_data_size (mos);
2310
2311   signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2312   signature_str = NULL;
2313   if (signature != NULL)
2314       signature_str = g_variant_get_string (signature, NULL);
2315   if (message->body != NULL)
2316     {
2317       gchar *tupled_signature_str;
2318       tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2319       if (signature == NULL)
2320         {
2321           g_set_error (error,
2322                        G_IO_ERROR,
2323                        G_IO_ERROR_INVALID_ARGUMENT,
2324                        _("Message body has signature `%s' but there is no signature header"),
2325                        signature_str);
2326           g_free (tupled_signature_str);
2327           goto out;
2328         }
2329       else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2330         {
2331           g_set_error (error,
2332                        G_IO_ERROR,
2333                        G_IO_ERROR_INVALID_ARGUMENT,
2334                        _("Message body has type signature `%s' but signature in the header field is `%s'"),
2335                        tupled_signature_str, g_variant_get_type_string (message->body));
2336           g_free (tupled_signature_str);
2337           goto out;
2338         }
2339       g_free (tupled_signature_str);
2340       if (!append_body_to_blob (message->body, mos, dos, error))
2341         goto out;
2342     }
2343   else
2344     {
2345       if (signature != NULL && strlen (signature_str) > 0)
2346         {
2347           g_set_error (error,
2348                        G_IO_ERROR,
2349                        G_IO_ERROR_INVALID_ARGUMENT,
2350                        _("Message body is empty but signature in the header field is `(%s)'"),
2351                        signature_str);
2352           goto out;
2353         }
2354     }
2355
2356   /* OK, we're done writing the message - set the body length */
2357   size = g_memory_output_stream_get_data_size (mos);
2358   body_size = size - body_start_offset;
2359
2360   if (!g_seekable_seek (G_SEEKABLE (mos), body_len_offset, G_SEEK_SET, NULL, error))
2361     goto out;
2362
2363   g_data_output_stream_put_uint32 (dos, body_size, NULL, NULL);
2364
2365   if (!g_output_stream_close (G_OUTPUT_STREAM (dos), NULL, error))
2366     goto out;
2367
2368   *out_size = size;
2369   ret = g_memory_output_stream_steal_data (mos);
2370
2371  out:
2372   g_object_unref (dos);
2373   g_object_unref (mos);
2374
2375   return ret;
2376 }
2377
2378 /* ---------------------------------------------------------------------------------------------------- */
2379
2380 static guint32
2381 get_uint32_header (GDBusMessage            *message,
2382                    GDBusMessageHeaderField  header_field)
2383 {
2384   GVariant *value;
2385   guint32 ret;
2386
2387   ret = 0;
2388   value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2389   if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2390     ret = g_variant_get_uint32 (value);
2391
2392   return ret;
2393 }
2394
2395 static const gchar *
2396 get_string_header (GDBusMessage            *message,
2397                    GDBusMessageHeaderField  header_field)
2398 {
2399   GVariant *value;
2400   const gchar *ret;
2401
2402   ret = NULL;
2403   value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2404   if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2405     ret = g_variant_get_string (value, NULL);
2406
2407   return ret;
2408 }
2409
2410 static const gchar *
2411 get_object_path_header (GDBusMessage            *message,
2412                         GDBusMessageHeaderField  header_field)
2413 {
2414   GVariant *value;
2415   const gchar *ret;
2416
2417   ret = NULL;
2418   value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2419   if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2420     ret = g_variant_get_string (value, NULL);
2421
2422   return ret;
2423 }
2424
2425 static const gchar *
2426 get_signature_header (GDBusMessage            *message,
2427                       GDBusMessageHeaderField  header_field)
2428 {
2429   GVariant *value;
2430   const gchar *ret;
2431
2432   ret = NULL;
2433   value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2434   if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2435     ret = g_variant_get_string (value, NULL);
2436
2437   return ret;
2438 }
2439
2440 /* ---------------------------------------------------------------------------------------------------- */
2441
2442 static void
2443 set_uint32_header (GDBusMessage             *message,
2444                    GDBusMessageHeaderField   header_field,
2445                    guint32                   value)
2446 {
2447   g_dbus_message_set_header (message,
2448                              header_field,
2449                              g_variant_new_uint32 (value));
2450 }
2451
2452 static void
2453 set_string_header (GDBusMessage             *message,
2454                    GDBusMessageHeaderField   header_field,
2455                    const gchar              *value)
2456 {
2457   g_dbus_message_set_header (message,
2458                              header_field,
2459                              value == NULL ? NULL : g_variant_new_string (value));
2460 }
2461
2462 static void
2463 set_object_path_header (GDBusMessage             *message,
2464                         GDBusMessageHeaderField   header_field,
2465                         const gchar              *value)
2466 {
2467   g_dbus_message_set_header (message,
2468                              header_field,
2469                              value == NULL ? NULL : g_variant_new_object_path (value));
2470 }
2471
2472 static void
2473 set_signature_header (GDBusMessage             *message,
2474                       GDBusMessageHeaderField   header_field,
2475                       const gchar              *value)
2476 {
2477   g_dbus_message_set_header (message,
2478                              header_field,
2479                              value == NULL ? NULL : g_variant_new_signature (value));
2480 }
2481
2482 /* ---------------------------------------------------------------------------------------------------- */
2483
2484 /**
2485  * g_dbus_message_get_reply_serial:
2486  * @message: A #GDBusMessage.
2487  *
2488  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2489  *
2490  * Returns: The value.
2491  *
2492  * Since: 2.26
2493  */
2494 guint32
2495 g_dbus_message_get_reply_serial (GDBusMessage  *message)
2496 {
2497   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2498   return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2499 }
2500
2501 /**
2502  * g_dbus_message_set_reply_serial:
2503  * @message: A #GDBusMessage.
2504  * @value: The value to set.
2505  *
2506  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2507  *
2508  * Since: 2.26
2509  */
2510 void
2511 g_dbus_message_set_reply_serial (GDBusMessage  *message,
2512                                  guint32        value)
2513 {
2514   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2515   set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2516 }
2517
2518 /* ---------------------------------------------------------------------------------------------------- */
2519
2520 /**
2521  * g_dbus_message_get_interface:
2522  * @message: A #GDBusMessage.
2523  *
2524  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2525  *
2526  * Returns: The value.
2527  *
2528  * Since: 2.26
2529  */
2530 const gchar *
2531 g_dbus_message_get_interface (GDBusMessage  *message)
2532 {
2533   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2534   return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2535 }
2536
2537 /**
2538  * g_dbus_message_set_interface:
2539  * @message: A #GDBusMessage.
2540  * @value: The value to set.
2541  *
2542  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2543  *
2544  * Since: 2.26
2545  */
2546 void
2547 g_dbus_message_set_interface (GDBusMessage  *message,
2548                               const gchar   *value)
2549 {
2550   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2551   g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2552   set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2553 }
2554
2555 /* ---------------------------------------------------------------------------------------------------- */
2556
2557 /**
2558  * g_dbus_message_get_member:
2559  * @message: A #GDBusMessage.
2560  *
2561  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2562  *
2563  * Returns: The value.
2564  *
2565  * Since: 2.26
2566  */
2567 const gchar *
2568 g_dbus_message_get_member (GDBusMessage  *message)
2569 {
2570   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2571   return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2572 }
2573
2574 /**
2575  * g_dbus_message_set_member:
2576  * @message: A #GDBusMessage.
2577  * @value: The value to set.
2578  *
2579  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2580  *
2581  * Since: 2.26
2582  */
2583 void
2584 g_dbus_message_set_member (GDBusMessage  *message,
2585                            const gchar   *value)
2586 {
2587   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2588   g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2589   set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2590 }
2591
2592 /* ---------------------------------------------------------------------------------------------------- */
2593
2594 /**
2595  * g_dbus_message_get_path:
2596  * @message: A #GDBusMessage.
2597  *
2598  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2599  *
2600  * Returns: The value.
2601  *
2602  * Since: 2.26
2603  */
2604 const gchar *
2605 g_dbus_message_get_path (GDBusMessage  *message)
2606 {
2607   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2608   return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2609 }
2610
2611 /**
2612  * g_dbus_message_set_path:
2613  * @message: A #GDBusMessage.
2614  * @value: The value to set.
2615  *
2616  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2617  *
2618  * Since: 2.26
2619  */
2620 void
2621 g_dbus_message_set_path (GDBusMessage  *message,
2622                          const gchar   *value)
2623 {
2624   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2625   g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2626   set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2627 }
2628
2629 /* ---------------------------------------------------------------------------------------------------- */
2630
2631 /**
2632  * g_dbus_message_get_sender:
2633  * @message: A #GDBusMessage.
2634  *
2635  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2636  *
2637  * Returns: The value.
2638  *
2639  * Since: 2.26
2640  */
2641 const gchar *
2642 g_dbus_message_get_sender (GDBusMessage *message)
2643 {
2644   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2645   return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
2646 }
2647
2648 /**
2649  * g_dbus_message_set_sender:
2650  * @message: A #GDBusMessage.
2651  * @value: The value to set.
2652  *
2653  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2654  *
2655  * Since: 2.26
2656  */
2657 void
2658 g_dbus_message_set_sender (GDBusMessage  *message,
2659                            const gchar   *value)
2660 {
2661   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2662   g_return_if_fail (value == NULL || g_dbus_is_name (value));
2663   set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
2664 }
2665
2666 /* ---------------------------------------------------------------------------------------------------- */
2667
2668 /**
2669  * g_dbus_message_get_destination:
2670  * @message: A #GDBusMessage.
2671  *
2672  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2673  *
2674  * Returns: The value.
2675  *
2676  * Since: 2.26
2677  */
2678 const gchar *
2679 g_dbus_message_get_destination (GDBusMessage  *message)
2680 {
2681   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2682   return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
2683 }
2684
2685 /**
2686  * g_dbus_message_set_destination:
2687  * @message: A #GDBusMessage.
2688  * @value: The value to set.
2689  *
2690  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2691  *
2692  * Since: 2.26
2693  */
2694 void
2695 g_dbus_message_set_destination (GDBusMessage  *message,
2696                                 const gchar   *value)
2697 {
2698   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2699   g_return_if_fail (value == NULL || g_dbus_is_name (value));
2700   set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
2701 }
2702
2703 /* ---------------------------------------------------------------------------------------------------- */
2704
2705 /**
2706  * g_dbus_message_get_error_name:
2707  * @message: A #GDBusMessage.
2708  *
2709  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2710  *
2711  * Returns: The value.
2712  *
2713  * Since: 2.26
2714  */
2715 const gchar *
2716 g_dbus_message_get_error_name (GDBusMessage  *message)
2717 {
2718   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2719   return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
2720 }
2721
2722 /**
2723  * g_dbus_message_set_error_name:
2724  * @message: A #GDBusMessage.
2725  * @value: The value to set.
2726  *
2727  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2728  *
2729  * Since: 2.26
2730  */
2731 void
2732 g_dbus_message_set_error_name (GDBusMessage  *message,
2733                                const gchar   *value)
2734 {
2735   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2736   g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2737   set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
2738 }
2739
2740 /* ---------------------------------------------------------------------------------------------------- */
2741
2742 /**
2743  * g_dbus_message_get_signature:
2744  * @message: A #GDBusMessage.
2745  *
2746  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2747  *
2748  * Returns: The value.
2749  *
2750  * Since: 2.26
2751  */
2752 const gchar *
2753 g_dbus_message_get_signature (GDBusMessage  *message)
2754 {
2755   const gchar *ret;
2756   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2757   ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2758   if (ret == NULL)
2759     ret = "";
2760   return ret;
2761 }
2762
2763 /**
2764  * g_dbus_message_set_signature:
2765  * @message: A #GDBusMessage.
2766  * @value: The value to set.
2767  *
2768  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2769  *
2770  * Since: 2.26
2771  */
2772 void
2773 g_dbus_message_set_signature (GDBusMessage  *message,
2774                               const gchar   *value)
2775 {
2776   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2777   g_return_if_fail (value == NULL || g_variant_is_signature (value));
2778   set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
2779 }
2780
2781 /* ---------------------------------------------------------------------------------------------------- */
2782
2783 /**
2784  * g_dbus_message_get_arg0:
2785  * @message: A #GDBusMessage.
2786  *
2787  * Convenience to get the first item in the body of @message.
2788  *
2789  * Returns: The string item or %NULL if the first item in the body of
2790  * @message is not a string.
2791  *
2792  * Since: 2.26
2793  */
2794 const gchar *
2795 g_dbus_message_get_arg0 (GDBusMessage  *message)
2796 {
2797   const gchar *ret;
2798
2799   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2800
2801   ret = NULL;
2802
2803   if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
2804     {
2805       GVariant *item;
2806       item = g_variant_get_child_value (message->body, 0);
2807       if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
2808         ret = g_variant_get_string (item, NULL);
2809       g_variant_unref (item);
2810     }
2811
2812   return ret;
2813 }
2814
2815 /* ---------------------------------------------------------------------------------------------------- */
2816
2817 /**
2818  * g_dbus_message_get_num_unix_fds:
2819  * @message: A #GDBusMessage.
2820  *
2821  * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2822  *
2823  * Returns: The value.
2824  *
2825  * Since: 2.26
2826  */
2827 guint32
2828 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
2829 {
2830   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2831   return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
2832 }
2833
2834 /**
2835  * g_dbus_message_set_num_unix_fds:
2836  * @message: A #GDBusMessage.
2837  * @value: The value to set.
2838  *
2839  * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2840  *
2841  * Since: 2.26
2842  */
2843 void
2844 g_dbus_message_set_num_unix_fds (GDBusMessage  *message,
2845                                  guint32        value)
2846 {
2847   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2848   set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
2849 }
2850
2851 /* ---------------------------------------------------------------------------------------------------- */
2852
2853 /**
2854  * g_dbus_message_to_gerror:
2855  * @message: A #GDBusMessage.
2856  * @error: The #GError to set.
2857  *
2858  * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
2859  * nothing and returns %FALSE.
2860  *
2861  * Otherwise this method encodes the error in @message as a #GError
2862  * using g_dbus_error_set_dbus_error() using the information in the
2863  * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
2864  * well as the first string item in @message's body.
2865  *
2866  * Returns: %TRUE if @error was set, %FALSE otherwise.
2867  *
2868  * Since: 2.26
2869  */
2870 gboolean
2871 g_dbus_message_to_gerror (GDBusMessage   *message,
2872                           GError        **error)
2873 {
2874   gboolean ret;
2875   const gchar *error_name;
2876
2877   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
2878
2879   ret = FALSE;
2880   if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
2881     goto out;
2882
2883   error_name = g_dbus_message_get_error_name (message);
2884   if (error_name != NULL)
2885     {
2886       GVariant *body;
2887
2888       body = g_dbus_message_get_body (message);
2889
2890       if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
2891         {
2892           const gchar *error_message;
2893           g_variant_get (body, "(&s)", &error_message);
2894           g_dbus_error_set_dbus_error (error,
2895                                        error_name,
2896                                        error_message,
2897                                        NULL);
2898         }
2899       else
2900         {
2901           /* these two situations are valid, yet pretty rare */
2902           if (body != NULL)
2903             {
2904               g_dbus_error_set_dbus_error (error,
2905                                            error_name,
2906                                            "",
2907                                            _("Error return with body of type `%s'"),
2908                                            g_variant_get_type_string (body));
2909             }
2910           else
2911             {
2912               g_dbus_error_set_dbus_error (error,
2913                                            error_name,
2914                                            "",
2915                                            _("Error return with empty body"));
2916             }
2917         }
2918     }
2919   else
2920     {
2921       /* TOOD: this shouldn't happen - should check this at message serialization
2922        * time and disconnect the peer.
2923        */
2924       g_set_error (error,
2925                    G_IO_ERROR,
2926                    G_IO_ERROR_FAILED,
2927                    "Error return without error-name header!");
2928     }
2929
2930   ret = TRUE;
2931
2932  out:
2933   return ret;
2934 }
2935
2936 /* ---------------------------------------------------------------------------------------------------- */
2937
2938 static gchar *
2939 flags_to_string (GType flags_type, guint value)
2940 {
2941   GString *s;
2942   GFlagsClass *klass;
2943   guint n;
2944
2945   klass = g_type_class_ref (flags_type);
2946   s = g_string_new (NULL);
2947   for (n = 0; n < 32; n++)
2948     {
2949       if ((value & (1<<n)) != 0)
2950         {
2951           GFlagsValue *flags_value;
2952           flags_value = g_flags_get_first_value (klass, (1<<n));
2953           if (s->len > 0)
2954             g_string_append_c (s, ',');
2955           if (flags_value != NULL)
2956             g_string_append (s, flags_value->value_nick);
2957           else
2958             g_string_append_printf (s, "unknown (bit %d)", n);
2959         }
2960     }
2961   if (s->len == 0)
2962     g_string_append (s, "none");
2963   g_type_class_unref (klass);
2964   return g_string_free (s, FALSE);
2965 }
2966
2967 static gint
2968 _sort_keys_func (gconstpointer a,
2969                  gconstpointer b)
2970 {
2971   gint ia;
2972   gint ib;
2973
2974   ia = GPOINTER_TO_INT (a);
2975   ib = GPOINTER_TO_INT (b);
2976
2977   return ia - ib;
2978 }
2979
2980 /**
2981  * g_dbus_message_print:
2982  * @message: A #GDBusMessage.
2983  * @indent: Indentation level.
2984  *
2985  * Produces a human-readable multi-line description of @message.
2986  *
2987  * The contents of the description has no ABI guarantees, the contents
2988  * and formatting is subject to change at any time. Typical output
2989  * looks something like this:
2990  * <programlisting>
2991  * Type:    method-call
2992  * Flags:   none
2993  * Version: 0
2994  * Serial:  4
2995  * Headers:
2996  *   path -> objectpath '/org/gtk/GDBus/TestObject'
2997  *   interface -> 'org.gtk.GDBus.TestInterface'
2998  *   member -> 'GimmeStdout'
2999  *   destination -> ':1.146'
3000  * Body: ()
3001  * UNIX File Descriptors:
3002  *   (none)
3003  * </programlisting>
3004  * or
3005  * <programlisting>
3006  * Type:    method-return
3007  * Flags:   no-reply-expected
3008  * Version: 0
3009  * Serial:  477
3010  * Headers:
3011  *   reply-serial -> uint32 4
3012  *   destination -> ':1.159'
3013  *   sender -> ':1.146'
3014  *   num-unix-fds -> uint32 1
3015  * Body: ()
3016  * UNIX File Descriptors:
3017  *   fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3018  * </programlisting>
3019  *
3020  * Returns: A string that should be freed with g_free().
3021  *
3022  * Since: 2.26
3023  */
3024 gchar *
3025 g_dbus_message_print (GDBusMessage *message,
3026                       guint         indent)
3027 {
3028   GString *str;
3029   gchar *s;
3030   GList *keys;
3031   GList *l;
3032
3033   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3034
3035   str = g_string_new (NULL);
3036
3037   s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3038   g_string_append_printf (str, "%*sType:    %s\n", indent, "", s);
3039   g_free (s);
3040   s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3041   g_string_append_printf (str, "%*sFlags:   %s\n", indent, "", s);
3042   g_free (s);
3043   g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3044   g_string_append_printf (str, "%*sSerial:  %d\n", indent, "", message->serial);
3045
3046   g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3047   keys = g_hash_table_get_keys (message->headers);
3048   keys = g_list_sort (keys, _sort_keys_func);
3049   if (keys != NULL)
3050     {
3051       for (l = keys; l != NULL; l = l->next)
3052         {
3053           gint key = GPOINTER_TO_INT (l->data);
3054           GVariant *value;
3055           gchar *value_str;
3056
3057           value = g_hash_table_lookup (message->headers, l->data);
3058           g_assert (value != NULL);
3059
3060           s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3061           value_str = g_variant_print (value, TRUE);
3062           g_string_append_printf (str, "%*s  %s -> %s\n", indent, "", s, value_str);
3063           g_free (s);
3064           g_free (value_str);
3065         }
3066     }
3067   else
3068     {
3069       g_string_append_printf (str, "%*s  (none)\n", indent, "");
3070     }
3071   g_string_append_printf (str, "%*sBody: ", indent, "");
3072   if (message->body != NULL)
3073     {
3074       g_variant_print_string (message->body,
3075                               str,
3076                               TRUE);
3077     }
3078   else
3079     {
3080       g_string_append (str, "()");
3081     }
3082   g_string_append (str, "\n");
3083 #ifdef G_OS_UNIX
3084   g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3085   if (message->fd_list != NULL)
3086     {
3087       gint num_fds;
3088       const gint *fds;
3089       gint n;
3090
3091       fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3092       if (num_fds > 0)
3093         {
3094           for (n = 0; n < num_fds; n++)
3095             {
3096               GString *fs;
3097               struct stat statbuf;
3098               fs = g_string_new (NULL);
3099               if (fstat (fds[n], &statbuf) == 0)
3100                 {
3101                   g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3102                                           major (statbuf.st_dev), minor (statbuf.st_dev));
3103                   g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3104                                           statbuf.st_mode);
3105                   g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3106                                           (guint64) statbuf.st_ino);
3107                   g_string_append_printf (fs, "%s" "uid=%d", fs->len > 0 ? "," : "",
3108                                           statbuf.st_uid);
3109                   g_string_append_printf (fs, "%s" "gid=%d", fs->len > 0 ? "," : "",
3110                                           statbuf.st_gid);
3111                   g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3112                                           major (statbuf.st_rdev), minor (statbuf.st_rdev));
3113                   g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3114                                           (guint64) statbuf.st_size);
3115                   g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3116                                           (guint64) statbuf.st_atime);
3117                   g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3118                                           (guint64) statbuf.st_mtime);
3119                   g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3120                                           (guint64) statbuf.st_ctime);
3121                 }
3122               else
3123                 {
3124                   g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3125                 }
3126               g_string_append_printf (str, "%*s  fd %d: %s\n", indent, "", fds[n], fs->str);
3127               g_string_free (fs, TRUE);
3128             }
3129         }
3130       else
3131         {
3132           g_string_append_printf (str, "%*s  (empty)\n", indent, "");
3133         }
3134     }
3135   else
3136     {
3137       g_string_append_printf (str, "%*s  (none)\n", indent, "");
3138     }
3139 #endif
3140
3141   return g_string_free (str, FALSE);
3142 }
3143
3144 /**
3145  * g_dbus_message_get_locked:
3146  * @message: A #GDBusMessage.
3147  *
3148  * Checks whether @message is locked. To monitor changes to this
3149  * value, conncet to the #GObject::notify signal to listen for changes
3150  * on the #GDBusMessage:locked property.
3151  *
3152  * Returns: %TRUE if @message is locked, %FALSE otherwise.
3153  *
3154  * Since: 2.26
3155  */
3156 gboolean
3157 g_dbus_message_get_locked (GDBusMessage *message)
3158 {
3159   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3160   return message->locked;
3161 }
3162
3163 /**
3164  * g_dbus_message_lock:
3165  * @message: A #GDBusMessage.
3166  *
3167  * If @message is locked, does nothing. Otherwise locks the message.
3168  *
3169  * Since: 2.26
3170  */
3171 void
3172 g_dbus_message_lock (GDBusMessage *message)
3173 {
3174   g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3175
3176   if (message->locked)
3177     goto out;
3178
3179   message->locked = TRUE;
3180   g_object_notify (G_OBJECT (message), "locked");
3181
3182  out:
3183   ;
3184 }
3185
3186 /**
3187  * g_dbus_message_copy:
3188  * @message: A #GDBusMessage.
3189  * @error: Return location for error or %NULL.
3190  *
3191  * Copies @message. The copy is a deep copy and the returned
3192  * #GDBusMessage is completely identical except that it is guaranteed
3193  * to not be locked.
3194  *
3195  * This operation can fail if e.g. @message contains file descriptors
3196  * and the per-process or system-wide open files limit is reached.
3197  *
3198  * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
3199  * g_object_unref().
3200  *
3201  * Since: 2.26
3202  */
3203 GDBusMessage *
3204 g_dbus_message_copy (GDBusMessage  *message,
3205                      GError       **error)
3206 {
3207   GDBusMessage *ret;
3208   GHashTableIter iter;
3209   gpointer header_key;
3210   GVariant *header_value;
3211
3212   g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3213   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
3214
3215   ret = g_dbus_message_new ();
3216   ret->type                   = message->type;
3217   ret->flags                  = message->flags;
3218   ret->byte_order             = message->byte_order;
3219   ret->major_protocol_version = message->major_protocol_version;
3220   ret->serial                 = message->serial;
3221
3222 #ifdef G_OS_UNIX
3223   if (message->fd_list != NULL)
3224     {
3225       gint n;
3226       gint num_fds;
3227       const gint *fds;
3228
3229       ret->fd_list = g_unix_fd_list_new ();
3230       fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3231       for (n = 0; n < num_fds; n++)
3232         {
3233           if (g_unix_fd_list_append (ret->fd_list,
3234                                      fds[n],
3235                                      error) == -1)
3236             {
3237               g_object_unref (ret);
3238               ret = NULL;
3239               goto out;
3240             }
3241         }
3242     }
3243 #endif
3244
3245   /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3246    * to just ref (as opposed to deep-copying) the GVariant instances
3247    */
3248   ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3249   g_hash_table_iter_init (&iter, message->headers);
3250   while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3251     g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));
3252
3253  out:
3254   return ret;
3255 }
3256