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