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