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