dlls/wbemprox/reg.c

   1 /*
   2  * StdRegProv implementation
   3  *
   4  * Copyright 2012 Hans Leidekker for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wbemcli.h"
  28
  29 #include "wine/debug.h"
  30 #include "wbemprox_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  33
  34 static HRESULT to_bstr_array( BSTR *strings, DWORD count, VARIANT *var )
  35 {
  36     SAFEARRAY *sa;
  37     HRESULT hr;
  38     LONG i;
  39
  40     if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, count ))) return E_OUTOFMEMORY;
  41     for (i = 0; i < count; i++)
  42     {
  43         if ((hr = SafeArrayPutElement( sa, &i, strings[i] )) != S_OK)
  44         {
  45             SafeArrayDestroy( sa );
  46             return hr;
  47         }
  48     }
  49     set_variant( VT_BSTR|VT_ARRAY, 0, sa, var );
  50     return S_OK;
  51 }
  52
  53 static void free_bstr_array( BSTR *strings, DWORD count )
  54 {
  55     while (count--)
  56         SysFreeString( *(strings++) );
  57 }
  58
  59 static HRESULT to_i4_array( DWORD *values, DWORD count, VARIANT *var )
  60 {
  61     SAFEARRAY *sa;
  62     HRESULT hr;
  63     LONG i;
  64
  65     if (!(sa = SafeArrayCreateVector( VT_I4, 0, count ))) return E_OUTOFMEMORY;
  66     for (i = 0; i < count; i++)
  67     {
  68         if ((hr = SafeArrayPutElement( sa, &i, &values[i] )) != S_OK)
  69         {
  70             SafeArrayDestroy( sa );
  71             return hr;
  72         }
  73     }
  74     set_variant( VT_I4|VT_ARRAY, 0, sa, var );
  75     return S_OK;
  76 }
  77
  78 static unsigned int reg_get_access_mask( IWbemContext *context )
  79 {
  80     VARIANT value;
  81
  82     if (!context) return 0;
  83
  84     V_VT( &value ) = VT_EMPTY;
  85     if (FAILED(IWbemContext_GetValue( context, L"__ProviderArchitecture", 0, &value )))
  86         return 0;
  87
  88     if (FAILED(VariantChangeType( &value, &value, 0, VT_I4 )))
  89     {
  90         VariantClear( &value );
  91         return 0;
  92     }
  93
  94     if (V_I4( &value ) == 32)
  95         return KEY_WOW64_32KEY;
  96     else if (V_I4( &value ) == 64)
  97         return KEY_WOW64_64KEY;
  98
  99     return 0;
 100 }
 101
 102 static HRESULT create_key( HKEY root, const WCHAR *subkey, IWbemContext *context, VARIANT *retval )
 103 {
 104     LONG res;
 105     HKEY hkey;
 106
 107     TRACE("%p, %s\n", root, debugstr_w(subkey));
 108
 109     res = RegCreateKeyExW( root, subkey, 0, NULL, 0, reg_get_access_mask( context ), NULL, &hkey, NULL );
 110     set_variant( VT_UI4, res, NULL, retval );
 111     if (!res)
 112     {
 113         RegCloseKey( hkey );
 114         return S_OK;
 115     }
 116     return HRESULT_FROM_WIN32( res );
 117 }
 118
 119 HRESULT reg_create_key( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 120 {
 121     VARIANT defkey, subkey, retval;
 122     IWbemClassObject *sig, *out_params = NULL;
 123     HRESULT hr;
 124
 125     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 126
 127     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 128     if (hr != S_OK) return hr;
 129     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 130     if (hr != S_OK) return hr;
 131
 132     hr = create_signature( L"StdRegProv", L"CreateKey", PARAM_OUT, &sig );
 133     if (hr != S_OK)
 134     {
 135         VariantClear( &subkey );
 136         return hr;
 137     }
 138     if (out)
 139     {
 140         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 141         if (hr != S_OK)
 142         {
 143             VariantClear( &subkey );
 144             IWbemClassObject_Release( sig );
 145             return hr;
 146         }
 147     }
 148     hr = create_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), context, &retval );
 149     if (hr == S_OK && out_params)
 150         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 151
 152     VariantClear( &subkey );
 153     IWbemClassObject_Release( sig );
 154     if (hr == S_OK && out)
 155     {
 156         *out = out_params;
 157         IWbemClassObject_AddRef( out_params );
 158     }
 159     if (out_params) IWbemClassObject_Release( out_params );
 160     return hr;
 161 }
 162
 163 static HRESULT enum_key( HKEY root, const WCHAR *subkey, VARIANT *names, IWbemContext *context, VARIANT *retval )
 164 {
 165     HKEY hkey;
 166     HRESULT hr = S_OK;
 167     WCHAR buf[256];
 168     BSTR *strings, *tmp;
 169     DWORD count = 2, len = ARRAY_SIZE( buf );
 170     LONG res, i = 0;
 171
 172     TRACE("%p, %s\n", root, debugstr_w(subkey));
 173
 174     if (!(strings = heap_alloc( count * sizeof(BSTR) ))) return E_OUTOFMEMORY;
 175     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_ENUMERATE_SUB_KEYS | reg_get_access_mask( context ), &hkey )))
 176     {
 177         set_variant( VT_UI4, res, NULL, retval );
 178         heap_free( strings );
 179         return S_OK;
 180     }
 181     for (;;)
 182     {
 183         if (i >= count)
 184         {
 185             count *= 2;
 186             if (!(tmp = heap_realloc( strings, count * sizeof(BSTR) )))
 187             {
 188                 RegCloseKey( hkey );
 189                 return E_OUTOFMEMORY;
 190             }
 191             strings = tmp;
 192         }
 193         if ((res = RegEnumKeyW( hkey, i, buf, len )) == ERROR_NO_MORE_ITEMS)
 194         {
 195             if (i) res = ERROR_SUCCESS;
 196             break;
 197         }
 198         if (res) break;
 199         if (!(strings[i] = SysAllocString( buf )))
 200         {
 201             for (i--; i >= 0; i--) SysFreeString( strings[i] );
 202             hr = E_OUTOFMEMORY;
 203             break;
 204         }
 205         i++;
 206     }
 207     if (hr == S_OK && !res)
 208     {
 209         hr = to_bstr_array( strings, i, names );
 210         free_bstr_array( strings, i );
 211     }
 212     set_variant( VT_UI4, res, NULL, retval );
 213     RegCloseKey( hkey );
 214     heap_free( strings );
 215     return hr;
 216 }
 217
 218 HRESULT reg_enum_key( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 219 {
 220     VARIANT defkey, subkey, names, retval;
 221     IWbemClassObject *sig, *out_params = NULL;
 222     HRESULT hr;
 223
 224     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 225
 226     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 227     if (hr != S_OK) return hr;
 228     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 229     if (hr != S_OK) return hr;
 230
 231     hr = create_signature( L"StdRegProv", L"EnumKey", PARAM_OUT, &sig );
 232     if (hr != S_OK)
 233     {
 234         VariantClear( &subkey );
 235         return hr;
 236     }
 237     if (out)
 238     {
 239         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 240         if (hr != S_OK)
 241         {
 242             VariantClear( &subkey );
 243             IWbemClassObject_Release( sig );
 244             return hr;
 245         }
 246     }
 247     VariantInit( &names );
 248     hr = enum_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, context, &retval );
 249     if (hr != S_OK) goto done;
 250     if (out_params)
 251     {
 252         if (!V_UI4( &retval ))
 253         {
 254             hr = IWbemClassObject_Put( out_params, L"sNames", 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 255             if (hr != S_OK) goto done;
 256         }
 257         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 258     }
 259
 260 done:
 261     VariantClear( &names );
 262     VariantClear( &subkey );
 263     IWbemClassObject_Release( sig );
 264     if (hr == S_OK && out)
 265     {
 266         *out = out_params;
 267         IWbemClassObject_AddRef( out_params );
 268     }
 269     if (out_params) IWbemClassObject_Release( out_params );
 270     return hr;
 271 }
 272
 273 static HRESULT enum_values( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *types, IWbemContext *context,
 274         VARIANT *retval )
 275 {
 276     HKEY hkey = NULL;
 277     HRESULT hr = S_OK;
 278     BSTR *value_names = NULL;
 279     DWORD count, buflen, len, *value_types = NULL;
 280     LONG res, i = 0;
 281     WCHAR *buf = NULL;
 282
 283     TRACE("%p, %s\n", root, debugstr_w(subkey));
 284
 285     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_QUERY_VALUE | reg_get_access_mask( context ), &hkey ))) goto done;
 286     if ((res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, NULL, &count, &buflen, NULL, NULL, NULL )))
 287         goto done;
 288
 289     hr = E_OUTOFMEMORY;
 290     if (!(buf = heap_alloc( (buflen + 1) * sizeof(WCHAR) ))) goto done;
 291     if (!(value_names = heap_alloc( count * sizeof(BSTR) ))) goto done;
 292     if (!(value_types = heap_alloc( count * sizeof(DWORD) ))) goto done;
 293
 294     hr = S_OK;
 295     for (;;)
 296     {
 297         len = buflen + 1;
 298         res = RegEnumValueW( hkey, i, buf, &len, NULL, &value_types[i], NULL, NULL );
 299         if (res == ERROR_NO_MORE_ITEMS)
 300         {
 301             if (i) res = ERROR_SUCCESS;
 302             break;
 303         }
 304         if (res) break;
 305         if (!(value_names[i] = SysAllocString( buf )))
 306         {
 307             for (i--; i >= 0; i--) SysFreeString( value_names[i] );
 308             hr = E_OUTOFMEMORY;
 309             break;
 310         }
 311         i++;
 312     }
 313     if (hr == S_OK && !res)
 314     {
 315         hr = to_bstr_array( value_names, i, names );
 316         free_bstr_array( value_names, i );
 317         if (hr == S_OK) hr = to_i4_array( value_types, i, types );
 318     }
 319
 320 done:
 321     set_variant( VT_UI4, res, NULL, retval );
 322     RegCloseKey( hkey );
 323     heap_free( value_names );
 324     heap_free( value_types );
 325     heap_free( buf );
 326     return hr;
 327 }
 328
 329 HRESULT reg_enum_values( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 330 {
 331     VARIANT defkey, subkey, names, types, retval;
 332     IWbemClassObject *sig, *out_params = NULL;
 333     HRESULT hr;
 334
 335     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 336
 337     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 338     if (hr != S_OK) return hr;
 339     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 340     if (hr != S_OK) return hr;
 341
 342     hr = create_signature( L"StdRegProv", L"EnumValues", PARAM_OUT, &sig );
 343     if (hr != S_OK)
 344     {
 345         VariantClear( &subkey );
 346         return hr;
 347     }
 348     if (out)
 349     {
 350         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 351         if (hr != S_OK)
 352         {
 353             VariantClear( &subkey );
 354             IWbemClassObject_Release( sig );
 355             return hr;
 356         }
 357     }
 358     VariantInit( &names );
 359     VariantInit( &types );
 360     hr = enum_values( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &types, context, &retval );
 361     if (hr != S_OK) goto done;
 362     if (out_params)
 363     {
 364         if (!V_UI4( &retval ))
 365         {
 366             hr = IWbemClassObject_Put( out_params, L"sNames", 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 367             if (hr != S_OK) goto done;
 368             hr = IWbemClassObject_Put( out_params, L"Types", 0, &types, CIM_SINT32|CIM_FLAG_ARRAY );
 369             if (hr != S_OK) goto done;
 370         }
 371         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 372     }
 373
 374 done:
 375     VariantClear( &types );
 376     VariantClear( &names );
 377     VariantClear( &subkey );
 378     IWbemClassObject_Release( sig );
 379     if (hr == S_OK && out)
 380     {
 381         *out = out_params;
 382         IWbemClassObject_AddRef( out_params );
 383     }
 384     if (out_params) IWbemClassObject_Release( out_params );
 385     return hr;
 386 }
 387
 388 static HRESULT get_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, VARIANT *value,
 389         IWbemContext *context, VARIANT *retval )
 390 {
 391     DWORD size, mask, flags = RRF_RT_REG_SZ;
 392     HRESULT hr = S_OK;
 393     BSTR str = NULL;
 394     LONG res;
 395
 396     TRACE("%p, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name));
 397
 398     mask = reg_get_access_mask( context );
 399
 400     if (mask & KEY_WOW64_64KEY)
 401         flags |= RRF_SUBKEY_WOW6464KEY;
 402     else if (mask & KEY_WOW64_32KEY)
 403         flags |= RRF_SUBKEY_WOW6432KEY;
 404
 405     if ((res = RegGetValueW( root, subkey, name, flags, NULL, NULL, &size ))) goto done;
 406     if (!(str = SysAllocStringLen( NULL, size / sizeof(WCHAR) - 1 )))
 407     {
 408         hr = E_OUTOFMEMORY;
 409         goto done;
 410     }
 411     if (!(res = RegGetValueW( root, subkey, name, flags, NULL, str, &size )))
 412         set_variant( VT_BSTR, 0, str, value );
 413
 414 done:
 415     set_variant( VT_UI4, res, NULL, retval );
 416     if (res) SysFreeString( str );
 417     return hr;
 418 }
 419
 420 HRESULT reg_get_stringvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 421 {
 422     VARIANT defkey, subkey, name, value, retval;
 423     IWbemClassObject *sig, *out_params = NULL;
 424     HRESULT hr;
 425
 426     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 427
 428     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 429     if (hr != S_OK) return hr;
 430     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 431     if (hr != S_OK) return hr;
 432     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 433     if (hr != S_OK)
 434     {
 435         VariantClear( &subkey );
 436         return hr;
 437     }
 438
 439     hr = create_signature( L"StdRegProv", L"GetStringValue", PARAM_OUT, &sig );
 440     if (hr != S_OK)
 441     {
 442         VariantClear( &name );
 443         VariantClear( &subkey );
 444         return hr;
 445     }
 446     if (out)
 447     {
 448         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 449         if (hr != S_OK)
 450         {
 451             VariantClear( &name );
 452             VariantClear( &subkey );
 453             IWbemClassObject_Release( sig );
 454             return hr;
 455         }
 456     }
 457     VariantInit( &value );
 458     hr = get_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), &value, context, &retval );
 459     if (hr != S_OK) goto done;
 460     if (out_params)
 461     {
 462         if (!V_UI4( &retval ))
 463         {
 464             hr = IWbemClassObject_Put( out_params, L"sValue", 0, &value, CIM_STRING );
 465             if (hr != S_OK) goto done;
 466         }
 467         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 468     }
 469
 470 done:
 471     VariantClear( &name );
 472     VariantClear( &subkey );
 473     IWbemClassObject_Release( sig );
 474     if (hr == S_OK && out)
 475     {
 476         *out = out_params;
 477         IWbemClassObject_AddRef( out_params );
 478     }
 479     if (out_params) IWbemClassObject_Release( out_params );
 480     return hr;
 481 }
 482
 483 static void set_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, const WCHAR *value,
 484         IWbemContext *context, VARIANT *retval )
 485 {
 486     HKEY hkey;
 487     LONG res;
 488
 489     TRACE("%p, %s, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name), debugstr_w(value));
 490
 491     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_SET_VALUE | reg_get_access_mask( context ), &hkey )))
 492     {
 493         set_variant( VT_UI4, res, NULL, retval );
 494         return;
 495     }
 496
 497     res = RegSetKeyValueW( hkey, NULL, name, REG_SZ, value, (lstrlenW( value ) + 1) * sizeof(*value) );
 498     set_variant( VT_UI4, res, NULL, retval );
 499     RegCloseKey( hkey );
 500 }
 501
 502 HRESULT reg_set_stringvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 503 {
 504     VARIANT defkey, subkey, name, value, retval;
 505     IWbemClassObject *sig, *out_params = NULL;
 506     HRESULT hr;
 507
 508     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 509
 510     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 511     if (hr != S_OK) return hr;
 512     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 513     if (hr != S_OK) return hr;
 514     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 515     if (hr != S_OK)
 516     {
 517         VariantClear( &subkey );
 518         return hr;
 519     }
 520     hr = IWbemClassObject_Get( in, L"sValue", 0, &value, NULL, NULL );
 521     if (hr != S_OK)
 522     {
 523         VariantClear( &name );
 524         VariantClear( &subkey );
 525         return hr;
 526     }
 527
 528     hr = create_signature( L"StdRegProv", L"SetStringValue", PARAM_OUT, &sig );
 529     if (hr != S_OK)
 530     {
 531         VariantClear( &name );
 532         VariantClear( &subkey );
 533         VariantClear( &value );
 534         return hr;
 535     }
 536     if (out)
 537     {
 538         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 539         if (hr != S_OK)
 540         {
 541             VariantClear( &name );
 542             VariantClear( &subkey );
 543             VariantClear( &value );
 544             IWbemClassObject_Release( sig );
 545             return hr;
 546         }
 547     }
 548
 549     set_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), V_BSTR(&value), context, &retval );
 550     if (out_params)
 551         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 552
 553     VariantClear( &name );
 554     VariantClear( &subkey );
 555     VariantClear( &value );
 556     IWbemClassObject_Release( sig );
 557     if (hr == S_OK && out)
 558     {
 559         *out = out_params;
 560         IWbemClassObject_AddRef( out_params );
 561     }
 562     if (out_params) IWbemClassObject_Release( out_params );
 563     return hr;
 564 }
 565
 566 static void set_dwordvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, DWORD value, IWbemContext *context,
 567         VARIANT *retval )
 568 {
 569     HKEY hkey;
 570     LONG res;
 571
 572     TRACE("%p, %s, %s, %#x\n", root, debugstr_w(subkey), debugstr_w(name), value);
 573
 574     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_SET_VALUE | reg_get_access_mask( context ), &hkey )))
 575     {
 576         set_variant( VT_UI4, res, NULL, retval );
 577         return;
 578     }
 579
 580     res = RegSetKeyValueW( hkey, NULL, name, REG_DWORD, &value, sizeof(value) );
 581     set_variant( VT_UI4, res, NULL, retval );
 582     RegCloseKey( hkey );
 583 }
 584
 585 HRESULT reg_set_dwordvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 586 {
 587     VARIANT defkey, subkey, name, value, retval;
 588     IWbemClassObject *sig, *out_params = NULL;
 589     HRESULT hr;
 590
 591     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 592
 593     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 594     if (hr != S_OK) return hr;
 595     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 596     if (hr != S_OK) return hr;
 597     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 598     if (hr != S_OK)
 599     {
 600         VariantClear( &subkey );
 601         return hr;
 602     }
 603     hr = IWbemClassObject_Get( in, L"uValue", 0, &value, NULL, NULL );
 604     if (hr != S_OK)
 605     {
 606         VariantClear( &name );
 607         VariantClear( &subkey );
 608         return hr;
 609     }
 610
 611     hr = create_signature( L"StdRegProv", L"SetDWORDValue", PARAM_OUT, &sig );
 612     if (hr != S_OK)
 613     {
 614         VariantClear( &name );
 615         VariantClear( &subkey );
 616         return hr;
 617     }
 618     if (out)
 619     {
 620         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 621         if (hr != S_OK)
 622         {
 623             VariantClear( &name );
 624             VariantClear( &subkey );
 625             IWbemClassObject_Release( sig );
 626             return hr;
 627         }
 628     }
 629     set_dwordvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), V_UI4(&value), context, &retval );
 630     if (out_params)
 631         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 632
 633     VariantClear( &name );
 634     VariantClear( &subkey );
 635     IWbemClassObject_Release( sig );
 636     if (hr == S_OK && out)
 637     {
 638         *out = out_params;
 639         IWbemClassObject_AddRef( out_params );
 640     }
 641     if (out_params) IWbemClassObject_Release( out_params );
 642     return hr;
 643 }
 644
 645 static void delete_key( HKEY root, const WCHAR *subkey, IWbemContext *context, VARIANT *retval )
 646 {
 647     LONG res;
 648
 649     TRACE("%p, %s\n", root, debugstr_w(subkey));
 650
 651     res = RegDeleteKeyExW( root, subkey, reg_get_access_mask( context ), 0 );
 652     set_variant( VT_UI4, res, NULL, retval );
 653 }
 654
 655 HRESULT reg_delete_key( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 656 {
 657     VARIANT defkey, subkey, retval;
 658     IWbemClassObject *sig, *out_params = NULL;
 659     HRESULT hr;
 660
 661     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 662
 663     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 664     if (hr != S_OK) return hr;
 665     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 666     if (hr != S_OK) return hr;
 667
 668     hr = create_signature( L"StdRegProv", L"DeleteKey", PARAM_OUT, &sig );
 669     if (hr != S_OK)
 670     {
 671         VariantClear( &subkey );
 672         return hr;
 673     }
 674     if (out)
 675     {
 676         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 677         if (hr != S_OK)
 678         {
 679             VariantClear( &subkey );
 680             IWbemClassObject_Release( sig );
 681             return hr;
 682         }
 683     }
 684     delete_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), context, &retval );
 685     if (out_params)
 686         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 687
 688     VariantClear( &subkey );
 689     IWbemClassObject_Release( sig );
 690     if (hr == S_OK && out)
 691     {
 692         *out = out_params;
 693         IWbemClassObject_AddRef( out_params );
 694     }
 695     if (out_params) IWbemClassObject_Release( out_params );
 696     return hr;
 697 }