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 "config.h"
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wbemcli.h"
  29
  30 #include "wine/debug.h"
  31 #include "wbemprox_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  34
  35 static HRESULT to_bstr_array( BSTR *strings, DWORD count, VARIANT *var )
  36 {
  37     SAFEARRAY *sa;
  38     HRESULT hr;
  39     LONG i;
  40
  41     if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, count ))) return E_OUTOFMEMORY;
  42     for (i = 0; i < count; i++)
  43     {
  44         if ((hr = SafeArrayPutElement( sa, &i, strings[i] )) != S_OK)
  45         {
  46             SafeArrayDestroy( sa );
  47             return hr;
  48         }
  49     }
  50     set_variant( VT_BSTR|VT_ARRAY, 0, sa, var );
  51     return S_OK;
  52 }
  53
  54 static void free_bstr_array( BSTR *strings, DWORD count )
  55 {
  56     while (count--)
  57         SysFreeString( *(strings++) );
  58 }
  59
  60 static HRESULT to_i4_array( DWORD *values, DWORD count, VARIANT *var )
  61 {
  62     SAFEARRAY *sa;
  63     HRESULT hr;
  64     LONG i;
  65
  66     if (!(sa = SafeArrayCreateVector( VT_I4, 0, count ))) return E_OUTOFMEMORY;
  67     for (i = 0; i < count; i++)
  68     {
  69         if ((hr = SafeArrayPutElement( sa, &i, &values[i] )) != S_OK)
  70         {
  71             SafeArrayDestroy( sa );
  72             return hr;
  73         }
  74     }
  75     set_variant( VT_I4|VT_ARRAY, 0, sa, var );
  76     return S_OK;
  77 }
  78
  79 static HRESULT create_key( HKEY root, const WCHAR *subkey, VARIANT *retval )
  80 {
  81     LONG res;
  82     HKEY hkey;
  83
  84     TRACE("%p, %s\n", root, debugstr_w(subkey));
  85
  86     res = RegCreateKeyExW( root, subkey, 0, NULL, 0, 0, NULL, &hkey, NULL );
  87     set_variant( VT_UI4, res, NULL, retval );
  88     if (!res)
  89     {
  90         RegCloseKey( hkey );
  91         return S_OK;
  92     }
  93     return HRESULT_FROM_WIN32( res );
  94 }
  95
  96 HRESULT reg_create_key( IWbemClassObject *obj, IWbemClassObject *in, IWbemClassObject **out )
  97 {
  98     VARIANT defkey, subkey, retval;
  99     IWbemClassObject *sig, *out_params = NULL;
 100     HRESULT hr;
 101
 102     TRACE("%p, %p\n", in, out);
 103
 104     hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
 105     if (hr != S_OK) return hr;
 106     hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
 107     if (hr != S_OK) return hr;
 108
 109     hr = create_signature( class_stdregprovW, method_createkeyW, PARAM_OUT, &sig );
 110     if (hr != S_OK)
 111     {
 112         VariantClear( &subkey );
 113         return hr;
 114     }
 115     if (out)
 116     {
 117         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 118         if (hr != S_OK)
 119         {
 120             VariantClear( &subkey );
 121             IWbemClassObject_Release( sig );
 122             return hr;
 123         }
 124     }
 125     hr = create_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &retval );
 126     if (hr == S_OK && out_params)
 127         hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 128
 129     VariantClear( &subkey );
 130     IWbemClassObject_Release( sig );
 131     if (hr == S_OK && out)
 132     {
 133         *out = out_params;
 134         IWbemClassObject_AddRef( out_params );
 135     }
 136     if (out_params) IWbemClassObject_Release( out_params );
 137     return hr;
 138 }
 139
 140 static HRESULT enum_key( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *retval )
 141 {
 142     HKEY hkey;
 143     HRESULT hr = S_OK;
 144     WCHAR buf[256];
 145     BSTR *strings, *tmp;
 146     DWORD count = 2, len = ARRAY_SIZE( buf );
 147     LONG res, i = 0;
 148
 149     TRACE("%p, %s\n", root, debugstr_w(subkey));
 150
 151     if (!(strings = heap_alloc( count * sizeof(BSTR) ))) return E_OUTOFMEMORY;
 152     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_ENUMERATE_SUB_KEYS, &hkey )))
 153     {
 154         set_variant( VT_UI4, res, NULL, retval );
 155         heap_free( strings );
 156         return S_OK;
 157     }
 158     for (;;)
 159     {
 160         if (i >= count)
 161         {
 162             count *= 2;
 163             if (!(tmp = heap_realloc( strings, count * sizeof(BSTR) )))
 164             {
 165                 RegCloseKey( hkey );
 166                 return E_OUTOFMEMORY;
 167             }
 168             strings = tmp;
 169         }
 170         if ((res = RegEnumKeyW( hkey, i, buf, len )) == ERROR_NO_MORE_ITEMS)
 171         {
 172             if (i) res = ERROR_SUCCESS;
 173             break;
 174         }
 175         if (res) break;
 176         if (!(strings[i] = SysAllocString( buf )))
 177         {
 178             for (i--; i >= 0; i--) SysFreeString( strings[i] );
 179             hr = E_OUTOFMEMORY;
 180             break;
 181         }
 182         i++;
 183     }
 184     if (hr == S_OK && !res)
 185     {
 186         hr = to_bstr_array( strings, i, names );
 187         free_bstr_array( strings, i );
 188     }
 189     set_variant( VT_UI4, res, NULL, retval );
 190     RegCloseKey( hkey );
 191     heap_free( strings );
 192     return hr;
 193 }
 194
 195 HRESULT reg_enum_key( IWbemClassObject *obj, IWbemClassObject *in, IWbemClassObject **out )
 196 {
 197     VARIANT defkey, subkey, names, retval;
 198     IWbemClassObject *sig, *out_params = NULL;
 199     HRESULT hr;
 200
 201     TRACE("%p, %p\n", in, out);
 202
 203     hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
 204     if (hr != S_OK) return hr;
 205     hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
 206     if (hr != S_OK) return hr;
 207
 208     hr = create_signature( class_stdregprovW, method_enumkeyW, PARAM_OUT, &sig );
 209     if (hr != S_OK)
 210     {
 211         VariantClear( &subkey );
 212         return hr;
 213     }
 214     if (out)
 215     {
 216         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 217         if (hr != S_OK)
 218         {
 219             VariantClear( &subkey );
 220             IWbemClassObject_Release( sig );
 221             return hr;
 222         }
 223     }
 224     VariantInit( &names );
 225     hr = enum_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &retval );
 226     if (hr != S_OK) goto done;
 227     if (out_params)
 228     {
 229         if (!V_UI4( &retval ))
 230         {
 231             hr = IWbemClassObject_Put( out_params, param_namesW, 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 232             if (hr != S_OK) goto done;
 233         }
 234         hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 235     }
 236
 237 done:
 238     VariantClear( &names );
 239     VariantClear( &subkey );
 240     IWbemClassObject_Release( sig );
 241     if (hr == S_OK && out)
 242     {
 243         *out = out_params;
 244         IWbemClassObject_AddRef( out_params );
 245     }
 246     if (out_params) IWbemClassObject_Release( out_params );
 247     return hr;
 248 }
 249
 250 static HRESULT enum_values( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *types, VARIANT *retval )
 251 {
 252     HKEY hkey = NULL;
 253     HRESULT hr = S_OK;
 254     BSTR *value_names = NULL;
 255     DWORD count, buflen, len, *value_types = NULL;
 256     LONG res, i = 0;
 257     WCHAR *buf = NULL;
 258
 259     TRACE("%p, %s\n", root, debugstr_w(subkey));
 260
 261     if ((res = RegOpenKeyExW( root, subkey, 0, KEY_QUERY_VALUE, &hkey ))) goto done;
 262     if ((res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, NULL, &count, &buflen, NULL, NULL, NULL )))
 263         goto done;
 264
 265     hr = E_OUTOFMEMORY;
 266     if (!(buf = heap_alloc( (buflen + 1) * sizeof(WCHAR) ))) goto done;
 267     if (!(value_names = heap_alloc( count * sizeof(BSTR) ))) goto done;
 268     if (!(value_types = heap_alloc( count * sizeof(DWORD) ))) goto done;
 269
 270     hr = S_OK;
 271     for (;;)
 272     {
 273         len = buflen + 1;
 274         res = RegEnumValueW( hkey, i, buf, &len, NULL, &value_types[i], NULL, NULL );
 275         if (res == ERROR_NO_MORE_ITEMS)
 276         {
 277             if (i) res = ERROR_SUCCESS;
 278             break;
 279         }
 280         if (res) break;
 281         if (!(value_names[i] = SysAllocString( buf )))
 282         {
 283             for (i--; i >= 0; i--) SysFreeString( value_names[i] );
 284             hr = E_OUTOFMEMORY;
 285             break;
 286         }
 287         i++;
 288     }
 289     if (hr == S_OK && !res)
 290     {
 291         hr = to_bstr_array( value_names, i, names );
 292         free_bstr_array( value_names, i );
 293         if (hr == S_OK) hr = to_i4_array( value_types, i, types );
 294     }
 295
 296 done:
 297     set_variant( VT_UI4, res, NULL, retval );
 298     RegCloseKey( hkey );
 299     heap_free( value_names );
 300     heap_free( value_types );
 301     heap_free( buf );
 302     return hr;
 303 }
 304
 305 HRESULT reg_enum_values( IWbemClassObject *obj, IWbemClassObject *in, IWbemClassObject **out )
 306 {
 307     VARIANT defkey, subkey, names, types, retval;
 308     IWbemClassObject *sig, *out_params = NULL;
 309     HRESULT hr;
 310
 311     TRACE("%p, %p\n", in, out);
 312
 313     hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
 314     if (hr != S_OK) return hr;
 315     hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
 316     if (hr != S_OK) return hr;
 317
 318     hr = create_signature( class_stdregprovW, method_enumvaluesW, PARAM_OUT, &sig );
 319     if (hr != S_OK)
 320     {
 321         VariantClear( &subkey );
 322         return hr;
 323     }
 324     if (out)
 325     {
 326         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 327         if (hr != S_OK)
 328         {
 329             VariantClear( &subkey );
 330             IWbemClassObject_Release( sig );
 331             return hr;
 332         }
 333     }
 334     VariantInit( &names );
 335     VariantInit( &types );
 336     hr = enum_values( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &types, &retval );
 337     if (hr != S_OK) goto done;
 338     if (out_params)
 339     {
 340         if (!V_UI4( &retval ))
 341         {
 342             hr = IWbemClassObject_Put( out_params, param_namesW, 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
 343             if (hr != S_OK) goto done;
 344             hr = IWbemClassObject_Put( out_params, param_typesW, 0, &types, CIM_SINT32|CIM_FLAG_ARRAY );
 345             if (hr != S_OK) goto done;
 346         }
 347         hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 348     }
 349
 350 done:
 351     VariantClear( &types );
 352     VariantClear( &names );
 353     VariantClear( &subkey );
 354     IWbemClassObject_Release( sig );
 355     if (hr == S_OK && out)
 356     {
 357         *out = out_params;
 358         IWbemClassObject_AddRef( out_params );
 359     }
 360     if (out_params) IWbemClassObject_Release( out_params );
 361     return hr;
 362 }
 363
 364 static HRESULT get_stringvalue( HKEY root, const WCHAR *subkey, const WCHAR *name, VARIANT *value, VARIANT *retval )
 365 {
 366     HRESULT hr = S_OK;
 367     BSTR str = NULL;
 368     DWORD size;
 369     LONG res;
 370
 371     TRACE("%p, %s, %s\n", root, debugstr_w(subkey), debugstr_w(name));
 372
 373     if ((res = RegGetValueW( root, subkey, name, RRF_RT_REG_SZ, NULL, NULL, &size ))) goto done;
 374     if (!(str = SysAllocStringLen( NULL, size / sizeof(WCHAR) - 1 )))
 375     {
 376         hr = E_OUTOFMEMORY;
 377         goto done;
 378     }
 379     if (!(res = RegGetValueW( root, subkey, name, RRF_RT_REG_SZ, NULL, str, &size )))
 380         set_variant( VT_BSTR, 0, str, value );
 381
 382 done:
 383     set_variant( VT_UI4, res, NULL, retval );
 384     if (res) SysFreeString( str );
 385     return hr;
 386 }
 387
 388 HRESULT reg_get_stringvalue( IWbemClassObject *obj, IWbemClassObject *in, IWbemClassObject **out )
 389 {
 390     VARIANT defkey, subkey, name, value, retval;
 391     IWbemClassObject *sig, *out_params = NULL;
 392     HRESULT hr;
 393
 394     TRACE("%p, %p\n", in, out);
 395
 396     hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
 397     if (hr != S_OK) return hr;
 398     hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
 399     if (hr != S_OK) return hr;
 400     hr = IWbemClassObject_Get( in, param_valuenameW, 0, &name, NULL, NULL );
 401     if (hr != S_OK) return hr;
 402
 403     hr = create_signature( class_stdregprovW, method_getstringvalueW, PARAM_OUT, &sig );
 404     if (hr != S_OK)
 405     {
 406         VariantClear( &name );
 407         VariantClear( &subkey );
 408         return hr;
 409     }
 410     if (out)
 411     {
 412         hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 413         if (hr != S_OK)
 414         {
 415             VariantClear( &name );
 416             VariantClear( &subkey );
 417             IWbemClassObject_Release( sig );
 418             return hr;
 419         }
 420     }
 421     VariantInit( &value );
 422     hr = get_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), &value, &retval );
 423     if (hr != S_OK) goto done;
 424     if (out_params)
 425     {
 426         if (!V_UI4( &retval ))
 427         {
 428             hr = IWbemClassObject_Put( out_params, param_valueW, 0, &value, CIM_STRING );
 429             if (hr != S_OK) goto done;
 430         }
 431         hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 432     }
 433
 434 done:
 435     VariantClear( &name );
 436     VariantClear( &subkey );
 437     IWbemClassObject_Release( sig );
 438     if (hr == S_OK && out)
 439     {
 440         *out = out_params;
 441         IWbemClassObject_AddRef( out_params );
 442     }
 443     if (out_params) IWbemClassObject_Release( out_params );
 444     return hr;
 445 }