gio/gdbusutils.c

   1 /* GDBus - GLib D-Bus Library
   2  *
   3  * Copyright (C) 2008-2010 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: David Zeuthen <davidz@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "gdbusutils.h"
  29
  30 #include "glibintl.h"
  31
  32 /**
  33  * SECTION:gdbusutils
  34  * @title: D-Bus Utilities
  35  * @short_description: Various utilities related to D-Bus.
  36  * @include: gio/gio.h
  37  *
  38  * Various utility routines related to D-Bus.
  39  */
  40
  41 static gboolean
  42 is_valid_bus_name_character (gint c,
  43                              gboolean allow_hyphen)
  44 {
  45   return
  46     (c >= '0' && c <= '9') ||
  47     (c >= 'A' && c <= 'Z') ||
  48     (c >= 'a' && c <= 'z') ||
  49     (c == '_') ||
  50     (allow_hyphen && c == '-');
  51 }
  52
  53 static gboolean
  54 is_valid_initial_bus_name_character (gint c,
  55                                      gboolean allow_initial_digit,
  56                                      gboolean allow_hyphen)
  57 {
  58   if (allow_initial_digit)
  59     return is_valid_bus_name_character (c, allow_hyphen);
  60   else
  61     return
  62       (c >= 'A' && c <= 'Z') ||
  63       (c >= 'a' && c <= 'z') ||
  64       (c == '_') ||
  65       (allow_hyphen && c == '-');
  66 }
  67
  68 static gboolean
  69 is_valid_name (const gchar *start,
  70                guint len,
  71                gboolean allow_initial_digit,
  72                gboolean allow_hyphen)
  73 {
  74   gboolean ret;
  75   const gchar *s;
  76   const gchar *end;
  77   gboolean has_dot;
  78
  79   ret = FALSE;
  80
  81   if (len == 0)
  82     goto out;
  83
  84   s = start;
  85   end = s + len;
  86   has_dot = FALSE;
  87   while (s != end)
  88     {
  89       if (*s == '.')
  90         {
  91           s += 1;
  92           if (G_UNLIKELY (!is_valid_initial_bus_name_character (*s, allow_initial_digit, allow_hyphen)))
  93             goto out;
  94           has_dot = TRUE;
  95         }
  96       else if (G_UNLIKELY (!is_valid_bus_name_character (*s, allow_hyphen)))
  97         {
  98           goto out;
  99         }
 100       s += 1;
 101     }
 102
 103   if (G_UNLIKELY (!has_dot))
 104     goto out;
 105
 106   ret = TRUE;
 107
 108  out:
 109   return ret;
 110 }
 111
 112 /**
 113  * g_dbus_is_name:
 114  * @string: The string to check.
 115  *
 116  * Checks if @string is a valid D-Bus bus name (either unique or well-known).
 117  *
 118  * Returns: %TRUE if valid, %FALSE otherwise.
 119  *
 120  * Since: 2.26
 121  */
 122 gboolean
 123 g_dbus_is_name (const gchar *string)
 124 {
 125   guint len;
 126   gboolean ret;
 127   const gchar *s;
 128
 129   g_return_val_if_fail (string != NULL, FALSE);
 130
 131   ret = FALSE;
 132
 133   len = strlen (string);
 134   if (G_UNLIKELY (len == 0 || len > 255))
 135     goto out;
 136
 137   s = string;
 138   if (*s == ':')
 139     {
 140       /* handle unique name */
 141       if (!is_valid_name (s + 1, len - 1, TRUE, TRUE))
 142         goto out;
 143       ret = TRUE;
 144       goto out;
 145     }
 146   else if (G_UNLIKELY (*s == '.'))
 147     {
 148       /* can't start with a . */
 149       goto out;
 150     }
 151   else if (G_UNLIKELY (!is_valid_initial_bus_name_character (*s, FALSE, TRUE)))
 152     goto out;
 153
 154   ret = is_valid_name (s + 1, len - 1, FALSE, TRUE);
 155
 156  out:
 157   return ret;
 158 }
 159
 160 /**
 161  * g_dbus_is_unique_name:
 162  * @string: The string to check.
 163  *
 164  * Checks if @string is a valid D-Bus unique bus name.
 165  *
 166  * Returns: %TRUE if valid, %FALSE otherwise.
 167  *
 168  * Since: 2.26
 169  */
 170 gboolean
 171 g_dbus_is_unique_name (const gchar *string)
 172 {
 173   gboolean ret;
 174   guint len;
 175
 176   g_return_val_if_fail (string != NULL, FALSE);
 177
 178   ret = FALSE;
 179
 180   len = strlen (string);
 181   if (G_UNLIKELY (len == 0 || len > 255))
 182     goto out;
 183
 184   if (G_UNLIKELY (*string != ':'))
 185     goto out;
 186
 187   if (G_UNLIKELY (!is_valid_name (string + 1, len - 1, TRUE, TRUE)))
 188     goto out;
 189
 190   ret = TRUE;
 191
 192  out:
 193   return ret;
 194 }
 195
 196 /**
 197  * g_dbus_is_member_name:
 198  * @string: The string to check.
 199  *
 200  * Checks if @string is a valid D-Bus member (e.g. signal or method) name.
 201  *
 202  * Returns: %TRUE if valid, %FALSE otherwise.
 203  *
 204  * Since: 2.26
 205  */
 206 gboolean
 207 g_dbus_is_member_name (const gchar *string)
 208 {
 209   gboolean ret;
 210   guint n;
 211
 212   ret = FALSE;
 213   if (G_UNLIKELY (string == NULL))
 214     goto out;
 215
 216   if (G_UNLIKELY (!is_valid_initial_bus_name_character (string[0], FALSE, FALSE)))
 217     goto out;
 218
 219   for (n = 1; string[n] != '\0'; n++)
 220     {
 221       if (G_UNLIKELY (!is_valid_bus_name_character (string[n], FALSE)))
 222         {
 223           goto out;
 224         }
 225     }
 226
 227   ret = TRUE;
 228
 229  out:
 230   return ret;
 231 }
 232
 233 /**
 234  * g_dbus_is_interface_name:
 235  * @string: The string to check.
 236  *
 237  * Checks if @string is a valid D-Bus interface name.
 238  *
 239  * Returns: %TRUE if valid, %FALSE otherwise.
 240  *
 241  * Since: 2.26
 242  */
 243 gboolean
 244 g_dbus_is_interface_name (const gchar *string)
 245 {
 246   guint len;
 247   gboolean ret;
 248   const gchar *s;
 249
 250   g_return_val_if_fail (string != NULL, FALSE);
 251
 252   ret = FALSE;
 253
 254   len = strlen (string);
 255   if (G_UNLIKELY (len == 0 || len > 255))
 256     goto out;
 257
 258   s = string;
 259   if (G_UNLIKELY (*s == '.'))
 260     {
 261       /* can't start with a . */
 262       goto out;
 263     }
 264   else if (G_UNLIKELY (!is_valid_initial_bus_name_character (*s, FALSE, FALSE)))
 265     goto out;
 266
 267   ret = is_valid_name (s + 1, len - 1, FALSE, FALSE);
 268
 269  out:
 270   return ret;
 271 }
 272
 273 /* ---------------------------------------------------------------------------------------------------- */
 274
 275 /* TODO: maybe move to glib? if so, it should conform to http://en.wikipedia.org/wiki/Guid and/or
 276  *       http://tools.ietf.org/html/rfc4122 - specifically it should have hyphens then.
 277  */
 278
 279 /**
 280  * g_dbus_generate_guid:
 281  *
 282  * Generate a D-Bus GUID that can be used with
 283  * e.g. g_dbus_connection_new().
 284  *
 285  * See the D-Bus specification regarding what strings are valid D-Bus
 286  * GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
 287  *
 288  * Returns: A valid D-Bus GUID. Free with g_free().
 289  *
 290  * Since: 2.26
 291  */
 292 gchar *
 293 g_dbus_generate_guid (void)
 294 {
 295   GString *s;
 296   GTimeVal now;
 297   guint32 r1;
 298   guint32 r2;
 299   guint32 r3;
 300
 301   s = g_string_new (NULL);
 302
 303   r1 = g_random_int ();
 304   r2 = g_random_int ();
 305   r3 = g_random_int ();
 306   g_get_current_time (&now);
 307
 308   g_string_append_printf (s, "%08x", r1);
 309   g_string_append_printf (s, "%08x", r2);
 310   g_string_append_printf (s, "%08x", r3);
 311   g_string_append_printf (s, "%08x", (guint32) now.tv_sec);
 312
 313   return g_string_free (s, FALSE);
 314 }
 315
 316 /**
 317  * g_dbus_is_guid:
 318  * @string: The string to check.
 319  *
 320  * Checks if @string is a D-Bus GUID.
 321  *
 322  * See the D-Bus specification regarding what strings are valid D-Bus
 323  * GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
 324  *
 325  * Returns: %TRUE if @string is a guid, %FALSE otherwise.
 326  *
 327  * Since: 2.26
 328  */
 329 gboolean
 330 g_dbus_is_guid (const gchar *string)
 331 {
 332   gboolean ret;
 333   guint n;
 334
 335   g_return_val_if_fail (string != NULL, FALSE);
 336
 337   ret = FALSE;
 338
 339   for (n = 0; n < 32; n++)
 340     {
 341       if (!g_ascii_isxdigit (string[n]))
 342         goto out;
 343     }
 344   if (string[32] != '\0')
 345     goto out;
 346
 347   ret = TRUE;
 348
 349  out:
 350   return ret;
 351 }
 352
 353 /* ---------------------------------------------------------------------------------------------------- */
 354
 355 /**
 356  * g_dbus_gvariant_to_gvalue:
 357  * @value: A #GVariant.
 358  * @out_gvalue: Return location pointing to a zero-filled (uninitialized) #GValue.
 359  *
 360  * Converts a #GVariant to a #GValue. If @value is floating, it is consumed.
 361  *
 362  * The rules specified in the g_dbus_gvalue_to_gvariant() function are
 363  * used - this function is essentially its reverse form.
 364  *
 365  * The conversion never fails - a valid #GValue is always returned in
 366  * @out_gvalue.
 367  *
 368  * Since: 2.30
 369  */
 370 void
 371 g_dbus_gvariant_to_gvalue (GVariant  *value,
 372                            GValue    *out_gvalue)
 373 {
 374   const GVariantType *type;
 375   gchar **array;
 376
 377   g_return_if_fail (value != NULL);
 378   g_return_if_fail (out_gvalue != NULL);
 379
 380   memset (out_gvalue, '\0', sizeof (GValue));
 381
 382   switch (g_variant_classify (value))
 383     {
 384     case G_VARIANT_CLASS_BOOLEAN:
 385       g_value_init (out_gvalue, G_TYPE_BOOLEAN);
 386       g_value_set_boolean (out_gvalue, g_variant_get_boolean (value));
 387       break;
 388
 389     case G_VARIANT_CLASS_BYTE:
 390       g_value_init (out_gvalue, G_TYPE_UCHAR);
 391       g_value_set_uchar (out_gvalue, g_variant_get_byte (value));
 392       break;
 393
 394     case G_VARIANT_CLASS_INT16:
 395       g_value_init (out_gvalue, G_TYPE_INT);
 396       g_value_set_int (out_gvalue, g_variant_get_int16 (value));
 397       break;
 398
 399     case G_VARIANT_CLASS_UINT16:
 400       g_value_init (out_gvalue, G_TYPE_UINT);
 401       g_value_set_uint (out_gvalue, g_variant_get_uint16 (value));
 402       break;
 403
 404     case G_VARIANT_CLASS_INT32:
 405       g_value_init (out_gvalue, G_TYPE_INT);
 406       g_value_set_int (out_gvalue, g_variant_get_int32 (value));
 407       break;
 408
 409     case G_VARIANT_CLASS_UINT32:
 410       g_value_init (out_gvalue, G_TYPE_UINT);
 411       g_value_set_uint (out_gvalue, g_variant_get_uint32 (value));
 412       break;
 413
 414     case G_VARIANT_CLASS_INT64:
 415       g_value_init (out_gvalue, G_TYPE_INT64);
 416       g_value_set_int64 (out_gvalue, g_variant_get_int64 (value));
 417       break;
 418
 419     case G_VARIANT_CLASS_UINT64:
 420       g_value_init (out_gvalue, G_TYPE_UINT64);
 421       g_value_set_uint64 (out_gvalue, g_variant_get_uint64 (value));
 422       break;
 423
 424     case G_VARIANT_CLASS_HANDLE:
 425       g_value_init (out_gvalue, G_TYPE_INT);
 426       g_value_set_int (out_gvalue, g_variant_get_int32 (value));
 427       break;
 428
 429     case G_VARIANT_CLASS_DOUBLE:
 430       g_value_init (out_gvalue, G_TYPE_DOUBLE);
 431       g_value_set_double (out_gvalue, g_variant_get_double (value));
 432       break;
 433
 434     case G_VARIANT_CLASS_STRING:
 435       g_value_init (out_gvalue, G_TYPE_STRING);
 436       g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
 437       break;
 438
 439     case G_VARIANT_CLASS_OBJECT_PATH:
 440       g_value_init (out_gvalue, G_TYPE_STRING);
 441       g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
 442       break;
 443
 444     case G_VARIANT_CLASS_SIGNATURE:
 445       g_value_init (out_gvalue, G_TYPE_STRING);
 446       g_value_set_string (out_gvalue, g_variant_get_string (value, NULL));
 447       break;
 448
 449     case G_VARIANT_CLASS_ARRAY:
 450       type = g_variant_get_type (value);
 451       switch (g_variant_type_peek_string (type)[1])
 452         {
 453         case G_VARIANT_CLASS_BYTE:
 454           g_value_init (out_gvalue, G_TYPE_STRING);
 455           g_value_set_string (out_gvalue, g_variant_get_bytestring (value));
 456           break;
 457
 458         case G_VARIANT_CLASS_STRING:
 459           g_value_init (out_gvalue, G_TYPE_STRV);
 460           array = g_variant_dup_strv (value, NULL);
 461           g_value_take_boxed (out_gvalue, array);
 462           break;
 463
 464         case G_VARIANT_CLASS_OBJECT_PATH:
 465           g_value_init (out_gvalue, G_TYPE_STRV);
 466           array = g_variant_dup_objv (value, NULL);
 467           g_value_take_boxed (out_gvalue, array);
 468           break;
 469
 470         case G_VARIANT_CLASS_ARRAY:
 471           switch (g_variant_type_peek_string (type)[2])
 472             {
 473             case G_VARIANT_CLASS_BYTE:
 474               g_value_init (out_gvalue, G_TYPE_STRV);
 475               array = g_variant_dup_bytestring_array (value, NULL);
 476               g_value_take_boxed (out_gvalue, array);
 477               break;
 478
 479             default:
 480               g_value_init (out_gvalue, G_TYPE_VARIANT);
 481               g_value_set_variant (out_gvalue, value);
 482               break;
 483             }
 484           break;
 485
 486         default:
 487           g_value_init (out_gvalue, G_TYPE_VARIANT);
 488           g_value_set_variant (out_gvalue, value);
 489           break;
 490         }
 491       break;
 492
 493     case G_VARIANT_CLASS_VARIANT:
 494     case G_VARIANT_CLASS_MAYBE:
 495     case G_VARIANT_CLASS_TUPLE:
 496     case G_VARIANT_CLASS_DICT_ENTRY:
 497       g_value_init (out_gvalue, G_TYPE_VARIANT);
 498       g_value_set_variant (out_gvalue, value);
 499       break;
 500     }
 501 }
 502
 503
 504 /**
 505  * g_dbus_gvalue_to_gvariant:
 506  * @gvalue: A #GValue to convert to a #GVariant.
 507  * @type: A #GVariantType.
 508  *
 509  * Converts a #GValue to a #GVariant of the type indicated by the @type parameter.
 510  *
 511  * The conversion is using the following rules:
 512  * <table frame='all'>
 513  *   <title>#GValue / #GVariant conversion rules</title>
 514  *   <tgroup cols='2' align='left' colsep='1' rowsep='1'>
 515  *     <thead>
 516  *       <row>
 517  *         <entry>If the #GType for @gvalue is...</entry>
 518  *         <entry>... then @type must be</entry>
 519  *       </row>
 520  *     </thead>
 521  *     <tbody>
 522  *       <row>
 523  *         <entry>#G_TYPE_STRING</entry>
 524  *         <entry><link linkend="G-VARIANT-TYPE-STRING:CAPS">'s'</link>, <link linkend="G-VARIANT-TYPE-OBJECT-PATH:CAPS">'o'</link>, <link linkend="G-VARIANT-TYPE-SIGNATURE:CAPS">'g'</link> or <link linkend="G-VARIANT-TYPE-BYTESTRING:CAPS">'ay'</link></entry>
 525  *       </row>
 526  *       <row>
 527  *         <entry>#G_TYPE_STRV</entry>
 528  *         <entry><link linkend="G-VARIANT-TYPE-STRING-ARRAY:CAPS">'as'</link>, <link linkend="G-VARIANT-TYPE-OBJECT-PATH-ARRAY:CAPS">'ao'</link> or <link linkend="G-VARIANT-TYPE-BYTESTRING-ARRAY:CAPS">'aay'</link></entry>
 529  *       </row>
 530  *       <row>
 531  *         <entry>#G_TYPE_BOOLEAN</entry>
 532  *         <entry><link linkend="G-VARIANT-TYPE-BOOLEAN:CAPS">'b'</link></entry>
 533  *       </row>
 534  *       <row>
 535  *         <entry>#G_TYPE_UCHAR</entry>
 536  *         <entry><link linkend="G-VARIANT-TYPE-BYTE:CAPS">'y'</link></entry>
 537  *       </row>
 538  *       <row>
 539  *         <entry>#G_TYPE_INT</entry>
 540  *         <entry><link linkend="G-VARIANT-TYPE-INT32:CAPS">'i'</link> or <link linkend="G-VARIANT-TYPE-INT16:CAPS">'n'</link></entry>
 541  *       </row>
 542  *       <row>
 543  *         <entry>#G_TYPE_UINT</entry>
 544  *         <entry><link linkend="G-VARIANT-TYPE-UINT32:CAPS">'u'</link> or <link linkend="G-VARIANT-TYPE-UINT16:CAPS">'q'</link></entry>
 545  *       </row>
 546  *       <row>
 547  *         <entry>#G_TYPE_INT64</entry>
 548  *         <entry><link linkend="G-VARIANT-TYPE-INT64:CAPS">'x'</link></entry>
 549  *       </row>
 550  *       <row>
 551  *         <entry>#G_TYPE_UINT64</entry>
 552  *         <entry><link linkend="G-VARIANT-TYPE-UINT64:CAPS">'t'</link></entry>
 553  *       </row>
 554  *       <row>
 555  *         <entry>#G_TYPE_INT</entry>
 556  *         <entry><link linkend="G-VARIANT-TYPE-HANDLE:CAPS">'h'</link></entry>
 557  *       </row>
 558  *       <row>
 559  *         <entry>#G_TYPE_DOUBLE</entry>
 560  *         <entry><link linkend="G-VARIANT-TYPE-DOUBLE:CAPS">'d'</link></entry>
 561  *       </row>
 562  *       <row>
 563  *         <entry>#G_TYPE_VARIANT</entry>
 564  *         <entry>Any #GVariantType</entry>
 565  *       </row>
 566  *     </tbody>
 567  *   </tgroup>
 568  * </table>
 569  * This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type
 570  * is <link linkend="G-VARIANT-TYPE-INT32:CAPS">'i'</link>. It will
 571  * also fail for any #GType (including e.g. #G_TYPE_OBJECT and
 572  * #G_TYPE_BOXED derived-types) not in the table above.
 573  *
 574  * Note that if @gvalue is of type #G_TYPE_VARIANT and its value is
 575  * %NULL, the <emphasis>empty</emphasis> #GVariant instance (never
 576  * %NULL) for @type is returned (e.g. 0 for scalar types, the empty
 577  * string for string types, <literal>'/'</literal> for object path
 578  * types, the empty array for any array type and so on).
 579  *
 580  * See the g_dbus_gvariant_to_gvalue() function for how to convert a
 581  * #GVariant to a #GValue.
 582  *
 583  * Returns: A #GVariant (never floating) of #GVariantType
 584  * @type holding the data from @gvalue or %NULL in case of
 585  * failure. Free with g_variant_unref().
 586  *
 587  * Since: 2.30
 588  */
 589 GVariant *
 590 g_dbus_gvalue_to_gvariant (const GValue       *gvalue,
 591                            const GVariantType *type)
 592 {
 593   GVariant *ret;
 594   const gchar *s;
 595   const gchar * const *as;
 596   const gchar *empty_strv[1] = {NULL};
 597
 598   g_return_val_if_fail (gvalue != NULL, NULL);
 599   g_return_val_if_fail (type != NULL, NULL);
 600
 601   ret = NULL;
 602
 603   /* @type can easily be e.g. "s" with the GValue holding a GVariant - for example this
 604    * can happen when using the org.gtk.GDBus.C.ForceGVariant annotation with the
 605    * gdbus-codegen(1) tool.
 606    */
 607   if (G_VALUE_TYPE (gvalue) == G_TYPE_VARIANT)
 608     {
 609       ret = g_value_dup_variant (gvalue);
 610     }
 611   else
 612     {
 613       switch (g_variant_type_peek_string (type)[0])
 614         {
 615         case G_VARIANT_CLASS_BOOLEAN:
 616           ret = g_variant_ref_sink (g_variant_new_boolean (g_value_get_boolean (gvalue)));
 617           break;
 618
 619         case G_VARIANT_CLASS_BYTE:
 620           ret = g_variant_ref_sink (g_variant_new_byte (g_value_get_uchar (gvalue)));
 621           break;
 622
 623         case G_VARIANT_CLASS_INT16:
 624           ret = g_variant_ref_sink (g_variant_new_int16 (g_value_get_int (gvalue)));
 625           break;
 626
 627         case G_VARIANT_CLASS_UINT16:
 628           ret = g_variant_ref_sink (g_variant_new_uint16 (g_value_get_uint (gvalue)));
 629           break;
 630
 631         case G_VARIANT_CLASS_INT32:
 632           ret = g_variant_ref_sink (g_variant_new_int32 (g_value_get_int (gvalue)));
 633           break;
 634
 635         case G_VARIANT_CLASS_UINT32:
 636           ret = g_variant_ref_sink (g_variant_new_uint32 (g_value_get_uint (gvalue)));
 637           break;
 638
 639         case G_VARIANT_CLASS_INT64:
 640           ret = g_variant_ref_sink (g_variant_new_int64 (g_value_get_int64 (gvalue)));
 641           break;
 642
 643         case G_VARIANT_CLASS_UINT64:
 644           ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue)));
 645           break;
 646
 647         case G_VARIANT_CLASS_HANDLE:
 648           ret = g_variant_ref_sink (g_variant_new_handle (g_value_get_int (gvalue)));
 649           break;
 650
 651         case G_VARIANT_CLASS_DOUBLE:
 652           ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue)));
 653           break;
 654
 655         case G_VARIANT_CLASS_STRING:
 656           s = g_value_get_string (gvalue);
 657           if (s == NULL)
 658             s = "";
 659           ret = g_variant_ref_sink (g_variant_new_string (s));
 660           break;
 661
 662         case G_VARIANT_CLASS_OBJECT_PATH:
 663           s = g_value_get_string (gvalue);
 664           if (s == NULL)
 665             s = "/";
 666           ret = g_variant_ref_sink (g_variant_new_object_path (s));
 667           break;
 668
 669         case G_VARIANT_CLASS_SIGNATURE:
 670           s = g_value_get_string (gvalue);
 671           if (s == NULL)
 672             s = "";
 673           ret = g_variant_ref_sink (g_variant_new_signature (s));
 674           break;
 675
 676         case G_VARIANT_CLASS_ARRAY:
 677           switch (g_variant_type_peek_string (type)[1])
 678             {
 679             case G_VARIANT_CLASS_BYTE:
 680               s = g_value_get_string (gvalue);
 681               if (s == NULL)
 682                 s = "";
 683               ret = g_variant_ref_sink (g_variant_new_bytestring (s));
 684               break;
 685
 686             case G_VARIANT_CLASS_STRING:
 687               as = g_value_get_boxed (gvalue);
 688               if (as == NULL)
 689                 as = empty_strv;
 690               ret = g_variant_ref_sink (g_variant_new_strv (as, -1));
 691               break;
 692
 693             case G_VARIANT_CLASS_OBJECT_PATH:
 694               as = g_value_get_boxed (gvalue);
 695               if (as == NULL)
 696                 as = empty_strv;
 697               ret = g_variant_ref_sink (g_variant_new_objv (as, -1));
 698               break;
 699
 700             case G_VARIANT_CLASS_ARRAY:
 701               switch (g_variant_type_peek_string (type)[2])
 702                 {
 703                 case G_VARIANT_CLASS_BYTE:
 704                   as = g_value_get_boxed (gvalue);
 705                   if (as == NULL)
 706                     as = empty_strv;
 707                   ret = g_variant_ref_sink (g_variant_new_bytestring_array (as, -1));
 708                   break;
 709
 710                 default:
 711                   ret = g_value_dup_variant (gvalue);
 712                   break;
 713                 }
 714               break;
 715
 716             default:
 717               ret = g_value_dup_variant (gvalue);
 718               break;
 719             }
 720           break;
 721
 722         default:
 723         case G_VARIANT_CLASS_VARIANT:
 724         case G_VARIANT_CLASS_MAYBE:
 725         case G_VARIANT_CLASS_TUPLE:
 726         case G_VARIANT_CLASS_DICT_ENTRY:
 727           ret = g_value_dup_variant (gvalue);
 728           break;
 729         }
 730     }
 731
 732   /* Could be that the GValue is holding a NULL GVariant - in that case,
 733    * we return an "empty" GVariant instead of a NULL GVariant
 734    */
 735   if (ret == NULL)
 736     {
 737       GVariant *untrusted_empty;
 738       untrusted_empty = g_variant_new_from_data (type, NULL, 0, FALSE, NULL, NULL);
 739       ret = g_variant_ref_sink (g_variant_get_normal_form (untrusted_empty));
 740       g_variant_unref (untrusted_empty);
 741     }
 742
 743   g_assert (!g_variant_is_floating (ret));
 744
 745   return ret;
 746 }