?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
menu threaded test: run the mainloop after export
[glib.git] / gio / gdbusmessage.c
blob82860f45a0a59270c7bdd268bc42e65c2705a6cc
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 g_dngettext (GETTEXT_PACKAGE,
998 "Wanted to read %lu byte but got EOF",
999 "Wanted to read %lu bytes but got EOF",
1000 (gulong)to_read),
1001 (gulong)to_read);
1002 goto fail;
1003 }
1004
1005 remaining -= num_read;
1006 g_string_append_len (s, buf, num_read);
1007 }
1008
1009 local_error = NULL;
1010 nul = g_data_input_stream_read_byte (dis, NULL, &local_error);
1011 if (local_error != NULL)
1012 {
1013 g_propagate_error (error, local_error);
1014 goto fail;
1015 }
1016 if (!g_utf8_validate (s->str, -1, &end_valid))
1017 {
1018 gint offset;
1019 gchar *valid_str;
1020 offset = (gint) (end_valid - s->str);
1021 valid_str = g_strndup (s->str, offset);
1022 g_set_error (error,
1023 G_IO_ERROR,
1024 G_IO_ERROR_INVALID_ARGUMENT,
1025 _("Expected valid UTF-8 string but found invalid bytes at byte offset %d (length of string is %d). "
1026 "The valid UTF-8 string up until that point was `%s'"),
1027 offset,
1028 (gint) s->len,
1029 valid_str);
1030 g_free (valid_str);
1031 goto fail;
1032 }
1033 if (nul != '\0')
1034 {
1035 g_set_error (error,
1036 G_IO_ERROR,
1037 G_IO_ERROR_INVALID_ARGUMENT,
1038 _("Expected NUL byte after the string `%s' but found byte %d"),
1039 s->str, nul);
1040 goto fail;
1041 }
1042
1043 return g_string_free (s, FALSE);
1044
1045 fail:
1046 g_string_free (s, TRUE);
1047 return NULL;
1048 }
1049
1050 /* if just_align==TRUE, don't read a value, just align the input stream wrt padding */
1051
1052 /* returns a non-floating GVariant! */
1053 static GVariant *
1054 parse_value_from_blob (GMemoryInputStream *mis,
1055 GDataInputStream *dis,
1056 const GVariantType *type,
1057 gboolean just_align,
1058 guint indent,
1059 GError **error)
1060 {
1061 GVariant *ret;
1062 GError *local_error;
1063 gboolean is_leaf;
1064 const gchar *type_string;
1065
1066 type_string = g_variant_type_peek_string (type);
1067
1068 #ifdef DEBUG_SERIALIZER
1069 if (!just_align)
1070 {
1071 gchar *s;
1072 s = g_variant_type_dup_string (type);
1073 g_print ("%*sReading type %s from offset 0x%04x",
1074 indent, "",
1075 s,
1076 (gint) g_seekable_tell (G_SEEKABLE (mis)));
1077 g_free (s);
1078 }
1079 #endif /* DEBUG_SERIALIZER */
1080
1081 ret = NULL;
1082
1083 is_leaf = TRUE;
1084 local_error = NULL;
1085 switch (type_string[0])
1086 {
1087 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1088 if (!ensure_input_padding (mis, 4, &local_error))
1089 goto fail;
1090 if (!just_align)
1091 {
1092 gboolean v;
1093 v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1094 if (local_error != NULL)
1095 goto fail;
1096 ret = g_variant_new_boolean (v);
1097 }
1098 break;
1099
1100 case 'y': /* G_VARIANT_TYPE_BYTE */
1101 if (!just_align)
1102 {
1103 guchar v;
1104 v = g_data_input_stream_read_byte (dis, NULL, &local_error);
1105 if (local_error != NULL)
1106 goto fail;
1107 ret = g_variant_new_byte (v);
1108 }
1109 break;
1110
1111 case 'n': /* G_VARIANT_TYPE_INT16 */
1112 if (!ensure_input_padding (mis, 2, &local_error))
1113 goto fail;
1114 if (!just_align)
1115 {
1116 gint16 v;
1117 v = g_data_input_stream_read_int16 (dis, NULL, &local_error);
1118 if (local_error != NULL)
1119 goto fail;
1120 ret = g_variant_new_int16 (v);
1121 }
1122 break;
1123
1124 case 'q': /* G_VARIANT_TYPE_UINT16 */
1125 if (!ensure_input_padding (mis, 2, &local_error))
1126 goto fail;
1127 if (!just_align)
1128 {
1129 guint16 v;
1130 v = g_data_input_stream_read_uint16 (dis, NULL, &local_error);
1131 if (local_error != NULL)
1132 goto fail;
1133 ret = g_variant_new_uint16 (v);
1134 }
1135 break;
1136
1137 case 'i': /* G_VARIANT_TYPE_INT32 */
1138 if (!ensure_input_padding (mis, 4, &local_error))
1139 goto fail;
1140 if (!just_align)
1141 {
1142 gint32 v;
1143 v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1144 if (local_error != NULL)
1145 goto fail;
1146 ret = g_variant_new_int32 (v);
1147 }
1148 break;
1149
1150 case 'u': /* G_VARIANT_TYPE_UINT32 */
1151 if (!ensure_input_padding (mis, 4, &local_error))
1152 goto fail;
1153 if (!just_align)
1154 {
1155 guint32 v;
1156 v = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1157 if (local_error != NULL)
1158 goto fail;
1159 ret = g_variant_new_uint32 (v);
1160 }
1161 break;
1162
1163 case 'x': /* G_VARIANT_TYPE_INT64 */
1164 if (!ensure_input_padding (mis, 8, &local_error))
1165 goto fail;
1166 if (!just_align)
1167 {
1168 gint64 v;
1169 v = g_data_input_stream_read_int64 (dis, NULL, &local_error);
1170 if (local_error != NULL)
1171 goto fail;
1172 ret = g_variant_new_int64 (v);
1173 }
1174 break;
1175
1176 case 't': /* G_VARIANT_TYPE_UINT64 */
1177 if (!ensure_input_padding (mis, 8, &local_error))
1178 goto fail;
1179 if (!just_align)
1180 {
1181 guint64 v;
1182 v = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1183 if (local_error != NULL)
1184 goto fail;
1185 ret = g_variant_new_uint64 (v);
1186 }
1187 break;
1188
1189 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1190 if (!ensure_input_padding (mis, 8, &local_error))
1191 goto fail;
1192 if (!just_align)
1193 {
1194 union {
1195 guint64 v_uint64;
1196 gdouble v_double;
1197 } u;
1198 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1199 u.v_uint64 = g_data_input_stream_read_uint64 (dis, NULL, &local_error);
1200 if (local_error != NULL)
1201 goto fail;
1202 ret = g_variant_new_double (u.v_double);
1203 }
1204 break;
1205
1206 case 's': /* G_VARIANT_TYPE_STRING */
1207 if (!ensure_input_padding (mis, 4, &local_error))
1208 goto fail;
1209 if (!just_align)
1210 {
1211 guint32 len;
1212 gchar *v;
1213 len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1214 if (local_error != NULL)
1215 goto fail;
1216 v = read_string (mis, dis, (gsize) len, &local_error);
1217 if (v == NULL)
1218 goto fail;
1219 ret = g_variant_new_string (v);
1220 g_free (v);
1221 }
1222 break;
1223
1224 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1225 if (!ensure_input_padding (mis, 4, &local_error))
1226 goto fail;
1227 if (!just_align)
1228 {
1229 guint32 len;
1230 gchar *v;
1231 len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1232 if (local_error != NULL)
1233 goto fail;
1234 v = read_string (mis, dis, (gsize) len, &local_error);
1235 if (v == NULL)
1236 goto fail;
1237 if (!g_variant_is_object_path (v))
1238 {
1239 g_set_error (&local_error,
1240 G_IO_ERROR,
1241 G_IO_ERROR_INVALID_ARGUMENT,
1242 _("Parsed value `%s' is not a valid D-Bus object path"),
1243 v);
1244 g_free (v);
1245 goto fail;
1246 }
1247 ret = g_variant_new_object_path (v);
1248 g_free (v);
1249 }
1250 break;
1251
1252 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
1253 if (!just_align)
1254 {
1255 guchar len;
1256 gchar *v;
1257 len = g_data_input_stream_read_byte (dis, NULL, &local_error);
1258 if (local_error != NULL)
1259 goto fail;
1260 v = read_string (mis, dis, (gsize) len, &local_error);
1261 if (v == NULL)
1262 goto fail;
1263 if (!g_variant_is_signature (v))
1264 {
1265 g_set_error (&local_error,
1266 G_IO_ERROR,
1267 G_IO_ERROR_INVALID_ARGUMENT,
1268 _("Parsed value `%s' is not a valid D-Bus signature"),
1269 v);
1270 g_free (v);
1271 goto fail;
1272 }
1273 ret = g_variant_new_signature (v);
1274 g_free (v);
1275 }
1276 break;
1277
1278 case 'h': /* G_VARIANT_TYPE_HANDLE */
1279 if (!ensure_input_padding (mis, 4, &local_error))
1280 goto fail;
1281 if (!just_align)
1282 {
1283 gint32 v;
1284 v = g_data_input_stream_read_int32 (dis, NULL, &local_error);
1285 if (local_error != NULL)
1286 goto fail;
1287 ret = g_variant_new_handle (v);
1288 }
1289 break;
1290
1291 case 'a': /* G_VARIANT_TYPE_ARRAY */
1292 {
1293 guint32 array_len;
1294 goffset offset;
1295 goffset target;
1296 const GVariantType *element_type;
1297 GVariantBuilder builder;
1298
1299 if (!ensure_input_padding (mis, 4, &local_error))
1300 goto fail;
1301
1302 if (just_align)
1303 {
1304 array_len = 0;
1305 }
1306 else
1307 {
1308 array_len = g_data_input_stream_read_uint32 (dis, NULL, &local_error);
1309 if (local_error != NULL)
1310 goto fail;
1311
1312 is_leaf = FALSE;
1313 #ifdef DEBUG_SERIALIZER
1314 g_print (": array spans 0x%04x bytes\n", array_len);
1315 #endif /* DEBUG_SERIALIZER */
1316
1317 if (array_len > (2<<26))
1318 {
1319 /* G_GUINT32_FORMAT doesn't work with gettext, so use u */
1320 g_set_error (&local_error,
1321 G_IO_ERROR,
1322 G_IO_ERROR_INVALID_ARGUMENT,
1323 g_dngettext (GETTEXT_PACKAGE,
1324 "Encountered array of length %u byte. Maximum length is 2<<26 bytes (64 MiB).",
1325 "Encountered array of length %u bytes. Maximum length is 2<<26 bytes (64 MiB).",
1326 array_len),
1327 array_len);
1328 goto fail;
1329 }
1330 }
1331
1332 g_variant_builder_init (&builder, type);
1333 element_type = g_variant_type_element (type);
1334
1335 if (array_len == 0)
1336 {
1337 GVariant *item;
1338 item = parse_value_from_blob (mis,
1339 dis,
1340 element_type,
1341 TRUE,
1342 indent + 2,
1343 NULL);
1344 g_assert (item == NULL);
1345 }
1346 else
1347 {
1348 /* TODO: optimize array of primitive types */
1349 offset = g_seekable_tell (G_SEEKABLE (mis));
1350 target = offset + array_len;
1351 while (offset < target)
1352 {
1353 GVariant *item;
1354 item = parse_value_from_blob (mis,
1355 dis,
1356 element_type,
1357 FALSE,
1358 indent + 2,
1359 &local_error);
1360 if (item == NULL)
1361 {
1362 g_variant_builder_clear (&builder);
1363 goto fail;
1364 }
1365 g_variant_builder_add_value (&builder, item);
1366 g_variant_unref (item);
1367 offset = g_seekable_tell (G_SEEKABLE (mis));
1368 }
1369 }
1370
1371 if (!just_align)
1372 {
1373 ret = g_variant_builder_end (&builder);
1374 }
1375 else
1376 {
1377 g_variant_builder_clear (&builder);
1378 }
1379 }
1380 break;
1381
1382 default:
1383 if (g_variant_type_is_dict_entry (type))
1384 {
1385 const GVariantType *key_type;
1386 const GVariantType *value_type;
1387 GVariant *key;
1388 GVariant *value;
1389
1390 if (!ensure_input_padding (mis, 8, &local_error))
1391 goto fail;
1392
1393 is_leaf = FALSE;
1394 #ifdef DEBUG_SERIALIZER
1395 g_print ("\n");
1396 #endif /* DEBUG_SERIALIZER */
1397
1398 if (!just_align)
1399 {
1400 key_type = g_variant_type_key (type);
1401 key = parse_value_from_blob (mis,
1402 dis,
1403 key_type,
1404 FALSE,
1405 indent + 2,
1406 &local_error);
1407 if (key == NULL)
1408 goto fail;
1409 value_type = g_variant_type_value (type);
1410 value = parse_value_from_blob (mis,
1411 dis,
1412 value_type,
1413 FALSE,
1414 indent + 2,
1415 &local_error);
1416 if (value == NULL)
1417 {
1418 g_variant_unref (key);
1419 goto fail;
1420 }
1421 ret = g_variant_new_dict_entry (key, value);
1422 g_variant_unref (key);
1423 g_variant_unref (value);
1424 }
1425 }
1426 else if (g_variant_type_is_tuple (type))
1427 {
1428 if (!ensure_input_padding (mis, 8, &local_error))
1429 goto fail;
1430
1431 is_leaf = FALSE;
1432 #ifdef DEBUG_SERIALIZER
1433 g_print ("\n");
1434 #endif /* DEBUG_SERIALIZER */
1435
1436 if (!just_align)
1437 {
1438 const GVariantType *element_type;
1439 GVariantBuilder builder;
1440
1441 g_variant_builder_init (&builder, type);
1442 element_type = g_variant_type_first (type);
1443 while (element_type != NULL)
1444 {
1445 GVariant *item;
1446 item = parse_value_from_blob (mis,
1447 dis,
1448 element_type,
1449 FALSE,
1450 indent + 2,
1451 &local_error);
1452 if (item == NULL)
1453 {
1454 g_variant_builder_clear (&builder);
1455 goto fail;
1456 }
1457 g_variant_builder_add_value (&builder, item);
1458 g_variant_unref (item);
1459
1460 element_type = g_variant_type_next (element_type);
1461 }
1462 ret = g_variant_builder_end (&builder);
1463 }
1464 }
1465 else if (g_variant_type_is_variant (type))
1466 {
1467 is_leaf = FALSE;
1468 #ifdef DEBUG_SERIALIZER
1469 g_print ("\n");
1470 #endif /* DEBUG_SERIALIZER */
1471
1472 if (!just_align)
1473 {
1474 guchar siglen;
1475 gchar *sig;
1476 GVariantType *variant_type;
1477 GVariant *value;
1478
1479 siglen = g_data_input_stream_read_byte (dis, NULL, &local_error);
1480 if (local_error != NULL)
1481 goto fail;
1482 sig = read_string (mis, dis, (gsize) siglen, &local_error);
1483 if (sig == NULL)
1484 goto fail;
1485 if (!g_variant_is_signature (sig))
1486 {
1487 g_set_error (&local_error,
1488 G_IO_ERROR,
1489 G_IO_ERROR_INVALID_ARGUMENT,
1490 _("Parsed value `%s' for variant is not a valid D-Bus signature"),
1491 sig);
1492 g_free (sig);
1493 goto fail;
1494 }
1495 variant_type = g_variant_type_new (sig);
1496 g_free (sig);
1497 value = parse_value_from_blob (mis,
1498 dis,
1499 variant_type,
1500 FALSE,
1501 indent + 2,
1502 &local_error);
1503 g_variant_type_free (variant_type);
1504 if (value == NULL)
1505 goto fail;
1506 ret = g_variant_new_variant (value);
1507 g_variant_unref (value);
1508 }
1509 }
1510 else
1511 {
1512 gchar *s;
1513 s = g_variant_type_dup_string (type);
1514 g_set_error (&local_error,
1515 G_IO_ERROR,
1516 G_IO_ERROR_INVALID_ARGUMENT,
1517 _("Error deserializing GVariant with type string `%s' from the D-Bus wire format"),
1518 s);
1519 g_free (s);
1520 goto fail;
1521 }
1522 break;
1523 }
1524
1525 g_assert ((just_align && ret == NULL) || (!just_align && ret != NULL));
1526
1527 #ifdef DEBUG_SERIALIZER
1528 if (ret != NULL)
1529 {
1530 if (is_leaf)
1531 {
1532 gchar *s;
1533 if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
1534 {
1535 s = g_strdup_printf ("0x%02x '%c'", g_variant_get_byte (ret), g_variant_get_byte (ret));
1536 }
1537 else
1538 {
1539 s = g_variant_print (ret, FALSE);
1540 }
1541 g_print (": %s\n", s);
1542 g_free (s);
1543 }
1544 }
1545 #else
1546 is_leaf = is_leaf; /* To avoid -Wunused-but-set-variable */
1547 #endif /* DEBUG_SERIALIZER */
1548
1549 /* sink the reference */
1550 if (ret != NULL)
1551 {
1552 g_assert (g_variant_is_floating (ret));
1553 g_variant_ref_sink (ret);
1554 }
1555 return ret;
1556
1557 fail:
1558 #ifdef DEBUG_SERIALIZER
1559 g_print ("\n"
1560 "%*sFAILURE: %s (%s, %d)\n",
1561 indent, "",
1562 local_error->message,
1563 g_quark_to_string (local_error->domain),
1564 local_error->code);
1565 #endif /* DEBUG_SERIALIZER */
1566 g_propagate_error (error, local_error);
1567 return NULL;
1568 }
1569
1570 /* ---------------------------------------------------------------------------------------------------- */
1571
1572 /* message_header must be at least 16 bytes */
1573
1574 /**
1575 * g_dbus_message_bytes_needed:
1576 * @blob: A blob represent a binary D-Bus message.
1577 * @blob_len: The length of @blob (must be at least 16).
1578 * @error: Return location for error or %NULL.
1579 *
1580 * Utility function to calculate how many bytes are needed to
1581 * completely deserialize the D-Bus message stored at @blob.
1582 *
1583 * Returns: Number of bytes needed or -1 if @error is set (e.g. if
1584 * @blob contains invalid data or not enough data is available to
1585 * determine the size).
1586 *
1587 * Since: 2.26
1588 */
1589 gssize
1590 g_dbus_message_bytes_needed (guchar *blob,
1591 gsize blob_len,
1592 GError **error)
1593 {
1594 gssize ret;
1595
1596 ret = -1;
1597
1598 g_return_val_if_fail (blob != NULL, -1);
1599 g_return_val_if_fail (error == NULL || *error == NULL, -1);
1600 g_return_val_if_fail (blob_len >= 16, -1);
1601
1602 if (blob[0] == 'l')
1603 {
1604 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1605 ret = 12 + 4 + GUINT32_FROM_LE (((guint32 *) blob)[3]);
1606 /* round up so it's a multiple of 8 */
1607 ret = 8 * ((ret + 7)/8);
1608 /* finally add the body size */
1609 ret += GUINT32_FROM_LE (((guint32 *) blob)[1]);
1610 }
1611 else if (blob[0] == 'B')
1612 {
1613 /* core header (12 bytes) + ARRAY of STRUCT of (BYTE,VARIANT) */
1614 ret = 12 + 4 + GUINT32_FROM_BE (((guint32 *) blob)[3]);
1615 /* round up so it's a multiple of 8 */
1616 ret = 8 * ((ret + 7)/8);
1617 /* finally add the body size */
1618 ret += GUINT32_FROM_BE (((guint32 *) blob)[1]);
1619 }
1620 else
1621 {
1622 g_set_error (error,
1623 G_IO_ERROR,
1624 G_IO_ERROR_INVALID_ARGUMENT,
1625 "Unable to determine message blob length - given blob is malformed");
1626 }
1627
1628 if (ret > (2<<27))
1629 {
1630 g_set_error (error,
1631 G_IO_ERROR,
1632 G_IO_ERROR_INVALID_ARGUMENT,
1633 "Blob indicates that message exceeds maximum message length (128MiB)");
1634 ret = -1;
1635 }
1636
1637 return ret;
1638 }
1639
1640 /* ---------------------------------------------------------------------------------------------------- */
1641
1642 /**
1643 * g_dbus_message_new_from_blob:
1644 * @blob: A blob represent a binary D-Bus message.
1645 * @blob_len: The length of @blob.
1646 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
1647 * @error: Return location for error or %NULL.
1648 *
1649 * Creates a new #GDBusMessage from the data stored at @blob. The byte
1650 * order that the message was in can be retrieved using
1651 * g_dbus_message_get_byte_order().
1652 *
1653 * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
1654 * g_object_unref().
1655 *
1656 * Since: 2.26
1657 */
1658 GDBusMessage *
1659 g_dbus_message_new_from_blob (guchar *blob,
1660 gsize blob_len,
1661 GDBusCapabilityFlags capabilities,
1662 GError **error)
1663 {
1664 gboolean ret;
1665 GMemoryInputStream *mis;
1666 GDataInputStream *dis;
1667 GDBusMessage *message;
1668 guchar endianness;
1669 guchar major_protocol_version;
1670 GDataStreamByteOrder byte_order;
1671 guint32 message_body_len;
1672 GVariant *headers;
1673 GVariant *item;
1674 GVariantIter iter;
1675 GVariant *signature;
1676
1677 /* TODO: check against @capabilities */
1678
1679 ret = FALSE;
1680
1681 g_return_val_if_fail (blob != NULL, NULL);
1682 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
1683 g_return_val_if_fail (blob_len >= 12, NULL);
1684
1685 message = g_dbus_message_new ();
1686
1687 mis = G_MEMORY_INPUT_STREAM (g_memory_input_stream_new_from_data (blob, blob_len, NULL));
1688 dis = g_data_input_stream_new (G_INPUT_STREAM (mis));
1689
1690 endianness = g_data_input_stream_read_byte (dis, NULL, NULL);
1691 switch (endianness)
1692 {
1693 case 'l':
1694 byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
1695 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN;
1696 break;
1697 case 'B':
1698 byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
1699 message->byte_order = G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN;
1700 break;
1701 default:
1702 g_set_error (error,
1703 G_IO_ERROR,
1704 G_IO_ERROR_INVALID_ARGUMENT,
1705 _("Invalid endianness value. Expected 0x6c ('l') or 0x42 ('B') but found value 0x%02x"),
1706 endianness);
1707 goto out;
1708 }
1709 g_data_input_stream_set_byte_order (dis, byte_order);
1710
1711 message->type = g_data_input_stream_read_byte (dis, NULL, NULL);
1712 message->flags = g_data_input_stream_read_byte (dis, NULL, NULL);
1713 major_protocol_version = g_data_input_stream_read_byte (dis, NULL, NULL);
1714 if (major_protocol_version != 1)
1715 {
1716 g_set_error (error,
1717 G_IO_ERROR,
1718 G_IO_ERROR_INVALID_ARGUMENT,
1719 _("Invalid major protocol version. Expected 1 but found %d"),
1720 major_protocol_version);
1721 goto out;
1722 }
1723 message_body_len = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1724 message->serial = g_data_input_stream_read_uint32 (dis, NULL, NULL);
1725
1726 #ifdef DEBUG_SERIALIZER
1727 g_print ("Parsing blob (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1728 {
1729 gchar *s;
1730 s = _g_dbus_hexdump ((const gchar *) blob, blob_len, 2);
1731 g_print ("%s\n", s);
1732 g_free (s);
1733 }
1734 #endif /* DEBUG_SERIALIZER */
1735
1736 #ifdef DEBUG_SERIALIZER
1737 g_print ("Parsing headers (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1738 #endif /* DEBUG_SERIALIZER */
1739 headers = parse_value_from_blob (mis,
1740 dis,
1741 G_VARIANT_TYPE ("a{yv}"),
1742 FALSE,
1743 2,
1744 error);
1745 if (headers == NULL)
1746 goto out;
1747 g_variant_iter_init (&iter, headers);
1748 while ((item = g_variant_iter_next_value (&iter)) != NULL)
1749 {
1750 guchar header_field;
1751 GVariant *value;
1752 g_variant_get (item,
1753 "{yv}",
1754 &header_field,
1755 &value);
1756 g_dbus_message_set_header (message, header_field, value);
1757 g_variant_unref (value);
1758 g_variant_unref (item);
1759 }
1760 g_variant_unref (headers);
1761
1762 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
1763 if (signature != NULL)
1764 {
1765 const gchar *signature_str;
1766 gsize signature_str_len;
1767
1768 signature_str = g_variant_get_string (signature, &signature_str_len);
1769
1770 /* signature but no body */
1771 if (message_body_len == 0 && signature_str_len > 0)
1772 {
1773 g_set_error (error,
1774 G_IO_ERROR,
1775 G_IO_ERROR_INVALID_ARGUMENT,
1776 _("Signature header with signature `%s' found but message body is empty"),
1777 signature_str);
1778 goto out;
1779 }
1780 else if (signature_str_len > 0)
1781 {
1782 GVariantType *variant_type;
1783 gchar *tupled_signature_str;
1784
1785 if (!g_variant_is_signature (signature_str))
1786 {
1787 g_set_error (error,
1788 G_IO_ERROR,
1789 G_IO_ERROR_INVALID_ARGUMENT,
1790 _("Parsed value `%s' is not a valid D-Bus signature (for body)"),
1791 signature_str);
1792 goto out;
1793 }
1794 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
1795 variant_type = g_variant_type_new (tupled_signature_str);
1796 g_free (tupled_signature_str);
1797 #ifdef DEBUG_SERIALIZER
1798 g_print ("Parsing body (blob_len = 0x%04x bytes)\n", (gint) blob_len);
1799 #endif /* DEBUG_SERIALIZER */
1800 message->body = parse_value_from_blob (mis,
1801 dis,
1802 variant_type,
1803 FALSE,
1804 2,
1805 error);
1806 g_variant_type_free (variant_type);
1807 if (message->body == NULL)
1808 goto out;
1809 }
1810 }
1811 else
1812 {
1813 /* no signature, this is only OK if the body is empty */
1814 if (message_body_len != 0)
1815 {
1816 /* G_GUINT32_FORMAT doesn't work with gettext, just use %u */
1817 g_set_error (error,
1818 G_IO_ERROR,
1819 G_IO_ERROR_INVALID_ARGUMENT,
1820 g_dngettext (GETTEXT_PACKAGE,
1821 "No signature header in message but the message body is %u byte",
1822 "No signature header in message but the message body is %u bytes",
1823 message_body_len),
1824 message_body_len);
1825 goto out;
1826 }
1827 }
1828
1829 if (!validate_headers (message, error))
1830 {
1831 g_prefix_error (error, _("Cannot deserialize message: "));
1832 goto out;
1833 }
1834
1835 ret = TRUE;
1836
1837 out:
1838 g_object_unref (dis);
1839 g_object_unref (mis);
1840
1841 if (ret)
1842 {
1843 return message;
1844 }
1845 else
1846 {
1847 if (message != NULL)
1848 g_object_unref (message);
1849 return NULL;
1850 }
1851 }
1852
1853 /* ---------------------------------------------------------------------------------------------------- */
1854
1855 static gsize
1856 ensure_output_padding (GMemoryOutputStream *mos,
1857 GDataOutputStream *dos,
1858 gsize padding_size)
1859 {
1860 gsize offset;
1861 gsize wanted_offset;
1862 gsize padding_needed;
1863 guint n;
1864
1865 offset = g_memory_output_stream_get_data_size (mos);
1866 wanted_offset = ((offset + padding_size - 1) / padding_size) * padding_size;
1867 padding_needed = wanted_offset - offset;
1868
1869 for (n = 0; n < padding_needed; n++)
1870 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1871
1872 return padding_needed;
1873 }
1874
1875 /* note that value can be NULL for e.g. empty arrays - type is never NULL */
1876 static gboolean
1877 append_value_to_blob (GVariant *value,
1878 const GVariantType *type,
1879 GMemoryOutputStream *mos,
1880 GDataOutputStream *dos,
1881 gsize *out_padding_added,
1882 GError **error)
1883 {
1884 gsize padding_added;
1885 const gchar *type_string;
1886
1887 type_string = g_variant_type_peek_string (type);
1888
1889 padding_added = 0;
1890
1891 switch (type_string[0])
1892 {
1893 case 'b': /* G_VARIANT_TYPE_BOOLEAN */
1894 padding_added = ensure_output_padding (mos, dos, 4);
1895 if (value != NULL)
1896 {
1897 gboolean v = g_variant_get_boolean (value);
1898 g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1899 }
1900 break;
1901
1902 case 'y': /* G_VARIANT_TYPE_BYTE */
1903 if (value != NULL)
1904 {
1905 guint8 v = g_variant_get_byte (value);
1906 g_data_output_stream_put_byte (dos, v, NULL, NULL);
1907 }
1908 break;
1909
1910 case 'n': /* G_VARIANT_TYPE_INT16 */
1911 padding_added = ensure_output_padding (mos, dos, 2);
1912 if (value != NULL)
1913 {
1914 gint16 v = g_variant_get_int16 (value);
1915 g_data_output_stream_put_int16 (dos, v, NULL, NULL);
1916 }
1917 break;
1918
1919 case 'q': /* G_VARIANT_TYPE_UINT16 */
1920 padding_added = ensure_output_padding (mos, dos, 2);
1921 if (value != NULL)
1922 {
1923 guint16 v = g_variant_get_uint16 (value);
1924 g_data_output_stream_put_uint16 (dos, v, NULL, NULL);
1925 }
1926 break;
1927
1928 case 'i': /* G_VARIANT_TYPE_INT32 */
1929 padding_added = ensure_output_padding (mos, dos, 4);
1930 if (value != NULL)
1931 {
1932 gint32 v = g_variant_get_int32 (value);
1933 g_data_output_stream_put_int32 (dos, v, NULL, NULL);
1934 }
1935 break;
1936
1937 case 'u': /* G_VARIANT_TYPE_UINT32 */
1938 padding_added = ensure_output_padding (mos, dos, 4);
1939 if (value != NULL)
1940 {
1941 guint32 v = g_variant_get_uint32 (value);
1942 g_data_output_stream_put_uint32 (dos, v, NULL, NULL);
1943 }
1944 break;
1945
1946 case 'x': /* G_VARIANT_TYPE_INT64 */
1947 padding_added = ensure_output_padding (mos, dos, 8);
1948 if (value != NULL)
1949 {
1950 gint64 v = g_variant_get_int64 (value);
1951 g_data_output_stream_put_int64 (dos, v, NULL, NULL);
1952 }
1953 break;
1954
1955 case 't': /* G_VARIANT_TYPE_UINT64 */
1956 padding_added = ensure_output_padding (mos, dos, 8);
1957 if (value != NULL)
1958 {
1959 guint64 v = g_variant_get_uint64 (value);
1960 g_data_output_stream_put_uint64 (dos, v, NULL, NULL);
1961 }
1962 break;
1963
1964 case 'd': /* G_VARIANT_TYPE_DOUBLE */
1965 padding_added = ensure_output_padding (mos, dos, 8);
1966 if (value != NULL)
1967 {
1968 union {
1969 guint64 v_uint64;
1970 gdouble v_double;
1971 } u;
1972 G_STATIC_ASSERT (sizeof (gdouble) == sizeof (guint64));
1973 u.v_double = g_variant_get_double (value);
1974 g_data_output_stream_put_uint64 (dos, u.v_uint64, NULL, NULL);
1975 }
1976 break;
1977
1978 case 's': /* G_VARIANT_TYPE_STRING */
1979 padding_added = ensure_output_padding (mos, dos, 4);
1980 if (value != NULL)
1981 {
1982 gsize len;
1983 const gchar *v;
1984 const gchar *end;
1985 v = g_variant_get_string (value, &len);
1986 g_assert (g_utf8_validate (v, -1, &end) && (end == v + len));
1987 g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
1988 g_data_output_stream_put_string (dos, v, NULL, NULL);
1989 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
1990 }
1991 break;
1992
1993 case 'o': /* G_VARIANT_TYPE_OBJECT_PATH */
1994 padding_added = ensure_output_padding (mos, dos, 4);
1995 if (value != NULL)
1996 {
1997 gsize len;
1998 const gchar *v = g_variant_get_string (value, &len);
1999 g_assert (g_variant_is_object_path (v));
2000 g_data_output_stream_put_uint32 (dos, len, NULL, NULL);
2001 g_data_output_stream_put_string (dos, v, NULL, NULL);
2002 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
2003 }
2004 break;
2005
2006 case 'g': /* G_VARIANT_TYPE_SIGNATURE */
2007 if (value != NULL)
2008 {
2009 gsize len;
2010 const gchar *v = g_variant_get_string (value, &len);
2011 g_assert (g_variant_is_signature (v));
2012 g_data_output_stream_put_byte (dos, len, NULL, NULL);
2013 g_data_output_stream_put_string (dos, v, NULL, NULL);
2014 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
2015 }
2016 break;
2017
2018 case 'h': /* G_VARIANT_TYPE_HANDLE */
2019 padding_added = ensure_output_padding (mos, dos, 4);
2020 if (value != NULL)
2021 {
2022 gint32 v = g_variant_get_handle (value);
2023 g_data_output_stream_put_int32 (dos, v, NULL, NULL);
2024 }
2025 break;
2026
2027 case 'a': /* G_VARIANT_TYPE_ARRAY */
2028 {
2029 GVariant *item;
2030 GVariantIter iter;
2031 goffset array_len_offset;
2032 goffset array_payload_begin_offset;
2033 goffset cur_offset;
2034 gsize array_len;
2035
2036 padding_added = ensure_output_padding (mos, dos, 4);
2037 if (value != NULL)
2038 {
2039 /* array length - will be filled in later */
2040 array_len_offset = g_memory_output_stream_get_data_size (mos);
2041 g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2042
2043 /* From the D-Bus spec:
2044 *
2045 * "A UINT32 giving the length of the array data in bytes,
2046 * followed by alignment padding to the alignment boundary of
2047 * the array element type, followed by each array element. The
2048 * array length is from the end of the alignment padding to
2049 * the end of the last element, i.e. it does not include the
2050 * padding after the length, or any padding after the last
2051 * element."
2052 *
2053 * Thus, we need to count how much padding the first element
2054 * contributes and subtract that from the array length.
2055 */
2056 array_payload_begin_offset = g_memory_output_stream_get_data_size (mos);
2057
2058 if (g_variant_n_children (value) == 0)
2059 {
2060 gsize padding_added_for_item;
2061 if (!append_value_to_blob (NULL,
2062 g_variant_type_element (type),
2063 mos,
2064 dos,
2065 &padding_added_for_item,
2066 error))
2067 goto fail;
2068 array_payload_begin_offset += padding_added_for_item;
2069 }
2070 else
2071 {
2072 guint n;
2073 n = 0;
2074 g_variant_iter_init (&iter, value);
2075 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2076 {
2077 gsize padding_added_for_item;
2078 if (!append_value_to_blob (item,
2079 g_variant_get_type (item),
2080 mos,
2081 dos,
2082 &padding_added_for_item,
2083 error))
2084 {
2085 g_variant_unref (item);
2086 goto fail;
2087 }
2088 g_variant_unref (item);
2089 if (n == 0)
2090 {
2091 array_payload_begin_offset += padding_added_for_item;
2092 }
2093 n++;
2094 }
2095 }
2096
2097 cur_offset = g_memory_output_stream_get_data_size (mos);
2098 array_len = cur_offset - array_payload_begin_offset;
2099 if (!g_seekable_seek (G_SEEKABLE (mos), array_len_offset, G_SEEK_SET, NULL, error))
2100 goto fail;
2101
2102 g_data_output_stream_put_uint32 (dos, array_len, NULL, NULL);
2103 if (!g_seekable_seek (G_SEEKABLE (mos), cur_offset, G_SEEK_SET, NULL, error))
2104 goto fail;
2105 }
2106 }
2107 break;
2108
2109 default:
2110 if (g_variant_type_is_dict_entry (type) || g_variant_type_is_tuple (type))
2111 {
2112 padding_added = ensure_output_padding (mos, dos, 8);
2113 if (value != NULL)
2114 {
2115 GVariant *item;
2116 GVariantIter iter;
2117 g_variant_iter_init (&iter, value);
2118 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2119 {
2120 if (!append_value_to_blob (item,
2121 g_variant_get_type (item),
2122 mos,
2123 dos,
2124 NULL,
2125 error))
2126 {
2127 g_variant_unref (item);
2128 goto fail;
2129 }
2130 g_variant_unref (item);
2131 }
2132 }
2133 }
2134 else if (g_variant_type_is_variant (type))
2135 {
2136 if (value != NULL)
2137 {
2138 GVariant *child;
2139 const gchar *signature;
2140 child = g_variant_get_child_value (value, 0);
2141 signature = g_variant_get_type_string (child);
2142 g_data_output_stream_put_byte (dos, strlen (signature), NULL, NULL);
2143 g_data_output_stream_put_string (dos, signature, NULL, NULL);
2144 g_data_output_stream_put_byte (dos, '\0', NULL, NULL);
2145 if (!append_value_to_blob (child,
2146 g_variant_get_type (child),
2147 mos,
2148 dos,
2149 NULL,
2150 error))
2151 {
2152 g_variant_unref (child);
2153 goto fail;
2154 }
2155 g_variant_unref (child);
2156 }
2157 }
2158 else
2159 {
2160 g_set_error (error,
2161 G_IO_ERROR,
2162 G_IO_ERROR_INVALID_ARGUMENT,
2163 _("Error serializing GVariant with type string `%s' to the D-Bus wire format"),
2164 g_variant_get_type_string (value));
2165 goto fail;
2166 }
2167 break;
2168 }
2169
2170 if (out_padding_added != NULL)
2171 *out_padding_added = padding_added;
2172
2173 return TRUE;
2174
2175 fail:
2176 return FALSE;
2177 }
2178
2179 static gboolean
2180 append_body_to_blob (GVariant *value,
2181 GMemoryOutputStream *mos,
2182 GDataOutputStream *dos,
2183 GError **error)
2184 {
2185 GVariant *item;
2186 GVariantIter iter;
2187
2188 if (!g_variant_is_of_type (value, G_VARIANT_TYPE_TUPLE))
2189 {
2190 g_set_error (error,
2191 G_IO_ERROR,
2192 G_IO_ERROR_INVALID_ARGUMENT,
2193 "Expected a tuple for the body of the GDBusMessage.");
2194 goto fail;
2195 }
2196
2197 g_variant_iter_init (&iter, value);
2198 while ((item = g_variant_iter_next_value (&iter)) != NULL)
2199 {
2200 if (!append_value_to_blob (item,
2201 g_variant_get_type (item),
2202 mos,
2203 dos,
2204 NULL,
2205 error))
2206 {
2207 g_variant_unref (item);
2208 goto fail;
2209 }
2210 g_variant_unref (item);
2211 }
2212 return TRUE;
2213
2214 fail:
2215 return FALSE;
2216 }
2217
2218 /* ---------------------------------------------------------------------------------------------------- */
2219
2220 /**
2221 * g_dbus_message_to_blob:
2222 * @message: A #GDBusMessage.
2223 * @out_size: Return location for size of generated blob.
2224 * @capabilities: A #GDBusCapabilityFlags describing what protocol features are supported.
2225 * @error: Return location for error.
2226 *
2227 * Serializes @message to a blob. The byte order returned by
2228 * g_dbus_message_get_byte_order() will be used.
2229 *
2230 * Returns: A pointer to a valid binary D-Bus message of @out_size bytes
2231 * generated by @message or %NULL if @error is set. Free with g_free().
2232 *
2233 * Since: 2.26
2234 */
2235 guchar *
2236 g_dbus_message_to_blob (GDBusMessage *message,
2237 gsize *out_size,
2238 GDBusCapabilityFlags capabilities,
2239 GError **error)
2240 {
2241 GMemoryOutputStream *mos;
2242 GDataOutputStream *dos;
2243 guchar *ret;
2244 gsize size;
2245 GDataStreamByteOrder byte_order;
2246 goffset body_len_offset;
2247 goffset body_start_offset;
2248 gsize body_size;
2249 GVariant *header_fields;
2250 GVariantBuilder builder;
2251 GHashTableIter hash_iter;
2252 gpointer key;
2253 GVariant *header_value;
2254 GVariant *signature;
2255 const gchar *signature_str;
2256 gint num_fds_in_message;
2257 gint num_fds_according_to_header;
2258
2259 /* TODO: check against @capabilities */
2260
2261 ret = NULL;
2262
2263 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2264 g_return_val_if_fail (out_size != NULL, NULL);
2265 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
2266
2267 mos = G_MEMORY_OUTPUT_STREAM (g_memory_output_stream_new (NULL, 0, g_realloc, g_free));
2268 dos = g_data_output_stream_new (G_OUTPUT_STREAM (mos));
2269
2270 byte_order = G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN;
2271 switch (message->byte_order)
2272 {
2273 case G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN:
2274 byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN;
2275 break;
2276 case G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN:
2277 byte_order = G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
2278 break;
2279 }
2280 g_data_output_stream_set_byte_order (dos, byte_order);
2281
2282 /* Core header */
2283 g_data_output_stream_put_byte (dos, (guchar) message->byte_order, NULL, NULL);
2284 g_data_output_stream_put_byte (dos, message->type, NULL, NULL);
2285 g_data_output_stream_put_byte (dos, message->flags, NULL, NULL);
2286 g_data_output_stream_put_byte (dos, 1, NULL, NULL); /* major protocol version */
2287 body_len_offset = g_memory_output_stream_get_data_size (mos);
2288 /* body length - will be filled in later */
2289 g_data_output_stream_put_uint32 (dos, 0xF00DFACE, NULL, NULL);
2290 g_data_output_stream_put_uint32 (dos, message->serial, NULL, NULL);
2291
2292 num_fds_in_message = 0;
2293 #ifdef G_OS_UNIX
2294 if (message->fd_list != NULL)
2295 num_fds_in_message = g_unix_fd_list_get_length (message->fd_list);
2296 #endif
2297 num_fds_according_to_header = g_dbus_message_get_num_unix_fds (message);
2298 if (num_fds_in_message != num_fds_according_to_header)
2299 {
2300 g_set_error (error,
2301 G_IO_ERROR,
2302 G_IO_ERROR_INVALID_ARGUMENT,
2303 _("Message has %d file descriptors but the header field indicates %d file descriptors"),
2304 num_fds_in_message,
2305 num_fds_according_to_header);
2306 goto out;
2307 }
2308
2309 if (!validate_headers (message, error))
2310 {
2311 g_prefix_error (error, _("Cannot serialize message: "));
2312 goto out;
2313 }
2314
2315 g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{yv}"));
2316 g_hash_table_iter_init (&hash_iter, message->headers);
2317 while (g_hash_table_iter_next (&hash_iter, &key, (gpointer) &header_value))
2318 {
2319 g_variant_builder_add (&builder,
2320 "{yv}",
2321 (guchar) GPOINTER_TO_UINT (key),
2322 header_value);
2323 }
2324 header_fields = g_variant_builder_end (&builder);
2325
2326 if (!append_value_to_blob (header_fields,
2327 g_variant_get_type (header_fields),
2328 mos, dos,
2329 NULL,
2330 error))
2331 {
2332 g_variant_unref (header_fields);
2333 goto out;
2334 }
2335 g_variant_unref (header_fields);
2336
2337 /* header size must be a multiple of 8 */
2338 ensure_output_padding (mos, dos, 8);
2339
2340 body_start_offset = g_memory_output_stream_get_data_size (mos);
2341
2342 signature = g_dbus_message_get_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2343 signature_str = NULL;
2344 if (signature != NULL)
2345 signature_str = g_variant_get_string (signature, NULL);
2346 if (message->body != NULL)
2347 {
2348 gchar *tupled_signature_str;
2349 tupled_signature_str = g_strdup_printf ("(%s)", signature_str);
2350 if (signature == NULL)
2351 {
2352 g_set_error (error,
2353 G_IO_ERROR,
2354 G_IO_ERROR_INVALID_ARGUMENT,
2355 _("Message body has signature `%s' but there is no signature header"),
2356 signature_str);
2357 g_free (tupled_signature_str);
2358 goto out;
2359 }
2360 else if (g_strcmp0 (tupled_signature_str, g_variant_get_type_string (message->body)) != 0)
2361 {
2362 g_set_error (error,
2363 G_IO_ERROR,
2364 G_IO_ERROR_INVALID_ARGUMENT,
2365 _("Message body has type signature `%s' but signature in the header field is `%s'"),
2366 tupled_signature_str, g_variant_get_type_string (message->body));
2367 g_free (tupled_signature_str);
2368 goto out;
2369 }
2370 g_free (tupled_signature_str);
2371 if (!append_body_to_blob (message->body, mos, dos, error))
2372 goto out;
2373 }
2374 else
2375 {
2376 if (signature != NULL && strlen (signature_str) > 0)
2377 {
2378 g_set_error (error,
2379 G_IO_ERROR,
2380 G_IO_ERROR_INVALID_ARGUMENT,
2381 _("Message body is empty but signature in the header field is `(%s)'"),
2382 signature_str);
2383 goto out;
2384 }
2385 }
2386
2387 /* OK, we're done writing the message - set the body length */
2388 size = g_memory_output_stream_get_data_size (mos);
2389 body_size = size - body_start_offset;
2390
2391 if (!g_seekable_seek (G_SEEKABLE (mos), body_len_offset, G_SEEK_SET, NULL, error))
2392 goto out;
2393
2394 g_data_output_stream_put_uint32 (dos, body_size, NULL, NULL);
2395
2396 if (!g_output_stream_close (G_OUTPUT_STREAM (dos), NULL, error))
2397 goto out;
2398
2399 *out_size = size;
2400 ret = g_memory_output_stream_steal_data (mos);
2401
2402 out:
2403 g_object_unref (dos);
2404 g_object_unref (mos);
2405
2406 return ret;
2407 }
2408
2409 /* ---------------------------------------------------------------------------------------------------- */
2410
2411 static guint32
2412 get_uint32_header (GDBusMessage *message,
2413 GDBusMessageHeaderField header_field)
2414 {
2415 GVariant *value;
2416 guint32 ret;
2417
2418 ret = 0;
2419 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2420 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32))
2421 ret = g_variant_get_uint32 (value);
2422
2423 return ret;
2424 }
2425
2426 static const gchar *
2427 get_string_header (GDBusMessage *message,
2428 GDBusMessageHeaderField header_field)
2429 {
2430 GVariant *value;
2431 const gchar *ret;
2432
2433 ret = NULL;
2434 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2435 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
2436 ret = g_variant_get_string (value, NULL);
2437
2438 return ret;
2439 }
2440
2441 static const gchar *
2442 get_object_path_header (GDBusMessage *message,
2443 GDBusMessageHeaderField header_field)
2444 {
2445 GVariant *value;
2446 const gchar *ret;
2447
2448 ret = NULL;
2449 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2450 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
2451 ret = g_variant_get_string (value, NULL);
2452
2453 return ret;
2454 }
2455
2456 static const gchar *
2457 get_signature_header (GDBusMessage *message,
2458 GDBusMessageHeaderField header_field)
2459 {
2460 GVariant *value;
2461 const gchar *ret;
2462
2463 ret = NULL;
2464 value = g_hash_table_lookup (message->headers, GUINT_TO_POINTER (header_field));
2465 if (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_SIGNATURE))
2466 ret = g_variant_get_string (value, NULL);
2467
2468 return ret;
2469 }
2470
2471 /* ---------------------------------------------------------------------------------------------------- */
2472
2473 static void
2474 set_uint32_header (GDBusMessage *message,
2475 GDBusMessageHeaderField header_field,
2476 guint32 value)
2477 {
2478 g_dbus_message_set_header (message,
2479 header_field,
2480 g_variant_new_uint32 (value));
2481 }
2482
2483 static void
2484 set_string_header (GDBusMessage *message,
2485 GDBusMessageHeaderField header_field,
2486 const gchar *value)
2487 {
2488 g_dbus_message_set_header (message,
2489 header_field,
2490 value == NULL ? NULL : g_variant_new_string (value));
2491 }
2492
2493 static void
2494 set_object_path_header (GDBusMessage *message,
2495 GDBusMessageHeaderField header_field,
2496 const gchar *value)
2497 {
2498 g_dbus_message_set_header (message,
2499 header_field,
2500 value == NULL ? NULL : g_variant_new_object_path (value));
2501 }
2502
2503 static void
2504 set_signature_header (GDBusMessage *message,
2505 GDBusMessageHeaderField header_field,
2506 const gchar *value)
2507 {
2508 g_dbus_message_set_header (message,
2509 header_field,
2510 value == NULL ? NULL : g_variant_new_signature (value));
2511 }
2512
2513 /* ---------------------------------------------------------------------------------------------------- */
2514
2515 /**
2516 * g_dbus_message_get_reply_serial:
2517 * @message: A #GDBusMessage.
2518 *
2519 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2520 *
2521 * Returns: The value.
2522 *
2523 * Since: 2.26
2524 */
2525 guint32
2526 g_dbus_message_get_reply_serial (GDBusMessage *message)
2527 {
2528 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2529 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL);
2530 }
2531
2532 /**
2533 * g_dbus_message_set_reply_serial:
2534 * @message: A #GDBusMessage.
2535 * @value: The value to set.
2536 *
2537 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
2538 *
2539 * Since: 2.26
2540 */
2541 void
2542 g_dbus_message_set_reply_serial (GDBusMessage *message,
2543 guint32 value)
2544 {
2545 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2546 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL, value);
2547 }
2548
2549 /* ---------------------------------------------------------------------------------------------------- */
2550
2551 /**
2552 * g_dbus_message_get_interface:
2553 * @message: A #GDBusMessage.
2554 *
2555 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2556 *
2557 * Returns: The value.
2558 *
2559 * Since: 2.26
2560 */
2561 const gchar *
2562 g_dbus_message_get_interface (GDBusMessage *message)
2563 {
2564 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2565 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE);
2566 }
2567
2568 /**
2569 * g_dbus_message_set_interface:
2570 * @message: A #GDBusMessage.
2571 * @value: The value to set.
2572 *
2573 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
2574 *
2575 * Since: 2.26
2576 */
2577 void
2578 g_dbus_message_set_interface (GDBusMessage *message,
2579 const gchar *value)
2580 {
2581 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2582 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2583 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE, value);
2584 }
2585
2586 /* ---------------------------------------------------------------------------------------------------- */
2587
2588 /**
2589 * g_dbus_message_get_member:
2590 * @message: A #GDBusMessage.
2591 *
2592 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2593 *
2594 * Returns: The value.
2595 *
2596 * Since: 2.26
2597 */
2598 const gchar *
2599 g_dbus_message_get_member (GDBusMessage *message)
2600 {
2601 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2602 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER);
2603 }
2604
2605 /**
2606 * g_dbus_message_set_member:
2607 * @message: A #GDBusMessage.
2608 * @value: The value to set.
2609 *
2610 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
2611 *
2612 * Since: 2.26
2613 */
2614 void
2615 g_dbus_message_set_member (GDBusMessage *message,
2616 const gchar *value)
2617 {
2618 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2619 g_return_if_fail (value == NULL || g_dbus_is_member_name (value));
2620 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_MEMBER, value);
2621 }
2622
2623 /* ---------------------------------------------------------------------------------------------------- */
2624
2625 /**
2626 * g_dbus_message_get_path:
2627 * @message: A #GDBusMessage.
2628 *
2629 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2630 *
2631 * Returns: The value.
2632 *
2633 * Since: 2.26
2634 */
2635 const gchar *
2636 g_dbus_message_get_path (GDBusMessage *message)
2637 {
2638 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2639 return get_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH);
2640 }
2641
2642 /**
2643 * g_dbus_message_set_path:
2644 * @message: A #GDBusMessage.
2645 * @value: The value to set.
2646 *
2647 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
2648 *
2649 * Since: 2.26
2650 */
2651 void
2652 g_dbus_message_set_path (GDBusMessage *message,
2653 const gchar *value)
2654 {
2655 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2656 g_return_if_fail (value == NULL || g_variant_is_object_path (value));
2657 set_object_path_header (message, G_DBUS_MESSAGE_HEADER_FIELD_PATH, value);
2658 }
2659
2660 /* ---------------------------------------------------------------------------------------------------- */
2661
2662 /**
2663 * g_dbus_message_get_sender:
2664 * @message: A #GDBusMessage.
2665 *
2666 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2667 *
2668 * Returns: The value.
2669 *
2670 * Since: 2.26
2671 */
2672 const gchar *
2673 g_dbus_message_get_sender (GDBusMessage *message)
2674 {
2675 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2676 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER);
2677 }
2678
2679 /**
2680 * g_dbus_message_set_sender:
2681 * @message: A #GDBusMessage.
2682 * @value: The value to set.
2683 *
2684 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
2685 *
2686 * Since: 2.26
2687 */
2688 void
2689 g_dbus_message_set_sender (GDBusMessage *message,
2690 const gchar *value)
2691 {
2692 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2693 g_return_if_fail (value == NULL || g_dbus_is_name (value));
2694 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SENDER, value);
2695 }
2696
2697 /* ---------------------------------------------------------------------------------------------------- */
2698
2699 /**
2700 * g_dbus_message_get_destination:
2701 * @message: A #GDBusMessage.
2702 *
2703 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2704 *
2705 * Returns: The value.
2706 *
2707 * Since: 2.26
2708 */
2709 const gchar *
2710 g_dbus_message_get_destination (GDBusMessage *message)
2711 {
2712 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2713 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION);
2714 }
2715
2716 /**
2717 * g_dbus_message_set_destination:
2718 * @message: A #GDBusMessage.
2719 * @value: The value to set.
2720 *
2721 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
2722 *
2723 * Since: 2.26
2724 */
2725 void
2726 g_dbus_message_set_destination (GDBusMessage *message,
2727 const gchar *value)
2728 {
2729 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2730 g_return_if_fail (value == NULL || g_dbus_is_name (value));
2731 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION, value);
2732 }
2733
2734 /* ---------------------------------------------------------------------------------------------------- */
2735
2736 /**
2737 * g_dbus_message_get_error_name:
2738 * @message: A #GDBusMessage.
2739 *
2740 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2741 *
2742 * Returns: The value.
2743 *
2744 * Since: 2.26
2745 */
2746 const gchar *
2747 g_dbus_message_get_error_name (GDBusMessage *message)
2748 {
2749 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2750 return get_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME);
2751 }
2752
2753 /**
2754 * g_dbus_message_set_error_name:
2755 * @message: A #GDBusMessage.
2756 * @value: The value to set.
2757 *
2758 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
2759 *
2760 * Since: 2.26
2761 */
2762 void
2763 g_dbus_message_set_error_name (GDBusMessage *message,
2764 const gchar *value)
2765 {
2766 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2767 g_return_if_fail (value == NULL || g_dbus_is_interface_name (value));
2768 set_string_header (message, G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME, value);
2769 }
2770
2771 /* ---------------------------------------------------------------------------------------------------- */
2772
2773 /**
2774 * g_dbus_message_get_signature:
2775 * @message: A #GDBusMessage.
2776 *
2777 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2778 *
2779 * Returns: The value.
2780 *
2781 * Since: 2.26
2782 */
2783 const gchar *
2784 g_dbus_message_get_signature (GDBusMessage *message)
2785 {
2786 const gchar *ret;
2787 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2788 ret = get_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE);
2789 if (ret == NULL)
2790 ret = "";
2791 return ret;
2792 }
2793
2794 /**
2795 * g_dbus_message_set_signature:
2796 * @message: A #GDBusMessage.
2797 * @value: The value to set.
2798 *
2799 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
2800 *
2801 * Since: 2.26
2802 */
2803 void
2804 g_dbus_message_set_signature (GDBusMessage *message,
2805 const gchar *value)
2806 {
2807 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2808 g_return_if_fail (value == NULL || g_variant_is_signature (value));
2809 set_signature_header (message, G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE, value);
2810 }
2811
2812 /* ---------------------------------------------------------------------------------------------------- */
2813
2814 /**
2815 * g_dbus_message_get_arg0:
2816 * @message: A #GDBusMessage.
2817 *
2818 * Convenience to get the first item in the body of @message.
2819 *
2820 * Returns: The string item or %NULL if the first item in the body of
2821 * @message is not a string.
2822 *
2823 * Since: 2.26
2824 */
2825 const gchar *
2826 g_dbus_message_get_arg0 (GDBusMessage *message)
2827 {
2828 const gchar *ret;
2829
2830 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
2831
2832 ret = NULL;
2833
2834 if (message->body != NULL && g_variant_is_of_type (message->body, G_VARIANT_TYPE_TUPLE))
2835 {
2836 GVariant *item;
2837 item = g_variant_get_child_value (message->body, 0);
2838 if (g_variant_is_of_type (item, G_VARIANT_TYPE_STRING))
2839 ret = g_variant_get_string (item, NULL);
2840 g_variant_unref (item);
2841 }
2842
2843 return ret;
2844 }
2845
2846 /* ---------------------------------------------------------------------------------------------------- */
2847
2848 /**
2849 * g_dbus_message_get_num_unix_fds:
2850 * @message: A #GDBusMessage.
2851 *
2852 * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2853 *
2854 * Returns: The value.
2855 *
2856 * Since: 2.26
2857 */
2858 guint32
2859 g_dbus_message_get_num_unix_fds (GDBusMessage *message)
2860 {
2861 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), 0);
2862 return get_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS);
2863 }
2864
2865 /**
2866 * g_dbus_message_set_num_unix_fds:
2867 * @message: A #GDBusMessage.
2868 * @value: The value to set.
2869 *
2870 * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
2871 *
2872 * Since: 2.26
2873 */
2874 void
2875 g_dbus_message_set_num_unix_fds (GDBusMessage *message,
2876 guint32 value)
2877 {
2878 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
2879 set_uint32_header (message, G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS, value);
2880 }
2881
2882 /* ---------------------------------------------------------------------------------------------------- */
2883
2884 /**
2885 * g_dbus_message_to_gerror:
2886 * @message: A #GDBusMessage.
2887 * @error: The #GError to set.
2888 *
2889 * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
2890 * nothing and returns %FALSE.
2891 *
2892 * Otherwise this method encodes the error in @message as a #GError
2893 * using g_dbus_error_set_dbus_error() using the information in the
2894 * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
2895 * well as the first string item in @message's body.
2896 *
2897 * Returns: %TRUE if @error was set, %FALSE otherwise.
2898 *
2899 * Since: 2.26
2900 */
2901 gboolean
2902 g_dbus_message_to_gerror (GDBusMessage *message,
2903 GError **error)
2904 {
2905 gboolean ret;
2906 const gchar *error_name;
2907
2908 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
2909
2910 ret = FALSE;
2911 if (message->type != G_DBUS_MESSAGE_TYPE_ERROR)
2912 goto out;
2913
2914 error_name = g_dbus_message_get_error_name (message);
2915 if (error_name != NULL)
2916 {
2917 GVariant *body;
2918
2919 body = g_dbus_message_get_body (message);
2920
2921 if (body != NULL && g_variant_is_of_type (body, G_VARIANT_TYPE ("(s)")))
2922 {
2923 const gchar *error_message;
2924 g_variant_get (body, "(&s)", &error_message);
2925 g_dbus_error_set_dbus_error (error,
2926 error_name,
2927 error_message,
2928 NULL);
2929 }
2930 else
2931 {
2932 /* these two situations are valid, yet pretty rare */
2933 if (body != NULL)
2934 {
2935 g_dbus_error_set_dbus_error (error,
2936 error_name,
2937 "",
2938 _("Error return with body of type `%s'"),
2939 g_variant_get_type_string (body));
2940 }
2941 else
2942 {
2943 g_dbus_error_set_dbus_error (error,
2944 error_name,
2945 "",
2946 _("Error return with empty body"));
2947 }
2948 }
2949 }
2950 else
2951 {
2952 /* TOOD: this shouldn't happen - should check this at message serialization
2953 * time and disconnect the peer.
2954 */
2955 g_set_error (error,
2956 G_IO_ERROR,
2957 G_IO_ERROR_FAILED,
2958 "Error return without error-name header!");
2959 }
2960
2961 ret = TRUE;
2962
2963 out:
2964 return ret;
2965 }
2966
2967 /* ---------------------------------------------------------------------------------------------------- */
2968
2969 static gchar *
2970 flags_to_string (GType flags_type, guint value)
2971 {
2972 GString *s;
2973 GFlagsClass *klass;
2974 guint n;
2975
2976 klass = g_type_class_ref (flags_type);
2977 s = g_string_new (NULL);
2978 for (n = 0; n < 32; n++)
2979 {
2980 if ((value & (1<<n)) != 0)
2981 {
2982 GFlagsValue *flags_value;
2983 flags_value = g_flags_get_first_value (klass, (1<<n));
2984 if (s->len > 0)
2985 g_string_append_c (s, ',');
2986 if (flags_value != NULL)
2987 g_string_append (s, flags_value->value_nick);
2988 else
2989 g_string_append_printf (s, "unknown (bit %d)", n);
2990 }
2991 }
2992 if (s->len == 0)
2993 g_string_append (s, "none");
2994 g_type_class_unref (klass);
2995 return g_string_free (s, FALSE);
2996 }
2997
2998 static gint
2999 _sort_keys_func (gconstpointer a,
3000 gconstpointer b)
3001 {
3002 gint ia;
3003 gint ib;
3004
3005 ia = GPOINTER_TO_INT (a);
3006 ib = GPOINTER_TO_INT (b);
3007
3008 return ia - ib;
3009 }
3010
3011 /**
3012 * g_dbus_message_print:
3013 * @message: A #GDBusMessage.
3014 * @indent: Indentation level.
3015 *
3016 * Produces a human-readable multi-line description of @message.
3017 *
3018 * The contents of the description has no ABI guarantees, the contents
3019 * and formatting is subject to change at any time. Typical output
3020 * looks something like this:
3021 * <programlisting>
3022 * Type: method-call
3023 * Flags: none
3024 * Version: 0
3025 * Serial: 4
3026 * Headers:
3027 * path -> objectpath '/org/gtk/GDBus/TestObject'
3028 * interface -> 'org.gtk.GDBus.TestInterface'
3029 * member -> 'GimmeStdout'
3030 * destination -> ':1.146'
3031 * Body: ()
3032 * UNIX File Descriptors:
3033 * (none)
3034 * </programlisting>
3035 * or
3036 * <programlisting>
3037 * Type: method-return
3038 * Flags: no-reply-expected
3039 * Version: 0
3040 * Serial: 477
3041 * Headers:
3042 * reply-serial -> uint32 4
3043 * destination -> ':1.159'
3044 * sender -> ':1.146'
3045 * num-unix-fds -> uint32 1
3046 * Body: ()
3047 * UNIX File Descriptors:
3048 * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
3049 * </programlisting>
3050 *
3051 * Returns: A string that should be freed with g_free().
3052 *
3053 * Since: 2.26
3054 */
3055 gchar *
3056 g_dbus_message_print (GDBusMessage *message,
3057 guint indent)
3058 {
3059 GString *str;
3060 gchar *s;
3061 GList *keys;
3062 GList *l;
3063
3064 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3065
3066 str = g_string_new (NULL);
3067
3068 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, message->type);
3069 g_string_append_printf (str, "%*sType: %s\n", indent, "", s);
3070 g_free (s);
3071 s = flags_to_string (G_TYPE_DBUS_MESSAGE_FLAGS, message->flags);
3072 g_string_append_printf (str, "%*sFlags: %s\n", indent, "", s);
3073 g_free (s);
3074 g_string_append_printf (str, "%*sVersion: %d\n", indent, "", message->major_protocol_version);
3075 g_string_append_printf (str, "%*sSerial: %d\n", indent, "", message->serial);
3076
3077 g_string_append_printf (str, "%*sHeaders:\n", indent, "");
3078 keys = g_hash_table_get_keys (message->headers);
3079 keys = g_list_sort (keys, _sort_keys_func);
3080 if (keys != NULL)
3081 {
3082 for (l = keys; l != NULL; l = l->next)
3083 {
3084 gint key = GPOINTER_TO_INT (l->data);
3085 GVariant *value;
3086 gchar *value_str;
3087
3088 value = g_hash_table_lookup (message->headers, l->data);
3089 g_assert (value != NULL);
3090
3091 s = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_HEADER_FIELD, key);
3092 value_str = g_variant_print (value, TRUE);
3093 g_string_append_printf (str, "%*s %s -> %s\n", indent, "", s, value_str);
3094 g_free (s);
3095 g_free (value_str);
3096 }
3097 }
3098 else
3099 {
3100 g_string_append_printf (str, "%*s (none)\n", indent, "");
3101 }
3102 g_string_append_printf (str, "%*sBody: ", indent, "");
3103 if (message->body != NULL)
3104 {
3105 g_variant_print_string (message->body,
3106 str,
3107 TRUE);
3108 }
3109 else
3110 {
3111 g_string_append (str, "()");
3112 }
3113 g_string_append (str, "\n");
3114 #ifdef G_OS_UNIX
3115 g_string_append_printf (str, "%*sUNIX File Descriptors:\n", indent, "");
3116 if (message->fd_list != NULL)
3117 {
3118 gint num_fds;
3119 const gint *fds;
3120 gint n;
3121
3122 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3123 if (num_fds > 0)
3124 {
3125 for (n = 0; n < num_fds; n++)
3126 {
3127 GString *fs;
3128 struct stat statbuf;
3129 fs = g_string_new (NULL);
3130 if (fstat (fds[n], &statbuf) == 0)
3131 {
3132 g_string_append_printf (fs, "%s" "dev=%d:%d", fs->len > 0 ? "," : "",
3133 major (statbuf.st_dev), minor (statbuf.st_dev));
3134 g_string_append_printf (fs, "%s" "mode=0%o", fs->len > 0 ? "," : "",
3135 statbuf.st_mode);
3136 g_string_append_printf (fs, "%s" "ino=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3137 (guint64) statbuf.st_ino);
3138 g_string_append_printf (fs, "%s" "uid=%d", fs->len > 0 ? "," : "",
3139 statbuf.st_uid);
3140 g_string_append_printf (fs, "%s" "gid=%d", fs->len > 0 ? "," : "",
3141 statbuf.st_gid);
3142 g_string_append_printf (fs, "%s" "rdev=%d:%d", fs->len > 0 ? "," : "",
3143 major (statbuf.st_rdev), minor (statbuf.st_rdev));
3144 g_string_append_printf (fs, "%s" "size=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3145 (guint64) statbuf.st_size);
3146 g_string_append_printf (fs, "%s" "atime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3147 (guint64) statbuf.st_atime);
3148 g_string_append_printf (fs, "%s" "mtime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3149 (guint64) statbuf.st_mtime);
3150 g_string_append_printf (fs, "%s" "ctime=%" G_GUINT64_FORMAT, fs->len > 0 ? "," : "",
3151 (guint64) statbuf.st_ctime);
3152 }
3153 else
3154 {
3155 g_string_append_printf (fs, "(fstat failed: %s)", strerror (errno));
3156 }
3157 g_string_append_printf (str, "%*s fd %d: %s\n", indent, "", fds[n], fs->str);
3158 g_string_free (fs, TRUE);
3159 }
3160 }
3161 else
3162 {
3163 g_string_append_printf (str, "%*s (empty)\n", indent, "");
3164 }
3165 }
3166 else
3167 {
3168 g_string_append_printf (str, "%*s (none)\n", indent, "");
3169 }
3170 #endif
3171
3172 return g_string_free (str, FALSE);
3173 }
3174
3175 /**
3176 * g_dbus_message_get_locked:
3177 * @message: A #GDBusMessage.
3178 *
3179 * Checks whether @message is locked. To monitor changes to this
3180 * value, conncet to the #GObject::notify signal to listen for changes
3181 * on the #GDBusMessage:locked property.
3182 *
3183 * Returns: %TRUE if @message is locked, %FALSE otherwise.
3184 *
3185 * Since: 2.26
3186 */
3187 gboolean
3188 g_dbus_message_get_locked (GDBusMessage *message)
3189 {
3190 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), FALSE);
3191 return message->locked;
3192 }
3193
3194 /**
3195 * g_dbus_message_lock:
3196 * @message: A #GDBusMessage.
3197 *
3198 * If @message is locked, does nothing. Otherwise locks the message.
3199 *
3200 * Since: 2.26
3201 */
3202 void
3203 g_dbus_message_lock (GDBusMessage *message)
3204 {
3205 g_return_if_fail (G_IS_DBUS_MESSAGE (message));
3206
3207 if (message->locked)
3208 goto out;
3209
3210 message->locked = TRUE;
3211 g_object_notify (G_OBJECT (message), "locked");
3212
3213 out:
3214 ;
3215 }
3216
3217 /**
3218 * g_dbus_message_copy:
3219 * @message: A #GDBusMessage.
3220 * @error: Return location for error or %NULL.
3221 *
3222 * Copies @message. The copy is a deep copy and the returned
3223 * #GDBusMessage is completely identical except that it is guaranteed
3224 * to not be locked.
3225 *
3226 * This operation can fail if e.g. @message contains file descriptors
3227 * and the per-process or system-wide open files limit is reached.
3228 *
3229 * Returns: (transfer full): A new #GDBusMessage or %NULL if @error is set.
3230 * Free with g_object_unref().
3231 *
3232 * Since: 2.26
3233 */
3234 GDBusMessage *
3235 g_dbus_message_copy (GDBusMessage *message,
3236 GError **error)
3237 {
3238 GDBusMessage *ret;
3239 GHashTableIter iter;
3240 gpointer header_key;
3241 GVariant *header_value;
3242
3243 g_return_val_if_fail (G_IS_DBUS_MESSAGE (message), NULL);
3244 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
3245
3246 ret = g_dbus_message_new ();
3247 ret->type = message->type;
3248 ret->flags = message->flags;
3249 ret->byte_order = message->byte_order;
3250 ret->major_protocol_version = message->major_protocol_version;
3251 ret->serial = message->serial;
3252
3253 #ifdef G_OS_UNIX
3254 if (message->fd_list != NULL)
3255 {
3256 gint n;
3257 gint num_fds;
3258 const gint *fds;
3259
3260 ret->fd_list = g_unix_fd_list_new ();
3261 fds = g_unix_fd_list_peek_fds (message->fd_list, &num_fds);
3262 for (n = 0; n < num_fds; n++)
3263 {
3264 if (g_unix_fd_list_append (ret->fd_list,
3265 fds[n],
3266 error) == -1)
3267 {
3268 g_object_unref (ret);
3269 ret = NULL;
3270 goto out;
3271 }
3272 }
3273 }
3274 #endif
3275
3276 /* see https://bugzilla.gnome.org/show_bug.cgi?id=624546#c8 for why it's fine
3277 * to just ref (as opposed to deep-copying) the GVariant instances
3278 */
3279 ret->body = message->body != NULL ? g_variant_ref (message->body) : NULL;
3280 g_hash_table_iter_init (&iter, message->headers);
3281 while (g_hash_table_iter_next (&iter, &header_key, (gpointer) &header_value))
3282 g_hash_table_insert (ret->headers, header_key, g_variant_ref (header_value));
3283
3284 out:
3285 return ret;
3286 }
glib mirror