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 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, 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( WBEMPROX_NAMESPACE_CIMV2, 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 = malloc( count * sizeof(BSTR) ))) return E_OUTOFMEMORY;
 175     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_ENUMERATE_SUB_KEYS | get_access_mask( context ), &hkey )))
 176     {
 177         set_variant( VT_UI4, res, NULL, retval );
 178         free( strings );
 179         return S_OK;
 180     }
 181     for (;;)
 182     {
 183         if (i >= count)
 184         {
 185             count *= 2;
 186             if (!(tmp = realloc( strings, count * sizeof(BSTR) )))
 187             {
 188                 RegCloseKey( hkey );
 189                 free( strings );
 190                 return E_OUTOFMEMORY;
 191             }
 192             strings = tmp;
 193         }
 194         if ((res = RegEnumKeyW( hkey, i, buf, len )) == ERROR_NO_MORE_ITEMS)
 195         {
 196             if (i) res = ERROR_SUCCESS;
 197             break;
 198         }
 199         if (res) break;
 200         if (!(strings[i] = SysAllocString( buf )))
 201         {
 202             for (i--; i >= 0; i--) SysFreeString( strings[i] );
 203             hr = E_OUTOFMEMORY;
 204             break;
 205         }
 206         i++;
 207     }
 208     if (hr == S_OK && !res)
 209     {
 210         hr = to_bstr_array( strings, i, names );
 211         free_bstr_array( strings, i );
 212     }
 213     set_variant( VT_UI4, res, NULL, retval );
 214     RegCloseKey( hkey );
 215     free( strings );
 216     return hr;
 217 }
 218
 219 HRESULT reg_enum_key( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 220 {
 221     VARIANT defkey, subkey, names, retval;
 222     IWbemClassObject *sig, *out_params = NULL;
 223     HRESULT hr;
 224
 225     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 226
 227     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 228     if (hr != S_OK) return hr;
 229     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 230     if (hr != S_OK) return hr;
 231
 232     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"EnumKey", PARAM_OUT, &sig );
 233     if (hr != S_OK)
 234     {
 235         VariantClear( &subkey );
 236         return hr;
 237     }
 238     if (out)
 239     {
 240         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 241         if (hr != S_OK)
 242         {
 243             VariantClear( &subkey );
 244             IWbemClassObject_Release( sig );
 245             return hr;
 246         }
 247     }
 248     VariantInit( &names );
 249     hr = enum_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, context, &retval );
 250     if (hr != S_OK) goto done;
 251     if (out_params)
 252     {
 253         if (!V_UI4( &retval ))
 254         {
 255             hr = IWbemClassObject_Put( out_params, L"sNames", 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 256             if (hr != S_OK) goto done;
 257         }
 258         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 259     }
 260
 261 done:
 262     VariantClear( &names );
 263     VariantClear( &subkey );
 264     IWbemClassObject_Release( sig );
 265     if (hr == S_OK && out)
 266     {
 267         *out = out_params;
 268         IWbemClassObject_AddRef( out_params );
 269     }
 270     if (out_params) IWbemClassObject_Release( out_params );
 271     return hr;
 272 }
 273
 274 static HRESULT enum_values( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *types, IWbemContext *context,
 275                             VARIANT *retval )
 276 {
 277     HKEY hkey = NULL;
 278     HRESULT hr = S_OK;
 279     BSTR *value_names = NULL;
 280     DWORD count, buflen, len, *value_types = NULL;
 281     LONG res, i = 0;
 282     WCHAR *buf = NULL;
 283
 284     TRACE("%p, %s\n", root, debugstr_w(subkey));
 285
 286     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_QUERY_VALUE | get_access_mask( context ), &hkey ))) goto done;
 287     if ((res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, NULL, &count, &buflen, NULL, NULL, NULL )))
 288         goto done;
 289
 290     hr = E_OUTOFMEMORY;
 291     if (!(buf = malloc( (buflen + 1) * sizeof(WCHAR) ))) goto done;
 292     if (!(value_names = malloc( count * sizeof(BSTR) ))) goto done;
 293     if (!(value_types = malloc( count * sizeof(DWORD) ))) goto done;
 294
 295     hr = S_OK;
 296     for (;;)
 297     {
 298         len = buflen + 1;
 299         res = RegEnumValueW( hkey, i, buf, &len, NULL, &value_types[i], NULL, NULL );
 300         if (res == ERROR_NO_MORE_ITEMS)
 301         {
 302             if (i) res = ERROR_SUCCESS;
 303             break;
 304         }
 305         if (res) break;
 306         if (!(value_names[i] = SysAllocString( buf )))
 307         {
 308             for (i--; i >= 0; i--) SysFreeString( value_names[i] );
 309             hr = E_OUTOFMEMORY;
 310             break;
 311         }
 312         i++;
 313     }
 314     if (hr == S_OK && !res)
 315     {
 316         hr = to_bstr_array( value_names, i, names );
 317         free_bstr_array( value_names, i );
 318         if (hr == S_OK) hr = to_i4_array( value_types, i, types );
 319     }
 320
 321 done:
 322     set_variant( VT_UI4, res, NULL, retval );
 323     RegCloseKey( hkey );
 324     free( value_names );
 325     free( value_types );
 326     free( buf );
 327     return hr;
 328 }
 329
 330 HRESULT reg_enum_values( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 331 {
 332     VARIANT defkey, subkey, names, types, retval;
 333     IWbemClassObject *sig, *out_params = NULL;
 334     HRESULT hr;
 335
 336     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 337
 338     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 339     if (hr != S_OK) return hr;
 340     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 341     if (hr != S_OK) return hr;
 342
 343     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"EnumValues", PARAM_OUT, &sig );
 344     if (hr != S_OK)
 345     {
 346         VariantClear( &subkey );
 347         return hr;
 348     }
 349     if (out)
 350     {
 351         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 352         if (hr != S_OK)
 353         {
 354             VariantClear( &subkey );
 355             IWbemClassObject_Release( sig );
 356             return hr;
 357         }
 358     }
 359     VariantInit( &names );
 360     VariantInit( &types );
 361     hr = enum_values( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &types, context, &retval );
 362     if (hr != S_OK) goto done;
 363     if (out_params)
 364     {
 365         if (!V_UI4( &retval ))
 366         {
 367             hr = IWbemClassObject_Put( out_params, L"sNames", 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 368             if (hr != S_OK) goto done;
 369             hr = IWbemClassObject_Put( out_params, L"Types", 0, &types, CIM_SINT32|CIM_FLAG_ARRAY );
 370             if (hr != S_OK) goto done;
 371         }
 372         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 373     }
 374
 375 done:
 376     VariantClear( &types );
 377     VariantClear( &names );
 378     VariantClear( &subkey );
 379     IWbemClassObject_Release( sig );
 380     if (hr == S_OK && out)
 381     {
 382         *out = out_params;
 383         IWbemClassObject_AddRef( out_params );
 384     }
 385     if (out_params) IWbemClassObject_Release( out_params );
 386     return hr;
 387 }
 388
 389 static HRESULT get_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, VARIANT *value,
 390                                 IWbemContext *context, VARIANT *retval )
 391 {
 392     DWORD size, mask, flags = RRF_RT_REG_SZ;
 393     HRESULT hr = S_OK;
 394     BSTR str = NULL;
 395     LONG res;
 396
 397     TRACE("%p, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name));
 398
 399     mask = get_access_mask( context );
 400
 401     if (mask & KEY_WOW64_64KEY)
 402         flags |= RRF_SUBKEY_WOW6464KEY;
 403     else if (mask & KEY_WOW64_32KEY)
 404         flags |= RRF_SUBKEY_WOW6432KEY;
 405
 406     if ((res = RegGetValueW( root, subkey, name, flags, NULL, NULL, &size ))) goto done;
 407     if (!(str = SysAllocStringLen( NULL, size / sizeof(WCHAR) - 1 ))) return E_OUTOFMEMORY;
 408     if (!(res = RegGetValueW( root, subkey, name, flags, NULL, str, &size ))) set_variant( VT_BSTR, 0, str, value );
 409
 410 done:
 411     set_variant( VT_UI4, res, NULL, retval );
 412     if (res) SysFreeString( str );
 413     return hr;
 414 }
 415
 416 HRESULT reg_get_stringvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 417 {
 418     VARIANT defkey, subkey, name, value, retval;
 419     IWbemClassObject *sig, *out_params = NULL;
 420     HRESULT hr;
 421
 422     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 423
 424     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 425     if (hr != S_OK) return hr;
 426     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 427     if (hr != S_OK) return hr;
 428     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 429     if (hr != S_OK)
 430     {
 431         VariantClear( &subkey );
 432         return hr;
 433     }
 434
 435     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"GetStringValue", PARAM_OUT, &sig );
 436     if (hr != S_OK)
 437     {
 438         VariantClear( &name );
 439         VariantClear( &subkey );
 440         return hr;
 441     }
 442     if (out)
 443     {
 444         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 445         if (hr != S_OK)
 446         {
 447             VariantClear( &name );
 448             VariantClear( &subkey );
 449             IWbemClassObject_Release( sig );
 450             return hr;
 451         }
 452     }
 453     VariantInit( &value );
 454     hr = get_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), &value, context, &retval );
 455     if (hr != S_OK) goto done;
 456     if (out_params)
 457     {
 458         if (!V_UI4( &retval ))
 459         {
 460             hr = IWbemClassObject_Put( out_params, L"sValue", 0, &value, CIM_STRING );
 461             if (hr != S_OK) goto done;
 462         }
 463         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 464     }
 465
 466 done:
 467     VariantClear( &name );
 468     VariantClear( &subkey );
 469     IWbemClassObject_Release( sig );
 470     if (hr == S_OK && out)
 471     {
 472         *out = out_params;
 473         IWbemClassObject_AddRef( out_params );
 474     }
 475     if (out_params) IWbemClassObject_Release( out_params );
 476     return hr;
 477 }
 478
 479 static HRESULT to_ui1_array( BYTE *value, DWORD size, VARIANT *var )
 480 {
 481     SAFEARRAY *sa;
 482     HRESULT hr;
 483     LONG i;
 484
 485     if (!(sa = SafeArrayCreateVector( VT_UI1, 0, size ))) return E_OUTOFMEMORY;
 486     for (i = 0; i < size; i++)
 487     {
 488         if ((hr = SafeArrayPutElement( sa, &i, &value[i] )) != S_OK)
 489         {
 490             SafeArrayDestroy( sa );
 491             return hr;
 492         }
 493     }
 494     set_variant( VT_UI1|VT_ARRAY, 0, sa, var );
 495     return S_OK;
 496 }
 497
 498 static HRESULT get_binaryvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, VARIANT *value,
 499                                 IWbemContext *context, VARIANT *retval )
 500 {
 501     DWORD size, mask, flags = RRF_RT_REG_BINARY;
 502     HRESULT hr = S_OK;
 503     BYTE *buf = NULL;
 504     LONG res;
 505
 506     TRACE("%p, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name));
 507
 508     mask = get_access_mask( context );
 509
 510     if (mask & KEY_WOW64_64KEY)
 511         flags |= RRF_SUBKEY_WOW6464KEY;
 512     else if (mask & KEY_WOW64_32KEY)
 513         flags |= RRF_SUBKEY_WOW6432KEY;
 514
 515     if ((res = RegGetValueW( root, subkey, name, flags, NULL, NULL, &size ))) goto done;
 516     if (!(buf = malloc( size ))) return E_OUTOFMEMORY;
 517     if (!(res = RegGetValueW( root, subkey, name, flags, NULL, buf, &size ))) hr = to_ui1_array( buf, size, value );
 518
 519 done:
 520     set_variant( VT_UI4, res, NULL, retval );
 521     free( buf );
 522     return hr;
 523 }
 524
 525 HRESULT reg_get_binaryvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 526 {
 527     VARIANT defkey, subkey, name, value, retval;
 528     IWbemClassObject *sig, *out_params = NULL;
 529     HRESULT hr;
 530
 531     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 532
 533     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 534     if (hr != S_OK) return hr;
 535     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 536     if (hr != S_OK) return hr;
 537     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 538     if (hr != S_OK)
 539     {
 540         VariantClear( &subkey );
 541         return hr;
 542     }
 543
 544     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"GetBinaryValue", PARAM_OUT, &sig );
 545     if (hr != S_OK)
 546     {
 547         VariantClear( &name );
 548         VariantClear( &subkey );
 549         return hr;
 550     }
 551     if (out)
 552     {
 553         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 554         if (hr != S_OK)
 555         {
 556             VariantClear( &name );
 557             VariantClear( &subkey );
 558             IWbemClassObject_Release( sig );
 559             return hr;
 560         }
 561     }
 562     VariantInit( &value );
 563     hr = get_binaryvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), &value, context, &retval );
 564     if (hr != S_OK) goto done;
 565     if (out_params)
 566     {
 567         if (!V_UI4( &retval ))
 568         {
 569             hr = IWbemClassObject_Put( out_params, L"uValue", 0, &value, CIM_UINT8|CIM_FLAG_ARRAY );
 570             if (hr != S_OK) goto done;
 571         }
 572         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 573     }
 574
 575 done:
 576     VariantClear( &name );
 577     VariantClear( &subkey );
 578     IWbemClassObject_Release( sig );
 579     if (hr == S_OK && out)
 580     {
 581         *out = out_params;
 582         IWbemClassObject_AddRef( out_params );
 583     }
 584     if (out_params) IWbemClassObject_Release( out_params );
 585     return hr;
 586 }
 587
 588 static void set_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, const WCHAR *value,
 589                              IWbemContext *context, VARIANT *retval )
 590 {
 591     HKEY hkey;
 592     LONG res;
 593
 594     TRACE("%p, %s, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name), debugstr_w(value));
 595
 596     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_SET_VALUE | get_access_mask( context ), &hkey )))
 597     {
 598         set_variant( VT_UI4, res, NULL, retval );
 599         return;
 600     }
 601
 602     res = RegSetKeyValueW( hkey, NULL, name, REG_SZ, value, (lstrlenW( value ) + 1) * sizeof(*value) );
 603     set_variant( VT_UI4, res, NULL, retval );
 604     RegCloseKey( hkey );
 605 }
 606
 607 HRESULT reg_set_stringvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 608 {
 609     VARIANT defkey, subkey, name, value, retval;
 610     IWbemClassObject *sig, *out_params = NULL;
 611     HRESULT hr;
 612
 613     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 614
 615     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 616     if (hr != S_OK) return hr;
 617     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 618     if (hr != S_OK) return hr;
 619     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 620     if (hr != S_OK)
 621     {
 622         VariantClear( &subkey );
 623         return hr;
 624     }
 625     hr = IWbemClassObject_Get( in, L"sValue", 0, &value, NULL, NULL );
 626     if (hr != S_OK)
 627     {
 628         VariantClear( &name );
 629         VariantClear( &subkey );
 630         return hr;
 631     }
 632
 633     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"SetStringValue", PARAM_OUT, &sig );
 634     if (hr != S_OK)
 635     {
 636         VariantClear( &name );
 637         VariantClear( &subkey );
 638         VariantClear( &value );
 639         return hr;
 640     }
 641     if (out)
 642     {
 643         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 644         if (hr != S_OK)
 645         {
 646             VariantClear( &name );
 647             VariantClear( &subkey );
 648             VariantClear( &value );
 649             IWbemClassObject_Release( sig );
 650             return hr;
 651         }
 652     }
 653
 654     set_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), V_BSTR(&value), context, &retval );
 655     if (out_params)
 656         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 657
 658     VariantClear( &name );
 659     VariantClear( &subkey );
 660     VariantClear( &value );
 661     IWbemClassObject_Release( sig );
 662     if (hr == S_OK && out)
 663     {
 664         *out = out_params;
 665         IWbemClassObject_AddRef( out_params );
 666     }
 667     if (out_params) IWbemClassObject_Release( out_params );
 668     return hr;
 669 }
 670
 671 static void set_dwordvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, DWORD value, IWbemContext *context,
 672                             VARIANT *retval )
 673 {
 674     HKEY hkey;
 675     LONG res;
 676
 677     TRACE( "%p, %s, %s, %#lx\n", root, debugstr_w(subkey), debugstr_w(name), value );
 678
 679     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_SET_VALUE | get_access_mask( context ), &hkey )))
 680     {
 681         set_variant( VT_UI4, res, NULL, retval );
 682         return;
 683     }
 684
 685     res = RegSetKeyValueW( hkey, NULL, name, REG_DWORD, &value, sizeof(value) );
 686     set_variant( VT_UI4, res, NULL, retval );
 687     RegCloseKey( hkey );
 688 }
 689
 690 HRESULT reg_set_dwordvalue( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 691 {
 692     VARIANT defkey, subkey, name, value, retval;
 693     IWbemClassObject *sig, *out_params = NULL;
 694     HRESULT hr;
 695
 696     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 697
 698     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 699     if (hr != S_OK) return hr;
 700     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 701     if (hr != S_OK) return hr;
 702     hr = IWbemClassObject_Get( in, L"sValueName", 0, &name, NULL, NULL );
 703     if (hr != S_OK)
 704     {
 705         VariantClear( &subkey );
 706         return hr;
 707     }
 708     hr = IWbemClassObject_Get( in, L"uValue", 0, &value, NULL, NULL );
 709     if (hr != S_OK)
 710     {
 711         VariantClear( &name );
 712         VariantClear( &subkey );
 713         return hr;
 714     }
 715
 716     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"SetDWORDValue", PARAM_OUT, &sig );
 717     if (hr != S_OK)
 718     {
 719         VariantClear( &name );
 720         VariantClear( &subkey );
 721         return hr;
 722     }
 723     if (out)
 724     {
 725         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 726         if (hr != S_OK)
 727         {
 728             VariantClear( &name );
 729             VariantClear( &subkey );
 730             IWbemClassObject_Release( sig );
 731             return hr;
 732         }
 733     }
 734     set_dwordvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), V_UI4(&value), context, &retval );
 735     if (out_params)
 736         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 737
 738     VariantClear( &name );
 739     VariantClear( &subkey );
 740     IWbemClassObject_Release( sig );
 741     if (hr == S_OK && out)
 742     {
 743         *out = out_params;
 744         IWbemClassObject_AddRef( out_params );
 745     }
 746     if (out_params) IWbemClassObject_Release( out_params );
 747     return hr;
 748 }
 749
 750 static void delete_key( HKEY root, const WCHAR *subkey, IWbemContext *context, VARIANT *retval )
 751 {
 752     LONG res;
 753
 754     TRACE("%p, %s\n", root, debugstr_w(subkey));
 755
 756     res = RegDeleteKeyExW( root, subkey, get_access_mask( context ), 0 );
 757     set_variant( VT_UI4, res, NULL, retval );
 758 }
 759
 760 HRESULT reg_delete_key( IWbemClassObject *obj, IWbemContext *context, IWbemClassObject *in, IWbemClassObject **out )
 761 {
 762     VARIANT defkey, subkey, retval;
 763     IWbemClassObject *sig, *out_params = NULL;
 764     HRESULT hr;
 765
 766     TRACE("%p, %p, %p, %p\n", obj, context, in, out);
 767
 768     hr = IWbemClassObject_Get( in, L"hDefKey", 0, &defkey, NULL, NULL );
 769     if (hr != S_OK) return hr;
 770     hr = IWbemClassObject_Get( in, L"sSubKeyName", 0, &subkey, NULL, NULL );
 771     if (hr != S_OK) return hr;
 772
 773     hr = create_signature( WBEMPROX_NAMESPACE_CIMV2, L"StdRegProv", L"DeleteKey", PARAM_OUT, &sig );
 774     if (hr != S_OK)
 775     {
 776         VariantClear( &subkey );
 777         return hr;
 778     }
 779     if (out)
 780     {
 781         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 782         if (hr != S_OK)
 783         {
 784             VariantClear( &subkey );
 785             IWbemClassObject_Release( sig );
 786             return hr;
 787         }
 788     }
 789     delete_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), context, &retval );
 790     if (out_params)
 791         hr = IWbemClassObject_Put( out_params, L"ReturnValue", 0, &retval, CIM_UINT32 );
 792
 793     VariantClear( &subkey );
 794     IWbemClassObject_Release( sig );
 795     if (hr == S_OK && out)
 796     {
 797         *out = out_params;
 798         IWbemClassObject_AddRef( out_params );
 799     }
 800     if (out_params) IWbemClassObject_Release( out_params );
 801     return hr;
 802 }